diff --git a/src/minecraft/Start.java b/src/minecraft/Start.java index bbc3dcc..eb78b08 100644 --- a/src/minecraft/Start.java +++ b/src/minecraft/Start.java @@ -1,6 +1,8 @@ import java.io.File; import java.lang.reflect.Field; +import javax.imageio.ImageIO; + import net.minecraft.client.Minecraft; public class Start @@ -21,4 +23,8 @@ public class Start Minecraft.main(args); } + + static { + ImageIO.setUseCache(false); + } } diff --git a/src/minecraft/net/minecraft/src/ChunkProviderGenerate.java b/src/minecraft/net/minecraft/src/ChunkProviderGenerate.java index da703a2..52be32c 100644 --- a/src/minecraft/net/minecraft/src/ChunkProviderGenerate.java +++ b/src/minecraft/net/minecraft/src/ChunkProviderGenerate.java @@ -98,80 +98,83 @@ public class ChunkProviderGenerate implements IChunkProvider */ public void generateTerrain(BigInteger par1, BigInteger par2, byte[] par3ArrayOfByte) { - byte var4 = 4; - byte var5 = 32; - byte var6 = 63; - int var7 = var4 + 1; - byte var8 = 33; - 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, 17); - - for (int var10 = 0; var10 < var4; ++var10) + byte width1 = 4; + byte height1 = 32; + byte seaLevel = 63; +// int var7 = var4 + 1; + byte noiseHeight = 33; + 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, 17); + + // Scan blocks... + for (int x1 = 0; x1 < width1; ++x1) { - for (int var11 = 0; var11 < var4; ++var11) + for (int z1 = 0; z1 < width1; ++z1) { - for (int var12 = 0; var12 < var5; ++var12) + for (int y1 = 0; y1 < height1; ++y1) { - 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) + // 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 var32 = 0.25D; - double var34 = var15; - double var36 = var17; - double var38 = (var19 - var15) * var32; - double var40 = (var21 - var17) * var32; + double step4 = 0.25D; + double EE = AA; + double FF = BB; + double stepEE = (CC - AA) * step4; + double stepFF = (DD - BB) * step4; - for (int var42 = 0; var42 < 4; ++var42) + for (int x2 = 0; x2 < 4; ++x2) { - int var43 = var42 + var10 * 4 << 12 | 0 + var11 * 4 << 8 | var12 * 8 + var31; - short var44 = 256; - var43 -= var44; - double var45 = 0.25D; - double var49 = (var36 - var34) * var45; - double var47 = var34 - var49; - - for (int var51 = 0; var51 < 4; ++var51) + int xzy = x2 + x1 * 4 << 12 | 0 + z1 * 4 << 8 | y1 * 8 + y2; + short height = 256; + xzy -= height; +// double var45 = 0.25D; + double stepGG = (FF - EE) * step4; + double GG = EE - stepGG; + + for (int z2 = 0; z2 < 4; ++z2) { if(!ENABLE_FRINGE_LAND) { - var47 += var49; + GG += stepGG; } else { - if(var51 == 0) var47 = var34; + if(z2 == 0) GG = EE; } - if (var47 > 0.0D) + if (GG > 0.0D) { - par3ArrayOfByte[var43 += var44] = (byte)Block.stone.blockID; + par3ArrayOfByte[xzy += height] = (byte)Block.stone.blockID; } - else if (var12 * 8 + var31 < var6) + else if (y1 * 8 + y2 < seaLevel) { - par3ArrayOfByte[var43 += var44] = (byte)Block.waterStill.blockID; + par3ArrayOfByte[xzy += height] = (byte)Block.waterStill.blockID; } else { - par3ArrayOfByte[var43 += var44] = 0; + par3ArrayOfByte[xzy += height] = 0; } if(ENABLE_FRINGE_LAND) { - var47 += var49; + GG += stepGG; } } - var34 += var38; - var36 += var40; + EE += stepEE; + FF += stepFF; } - var15 += var23; - var17 += var25; - var19 += var27; - var21 += var29; + AA += stepAA; + BB += stepBB; + CC += stepCC; + DD += stepDD; } } } @@ -327,11 +330,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[] par1ArrayOfDouble, BigInteger par2, int par3, BigInteger par4, int par5, int par6, int par7, int par8) + private double[] initializeNoiseField(double[] noiseTable, BigInteger x, int y, BigInteger z, int width, int depth, int height, int par8) { - if (par1ArrayOfDouble == null) + if (noiseTable == null) { - par1ArrayOfDouble = new double[par5 * par6 * par7]; + noiseTable = new double[width * depth * height]; } if (this.parabolicField == null) @@ -348,33 +351,33 @@ public class ChunkProviderGenerate implements IChunkProvider } } - 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); + 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); boolean var43 = false; boolean var42 = false; int var12 = 0; int var13 = 0; - for (int var14 = 0; var14 < par5; ++var14) + for (int var14 = 0; var14 < width; ++var14) { - for (int var15 = 0; var15 < par7; ++var15) + for (int var15 = 0; var15 < height; ++var15) { - float var16 = 0.0F; - float var17 = 0.0F; + float maxHeight = 0.0F; + float minHeight = 0.0F; float var18 = 0.0F; byte var19 = 2; - BiomeGenBase var20 = this.biomesForGeneration[var14 + 2 + (var15 + 2) * (par5 + 5)]; + BiomeGenBase var20 = this.biomesForGeneration[var14 + 2 + (var15 + 2) * (width + 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) * (par5 + 5)]; + BiomeGenBase var23 = this.biomesForGeneration[var14 + var21 + 2 + (var15 + var22 + 2) * (width + 5)]; float var24 = this.parabolicField[var21 + 2 + (var22 + 2) * 5] / (var23.minHeight + 2.0F); if (var23.minHeight > var20.minHeight) @@ -382,16 +385,16 @@ public class ChunkProviderGenerate implements IChunkProvider var24 /= 2.0F; } - var16 += var23.maxHeight * var24; - var17 += var23.minHeight * var24; + maxHeight += var23.maxHeight * var24; + minHeight += var23.minHeight * var24; var18 += var24; } } - var16 /= var18; - var17 /= var18; - var16 = var16 * 0.9F + 0.1F; - var17 = (var17 * 4.0F - 1.0F) / 8.0F; + maxHeight /= var18; + minHeight /= var18; + maxHeight = maxHeight * 0.9F + 0.1F; + minHeight = (minHeight * 4.0F - 1.0F) / 8.0F; double var46 = this.noise6[var13] / 8000.0D; if (var46 < 0.0D) @@ -425,14 +428,14 @@ public class ChunkProviderGenerate implements IChunkProvider ++var13; - double var48 = (double)var17; - double var26 = (double)var16; + double var48 = (double)minHeight; + double var26 = (double)maxHeight; var48 += var46 * 0.2D; var48 = var48 * (double)par8 / 16.0D; - double var28 = (double)par8 / 2.0D + var48 * 4.0D - par3; + double var28 = (double)par8 / 2.0D + var48 * 4.0D - y; double var30 = 0.0D; - for (int var47 = 0; var47 < par6; ++var47) + for (int var47 = 0; var47 < depth; ++var47) { double var32 = ((double)var47 - var28) * 12.0D * 128.0D / 128.0D / var26; @@ -460,19 +463,19 @@ public class ChunkProviderGenerate implements IChunkProvider var30 -= var32; - if (var47 > par6 - 4) + if (var47 > depth - 4) { - double var40 = (double)((float)(var47 - (par6 - 4)) / 3.0F); + double var40 = (double)((float)(var47 - (depth - 4)) / 3.0F); var30 = var30 * (1.0D - var40) + -10.0D * var40; } - par1ArrayOfDouble[var12] = var30; + noiseTable[var12] = var30; ++var12; } } } - return par1ArrayOfDouble; + return noiseTable; } // FIXME diff --git a/src/minecraft/net/minecraft/src/MathHelper.java b/src/minecraft/net/minecraft/src/MathHelper.java index 4c02b95..2fbb459 100644 --- a/src/minecraft/net/minecraft/src/MathHelper.java +++ b/src/minecraft/net/minecraft/src/MathHelper.java @@ -141,6 +141,11 @@ public class MathHelper { return par0 < par1 ? par1 : (par0 > par2 ? par2 : par0); } + + public static double clamp_double(double par0, double par1, double par2) + { + return par0 < par1 ? par1 : (par0 > par2 ? par2 : par0); + } /** * Maximum of the absolute value of two numbers. diff --git a/src/minecraft/net/minecraft/src/NetServerHandler.java b/src/minecraft/net/minecraft/src/NetServerHandler.java index f846cbe..aa89c79 100644 --- a/src/minecraft/net/minecraft/src/NetServerHandler.java +++ b/src/minecraft/net/minecraft/src/NetServerHandler.java @@ -128,13 +128,14 @@ public class NetServerHandler extends NetHandler if (!this.field_72587_r) { -// var3 = par1Packet10Flying.yPosition - this.lastPosY; -// -// if (par1Packet10Flying.xPosition.compareTo(this.lastPosX) == 0 && var3 * var3 < 0.01D && par1Packet10Flying.zPosition.compareTo(this.lastPosZ) == 0) -// { -// this.field_72587_r = true; -// } - this.field_72587_r = true; + var3 = par1Packet10Flying.yPosition - this.lastPosY; + + if (par1Packet10Flying.xPosition.compareTo(this.lastPosX) == 0 && var3 * var3 < 0.01D && par1Packet10Flying.zPosition.compareTo(this.lastPosZ) == 0) + { + this.field_72587_r = true; + } else { + this.playerEntity.serverForThisPlayer.sendPacketToPlayer(new Packet11PlayerPosition(this.lastPosX, this.lastPosY + 1.6200000047683716D, this.lastPosY, this.lastPosZ, false)); + } } if (this.field_72587_r) diff --git a/src/minecraft/net/minecraft/src/NoiseGeneratorPerlin16.java b/src/minecraft/net/minecraft/src/NoiseGeneratorPerlin16.java new file mode 100644 index 0000000..52211f6 --- /dev/null +++ b/src/minecraft/net/minecraft/src/NoiseGeneratorPerlin16.java @@ -0,0 +1,217 @@ +package net.minecraft.src; + +import java.util.Random; + +import static net.minecraft.src.Constants.*; + +public class NoiseGeneratorPerlin16 extends NoiseGenerator +{ + private int[] permutations; + public double xCoord; + public double yCoord; + public double zCoord; + + public NoiseGeneratorPerlin16() + { + this(new Random()); + } + + public NoiseGeneratorPerlin16(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 grad2d(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 grad3d(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); + } + + private double floor(double value) { + return MathHelper.clamp_double(value < 0 ? Math.floor(value) + 1 : Math.floor(value), -32768D, 32767D); + } + + /** + * 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; + 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; + double var78 = floor(var31); + + if (var31 < (double)var78) + { + --var78; + } + + int var34 = (int) (var78 % 256D) & 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; + double var40 = floor(var38); + + if (var38 < (double)var40) + { + --var40; + } + + var41 = (int) (var40 % 256D) & 255; + var38 -= (double)var40; + var42 = var38 * var38 * var38 * (var38 * (var38 * 6.0D - 15.0D) + 10.0D); + var19 = this.permutations[var34] + 0; + int var66 = this.permutations[var19] + var41; + int var67 = this.permutations[var34 + 1] + 0; + var22 = this.permutations[var67] + var41; + var70 = this.lerp(var35, this.grad2d(this.permutations[var66], var31, var38), this.grad3d(this.permutations[var22], var31 - 1.0D, 0.0D, var38)); + var73 = this.lerp(var35, this.grad3d(this.permutations[var66 + 1], var31, 0.0D, var38 - 1.0D), this.grad3d(this.permutations[var22 + 1], var31 - 1.0D, 0.0D, var38 - 1.0D)); + double var79 = this.lerp(var42, var70, var73); + var10001 = var75++; + par1ArrayOfDouble[var10001] += FLOAT_PERLIN_GENERATOR ? (float) (var79 * var77) : 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; + double var40 = floor(var38); + + if (var38 < (double)var40) + { + --var40; + } + + var41 = (int) (var40 % 256D) & 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; + double var47 = floor(var45); + + if (var45 < (double)var47) + { + --var47; + } + + int var48 = (int) (var47 % 256D) & 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; + double var54 = floor(var52); + + if (var52 < (double)var54) + { + --var54; + } + + int var55 = (int) (var54 % 256D) & 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.grad3d(this.permutations[var71], var38, var52, var45), this.grad3d(this.permutations[var75], var38 - 1.0D, var52, var45)); + var31 = this.lerp(var42, this.grad3d(this.permutations[var72], var38, var52 - 1.0D, var45), this.grad3d(this.permutations[var76], var38 - 1.0D, var52 - 1.0D, var45)); + var33 = this.lerp(var42, this.grad3d(this.permutations[var71 + 1], var38, var52, var45 - 1.0D), this.grad3d(this.permutations[var75 + 1], var38 - 1.0D, var52, var45 - 1.0D)); + var35 = this.lerp(var42, this.grad3d(this.permutations[var72 + 1], var38, var52 - 1.0D, var45 - 1.0D), this.grad3d(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] += FLOAT_PERLIN_GENERATOR ? (float) (var62 * var20) : var62 * var20; + } + } + } + } + } +} diff --git a/src/minecraft/net/minecraft/src/NoiseGeneratorPerlin2.java b/src/minecraft/net/minecraft/src/NoiseGeneratorPerlinDouble.java similarity index 98% rename from src/minecraft/net/minecraft/src/NoiseGeneratorPerlin2.java rename to src/minecraft/net/minecraft/src/NoiseGeneratorPerlinDouble.java index b05128b..5f2f2b6 100644 --- a/src/minecraft/net/minecraft/src/NoiseGeneratorPerlin2.java +++ b/src/minecraft/net/minecraft/src/NoiseGeneratorPerlinDouble.java @@ -4,19 +4,19 @@ import java.util.Random; import static net.minecraft.src.Constants.*; -public class NoiseGeneratorPerlin2 extends NoiseGenerator +public class NoiseGeneratorPerlinDouble extends NoiseGenerator { private int[] permutations; public double xCoord; public double yCoord; public double zCoord; - public NoiseGeneratorPerlin2() + public NoiseGeneratorPerlinDouble() { this(new Random()); } - public NoiseGeneratorPerlin2(Random par1Random) + public NoiseGeneratorPerlinDouble(Random par1Random) { this.permutations = new int[512]; this.xCoord = par1Random.nextDouble() * 256.0D; diff --git a/src/minecraft/net/minecraft/src/NoiseGeneratorPerlinFloat.java b/src/minecraft/net/minecraft/src/NoiseGeneratorPerlinFloat.java new file mode 100644 index 0000000..1fd5819 --- /dev/null +++ b/src/minecraft/net/minecraft/src/NoiseGeneratorPerlinFloat.java @@ -0,0 +1,217 @@ +package net.minecraft.src; + +import java.util.Random; + +import static net.minecraft.src.Constants.*; + +public class NoiseGeneratorPerlinFloat extends NoiseGenerator +{ + private int[] permutations; + public double xCoord; + public double yCoord; + public double zCoord; + + public NoiseGeneratorPerlinFloat() + { + this(new Random()); + } + + public NoiseGeneratorPerlinFloat(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 grad2d(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 grad3d(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); + } + + private double floor(double value) { + return (float) value < 0 ? Math.floor(value) + 1 : Math.floor(value); + } + + /** + * 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; + 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; + double var78 = floor(var31); + + if (var31 < (double)var78) + { + --var78; + } + + int var34 = (int) (var78 % 256D) & 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; + double var40 = floor(var38); + + if (var38 < (double)var40) + { + --var40; + } + + var41 = (int) (var40 % 256D) & 255; + var38 -= (double)var40; + var42 = var38 * var38 * var38 * (var38 * (var38 * 6.0D - 15.0D) + 10.0D); + var19 = this.permutations[var34] + 0; + int var66 = this.permutations[var19] + var41; + int var67 = this.permutations[var34 + 1] + 0; + var22 = this.permutations[var67] + var41; + var70 = this.lerp(var35, this.grad2d(this.permutations[var66], var31, var38), this.grad3d(this.permutations[var22], var31 - 1.0D, 0.0D, var38)); + var73 = this.lerp(var35, this.grad3d(this.permutations[var66 + 1], var31, 0.0D, var38 - 1.0D), this.grad3d(this.permutations[var22 + 1], var31 - 1.0D, 0.0D, var38 - 1.0D)); + double var79 = this.lerp(var42, var70, var73); + var10001 = var75++; + par1ArrayOfDouble[var10001] += FLOAT_PERLIN_GENERATOR ? (float) (var79 * var77) : 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; + double var40 = floor(var38); + + if (var38 < (double)var40) + { + --var40; + } + + var41 = (int) (var40 % 256D) & 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; + double var47 = floor(var45); + + if (var45 < (double)var47) + { + --var47; + } + + int var48 = (int) (var47 % 256D) & 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; + double var54 = floor(var52); + + if (var52 < (double)var54) + { + --var54; + } + + int var55 = (int) (var54 % 256D) & 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.grad3d(this.permutations[var71], var38, var52, var45), this.grad3d(this.permutations[var75], var38 - 1.0D, var52, var45)); + var31 = this.lerp(var42, this.grad3d(this.permutations[var72], var38, var52 - 1.0D, var45), this.grad3d(this.permutations[var76], var38 - 1.0D, var52 - 1.0D, var45)); + var33 = this.lerp(var42, this.grad3d(this.permutations[var71 + 1], var38, var52, var45 - 1.0D), this.grad3d(this.permutations[var75 + 1], var38 - 1.0D, var52, var45 - 1.0D)); + var35 = this.lerp(var42, this.grad3d(this.permutations[var72 + 1], var38, var52 - 1.0D, var45 - 1.0D), this.grad3d(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] += FLOAT_PERLIN_GENERATOR ? (float) (var62 * var20) : var62 * var20; + } + } + } + } + } +} diff --git a/src/minecraft/net/minecraft/src/OpenGlHelper.java b/src/minecraft/net/minecraft/src/OpenGlHelper.java index ab18230..9f7a0e5 100644 --- a/src/minecraft/net/minecraft/src/OpenGlHelper.java +++ b/src/minecraft/net/minecraft/src/OpenGlHelper.java @@ -49,10 +49,12 @@ public class OpenGlHelper { if (useMultitextureARB) { + ARBMultitexture.glClientActiveTextureARB(par0); ARBMultitexture.glActiveTextureARB(par0); } else { + GL13.glClientActiveTexture(par0); GL13.glActiveTexture(par0); } } diff --git a/src/minecraft/net/minecraft/src/PerlinNoiseFactory.java b/src/minecraft/net/minecraft/src/PerlinNoiseFactory.java index 1e95180..36729df 100644 --- a/src/minecraft/net/minecraft/src/PerlinNoiseFactory.java +++ b/src/minecraft/net/minecraft/src/PerlinNoiseFactory.java @@ -3,6 +3,12 @@ package net.minecraft.src; import java.util.Random; public enum PerlinNoiseFactory { + shortType { + @Override + public NoiseGenerator createPerlinNoiseGenerator(Random random) { + return new NoiseGeneratorPerlin16(random); + } + }, intType { @Override public NoiseGenerator createPerlinNoiseGenerator(Random random) { @@ -15,10 +21,16 @@ public enum PerlinNoiseFactory { return new NoiseGeneratorPerlin64(random); } }, + floatType { + @Override + public NoiseGenerator createPerlinNoiseGenerator(Random random) { + return new NoiseGeneratorPerlinFloat(random); + } + }, doubleType { @Override public NoiseGenerator createPerlinNoiseGenerator(Random random) { - return new NoiseGeneratorPerlin2(random); + return new NoiseGeneratorPerlinDouble(random); } };