From 5104b2d867ca9aba9d320e085df8b4f5cdceb747 Mon Sep 17 00:00:00 2001 From: mckuhei Date: Tue, 11 Apr 2023 22:58:02 +0800 Subject: [PATCH] Add 64bit perlin noise. --- .../minecraft/src/ChunkProviderGenerate.java | 53 ++--- .../net/minecraft/src/Constants.java | 14 +- .../net/minecraft/src/NoiseGenerator.java | 3 + .../minecraft/src/NoiseGeneratorOctaves.java | 34 +-- .../minecraft/src/NoiseGeneratorPerlin64.java | 212 ++++++++++++++++++ 5 files changed, 276 insertions(+), 40 deletions(-) create mode 100644 src/minecraft/net/minecraft/src/NoiseGeneratorPerlin64.java diff --git a/src/minecraft/net/minecraft/src/ChunkProviderGenerate.java b/src/minecraft/net/minecraft/src/ChunkProviderGenerate.java index 9153f4b..c0ba376 100644 --- a/src/minecraft/net/minecraft/src/ChunkProviderGenerate.java +++ b/src/minecraft/net/minecraft/src/ChunkProviderGenerate.java @@ -176,7 +176,7 @@ public class ChunkProviderGenerate implements IChunkProvider byte var5 = 63; double var6 = 0.03125D; // Must swap y and z - this.stoneNoise = this.noiseGen4.generateNoiseOctaves(this.stoneNoise, par1.shiftLeft(4), 0, par2.shiftLeft(4), 16, 1, 16, var6 * 2.0D, var6 * 2.0D, var6 * 2.0D); + this.stoneNoise = this.noiseGen4.generateNoiseOctaves(this.stoneNoise, par1.shiftLeft(4), par2.shiftLeft(4), BigInteger.ZERO, 16, 1, 16, var6 * 2.0D, var6 * 2.0D, var6 * 2.0D); for (int var8 = 0; var8 < 16; ++var8) { @@ -471,58 +471,59 @@ public class ChunkProviderGenerate implements IChunkProvider BigInteger var4 = par2.shiftLeft(4); BigInteger var5 = par3.shiftLeft(4); BiomeGenBase var6 = this.worldObj.getBiomeGenForCoords(var4.add(BigInteger.valueOf(16)), var5.add(BigInteger.valueOf(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)par2.longValue() * var7 + (long)par3.longValue() * var9 ^ this.worldObj.getSeed()); + Random rand = new Random(); + rand.setSeed(this.worldObj.getSeed()); + long var7 = rand.nextLong() / 2L * 2L + 1L; + long var9 = rand.nextLong() / 2L * 2L + 1L; + rand.setSeed((long)par2.longValue() * var7 + (long)par3.longValue() * var9 ^ this.worldObj.getSeed()); boolean var11 = false; if (this.mapFeaturesEnabled) { - this.mineshaftGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3); - var11 = 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); + this.mineshaftGenerator.generateStructuresInChunk(this.worldObj, rand, par2, par3); + var11 = this.villageGenerator.generateStructuresInChunk(this.worldObj, rand, par2, par3); + this.strongholdGenerator.generateStructuresInChunk(this.worldObj, rand, par2, par3); + this.scatteredFeatureGenerator.generateStructuresInChunk(this.worldObj, rand, par2, par3); } BigInteger x; int y; BigInteger z; - if (!var11 && this.rand.nextInt(4) == 0) + if (!var11 && rand.nextInt(4) == 0) { - x = var4.add(BigInteger.valueOf(this.rand.nextInt(16))).add(BigInteger.valueOf(8)); - y = this.rand.nextInt(128); - z = var5.add(BigInteger.valueOf(this.rand.nextInt(16))).add(BigInteger.valueOf(8)); - (new WorldGenLakes(Block.waterStill.blockID)).generate(this.worldObj, this.rand, x, y, z); + x = var4.add(BigInteger.valueOf(rand.nextInt(16))).add(BigInteger.valueOf(8)); + y = rand.nextInt(128); + z = var5.add(BigInteger.valueOf(rand.nextInt(16))).add(BigInteger.valueOf(8)); + (new WorldGenLakes(Block.waterStill.blockID)).generate(this.worldObj, rand, x, y, z); } - if (!var11 && this.rand.nextInt(8) == 0) + if (!var11 && rand.nextInt(8) == 0) { - x = var4.add(BigInteger.valueOf(this.rand.nextInt(16))).add(BigInteger.valueOf(8)); - y = this.rand.nextInt(this.rand.nextInt(120) + 8); - z = var5.add(BigInteger.valueOf(this.rand.nextInt(16))).add(BigInteger.valueOf(8)); + x = var4.add(BigInteger.valueOf(rand.nextInt(16))).add(BigInteger.valueOf(8)); + y = rand.nextInt(rand.nextInt(120) + 8); + z = var5.add(BigInteger.valueOf(rand.nextInt(16))).add(BigInteger.valueOf(8)); - if (y < 63 || this.rand.nextInt(10) == 0) + if (y < 63 || rand.nextInt(10) == 0) { - (new WorldGenLakes(Block.lavaStill.blockID)).generate(this.worldObj, this.rand, x, y, z); + (new WorldGenLakes(Block.lavaStill.blockID)).generate(this.worldObj, rand, x, y, z); } } for (int i = 0; i < 8; ++i) { - x = var4.add(BigInteger.valueOf(this.rand.nextInt(16))).add(BigInteger.valueOf(8)); - y = this.rand.nextInt(128); - z = var5.add(BigInteger.valueOf(this.rand.nextInt(16))).add(BigInteger.valueOf(8)); + x = var4.add(BigInteger.valueOf(rand.nextInt(16))).add(BigInteger.valueOf(8)); + y = rand.nextInt(128); + z = var5.add(BigInteger.valueOf(rand.nextInt(16))).add(BigInteger.valueOf(8)); - if ((new WorldGenDungeons()).generate(this.worldObj, this.rand, x, y, z)) + if ((new WorldGenDungeons()).generate(this.worldObj, rand, x, y, z)) { ; } } // FIXME: java.lang.RuntimeException: Already decorating!! - var6.decorate(this.worldObj, this.rand, var4, var5); - SpawnerAnimals.performWorldGenSpawning(this.worldObj, var6, var4.add(BigInteger.valueOf(8)), var5.add(BigInteger.valueOf(8)), 16, 16, this.rand); + var6.decorate(this.worldObj, rand, var4, var5); + SpawnerAnimals.performWorldGenSpawning(this.worldObj, var6, var4.add(BigInteger.valueOf(8)), var5.add(BigInteger.valueOf(8)), 16, 16, rand); var4 = var4.add(BigInteger.valueOf(8)); var5 = var5.add(BigInteger.valueOf(8)); diff --git a/src/minecraft/net/minecraft/src/Constants.java b/src/minecraft/net/minecraft/src/Constants.java index 82f0724..a96711e 100644 --- a/src/minecraft/net/minecraft/src/Constants.java +++ b/src/minecraft/net/minecraft/src/Constants.java @@ -1,5 +1,17 @@ package net.minecraft.src; -public class Constants { +import java.lang.reflect.Field; +public class Constants { + public static final boolean DISABLE_MODULO = false, + USE_64BIT_PERLIN_GENERATOR = false; + + static { + Class cls = Constants.class; + try { + for(Field f : cls.getDeclaredFields()) f.setBoolean(null, Boolean.getBoolean(cls.getName() + "." + f.getName())); + } catch(Throwable t) { + throw new RuntimeException(t); + } + } } diff --git a/src/minecraft/net/minecraft/src/NoiseGenerator.java b/src/minecraft/net/minecraft/src/NoiseGenerator.java index a3a9211..5fb11f1 100644 --- a/src/minecraft/net/minecraft/src/NoiseGenerator.java +++ b/src/minecraft/net/minecraft/src/NoiseGenerator.java @@ -2,4 +2,7 @@ package net.minecraft.src; public abstract class NoiseGenerator { + public void populateNoiseArray(double[] par1ArrayOfDouble, double par2, double par4, double par6, int par8, int par9, int par10, double par11, double par13, double par15, double par17) { + + } } diff --git a/src/minecraft/net/minecraft/src/NoiseGeneratorOctaves.java b/src/minecraft/net/minecraft/src/NoiseGeneratorOctaves.java index 9fc2cc5..a09c370 100644 --- a/src/minecraft/net/minecraft/src/NoiseGeneratorOctaves.java +++ b/src/minecraft/net/minecraft/src/NoiseGeneratorOctaves.java @@ -3,22 +3,24 @@ package net.minecraft.src; import org.mcmodule.math.BigInteger; import java.util.Random; +import static net.minecraft.src.Constants.*; + public class NoiseGeneratorOctaves extends NoiseGenerator { /** * Collection of noise generation functions. Output is combined to produce different octaves of noise. */ - private NoiseGeneratorPerlin[] generatorCollection; + private NoiseGenerator[] generatorCollection; private int octaves; public NoiseGeneratorOctaves(Random par1Random, int par2) { this.octaves = par2; - this.generatorCollection = new NoiseGeneratorPerlin[par2]; + this.generatorCollection = new NoiseGenerator[par2]; for (int var3 = 0; var3 < par2; ++var3) { - this.generatorCollection[var3] = new NoiseGeneratorPerlin(par1Random); + this.generatorCollection[var3] = USE_64BIT_PERLIN_GENERATOR ? new NoiseGeneratorPerlin64(par1Random) : new NoiseGeneratorPerlin(par1Random); } } @@ -26,7 +28,7 @@ public class NoiseGeneratorOctaves extends NoiseGenerator * pars:(par2,3,4=noiseOffset ; so that adjacent noise segments connect) (pars5,6,7=x,y,zArraySize),(pars8,10,12 = * x,y,z noiseScale) */ - public double[] generateNoiseOctaves(double[] par1ArrayOfDouble, BigInteger par2, int par3, BigInteger par4, int par5, int par6, int par7, double par8, double par10, double par12) + public double[] generateNoiseOctaves(double[] par1ArrayOfDouble, BigInteger par2, BigInteger par3, BigInteger par4, int par5, int par6, int par7, double par8, double par10, double par12) { if (par1ArrayOfDouble == null) { @@ -45,22 +47,28 @@ public class NoiseGeneratorOctaves extends NoiseGenerator for (int var16 = 0; var16 < this.octaves; ++var16) { double var17 = (double)par2.doubleValue() * var27 * par8; - double var19 = (double)par3 * var27 * par10; + double var19 = (double)par3.doubleValue() * var27 * par10; double var21 = (double)par4.doubleValue() * var27 * par12; - long var23 = MathHelper.floor_double_long(var17); - long var25 = MathHelper.floor_double_long(var21); - var17 -= (double)var23; - var21 -= (double)var25; - var23 %= 16777216L; - var25 %= 16777216L; - var17 += (double)var23; - var21 += (double)var25; + if(!DISABLE_MODULO) { + long var23 = MathHelper.floor_double_long(var17); + long var25 = MathHelper.floor_double_long(var21); + var17 -= (double)var23; + var21 -= (double)var25; + var23 %= 16777216L; + var25 %= 16777216L; + var17 += (double)var23; + var21 += (double)var25; + } this.generatorCollection[var16].populateNoiseArray(par1ArrayOfDouble, var17, var19, var21, par5, par6, par7, par8 * var27, par10 * var27, par12 * var27, var27); var27 /= 2.0D; } return par1ArrayOfDouble; } + + public double[] generateNoiseOctaves(double[] par1ArrayOfDouble, BigInteger par2, int par3, BigInteger par4, int par5, int par6, int par7, double par8, double par10, double par12) { + return this.generateNoiseOctaves(par1ArrayOfDouble, par2, BigInteger.valueOf(par3), par4, par5, par6, par7, par8, par10, par12); + } /** * Bouncer function to the main one with some default arguments. diff --git a/src/minecraft/net/minecraft/src/NoiseGeneratorPerlin64.java b/src/minecraft/net/minecraft/src/NoiseGeneratorPerlin64.java new file mode 100644 index 0000000..e368ea4 --- /dev/null +++ b/src/minecraft/net/minecraft/src/NoiseGeneratorPerlin64.java @@ -0,0 +1,212 @@ +package net.minecraft.src; + +import java.util.Random; + +public class NoiseGeneratorPerlin64 extends NoiseGenerator +{ + private int[] permutations; + public double xCoord; + public double yCoord; + public double zCoord; + + public NoiseGeneratorPerlin64() + { + this(new Random()); + } + + public NoiseGeneratorPerlin64(Random par1Random) + { + this.permutations = new int[512]; + this.xCoord = par1Random.nextDouble() * 256.0D; + this.yCoord = par1Random.nextDouble() * 256.0D; + this.zCoord = par1Random.nextDouble() * 256.0D; + int var2; + + for (var2 = 0; var2 < 256; this.permutations[var2] = var2++) + { + ; + } + + for (var2 = 0; var2 < 256; ++var2) + { + int var3 = par1Random.nextInt(256 - var2) + var2; + int var4 = this.permutations[var2]; + this.permutations[var2] = this.permutations[var3]; + this.permutations[var3] = var4; + this.permutations[var2 + 256] = this.permutations[var2]; + } + } + + public final double lerp(double par1, double par3, double par5) + { + return par3 + par1 * (par5 - par3); + } + + public final double func_76309_a(int par1, double par2, double par4) + { + int var6 = par1 & 15; + double var7 = (double)(1 - ((var6 & 8) >> 3)) * par2; + double var9 = var6 < 4 ? 0.0D : (var6 != 12 && var6 != 14 ? par4 : par2); + return ((var6 & 1) == 0 ? var7 : -var7) + ((var6 & 2) == 0 ? var9 : -var9); + } + + public final double grad(int par1, double par2, double par4, double par6) + { + int var8 = par1 & 15; + double var9 = var8 < 8 ? par2 : par4; + double var11 = var8 < 4 ? par4 : (var8 != 12 && var8 != 14 ? par6 : par2); + return ((var8 & 1) == 0 ? var9 : -var9) + ((var8 & 2) == 0 ? var11 : -var11); + } + + /** + * pars: noiseArray , xOffset , yOffset , zOffset , xSize , ySize , zSize , xScale, yScale , zScale , noiseScale. + * noiseArray should be xSize*ySize*zSize in size + */ + public void populateNoiseArray(double[] par1ArrayOfDouble, double par2, double par4, double par6, int par8, int par9, int par10, double par11, double par13, double par15, double par17) + { + int var10001; + int var19; + int var22; + double var31; + double var35; + int var37; + double var38; + long var40; + int var41; + double var42; + int var75; + + if (par9 == 1) + { + boolean var64 = false; + boolean var65 = false; + boolean var21 = false; + boolean var68 = false; + double var70 = 0.0D; + double var73 = 0.0D; + var75 = 0; + double var77 = 1.0D / par17; + + for (int var30 = 0; var30 < par8; ++var30) + { + var31 = par2 + (double)var30 * par11 + this.xCoord; + int var78 = (int)var31; + + if (var31 < (double)var78) + { + --var78; + } + + int var34 = var78 & 255; + var31 -= (double)var78; + var35 = var31 * var31 * var31 * (var31 * (var31 * 6.0D - 15.0D) + 10.0D); + + for (var37 = 0; var37 < par10; ++var37) + { + var38 = par6 + (double)var37 * par15 + this.zCoord; + var40 = (long)var38; + + if (var38 < (double)var40) + { + --var40; + } + + var41 = (int) (var40 & 255); + var38 -= (double)var40; + var42 = var38 * var38 * var38 * (var38 * (var38 * 6.0D - 15.0D) + 10.0D); + var19 = this.permutations[var34] + 0; + int var66 = (int) (this.permutations[var19] + var41); + int var67 = this.permutations[var34 + 1] + 0; + var22 = (int) (this.permutations[var67] + var41); + var70 = this.lerp(var35, this.func_76309_a(this.permutations[var66], var31, var38), this.grad(this.permutations[var22], var31 - 1.0D, 0.0D, var38)); + var73 = this.lerp(var35, this.grad(this.permutations[var66 + 1], var31, 0.0D, var38 - 1.0D), this.grad(this.permutations[var22 + 1], var31 - 1.0D, 0.0D, var38 - 1.0D)); + double var79 = this.lerp(var42, var70, var73); + var10001 = var75++; + par1ArrayOfDouble[var10001] += (var79 * var77); + } + } + } + else + { + var19 = 0; + double var20 = 1.0D / par17; + var22 = -1; + boolean var23 = false; + boolean var24 = false; + boolean var25 = false; + boolean var26 = false; + boolean var27 = false; + boolean var28 = false; + double var29 = 0.0D; + var31 = 0.0D; + double var33 = 0.0D; + var35 = 0.0D; + + for (var37 = 0; var37 < par8; ++var37) + { + var38 = par2 + (double)var37 * par11 + this.xCoord; + var40 = (long)var38; + + if (var38 < (double)var40) + { + --var40; + } + + var41 = (int) (var40 & 255); + var38 -= (double)var40; + var42 = var38 * var38 * var38 * (var38 * (var38 * 6.0D - 15.0D) + 10.0D); + + for (int var44 = 0; var44 < par10; ++var44) + { + double var45 = par6 + (double)var44 * par15 + this.zCoord; + long var47 = (long)var45; + + if (var45 < (double)var47) + { + --var47; + } + + int var48 = (int) (var47 & 255); + var45 -= (double)var47; + double var49 = var45 * var45 * var45 * (var45 * (var45 * 6.0D - 15.0D) + 10.0D); + + for (int var51 = 0; var51 < par9; ++var51) + { + double var52 = par4 + (double)var51 * par13 + this.yCoord; + long var54 = (long)var52; + + if (var52 < (double)var54) + { + --var54; + } + + int var55 = (int) (var54 & 255); + var52 -= (double)var54; + double var56 = var52 * var52 * var52 * (var52 * (var52 * 6.0D - 15.0D) + 10.0D); + + if (var51 == 0 || var55 != var22) + { + var22 = var55; + int var69 = this.permutations[var41] + var55; + int var71 = this.permutations[var69] + var48; + int var72 = this.permutations[var69 + 1] + var48; + int var74 = this.permutations[var41 + 1] + var55; + var75 = this.permutations[var74] + var48; + int var76 = this.permutations[var74 + 1] + var48; + var29 = this.lerp(var42, this.grad(this.permutations[var71], var38, var52, var45), this.grad(this.permutations[var75], var38 - 1.0D, var52, var45)); + var31 = this.lerp(var42, this.grad(this.permutations[var72], var38, var52 - 1.0D, var45), this.grad(this.permutations[var76], var38 - 1.0D, var52 - 1.0D, var45)); + var33 = this.lerp(var42, this.grad(this.permutations[var71 + 1], var38, var52, var45 - 1.0D), this.grad(this.permutations[var75 + 1], var38 - 1.0D, var52, var45 - 1.0D)); + var35 = this.lerp(var42, this.grad(this.permutations[var72 + 1], var38, var52 - 1.0D, var45 - 1.0D), this.grad(this.permutations[var76 + 1], var38 - 1.0D, var52 - 1.0D, var45 - 1.0D)); + } + + double var58 = this.lerp(var56, var29, var31); + double var60 = this.lerp(var56, var33, var35); + double var62 = this.lerp(var49, var58, var60); + var10001 = var19++; + par1ArrayOfDouble[var10001] += (var62 * var20); + } + } + } + } + } +}