From 92318aa9d6173a7a2de73afbf61011e701c51c70 Mon Sep 17 00:00:00 2001 From: ted80-PC Date: Thu, 4 Apr 2013 18:06:09 +0200 Subject: [PATCH] Added alpha beaches to origin valley biome --- .../biomesop/biomes/BiomeGenOriginValley.java | 3 + .../tdwp_ftw/biomesop/mod_BiomesOPlenty.java | 2 +- .../biomesop/worldtype/BeachNoiseOctaves.java | 65 ++ .../biomesop/worldtype/BeachNoisePerlin.java | 222 ++++++ .../biomesop/worldtype/ChunkProviderBOP.java | 666 ++++++++++++++++++ .../biomesop/worldtype/WTBiomesOP.java | 2 +- .../biomesop/worldtype/WorldTypeBase.java | 6 + 7 files changed, 964 insertions(+), 2 deletions(-) create mode 100644 src/minecraft/tdwp_ftw/biomesop/worldtype/BeachNoiseOctaves.java create mode 100644 src/minecraft/tdwp_ftw/biomesop/worldtype/BeachNoisePerlin.java create mode 100644 src/minecraft/tdwp_ftw/biomesop/worldtype/ChunkProviderBOP.java diff --git a/src/minecraft/tdwp_ftw/biomesop/biomes/BiomeGenOriginValley.java b/src/minecraft/tdwp_ftw/biomesop/biomes/BiomeGenOriginValley.java index d05060eec..4d28d62dc 100644 --- a/src/minecraft/tdwp_ftw/biomesop/biomes/BiomeGenOriginValley.java +++ b/src/minecraft/tdwp_ftw/biomesop/biomes/BiomeGenOriginValley.java @@ -21,6 +21,9 @@ public class BiomeGenOriginValley extends BiomeGenBase this.customBiomeDecorator.treesPerChunk = 4; this.customBiomeDecorator.grassPerChunk = -999; this.customBiomeDecorator.generatePumpkins = false; + this.customBiomeDecorator.sandPerChunk = 0; + this.customBiomeDecorator.sandPerChunk2 = 0; + this.customBiomeDecorator.clayPerChunk = 0; } /** diff --git a/src/minecraft/tdwp_ftw/biomesop/mod_BiomesOPlenty.java b/src/minecraft/tdwp_ftw/biomesop/mod_BiomesOPlenty.java index 22accb660..d41fd84bf 100644 --- a/src/minecraft/tdwp_ftw/biomesop/mod_BiomesOPlenty.java +++ b/src/minecraft/tdwp_ftw/biomesop/mod_BiomesOPlenty.java @@ -2637,7 +2637,7 @@ public class mod_BiomesOPlenty private int oasisID; private int ominousWoodsID; private int orchardID; - private int originValleyID; + public static int originValleyID; private int outbackID; private int pastureID; private int prairieID; diff --git a/src/minecraft/tdwp_ftw/biomesop/worldtype/BeachNoiseOctaves.java b/src/minecraft/tdwp_ftw/biomesop/worldtype/BeachNoiseOctaves.java new file mode 100644 index 000000000..6169f7baf --- /dev/null +++ b/src/minecraft/tdwp_ftw/biomesop/worldtype/BeachNoiseOctaves.java @@ -0,0 +1,65 @@ +package tdwp_ftw.biomesop.worldtype; + +import java.util.Random; + +import net.minecraft.world.gen.NoiseGenerator; + +public class BeachNoiseOctaves extends NoiseGenerator +{ + private BeachNoisePerlin generatorCollection[]; + private int octaves; + + public BeachNoiseOctaves(Random random, int i) + { + octaves = i; + generatorCollection = new BeachNoisePerlin[i]; + for (int j = 0; j < i; j++) + { + generatorCollection[j] = new BeachNoisePerlin(random); + } + } + + public double func_806_a(double d, double d1) + { + double d2 = 0.0D; + double d3 = 1.0D; + for (int i = 0; i < octaves; i++) + { + d2 += generatorCollection[i].func_801_a(d * d3, d1 * d3) / d3; + d3 /= 2D; + } + + return d2; + } + + public double[] generateNoiseOctaves(double ad[], double d, double d1, double d2, + int i, int j, int k, double d3, double d4, + double d5) + { + if (ad == null) + { + ad = new double[i * j * k]; + } + else + { + for (int l = 0; l < ad.length; l++) + { + ad[l] = 0.0D; + } + } + double d6 = 1.0D; + for (int i1 = 0; i1 < octaves; i1++) + { + generatorCollection[i1].func_805_a(ad, d, d1, d2, i, j, k, d3 * d6, d4 * d6, d5 * d6, d6); + d6 /= 2D; + } + + return ad; + } + + public double[] generateNoiseOctaves(double ad[], int i, int j, int k, int l, double d, + double d1, double d2) + { + return generateNoiseOctaves(ad, i, 10D, j, k, 1, l, d, 1.0D, d1); + } +} diff --git a/src/minecraft/tdwp_ftw/biomesop/worldtype/BeachNoisePerlin.java b/src/minecraft/tdwp_ftw/biomesop/worldtype/BeachNoisePerlin.java new file mode 100644 index 000000000..20be0442f --- /dev/null +++ b/src/minecraft/tdwp_ftw/biomesop/worldtype/BeachNoisePerlin.java @@ -0,0 +1,222 @@ +package tdwp_ftw.biomesop.worldtype; + +import java.util.Random; + +import net.minecraft.world.gen.NoiseGenerator; + +public class BeachNoisePerlin extends NoiseGenerator +{ + + public BeachNoisePerlin() + { + this(new Random()); + } + + public BeachNoisePerlin(Random random) + { + permutations = new int[512]; + xCoord = random.nextDouble() * 256D; + yCoord = random.nextDouble() * 256D; + zCoord = random.nextDouble() * 256D; + for (int i = 0; i < 256; i++) + { + permutations[i] = i; + } + + for (int j = 0; j < 256; j++) + { + int k = random.nextInt(256 - j) + j; + int l = permutations[j]; + permutations[j] = permutations[k]; + permutations[k] = l; + permutations[j + 256] = permutations[j]; + } + } + + public double generateNoise(double d, double d1, double d2) + { + double d3 = d + xCoord; + double d4 = d1 + yCoord; + double d5 = d2 + zCoord; + int i = (int)d3; + int j = (int)d4; + int k = (int)d5; + if (d3 < (double)i) + { + i--; + } + if (d4 < (double)j) + { + j--; + } + if (d5 < (double)k) + { + k--; + } + int l = i & 0xff; + int i1 = j & 0xff; + int j1 = k & 0xff; + d3 -= i; + d4 -= j; + d5 -= k; + double d6 = d3 * d3 * d3 * (d3 * (d3 * 6D - 15D) + 10D); + double d7 = d4 * d4 * d4 * (d4 * (d4 * 6D - 15D) + 10D); + double d8 = d5 * d5 * d5 * (d5 * (d5 * 6D - 15D) + 10D); + int k1 = permutations[l] + i1; + int l1 = permutations[k1] + j1; + int i2 = permutations[k1 + 1] + j1; + int j2 = permutations[l + 1] + i1; + int k2 = permutations[j2] + j1; + int l2 = permutations[j2 + 1] + j1; + return lerp(d8, lerp(d7, lerp(d6, grad(permutations[l1], d3, d4, d5), grad(permutations[k2], d3 - 1.0D, d4, d5)), lerp(d6, grad(permutations[i2], d3, d4 - 1.0D, d5), grad(permutations[l2], d3 - 1.0D, d4 - 1.0D, d5))), lerp(d7, lerp(d6, grad(permutations[l1 + 1], d3, d4, d5 - 1.0D), grad(permutations[k2 + 1], d3 - 1.0D, d4, d5 - 1.0D)), lerp(d6, grad(permutations[i2 + 1], d3, d4 - 1.0D, d5 - 1.0D), grad(permutations[l2 + 1], d3 - 1.0D, d4 - 1.0D, d5 - 1.0D)))); + } + + public final double lerp(double d, double d1, double d2) + { + return d1 + d * (d2 - d1); + } + + public final double func_4110_a(int i, double d, double d1) + { + int j = i & 0xf; + double d2 = (double)(1 - ((j & 8) >> 3)) * d; + double d3 = j >= 4 ? j != 12 && j != 14 ? d1 : d : 0.0D; + return ((j & 1) != 0 ? -d2 : d2) + ((j & 2) != 0 ? -d3 : d3); + } + + public final double grad(int i, double d, double d1, double d2) + { + int j = i & 0xf; + double d3 = j >= 8 ? d1 : d; + double d4 = j >= 4 ? j != 12 && j != 14 ? d2 : d : d1; + return ((j & 1) != 0 ? -d3 : d3) + ((j & 2) != 0 ? -d4 : d4); + } + + public double func_801_a(double d, double d1) + { + return generateNoise(d, d1, 0.0D); + } + + public void func_805_a(double ad[], double d, double d1, double d2, + int i, int j, int k, double d3, double d4, + double d5, double d6) + { + if(j == 1) + { + boolean flag = false; + boolean flag1 = false; + boolean flag2 = false; + boolean flag3 = false; + double d8 = 0.0D; + double d10 = 0.0D; + int j3 = 0; + double d12 = 1.0D / d6; + for(int i4 = 0; i4 < i; i4++) + { + double d14 = (d + (double)i4) * d3 + xCoord; + int j4 = (int)d14; + if(d14 < (double)j4) + { + j4--; + } + int k4 = j4 & 0xff; + d14 -= j4; + double d17 = d14 * d14 * d14 * (d14 * (d14 * 6D - 15D) + 10D); + for(int l4 = 0; l4 < k; l4++) + { + double d19 = (d2 + (double)l4) * d5 + zCoord; + int j5 = (int)d19; + if(d19 < (double)j5) + { + j5--; + } + int l5 = j5 & 0xff; + d19 -= j5; + double d21 = d19 * d19 * d19 * (d19 * (d19 * 6D - 15D) + 10D); + int l = permutations[k4] + 0; ///bwg4 made by ted80 + int j1 = permutations[l] + l5; + int k1 = permutations[k4 + 1] + 0; + int l1 = permutations[k1] + l5; + double d9 = lerp(d17, func_4110_a(permutations[j1], d14, d19), grad(permutations[l1], d14 - 1.0D, 0.0D, d19)); + double d11 = lerp(d17, grad(permutations[j1 + 1], d14, 0.0D, d19 - 1.0D), grad(permutations[l1 + 1], d14 - 1.0D, 0.0D, d19 - 1.0D)); + double d23 = lerp(d21, d9, d11); + ad[j3++] += d23 * d12; + } + + } + + return; + } + int i1 = 0; + double d7 = 1.0D / d6; + int i2 = -1; + boolean flag4 = false; + boolean flag5 = false; + boolean flag6 = false; + boolean flag7 = false; + boolean flag8 = false; + boolean flag9 = false; + double d13 = 0.0D; + double d15 = 0.0D; + double d16 = 0.0D; + double d18 = 0.0D; + for(int i5 = 0; i5 < i; i5++) + { + double d20 = (d + (double)i5) * d3 + xCoord; + int k5 = (int)d20; + if(d20 < (double)k5) + { + k5--; + } + int i6 = k5 & 0xff; + d20 -= k5; + double d22 = d20 * d20 * d20 * (d20 * (d20 * 6D - 15D) + 10D); + for(int j6 = 0; j6 < k; j6++) + { + double d24 = (d2 + (double)j6) * d5 + zCoord; + int k6 = (int)d24; + if(d24 < (double)k6) + { + k6--; + } + int l6 = k6 & 0xff; + d24 -= k6; + double d25 = d24 * d24 * d24 * (d24 * (d24 * 6D - 15D) + 10D); + for(int i7 = 0; i7 < j; i7++) + { + double d26 = (d1 + (double)i7) * d4 + yCoord; + int j7 = (int)d26; + if(d26 < (double)j7) + { + j7--; + } + int k7 = j7 & 0xff; + d26 -= j7; + double d27 = d26 * d26 * d26 * (d26 * (d26 * 6D - 15D) + 10D); + if(i7 == 0 || k7 != i2) + { + i2 = k7; + int j2 = permutations[i6] + k7; + int k2 = permutations[j2] + l6; + int l2 = permutations[j2 + 1] + l6; + int i3 = permutations[i6 + 1] + k7; + int k3 = permutations[i3] + l6; + int l3 = permutations[i3 + 1] + l6; + d13 = lerp(d22, grad(permutations[k2], d20, d26, d24), grad(permutations[k3], d20 - 1.0D, d26, d24)); + d15 = lerp(d22, grad(permutations[l2], d20, d26 - 1.0D, d24), grad(permutations[l3], d20 - 1.0D, d26 - 1.0D, d24)); + d16 = lerp(d22, grad(permutations[k2 + 1], d20, d26, d24 - 1.0D), grad(permutations[k3 + 1], d20 - 1.0D, d26, d24 - 1.0D)); + d18 = lerp(d22, grad(permutations[l2 + 1], d20, d26 - 1.0D, d24 - 1.0D), grad(permutations[l3 + 1], d20 - 1.0D, d26 - 1.0D, d24 - 1.0D)); + } + double d28 = lerp(d27, d13, d15); + double d29 = lerp(d27, d16, d18); + double d30 = lerp(d25, d28, d29); + ad[i1++] += d30 * d7; + } + } + } + } + private int permutations[]; + public double xCoord; + public double yCoord; + public double zCoord; +} diff --git a/src/minecraft/tdwp_ftw/biomesop/worldtype/ChunkProviderBOP.java b/src/minecraft/tdwp_ftw/biomesop/worldtype/ChunkProviderBOP.java new file mode 100644 index 000000000..96eb17628 --- /dev/null +++ b/src/minecraft/tdwp_ftw/biomesop/worldtype/ChunkProviderBOP.java @@ -0,0 +1,666 @@ +package tdwp_ftw.biomesop.worldtype; + +import java.util.List; +import java.util.Random; + +import tdwp_ftw.biomesop.mod_BiomesOPlenty; +import net.minecraft.block.Block; +import net.minecraft.block.BlockSand; +import net.minecraft.entity.EnumCreatureType; +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.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.NoiseGeneratorOctaves; +import net.minecraft.world.gen.feature.MapGenScatteredFeature; +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.MapGenStronghold; +import net.minecraft.world.gen.structure.MapGenVillage; + +import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.*; +import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.*; +import net.minecraftforge.common.*; +import net.minecraftforge.event.Event.*; +import net.minecraftforge.event.terraingen.*; + +public class ChunkProviderBOP implements IChunkProvider +{ + private Random rand; + private NoiseGeneratorOctaves noiseGen1; + private NoiseGeneratorOctaves noiseGen2; + private NoiseGeneratorOctaves noiseGen3; + private NoiseGeneratorOctaves noiseGen4; + public NoiseGeneratorOctaves noiseGen5; + public NoiseGeneratorOctaves noiseGen6; + public NoiseGeneratorOctaves mobSpawnerNoise; + private World worldObj; + private final boolean mapFeaturesEnabled; + private double[] noiseArray; + 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[] noise3; + double[] noise1; + double[] noise2; + double[] noise5; + double[] noise6; + + private BeachNoiseOctaves beachnoise; + private double[] sandNoise = new double[256]; + private double[] gravelNoise = new double[256]; + + float[] parabolicField; + int[][] field_73219_j = new int[32][32]; + + { + 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 ChunkProviderBOP(World par1World, long par2, boolean par4) + { + this.worldObj = par1World; + this.mapFeaturesEnabled = par4; + this.rand = new Random(par2); + this.noiseGen1 = new NoiseGeneratorOctaves(this.rand, 16); + this.noiseGen2 = new NoiseGeneratorOctaves(this.rand, 16); + this.noiseGen3 = new NoiseGeneratorOctaves(this.rand, 8); + this.noiseGen4 = new NoiseGeneratorOctaves(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.beachnoise = new BeachNoiseOctaves(this.rand, 4); + + NoiseGeneratorOctaves[] noiseGens = {noiseGen1, noiseGen2, noiseGen3, noiseGen4, noiseGen5, noiseGen6, mobSpawnerNoise}; + noiseGens = TerrainGen.getModdedNoiseGenerators(par1World, this.rand, noiseGens); + this.noiseGen1 = noiseGens[0]; + this.noiseGen2 = noiseGens[1]; + this.noiseGen3 = noiseGens[2]; + this.noiseGen4 = noiseGens[3]; + this.noiseGen5 = noiseGens[4]; + this.noiseGen6 = noiseGens[5]; + this.mobSpawnerNoise = noiseGens[6]; + } + + /** + * Generates the shape of the terrain for the chunk though its all stone though the water is frozen if the + * temperature is low enough + */ + public void generateTerrain(int par1, int par2, byte[] par3ArrayOfByte) + { + byte b0 = 4; + byte b1 = 16; + byte b2 = 63; + int k = b0 + 1; + byte b3 = 17; + int l = b0 + 1; + this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, par1 * 4 - 2, par2 * 4 - 2, k + 5, l + 5); + this.noiseArray = this.initializeNoiseField(this.noiseArray, par1 * b0, 0, par2 * b0, k, b3, l); + + for (int i1 = 0; i1 < b0; ++i1) + { + for (int j1 = 0; j1 < b0; ++j1) + { + for (int k1 = 0; k1 < b1; ++k1) + { + double d0 = 0.125D; + double d1 = this.noiseArray[((i1 + 0) * l + j1 + 0) * b3 + k1 + 0]; + double d2 = this.noiseArray[((i1 + 0) * l + j1 + 1) * b3 + k1 + 0]; + double d3 = this.noiseArray[((i1 + 1) * l + j1 + 0) * b3 + k1 + 0]; + double d4 = this.noiseArray[((i1 + 1) * l + j1 + 1) * b3 + k1 + 0]; + double d5 = (this.noiseArray[((i1 + 0) * l + j1 + 0) * b3 + k1 + 1] - d1) * d0; + double d6 = (this.noiseArray[((i1 + 0) * l + j1 + 1) * b3 + k1 + 1] - d2) * d0; + double d7 = (this.noiseArray[((i1 + 1) * l + j1 + 0) * b3 + k1 + 1] - d3) * d0; + double d8 = (this.noiseArray[((i1 + 1) * l + j1 + 1) * b3 + k1 + 1] - d4) * d0; + + for (int l1 = 0; l1 < 8; ++l1) + { + double d9 = 0.25D; + double d10 = d1; + double d11 = d2; + double d12 = (d3 - d1) * d9; + double d13 = (d4 - d2) * d9; + + for (int i2 = 0; i2 < 4; ++i2) + { + int j2 = i2 + i1 * 4 << 11 | 0 + j1 * 4 << 7 | k1 * 8 + l1; + short short1 = 128; + j2 -= short1; + double d14 = 0.25D; + double d15 = (d11 - d10) * d14; + double d16 = d10 - d15; + + for (int k2 = 0; k2 < 4; ++k2) + { + if ((d16 += d15) > 0.0D) + { + par3ArrayOfByte[j2 += short1] = (byte)Block.stone.blockID; + } + else if (k1 * 8 + l1 < b2) + { + par3ArrayOfByte[j2 += short1] = (byte)Block.waterStill.blockID; + } + else + { + par3ArrayOfByte[j2 += short1] = 0; + } + } + + d10 += d12; + d11 += d13; + } + + d1 += d5; + d2 += d6; + d3 += d7; + d4 += d8; + } + } + } + } + } + + /** + * Replaces the stone that was placed in with blocks that match the biome + */ + public void replaceBlocksForBiome(int par1, int par2, byte[] par3ArrayOfByte, BiomeGenBase[] par4ArrayOfBiomeGenBase) + { + ChunkProviderEvent.ReplaceBiomeBlocks event = new ChunkProviderEvent.ReplaceBiomeBlocks(this, par1, par2, par3ArrayOfByte, par4ArrayOfBiomeGenBase); + MinecraftForge.EVENT_BUS.post(event); + if (event.getResult() == Result.DENY) return; + + byte b0 = 63; + double d0 = 0.03125D; + sandNoise = beachnoise.generateNoiseOctaves(sandNoise, par1 * 16, par2 * 16, 0.0D, 16, 16, 1, d0, d0, 1.0D); + gravelNoise = beachnoise.generateNoiseOctaves(gravelNoise, par1 * 16, 109.0134D, par2 * 16, 16, 1, 16, d0, 1.0D, d0); + this.stoneNoise = this.noiseGen4.generateNoiseOctaves(this.stoneNoise, par1 * 16, par2 * 16, 0, 16, 16, 1, d0 * 2.0D, d0 * 2.0D, d0 * 2.0D); + + for (int k = 0; k < 16; ++k) + { + for (int l = 0; l < 16; ++l) + { + BiomeGenBase biomegenbase = par4ArrayOfBiomeGenBase[l + k * 16]; + float f = biomegenbase.getFloatTemperature(); + int i1 = (int)(this.stoneNoise[k + l * 16] / 3.0D + 3.0D + this.rand.nextDouble() * 0.25D); + boolean sandbeach = sandNoise[k + l * 16] + rand.nextDouble() * 0.20000000000000001D > 0.0D; + boolean gravelbeach = gravelNoise[k + l * 16] + rand.nextDouble() * 0.20000000000000001D > 3D; + int j1 = -1; + byte b1 = biomegenbase.topBlock; + byte b2 = biomegenbase.fillerBlock; + + for (int k1 = 127; k1 >= 0; --k1) + { + int l1 = (l * 16 + k) * 128 + k1; + + if (k1 <= 0 + this.rand.nextInt(5)) + { + par3ArrayOfByte[l1] = (byte)Block.bedrock.blockID; + } + else + { + byte b3 = par3ArrayOfByte[l1]; + + if (b3 == 0) + { + j1 = -1; + } + else if (b3 == Block.stone.blockID) + { + if (j1 == -1) + { + if (i1 <= 0) + { + b1 = 0; + b2 = (byte)Block.stone.blockID; + } + else if (k1 >= b0 - 4 && k1 <= b0 + 1) + { + if(biomegenbase.biomeID == mod_BiomesOPlenty.originValleyID) + { + if(gravelbeach) + { + b1 = 0; + b2 = (byte)Block.gravel.blockID; + } + else if(sandbeach) + { + b1 = (byte)Block.sand.blockID; + b2 = (byte)Block.sand.blockID; + } + else + { + b1 = biomegenbase.topBlock; + b2 = biomegenbase.fillerBlock; + } + } + else + { + b1 = biomegenbase.topBlock; + b2 = biomegenbase.fillerBlock; + } + } + + if (k1 < b0 && b1 == 0) + { + if (f < 0.15F) + { + b1 = (byte)Block.ice.blockID; + } + else + { + b1 = (byte)Block.waterStill.blockID; + } + } + + j1 = i1; + + if (k1 >= b0 - 1) + { + par3ArrayOfByte[l1] = b1; + } + else + { + par3ArrayOfByte[l1] = b2; + } + } + else if (j1 > 0) + { + --j1; + par3ArrayOfByte[l1] = b2; + + if (j1 == 0 && b2 == Block.sand.blockID) + { + j1 = this.rand.nextInt(4); + b2 = (byte)Block.sandStone.blockID; + } + } + } + } + } + } + } + } + + /** + * loads or generates the chunk at the chunk location specified + */ + public Chunk loadChunk(int par1, int par2) + { + return this.provideChunk(par1, par2); + } + + /** + * Will return back a chunk, if it doesn't exist and its not a MP client it will generates all the blocks for the + * specified chunk from the map seed and chunk seed + */ + public Chunk provideChunk(int par1, int par2) + { + this.rand.setSeed((long)par1 * 341873128712L + (long)par2 * 132897987541L); + byte[] abyte = new byte[32768]; + this.generateTerrain(par1, par2, abyte); + this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, par1 * 16, par2 * 16, 16, 16); + this.replaceBlocksForBiome(par1, par2, abyte, this.biomesForGeneration); + this.caveGenerator.generate(this, this.worldObj, par1, par2, abyte); + this.ravineGenerator.generate(this, this.worldObj, par1, par2, abyte); + + if (this.mapFeaturesEnabled) + { + this.mineshaftGenerator.generate(this, this.worldObj, par1, par2, abyte); + this.villageGenerator.generate(this, this.worldObj, par1, par2, abyte); + this.strongholdGenerator.generate(this, this.worldObj, par1, par2, abyte); + this.scatteredFeatureGenerator.generate(this, this.worldObj, par1, par2, abyte); + } + + Chunk chunk = new Chunk(this.worldObj, abyte, par1, par2); + byte[] abyte1 = chunk.getBiomeArray(); + + for (int k = 0; k < abyte1.length; ++k) + { + abyte1[k] = (byte)this.biomesForGeneration[k].biomeID; + } + + chunk.generateSkylightMap(); + return chunk; + } + + /** + * generates a subset of the level's terrain data. Takes 7 arguments: the [empty] noise array, the position, and the + * size. + */ + private double[] initializeNoiseField(double[] par1ArrayOfDouble, int par2, int par3, int par4, int par5, int par6, int par7) + { + ChunkProviderEvent.InitNoiseField event = new ChunkProviderEvent.InitNoiseField(this, par1ArrayOfDouble, par2, par3, par4, par5, par6, par7); + MinecraftForge.EVENT_BUS.post(event); + if (event.getResult() == Result.DENY) return event.noisefield; + + if (par1ArrayOfDouble == null) + { + par1ArrayOfDouble = new double[par5 * par6 * par7]; + } + + if (this.parabolicField == null) + { + this.parabolicField = new float[25]; + + for (int k1 = -2; k1 <= 2; ++k1) + { + for (int l1 = -2; l1 <= 2; ++l1) + { + float f = 10.0F / MathHelper.sqrt_float((float)(k1 * k1 + l1 * l1) + 0.2F); + this.parabolicField[k1 + 2 + (l1 + 2) * 5] = f; + } + } + } + + double d0 = 684.412D; + double d1 = 684.412D; + this.noise5 = this.noiseGen5.generateNoiseOctaves(this.noise5, par2, par4, par5, par7, 1.121D, 1.121D, 0.5D); + this.noise6 = this.noiseGen6.generateNoiseOctaves(this.noise6, par2, par4, par5, par7, 200.0D, 200.0D, 0.5D); + this.noise3 = this.noiseGen3.generateNoiseOctaves(this.noise3, par2, par3, par4, par5, par6, par7, d0 / 80.0D, d1 / 160.0D, d0 / 80.0D); + this.noise1 = this.noiseGen1.generateNoiseOctaves(this.noise1, par2, par3, par4, par5, par6, par7, d0, d1, d0); + this.noise2 = this.noiseGen2.generateNoiseOctaves(this.noise2, par2, par3, par4, par5, par6, par7, d0, d1, d0); + boolean flag = false; + boolean flag1 = false; + int i2 = 0; + int j2 = 0; + + for (int k2 = 0; k2 < par5; ++k2) + { + for (int l2 = 0; l2 < par7; ++l2) + { + float f1 = 0.0F; + float f2 = 0.0F; + float f3 = 0.0F; + byte b0 = 2; + BiomeGenBase biomegenbase = this.biomesForGeneration[k2 + 2 + (l2 + 2) * (par5 + 5)]; + + for (int i3 = -b0; i3 <= b0; ++i3) + { + for (int j3 = -b0; j3 <= b0; ++j3) + { + BiomeGenBase biomegenbase1 = this.biomesForGeneration[k2 + i3 + 2 + (l2 + j3 + 2) * (par5 + 5)]; + float f4 = this.parabolicField[i3 + 2 + (j3 + 2) * 5] / (biomegenbase1.minHeight + 2.0F); + + if (biomegenbase1.minHeight > biomegenbase.minHeight) + { + f4 /= 2.0F; + } + + f1 += biomegenbase1.maxHeight * f4; + f2 += biomegenbase1.minHeight * f4; + f3 += f4; + } + } + + f1 /= f3; + f2 /= f3; + f1 = f1 * 0.9F + 0.1F; + f2 = (f2 * 4.0F - 1.0F) / 8.0F; + double d2 = this.noise6[j2] / 8000.0D; + + if (d2 < 0.0D) + { + d2 = -d2 * 0.3D; + } + + d2 = d2 * 3.0D - 2.0D; + + if (d2 < 0.0D) + { + d2 /= 2.0D; + + if (d2 < -1.0D) + { + d2 = -1.0D; + } + + d2 /= 1.4D; + d2 /= 2.0D; + } + else + { + if (d2 > 1.0D) + { + d2 = 1.0D; + } + + d2 /= 8.0D; + } + + ++j2; + + for (int k3 = 0; k3 < par6; ++k3) + { + double d3 = (double)f2; + double d4 = (double)f1; + d3 += d2 * 0.2D; + d3 = d3 * (double)par6 / 16.0D; + double d5 = (double)par6 / 2.0D + d3 * 4.0D; + double d6 = 0.0D; + double d7 = ((double)k3 - d5) * 12.0D * 128.0D / 128.0D / d4; + + if (d7 < 0.0D) + { + d7 *= 4.0D; + } + + double d8 = this.noise1[i2] / 512.0D; + double d9 = this.noise2[i2] / 512.0D; + double d10 = (this.noise3[i2] / 10.0D + 1.0D) / 2.0D; + + if (d10 < 0.0D) + { + d6 = d8; + } + else if (d10 > 1.0D) + { + d6 = d9; + } + else + { + d6 = d8 + (d9 - d8) * d10; + } + + d6 -= d7; + + if (k3 > par6 - 4) + { + double d11 = (double)((float)(k3 - (par6 - 4)) / 3.0F); + d6 = d6 * (1.0D - d11) + -10.0D * d11; + } + + par1ArrayOfDouble[i2] = d6; + ++i2; + } + } + } + + return par1ArrayOfDouble; + } + + /** + * Checks to see if a chunk exists at x, y + */ + public boolean chunkExists(int par1, int par2) + { + return true; + } + + /** + * Populates chunk with ores etc etc + */ + public void populate(IChunkProvider par1IChunkProvider, int par2, int par3) + { + BlockSand.fallInstantly = true; + int k = par2 * 16; + int l = par3 * 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)par2 * i1 + (long)par3 * j1 ^ this.worldObj.getSeed()); + boolean flag = false; + + MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(par1IChunkProvider, worldObj, rand, par2, par3, flag)); + + if (this.mapFeaturesEnabled) + { + this.mineshaftGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3); + flag = this.villageGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3); + this.strongholdGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3); + this.scatteredFeatureGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3); + } + + int k1; + int l1; + int i2; + + if (TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, flag, LAKE) && + !flag && this.rand.nextInt(4) == 0) + { + k1 = k + this.rand.nextInt(16) + 8; + l1 = this.rand.nextInt(128); + i2 = l + this.rand.nextInt(16) + 8; + (new WorldGenLakes(Block.waterStill.blockID)).generate(this.worldObj, this.rand, k1, l1, i2); + } + + if (TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, flag, LAVA) && + !flag && this.rand.nextInt(8) == 0) + { + k1 = k + this.rand.nextInt(16) + 8; + l1 = this.rand.nextInt(this.rand.nextInt(120) + 8); + i2 = l + this.rand.nextInt(16) + 8; + + if (l1 < 63 || this.rand.nextInt(10) == 0) + { + (new WorldGenLakes(Block.lavaStill.blockID)).generate(this.worldObj, this.rand, k1, l1, i2); + } + } + + boolean doGen = TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, flag, DUNGEON); + for (k1 = 0; doGen && k1 < 8; ++k1) + { + l1 = k + this.rand.nextInt(16) + 8; + i2 = this.rand.nextInt(128); + int j2 = l + this.rand.nextInt(16) + 8; + + if ((new WorldGenDungeons()).generate(this.worldObj, this.rand, l1, i2, j2)) + { + ; + } + } + + biomegenbase.decorate(this.worldObj, this.rand, k, l); + SpawnerAnimals.performWorldGenSpawning(this.worldObj, biomegenbase, k + 8, l + 8, 16, 16, this.rand); + k += 8; + l += 8; + + doGen = TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, 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, Block.ice.blockID, 0, 2); + } + + if (this.worldObj.canSnowAt(k1 + k, i2, l1 + l)) + { + this.worldObj.setBlock(k1 + k, i2, l1 + l, Block.snow.blockID, 0, 2); + } + } + } + + MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(par1IChunkProvider, worldObj, rand, par2, par3, flag)); + + BlockSand.fallInstantly = false; + } + + /** + * Two modes of operation: if passed true, save all Chunks in one go. If passed false, save up to two chunks. + * Return true if all chunks have been saved. + */ + public boolean saveChunks(boolean par1, IProgressUpdate par2IProgressUpdate) + { + return true; + } + + /** + * Unloads chunks that are marked to be unloaded. This is not guaranteed to unload every such chunk. + */ + public boolean unloadQueuedChunks() + { + return false; + } + + /** + * Returns if the IChunkProvider supports saving. + */ + public boolean canSave() + { + return true; + } + + /** + * Converts the instance data to a readable string. + */ + public String makeString() + { + return "RandomLevelSource"; + } + + /** + * Returns a list of creatures of the specified type that can spawn at the given location. + */ + public List getPossibleCreatures(EnumCreatureType par1EnumCreatureType, int par2, int par3, int par4) + { + BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(par2, par4); + return biomegenbase == null ? null : (biomegenbase == BiomeGenBase.swampland && par1EnumCreatureType == EnumCreatureType.monster && this.scatteredFeatureGenerator.hasStructureAt(par2, par3, par4) ? this.scatteredFeatureGenerator.getScatteredFeatureSpawnList() : biomegenbase.getSpawnableList(par1EnumCreatureType)); + } + + /** + * Returns the location of the closest structure of the specified type. If not found returns null. + */ + public ChunkPosition findClosestStructure(World par1World, String par2Str, int par3, int par4, int par5) + { + return "Stronghold".equals(par2Str) && this.strongholdGenerator != null ? this.strongholdGenerator.getNearestInstance(par1World, par3, par4, par5) : null; + } + + public int getLoadedChunkCount() + { + return 0; + } + + public void recreateStructures(int par1, int par2) + { + if (this.mapFeaturesEnabled) + { + this.mineshaftGenerator.generate(this, this.worldObj, par1, par2, (byte[])null); + this.villageGenerator.generate(this, this.worldObj, par1, par2, (byte[])null); + this.strongholdGenerator.generate(this, this.worldObj, par1, par2, (byte[])null); + this.scatteredFeatureGenerator.generate(this, this.worldObj, par1, par2, (byte[])null); + } + } +} diff --git a/src/minecraft/tdwp_ftw/biomesop/worldtype/WTBiomesOP.java b/src/minecraft/tdwp_ftw/biomesop/worldtype/WTBiomesOP.java index c2643fa5b..6946f0ef1 100644 --- a/src/minecraft/tdwp_ftw/biomesop/worldtype/WTBiomesOP.java +++ b/src/minecraft/tdwp_ftw/biomesop/worldtype/WTBiomesOP.java @@ -15,7 +15,7 @@ public class WTBiomesOP extends WorldTypeBase this.removeBiome(BiomeGenBase.taiga); this.removeBiome(BiomeGenBase.swampland); this.removeBiome(BiomeGenBase.jungle); - + if (mod_BiomesOPlenty.alpsGen == true) { this.addNewBiome(mod_BiomesOPlenty.alps); diff --git a/src/minecraft/tdwp_ftw/biomesop/worldtype/WorldTypeBase.java b/src/minecraft/tdwp_ftw/biomesop/worldtype/WorldTypeBase.java index db3b5604d..cf6452cca 100644 --- a/src/minecraft/tdwp_ftw/biomesop/worldtype/WorldTypeBase.java +++ b/src/minecraft/tdwp_ftw/biomesop/worldtype/WorldTypeBase.java @@ -4,6 +4,7 @@ import net.minecraft.world.World; import net.minecraft.world.WorldType; import net.minecraft.world.biome.BiomeGenBase; import net.minecraft.world.biome.WorldChunkManager; +import net.minecraft.world.chunk.IChunkProvider; public class WorldTypeBase extends WorldType { @@ -17,6 +18,11 @@ public class WorldTypeBase extends WorldType return new WorldChunkManagerBOP(var1); } + public IChunkProvider getChunkGenerator(World world, String generatorOptions) + { + return new ChunkProviderBOP(world, world.getSeed(), world.getWorldInfo().isMapFeaturesEnabled()); + } + public void removeAllBiomes() { this.removeBiome(BiomeGenBase.plains);