New Dimension - Blocks of water still generate at sea level (but not below it) despite lowering the sea level? [Unsolved] - Modification Development - Minecraft Mods - Mapping and Modding: Java Edition - Minecraft Forum

1.7.10 Forge

New Dimension - Blocks of water still generate at sea level (but not below it) despite lowering the sea level? [Unsolved]

#1 Oct 12, 2014
Clustafer123
Clustafer123

View User Profile

View Posts

Send Message
- Coal Miner
- Join Date: 2/16/2013
- Posts: 105
- Member Details
So in my new dimension, I don't want any water in oceans to generate. I lowered the sea level, which mostly works. However, some blocks of water still generate at the height of the default sea level.

Like this:

I don't know what code to post, and if you need to check any other classes just ask, but I'll start with my ChunkProvider:

_{package xtracraft.world;}
_{import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.CAVE;}
_{import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.MINESHAFT;}
_{import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.RAVINE;}
_{import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.SCATTERED_FEATURE;}
_{import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.STRONGHOLD;}
_{import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.VILLAGE;}
_{import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.ANIMALS;}
_{import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.DUNGEON;}
_{import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.ICE;}
_{import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.LAKE;}
_{import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.LAVA;}

_{import java.util.List;}
_{import java.util.Random;}

_{import xtracraft.Xtracraft;}

_{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.WorldType;}
_{import net.minecraft.world.biome.BiomeGenBase;}
_{import net.minecraft.world.chunk.Chunk;}
_{import net.minecraft.world.chunk.IChunkProvider;}
_{import net.minecraft.world.gen.MapGenBase;}
_{import net.minecraft.world.gen.MapGenCaves;}
_{import net.minecraft.world.gen.MapGenRavine;}
_{import net.minecraft.world.gen.NoiseGenerator;}
_{import net.minecraft.world.gen.NoiseGeneratorOctaves;}
_{import net.minecraft.world.gen.NoiseGeneratorPerlin;}
_{import net.minecraft.world.gen.feature.WorldGenDungeons;}
_{import net.minecraft.world.gen.feature.WorldGenLakes;}
_{import net.minecraft.world.gen.structure.MapGenMineshaft;}
_{import net.minecraft.world.gen.structure.MapGenScatteredFeature;}
_{import net.minecraft.world.gen.structure.MapGenStronghold;}
_{import net.minecraft.world.gen.structure.MapGenVillage;}
_{import net.minecraftforge.common.MinecraftForge;}
_{import net.minecraftforge.event.terraingen.ChunkProviderEvent;}
_{import net.minecraftforge.event.terraingen.PopulateChunkEvent;}
_{import net.minecraftforge.event.terraingen.TerrainGen;}
_{import cpw.mods.fml.common.eventhandler.Event.Result;}

_{public class ChunkProviderWasteland implements IChunkProvider}
_{
_{/** RNG. */}
_{private Random rand;}
_{private NoiseGeneratorOctaves field_147431_j;}
_{private NoiseGeneratorOctaves field_147432_k;}
_{private NoiseGeneratorOctaves field_147429_l;}
_{private NoiseGeneratorPerlin field_147430_m;}
_{public NoiseGeneratorOctaves noiseGen5;}
_{public NoiseGeneratorOctaves noiseGen6;}
_{public NoiseGeneratorOctaves mobSpawnerNoise;}
_{private World worldObj;}
_{private final boolean mapFeaturesEnabled;}
_{private WorldType field_147435_p;}
_{private final double[] field_147434_q;}
_{private final float[] parabolicField;}
_{private double[] stoneNoise = new double[256];}
_{private MapGenBase caveGenerator = new MapGenCaves();}
_{//private MapGenStronghold strongholdGenerator = new MapGenStronghold();}
_{private MapGenVillage villageGenerator = new MapGenVillage();}
_{//private MapGenMineshaft mineshaftGenerator = new MapGenMineshaft();}
_{private MapGenScatteredFeature scatteredFeatureGenerator = new MapGenScatteredFeature();}
_{private MapGenBase ravineGenerator = new MapGenRavine();}
_{private BiomeGenBase[] biomesForGeneration;}
_{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 static final String __OBFID = "CL_00000396";}

_{
_{caveGenerator = TerrainGen.getModdedMapGen(caveGenerator, CAVE);}
_{//strongholdGenerator = (MapGenStronghold) TerrainGen.getModdedMapGen(strongholdGenerator, STRONGHOLD);}
_{villageGenerator = (MapGenVillage) TerrainGen.getModdedMapGen(villageGenerator, VILLAGE);}
_{//mineshaftGenerator = (MapGenMineshaft) TerrainGen.getModdedMapGen(mineshaftGenerator, MINESHAFT);}
_{scatteredFeatureGenerator = (MapGenScatteredFeature) TerrainGen.getModdedMapGen(scatteredFeatureGenerator, SCATTERED_FEATURE);}
_{ravineGenerator = TerrainGen.getModdedMapGen(ravineGenerator, RAVINE);}
_}

_{public ChunkProviderWasteland(World p_i2006_1_, long p_i2006_2_, boolean p_i2006_4_)}
_{
_{this.worldObj = p_i2006_1_;}
_{this.mapFeaturesEnabled = p_i2006_4_;}
_{this.field_147435_p = p_i2006_1_.getWorldInfo().getTerrainType();}
_{this.rand = new Random(p_i2006_2_);}
_{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.noiseGen5 = new NoiseGeneratorOctaves(this.rand, 10);}
_{this.noiseGen6 = new NoiseGeneratorOctaves(this.rand, 16);}
_{this.mobSpawnerNoise = new NoiseGeneratorOctaves(this.rand, 8);}
_{this.field_147434_q = 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;}
_}
_}

_{NoiseGenerator[] noiseGens = {field_147431_j, field_147432_k, field_147429_l, field_147430_m, noiseGen5, noiseGen6, mobSpawnerNoise};}
_{noiseGens = TerrainGen.getModdedNoiseGenerators(p_i2006_1_, this.rand, noiseGens);}
_{this.field_147431_j = (NoiseGeneratorOctaves)noiseGens[0];}
_{this.field_147432_k = (NoiseGeneratorOctaves)noiseGens[1];}
_{this.field_147429_l = (NoiseGeneratorOctaves)noiseGens[2];}
_{this.field_147430_m = (NoiseGeneratorPerlin)noiseGens[3];}
_{this.noiseGen5 = (NoiseGeneratorOctaves)noiseGens[4];}
_{this.noiseGen6 = (NoiseGeneratorOctaves)noiseGens[5];}
_{this.mobSpawnerNoise = (NoiseGeneratorOctaves)noiseGens[6];}
_}

_{public void func_147424_a(int p_147424_1_, int p_147424_2_, Block[] p_147424_3_)}
_{
_{byte b0 = 0; //Was 63 (ocean height)}
_{this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, p_147424_1_ * 4 - 2, p_147424_2_ * 4 - 2, 10, 10);}
_{this.func_147423_a(p_147424_1_ * 4, 0, p_147424_2_ * 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.field_147434_q[k1 + k2];}
_{double d2 = this.field_147434_q[l1 + k2];}
_{double d3 = this.field_147434_q[i2 + k2];}
_{double d4 = this.field_147434_q[j2 + k2];}
_{double d5 = (this.field_147434_q[k1 + k2 + 1] - d1) * d0;}
_{double d6 = (this.field_147434_q[l1 + k2 + 1] - d2) * d0;}
_{double d7 = (this.field_147434_q[i2 + k2 + 1] - d3) * d0;}
_{double d8 = (this.field_147434_q[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)}
_{
_{p_147424_3_[j3 += short1] = Blocks.stone;}
_}
_{else if (k2 * 8 + l2 < b0)}
_{
_{p_147424_3_[j3 += short1] = Blocks.water;}
_}
_else
_{
_{p_147424_3_[j3 += short1] = null;}
_}
_}

_{d10 += d12;}
_{d11 += d13;}
_}

_{d1 += d5;}
_{d2 += d6;}
_{d3 += d7;}
_{d4 += d8;}
_}
_}
_}
_}
_}
_{public void replaceBlocksForBiome(int p_147422_1_, int p_147422_2_, Block[] p_147422_3_, byte[] p_147422_4_, BiomeGenBase[] p_147422_5_)}
_{
_{ChunkProviderEvent.ReplaceBiomeBlocks event = new ChunkProviderEvent.ReplaceBiomeBlocks(this, p_147422_1_, p_147422_2_, p_147422_3_, p_147422_4_, p_147422_5_); //this.worldObj was last arg}
_{MinecraftForge.EVENT_BUS.post(event);}
_{if (event.getResult() == Result.DENY) return;}

_{double d0 = 0.03125D;}
_{this.stoneNoise = this.field_147430_m.func_151599_a(this.stoneNoise, (double)(p_147422_1_ * 16), (double)(p_147422_2_ * 16), 16, 16, d0 * 2.0D, d0 * 2.0D, 1.0D);}

_{for (int k = 0; k < 16; ++k)}
_{
_{for (int l = 0; l < 16; ++l)}
_{
_{BiomeGenBase biomegenbase = p_147422_5_[l + k * 16];}
_{biomegenbase.genTerrainBlocks(this.worldObj, this.rand, p_147422_3_, p_147422_4_, p_147422_1_ * 16 + k, p_147422_2_ * 16 + l, this.stoneNoise[l + k * 16]);}
_}
_}
_}

_{public Chunk loadChunk(int p_73158_1_, int p_73158_2_)}
_{
_{return this.provideChunk(p_73158_1_, p_73158_2_);}
_}

_{public Chunk provideChunk(int p_73154_1_, int p_73154_2_)}
_{
_{this.rand.setSeed((long)p_73154_1_ * 341873128712L + (long)p_73154_2_ * 132897987541L);}
_{Block[] ablock = new Block[65536];}
_{byte[] abyte = new byte[65536];}
_{this.func_147424_a(p_73154_1_, p_73154_2_, ablock);}
_{this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, p_73154_1_ * 16, p_73154_2_ * 16, 16, 16);}
_{this.replaceBlocksForBiome(p_73154_1_, p_73154_2_, ablock, abyte, this.biomesForGeneration);}
_{this.caveGenerator.func_151539_a(this, this.worldObj, p_73154_1_, p_73154_2_, ablock);}
_{this.ravineGenerator.func_151539_a(this, this.worldObj, p_73154_1_, p_73154_2_, ablock);}

_{if (this.mapFeaturesEnabled)}
_{
_{//this.mineshaftGenerator.func_151539_a(this, this.worldObj, p_73154_1_, p_73154_2_, ablock);}
_{this.villageGenerator.func_151539_a(this, this.worldObj, p_73154_1_, p_73154_2_, ablock);}
_{//this.strongholdGenerator.func_151539_a(this, this.worldObj, p_73154_1_, p_73154_2_, ablock);}
_{this.scatteredFeatureGenerator.func_151539_a(this, this.worldObj, p_73154_1_, p_73154_2_, ablock);}
_}

_{Chunk chunk = new Chunk(this.worldObj, ablock, abyte, p_73154_1_, p_73154_2_);}
_{byte[] abyte1 = chunk.getBiomeArray();}

_{for (int k = 0; k < abyte1.length; ++k)}
_{
_{abyte1[k] = (byte)this.biomesForGeneration[k].biomeID;}
_}

_{chunk.generateSkylightMap();}
_{return chunk;}
_}

_{private void func_147423_a(int p_147423_1_, int p_147423_2_, int p_147423_3_)}
_{
_{double d0 = 684.412D;}
_{double d1 = 684.412D;}
_{double d2 = 512.0D;}
_{double d3 = 512.0D;}
_{this.field_147426_g = this.noiseGen6.generateNoiseOctaves(this.field_147426_g, p_147423_1_, p_147423_3_, 5, 5, 200.0D, 200.0D, 0.5D);}
_{this.field_147427_d = this.field_147429_l.generateNoiseOctaves(this.field_147427_d, p_147423_1_, p_147423_2_, p_147423_3_, 5, 33, 5, 8.555150000000001D, 4.277575000000001D, 8.555150000000001D);}
_{this.field_147428_e = this.field_147431_j.generateNoiseOctaves(this.field_147428_e, p_147423_1_, p_147423_2_, p_147423_3_, 5, 33, 5, 684.412D, 684.412D, 684.412D);}
_{this.field_147425_f = this.field_147432_k.generateNoiseOctaves(this.field_147425_f, p_147423_1_, p_147423_2_, p_147423_3_, 5, 33, 5, 684.412D, 684.412D, 684.412D);}
_{boolean flag1 = false;}
_{boolean flag = false;}
_{int l = 0;}
_{int i1 = 0;}
_{double d4 = 8.5D;}

_{for (int j1 = 0; j1 < 5; ++j1)}
_{
_{for (int k1 = 0; k1 < 5; ++k1)}
_{
_{float f = 0.0F;}
_{float f1 = 0.0F;}
_{float f2 = 0.0F;}
_{byte b0 = 2;}
_{BiomeGenBase biomegenbase = this.biomesForGeneration[j1 + 2 + (k1 + 2) * 10];}

_{for (int l1 = -b0; l1 <= b0; ++l1)}
_{
_{for (int i2 = -b0; i2 <= b0; ++i2)}
_{
_{BiomeGenBase biomegenbase1 = this.biomesForGeneration[j1 + l1 + 2 + (k1 + i2 + 2) * 10];}
_{float f3 = biomegenbase1.rootHeight;}
_{float f4 = biomegenbase1.heightVariation;}

_{if (this.field_147435_p == WorldType.AMPLIFIED && f3 > 0.0F)}
_{
_{f3 = 1.0F + f3 * 2.0F;}
_{f4 = 1.0F + f4 * 4.0F;}
_}

_{float f5 = this.parabolicField[l1 + 2 + (i2 + 2) * 5] / (f3 + 2.0F);}

_{if (biomegenbase1.rootHeight > biomegenbase.rootHeight)}
_{
_{f5 /= 2.0F;}
_}

_{f += f4 * f5;}
_{f1 += f3 * f5;}
_{f2 += f5;}
_}
_}

_{f /= f2;}
_{f1 /= f2;}
_{f = f * 0.9F + 0.1F;}
_{f1 = (f1 * 4.0F - 1.0F) / 8.0F;}
_{double d12 = this.field_147426_g[i1] / 8000.0D;}

_{if (d12 < 0.0D)}
_{
_{d12 = -d12 * 0.3D;}
_}

_{d12 = d12 * 3.0D - 2.0D;}

_{if (d12 < 0.0D)}
_{
_{d12 /= 2.0D;}

_{if (d12 < -1.0D)}
_{
_{d12 = -1.0D;}
_}

_{d12 /= 1.4D;}
_{d12 /= 2.0D;}
_}
_else
_{
_{if (d12 > 1.0D)}
_{
_{d12 = 1.0D;}
_}

_{d12 /= 8.0D;}
_}

_++i1;
_{double d13 = (double)f1;}
_{double d14 = (double)f;}
_{d13 += d12 * 0.2D;}
_{d13 = d13 * 8.5D / 8.0D;}
_{double d5 = 8.5D + d13 * 4.0D;}

_{for (int j2 = 0; j2 < 33; ++j2)}
_{
_{double d6 = ((double)j2 - d5) * 12.0D * 128.0D / 256.0D / d14;}

_{if (d6 < 0.0D)}
_{
_{d6 *= 4.0D;}
_}

_{double d7 = this.field_147428_e[l] / 512.0D;}
_{double d8 = this.field_147425_f[l] / 512.0D;}
_{double d9 = (this.field_147427_d[l] / 10.0D + 1.0D) / 2.0D;}
_{double d10 = MathHelper.denormalizeClamp(d7, d8, d9) - d6;}

_{if (j2 > 29)}
_{
_{double d11 = (double)((float)(j2 - 29) / 3.0F);}
_{d10 = d10 * (1.0D - d11) + -10.0D * d11;}
_}

_{this.field_147434_q[l] = d10;}
_++l;
_}
_}
_}
_}

_{public boolean chunkExists(int p_73149_1_, int p_73149_2_)}
_{
_{return true;}
_}

_{public void populate(IChunkProvider p_73153_1_, int p_73153_2_, int p_73153_3_)}
_{
_{BlockFalling.fallInstantly = true;}
_{int k = p_73153_2_ * 16;}
_{int l = p_73153_3_ * 16;}
_{BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(k + 16, l + 16);}
_{this.rand.setSeed(this.worldObj.getSeed());}
_{long i1 = this.rand.nextLong() / 2L * 2L + 1L;}
_{long j1 = this.rand.nextLong() / 2L * 2L + 1L;}
_{this.rand.setSeed((long)p_73153_2_ * i1 + (long)p_73153_3_ * j1 ^ this.worldObj.getSeed());}
_{boolean flag = false;}

_{MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag));}

_{if (this.mapFeaturesEnabled)}
_{
_{//this.mineshaftGenerator.generateStructuresInChunk(this.worldObj, this.rand, p_73153_2_, p_73153_3_);}
_{flag = this.villageGenerator.generateStructuresInChunk(this.worldObj, this.rand, p_73153_2_, p_73153_3_);}
_{//this.strongholdGenerator.generateStructuresInChunk(this.worldObj, this.rand, p_73153_2_, p_73153_3_);}
_{this.scatteredFeatureGenerator.generateStructuresInChunk(this.worldObj, this.rand, p_73153_2_, p_73153_3_);}
_}

_{int k1;}
_{int l1;}
_{int i2;}

_{if (biomegenbase != Xtracraft.wasteDesert && biomegenbase != BiomeGenBase.desertHills && !flag && this.rand.nextInt(4) == 0}
_{&& TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, LAKE))}
_{
_{k1 = k + this.rand.nextInt(16) + 8;}
_{l1 = this.rand.nextInt(256);}
_{i2 = l + this.rand.nextInt(16) + 8;}
_{(new WorldGenLakes(Blocks.water)).generate(this.worldObj, this.rand, k1, l1, i2);}
_}

_{if (TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, LAVA) && !flag && this.rand.nextInt(8) == 0)}
_{
_{k1 = k + this.rand.nextInt(16) + 8;}
_{l1 = this.rand.nextInt(this.rand.nextInt(248) + 8);}
_{i2 = l + this.rand.nextInt(16) + 8;}

_{if (l1 < 63 || this.rand.nextInt(10) == 0)}
_{
_{(new WorldGenLakes(Blocks.lava)).generate(this.worldObj, this.rand, k1, l1, i2);}
_}
_}

_{boolean doGen = TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, DUNGEON);}
_{for (k1 = 0; doGen && k1 < 8; ++k1)}
_{
_{l1 = k + this.rand.nextInt(16) + 8;}
_{i2 = this.rand.nextInt(256);}
_{int j2 = l + this.rand.nextInt(16) + 8;}
_{(new WorldGenDungeons()).generate(this.worldObj, this.rand, l1, i2, j2);}
_}

_{biomegenbase.decorate(this.worldObj, this.rand, k, l);}
_{if (TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, ANIMALS))}
_{
_{SpawnerAnimals.performWorldGenSpawning(this.worldObj, biomegenbase, k + 8, l + 8, 16, 16, this.rand);}
_}
_{k += 8;}
_{l += 8;}

_{doGen = TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, ICE);}
_{for (k1 = 0; doGen && k1 < 16; ++k1)}
_{
_{for (l1 = 0; l1 < 16; ++l1)}
_{
_{i2 = this.worldObj.getPrecipitationHeight(k + k1, l + l1);}

_{if (this.worldObj.isBlockFreezable(k1 + k, i2 - 1, l1 + l))}
_{
_{this.worldObj.setBlock(k1 + k, i2 - 1, l1 + l, Blocks.ice, 0, 2);}
_}

_{if (this.worldObj.func_147478_e(k1 + k, i2, l1 + l, true))}
_{
_{this.worldObj.setBlock(k1 + k, i2, l1 + l, Blocks.snow_layer, 0, 2);}
_}
_}
_}

_{MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag));}

_{BlockFalling.fallInstantly = false;}
_}

_{public boolean saveChunks(boolean p_73151_1_, IProgressUpdate p_73151_2_)}
_{
_{return true;}
_}

_{public void saveExtraData() {}}

_{public boolean unloadQueuedChunks()}
_{
_{return false;}
_}

_{public boolean canSave()}
_{
_{return true;}
_}

_{public String makeString()}
_{
_{return "RandomLevelSource";}
_}

_{public List getPossibleCreatures(EnumCreatureType p_73155_1_, int p_73155_2_, int p_73155_3_, int p_73155_4_)}
_{
_{BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(p_73155_2_, p_73155_4_);}
_{return p_73155_1_ == EnumCreatureType.monster && this.scatteredFeatureGenerator.func_143030_a(p_73155_2_, p_73155_3_, p_73155_4_) ? this.scatteredFeatureGenerator.getScatteredFeatureSpawnList() : biomegenbase.getSpawnableList(p_73155_1_);}
_}

_{public ChunkPosition func_147416_a(World p_147416_1_, String p_147416_2_, int p_147416_3_, int p_147416_4_, int p_147416_5_)}
_{
_{return null;//"Stronghold".equals(p_147416_2_) && this.strongholdGenerator != null ? this.strongholdGenerator.func_151545_a(p_147416_1_, p_147416_3_, p_147416_4_, p_147416_5_) : null;}
_}

_{public int getLoadedChunkCount()}
_{
_{return 0;}
_}

_{public void recreateStructures(int p_82695_1_, int p_82695_2_)}
_{
_{if (this.mapFeaturesEnabled)}
_{
_{//this.mineshaftGenerator.func_151539_a(this, this.worldObj, p_82695_1_, p_82695_2_, (Block[])null);}
_{this.villageGenerator.func_151539_a(this, this.worldObj, p_82695_1_, p_82695_2_, (Block[])null);}
_{//this.strongholdGenerator.func_151539_a(this, this.worldObj, p_82695_1_, p_82695_2_, (Block[])null);}
_{this.scatteredFeatureGenerator.func_151539_a(this, this.worldObj, p_82695_1_, p_82695_2_, (Block[])null);}
_}
_}
_}

Last edited by Clustafer123: Oct 12, 2014

Rollback Post to Revision RollBack
#3 Oct 12, 2014
Clustafer123
Clustafer123

View User Profile

View Posts

Send Message
- Coal Miner
- Join Date: 2/16/2013
- Posts: 105
- Member Details
Nope, it's set to my custom dirt block.

Rollback Post to Revision RollBack
#5 Oct 12, 2014
Clustafer123
Clustafer123

View User Profile

View Posts

Send Message
- Coal Miner
- Join Date: 2/16/2013
- Posts: 105
- Member Details
The lines are removed, and the water is still there! This doesn't seem like it will have an easy fix.

Rollback Post to Revision RollBack

#6 Oct 13, 2014

Coal Miner
Join Date: 2/16/2013
Posts: 105
Member Details

Okay here's an update on something I've discovered:

I just started making another dimension for the mod. It's the starter dimension, so it only has one biome, and uses the exact same chunk provider as the overworld. When changing water to air in this chunk provider, I don't get the same problem. This confirms that the cause of some water generating is in the Wasteland's ChunkProvider.

EDIT: Well I thought it was in the chunk provider... I replaced it with the starter dimension's chunk provider, and the problem still exists. So I guess it's in the world chunk manager or one of the genlayers?

WorldChunkManager code

 package xtracraft.world;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;

import xtracraft.Xtracraft;
import xtracraft.genlayer.GenLayerWasteland;

import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;

import net.minecraft.world.ChunkPosition;
import net.minecraft.world.World;
import net.minecraft.world.WorldType;
import net.minecraft.world.biome.BiomeCache;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraft.world.biome.WorldChunkManager;
import net.minecraft.world.gen.layer.GenLayer;
import net.minecraft.world.gen.layer.IntCache;

public class WorldChunkManagerWasteland extends WorldChunkManager
{
 private GenLayer myGenBiomes;
 private GenLayer myBiomeIndexLayer;
 private BiomeCache myBiomeCache;
 private List myBiomesToSpawnIn;

 protected WorldChunkManagerWasteland()
 {
 this.myBiomeCache = new BiomeCache(this);
 this.myBiomesToSpawnIn = new ArrayList();
 this.myBiomesToSpawnIn.add(Xtracraft.wasteDesert);
 this.myBiomesToSpawnIn.add(Xtracraft.wasteHills);
 this.myBiomesToSpawnIn.add(Xtracraft.wastePlains);
 this.myBiomesToSpawnIn.add(Xtracraft.deadForest);
 }

 public WorldChunkManagerWasteland(long seed, WorldType worldtype)
 {
 this();
 // i changed this to my GenLayerTutorial
 GenLayer[] agenlayer = GenLayerWasteland.makeTheWorld(seed);
 this.myGenBiomes = agenlayer[0];
 this.myBiomeIndexLayer = agenlayer[1];
 }

 public WorldChunkManagerWasteland(World world)
 {
 this(world.getSeed(), world.provider.terrainType);
 }

 /**
 * Gets the list of valid biomes for the player to spawn in.
 */
 public List getBiomesToSpawnIn()
 {
 return this.myBiomesToSpawnIn;
 }

 /**
 * Returns the BiomeGenBase related to the x, z position on the world.
 */
 public BiomeGenBase getBiomeGenAt(int x, int z)
 {
 BiomeGenBase biome = this.myBiomeCache.getBiomeGenAt(x, z);
 if (biome == null)
 {
 return Xtracraft.wastePlains;
 }

 return biome;
 }

 /**
 * Returns a list of rainfall values for the specified blocks. Args:
 * listToReuse, x, z, width, length.
 */
 @Override
 public float[] getRainfall(float[] par1ArrayOfFloat, int par2, int par3, int par4, int par5)
 {
 IntCache.resetIntCache();

 if (par1ArrayOfFloat == null || par1ArrayOfFloat.length < par4 * par5)
 {
 par1ArrayOfFloat = new float[par4 * par5];
 }

 int[] aint = this.myBiomeIndexLayer.getInts(par2, par3, par4, par5);

 for (int i1 = 0; i1 < par4 * par5; ++i1)
 {
 float f = (float) BiomeGenBase.getBiome(aint[i1]).getIntRainfall() / 65536.0F;

 if (f > 1.0F) {
 f = 1.0F;
 }
 par1ArrayOfFloat[i1] = f;
 }
 return par1ArrayOfFloat;
 }

 /**
 * Return an adjusted version of a given temperature based on the y height
 */
 @Override
 @SideOnly(Side.CLIENT)
 public float getTemperatureAtHeight(float par1, int par2)
 {
 return par1;
 }

 /**
 * Returns an array of biomes for the location input.
 */
 @Override
 public BiomeGenBase[] getBiomesForGeneration(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5) {
 IntCache.resetIntCache();

 if (par1ArrayOfBiomeGenBase == null || par1ArrayOfBiomeGenBase.length < par4 * par5) {
 par1ArrayOfBiomeGenBase = new BiomeGenBase[par4 * par5];
 }

 int[] aint = this.myGenBiomes.getInts(par2, par3, par4, par5);

 for (int i = 0; i < par4 * par5; ++i) {
 if (aint[i] >= 0) {
 par1ArrayOfBiomeGenBase[i] = BiomeGenBase.getBiome(aint[i]);
 } else {
 //Change this to a biome
 par1ArrayOfBiomeGenBase[i] = Xtracraft.wastePlains;
 }
 }

 return par1ArrayOfBiomeGenBase;
 }

 /**
 * Returns biomes to use for the blocks and loads the other data like
 * temperature and humidity onto the WorldChunkManager Args: oldBiomeList,
 * x, z, width, depth
 */
 @Override
 public BiomeGenBase[] loadBlockGeneratorData(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5) {
 return this.getBiomeGenAt(par1ArrayOfBiomeGenBase, par2, par3, par4, par5, true);
 }

 /**
 * Return a list of biomes for the specified blocks. Args: listToReuse, x,
 * y, width, length, cacheFlag (if false, don't check biomeCache to avoid
 * infinite loop in BiomeCacheBlock)
 */
 @Override
 public BiomeGenBase[] getBiomeGenAt(BiomeGenBase[] par1ArrayOfBiomeGenBase, int x, int y, int width, int length, boolean cacheFlag) {
 IntCache.resetIntCache();

 if (par1ArrayOfBiomeGenBase == null || par1ArrayOfBiomeGenBase.length < width * length) {
 par1ArrayOfBiomeGenBase = new BiomeGenBase[width * length];
 }

 if (cacheFlag && width == 16 && length == 16 && (x & 15) == 0 && (y & 15) == 0) {
 BiomeGenBase[] abiomegenbase1 = this.myBiomeCache.getCachedBiomes(x, y);
 System.arraycopy(abiomegenbase1, 0, par1ArrayOfBiomeGenBase, 0, width * length);
 return par1ArrayOfBiomeGenBase;
 } else {
 int[] aint = this.myBiomeIndexLayer.getInts(x, y, width, length);

 for (int i = 0; i < width * length; ++i) {
 if (aint[i] >= 0) {
 par1ArrayOfBiomeGenBase[i] = BiomeGenBase.getBiome(aint[i]);
 } else {
 //Change this to a biome
 par1ArrayOfBiomeGenBase[i] = Xtracraft.wastePlains;
 }
 }

 return par1ArrayOfBiomeGenBase;
 }
 }

 /**
 * checks given Chunk's Biomes against List of allowed ones
 */
 @Override
 public boolean areBiomesViable(int par1, int par2, int par3, List par4List) {
 IntCache.resetIntCache();
 int l = par1 - par3 >> 2;
 int i1 = par2 - par3 >> 2;
 int j1 = par1 + par3 >> 2;
 int k1 = par2 + par3 >> 2;
 int l1 = j1 - l + 1;
 int i2 = k1 - i1 + 1;
 int[] aint = this.myGenBiomes.getInts(l, i1, l1, i2);

 for (int j2 = 0; j2 < l1 * i2; ++j2) {
 BiomeGenBase biomegenbase = BiomeGenBase.getBiome(aint[j2]);

 if (!par4List.contains(biomegenbase)) {
 return false;
 }
 }

 return true;
 }

 /**
 * Finds a valid position within a range, that is in one of the listed
 * biomes. Searches {par1,par2} +-par3 blocks. Strongly favors positive y
 * positions.
 */
 @Override
 public ChunkPosition findBiomePosition(int par1, int par2, int par3, List par4List, Random par5Random) {
 IntCache.resetIntCache();
 int l = par1 - par3 >> 2;
 int i1 = par2 - par3 >> 2;
 int j1 = par1 + par3 >> 2;
 int k1 = par2 + par3 >> 2;
 int l1 = j1 - l + 1;
 int i2 = k1 - i1 + 1;
 int[] aint = this.myGenBiomes.getInts(l, i1, l1, i2);
 ChunkPosition chunkposition = null;
 int j2 = 0;

 for (int k2 = 0; k2 < l1 * i2; ++k2) {
 int l2 = l + k2 % l1 << 2;
 int i3 = i1 + k2 / l1 << 2;
 BiomeGenBase biomegenbase = BiomeGenBase.getBiome(aint[k2]);

 if (par4List.contains(biomegenbase) && (chunkposition == null || par5Random.nextInt(j2 + 1) == 0)) {
 chunkposition = new ChunkPosition(l2, 0, i3);
 ++j2;
 }
 }

 return chunkposition;
 }

 /**
 * Calls the WorldChunkManager's biomeCache.cleanupCache()
 */
 @Override
 public void cleanupCache()
 {
 this.myBiomeCache.cleanupCache();
 }
}
[/i][/i][/i][/i][/i][/i][/i][/i]

Last edited by Clustafer123: Oct 13, 2014

To post a comment, please login.

Previous Thread

Next Thread

Minecraft Forums

New Dimension - Blocks of water still generate at sea level (but not below it) despite lowering the sea level? [Unsolved]

Social Media

Services

Resources

Our Communities