diff options
Diffstat (limited to 'src/Java')
17 files changed, 1769 insertions, 11 deletions
diff --git a/src/Java/gtPlusPlus/core/tileentities/general/TileEntityPlayerDoorBase.java b/src/Java/gtPlusPlus/core/tileentities/general/TileEntityPlayerDoorBase.java index 7df4bd45f3..48f05fe0fd 100644 --- a/src/Java/gtPlusPlus/core/tileentities/general/TileEntityPlayerDoorBase.java +++ b/src/Java/gtPlusPlus/core/tileentities/general/TileEntityPlayerDoorBase.java @@ -1,12 +1,19 @@ package gtPlusPlus.core.tileentities.general; +import java.util.ArrayList; +import java.util.List; + +import gtPlusPlus.api.objects.data.AutoMap; import gtPlusPlus.api.objects.minecraft.BlockPos; +import gtPlusPlus.core.util.minecraft.EntityUtils; import net.minecraft.block.Block; import net.minecraft.block.BlockDoor; +import net.minecraft.entity.Entity; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.tileentity.TileEntity; import net.minecraft.world.World; +import net.minecraft.world.chunk.Chunk; public class TileEntityPlayerDoorBase extends TileEntity { @@ -69,6 +76,8 @@ public class TileEntityPlayerDoorBase extends TileEntity { return 0; } + AutoMap<Entity> mNearbyEntityCache = new AutoMap<Entity>(); + @Override public void updateEntity() { @@ -125,43 +134,94 @@ public class TileEntityPlayerDoorBase extends TileEntity { } } - if (mTickCounter % 4 == 0) { - int aDoorState = 0; + World aWorld = this.getWorldObj(); + Block aBlock = aWorld.getBlock(xCoord, yCoord, zCoord); + BlockPos aThisPos = new BlockPos(xCoord, yCoord, zCoord, this.worldObj); + + if (mTickCounter % 20 == 0) { + int x = 0, y = 0, z = 0; + x = this.xCoord; + y = this.yCoord; + z = this.zCoord; + //List aEntityList = aWorld.loadedEntityList; + List<Entity> aEntityList = new ArrayList<Entity>(); + Chunk aThisChunk = aWorld.getChunkFromBlockCoords(x, z); + for (List l : aThisChunk.entityLists) { + aEntityList.addAll(l); + } + for (Object o : aEntityList) { + if (o != null) { + if (o instanceof Entity) { + if (o instanceof EntityPlayer) { + continue; + } + else { + Entity e = (Entity) o; + BlockPos p = EntityUtils.findBlockPosUnderEntity(e); + if (p != null) { + int newY = p.yPos+1; + if (e.getDistance(xCoord, yCoord, zCoord) <= 2){ + mNearbyEntityCache.put(e); + } + else if (aThisPos.distanceFrom(p.xPos, newY, p.zPos) <= 2) { + mNearbyEntityCache.put(e); + } + } + } + } + } + } + } + + if (mTickCounter % 4 == 0) { + for (Entity y : mNearbyEntityCache) { + if (y.getDistance(xCoord, yCoord, zCoord) > 2){ + mNearbyEntityCache.remove(y); + } + } + + boolean foundMonster = mNearbyEntityCache.size() > 0; + int aNeighbourDoorState = 0; if (mNeighbourDoor != null) { - aDoorState = getNeighbourState(); + aNeighbourDoorState = getNeighbourState(); } - World aWorld = this.getWorldObj(); - Block aBlock = aWorld.getBlock(xCoord, yCoord, zCoord); BlockDoor aDoor = (aBlock instanceof BlockDoor ? (BlockDoor) aBlock : null); boolean aPlayers = checkForPlayers(this.getWorldObj()); if (aDoor != null) { - if (aDoorState != 0 && mMeta == -1) { - if (aDoorState == 100) { - if (!mIsOpen) { + //If neighbour state != 0 and we are in slave mode + if (aNeighbourDoorState != 0 && mMeta == -1) { + if (aNeighbourDoorState == 100) { + if (!mIsOpen && !foundMonster) { //Logger.INFO("Opening Door (Slave)"); aDoor.func_150014_a(aWorld, this.xCoord, this.yCoord, this.zCoord, true); mIsOpen = true; } - } else if (aDoorState == -100) { + } else if (aNeighbourDoorState == -100 || foundMonster) { if (mIsOpen) { //Logger.INFO("Closing Door (Slave)"); aDoor.func_150014_a(aWorld, this.xCoord, this.yCoord, this.zCoord, false); mIsOpen = false; } } + //We are master, proceed } else { + //No redstone found, allow automatic handling if (aDoor != null && !hasRedstone()) { + //Found a nearby player if (aPlayers) { - if (!mIsOpen) { + //If we are closed and there are no monsters nearby, open + if (!mIsOpen && !foundMonster) { //Logger.INFO("Opening Door (Mstr)"); aDoor.func_150014_a(aWorld, this.xCoord, this.yCoord, this.zCoord, true); mIsOpen = true; } else { // Logger.INFO("Doing Nothing, Door is in correct state."); } + //Did not find nearby player } else { - if (mIsOpen) { + //If we are open or there is a monster nearby, close. + if (mIsOpen || foundMonster) { //Logger.INFO("Closing Door (Mstr)"); aDoor.func_150014_a(aWorld, this.xCoord, this.yCoord, this.zCoord, false); mIsOpen = false; diff --git a/src/Java/gtPlusPlus/xmod/galacticraft/system/BaseGalacticDimension.java b/src/Java/gtPlusPlus/xmod/galacticraft/system/BaseGalacticDimension.java new file mode 100644 index 0000000000..cb02fa0e31 --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/galacticraft/system/BaseGalacticDimension.java @@ -0,0 +1,304 @@ +package gtPlusPlus.xmod.galacticraft.system; + +import java.util.Random; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gtPlusPlus.xmod.galacticraft.system.objects.DimensionSettings; +import gtPlusPlus.xmod.galacticraft.system.objects.PlanetGenerator; +import micdoodle8.mods.galacticraft.api.galaxies.CelestialBody; +import micdoodle8.mods.galacticraft.api.prefab.world.gen.WorldChunkManagerSpace; +import micdoodle8.mods.galacticraft.api.prefab.world.gen.WorldProviderSpace; +import micdoodle8.mods.galacticraft.api.vector.Vector3; +import micdoodle8.mods.galacticraft.api.world.IExitHeight; +import micdoodle8.mods.galacticraft.api.world.ISolarLevel; +import micdoodle8.mods.galacticraft.api.world.ITeleportType; +import micdoodle8.mods.galacticraft.core.entities.player.GCPlayerStats; +import micdoodle8.mods.galacticraft.core.util.ConfigManagerCore; +import micdoodle8.mods.galacticraft.planets.mars.entities.EntityLandingBalloons; +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.util.MathHelper; +import net.minecraft.world.World; +import net.minecraft.world.WorldServer; +import net.minecraft.world.biome.BiomeGenBase; +import net.minecraft.world.chunk.IChunkProvider; + +public class BaseGalacticDimension { + + private final WorldChunkManagerGalactic mGlobalChunkManager; + private final WorldProviderGalactic mWorldProvider; + private final Class<? extends IChunkProvider> mChunkProvider; + private final PlanetGenerator mPlanet; + + public BaseGalacticDimension(PlanetGenerator aPlanet, BiomeGenBase aBiomeForDim, Class<? extends IChunkProvider> aChunkProvider, DimensionSettings aSettings) { + mPlanet = aPlanet; + mGlobalChunkManager = new WorldChunkManagerGalactic(aBiomeForDim); + mChunkProvider = aChunkProvider; + mWorldProvider = new WorldProviderGalactic(aSettings); + } + + public class WorldChunkManagerGalactic extends WorldChunkManagerSpace { + private final BiomeGenBase mBiome; + + public WorldChunkManagerGalactic(BiomeGenBase aDimBiome) { + mBiome = aDimBiome; + } + + public BiomeGenBase getBiome() { + return mBiome; + } + } + + public class WorldProviderGalactic extends WorldProviderSpace implements IExitHeight, ISolarLevel, ITeleportType { + + private final int mTierRequirement; + private final PlanetGenerator mPlanet; + private final boolean mAtmosphere; + private final int mPressure; + private final boolean mSolarRadiation; + private final float mCloudHeight; + private final float mGravity; + private final float mMeteorFreq; + private final boolean mCanRainOrSnow; + private final long mDayLength; + private final Class<? extends IChunkProvider> mChunkProvider; + + public WorldProviderGalactic(DimensionSettings aSettings) { + mPlanet = aSettings.getPlanet(); + mTierRequirement = aSettings.getTierRequirement(); + mAtmosphere = aSettings.hasAtmosphere(); + mPressure = aSettings.getPressure(); + mSolarRadiation = aSettings.hasSolarRadiation(); + mCloudHeight = aSettings.getCloudHeight(); + mGravity = aSettings.getGravity(); + mMeteorFreq = aSettings.getMeteorFreq(); + mCanRainOrSnow = aSettings.hasRainOrSnow(); + mDayLength = aSettings.getDayLength(); + mChunkProvider = aSettings.getChunkProvider(); + } + + public WorldProviderGalactic(PlanetGenerator aPlanet, Class<? extends IChunkProvider> aChunkProvider, int aTierRequirement, boolean aHasBreathableAtmo, + int aPressure, boolean aSolarRadiation, float aCloudHeight, float aGravity, float aMeteorFreq, boolean aCanRainOrSnow, long aDayLength) { + mPlanet = aPlanet; + mTierRequirement = aTierRequirement; + mAtmosphere = aHasBreathableAtmo; + mPressure = aPressure; + mSolarRadiation = aSolarRadiation; + mCloudHeight = aCloudHeight; + mGravity = aGravity; + mMeteorFreq = aMeteorFreq; + mCanRainOrSnow = aCanRainOrSnow; + mDayLength = aDayLength; + mChunkProvider = aChunkProvider; + } + + public boolean canSpaceshipTierPass(int tier) { + return tier >= mTierRequirement; + } + + @SideOnly(Side.CLIENT) + public float getCloudHeight() { + return mCloudHeight; + } + + public double getHorizon() { + return 44.0D; + } + + public float getFallDamageModifier() { + return 0.16F; + } + + public double getFuelUsageMultiplier() { + return 0.8D; + } + + public float getGravity() { + return mGravity; + } + + public double getMeteorFrequency() { + return mMeteorFreq; + } + + public float getSoundVolReductionAmount() { + return Float.MAX_VALUE; + } + + public float getThermalLevelModifier() { + return 0.0F; + } + + public float getWindLevel() { + return 0.6F; + } + + public boolean canRainOrSnow() { + return mCanRainOrSnow; + } + + public boolean canBlockFreeze(int x, int y, int z, boolean byWater) { + return false; + } + + public CelestialBody getCelestialBody() { + return mPlanet.getPlanet(); + } + + public Class<? extends IChunkProvider> getChunkProviderClass() { + return mChunkProvider; + } + + public long getDayLength() { + return mDayLength; + } + + public boolean hasBreathableAtmosphere() { + return mAtmosphere; + } + + public Vector3 getFogColor() { + float f = 1.0F - this.getStarBrightness(1.0F); + return new Vector3((double) (0.65882355F * f), (double) (0.84705883F * f), (double) (1.0F * f)); + } + + public Vector3 getSkyColor() { + float f = 1.0F - this.getStarBrightness(1.0F); + return new Vector3((double) (0.25882354F * f), (double) (0.6666667F * f), (double) (1.0F * f)); + } + + public boolean isSkyColored() { + return true; + } + + public Class<? extends WorldChunkManagerGalactic> getWorldChunkManagerClass() { + return WorldChunkManagerGalactic.class; + } + + public boolean hasSunset() { + return false; + } + + public boolean shouldForceRespawn() { + return !ConfigManagerCore.forceOverworldRespawn; + } + + public double getSolarEnergyMultiplier() { + return 0.8D; + } + + public double getYCoordinateToTeleport() { + return 800.0D; + } + + public Vector3 getEntitySpawnLocation(WorldServer arg0, Entity arg1) { + return new Vector3(arg1.posX, ConfigManagerCore.disableLander ? 250.0D : 900.0D, arg1.posZ); + } + + public Vector3 getParaChestSpawnLocation(WorldServer arg0, EntityPlayerMP arg1, Random arg2) { + if (ConfigManagerCore.disableLander) { + double x = (arg2.nextDouble() * 2.0D - 1.0D) * 5.0D; + double z = (arg2.nextDouble() * 2.0D - 1.0D) * 5.0D; + return new Vector3(x, 220.0D, z); + } else { + return null; + } + } + + public Vector3 getPlayerSpawnLocation(WorldServer arg0, EntityPlayerMP arg1) { + if (arg1 != null) { + GCPlayerStats stats = GCPlayerStats.get(arg1); + return new Vector3(stats.coordsTeleportedFromX, ConfigManagerCore.disableLander ? 250.0D : 900.0D, + stats.coordsTeleportedFromZ); + } else { + return null; + } + } + + public void onSpaceDimensionChanged(World arg0, EntityPlayerMP player, boolean arg2) { + if (player != null && GCPlayerStats.get(player).teleportCooldown <= 0) { + if (player.capabilities.isFlying) { + player.capabilities.isFlying = false; + } + + EntityLandingBalloons lander = new EntityLandingBalloons(player); + if (!arg0.isRemote) { + arg0.spawnEntityInWorld(lander); + } + + GCPlayerStats.get(player).teleportCooldown = 10; + } + + } + + public boolean useParachute() { + return ConfigManagerCore.disableLander; + } + + @SideOnly(Side.CLIENT) + public float getStarBrightness(float par1) { + float var2 = this.worldObj.getCelestialAngle(par1); + float var3 = 1.0F - (MathHelper.cos(var2 * 3.1415927F * 2.0F) * 2.0F + 0.25F); + if (var3 < 0.0F) { + var3 = 0.0F; + } + + if (var3 > 1.0F) { + var3 = 1.0F; + } + + return var3 * var3 * 0.5F + 0.3F; + } + + @SideOnly(Side.CLIENT) + public float getSunBrightness(float par1) { + float f1 = this.worldObj.getCelestialAngle(1.0F); + float f2 = 1.25F - (MathHelper.cos(f1 * 3.1415927F * 2.0F) * 2.0F + 0.2F); + if (f2 < 0.0F) { + f2 = 0.0F; + } + + if (f2 > 1.0F) { + f2 = 1.0F; + } + + f2 = 1.2F - f2; + return f2 * 0.2F; + } + + public void setupAdventureSpawn(EntityPlayerMP player) { + } + + public int AtmosphericPressure() { + return mPressure; + } + + public boolean SolarRadiation() { + return mSolarRadiation; + } + } + + public synchronized final WorldChunkManagerGalactic getGlobalChunkManager() { + return mGlobalChunkManager; + } + + public synchronized final WorldProviderGalactic getWorldProvider() { + return mWorldProvider; + } + + public synchronized final Class<? extends WorldProviderSpace> getWorldProviderClass() { + return mWorldProvider.getClass(); + } + + public synchronized final Class<? extends IChunkProvider> getChunkProvider() { + return mChunkProvider; + } + + public synchronized final PlanetGenerator getPlanet() { + return mPlanet; + } + + + +} diff --git a/src/Java/gtPlusPlus/xmod/galacticraft/system/BaseSolarSystem.java b/src/Java/gtPlusPlus/xmod/galacticraft/system/BaseSolarSystem.java new file mode 100644 index 0000000000..96148c0cdb --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/galacticraft/system/BaseSolarSystem.java @@ -0,0 +1,95 @@ +package gtPlusPlus.xmod.galacticraft.system; + +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.xmod.galacticraft.system.objects.IPlanetBlockRegister; +import gtPlusPlus.xmod.galacticraft.system.objects.PlanetGenerator; +import micdoodle8.mods.galacticraft.api.GalacticraftRegistry; +import micdoodle8.mods.galacticraft.api.galaxies.GalaxyRegistry; +import micdoodle8.mods.galacticraft.api.galaxies.Planet; +import micdoodle8.mods.galacticraft.api.galaxies.SolarSystem; +import micdoodle8.mods.galacticraft.api.galaxies.Star; +import micdoodle8.mods.galacticraft.api.prefab.world.gen.WorldProviderSpace; +import micdoodle8.mods.galacticraft.api.galaxies.CelestialBody.ScalableDistance; +import micdoodle8.mods.galacticraft.api.vector.Vector3; +import micdoodle8.mods.galacticraft.api.world.ITeleportType; +import net.minecraft.util.ResourceLocation; + +public abstract class BaseSolarSystem { + private SolarSystem mSolarSystem; + private Star mStar; + private AutoMap<Planet> mPlanetMap = new AutoMap<Planet>(); + + public SolarSystem getSystem() { + return mSolarSystem; + } + + public Star getStar() { + return mStar; + } + + public AutoMap<Planet> getPlanets(){ + return mPlanetMap; + } + + public abstract void preInit(); + + public final void init() { + initSolarSystem(); + } + + public abstract void initSolarSystem(); + + public static void registryteleport(Class<? extends WorldProviderSpace> aWorldProvider, ITeleportType aWorldProviderInstance) { + GalacticraftRegistry.registerTeleportType(aWorldProvider, aWorldProviderInstance); + } + + public boolean registerSolarSystem(SolarSystem aSystem) { + this.mSolarSystem = aSystem; + return GalaxyRegistry.registerSolarSystem(aSystem); + } + + public boolean registerPlanet(BaseGalacticDimension aDimension) { + return registerPlanet(aDimension.getPlanet().getPlanet(), aDimension.getWorldProviderClass(), aDimension.getWorldProvider()); + } + public boolean registerPlanet(Planet aPlanet, Class<? extends WorldProviderSpace> aWorldProvider, ITeleportType aWorldProviderInstance) { + try { + mPlanetMap.put(aPlanet); + GalaxyRegistry.registerPlanet(aPlanet); + registryteleport(aWorldProvider, aWorldProviderInstance); + return true; + } + catch(Throwable t) { + return false; + } + } + + public SolarSystem createSolarSystem(String aSystemName, String aParentGalaxyName, Vector3 aMapPosition) { + SolarSystem aSolarSystem = (new SolarSystem(aSystemName, aParentGalaxyName)).setMapPosition(aMapPosition); + return aSolarSystem; + } + + public Star createStar(String aStarName, int aTierRequired) { + Star aStar = (Star) (new Star(aStarName)).setParentSolarSystem(getSystem()).setTierRequired(aTierRequired); + aStar.setBodyIcon(new ResourceLocation(CORE.MODID, "textures/space/planets/"+aStarName.toLowerCase()+"/"+aStarName+".png")); + return aStar; + } + + public PlanetGenerator createPlanet(String aPlanetName, float[] aRingRGB, float aPhaseShift, float aRelativeDistanceFromCentMin, float aRelativeDistanceFromCentMax, float aRelativeOrbitTime, IPlanetBlockRegister aPlanetBlocks) { + Planet aNewPlanet = (new Planet(aPlanetName)).setParentSolarSystem(getSystem()); + aNewPlanet.setRingColorRGB(aRingRGB[0], aRingRGB[1], aRingRGB[2]); + aNewPlanet.setPhaseShift(aPhaseShift); + aNewPlanet.setBodyIcon(new ResourceLocation(CORE.MODID, "textures/space/planets/"+aPlanetName.toLowerCase()+"/"+aPlanetName+".png")); + aNewPlanet.setRelativeDistanceFromCenter(new ScalableDistance(aRelativeDistanceFromCentMin, aRelativeDistanceFromCentMax)); + aNewPlanet.setRelativeOrbitTime(aRelativeOrbitTime); + PlanetGenerator aPlanet = new PlanetGenerator(aNewPlanet, aPlanetBlocks); + return aPlanet; + } + + public void setMainStarForSolarSystem(Star aStar) { + this.mStar = aStar; + getSystem().setMainStar(aStar); + } + + +}
\ No newline at end of file diff --git a/src/Java/gtPlusPlus/xmod/galacticraft/system/core/dim/BaseWorldProviderGalactic.java b/src/Java/gtPlusPlus/xmod/galacticraft/system/core/dim/BaseWorldProviderGalactic.java new file mode 100644 index 0000000000..01180f913c --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/galacticraft/system/core/dim/BaseWorldProviderGalactic.java @@ -0,0 +1,123 @@ +package gtPlusPlus.xmod.galacticraft.system.core.dim; + +import java.util.Random; + +import gtPlusPlus.api.objects.random.XSTR; +import gtPlusPlus.xmod.galacticraft.system.BaseGalacticDimension; +import gtPlusPlus.xmod.galacticraft.system.core.world.gen.GalacticBiomeGenBase; +import gtPlusPlus.xmod.galacticraft.system.objects.BiomeSettings; +import gtPlusPlus.xmod.galacticraft.system.objects.DimensionSettings; +import gtPlusPlus.xmod.galacticraft.system.objects.PlanetGenerator; +import gtPlusPlus.xmod.galacticraft.system.objects.WorldProviderSettings; +import micdoodle8.mods.galacticraft.core.util.ConfigManagerCore; +import net.minecraft.init.Blocks; +import net.minecraft.world.World; +import net.minecraft.world.biome.BiomeDecorator; +import net.minecraft.world.biome.BiomeGenBase; +import net.minecraft.world.chunk.IChunkProvider; +import net.minecraftforge.common.BiomeDictionary; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.common.BiomeDictionary.Type; +import net.minecraftforge.event.terraingen.TerrainGen; +import net.minecraftforge.event.terraingen.DecorateBiomeEvent.Post; +import net.minecraftforge.event.terraingen.DecorateBiomeEvent.Pre; +import net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType; + +public class BaseWorldProviderGalactic { + + private final PlanetGenerator mThisPlanet; + private final BaseGalacticDimension mDim; + public final BiomeGenBase mBiome; + + //new DimensionSettings(b, aCP, 5, true, 1, false, 240f, 0.1f, 0.2f, false, 48000L) + + public BaseWorldProviderGalactic(WorldProviderSettings b) { + this(b.getPlanet(), b.getDimSettings(), b.getBiomeSettings()); + } + + private BaseWorldProviderGalactic(PlanetGenerator b, DimensionSettings aDimSettings, BiomeSettings aBiomeSettings) { + mThisPlanet = b; + Class<? extends IChunkProvider> aCP = aDimSettings.getChunkProvider(); + mBiome = tryCreateBiome(aBiomeSettings); + mDim = new BaseGalacticDimension(b, mBiome, aCP, aDimSettings); + } + + public synchronized final BaseGalacticDimension getDim() { + return mDim; + } + + public BiomeGenBase tryCreateBiome(BiomeSettings aSettings) { + BiomeGenBase x = (new BiomeGenMain(aSettings.getID())).setBiomeName(aSettings.getName()).setHeight(aSettings.getHeight()); + return x; + } + + public class BiomeGenBasePlanetSurface extends GalacticBiomeGenBase { + public BiomeGenBase aBiome; + + public BiomeGenBasePlanetSurface(int id) { + super(id); + this.enableRain = true; + this.enableSnow = true; + this.topBlock = Blocks.stone; + this.fillerBlock = Blocks.stone; + } + + public BiomeDecorator createBiomeDecorator() { + return new BiomeDecoratorGalactic(); + } + + protected BiomeDecoratorGalactic getBiomeDecorator() { + return (BiomeDecoratorGalactic) this.theBiomeDecorator; + } + + } + + public class BiomeGenMain extends BiomeGenBasePlanetSurface { + public BiomeGenMain(int aID) { + super(aID); + this.enableRain = false; + this.enableSnow = false; + this.topBlock = mThisPlanet.getTask().getTopLayer(); + this.topMeta = 0; + this.fillerBlock = mThisPlanet.getTask().getSoil(); + this.fillerMeta = 0; + this.stoneBlock = mThisPlanet.getTask().getStone(); + this.stoneMeta = 0; + this.spawnableCaveCreatureList.clear(); + this.spawnableCreatureList.clear(); + this.spawnableMonsterList.clear(); + this.spawnableWaterCreatureList.clear(); + if (!ConfigManagerCore.disableBiomeTypeRegistrations) { + BiomeDictionary.registerBiomeType(this, new Type[]{Type.COLD, Type.DRY, Type.DEAD, Type.SPOOKY}); + } + + } + } + + public class BiomeDecoratorGalactic extends BiomeDecorator { + + public void decorateChunk(World world, Random rand, BiomeGenBase biome, int x, int z) { + if (this.currentWorld != null) { + throw new RuntimeException("Already decorating!!"); + } else { + this.currentWorld = world; + this.randomGenerator = new XSTR(rand.nextLong()); + this.chunk_X = x; + this.chunk_Z = z; + this.genDecorations(biome); + this.currentWorld = null; + this.randomGenerator = null; + } + } + + protected void genDecorations(BiomeGenBase biome) { + MinecraftForge.EVENT_BUS.post(new Pre(this.currentWorld, this.randomGenerator, this.chunk_X, this.chunk_Z)); + MinecraftForge.EVENT_BUS.post(new Post(this.currentWorld, this.randomGenerator, this.chunk_X, this.chunk_Z)); + } + + protected boolean getGen(EventType event) { + return TerrainGen.decorate(this.currentWorld, this.randomGenerator, this.chunk_X, this.chunk_Z, event); + } + } + +}
\ No newline at end of file diff --git a/src/Java/gtPlusPlus/xmod/galacticraft/system/core/dim/BasicChunkProviderGalactic.java b/src/Java/gtPlusPlus/xmod/galacticraft/system/core/dim/BasicChunkProviderGalactic.java new file mode 100644 index 0000000000..9a912fdfc0 --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/galacticraft/system/core/dim/BasicChunkProviderGalactic.java @@ -0,0 +1,18 @@ +package gtPlusPlus.xmod.galacticraft.system.core.dim; + +import gtPlusPlus.xmod.galacticraft.system.core.world.gen.ChunkProviderGalactic; +import micdoodle8.mods.galacticraft.api.prefab.world.gen.BiomeDecoratorSpace; +import net.minecraft.world.World; + +public class BasicChunkProviderGalactic extends ChunkProviderGalactic { + + public BasicChunkProviderGalactic(World par1World, long seed, boolean mapFeaturesEnabled) { + super(par1World, seed, mapFeaturesEnabled); + } + + @Override + public BiomeDecoratorSpace getBiomeGenerator() { + return null; + } + +} diff --git a/src/Java/gtPlusPlus/xmod/galacticraft/system/core/world/gen/ChunkProviderGalactic.java b/src/Java/gtPlusPlus/xmod/galacticraft/system/core/world/gen/ChunkProviderGalactic.java new file mode 100644 index 0000000000..3b9633b21d --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/galacticraft/system/core/world/gen/ChunkProviderGalactic.java @@ -0,0 +1,111 @@ +package gtPlusPlus.xmod.galacticraft.system.core.world.gen; + +import java.util.List; + +import com.google.common.collect.Lists; + +import micdoodle8.mods.galacticraft.api.prefab.core.BlockMetaPair; +import micdoodle8.mods.galacticraft.api.prefab.world.gen.BiomeDecoratorSpace; +import micdoodle8.mods.galacticraft.api.prefab.world.gen.MapGenBaseMeta; +import micdoodle8.mods.galacticraft.core.entities.EntityEvolvedCreeper; +import micdoodle8.mods.galacticraft.core.entities.EntityEvolvedSkeleton; +import micdoodle8.mods.galacticraft.core.entities.EntityEvolvedSpider; +import net.minecraft.block.Block; +import net.minecraft.world.World; +import net.minecraft.world.biome.BiomeGenBase; +import net.minecraft.world.biome.BiomeGenBase.SpawnListEntry; +import net.minecraft.world.chunk.IChunkProvider; + +public abstract class ChunkProviderGalactic extends ChunkProviderGalaxyLakes { + + private List<MapGenBaseMeta> worldGenerators; + private BiomeGenBase[] biomesForGeneration = this.getBiomesForGeneration(); + private final GalacticMapGenCavesBase caveGenerator = new GalacticMapGenCavesBase(); + + protected List<MapGenBaseMeta> getWorldGenerators() { + List<MapGenBaseMeta> generators = Lists.newArrayList(); + return generators; + } + + public ChunkProviderGalactic(World par1World, long seed, boolean mapFeaturesEnabled) { + super(par1World, seed, mapFeaturesEnabled); + } + + public abstract BiomeDecoratorSpace getBiomeGenerator(); + + protected BiomeGenBase[] getBiomesForGeneration() { + return new BiomeGenBase[] { GalacticBiomeGenBase.mGalaxy }; + } + + protected SpawnListEntry[] getCreatures() { + return new SpawnListEntry[0]; + } + + public double getHeightModifier() { + return 24.0D; + } + + protected SpawnListEntry[] getMonsters() { + SpawnListEntry skele = new SpawnListEntry(EntityEvolvedSkeleton.class, 100, 4, 4); + SpawnListEntry creeper = new SpawnListEntry(EntityEvolvedCreeper.class, 100, 4, 4); + SpawnListEntry spider = new SpawnListEntry(EntityEvolvedSpider.class, 100, 4, 4); + + Class<?> aEnderman; + try { + aEnderman = Class.forName("galaxyspace.SolarSystem.planets.pluto.entities.EntityEvolvedEnderman"); + if (aEnderman != null) { + SpawnListEntry enderman = new SpawnListEntry(aEnderman, 100, 4, 4); + return new SpawnListEntry[] { skele, creeper, spider, enderman }; + } + } catch (ClassNotFoundException e) {} + + return new SpawnListEntry[] { skele, creeper, spider }; + } + + public void onPopulate(IChunkProvider arg0, int arg1, int arg2) { + } + + public boolean chunkExists(int x, int y) { + return false; + } + + protected SpawnListEntry[] getWaterCreatures() { + return new SpawnListEntry[0]; + } + + public BlockMetaPair getGrassBlock() { + return new BlockMetaPair(null, (byte) 0); + } + + public BlockMetaPair getDirtBlock() { + return new BlockMetaPair(null, (byte) 0); + } + + public BlockMetaPair getStoneBlock() { + return new BlockMetaPair(null, (byte) 0); + } + + protected boolean enableBiomeGenBaseBlock() { + return false; + } + + public void onChunkProvider(int cX, int cZ, Block[] blocks, byte[] metadata) { + } + + public int getWaterLevel() { + return 110; + } + + public boolean canGenerateWaterBlock() { + return true; + } + + protected BlockMetaPair getWaterBlock() { + return new BlockMetaPair(null, (byte) 0); + } + + public boolean canGenerateIceBlock() { + return false; + } + +} diff --git a/src/Java/gtPlusPlus/xmod/galacticraft/system/core/world/gen/ChunkProviderGalaxyLakes.java b/src/Java/gtPlusPlus/xmod/galacticraft/system/core/world/gen/ChunkProviderGalaxyLakes.java new file mode 100644 index 0000000000..a3d696d7c5 --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/galacticraft/system/core/world/gen/ChunkProviderGalaxyLakes.java @@ -0,0 +1,529 @@ +package gtPlusPlus.xmod.galacticraft.system.core.world.gen; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.Random; + +import gtPlusPlus.api.objects.random.XSTR; +import micdoodle8.mods.galacticraft.api.prefab.core.BlockMetaPair; +import micdoodle8.mods.galacticraft.api.prefab.world.gen.BiomeDecoratorSpace; +import micdoodle8.mods.galacticraft.api.prefab.world.gen.MapGenBaseMeta; +import micdoodle8.mods.galacticraft.core.perlin.generator.Gradient; +import net.minecraft.block.Block; +import net.minecraft.block.BlockFalling; +import net.minecraft.entity.EnumCreatureType; +import net.minecraft.init.Blocks; +import net.minecraft.util.IProgressUpdate; +import net.minecraft.util.MathHelper; +import net.minecraft.world.ChunkPosition; +import net.minecraft.world.SpawnerAnimals; +import net.minecraft.world.World; +import net.minecraft.world.biome.BiomeGenBase; +import net.minecraft.world.biome.BiomeGenBase.SpawnListEntry; +import net.minecraft.world.chunk.Chunk; +import net.minecraft.world.chunk.IChunkProvider; +import net.minecraft.world.gen.ChunkProviderGenerate; +import net.minecraft.world.gen.NoiseGeneratorOctaves; +import net.minecraft.world.gen.NoiseGeneratorPerlin; + +public abstract class ChunkProviderGalaxyLakes extends ChunkProviderGenerate { + protected Random rand; + private NoiseGeneratorOctaves noiseGen4; + public NoiseGeneratorOctaves noiseGen5; + public NoiseGeneratorOctaves noiseGen6; + public NoiseGeneratorOctaves mobSpawnerNoise; + protected World worldObj; + private BiomeGenBase[] biomesForGeneration = this.getBiomesForGeneration(); + double[] noise3; + double[] noise1; + double[] noise2; + double[] noise5; + double[] noise6; + float[] squareTable; + private NoiseGeneratorOctaves field_147431_j; + private NoiseGeneratorOctaves field_147432_k; + private NoiseGeneratorOctaves field_147429_l; + private NoiseGeneratorPerlin field_147430_m; + private double[] terrainCalcs; + private float[] parabolicField; + double[] field_147427_d; + double[] field_147428_e; + double[] field_147425_f; + double[] field_147426_g; + int[][] field_73219_j = new int[32][32]; + private final Gradient noiseGen8; + private List<MapGenBaseMeta> worldGenerators; + + public ChunkProviderGalaxyLakes(World world, long seed, boolean flag) { + super(world, seed, flag); + this.worldObj = world; + this.rand = new XSTR(seed); + this.noiseGen4 = new NoiseGeneratorOctaves(this.rand, 4); + this.noiseGen5 = new NoiseGeneratorOctaves(this.rand, 10); + this.noiseGen6 = new NoiseGeneratorOctaves(this.rand, 16); + this.noiseGen8 = new Gradient(this.rand.nextLong(), 2, 0.25F); + this.mobSpawnerNoise = new NoiseGeneratorOctaves(this.rand, 8); + this.field_147431_j = new NoiseGeneratorOctaves(this.rand, 16); + this.field_147432_k = new NoiseGeneratorOctaves(this.rand, 16); + this.field_147429_l = new NoiseGeneratorOctaves(this.rand, 8); + this.field_147430_m = new NoiseGeneratorPerlin(this.rand, 4); + this.terrainCalcs = new double[825]; + this.parabolicField = new float[25]; + + for (int j = -2; j <= 2; ++j) { + for (int k = -2; k <= 2; ++k) { + float f = 10.0F / MathHelper.sqrt_float((float) (j * j + k * k) + 0.2F); + this.parabolicField[j + 2 + (k + 2) * 5] = f; + } + } + + } + + public Chunk provideChunk(int x, int z) { + this.rand.setSeed((long) x * 341873128712L + (long) z * 132897987541L); + Block[] blockStorage = new Block[65536]; + byte[] metaStorage = new byte[65536]; + this.generateTerrain(x, z, blockStorage, metaStorage); + this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, + x * 16, z * 16, 16, 16); + this.replaceBlocksForBiome(x, z, blockStorage, metaStorage, this.biomesForGeneration); + this.onChunkProvider(x, z, blockStorage, metaStorage); + Chunk chunk = new Chunk(this.worldObj, blockStorage, metaStorage, x, z); + byte[] chunkBiomes = chunk.getBiomeArray(); + if (this.worldGenerators == null) { + this.worldGenerators = this.getWorldGenerators(); + } + + Iterator<MapGenBaseMeta> i$ = this.worldGenerators.iterator(); + + while (i$.hasNext()) { + MapGenBaseMeta generator = (MapGenBaseMeta) i$.next(); + generator.generate(this, this.worldObj, x, z, blockStorage, metaStorage); + } + + for (int i = 0; i < chunkBiomes.length; ++i) { + chunkBiomes[i] = (byte) this.biomesForGeneration[i].biomeID; + } + + chunk.generateSkylightMap(); + return chunk; + } + + public void generateTerrain(int chunkX, int chunkZ, Block[] blockStorage, byte[] metaStorage) { + int seaLevel = this.getWaterLevel(); + metaStorage = new byte[65536]; + this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, + chunkX * 4 - 2, chunkZ * 4 - 2, 10, 10); + this.makeLandPerBiome2(chunkX * 4, 0, chunkZ * 4); + + for (int k = 0; k < 4; ++k) { + int l = k * 5; + int i1 = (k + 1) * 5; + + for (int j1 = 0; j1 < 4; ++j1) { + int k1 = (l + j1) * 33; + int l1 = (l + j1 + 1) * 33; + int i2 = (i1 + j1) * 33; + int j2 = (i1 + j1 + 1) * 33; + + for (int k2 = 0; k2 < 32; ++k2) { + double d0 = 0.125D; + double d1 = this.terrainCalcs[k1 + k2]; + double d2 = this.terrainCalcs[l1 + k2]; + double d3 = this.terrainCalcs[i2 + k2]; + double d4 = this.terrainCalcs[j2 + k2]; + double d5 = (this.terrainCalcs[k1 + k2 + 1] - d1) * d0; + double d6 = (this.terrainCalcs[l1 + k2 + 1] - d2) * d0; + double d7 = (this.terrainCalcs[i2 + k2 + 1] - d3) * d0; + double d8 = (this.terrainCalcs[j2 + k2 + 1] - d4) * d0; + + for (int l2 = 0; l2 < 8; ++l2) { + double d9 = 0.25D; + double d10 = d1; + double d11 = d2; + double d12 = (d3 - d1) * d9; + double d13 = (d4 - d2) * d9; + + for (int i3 = 0; i3 < 4; ++i3) { + int j3 = i3 + k * 4 << 12 | 0 + j1 * 4 << 8 | k2 * 8 + l2; + short short1 = 256; + j3 -= short1; + double d14 = 0.25D; + double d16 = (d11 - d10) * d14; + double d15 = d10 - d16; + + for (int k3 = 0; k3 < 4; ++k3) { + if ((d15 += d16) > 0.0D) { + blockStorage[j3 += short1] = this.getStoneBlock().getBlock(); + } else if (k2 * 8 + l2 < seaLevel && this.canGenerateWaterBlock()) { + blockStorage[j3 += short1] = this.getWaterBlock().getBlock(); + } else { + blockStorage[j3 += short1] = null; + } + } + + d10 += d12; + d11 += d13; + } + + d1 += d5; + d2 += d6; + d3 += d7; + d4 += d8; + } + } + } + } + + } + + private void makeLandPerBiome2(int x, int zero, int z) { + this.field_147426_g = this.noiseGen6.generateNoiseOctaves(this.field_147426_g, x, z, 5, 5, 200.0D, 200.0D, + 0.5D); + this.field_147427_d = this.field_147429_l.generateNoiseOctaves(this.field_147427_d, x, zero, z, 5, 33, 5, + 8.555150000000001D, 4.277575000000001D, 8.555150000000001D); + this.field_147428_e = this.field_147431_j.generateNoiseOctaves(this.field_147428_e, x, zero, z, 5, 33, 5, + 684.412D, 684.412D, 684.412D); + this.field_147425_f = this.field_147432_k.generateNoiseOctaves(this.field_147425_f, x, zero, z, 5, 33, 5, + 684.412D, 684.412D, 684.412D); + int terrainIndex = 0; + int noiseIndex = 0; + + for (int ax = 0; ax < 5; ++ax) { + for (int az = 0; az < 5; ++az) { + float totalVariation = 0.0F; + float totalHeight = 0.0F; + float totalFactor = 0.0F; + byte two = 2; + BiomeGenBase biomegenbase = this.biomesForGeneration[ax + 2 + (az + 2) * 10]; + + for (int ox = -two; ox <= two; ++ox) { + for (int oz = -two; oz <= two; ++oz) { + BiomeGenBase biomegenbase1 = this.biomesForGeneration[ax + ox + 2 + (az + oz + 2) * 10]; + float rootHeight = biomegenbase1.rootHeight; + float heightVariation = biomegenbase1.heightVariation; + float heightFactor = this.parabolicField[ox + 2 + (oz + 2) * 5] / (rootHeight + 2.0F); + if (biomegenbase1.rootHeight > biomegenbase.rootHeight) { + heightFactor /= 2.0F; + } + + totalVariation += heightVariation * heightFactor; + totalHeight += rootHeight * heightFactor; + totalFactor += heightFactor; + } + } + + totalVariation /= totalFactor; + totalHeight /= totalFactor; + totalVariation = totalVariation * 0.9F + 0.1F; + totalHeight = (totalHeight * 4.0F - 1.0F) / 8.0F; + double terrainNoise = this.field_147426_g[noiseIndex] / 8000.0D; + if (terrainNoise < 0.0D) { + terrainNoise = -terrainNoise * 0.3D; + } + + terrainNoise = terrainNoise * 3.0D - 2.0D; + if (terrainNoise < 0.0D) { + terrainNoise /= 2.0D; + if (terrainNoise < -1.0D) { + terrainNoise = -1.0D; + } + + terrainNoise /= 1.4D; + terrainNoise /= 2.0D; + } else { + if (terrainNoise > 1.0D) { + terrainNoise = 1.0D; + } + + terrainNoise /= 8.0D; + } + + ++noiseIndex; + double heightCalc = (double) totalHeight; + double variationCalc = (double) totalVariation * this.getHeightModifier() / 10.0D; + heightCalc += terrainNoise * 0.2D; + heightCalc = heightCalc * 8.5D / 8.0D; + double d5 = 8.5D + heightCalc * 4.0D; + + for (int ay = 0; ay < 33; ++ay) { + double d6 = ((double) ay - d5) * 12.0D * 128.0D / 256.0D / variationCalc; + if (d6 < 0.0D) { + d6 *= 4.0D; + } + + double d7 = this.field_147428_e[terrainIndex] / 512.0D; + double d8 = this.field_147425_f[terrainIndex] / 512.0D; + double d9 = (this.field_147427_d[terrainIndex] / 10.0D + 1.0D) / 2.0D; + double terrainCalc = MathHelper.denormalizeClamp(d7, d8, d9) - d6; + if (ay > 29) { + double d11 = (double) ((float) (ay - 29) / 3.0F); + terrainCalc = terrainCalc * (1.0D - d11) + -10.0D * d11; + } + + this.terrainCalcs[terrainIndex] = terrainCalc; + ++terrainIndex; + } + } + } + + } + + public void replaceBlocksForBiome(int par1, int par2, Block[] arrayOfIDs, byte[] arrayOfMeta, + BiomeGenBase[] par4ArrayOfBiomeGenBase) { + this.noiseGen8.setFrequency(0.0625F); + + for (int var8 = 0; var8 < 16; ++var8) { + for (int var9 = 0; var9 < 16; ++var9) { + GalacticBiomeGenBase biomegenbase = (GalacticBiomeGenBase) par4ArrayOfBiomeGenBase[var8 + var9 * 16]; + int var12 = (int) ((double) this.noiseGen8.getNoise((float) (par1 * 16 + var8), + (float) (par2 * 16 + var9)) / 3.0D + 3.0D + this.rand.nextDouble() * 0.25D); + int var13 = -1; + Block var14 = this.enableBiomeGenBaseBlock() ? biomegenbase.topBlock : this.getGrassBlock().getBlock(); + byte var14m = this.enableBiomeGenBaseBlock() + ? biomegenbase.topMeta + : this.getGrassBlock().getMetadata(); + Block var15 = this.enableBiomeGenBaseBlock() + ? biomegenbase.fillerBlock + : this.getDirtBlock().getBlock(); + byte var15m = this.enableBiomeGenBaseBlock() + ? biomegenbase.fillerMeta + : this.getDirtBlock().getMetadata(); + + for (int var16 = 255; var16 >= 0; --var16) { + int index = this.getIndex(var8, var16, var9); + if (var16 <= 0 + this.rand.nextInt(5)) { + arrayOfIDs[index] = Blocks.bedrock; + } + + if (var16 != 5 && var16 != 6 + this.rand.nextInt(3)) { + Block var18 = arrayOfIDs[index]; + if (Blocks.air == var18) { + var13 = -1; + } else if (var18 == this.getStoneBlock().getBlock() && !this.enableBiomeGenBaseBlock()) { + arrayOfMeta[index] = this.getStoneBlock().getMetadata(); + if (var13 == -1) { + if (var12 <= 0) { + var14 = Blocks.air; + var14m = 0; + var15 = this.getStoneBlock().getBlock(); + var15m = this.getStoneBlock().getMetadata(); + } else if (var16 >= 36 && var16 <= 21) { + if (this.enableBiomeGenBaseBlock()) { + var14 = biomegenbase.topBlock; + var14m = biomegenbase.topMeta; + var14 = biomegenbase.fillerBlock; + var14m = biomegenbase.fillerMeta; + } else { + var14 = this.getGrassBlock().getBlock(); + var14m = this.getGrassBlock().getMetadata(); + var14 = this.getDirtBlock().getBlock(); + var14m = this.getDirtBlock().getMetadata(); + } + } + + var13 = var12; + if (var16 >= 19) { + arrayOfIDs[index] = var14; + arrayOfMeta[index] = var14m; + } else { + arrayOfIDs[index] = var15; + arrayOfMeta[index] = var15m; + } + } else if (var13 > 0) { + --var13; + arrayOfIDs[index] = var15; + arrayOfMeta[index] = var15m; + } + } else if (var18 == biomegenbase.stoneBlock) { + arrayOfMeta[index] = biomegenbase.stoneMeta; + if (var13 == -1) { + if (var12 <= 0) { + var14 = Blocks.air; + var14m = 0; + if (this.enableBiomeGenBaseBlock()) { + var15 = biomegenbase.stoneBlock; + var15m = biomegenbase.stoneMeta; + } else { + var15 = this.getStoneBlock().getBlock(); + var15m = this.getStoneBlock().getMetadata(); + } + } else if (var16 >= 36 && var16 <= 21) { + if (this.enableBiomeGenBaseBlock()) { + var14 = biomegenbase.topBlock; + var14m = biomegenbase.topMeta; + var14 = biomegenbase.fillerBlock; + var14m = biomegenbase.fillerMeta; + } else { + var14 = this.getGrassBlock().getBlock(); + var14m = this.getGrassBlock().getMetadata(); + var14 = this.getDirtBlock().getBlock(); + var14m = this.getDirtBlock().getMetadata(); + } + } + + var13 = var12; + if (var16 >= 19) { + arrayOfIDs[index] = var14; + arrayOfMeta[index] = var14m; + } else { + arrayOfIDs[index] = var15; + arrayOfMeta[index] = var15m; + } + } else if (var13 > 0) { + --var13; + arrayOfIDs[index] = var15; + arrayOfMeta[index] = var15m; + } + } + } else { + arrayOfIDs[index] = this.canGenerateIceBlock() ? Blocks.packed_ice : Blocks.bedrock; + } + } + } + } + + } + + private int getIndex(int x, int y, int z) { + return (x * 16 + z) * 256 + y; + } + + public Chunk loadChunk(int x, int z) { + return this.provideChunk(x, z); + } + + public boolean chunkExists(int x, int z) { + return true; + } + + public void populate(IChunkProvider chunk, int x, int z) { + BlockFalling.fallInstantly = true; + int var4 = x * 16; + int var5 = z * 16; + BiomeGenBase biomeGen = this.worldObj.getBiomeGenForCoords(var4 + 16, var5 + 16); + this.worldObj.getBiomeGenForCoords(var4 + 16, var5 + 16); + this.rand.setSeed(this.worldObj.getSeed()); + long var7 = this.rand.nextLong() / 2L * 2L + 1L; + long var9 = this.rand.nextLong() / 2L * 2L + 1L; + this.rand.setSeed((long) x * var7 + (long) z * var9 ^ this.worldObj.getSeed()); + biomeGen.decorate(this.worldObj, this.rand, var4, var5); + this.decoratePlanet(this.worldObj, this.rand, var4, var5); + SpawnerAnimals.performWorldGenSpawning(this.worldObj, biomeGen, var4 + 8, var5 + 8, 16, 16, this.rand); + this.onPopulate(chunk, x, z); + BlockFalling.fallInstantly = false; + } + + public void decoratePlanet(World world, Random rand, int x, int z) { + this.getBiomeGenerator().decorate(world, rand, x, z); + } + + public boolean saveChunks(boolean flag, IProgressUpdate progress) { + return true; + } + + public boolean canSave() { + return true; + } + + public String makeString() { + return "RandomLevelSource"; + } + + public List<SpawnListEntry> getPossibleCreatures(EnumCreatureType par1EnumCreatureType, int i, int j, int k) { + ArrayList<SpawnListEntry> watercreatures; + SpawnListEntry[] arr$; + int len$; + int i$; + SpawnListEntry watercreature; + if (par1EnumCreatureType == EnumCreatureType.monster) { + watercreatures = new ArrayList<SpawnListEntry>(); + arr$ = this.getMonsters(); + len$ = arr$.length; + + for (i$ = 0; i$ < len$; ++i$) { + watercreature = arr$[i$]; + watercreatures.add(watercreature); + } + + return watercreatures; + } else if (par1EnumCreatureType == EnumCreatureType.creature) { + watercreatures = new ArrayList<SpawnListEntry>(); + arr$ = this.getCreatures(); + len$ = arr$.length; + + for (i$ = 0; i$ < len$; ++i$) { + watercreature = arr$[i$]; + watercreatures.add(watercreature); + } + + return watercreatures; + } else if (par1EnumCreatureType != EnumCreatureType.waterCreature) { + return null; + } else { + watercreatures = new ArrayList<SpawnListEntry>(); + arr$ = this.getWaterCreatures(); + len$ = arr$.length; + + for (i$ = 0; i$ < len$; ++i$) { + watercreature = arr$[i$]; + watercreatures.add(watercreature); + } + + return watercreatures; + } + } + + public int getLoadedChunkCount() { + return 0; + } + + public void recreateStructures(int x, int z) { + } + + public boolean unloadQueuedChunks() { + return false; + } + + public void saveExtraData() { + } + + public ChunkPosition func_147416_a(World world, String string, int x, int y, int z) { + return null; + } + + protected abstract BiomeDecoratorSpace getBiomeGenerator(); + + protected abstract BiomeGenBase[] getBiomesForGeneration(); + + public abstract void onChunkProvider(int var1, int var2, Block[] var3, byte[] var4); + + public abstract void onPopulate(IChunkProvider var1, int var2, int var3); + + protected abstract SpawnListEntry[] getMonsters(); + + protected abstract SpawnListEntry[] getCreatures(); + + protected abstract SpawnListEntry[] getWaterCreatures(); + + protected abstract List<MapGenBaseMeta> getWorldGenerators(); + + public abstract double getHeightModifier(); + + public abstract int getWaterLevel(); + + public abstract boolean canGenerateWaterBlock(); + + public abstract boolean canGenerateIceBlock(); + + protected abstract BlockMetaPair getWaterBlock(); + + protected abstract BlockMetaPair getGrassBlock(); + + protected abstract BlockMetaPair getDirtBlock(); + + protected abstract BlockMetaPair getStoneBlock(); + + protected abstract boolean enableBiomeGenBaseBlock(); +}
\ No newline at end of file diff --git a/src/Java/gtPlusPlus/xmod/galacticraft/system/core/world/gen/GalacticBiomeGenBase.java b/src/Java/gtPlusPlus/xmod/galacticraft/system/core/world/gen/GalacticBiomeGenBase.java new file mode 100644 index 0000000000..9ebb7d3908 --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/galacticraft/system/core/world/gen/GalacticBiomeGenBase.java @@ -0,0 +1,39 @@ +package gtPlusPlus.xmod.galacticraft.system.core.world.gen; + +import gtPlusPlus.xmod.galacticraft.system.core.world.gen.biome.BiomeGenGalaxy; +import net.minecraft.block.Block; +import net.minecraft.world.biome.BiomeGenBase; + +public abstract class GalacticBiomeGenBase extends BiomeGenBase { + + public static BiomeGenBase mGalaxy; + public Block stoneBlock; + public byte topMeta; + public byte fillerMeta; + public byte stoneMeta; + + public int mBiomeID; + + public GalacticBiomeGenBase(int id) { + super(id); + this.spawnableMonsterList.clear(); + this.spawnableWaterCreatureList.clear(); + this.spawnableCreatureList.clear(); + this.spawnableCaveCreatureList.clear(); + this.rainfall = 0.0F; + this.setColor(-16744448); + mBiomeID = id; + } + + public GalacticBiomeGenBase setColor(int var1) { + return (GalacticBiomeGenBase) super.setColor(var1); + } + + public float getSpawningChance() { + return 0.1F; + } + + static { + mGalaxy = (new BiomeGenGalaxy(177)).setBiomeName("Galaxy"); + } +}
\ No newline at end of file diff --git a/src/Java/gtPlusPlus/xmod/galacticraft/system/core/world/gen/GalacticMapGenCavesBase.java b/src/Java/gtPlusPlus/xmod/galacticraft/system/core/world/gen/GalacticMapGenCavesBase.java new file mode 100644 index 0000000000..713682b921 --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/galacticraft/system/core/world/gen/GalacticMapGenCavesBase.java @@ -0,0 +1,191 @@ +package gtPlusPlus.xmod.galacticraft.system.core.world.gen; + +import galaxyspace.SolarSystem.core.registers.blocks.GSBlocks; +import java.util.Random; +import micdoodle8.mods.galacticraft.api.prefab.world.gen.MapGenBaseMeta; +import net.minecraft.block.Block; +import net.minecraft.init.Blocks; +import net.minecraft.util.MathHelper; +import net.minecraft.world.World; + +public class GalacticMapGenCavesBase extends MapGenBaseMeta { + public static final int BREAK_THROUGH_CHANCE = 25; + + protected void generateLargeCaveNode(long par1, int par3, int par4, Block[] blockIdArray, byte[] metaArray, + double par6, double par8, double par10) { + this.generateCaveNode(par1, par3, par4, blockIdArray, metaArray, par6, par8, par10, + 1.0F + this.rand.nextFloat() * 6.0F, 0.0F, 0.0F, -1, -1, 0.5D); + } + + protected void generateCaveNode(long par1, int par3, int par4, Block[] blockIdArray, byte[] metaArray, double par6, + double par8, double par10, float par12, float par13, float par14, int par15, int par16, double par17) { + double d4 = (double) (par3 * 16 + 8); + double d5 = (double) (par4 * 16 + 8); + float f3 = 0.0F; + float f4 = 0.0F; + Random random = new Random(par1); + if (par16 <= 0) { + int j1 = this.range * 16 - 16; + par16 = j1 - random.nextInt(j1 / 4); + } + + boolean flag = false; + if (par15 == -1) { + par15 = par16 / 2; + flag = true; + } + + int k1 = random.nextInt(par16 / 2) + par16 / 4; + + for (boolean flag1 = random.nextInt(6) == 0; par15 < par16; ++par15) { + double d6 = 1.5D + (double) (MathHelper.sin((float) par15 * 3.1415927F / (float) par16) * par12 * 1.0F); + double d7 = d6 * par17; + float f5 = MathHelper.cos(par14); + float f6 = MathHelper.sin(par14); + par6 += (double) (MathHelper.cos(par13) * f5); + par8 += (double) f6; + par10 += (double) (MathHelper.sin(par13) * f5); + if (flag1) { + par14 *= 0.92F; + } else { + par14 *= 0.7F; + } + + par14 += f4 * 0.1F; + par13 += f3 * 0.1F; + f4 *= 0.9F; + f3 *= 0.75F; + f4 += (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 2.0F; + f3 += (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 4.0F; + if (!flag && par15 == k1 && par12 > 1.0F && par16 > 0) { + this.generateCaveNode(random.nextLong(), par3, par4, blockIdArray, metaArray, par6, par8, par10, + random.nextFloat() * 0.5F + 0.5F, par13 - 1.5707964F, par14 / 3.0F, par15, par16, 1.0D); + this.generateCaveNode(random.nextLong(), par3, par4, blockIdArray, metaArray, par6, par8, par10, + random.nextFloat() * 0.5F + 0.5F, par13 + 1.5707964F, par14 / 3.0F, par15, par16, 1.0D); + return; + } + + if (flag || random.nextInt(4) != 0) { + double d8 = par6 - d4; + double d9 = par10 - d5; + double d10 = (double) (par16 - par15); + double d11 = (double) (par12 + 2.0F + 16.0F); + if (d8 * d8 + d9 * d9 - d10 * d10 > d11 * d11) { + return; + } + + if (par6 >= d4 - 16.0D - d6 * 2.0D && par10 >= d5 - 16.0D - d6 * 2.0D && par6 <= d4 + 16.0D + d6 * 2.0D + && par10 <= d5 + 16.0D + d6 * 2.0D) { + int l1 = MathHelper.floor_double(par6 - d6) - par3 * 16 - 1; + int i2 = MathHelper.floor_double(par6 + d6) - par3 * 16 + 1; + int j2 = MathHelper.floor_double(par8 - d7) - 1; + int k2 = MathHelper.floor_double(par8 + d7) + 1; + int l2 = MathHelper.floor_double(par10 - d6) - par4 * 16 - 1; + int i3 = MathHelper.floor_double(par10 + d6) - par4 * 16 + 1; + if (l1 < 0) { + l1 = 0; + } + + if (i2 > 16) { + i2 = 16; + } + + if (j2 < 1) { + j2 = 1; + } + + if (k2 > 120) { + k2 = 120; + } + + if (l2 < 0) { + l2 = 0; + } + + if (i3 > 16) { + i3 = 16; + } + + boolean flag2 = false; + + int localY; + for (int j3 = l1; j3 < i2; ++j3) { + for (localY = l2; localY < i3; ++localY) { + for (int i4 = k2 + 1; i4 >= j2 - 1; --i4) { + if (i4 >= 0 && i4 < 128 && i4 != j2 - 1 && j3 != l1 && j3 != i2 - 1 && localY != l2 + && localY != i3 - 1) { + i4 = j2; + } + } + } + } + + for (localY = j2; localY < k2; ++localY) { + double yfactor = ((double) localY + 0.5D - par8) / d7; + double yfactorSq = yfactor * yfactor; + + for (int localX = l1; localX < i2; ++localX) { + double zfactor = ((double) (localX + par3 * 16) + 0.5D - par6) / d6; + double zfactorSq = zfactor * zfactor; + + for (int localZ = l2; localZ < i3; ++localZ) { + double xfactor = ((double) (localZ + par4 * 16) + 0.5D - par10) / d6; + double xfactorSq = xfactor * xfactor; + if (xfactorSq + zfactorSq < 1.0D) { + int coords = (localX * 16 + localZ) * 256 + localY; + if (yfactor > -0.7D && xfactorSq + yfactorSq + zfactorSq < 1.0D) { + if (blockIdArray[coords] == GSBlocks.HaumeaBlocks && metaArray[coords] == 0 + && random.nextInt(25) == 0) { + blockIdArray[coords] = Blocks.air; + } else if (blockIdArray[coords] == GSBlocks.HaumeaBlocks + && metaArray[coords] == 0) { + blockIdArray[coords] = Blocks.air; + } + } + } + } + } + } + + if (flag) { + break; + } + } + } + } + + } + + protected void recursiveGenerate(World par1World, int par2, int par3, int par4, int par5, Block[] blockIdArray, + byte[] metaArray) { + int var7 = this.rand.nextInt(this.rand.nextInt(this.rand.nextInt(40) + 1) + 1); + if (this.rand.nextInt(15) != 0) { + var7 = 0; + } + + for (int var8 = 0; var8 < var7; ++var8) { + double var9 = (double) (par2 * 16 + this.rand.nextInt(16)); + double var11 = (double) this.rand.nextInt(this.rand.nextInt(120) + 8); + double var13 = (double) (par3 * 16 + this.rand.nextInt(16)); + int var15 = 1; + if (this.rand.nextInt(4) == 0) { + this.generateLargeCaveNode(this.rand.nextLong(), par4, par5, blockIdArray, metaArray, var9, var11, + var13); + var15 += this.rand.nextInt(4); + } + + for (int var16 = 0; var16 < var15; ++var16) { + float var17 = this.rand.nextFloat() * 3.1415927F * 2.0F; + float var18 = (this.rand.nextFloat() - 0.5F) * 2.0F / 8.0F; + float var19 = this.rand.nextFloat() * 2.0F + this.rand.nextFloat(); + if (this.rand.nextInt(10) == 0) { + var19 *= this.rand.nextFloat() * this.rand.nextFloat() * 3.0F + 1.0F; + } + + this.generateCaveNode(this.rand.nextLong(), par4, par5, blockIdArray, metaArray, var9, var11, var13, + var19, var17, var18, 0, 0, 1.0D); + } + } + + } +}
\ No newline at end of file diff --git a/src/Java/gtPlusPlus/xmod/galacticraft/system/core/world/gen/biome/BiomeGenGalaxy.java b/src/Java/gtPlusPlus/xmod/galacticraft/system/core/world/gen/biome/BiomeGenGalaxy.java new file mode 100644 index 0000000000..56d34831b8 --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/galacticraft/system/core/world/gen/biome/BiomeGenGalaxy.java @@ -0,0 +1,20 @@ +package gtPlusPlus.xmod.galacticraft.system.core.world.gen.biome; + +import gtPlusPlus.xmod.galacticraft.system.core.world.gen.GalacticBiomeGenBase; +import micdoodle8.mods.galacticraft.core.util.ConfigManagerCore; +import net.minecraftforge.common.BiomeDictionary; +import net.minecraftforge.common.BiomeDictionary.Type; + +public class BiomeGenGalaxy extends GalacticBiomeGenBase { + public BiomeGenGalaxy(int var1) { + super(var1); + this.spawnableCaveCreatureList.clear(); + this.spawnableCreatureList.clear(); + this.spawnableMonsterList.clear(); + this.spawnableWaterCreatureList.clear(); + if (!ConfigManagerCore.disableBiomeTypeRegistrations) { + BiomeDictionary.registerBiomeType(this, new Type[]{Type.COLD, Type.DRY, Type.DEAD, Type.SPOOKY}); + } + + } +}
\ No newline at end of file diff --git a/src/Java/gtPlusPlus/xmod/galacticraft/system/hd10180/SystemHD10180.java b/src/Java/gtPlusPlus/xmod/galacticraft/system/hd10180/SystemHD10180.java new file mode 100644 index 0000000000..6a1bb52204 --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/galacticraft/system/hd10180/SystemHD10180.java @@ -0,0 +1,40 @@ +package gtPlusPlus.xmod.galacticraft.system.hd10180; + +import gtPlusPlus.xmod.galacticraft.system.BaseSolarSystem; +import gtPlusPlus.xmod.galacticraft.system.core.dim.BasicChunkProviderGalactic; +import gtPlusPlus.xmod.galacticraft.system.hd10180.planets.b.dim.WorldProviderHD10180B; +import gtPlusPlus.xmod.galacticraft.system.objects.BiomeSettings; +import gtPlusPlus.xmod.galacticraft.system.objects.DimensionSettings; +import gtPlusPlus.xmod.galacticraft.system.objects.PlanetGenerator; +import gtPlusPlus.xmod.galacticraft.system.objects.WorldProviderSettings; +import micdoodle8.mods.galacticraft.api.galaxies.SolarSystem; +import micdoodle8.mods.galacticraft.api.galaxies.Star; +import micdoodle8.mods.galacticraft.api.vector.Vector3; + +public class SystemHD10180 extends BaseSolarSystem { + + public void preInit() { + //TCBlocks.initialize(); + } + + public void registrycelestial() { + + } + + @Override + public void initSolarSystem() { + + SolarSystem aSystemHD10180 = createSolarSystem("HD10180", "hydrus", new Vector3(2.0D, -1.0D, 2.0D)); + this.registerSolarSystem(aSystemHD10180); + + Star aMainStar = this.createStar("HD10180-A", -1); + this.setMainStarForSolarSystem(aMainStar); + + //Planet B + PlanetGenerator B = this.createPlanet("HD10180-B", new float[] {0.2f, 0.2f, 0.2f}, 3.1415927F, 1f, 2f, 11.861994F, null); + DimensionSettings Planet_B_Settings = new DimensionSettings(B, BasicChunkProviderGalactic.class, 5, true, 1, false, 240f, 0.1f, 0.2f, false, 48000L); + BiomeSettings Planet_B_Biome = new BiomeSettings("HD10180-B", 255, 0.1f, 0.2f); + this.registerPlanet(new WorldProviderHD10180B(new WorldProviderSettings(Planet_B_Settings, Planet_B_Biome)).getDim()); + + } +}
\ No newline at end of file diff --git a/src/Java/gtPlusPlus/xmod/galacticraft/system/hd10180/planets/b/dim/WorldProviderHD10180B.java b/src/Java/gtPlusPlus/xmod/galacticraft/system/hd10180/planets/b/dim/WorldProviderHD10180B.java new file mode 100644 index 0000000000..2566ef6280 --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/galacticraft/system/hd10180/planets/b/dim/WorldProviderHD10180B.java @@ -0,0 +1,13 @@ +package gtPlusPlus.xmod.galacticraft.system.hd10180.planets.b.dim; + +import gtPlusPlus.xmod.galacticraft.system.core.dim.BaseWorldProviderGalactic; +import gtPlusPlus.xmod.galacticraft.system.objects.WorldProviderSettings; + +public class WorldProviderHD10180B extends BaseWorldProviderGalactic { + + public WorldProviderHD10180B(WorldProviderSettings b) { + super(b); + } + + +}
\ No newline at end of file diff --git a/src/Java/gtPlusPlus/xmod/galacticraft/system/objects/BiomeSettings.java b/src/Java/gtPlusPlus/xmod/galacticraft/system/objects/BiomeSettings.java new file mode 100644 index 0000000000..33873f3f9e --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/galacticraft/system/objects/BiomeSettings.java @@ -0,0 +1,29 @@ +package gtPlusPlus.xmod.galacticraft.system.objects; + +import net.minecraft.world.biome.BiomeGenBase.Height; + +public class BiomeSettings { + + private final String mBiomeName; + private final int mBiomeID; + private final Height mHeight; + + public BiomeSettings(String aName, int aID, float aHeightMin, float aHeightMax) { + mBiomeName = aName; + mBiomeID = aID; + mHeight = new Height(aHeightMin, aHeightMax); + + } + + public synchronized final String getName() { + return mBiomeName; + } + + public synchronized final int getID() { + return mBiomeID; + } + + public synchronized final Height getHeight() { + return mHeight; + } +} diff --git a/src/Java/gtPlusPlus/xmod/galacticraft/system/objects/DimensionSettings.java b/src/Java/gtPlusPlus/xmod/galacticraft/system/objects/DimensionSettings.java new file mode 100644 index 0000000000..5e444805e0 --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/galacticraft/system/objects/DimensionSettings.java @@ -0,0 +1,77 @@ +package gtPlusPlus.xmod.galacticraft.system.objects; + +import net.minecraft.world.chunk.IChunkProvider; + +public class DimensionSettings { + + private final int TierRequirement; + private final PlanetGenerator Planet; + private final boolean Atmosphere; + private final int Pressure; + private final boolean SolarRadiation; + private final float CloudHeight; + private final float Gravity; + private final float MeteorFreq; + private final boolean CanRainOrSnow; + private final long DayLength; + private final Class<? extends IChunkProvider> ChunkProvider; + + public DimensionSettings(PlanetGenerator aPlanet, Class<? extends IChunkProvider> aChunkProvider, int aTierRequirement, boolean aHasBreathableAtmo, + int aPressure, boolean aSolarRadiation, float aCloudHeight, float aGravity, float aMeteorFreq, boolean aCanRainOrSnow, long aDayLength) { + Planet = aPlanet; + TierRequirement = aTierRequirement; + Atmosphere = aHasBreathableAtmo; + Pressure = aPressure; + SolarRadiation = aSolarRadiation; + CloudHeight = aCloudHeight; + Gravity = aGravity; + MeteorFreq = aMeteorFreq; + CanRainOrSnow = aCanRainOrSnow; + DayLength = aDayLength; + ChunkProvider = aChunkProvider; + } + + public synchronized final int getTierRequirement() { + return TierRequirement; + } + + public synchronized final PlanetGenerator getPlanet() { + return Planet; + } + + public synchronized final boolean hasAtmosphere() { + return Atmosphere; + } + + public synchronized final int getPressure() { + return Pressure; + } + + public synchronized final boolean hasSolarRadiation() { + return SolarRadiation; + } + + public synchronized final float getCloudHeight() { + return CloudHeight; + } + + public synchronized final float getGravity() { + return Gravity; + } + + public synchronized final float getMeteorFreq() { + return MeteorFreq; + } + + public synchronized final boolean hasRainOrSnow() { + return CanRainOrSnow; + } + + public synchronized final long getDayLength() { + return DayLength; + } + + public synchronized final Class<? extends IChunkProvider> getChunkProvider() { + return ChunkProvider; + } +} diff --git a/src/Java/gtPlusPlus/xmod/galacticraft/system/objects/IPlanetBlockRegister.java b/src/Java/gtPlusPlus/xmod/galacticraft/system/objects/IPlanetBlockRegister.java new file mode 100644 index 0000000000..e8349d8553 --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/galacticraft/system/objects/IPlanetBlockRegister.java @@ -0,0 +1,29 @@ +package gtPlusPlus.xmod.galacticraft.system.objects; + +import gtPlusPlus.api.objects.data.AutoMap; +import net.minecraft.block.Block; + +public interface IPlanetBlockRegister extends Runnable { + + public abstract AutoMap<Block> getBlocksToRegister(); + + public abstract Block getWaterBlock(); + + public abstract Block getTopLayer(); + + public abstract Block getSoil(); + + public abstract Block getSoil2(); + + public abstract Block getStone(); + + public abstract void register(); + + @Override + default void run() { + register(); + } + + + +} diff --git a/src/Java/gtPlusPlus/xmod/galacticraft/system/objects/PlanetGenerator.java b/src/Java/gtPlusPlus/xmod/galacticraft/system/objects/PlanetGenerator.java new file mode 100644 index 0000000000..7f59baa47a --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/galacticraft/system/objects/PlanetGenerator.java @@ -0,0 +1,50 @@ +package gtPlusPlus.xmod.galacticraft.system.objects; + +import java.util.HashMap; +import java.util.Map; + +import micdoodle8.mods.galacticraft.api.galaxies.Planet; +import net.minecraft.block.Block; + +public class PlanetGenerator { + + private final Planet mPlanet; + private final IPlanetBlockRegister mTask; + private final Map<String, Block> mPlanetBlocks; + private final Thread mTaskThread; + + public static final Map<String, PlanetGenerator> mGlobalPlanetCache = new HashMap<String, PlanetGenerator>(); + + public PlanetGenerator(Planet aPlanet, IPlanetBlockRegister aBlockRegistrationTask) { + mPlanet = aPlanet; + mTask = aBlockRegistrationTask; + mPlanetBlocks = new HashMap<String, Block>(); + for (Block b : aBlockRegistrationTask.getBlocksToRegister()) { + mPlanetBlocks.put(b.getUnlocalizedName(), b); + } + if (mGlobalPlanetCache.get(mPlanet.getName().toUpperCase()) == null) { + mGlobalPlanetCache.put(mPlanet.getName().toUpperCase(), this); + } + else { + try { + this.finalize(); + } catch (Throwable e) { + } + } + mTaskThread = new Thread(aBlockRegistrationTask); + mTaskThread.start(); + } + + public synchronized final Planet getPlanet() { + return mPlanet; + } + + public synchronized final IPlanetBlockRegister getTask() { + return mTask; + } + + public synchronized final Map<String, Block> getPlanetBlocks() { + return mPlanetBlocks; + } + +} diff --git a/src/Java/gtPlusPlus/xmod/galacticraft/system/objects/WorldProviderSettings.java b/src/Java/gtPlusPlus/xmod/galacticraft/system/objects/WorldProviderSettings.java new file mode 100644 index 0000000000..e5ef3b43d9 --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/galacticraft/system/objects/WorldProviderSettings.java @@ -0,0 +1,30 @@ +package gtPlusPlus.xmod.galacticraft.system.objects; + +public class WorldProviderSettings { + + private PlanetGenerator mPlanet; + private final DimensionSettings mDimSettings; + private final BiomeSettings mBiomeSettings; + + public WorldProviderSettings(DimensionSettings d, BiomeSettings b) { + mPlanet = d.getPlanet(); + mDimSettings = d; + mBiomeSettings = b; + } + + public synchronized final PlanetGenerator getPlanet() { + return mPlanet; + } + + public synchronized final void setPlanet(PlanetGenerator aPlanet) { + mPlanet = aPlanet; + } + + public synchronized final DimensionSettings getDimSettings() { + return mDimSettings; + } + + public synchronized final BiomeSettings getBiomeSettings() { + return mBiomeSettings; + } +} |