Fix reobfuscate

This reverts commit 18c2d4f399.

readme.md

@@ -1,5 +1,3 @@
-![Image](./Image.png)
+# Minecraft 1.3.2 128bit mod
 
-Please made it you self :)
+Incompleted yet.
-
-# End of support

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);
+    }
 }

src/minecraft/net/minecraft/src/ChunkProviderGenerate.java

@@ -4,6 +4,8 @@ import org.mcmodule.math.BigInteger;
 import java.util.List;
 import java.util.Random;
 
+import static net.minecraft.src.Constants.*;
+
 public class ChunkProviderGenerate implements IChunkProvider
 {
     /** RNG. */
@@ -96,72 +98,83 @@ public class ChunkProviderGenerate implements IChunkProvider
      */
     public void generateTerrain(BigInteger par1, BigInteger par2, byte[] par3ArrayOfByte)
     {
-        byte var4 = 4;
+        byte width1 = 4;
-        byte var5 = 16;
+        byte height1 = 16;
-        byte var6 = 63;
+        byte seaLevel = 63;
-        int var7 = var4 + 1;
+//        int var7 = width1 + 1;
-        byte var8 = 17;
+        byte noiseHeight = 17;
-        int var9 = var4 + 1;
+        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)), var7 + 5, var9 + 5);
+        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(var4)), 0, par2.multiply(BigInteger.valueOf(var4)), var7, var8, var9);
+        this.noiseArray = this.initializeNoiseField(this.noiseArray, par1.multiply(BigInteger.valueOf(width1)), 0, par2.multiply(BigInteger.valueOf(width1)), noiseWidth, noiseHeight, noiseWidth);
-
+
-        for (int var10 = 0; var10 < var4; ++var10)
+        // 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;
+                	// Who is faster? Is LOAD faster or LDC faster?
-                    double var15 = this.noiseArray[((var10 + 0) * var9 + var11 + 0) * var8 + var12 + 0];
+                    double step8 = 0.125D;
-                    double var17 = this.noiseArray[((var10 + 0) * var9 + var11 + 1) * var8 + var12 + 0];
+                    // Evil gradient variables.
-                    double var19 = this.noiseArray[((var10 + 1) * var9 + var11 + 0) * var8 + var12 + 0];
+                    double     AA =  this.noiseArray[((x1 + 0) * noiseWidth + z1 + 0) * noiseHeight + y1 + 0];
-                    double var21 = this.noiseArray[((var10 + 1) * var9 + var11 + 1) * var8 + var12 + 0];
+                    double     BB =  this.noiseArray[((x1 + 0) * noiseWidth + z1 + 1) * noiseHeight + y1 + 0];
-                    double var23 = (this.noiseArray[((var10 + 0) * var9 + var11 + 0) * var8 + var12 + 1] - var15) * var13;
+                    double     CC =  this.noiseArray[((x1 + 1) * noiseWidth + z1 + 0) * noiseHeight + y1 + 0];
-                    double var25 = (this.noiseArray[((var10 + 0) * var9 + var11 + 1) * var8 + var12 + 1] - var17) * var13;
+                    double     DD =  this.noiseArray[((x1 + 1) * noiseWidth + z1 + 1) * noiseHeight + y1 + 0];
-                    double var27 = (this.noiseArray[((var10 + 1) * var9 + var11 + 0) * var8 + var12 + 1] - var19) * var13;
+                    double stepAA = (this.noiseArray[((x1 + 0) * noiseWidth + z1 + 0) * noiseHeight + y1 + 1] - AA) * step8; // Use 0.125D instead of step8 may faster???
-                    double var29 = (this.noiseArray[((var10 + 1) * var9 + var11 + 1) * var8 + var12 + 1] - var21) * var13;
+                    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;
-                    for (int var31 = 0; var31 < 8; ++var31)
+                    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 step4 = 0.25D;
-                        double var34 = var15;
+                        double     EE = AA;
-                        double var36 = var17;
+                        double     FF = BB;
-                        double var38 = (var19 - var15) * var32;
+                        double stepEE = (CC - AA) * step4;
-                        double var40 = (var21 - var17) * var32;
+                        double stepFF = (DD - BB) * step4;
 
-                        for (int var42 = 0; var42 < 4; ++var42)
+                        for (int x2 = 0; x2 < 4; ++x2)
                         {
-                            int var43 = var42 + var10 * 4 << 11 | 0 + var11 * 4 << 7 | var12 * 8 + var31;
+                            int xzy = x2 + x1 * 4 << 11 | 0 + z1 * 4 << 7 | y1 * 8 + y2;
-                            short var44 = 128;
+                            short height = 128;
-                            var43 -= var44;
+                            xzy -= height;
-                            double var45 = 0.25D;
+//                            double var45 = 0.25D;
-                            double var49 = (var36 - var34) * var45;
+                            double stepGG = (FF - EE) * step4;
-                            double var47 = var34 - var49;
+                            double     GG = EE - stepGG;
-
+
-                            for (int var51 = 0; var51 < 4; ++var51)
+                            for (int z2 = 0; z2 < 4; ++z2)
                             {
-                                if ((var47 += var49) > 0.0D)
+                            	if(!ENABLE_FRINGE_LAND) {
+                            		GG += stepGG;
+                            	} else {
+                            		if(z2 == 0) GG = EE;
+                            	}
+                                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) {
+                            		GG += stepGG;
+                            	}
                             }
 
-                            var34 += var38;
+                            EE += stepEE;
-                            var36 += var40;
+                            FF += stepFF;
                         }
 
-                        var15 += var23;
+                        AA += stepAA;
-                        var17 += var25;
+                        BB += stepBB;
-                        var19 += var27;
+                        CC += stepCC;
-                        var21 += var29;
+                        DD += stepDD;
                     }
                 }
             }
@@ -191,15 +204,15 @@ public class ChunkProviderGenerate implements IChunkProvider
 
                 for (int var16 = 127; var16 >= 0; --var16)
                 {
-                    int var17 = (var9 * 16 + var8) * 128 + var16;
+                    int xzy = (var9 * 16 + var8) * 128 + var16;
 
                     if (var16 <= 0 + this.rand.nextInt(5))
                     {
-                        par3ArrayOfByte[var17] = (byte)Block.bedrock.blockID;
+                        par3ArrayOfByte[xzy] = (byte)Block.bedrock.blockID;
                     }
                     else
                     {
-                        byte var18 = par3ArrayOfByte[var17];
+                        byte var18 = par3ArrayOfByte[xzy];
 
                         if (var18 == 0)
                         {
@@ -236,17 +249,17 @@ public class ChunkProviderGenerate implements IChunkProvider
 
                                 if (var16 >= var5 - 1)
                                 {
-                                    par3ArrayOfByte[var17] = var14;
+                                    par3ArrayOfByte[xzy] = var14;
                                 }
                                 else
                                 {
-                                    par3ArrayOfByte[var17] = var15;
+                                    par3ArrayOfByte[xzy] = var15;
                                 }
                             }
                             else if (var13 > 0)
                             {
                                 --var13;
-                                par3ArrayOfByte[var17] = var15;
+                                par3ArrayOfByte[xzy] = var15;
 
                                 if (var13 == 0 && var15 == Block.sand.blockID)
                                 {
@@ -307,11 +320,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)
+    private double[] initializeNoiseField(double[] noiseTable, BigInteger x, int y, BigInteger z, int width, int depth, int height)
     {
-        if (par1ArrayOfDouble == null)
+        if (noiseTable == null)
         {
-            par1ArrayOfDouble = new double[par5 * par6 * par7];
+            noiseTable = new double[width * depth * height];
         }
 
         if (this.parabolicField == null)
@@ -328,33 +341,33 @@ public class ChunkProviderGenerate implements IChunkProvider
             }
         }
 
-        double var44 = 684.412D;
+        double scaleX = 684.412D;
-        double var45 = 684.412D;
+        double scaleY = 684.412D;
-        this.noise5 = this.noiseGen5.generateNoiseOctaves(this.noise5, par2, par4, par5, par7, 1.121D, 1.121D, 0.5D);
+        this.noise5 = this.noiseGen5.generateNoiseOctaves(this.noise5, x, z, width, height, 1.121D, 1.121D, 0.5D);
-        this.noise6 = this.noiseGen6.generateNoiseOctaves(this.noise6, par2, par4, par5, par7, 200.0D, 200.0D, 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, par2, par3, par4, par5, par6, par7, var44 / 80.0D, var45 / 160.0D, var44 / 80.0D);
+        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, par2, par3, par4, par5, par6, par7, var44, var45, var44);
+        this.noise1 = this.noiseGen1.generateNoiseOctaves(this.noise1, x, y, z, width, depth, height, scaleX, scaleY, scaleX);
-        this.noise2 = this.noiseGen2.generateNoiseOctaves(this.noise2, par2, par3, par4, par5, par6, par7, var44, var45, var44);
+        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 maxHeight = 0.0F;
-                float var17 = 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)
@@ -362,16 +375,16 @@ public class ChunkProviderGenerate implements IChunkProvider
                             var24 /= 2.0F;
                         }
 
-                        var16 += var23.maxHeight * var24;
+                        maxHeight += var23.maxHeight * var24;
-                        var17 += var23.minHeight * var24;
+                        minHeight += var23.minHeight * var24;
                         var18 += var24;
                     }
                 }
 
-                var16 /= var18;
+                maxHeight /= var18;
-                var17 /= var18;
+                minHeight /= var18;
-                var16 = var16 * 0.9F + 0.1F;
+                maxHeight = maxHeight * 0.9F + 0.1F;
-                var17 = (var17 * 4.0F - 1.0F) / 8.0F;
+                minHeight = (minHeight * 4.0F - 1.0F) / 8.0F;
                 double var46 = this.noise6[var13] / 8000.0D;
 
                 if (var46 < 0.0D)
@@ -405,13 +418,13 @@ public class ChunkProviderGenerate implements IChunkProvider
 
                 ++var13;
 
-                for (int var47 = 0; var47 < par6; ++var47)
+                for (int var47 = 0; var47 < depth; ++var47)
                 {
-                    double var48 = (double)var17;
+                    double var48 = (double)minHeight;
-                    double var26 = (double)var16;
+                    double var26 = (double)maxHeight;
                     var48 += var46 * 0.2D;
-                    var48 = var48 * (double)par6 / 16.0D;
+                    var48 = var48 * (double)depth / 16.0D;
-                    double var28 = (double)par6 / 2.0D + var48 * 4.0D;
+                    double var28 = (double)depth / 2.0D + var48 * 4.0D;
                     double var30 = 0.0D;
                     double var32 = ((double)var47 - var28) * 12.0D * 128.0D / 128.0D / var26;
 
@@ -439,19 +452,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;
     }
 
     /**

src/minecraft/net/minecraft/src/Constants.java

@@ -1,26 +1,37 @@
 package net.minecraft.src;
 
 import java.lang.reflect.Field;
+import sun.misc.Unsafe;
 
 public class Constants {
 	public static       boolean DISABLE_MODULO = false,
 								ENABLE_FRINGE_LAND = false,
 								FLOAT_PERLIN_GENERATOR = false,
-								COMPILE_CHUNK_ASYNC = false;
+								COMPILE_CHUNK_ASYNC = false,
+								DISABLE_ENTITY_UPDATE = false;
 	
 	@Deprecated(/* forRemoval = true */)
 	public static boolean USE_64BIT_PERLIN_GENERATOR = false;
 	
 	static {
+		Unsafe unsafe;
+		try {
+			Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
+			unsafeField.setAccessible(true);
+			unsafe = (Unsafe) unsafeField.get(null);
+		} catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) {
+			throw new RuntimeException(e);
+		}
 		Class<Constants> cls = Constants.class;
 		try {
 			for(Field f : cls.getDeclaredFields()) {
-				f.setBoolean(null, Boolean.getBoolean(cls.getName() + "." + f.getName()));
+//				unsafe.putBoolean(cls, unsafe.fieldOffset(f), Boolean.getBoolean(cls.getName() + "." + f.getName()));
+				f.setBoolean(null, Boolean.getBoolean("net.minecraft.src.Constants." + f.getName()));
 			}
 		} catch(Throwable t) {
 			throw new RuntimeException(t);
 		}
-		if(System.getProperty(cls.getName() + ".USE_64BIT_PERLIN_GENERATOR") != null) {
+		if(System.getProperty("net.minecraft.src.Constants.USE_64BIT_PERLIN_GENERATOR") != null) {
 			System.err.println("USE_64BIT_PERLIN_GENERATOR is deprecated and will remove in future, Please consider use -Dnet.minecraft.src.NoiseGeneratorOctaves.noiseType=" + (USE_64BIT_PERLIN_GENERATOR ? "long" : "int") + "Type");
 		}
 	}

src/minecraft/net/minecraft/src/MathHelper.java

@@ -142,6 +142,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.
      */

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;
+                var3 = par1Packet10Flying.yPosition - this.lastPosY;
-//
+
-//                if (par1Packet10Flying.xPosition.compareTo(this.lastPosX) == 0 && var3 * var3 < 0.01D && par1Packet10Flying.zPosition.compareTo(this.lastPosZ) == 0)
+                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;
-//                }
+                } else {
-            	this.field_72587_r = true;
+                	this.playerEntity.serverForThisPlayer.sendPacketToPlayer(new Packet11PlayerPosition(this.lastPosX, this.lastPosY + 1.6200000047683716D, this.lastPosY, this.lastPosZ, false));
+                }
             }
 
             if (this.field_72587_r)

src/minecraft/net/minecraft/src/NoiseGenerator.java

@@ -3,6 +3,8 @@ 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) {
-		
+		if (this instanceof NoiseGeneratorPerlin) {
+			((NoiseGeneratorPerlin) this).populateNoiseArray(par1ArrayOfDouble, par2, par4, par6, par8, par9, par10, par11, par13, par15, par17);
+		} else throw new Error("Fucked by MCP™");
 	}
 }

src/minecraft/net/minecraft/src/NoiseGeneratorPerlin.java

@@ -2,6 +2,8 @@ package net.minecraft.src;
 
 import java.util.Random;
 
+import static net.minecraft.src.Constants.*;
+
 public class NoiseGeneratorPerlin extends NoiseGenerator
 {
     private int[] permutations;
@@ -122,7 +124,7 @@ public class NoiseGeneratorPerlin extends NoiseGenerator
                     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] += (var79 * var77);
+                    par1ArrayOfDouble[var10001] += FLOAT_PERLIN_GENERATOR ? (float) (var79 * var77) : var79 * var77;
                 }
             }
         }
@@ -203,7 +205,7 @@ public class NoiseGeneratorPerlin extends NoiseGenerator
                         double var60 = this.lerp(var56, var33, var35);
                         double var62 = this.lerp(var49, var58, var60);
                         var10001 = var19++;
-                        par1ArrayOfDouble[var10001] += (var62 * var20);
+                        par1ArrayOfDouble[var10001] += FLOAT_PERLIN_GENERATOR ? (float) (var62 * var20) : var62 * var20;
                     }
                 }
             }

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;
+                    }
+                }
+            }
+        }
+    }
+}

src/minecraft/net/minecraft/src/NoiseGeneratorPerlin64.java

@@ -2,6 +2,8 @@ package net.minecraft.src;
 
 import java.util.Random;
 
+import static net.minecraft.src.Constants.*;
+
 public class NoiseGeneratorPerlin64 extends NoiseGenerator
 {
     private int[] permutations;
@@ -122,7 +124,7 @@ public class NoiseGeneratorPerlin64 extends NoiseGenerator
                     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] += (var79 * var77);
+                    par1ArrayOfDouble[var10001] += FLOAT_PERLIN_GENERATOR ? (float) (var79 * var77) : var79 * var77;
                 }
             }
         }
@@ -203,7 +205,7 @@ public class NoiseGeneratorPerlin64 extends NoiseGenerator
                         double var60 = this.lerp(var56, var33, var35);
                         double var62 = this.lerp(var49, var58, var60);
                         var10001 = var19++;
-                        par1ArrayOfDouble[var10001] += (var62 * var20);
+                        par1ArrayOfDouble[var10001] += FLOAT_PERLIN_GENERATOR ? (float) (var62 * var20) : var62 * var20;
                     }
                 }
             }

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;

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;
+                    }
+                }
+            }
+        }
+    }
+}

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);
         }
     }

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);
 		}
 	};
 	

src/minecraft/net/minecraft/src/World.java

@@ -295,8 +295,9 @@ public abstract class World implements IBlockAccess
      */
     public boolean doChunksNearChunkExist(BigInteger par1, int par2, BigInteger par3, int par4)
     {
-    	return true;
+//    	return true;
-//        return this.checkChunksExist(par1 - par4, par2 - par4, par3 - par4, par1 + par4, par2 + par4, par3 + par4);
+    	BigInteger dist = BigInteger.valueOf(par4);
+        return this.checkChunksExist(par1.subtract(par3), par2 - par4, par3.subtract(dist), par1.add(dist), par2 + par4, par3.add(dist));
     }
 
     /**
@@ -1759,6 +1760,7 @@ public abstract class World implements IBlockAccess
         for (var1 = 0; var1 < this.loadedEntityList.size(); ++var1)
         {
             var2 = (Entity)this.loadedEntityList.get(var1);
+            if (!(var2 instanceof EntityPlayer) && Constants.DISABLE_ENTITY_UPDATE) continue;
 
             if (var2.ridingEntity != null)
             {