From 3662aced9380077feeaaba816dca52e12f95a210 Mon Sep 17 00:00:00 2001 From: SolDev69 Date: Wed, 24 Apr 2024 00:26:37 -0400 Subject: [PATCH] Revert "Deobfuscate some variables." This reverts commit b603f86c1cbd57335941524459e3a30083cd5b45. --- .../minecraft/src/ChunkProviderGenerate.java | 179 +++++++++--------- 1 file changed, 88 insertions(+), 91 deletions(-) diff --git a/src/minecraft/net/minecraft/src/ChunkProviderGenerate.java b/src/minecraft/net/minecraft/src/ChunkProviderGenerate.java index d71b04a..cd22b63 100644 --- a/src/minecraft/net/minecraft/src/ChunkProviderGenerate.java +++ b/src/minecraft/net/minecraft/src/ChunkProviderGenerate.java @@ -98,83 +98,80 @@ public class ChunkProviderGenerate implements IChunkProvider */ public void generateTerrain(BigInteger par1, BigInteger par2, byte[] par3ArrayOfByte) { - byte width1 = 4; - byte height1 = 16; - byte seaLevel = 63; -// int var7 = width1 + 1; - byte noiseHeight = 17; - int noiseWidth = width1 + 1; - this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, par1.multiply(BigInteger.valueOf(4)).subtract(BigInteger.valueOf(2)), par2.multiply(BigInteger.valueOf(4)).subtract(BigInteger.valueOf(2)), noiseWidth + 5, noiseWidth + 5); - this.noiseArray = this.initializeNoiseField(this.noiseArray, par1.multiply(BigInteger.valueOf(width1)), 0, par2.multiply(BigInteger.valueOf(width1)), noiseWidth, noiseHeight, noiseWidth); - - // Scan blocks... - for (int x1 = 0; x1 < width1; ++x1) + byte var4 = 4; + byte var5 = 16; + byte var6 = 63; + int var7 = var4 + 1; + byte var8 = 17; + int var9 = var4 + 1; + this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, par1.multiply(BigInteger.valueOf(4)).subtract(BigInteger.valueOf(2)), par2.multiply(BigInteger.valueOf(4)).subtract(BigInteger.valueOf(2)), var7 + 5, var9 + 5); + this.noiseArray = this.initializeNoiseField(this.noiseArray, par1.multiply(BigInteger.valueOf(var4)), 0, par2.multiply(BigInteger.valueOf(var4)), var7, var8, var9); + + for (int var10 = 0; var10 < var4; ++var10) { - for (int z1 = 0; z1 < width1; ++z1) + for (int var11 = 0; var11 < var4; ++var11) { - for (int y1 = 0; y1 < height1; ++y1) + for (int var12 = 0; var12 < var5; ++var12) { - // Who is faster? Is LOAD faster or LDC faster? - double step8 = 0.125D; - // Evil gradient variables. - double AA = this.noiseArray[((x1 + 0) * noiseWidth + z1 + 0) * noiseHeight + y1 + 0]; - double BB = this.noiseArray[((x1 + 0) * noiseWidth + z1 + 1) * noiseHeight + y1 + 0]; - double CC = this.noiseArray[((x1 + 1) * noiseWidth + z1 + 0) * noiseHeight + y1 + 0]; - double DD = this.noiseArray[((x1 + 1) * noiseWidth + z1 + 1) * noiseHeight + y1 + 0]; - double stepAA = (this.noiseArray[((x1 + 0) * noiseWidth + z1 + 0) * noiseHeight + y1 + 1] - AA) * step8; // Use 0.125D instead of step8 may faster??? - double stepBB = (this.noiseArray[((x1 + 0) * noiseWidth + z1 + 1) * noiseHeight + y1 + 1] - BB) * step8; - double stepCC = (this.noiseArray[((x1 + 1) * noiseWidth + z1 + 0) * noiseHeight + y1 + 1] - CC) * step8; - double stepDD = (this.noiseArray[((x1 + 1) * noiseWidth + z1 + 1) * noiseHeight + y1 + 1] - DD) * step8; - - for (int y2 = 0; y2 < 8; ++y2) + double var13 = 0.125D; + double var15 = this.noiseArray[((var10 + 0) * var9 + var11 + 0) * var8 + var12 + 0]; + double var17 = this.noiseArray[((var10 + 0) * var9 + var11 + 1) * var8 + var12 + 0]; + double var19 = this.noiseArray[((var10 + 1) * var9 + var11 + 0) * var8 + var12 + 0]; + double var21 = this.noiseArray[((var10 + 1) * var9 + var11 + 1) * var8 + var12 + 0]; + double var23 = (this.noiseArray[((var10 + 0) * var9 + var11 + 0) * var8 + var12 + 1] - var15) * var13; + double var25 = (this.noiseArray[((var10 + 0) * var9 + var11 + 1) * var8 + var12 + 1] - var17) * var13; + double var27 = (this.noiseArray[((var10 + 1) * var9 + var11 + 0) * var8 + var12 + 1] - var19) * var13; + double var29 = (this.noiseArray[((var10 + 1) * var9 + var11 + 1) * var8 + var12 + 1] - var21) * var13; + + for (int var31 = 0; var31 < 8; ++var31) { - double step4 = 0.25D; - double EE = AA; - double FF = BB; - double stepEE = (CC - AA) * step4; - double stepFF = (DD - BB) * step4; + double var32 = 0.25D; + double var34 = var15; + double var36 = var17; + double var38 = (var19 - var15) * var32; + double var40 = (var21 - var17) * var32; - for (int x2 = 0; x2 < 4; ++x2) + for (int var42 = 0; var42 < 4; ++var42) { - int xzy = x2 + x1 * 4 << 11 | 0 + z1 * 4 << 7 | y1 * 8 + y2; - short height = 128; - xzy -= height; -// double var45 = 0.25D; - double stepGG = (FF - EE) * step4; - double GG = EE - stepGG; - - for (int z2 = 0; z2 < 4; ++z2) + int var43 = var42 + var10 * 4 << 11 | 0 + var11 * 4 << 7 | var12 * 8 + var31; + short var44 = 128; + var43 -= var44; + double var45 = 0.25D; + double var49 = (var36 - var34) * var45; + double var47 = var34 - var49; + + for (int var51 = 0; var51 < 4; ++var51) { if(!ENABLE_FRINGE_LAND) { - GG += stepGG; + var47 += var49; } else { - if(z2 == 0) GG = EE; + if(var51 == 0) var47 = var34; } - if (GG > 0.0D) + if (var47 > 0.0D) { - par3ArrayOfByte[xzy += height] = (byte)Block.stone.blockID; + par3ArrayOfByte[var43 += var44] = (byte)Block.stone.blockID; } - else if (y1 * 8 + y2 < seaLevel) + else if (var12 * 8 + var31 < var6) { - par3ArrayOfByte[xzy += height] = (byte)Block.waterStill.blockID; + par3ArrayOfByte[var43 += var44] = (byte)Block.waterStill.blockID; } else { - par3ArrayOfByte[xzy += height] = 0; + par3ArrayOfByte[var43 += var44] = 0; } if(ENABLE_FRINGE_LAND) { - GG += stepGG; + var47 += var49; } } - EE += stepEE; - FF += stepFF; + var34 += var38; + var36 += var40; } - AA += stepAA; - BB += stepBB; - CC += stepCC; - DD += stepDD; + var15 += var23; + var17 += var25; + var19 += var27; + var21 += var29; } } } @@ -204,15 +201,15 @@ public class ChunkProviderGenerate implements IChunkProvider for (int var16 = 127; var16 >= 0; --var16) { - int xzy = (var9 * 16 + var8) * 128 + var16; + int var17 = (var9 * 16 + var8) * 128 + var16; if (var16 <= 0 + this.rand.nextInt(5)) { - par3ArrayOfByte[xzy] = (byte)Block.bedrock.blockID; + par3ArrayOfByte[var17] = (byte)Block.bedrock.blockID; } else { - byte var18 = par3ArrayOfByte[xzy]; + byte var18 = par3ArrayOfByte[var17]; if (var18 == 0) { @@ -249,17 +246,17 @@ public class ChunkProviderGenerate implements IChunkProvider if (var16 >= var5 - 1) { - par3ArrayOfByte[xzy] = var14; + par3ArrayOfByte[var17] = var14; } else { - par3ArrayOfByte[xzy] = var15; + par3ArrayOfByte[var17] = var15; } } else if (var13 > 0) { --var13; - par3ArrayOfByte[xzy] = var15; + par3ArrayOfByte[var17] = var15; if (var13 == 0 && var15 == Block.sand.blockID) { @@ -320,11 +317,11 @@ public class ChunkProviderGenerate implements IChunkProvider * 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[] noiseTable, BigInteger x, int y, BigInteger z, int width, int depth, int height) + private double[] initializeNoiseField(double[] par1ArrayOfDouble, BigInteger par2, int par3, BigInteger par4, int par5, int par6, int par7) { - if (noiseTable == null) + if (par1ArrayOfDouble == null) { - noiseTable = new double[width * depth * height]; + par1ArrayOfDouble = new double[par5 * par6 * par7]; } if (this.parabolicField == null) @@ -341,33 +338,33 @@ public class ChunkProviderGenerate implements IChunkProvider } } - double scaleX = 684.412D; - double scaleY = 684.412D; - this.noise5 = this.noiseGen5.generateNoiseOctaves(this.noise5, x, z, width, height, 1.121D, 1.121D, 0.5D); - this.noise6 = this.noiseGen6.generateNoiseOctaves(this.noise6, x, z, width, height, 200.0D, 200.0D, 0.5D); - this.noise3 = this.noiseGen3.generateNoiseOctaves(this.noise3, x, y, z, width, depth, height, scaleX / 80.0D, scaleY / 160.0D, scaleX / 80.0D); - this.noise1 = this.noiseGen1.generateNoiseOctaves(this.noise1, x, y, z, width, depth, height, scaleX, scaleY, scaleX); - this.noise2 = this.noiseGen2.generateNoiseOctaves(this.noise2, x, y, z, width, depth, height, scaleX, scaleY, scaleX); + double var44 = 684.412D; + double var45 = 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, var44 / 80.0D, var45 / 160.0D, var44 / 80.0D); + this.noise1 = this.noiseGen1.generateNoiseOctaves(this.noise1, par2, par3, par4, par5, par6, par7, var44, var45, var44); + this.noise2 = this.noiseGen2.generateNoiseOctaves(this.noise2, par2, par3, par4, par5, par6, par7, var44, var45, var44); boolean var43 = false; boolean var42 = false; int var12 = 0; int var13 = 0; - for (int var14 = 0; var14 < width; ++var14) + for (int var14 = 0; var14 < par5; ++var14) { - for (int var15 = 0; var15 < height; ++var15) + for (int var15 = 0; var15 < par7; ++var15) { - float maxHeight = 0.0F; - float minHeight = 0.0F; + float var16 = 0.0F; + float var17 = 0.0F; float var18 = 0.0F; byte var19 = 2; - BiomeGenBase var20 = this.biomesForGeneration[var14 + 2 + (var15 + 2) * (width + 5)]; + BiomeGenBase var20 = this.biomesForGeneration[var14 + 2 + (var15 + 2) * (par5 + 5)]; for (int var21 = -var19; var21 <= var19; ++var21) { for (int var22 = -var19; var22 <= var19; ++var22) { - BiomeGenBase var23 = this.biomesForGeneration[var14 + var21 + 2 + (var15 + var22 + 2) * (width + 5)]; + BiomeGenBase var23 = this.biomesForGeneration[var14 + var21 + 2 + (var15 + var22 + 2) * (par5 + 5)]; float var24 = this.parabolicField[var21 + 2 + (var22 + 2) * 5] / (var23.minHeight + 2.0F); if (var23.minHeight > var20.minHeight) @@ -375,16 +372,16 @@ public class ChunkProviderGenerate implements IChunkProvider var24 /= 2.0F; } - maxHeight += var23.maxHeight * var24; - minHeight += var23.minHeight * var24; + var16 += var23.maxHeight * var24; + var17 += var23.minHeight * var24; var18 += var24; } } - maxHeight /= var18; - minHeight /= var18; - maxHeight = maxHeight * 0.9F + 0.1F; - minHeight = (minHeight * 4.0F - 1.0F) / 8.0F; + var16 /= var18; + var17 /= var18; + var16 = var16 * 0.9F + 0.1F; + var17 = (var17 * 4.0F - 1.0F) / 8.0F; double var46 = this.noise6[var13] / 8000.0D; if (var46 < 0.0D) @@ -418,13 +415,13 @@ public class ChunkProviderGenerate implements IChunkProvider ++var13; - for (int var47 = 0; var47 < depth; ++var47) + for (int var47 = 0; var47 < par6; ++var47) { - double var48 = (double)minHeight; - double var26 = (double)maxHeight; + double var48 = (double)var17; + double var26 = (double)var16; var48 += var46 * 0.2D; - var48 = var48 * (double)depth / 16.0D; - double var28 = (double)depth / 2.0D + var48 * 4.0D; + var48 = var48 * (double)par6 / 16.0D; + double var28 = (double)par6 / 2.0D + var48 * 4.0D; double var30 = 0.0D; double var32 = ((double)var47 - var28) * 12.0D * 128.0D / 128.0D / var26; @@ -452,19 +449,19 @@ public class ChunkProviderGenerate implements IChunkProvider var30 -= var32; - if (var47 > depth - 4) + if (var47 > par6 - 4) { - double var40 = (double)((float)(var47 - (depth - 4)) / 3.0F); + double var40 = (double)((float)(var47 - (par6 - 4)) / 3.0F); var30 = var30 * (1.0D - var40) + -10.0D * var40; } - noiseTable[var12] = var30; + par1ArrayOfDouble[var12] = var30; ++var12; } } } - return noiseTable; + return par1ArrayOfDouble; } /**