diff options
Diffstat (limited to 'src/main/java/bloodasp/galacticgreg/api/ModDimensionDef.java')
| -rw-r--r-- | src/main/java/bloodasp/galacticgreg/api/ModDimensionDef.java | 474 |
1 files changed, 474 insertions, 0 deletions
diff --git a/src/main/java/bloodasp/galacticgreg/api/ModDimensionDef.java b/src/main/java/bloodasp/galacticgreg/api/ModDimensionDef.java new file mode 100644 index 0000000000..8c2ef5c3e8 --- /dev/null +++ b/src/main/java/bloodasp/galacticgreg/api/ModDimensionDef.java @@ -0,0 +1,474 @@ +package bloodasp.galacticgreg.api; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +import net.minecraft.block.Block; +import net.minecraft.world.chunk.IChunkProvider; +import bloodasp.galacticgreg.GalacticGreg; +import bloodasp.galacticgreg.api.Enums.AirReplaceRule; +import bloodasp.galacticgreg.api.Enums.DimensionType; +import bloodasp.galacticgreg.api.Enums.ReplaceState; +import bloodasp.galacticgreg.api.Enums.SpaceObjectType; + +/** + * Class to define a Dimension. Supposed to be added to a ModContainer + */ +public class ModDimensionDef { + private static final String STR_NOTDEFINED = "iiznotdefined"; + private String _mDimensionName; + private String _mInternalDimIdentifier; + private String _mChunkProvider; + private AirReplaceRule _mDimAirSetting; + private ArrayList<ModDBMDef> _mReplaceableBlocks; + private DimensionType _mDimensionType; + + private List<ISpaceObjectGenerator> _mSpaceObjectsGenerators; + private List<ISpaceObjectGenerator> _mSpaceStructureGenerators; + + // Special Planets config settings + private int _mGroundOreMaxY = 64; + private int _mFloatingAsteroidsMinY = 128; + // ------ + + // Override for stonetype + private GTOreTypes _mStoneType; + + // Asteroid stuff + private List<AsteroidBlockComb> _mValidAsteroidMaterials; + private List<SpecialBlockComb> _mSpecialBlocksForAsteroids; + + private Random _mRandom = new Random(System.currentTimeMillis()); + + + /** Internal function + * @return A list of possible asteroid-mixes that shall be generated + */ + public List<AsteroidBlockComb> getValidAsteroidMaterials() + { + return _mValidAsteroidMaterials; + } + + // ================================================= + /** Internal function + * The only purpose of this functions is to get a default config value for this dim, that can be altered by + * the mod author which adds the dimension definition to his mod, but also provide the modpack-author/serveradmin + * to change these values aswell + */ + public int getPreConfiguratedGroundOreMaxY() + { + return _mGroundOreMaxY; + } + + /** Internal function + * The only purpose of this functions is to get a default config value for this dim, that can be altered by + * the mod author which adds the dimension definition to his mod, but also provide the modpack-author/serveradmin + * to change these values aswell + */ + public int getPreConfiguratedFloatingAsteroidMinY() + { + return _mFloatingAsteroidsMinY; + } + + /**Register new generator for objects in space. You can register as many as you want. + * If you don't register anything, no structures will generate and the default Asteroid-Generator will be used + * @param pSpaceObjectGenerator An instance of your own object generator + */ + public void registerSpaceObjectGenerator(ISpaceObjectGenerator pSpaceObjectGenerator) + { + SpaceObjectType tType = pSpaceObjectGenerator.getType(); + switch(tType) + { + case NonOreSchematic: + _mSpaceStructureGenerators.add(pSpaceObjectGenerator); + break; + case OreAsteroid: + _mSpaceObjectsGenerators.add(pSpaceObjectGenerator); + break; + default: + GalacticGreg.Logger.error("registerSpaceObjectGenerator() found unhandled generator type %s. Please report asap, the author was lazy!", tType.toString()); + break; + + } + } + + /**Internal function + * Return a random generator for space objects + */ + public ISpaceObjectGenerator getRandomSOGenerator(SpaceObjectType pTargetType) + { + ISpaceObjectGenerator tGen = null; + List<ISpaceObjectGenerator> tLst = null; + try + { + switch (pTargetType) + { + case NonOreSchematic: + tLst = _mSpaceStructureGenerators; + break; + case OreAsteroid: + tLst = _mSpaceObjectsGenerators; + break; + default: + break; + } + + if (tLst != null) + { + if (tLst.size() == 1) + tGen = tLst.get(0); + else if (tLst.size() > 1) + tGen = tLst.get(_mRandom.nextInt(tLst.size())); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + return tGen; + } + + /** + * Define the default values for the floating asteroids and the oregen here. + * As both generators run in the same dimension, and you probably don't want to + * have asteroids stuck in the ground, both generators are separated from each other. + * Basically, you can go with the default values. If you want to change them, make sure + * that pOregenMaxY is lower than pAsteroidMinY + * @param pOregenMaxY The maximum Y-height where ores will be allowed to spawn. Default: 64 + * @param pAsteroidMinY The minimum Y-height that has to be reached before asteroids will spawn. Default: 128 + * @throws IllegalArgumentException if the limits are invalid + * + */ + public void setAsteroidAndPlanetLimits(int pOregenMaxY, int pAsteroidMinY) + { + if (pOregenMaxY >= pAsteroidMinY) + throw new IllegalArgumentException("pOregenMaxY must be LOWER than pAsteroidMinY!"); + + _mFloatingAsteroidsMinY = pAsteroidMinY; + _mGroundOreMaxY = pOregenMaxY; + } + // ================================================= + + /**Internal function + * + * @return A list of all special blocks that shall be used to generate the asteroids. + */ + public List<SpecialBlockComb> getSpecialBlocksForAsteroids() + { + return _mSpecialBlocksForAsteroids; + } + + public List<ISpaceObjectGenerator> getSpaceObjectGenerators() + { + return _mSpaceObjectsGenerators; + } + + /**Internal function + * + * @return The type for this dimension + */ + public DimensionType getDimensionType() + { + return _mDimensionType; + } + + /** + * Set whether this DimensionDefinition defines an void-dimension that shall spawn asteroids instead of ores in stone + * @param pType The dimensiontype to be used + */ + public void setDimensionType(DimensionType pType) + { + _mDimensionType = pType; + } + + /**Internal function + * + * @return The configuration for AirBlocks + */ + public AirReplaceRule getAirSetting() + { + return _mDimAirSetting; + } + + /** + * Define how the oregen shall handle air-blocks. + * These settings should be pretty self-explandatory, but anyways: + * NeverReplaceAir: No matter what, if there is an Air-Block found, it will not replace it. + * AllowReplaceAir: This will generate Ores in Stones (defined by addBlockDefinition()) and air if found + * OnlyReplaceAir : This will not generate Ores in solid blocks, but only in air + * + * Note that "OnlyReplaceAir" is a special setting if you have a dimension that is not defined as "Asteroids" + * but you still need/want to generate ores in midair. + * @param pSetting + */ + public void setAirSetting(AirReplaceRule pSetting) + { + _mDimAirSetting = pSetting; + } + + /**Internal function + * + * @return The dimension identifier that is used internally to identify the dimension + */ + public String getDimIdentifier() + { + return _mInternalDimIdentifier; + } + + /** + * Set a manual override for ores that shall be generated. + * This setting is ignored if getIsAsteroidDimension() returns true + * + * For example, on GalactiCraft Mars, this value is set to GTOreTypes.RedGranite, because it matches the + * color better. If you don't set anything here, it will generate regular stone-ores. + * @param pOffset + */ + public void setStoneType(GTOreTypes pStoneType) + { + _mStoneType = pStoneType; + } + + /** Internal function + * + * @return The stone override for gregtech ores + */ + public GTOreTypes getStoneType() + { + return _mStoneType; + } + + /** Internal function + * + * @return The attached chunk-provider for this dimension + */ + public String getChunkProviderName() + { + return _mChunkProvider; + } + + /** + * Adds a new blockdefinition to this dimension. This block will then later be replaced by ores. + * You can add as many blocks as you want. Just don't add Blocks.Air, as there is another setting for allowing Air-Replacement + * @param pBlockDef + * @return + */ + public boolean addBlockDefinition(ModDBMDef pBlockDef) + { + if (_mReplaceableBlocks.contains(pBlockDef)) + { + GalacticGreg.Logger.error("Cannot add Block %s:%d, as it is already existing!", pBlockDef.getBlockName(), pBlockDef.getMeta()); + return false; + } + else + { + _mReplaceableBlocks.add(pBlockDef); + return true; + } + } + + /**Internal function + * + * @return The DimensionName in a Human-readable format + */ + public String getDimensionName() + { + return _mDimensionName; + } + + /**Internal function + * + * @return A list of all defined Blocks that can be replaced while generating ores + */ + public ArrayList<ModDBMDef> getReplaceableBlocks() + { + return _mReplaceableBlocks; + } + + /** Define a new dimension + * @param pDimensionName The human-readable. Spaces will be removed + * @param pChunkProvider The chunkprovider class that shall be observed for the oregen + */ + public ModDimensionDef(String pDimensionName, Class <? extends IChunkProvider> pChunkProvider) + { + this(pDimensionName, pChunkProvider.toString().substring(6), null); + } + + /** Define a new dimension + * @param pDimensionName The human-readable. Spaces will be removed + * @param pChunkProvider The chunkprovider class that shall be observed for the oregen + * @param pBlockDefinitions The list of predefined blocks to be replaced by ores + */ + public ModDimensionDef(String pDimensionName, Class <? extends IChunkProvider> pChunkProvider, List<ModDBMDef> pBlockDefinitions) + { + this(pDimensionName, pChunkProvider.toString().substring(6), pBlockDefinitions); + } + + /** Define a new dimension + * @param pDimensionName The human-readable DimensionName. Spaces will be removed + * @param pChunkProviderName The human-readable, full-qualified classname for the chunkprovider + */ + public ModDimensionDef(String pDimensionName, String pChunkProviderName) + { + this(pDimensionName, pChunkProviderName, null); + } + + /** Define a new dimension + * @param pDimensionName The human-readable DimensionName. Spaces will be removed + * @param pChunkProviderName The human-readable, full-qualified classname for the chunkprovider + * @param pBlockDefinitions The list of predefined blocks to be replaced by ores + */ + public ModDimensionDef(String pDimensionName, String pChunkProviderName, List<ModDBMDef> pBlockDefinitions) + { + _mInternalDimIdentifier = STR_NOTDEFINED; + _mDimensionName = pDimensionName; + _mChunkProvider = pChunkProviderName; + + _mReplaceableBlocks = new ArrayList<ModDBMDef>(); + if (pBlockDefinitions != null) + _mReplaceableBlocks.addAll(pBlockDefinitions); + + _mValidAsteroidMaterials = new ArrayList<AsteroidBlockComb>(); + _mSpecialBlocksForAsteroids = new ArrayList<SpecialBlockComb>(); + _mSpaceObjectsGenerators = new ArrayList<ISpaceObjectGenerator>(); + _mSpaceStructureGenerators = new ArrayList<ISpaceObjectGenerator>(); + } + + /**Internal function + * + * Do not call this function by yourself. Ever. It will cause explosions, water to blood, death of firstborn,... + * Seriously, don't do it. + */ + protected void setParentModName(String pModName) + { + if (!_mInternalDimIdentifier.equals(STR_NOTDEFINED)) + return; // Don't update, we're already set + else + { + _mInternalDimIdentifier = String.format("%s_%s", pModName, _mDimensionName); + GalacticGreg.Logger.debug("Set Internal Identifier for Dimension %s to %s", _mDimensionName, _mInternalDimIdentifier); + } + } + + /**Internal function + * + * Check if pBlock can be replaced by an ore + * @param pBlock + * @param pMeta + * @return + */ + public ReplaceState getReplaceStateForBlock(Block pBlock, int pMeta) + { + ReplaceState tFlag = ReplaceState.Unknown; + + for (ModDBMDef pDef : _mReplaceableBlocks) + { + ReplaceState tResult = pDef.blockEquals(pBlock, pMeta); + if (tResult == ReplaceState.Unknown) + continue; + + if (tResult == ReplaceState.CanReplace) + { + GalacticGreg.Logger.trace("Targetblock found and metadata match. Replacement allowed"); + tFlag = ReplaceState.CanReplace; + } + else if (tResult == ReplaceState.CannotReplace) + { + GalacticGreg.Logger.trace("Targetblock found but metadata mismatch. Replacement denied"); + tFlag = ReplaceState.CannotReplace; + } + break; + } + + return tFlag; + } + + /**Internal function + * + * Randomly select one material out of all defined materials + * @return + */ + public AsteroidBlockComb getRandomAsteroidMaterial() + { + if (_mValidAsteroidMaterials.size() == 0) + return null; + + if (_mValidAsteroidMaterials.size() == 1) + return _mValidAsteroidMaterials.get(0); + else + { + return _mValidAsteroidMaterials.get(_mRandom.nextInt(_mValidAsteroidMaterials.size())); + } + } + + /**Internal function + * + * Randomly select one special block to be placed in the asteroids + * @return + */ + public SpecialBlockComb getRandomSpecialAsteroidBlock() + { + if (_mSpecialBlocksForAsteroids.size() == 0) + return null; + + if (_mSpecialBlocksForAsteroids.size() == 1) + return _mSpecialBlocksForAsteroids.get(0); + else + { + return _mSpecialBlocksForAsteroids.get(_mRandom.nextInt(_mSpecialBlocksForAsteroids.size())); + } + } + + /** + * Define the material the asteroid shall be made of. Limited to GT-Based Ores and their stones + * @param pMaterial + */ + public void addAsteroidMaterial(GTOreTypes pMaterial) + { + addAsteroidMaterial(new AsteroidBlockComb(pMaterial)); + } + + /** + * Define the material the asteroid shall be made of, more advanced option to specify your own blocks + * @param pMaterial + */ + public void addAsteroidMaterial(AsteroidBlockComb pBlockComb) { + if (_mValidAsteroidMaterials.contains(pBlockComb)) + return; + else + _mValidAsteroidMaterials.add(pBlockComb); + } + + /** + * Adds a new material for asteroid generation. These will spawn randomly in asteroids if enabled. + * You can basically add every block you can imagine. + * Be warned though, if you use Liquids (Water / Lava / ..), it can affect performance if the liquid + * is flowing down to the void. So make sure you define "AsteroidCore" as position + * @param pBlock Block-Meta Combination that shall be used + */ + public void addSpecialAsteroidBlock(SpecialBlockComb pBlock) { + if (_mSpecialBlocksForAsteroids.contains(pBlock)) + return; + else + _mSpecialBlocksForAsteroids.add(pBlock); + } + + /**Internal function + * Called when GalacticGreg will finalize all its internal structures. You should never call this yourself + */ + public void finalizeReplaceableBlocks(String pParentModName) + { + for (ModDBMDef rpb : _mReplaceableBlocks) + { + try + { + rpb.updateBlockName(pParentModName); + } + catch(Exception e) + { + GalacticGreg.Logger.error("Unable to finalize replaceable block with modname for block %s. Dimension %s will probably have problems generating ores", rpb.getBlockName(), _mDimensionName); + continue; + } + } + } +} |