Merge branch 'master' into test

src/minecraft/net/minecraft/client/Minecraft.java

@@ -1552,6 +1552,11 @@ public abstract class Minecraft implements Runnable, IPlayerUsage
                             {
                                 this.gameSettings.smoothCamera = !this.gameSettings.smoothCamera;
                             }
+                            if (Keyboard.getEventKey() == Keyboard.KEY_F) {
+                            	if (this.thePlayer != null) {
+                            		this.thePlayer.capabilities.isFlying ^= true;
+                            	}
+                            }
                         }
 
                         int var5;

src/minecraft/net/minecraft/src/AnvilChunkLoader.java

@@ -223,7 +223,7 @@ public class AnvilChunkLoader implements IThreadedFileIO, IChunkLoader
             if (var9 != null)
             {
                 var10 = new NBTTagCompound();
-                var10.setByte("Y", (byte)(var9.getYLocation() >> 4 & 255));
+                var10.setByte("Y", (byte)(var9.getYLocation() & 255));
                 var10.setByteArray("Blocks", var9.getBlockLSBArray());
 
                 if (var9.getBlockMSBArray() != null)
@@ -313,11 +313,11 @@ public class AnvilChunkLoader implements IThreadedFileIO, IChunkLoader
         byte var7 = 16;
         ExtendedBlockStorage[] var8 = new ExtendedBlockStorage[var7];
 
-        for (int var9 = 0; var9 < var6.tagCount(); ++var9)
+        for (int var9 = 0; var9 < var6.tagCount() && var9 < var8.length; ++var9)
         {
             NBTTagCompound var10 = (NBTTagCompound)var6.tagAt(var9);
             byte var11 = var10.getByte("Y");
-            ExtendedBlockStorage var12 = new ExtendedBlockStorage(var11 << 4);
+            ExtendedBlockStorage var12 = new ExtendedBlockStorage(var11);
             var12.setBlockLSBArray(var10.getByteArray("Blocks"));
 
             if (var10.hasKey("Add"))

src/minecraft/net/minecraft/src/Chunk.java

@@ -5,6 +5,7 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Random;
@@ -22,6 +23,8 @@ public class Chunk
      */
     private ExtendedBlockStorage[] storageArrays;
     
+    private LinkedList<ExtendedBlockStorage>[] extraStorageArray = new LinkedList[256];
+
     /**
      * Contains a 16x16 mapping on the X/Z plane of the biome ID to which each colum belongs.
      */
@@ -115,24 +118,19 @@ public class Chunk
         this(par1World, par3, par4);
         int var5 = par2ArrayOfByte.length / 256;
 
-        for (int var6 = 0; var6 < 16; ++var6)
+        for (int x = 0; x < 16; ++x)
         {
-            for (int var7 = 0; var7 < 16; ++var7)
+            for (int z = 0; z < 16; ++z)
             {
-                for (int var8 = 0; var8 < var5; ++var8)
+                for (int y = 0; y < var5; ++y)
                 {
-                    byte var9 = par2ArrayOfByte[var6 << 11 | var7 << 7 | var8];
+                    byte var9 = par2ArrayOfByte[x << 12 | z << 8 | y];
 
                     if (var9 != 0)
                     {
-                        int var10 = var8 >> 4;
-
-                        if (this.storageArrays[var10] == null)
-                        {
-                            this.storageArrays[var10] = new ExtendedBlockStorage(var10 << 4);
-                        }
+                        int var10 = y >> 4;
 
-                        this.storageArrays[var10].setExtBlockID(var6, var8 & 15, var7, var9);
+                    	getBlockStorage(var10).setExtBlockID(x, y & 15, z, var9);
                     }
                 }
             }
@@ -179,6 +177,26 @@ public class Chunk
         return this.storageArrays;
     }
     
+    public ExtendedBlockStorage getBlockStorage(int yBase) {
+    	if(yBase < 0 || yBase >= storageArrays.length) {
+    		LinkedList<ExtendedBlockStorage> list = extraStorageArray[yBase & 0xFF];
+    		if(list == null) list = extraStorageArray[yBase & 0xFF] = new LinkedList<>();
+    		for(ExtendedBlockStorage blockStorage : list) if(blockStorage.yBase == yBase) {
+    			if (blockStorage.isPrototype) {
+    				this.worldObj.doDecorateExtraChunk(this, xPosition, yBase, zPosition, blockStorage);
+    			}
+    			return blockStorage;
+    		}
+    		ExtendedBlockStorage blockStorage = new ExtendedBlockStorage(yBase);
+    		list.add(blockStorage);
+    		this.worldObj.addExtraChunk(xPosition, yBase, zPosition, blockStorage);
+    		return blockStorage;
+    	} else {
+    		ExtendedBlockStorage blockStorage;
+    		return (blockStorage = storageArrays[yBase]) == null ? storageArrays[yBase] = new ExtendedBlockStorage(yBase) : blockStorage;
+    	}
+    }
+    
     /**
      * Generates the height map for a chunk from scratch
      */
@@ -510,32 +528,18 @@ public class Chunk
      */
     public int getBlockID(int par1, int par2, int par3)
     {
-        if (par2 >> 4 >= this.storageArrays.length)
-        {
-            return 0;
-        }
-        else
-        {
-            ExtendedBlockStorage var4 = this.storageArrays[par2 >> 4];
+    	ExtendedBlockStorage var4 = this.getBlockStorage(par2 >> 4);
         return var4 != null ? var4.getExtBlockID(par1, par2 & 15, par3) : 0;
     }
-    }
 
     /**
      * Return the metadata corresponding to the given coordinates inside a chunk.
      */
     public int getBlockMetadata(int par1, int par2, int par3)
     {
-        if (par2 >> 4 >= this.storageArrays.length)
-        {
-            return 0;
-        }
-        else
-        {
-            ExtendedBlockStorage var4 = this.storageArrays[par2 >> 4];
+    	ExtendedBlockStorage var4 = this.getBlockStorage(par2 >> 4);
         return var4 != null ? var4.getExtBlockMetadata(par1, par2 & 15, par3) : 0;
     }
-    }
 
     /**
      * Sets a blockID for a position in the chunk. Args: x, y, z, blockID
@@ -567,7 +571,7 @@ public class Chunk
         }
         else
         {
-            ExtendedBlockStorage var10 = this.storageArrays[par2 >> 4];
+            ExtendedBlockStorage var10 = this.getBlockStorage(par2 >> 4);
             boolean var11 = false;
 
             if (var10 == null)
@@ -577,7 +581,7 @@ public class Chunk
                     return false;
                 }
 
-                var10 = this.storageArrays[par2 >> 4] = new ExtendedBlockStorage(par2 >> 4 << 4);
+                var10 = this.storageArrays[par2 >> 4] = new ExtendedBlockStorage(par2 >> 4);
                 var11 = par2 >= var7;
             }
 
@@ -678,7 +682,7 @@ public class Chunk
      */
     public boolean setBlockMetadata(int par1, int par2, int par3, int par4)
     {
-        ExtendedBlockStorage var5 = this.storageArrays[par2 >> 4];
+        ExtendedBlockStorage var5 = this.getBlockStorage(par2 >> 4);
 
         if (var5 == null)
         {
@@ -719,7 +723,7 @@ public class Chunk
      */
     public int getSavedLightValue(EnumSkyBlock par1EnumSkyBlock, int par2, int par3, int par4)
     {
-        ExtendedBlockStorage var5 = this.storageArrays[par3 >> 4];
+        ExtendedBlockStorage var5 = this.getBlockStorage(par3 >> 4);
         return var5 == null ? (this.canBlockSeeTheSky(par2, par3, par4) ? par1EnumSkyBlock.defaultLightValue : 0) : (par1EnumSkyBlock == EnumSkyBlock.Sky ? var5.getExtSkylightValue(par2, par3 & 15, par4) : (par1EnumSkyBlock == EnumSkyBlock.Block ? var5.getExtBlocklightValue(par2, par3 & 15, par4) : par1EnumSkyBlock.defaultLightValue));
     }
 
@@ -729,11 +733,11 @@ public class Chunk
      */
     public void setLightValue(EnumSkyBlock par1EnumSkyBlock, int par2, int par3, int par4, int par5)
     {
-        ExtendedBlockStorage var6 = this.storageArrays[par3 >> 4];
+        ExtendedBlockStorage var6 = this.getBlockStorage(par3 >> 4);
 
         if (var6 == null)
         {
-            var6 = this.storageArrays[par3 >> 4] = new ExtendedBlockStorage(par3 >> 4 << 4);
+            var6 = this.storageArrays[par3 >> 4] = new ExtendedBlockStorage(par3 >> 4);
             this.generateSkylightMap();
         }
 
@@ -757,7 +761,7 @@ public class Chunk
      */
     public int getBlockLightValue(int par1, int par2, int par3, int par4)
     {
-        ExtendedBlockStorage var5 = this.storageArrays[par2 >> 4];
+        ExtendedBlockStorage var5 = this.getBlockStorage(par2 >> 4);
 
         if (var5 == null)
         {
@@ -1197,19 +1201,9 @@ public class Chunk
      */
     public boolean getAreLevelsEmpty(int par1, int par2)
     {
-        if (par1 < 0)
-        {
-            par1 = 0;
-        }
-
-        if (par2 >= 256)
-        {
-            par2 = 255;
-        }
-
         for (int var3 = par1; var3 <= par2; var3 += 16)
         {
-            ExtendedBlockStorage var4 = this.storageArrays[var3 >> 4];
+            ExtendedBlockStorage var4 = this.getBlockStorage(var3 >> 4);
 
             if (var4 != null && !var4.isEmpty())
             {
@@ -1239,7 +1233,7 @@ public class Chunk
             {
                 if (this.storageArrays[var6] == null)
                 {
-                    this.storageArrays[var6] = new ExtendedBlockStorage(var6 << 4);
+                    this.storageArrays[var6] = new ExtendedBlockStorage(var6);
                 }
 
                 byte[] var7 = this.storageArrays[var6].getBlockLSBArray();
@@ -1441,4 +1435,15 @@ public class Chunk
 //            }
 //        }
     }
+
+	public LinkedList<ExtendedBlockStorage>[] getExtraStorageArray() {
+		return extraStorageArray;
+	}
+
+	public void addExtraChunk(ExtendedBlockStorage storage) {
+		int yBase = storage.yBase;
+		if (yBase < 0 || yBase > storageArrays.length) {
+			extraStorageArray[yBase & 0xFF].add(storage);
+		}
+	}
 }

src/minecraft/net/minecraft/src/ChunkCache.java

@@ -56,16 +56,6 @@ public class ChunkCache implements IBlockAccess
      * Returns the block ID at coords x,y,z
      */
     public int getBlockId(BigInteger par1, int par2, BigInteger par3)
-    {
-        if (par2 < 0)
-        {
-            return 0;
-        }
-        else if (par2 >= 256)
-        {
-            return 0;
-        }
-        else
     {
     	int var4 = (par1.shiftRight(4)).subtract(chunkX).intValueExact();
         int var5 = (par3.shiftRight(4)).subtract(chunkZ).intValueExact();
@@ -80,7 +70,6 @@ public class ChunkCache implements IBlockAccess
             return 0;
         }
     }
-    }
 
     /**
      * Returns the TileEntity associated with a given block in X,Y,Z coordinates, or null if no TileEntity exists
@@ -208,22 +197,11 @@ public class ChunkCache implements IBlockAccess
      * Returns the block metadata at coords x,y,z
      */
     public int getBlockMetadata(BigInteger par1, int par2, BigInteger par3)
-    {
-        if (par2 < 0)
-        {
-            return 0;
-        }
-        else if (par2 >= 256)
-        {
-            return 0;
-        }
-        else
     {
     	int var4 = (par1.shiftRight(4)).subtract(chunkX).intValueExact();
         int var5 = (par3.shiftRight(4)).subtract(chunkZ).intValueExact();
         return this.chunkArray[var4][var5].getBlockMetadata(par1.intValue() & 15, par2, par3.intValue() & 15);
     }
-    }
 
     /**
      * Returns the block's material.

src/minecraft/net/minecraft/src/ChunkProviderEnd.java

@@ -69,8 +69,8 @@ public class ChunkProviderEnd implements IChunkProvider
 
                         for (int var41 = 0; var41 < 8; ++var41)
                         {
-                            int var42 = var41 + var9 * 8 << 11 | 0 + var10 * 8 << 7 | var11 * 4 + var30;
-                            short var43 = 128;
+                            int var42 = var41 + var9 * 8 << 12 | 0 + var10 * 8 << 8 | var11 * 4 + var30;
+                            short var43 = 256;
                             double var44 = 0.125D;
                             double var46 = var33;
                             double var48 = (var35 - var33) * var44;
@@ -116,7 +116,7 @@ public class ChunkProviderEnd implements IChunkProvider
 
                 for (int var11 = 127; var11 >= 0; --var11)
                 {
-                    int var12 = (var6 * 16 + var5) * 128 + var11;
+                    int var12 = (var6 * 16 + var5) * 256 + var11;
                     byte var13 = par3ArrayOfByte[var12];
 
                     if (var13 == 0)
@@ -170,7 +170,7 @@ public class ChunkProviderEnd implements IChunkProvider
     public Chunk provideChunk(BigInteger par1, BigInteger par2)
     {
         this.endRNG.setSeed((long)par1.intValue() * 341873128712L + (long)par2.intValue() * 132897987541L);
-        byte[] var3 = new byte[32768];
+        byte[] var3 = new byte[65536];
         this.biomesForGeneration = this.endWorld.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, par1.shiftLeft(4), par2.shiftLeft(4), 16, 16);
         this.generateTerrain(par1, par2, var3, this.biomesForGeneration);
         this.replaceBlocksForBiome(par1, par2, var3, this.biomesForGeneration);

src/minecraft/net/minecraft/src/ChunkProviderFlat.java

@@ -43,7 +43,7 @@ public class ChunkProviderFlat implements IChunkProvider
                         var6 = Block.grass.blockID;
                     }
 
-                    par1ArrayOfByte[var3 << 11 | var4 << 7 | var5] = (byte)var6;
+                    par1ArrayOfByte[var3 << 12 | var4 << 8 | var5] = (byte)var6;
                 }
             }
         }
@@ -63,7 +63,7 @@ public class ChunkProviderFlat implements IChunkProvider
      */
     public Chunk provideChunk(BigInteger par1, BigInteger par2)
     {
-        byte[] var3 = new byte[32768];
+        byte[] var3 = new byte[65536];
         this.generate(var3);
         Chunk var4 = new Chunk(this.worldObj, var3, par1, par2);
 

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

@@ -99,13 +99,13 @@ public class ChunkProviderGenerate implements IChunkProvider
     public void generateTerrain(BigInteger par1, BigInteger par2, byte[] par3ArrayOfByte)
     {
         byte width1 = 4;
-        byte height1 = 16;
+        byte height1 = 32;
         byte seaLevel = 63;
-//        int var7 = width1 + 1;
-        byte noiseHeight = 17;
+//        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);
+        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)
@@ -136,8 +136,8 @@ public class ChunkProviderGenerate implements IChunkProvider
 
                         for (int x2 = 0; x2 < 4; ++x2)
                         {
-                            int xzy = x2 + x1 * 4 << 11 | 0 + z1 * 4 << 7 | y1 * 8 + y2;
-                            short height = 128;
+                            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;
@@ -183,88 +183,93 @@ public class ChunkProviderGenerate implements IChunkProvider
 
     /**
      * Replaces the stone that was placed in with blocks that match the biome
+     * @param storage 
      */
-    public void replaceBlocksForBiome(BigInteger par1, BigInteger par2, byte[] par3ArrayOfByte, BiomeGenBase[] par4ArrayOfBiomeGenBase)
+    public void replaceBlocksForBiome(BigInteger par1, BigInteger par2, byte[] blockArray, BiomeGenBase[] par4ArrayOfBiomeGenBase, ExtendedBlockStorage storage)
     {
-        byte var5 = 63;
+        byte seaLevel = 63;
         double var6 = 0.03125D;
         // X, Y, 0 -> X. 0, Y
         this.stoneNoise = this.noiseGen4.generateNoiseOctaves(this.stoneNoise, par1.shiftLeft(4), BigInteger.ZERO, par2.shiftLeft(4), 16, 1, 16, var6 * 2.0D, var6 * 2.0D, var6 * 2.0D);
 
-        for (int var8 = 0; var8 < 16; ++var8)
+        for (int z = 0; z < 16; ++z)
         {
-            for (int var9 = 0; var9 < 16; ++var9)
+            for (int x = 0; x < 16; ++x)
             {
-                BiomeGenBase var10 = par4ArrayOfBiomeGenBase[var9 + var8 * 16];
-                float var11 = var10.getFloatTemperature();
-                int var12 = (int)(this.stoneNoise[var8 + var9 * 16] / 3.0D + 3.0D + this.rand.nextDouble() * 0.25D);
-                int var13 = -1;
-                byte var14 = var10.topBlock;
-                byte var15 = var10.fillerBlock;
+                BiomeGenBase biome = par4ArrayOfBiomeGenBase[x + z * 16];
+                float temperature = biome.getFloatTemperature();
+                int dirtLayerHeight = Math.min((int)(this.stoneNoise[z + x * 16] / 3.0D + 3.0D + this.rand.nextDouble() * 0.25D), 16); // clamp to 16 blocks
+                int currentHeight = -1;
+                byte topBlockId = biome.topBlock;
+                byte fillerBlockId = biome.fillerBlock;
 
-                for (int var16 = 127; var16 >= 0; --var16)
+                for (int y = 271; y >= 0; --y)
                 {
-                    int xzy = (var9 * 16 + var8) * 128 + var16;
+                    int idx = (x * 16 + z) * 256 + y;
 
-                    if (var16 <= 0 + this.rand.nextInt(5))
+                    if (y <= 0 + this.rand.nextInt(5))
                     {
-                        par3ArrayOfByte[xzy] = (byte)Block.bedrock.blockID;
+//                        par3ArrayOfByte[idx] = (byte)Block.bedrock.blockID;
                     }
                     else
                     {
-                        byte var18 = par3ArrayOfByte[xzy];
+                        byte blockId = (byte) (y > 255 ? storage.getExtBlockID(x, y & 0xF, z) : blockArray[idx]);
 
-                        if (var18 == 0)
+                        if (blockId == 0)
                         {
-                            var13 = -1;
+                            currentHeight = -1;
                         }
-                        else if (var18 == Block.stone.blockID)
+                        else if (blockId == Block.stone.blockID)
                         {
-                            if (var13 == -1)
+                            if (currentHeight == -1)
                             {
-                                if (var12 <= 0)
+                                if (dirtLayerHeight <= 0)
                                 {
-                                    var14 = 0;
-                                    var15 = (byte)Block.stone.blockID;
+                                    topBlockId = 0;
+                                    fillerBlockId = (byte)Block.stone.blockID;
                                 }
-                                else if (var16 >= var5 - 4 && var16 <= var5 + 1)
+                                else if (y >= seaLevel - 4 && y <= seaLevel + 1)
                                 {
-                                    var14 = var10.topBlock;
-                                    var15 = var10.fillerBlock;
+                                    topBlockId = biome.topBlock;
+                                    fillerBlockId = biome.fillerBlock;
                                 }
 
-                                if (var16 < var5 && var14 == 0)
+                                if (y < seaLevel && topBlockId == 0)
                                 {
-                                    if (var11 < 0.15F)
+                                    if (temperature < 0.15F)
                                     {
-                                        var14 = (byte)Block.ice.blockID;
+                                        topBlockId = (byte)Block.ice.blockID;
                                     }
                                     else
                                     {
-                                        var14 = (byte)Block.waterStill.blockID;
+                                        topBlockId = (byte)Block.waterStill.blockID;
                                     }
                                 }
 
-                                var13 = var12;
+                                currentHeight = dirtLayerHeight;
 
-                                if (var16 >= var5 - 1)
+                                if (y < 256) {
+                                	if (y >= seaLevel - 1)
                                     {
-                                    par3ArrayOfByte[xzy] = var14;
+                                        blockArray[idx] = topBlockId;
                                     }
                                     else
                                     {
-                                    par3ArrayOfByte[xzy] = var15;
+                                        blockArray[idx] = fillerBlockId;
+                                    }
                                 }
                             }
-                            else if (var13 > 0)
+                            else if (currentHeight > 0)
                             {
-                                --var13;
-                                par3ArrayOfByte[xzy] = var15;
+                                --currentHeight;
+                                if (y < 256) {
+                                	blockArray[idx] = fillerBlockId;
+                                }
 
-                                if (var13 == 0 && var15 == Block.sand.blockID)
+                                if (currentHeight == 0 && fillerBlockId == Block.sand.blockID)
                                 {
-                                    var13 = this.rand.nextInt(4);
-                                    var15 = (byte)Block.sandStone.blockID;
+                                    currentHeight = this.rand.nextInt(4);
+                                    fillerBlockId = (byte)Block.sandStone.blockID;
                                 }
                             }
                         }
@@ -289,22 +294,25 @@ public class ChunkProviderGenerate implements IChunkProvider
     public Chunk provideChunk(BigInteger par1, BigInteger par2)
     {
         this.rand.setSeed((long)par1.longValue() * 341873128712L + (long)par2.longValue() * 132897987541L);
-        byte[] var3 = new byte[32768];
-        this.generateTerrain(par1, par2, var3);
+        // index format: xxxxzzzzyyyyyyyy
+        byte[] blockArray = new byte[65536];
+        this.generateTerrain(par1, par2, blockArray);
         this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, par1.shiftLeft(4), par2.shiftLeft(4), 16, 16);
-        this.replaceBlocksForBiome(par1, par2, var3, this.biomesForGeneration);
-        this.caveGenerator.generate(this, this.worldObj, par1, par2, var3);
-        this.ravineGenerator.generate(this, this.worldObj, par1, par2, var3);
+        ExtendedBlockStorage storage = new ExtendedBlockStorage(16);
+        this.generateExtraBlockStorage(par1, 16, par2, storage);
+        this.replaceBlocksForBiome(par1, par2, blockArray, this.biomesForGeneration, storage);
+        this.caveGenerator.generate(this, this.worldObj, par1, par2, blockArray);
+        this.ravineGenerator.generate(this, this.worldObj, par1, par2, blockArray);
 
         if (this.mapFeaturesEnabled)
         {
-            this.mineshaftGenerator.generate(this, this.worldObj, par1, par2, var3);
-            this.villageGenerator.generate(this, this.worldObj, par1, par2, var3);
-            this.strongholdGenerator.generate(this, this.worldObj, par1, par2, var3);
-            this.scatteredFeatureGenerator.generate(this, this.worldObj, par1, par2, var3);
+            this.mineshaftGenerator.generate(this, this.worldObj, par1, par2, blockArray);
+            this.villageGenerator.generate(this, this.worldObj, par1, par2, blockArray);
+            this.strongholdGenerator.generate(this, this.worldObj, par1, par2, blockArray);
+            this.scatteredFeatureGenerator.generate(this, this.worldObj, par1, par2, blockArray);
         }
 
-        Chunk var4 = new Chunk(this.worldObj, var3, par1, par2);
+        Chunk var4 = new Chunk(this.worldObj, blockArray, par1, par2);
         byte[] var5 = var4.getBiomeArray();
 
         for (int var6 = 0; var6 < var5.length; ++var6)
@@ -312,6 +320,8 @@ public class ChunkProviderGenerate implements IChunkProvider
             var5[var6] = (byte)this.biomesForGeneration[var6].biomeID;
         }
         
+        var4.addExtraChunk(storage);
+
         var4.generateSkylightMap();
         return var4;
     }
@@ -320,7 +330,7 @@ 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[] noiseTable, BigInteger x, int y, BigInteger z, int width, int depth, int height, int par8)
     {
         if (noiseTable == null)
         {
@@ -345,9 +355,9 @@ public class ChunkProviderGenerate implements IChunkProvider
         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);
+        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;
@@ -418,14 +428,15 @@ public class ChunkProviderGenerate implements IChunkProvider
 
                 ++var13;
                 
-                for (int var47 = 0; var47 < depth; ++var47)
-                {
                 double var48 = (double)minHeight;
                 double var26 = (double)maxHeight;
                 var48 += var46 * 0.2D;
-                    var48 = var48 * (double)depth / 16.0D;
-                    double var28 = (double)depth / 2.0D + var48 * 4.0D;
+                var48 = var48 * (double)par8 / 16.0D;
+                double var28 = (double)par8 / 2.0D + var48 * 4.0D - y;
                 double var30 = 0.0D;
+
+                for (int var47 = 0; var47 < depth; ++var47)
+                {
                     double var32 = ((double)var47 - var28) * 12.0D * 128.0D / 128.0D / var26;
 
                     if (var32 < 0.0D)
@@ -467,6 +478,177 @@ public class ChunkProviderGenerate implements IChunkProvider
         return noiseTable;
     }
     
+    // FIXME
+    public void generateExtraBlockStorage(BigInteger x, int y, BigInteger z, ExtendedBlockStorage storage) {
+    	byte var4 = 4;
+        byte var5 = 2;
+        int var7 = var4 + 1;
+        byte var8 = 3;
+        int var9 = var4 + 1;
+        byte[] par3ArrayOfByte = new byte[1 << 12];
+        this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, x.multiply(BigInteger.valueOf(4)).subtract(BigInteger.valueOf(2)), z.multiply(BigInteger.valueOf(4)).subtract(BigInteger.valueOf(2)), var7 + 5, var9 + 5);
+    	double[] noiseArray = initializeNoiseField(null, x.multiply(BigInteger.valueOf(var4)), y * var5, z.multiply(BigInteger.valueOf(var4)), var7, var8, var9, 3);
+    	 for (int var10 = 0; var10 < var4; ++var10)
+         {
+             for (int var11 = 0; var11 < var4; ++var11)
+             {
+                 for (int var12 = 0; var12 < var5; ++var12)
+                 {
+                     double var13 = 0.125D;
+                     double var15 = noiseArray[((var10 + 0) * var9 + var11 + 0) * var8 + var12 + 0];
+                     double var17 = noiseArray[((var10 + 0) * var9 + var11 + 1) * var8 + var12 + 0];
+                     double var19 = noiseArray[((var10 + 1) * var9 + var11 + 0) * var8 + var12 + 0];
+                     double var21 = noiseArray[((var10 + 1) * var9 + var11 + 1) * var8 + var12 + 0];
+                     double var23 = (noiseArray[((var10 + 0) * var9 + var11 + 0) * var8 + var12 + 1] - var15) * var13;
+                     double var25 = (noiseArray[((var10 + 0) * var9 + var11 + 1) * var8 + var12 + 1] - var17) * var13;
+                     double var27 = (noiseArray[((var10 + 1) * var9 + var11 + 0) * var8 + var12 + 1] - var19) * var13;
+                     double var29 = (noiseArray[((var10 + 1) * var9 + var11 + 1) * var8 + var12 + 1] - var21) * var13;
+//
+//                     var15 += var23 * Math.floorDiv(y, 16);
+//                     var17 += var25 * Math.floorDiv(y, 16);
+//                     var19 += var27 * Math.floorDiv(y, 16);
+//                     var21 += var29 * Math.floorDiv(y, 16);
+//                     
+                     for (int var31 = 0; var31 < 8; ++var31)
+                     {
+                         double var32 = 0.25D;
+                         double var34 = var15;
+                         double var36 = var17;
+                         double var38 = (var19 - var15) * var32;
+                         double var40 = (var21 - var17) * var32;
+
+                         for (int var42 = 0; var42 < 4; ++var42)
+                         {
+                             int var43 = var42 + var10 * 4 << 8 | 0 + var11 * 4 << 4 | var12 * 8 + var31;
+                             short var44 = 16;
+                             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) {
+                             		var47 += var49;
+                             	} else {
+                             		if(var51 == 0) var47 = var34;
+                             	}
+                                 if (var47 > 0.0D)
+                                 {
+                                     par3ArrayOfByte[var43 += var44] = (byte)Block.stone.blockID;
+                                 }
+                                 else
+                                 {
+                                     par3ArrayOfByte[var43 += var44] = 0;
+                                 }
+                                 if(ENABLE_FRINGE_LAND) {
+                             		var47 += var49;
+                             	}
+                             }
+
+                             var34 += var38;
+                             var36 += var40;
+                         }
+
+                         var15 += var23;
+                         var17 += var25;
+                         var19 += var27;
+                         var21 += var29;
+                     }
+                 }
+             }
+         }
+    	 for(int i = 0; i < 16; i++) for(int j = 0; j < 16; j++) for(int k = 0; k < 16; k++) {
+    		 int blockId = par3ArrayOfByte[i << 8 | k << 4 | j] & 0xFF;
+    		 if(blockId != 0) storage.setExtBlockID(i, j, k, blockId);
+    	 }
+    	 storage.isPrototype = true;
+    }
+    
+    @Override
+	public void decorateExtraChunk(Chunk chunk, BigInteger x, int y, BigInteger z, ExtendedBlockStorage blockStorage) {
+    	blockStorage.isPrototype = false;
+    	if (blockStorage.getBlockRefCnt() <= 0) return;
+//    	this.rand.setSeed(((long)x.longValue() * 341873128712L + (long)z.longValue() * 132897987541L) ^ (0x5555555555555555L >>> y));
+    	this.rand.setSeed((long)x.longValue() * 341873128712L + (long)z.longValue() * 132897987541L);
+    	ExtendedBlockStorage upperStorage = chunk.getBlockStorage(y + 1);
+    	if (!upperStorage.isPrototype) {
+    		upperStorage = new ExtendedBlockStorage(y + 1);
+    		generateExtraBlockStorage(x, y + 1, z, upperStorage);
+    	}
+    	BiomeGenBase[] biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(null, x.shiftLeft(4), z.shiftLeft(4), 16, 16);
+    	replaceBlocksForBiome(x, y, z, biomesForGeneration, blockStorage, upperStorage);
+    }
+    
+    public void replaceBlocksForBiome(BigInteger chunkX, int chunkY, BigInteger chunkZ, BiomeGenBase[] par4ArrayOfBiomeGenBase, ExtendedBlockStorage storage, ExtendedBlockStorage upperStorage)
+    {
+        double var6 = 0.03125D;
+        // X, Y, 0 -> X. 0, Y
+        this.stoneNoise = this.noiseGen4.generateNoiseOctaves(this.stoneNoise, chunkX.shiftLeft(4), BigInteger.ZERO, chunkZ.shiftLeft(4), 16, 1, 16, var6 * 2.0D, var6 * 2.0D, var6 * 2.0D);
+
+        for (int z = 0; z < 16; ++z)
+        {
+            for (int x = 0; x < 16; ++x)
+            {
+                BiomeGenBase biome = par4ArrayOfBiomeGenBase[x + z * 16];
+                float temperature = biome.getFloatTemperature();
+                int dirtLayerHeight = Math.min((int)(this.stoneNoise[z + x * 16] / 3.0D + 3.0D + this.rand.nextDouble() * 0.25D), 16); // clamp to 16 blocks
+                int currentHeight = -1;
+                byte topBlockId = biome.topBlock;
+                byte fillerBlockId = biome.fillerBlock;
+
+                for (int y = 31; y >= 0; --y)
+                {
+                    byte blockId = (byte) (y > 15 ? upperStorage : storage).getExtBlockID(x, y & 0xF, z);
+
+                    if (blockId == 0)
+                    {
+                        currentHeight = -1;
+                    }
+                    else if (blockId == Block.stone.blockID)
+                    {
+                        if (currentHeight == -1)
+                        {
+                            if (dirtLayerHeight <= 0)
+                            {
+                                topBlockId = 0;
+                                fillerBlockId = (byte)Block.stone.blockID;
+                            }
+
+                            currentHeight = dirtLayerHeight;
+
+                            if (y < 16) {
+                            	if (chunkY > 0)
+                                {
+                                	storage.setExtBlockID(x, y, z, topBlockId);
+                                }
+                                else
+                                {
+                                	storage.setExtBlockID(x, y, z, fillerBlockId);
+                                }
+                            }
+                        }
+                        else if (currentHeight > 0)
+                        {
+                            --currentHeight;
+                            if (y < 16) {
+                            	storage.setExtBlockID(x, y, z, fillerBlockId);
+                            }
+
+                            if (currentHeight == 0 && fillerBlockId == Block.sand.blockID)
+                            {
+                                currentHeight = this.rand.nextInt(4);
+                                fillerBlockId = (byte)Block.sandStone.blockID;
+                            }
+                        }
+                    } else {
+                    	System.out.println("WTF");
+                    }
+                }
+            }
+        }
+    }
+
     /**
      * Checks to see if a chunk exists at x, y
      */

src/minecraft/net/minecraft/src/ChunkProviderHell.java

@@ -96,8 +96,8 @@ public class ChunkProviderHell implements IChunkProvider
 
                         for (int var41 = 0; var41 < 4; ++var41)
                         {
-                            int var42 = var41 + var9 * 4 << 11 | 0 + var10 * 4 << 7 | var11 * 8 + var30;
-                            short var43 = 128;
+                            int var42 = var41 + var9 * 4 << 12 | 0 + var10 * 4 << 8 | var11 * 8 + var30;
+                            short var43 = 256;
                             double var44 = 0.25D;
                             double var46 = var33;
                             double var48 = (var35 - var33) * var44;
@@ -160,7 +160,7 @@ public class ChunkProviderHell implements IChunkProvider
 
                 for (int var15 = 127; var15 >= 0; --var15)
                 {
-                    int var16 = (var8 * 16 + var7) * 128 + var15;
+                    int var16 = (var8 * 16 + var7) * 256 + var15;
 
                     if (var15 < 127 - this.hellRNG.nextInt(5) && var15 > 0 + this.hellRNG.nextInt(5))
                     {
@@ -252,7 +252,7 @@ public class ChunkProviderHell implements IChunkProvider
     public Chunk provideChunk(BigInteger par1, BigInteger par2)
     {
         this.hellRNG.setSeed((long)par1.longValue() * 341873128712L + (long)par2.longValue()* 132897987541L);
-        byte[] var3 = new byte[32768];
+        byte[] var3 = new byte[65536];
         this.generateNetherTerrain(par1, par2, var3);
         this.replaceBlocksForBiome(par1, par2, var3);
         this.netherCaveGenerator.generate(this, this.worldObj, par1, par2, var3);

src/minecraft/net/minecraft/src/ChunkProviderServer.java

@@ -333,4 +333,13 @@ public class ChunkProviderServer implements IChunkProvider
     {
         return this.loadedChunkHashMap.size();
     }
+    
+    public void generateExtraBlockStorage(BigInteger x, int y, BigInteger z, ExtendedBlockStorage storage) {
+    	this.currentChunkProvider.generateExtraBlockStorage(x, y, z, storage);
+    }
+
+	@Override
+	public void decorateExtraChunk(Chunk chunk, BigInteger x, int y, BigInteger z, ExtendedBlockStorage blockStorage) {
+		this.currentChunkProvider.decorateExtraChunk(chunk, x, y, z, blockStorage);
+	}
 }

src/minecraft/net/minecraft/src/CommandServerTp.java

@@ -63,7 +63,7 @@ public class CommandServerTp extends CommandBase
                 int var5 = par2ArrayOfStr.length - 3;
                 int var6 = 30000000;
                 BigDecimal var7 = parseBigDecimal(par1ICommandSender, par2ArrayOfStr[var5++]);
-                int var8 = parseIntBounded(par1ICommandSender, par2ArrayOfStr[var5++], 0, 256);
+                int var8 = parseInt(par1ICommandSender, par2ArrayOfStr[var5++]);
                 BigDecimal var9 = parseBigDecimal(par1ICommandSender, par2ArrayOfStr[var5++]);
                 var4.serverForThisPlayer.setPlayerLocation(var7.add(BigDecimal.valueOf(0.5)), (double)var8, var9.add(BigDecimal.valueOf(0.5)), var4.rotationYaw, var4.rotationPitch);
                 notifyAdmins(par1ICommandSender, "commands.tp.coordinates", new Object[] {var4.getEntityName(), var7.toString(), Integer.valueOf(var8), var9.toString()});

src/minecraft/net/minecraft/src/Entity.java

@@ -467,10 +467,10 @@ public abstract class Entity
             this.fallDistance *= 0.5F;
         }
 
-        if (this.posY < -64.0D)
-        {
-            this.kill();
-        }
+//        if (this.posY < -64.0D)
+//        {
+//            this.kill();
+//        }
 
         if (!this.worldObj.isRemote)
         {

src/minecraft/net/minecraft/src/EntityPlayerMP.java

@@ -24,8 +24,9 @@ public class EntityPlayerMP extends EntityPlayer implements ICrafting
 
     /** The ItemInWorldManager belonging to this player */
     public ItemInWorldManager theItemInWorldManager;
-    public BigDecimal field_71131_d = BigDecimal.ZERO;
-    public BigDecimal field_71132_e = BigDecimal.ZERO;
+    public BigDecimal lastTrackX = BigDecimal.ZERO;
+    public BigDecimal lastTrackZ = BigDecimal.ZERO;
+    public double lastTrackY = 0d;
     public final List chunksToLoad = new LinkedList();
 
     /** entities added to this list will  be packet29'd to the player */
@@ -173,7 +174,7 @@ public class EntityPlayerMP extends EntityPlayer implements ICrafting
 
         if (!this.chunksToLoad.isEmpty())
         {
-            ArrayList var6 = new ArrayList();
+            ArrayList<Chunk> var6 = new ArrayList<>();
             Iterator var7 = this.chunksToLoad.iterator();
             ArrayList var3 = new ArrayList();
 
@@ -192,6 +193,17 @@ public class EntityPlayerMP extends EntityPlayer implements ICrafting
             if (!var6.isEmpty())
             {
                 this.serverForThisPlayer.sendPacketToPlayer(new Packet56MapChunks(var6));
+                for(Chunk chunk : var6) {
+                	LinkedList<ExtendedBlockStorage>[] list = chunk.getExtraStorageArray();
+                    for (int i = 0; i < list.length; i++) {
+        				LinkedList<ExtendedBlockStorage> linkedList = list[i];
+        				if(linkedList == null) continue;
+        				for(ExtendedBlockStorage blockStorage : linkedList) {
+        					if (blockStorage.isPrototype) continue;
+        	            	this.serverForThisPlayer.sendPacketToPlayer(new Packet57ExtraChunk(chunk.xPosition, blockStorage.yBase, chunk.zPosition, blockStorage));
+        	            }
+        			}
+                }
                 Iterator var10 = var3.iterator();
 
                 while (var10.hasNext())

src/minecraft/net/minecraft/src/EntityRenderer.java

@@ -994,7 +994,9 @@ public class EntityRenderer
             this.mc.mcProfiler.endStartSection("culling");
             Frustrum var14 = new Frustrum();
             var14.setPosition(var7, var9, var11);
+//            long time = System.currentTimeMillis();
             this.mc.renderGlobal.clipRenderersByFrustum(var14, par1);
+//            System.out.println(System.currentTimeMillis() - time);
 
             if (var13 == 0)
             {

src/minecraft/net/minecraft/src/ExtendedBlockStorage.java

@@ -5,7 +5,7 @@ public class ExtendedBlockStorage
     /**
      * Contains the bottom-most Y block represented by this ExtendedBlockStorage. Typically a multiple of 16.
      */
-    private int yBase;
+    int yBase;
 
     /**
      * A total count of the number of non-air blocks in this block storage's Chunk.
@@ -39,6 +39,8 @@ public class ExtendedBlockStorage
     /** The NibbleArray containing a block of Sky-light data. */
     private NibbleArray skylightArray;
     
+    boolean isPrototype;
+
     public ExtendedBlockStorage(int par1)
     {
         this.yBase = par1;
@@ -46,6 +48,7 @@ public class ExtendedBlockStorage
         this.blockMetadataArray = new NibbleArray(this.blockLSBArray.length, 4);
         this.skylightArray = new NibbleArray(this.blockLSBArray.length, 4);
         this.blocklightArray = new NibbleArray(this.blockLSBArray.length, 4);
+        this.blockMSBArray = new NibbleArray(this.blockLSBArray.length, 4);
     }
 
     /**
@@ -316,4 +319,12 @@ public class ExtendedBlockStorage
         this.blockMSBArray = new NibbleArray(this.blockLSBArray.length, 4);
         return this.blockMSBArray;
     }
+
+	public int getBlockRefCnt() {
+		return this.blockRefCount;
+	}
+
+	public void setBlockRefCnt(int blockRefCnt) {
+		this.blockRefCount = blockRefCnt;
+	}
 }

src/minecraft/net/minecraft/src/IChunkProvider.java

@@ -59,4 +59,8 @@ public interface IChunkProvider
     ChunkPosition findClosestStructure(World var1, String var2, BigInteger var3, int var4, BigInteger var5);
 
     int getLoadedChunkCount();
+    
+    default void generateExtraBlockStorage(BigInteger x, int y, BigInteger z, ExtendedBlockStorage storage) {}
+
+    default void decorateExtraChunk(Chunk chunk, BigInteger x, int y, BigInteger z, ExtendedBlockStorage blockStorage) {}
 }

src/minecraft/net/minecraft/src/ItemBlock.java

@@ -72,10 +72,10 @@ public class ItemBlock extends Item
         {
             return false;
         }
-        else if (par5 == 255 && Block.blocksList[this.blockID].blockMaterial.isSolid())
+        /*else if (par5 == 255 && Block.blocksList[this.blockID].blockMaterial.isSolid())
         {
             return false;
-        }
+        }*/
         else if (par3World.canPlaceEntityOnSide(this.blockID, par4, par5, par6, false, par7, par2EntityPlayer))
         {
             Block var12 = Block.blocksList[this.blockID];

src/minecraft/net/minecraft/src/NetClientHandler.java

@@ -582,6 +582,19 @@ public class NetClientHandler extends NetHandler
         this.worldClient.setBlockAndMetadataAndInvalidate(par1Packet53BlockChange.xPosition, par1Packet53BlockChange.yPosition, par1Packet53BlockChange.zPosition, par1Packet53BlockChange.type, par1Packet53BlockChange.metadata);
     }
     
+    public void handleAddExtraChunk(Packet57ExtraChunk packet) {
+    	Chunk chunk = this.worldClient.getChunkFromChunkCoords(packet.getX(), packet.getZ());
+    	if(chunk instanceof EmptyChunk) throw new RuntimeException("Attempt send extra chunk data on empty chunk!");
+    	ExtendedBlockStorage storage = chunk.getBlockStorage(packet.getY());
+    	System.arraycopy(packet.getBlockLSB()  , 0, storage.getBlockLSBArray()       , 0, storage.getBlockLSBArray()       .length);
+    	System.arraycopy(packet.getBlockMSB()  , 0, storage.getBlockMSBArray()  .data, 0, storage.getBlockMSBArray()  .data.length);
+    	System.arraycopy(packet.getMetadata()  , 0, storage.getMetadataArray()  .data, 0, storage.getMetadataArray()  .data.length);
+    	System.arraycopy(packet.getSkyLight()  , 0, storage.getSkylightArray()  .data, 0, storage.getSkylightArray()  .data.length);
+    	System.arraycopy(packet.getBlockLight(), 0, storage.getBlocklightArray().data, 0, storage.getBlocklightArray().data.length);
+    	storage.setBlockRefCnt(packet.getBlockRefCnt());
+    	this.worldClient.markBlocksDirty(packet.getX().shiftLeft(4), packet.getY() << 4, packet.getZ().shiftLeft(4), (packet.getX().shiftLeft(4)).add(BigInteger.valueOf(16)), (packet.getY() << 4) + 16, (packet.getZ().shiftLeft(4)).add(BigInteger.valueOf(16)));
+    }
+
     public void handleKickDisconnect(Packet255KickDisconnect par1Packet255KickDisconnect)
     {
         this.netManager.networkShutdown("disconnect.kicked", new Object[0]);

src/minecraft/net/minecraft/src/NetHandler.java

@@ -410,6 +410,10 @@ public abstract class NetHandler
         this.registerPacket(par1Packet56MapChunks);
     }
     
+    public void handleAddExtraChunk(Packet57ExtraChunk packet57ExtraChunks) {
+		registerPacket(packet57ExtraChunks);
+	}
+
     /**
      * packet.processPacket is only called if this returns true
      */
@@ -417,4 +421,5 @@ public abstract class NetHandler
     {
         return false;
     }
+
 }

src/minecraft/net/minecraft/src/NetServerHandler.java

@@ -400,10 +400,10 @@ public class NetServerHandler extends NetHandler
                     return;
                 }
 
-                if (var6 >= this.mcServer.getBuildLimit())
-                {
-                    return;
-                }
+//                if (var6 >= this.mcServer.getBuildLimit())
+//                {
+//                    return;
+//                }
             }
 
             ChunkCoordinates var19 = var2.getSpawnPoint();
@@ -481,11 +481,11 @@ public class NetServerHandler extends NetHandler
 
             this.playerEntity.theItemInWorldManager.tryUseItem(this.playerEntity, var2, var3);
         }
-        else if (par1Packet15Place.getYPosition() >= this.mcServer.getBuildLimit() - 1 && (par1Packet15Place.getDirection() == 1 || par1Packet15Place.getYPosition() >= this.mcServer.getBuildLimit()))
+        /*else if (par1Packet15Place.getYPosition() >= this.mcServer.getBuildLimit() - 1 && (par1Packet15Place.getDirection() == 1 || par1Packet15Place.getYPosition() >= this.mcServer.getBuildLimit()))
         {
             this.playerEntity.serverForThisPlayer.sendPacketToPlayer(new Packet3Chat("\u00a77Height limit for building is " + this.mcServer.getBuildLimit()));
             var4 = true;
-        }
+        }*/
         else
         {
             ChunkCoordinates var10 = var2.getSpawnPoint();

src/minecraft/net/minecraft/src/NoiseGeneratorOctaves.java

@@ -33,7 +33,7 @@ public class NoiseGeneratorOctaves extends NoiseGenerator
      */
     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)
+        if (par1ArrayOfDouble == null || par1ArrayOfDouble.length < par5 * par6 * par7)
         {
             par1ArrayOfDouble = new double[par5 * par6 * par7];
         }

src/minecraft/net/minecraft/src/Packet.java

@@ -432,6 +432,7 @@ public abstract class Packet
         addIdClassMapping(54, true, false, Packet54PlayNoteBlock.class);
         addIdClassMapping(55, true, false, Packet55BlockDestroy.class);
         addIdClassMapping(56, true, false, Packet56MapChunks.class);
+        addIdClassMapping(57, true, false, Packet57ExtraChunk.class);
         addIdClassMapping(60, true, false, Packet60Explosion.class);
         addIdClassMapping(61, true, false, Packet61DoorChange.class);
         addIdClassMapping(62, true, false, Packet62LevelSound.class);

src/minecraft/net/minecraft/src/Packet57ExtraChunk.java

@@ -0,0 +1,101 @@
+package net.minecraft.src;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+import org.mcmodule.math.BigInteger;
+
+public class Packet57ExtraChunk extends Packet {
+
+	private byte[] blockLSB, blockMSB, metadata, skyLight, blockLight;
+	private BigInteger x, z;
+	private int y, blockRefCnt;
+
+	public Packet57ExtraChunk() {}
+	
+	public Packet57ExtraChunk(BigInteger x, int y, BigInteger z, ExtendedBlockStorage storage) {
+		this.x = x;
+		this.y = y;
+		this.z = z;
+		this.blockLSB    = storage.getBlockLSBArray();
+		this.blockMSB    = storage.getBlockMSBArray()  .data;
+		this.metadata    = storage.getMetadataArray()  .data;
+		this.skyLight    = storage.getSkylightArray()  .data;
+		this.blockLight  = storage.getBlocklightArray().data;
+		this.blockRefCnt = storage.getBlockRefCnt();
+	}
+	
+	@Override
+	public void readPacketData(DataInputStream var1) throws IOException {
+		this.x = readBigInteger(var1);
+		this.y = var1.readInt();
+		this.z = readBigInteger(var1);
+		this.blockLSB    = readBytesFromStream(var1);
+		this.blockMSB    = readBytesFromStream(var1);
+		this.metadata    = readBytesFromStream(var1);
+		this.skyLight    = readBytesFromStream(var1);
+		this.blockLight  = readBytesFromStream(var1);
+		this.blockRefCnt = var1.readInt();
+	}
+
+	@Override
+	public void writePacketData(DataOutputStream var1) throws IOException {
+		writeBigInteger(var1, this.x);
+		var1.writeInt(this.y);
+		writeBigInteger(var1, this.z);
+		writeByteArray(var1, this.blockLSB);
+		writeByteArray(var1, this.blockMSB);
+		writeByteArray(var1, this.metadata);
+		writeByteArray(var1, this.skyLight);
+		writeByteArray(var1, this.blockLight);
+		var1.writeInt(blockRefCnt);
+	}
+
+	@Override
+	public void processPacket(NetHandler var1) {
+		var1.handleAddExtraChunk(this);
+	}
+
+	@Override
+	public int getPacketSize() {
+		return 0;
+	}
+	
+	public byte[] getBlockLSB() {
+		return blockLSB;
+	}
+
+	public byte[] getBlockMSB() {
+		return blockMSB;
+	}
+
+	public byte[] getMetadata() {
+		return metadata;
+	}
+
+	public byte[] getSkyLight() {
+		return skyLight;
+	}
+
+	public byte[] getBlockLight() {
+		return blockLight;
+	}
+
+	public BigInteger getX() {
+		return x;
+	}
+
+	public BigInteger getZ() {
+		return z;
+	}
+
+	public int getY() {
+		return y;
+	}
+	
+	public int getBlockRefCnt() {
+		return blockRefCnt;
+	}
+
+}

src/minecraft/net/minecraft/src/PlayerInstance.java

@@ -3,6 +3,7 @@ package net.minecraft.src;
 import org.mcmodule.math.BigInteger;
 import java.util.ArrayList;
 import java.util.Iterator;
+import java.util.LinkedList;
 import java.util.List;
 
 class PlayerInstance
@@ -48,7 +49,8 @@ class PlayerInstance
     {
         if (this.playersInChunk.contains(par1EntityPlayerMP))
         {
-            par1EntityPlayerMP.serverForThisPlayer.sendPacketToPlayer(new Packet51MapChunk(PlayerManager.getWorldServer(this.myManager).getChunkFromChunkCoords(this.chunkLocation.chunkXPos, this.chunkLocation.chunkZPos), true, 0));
+        	Chunk chunk = PlayerManager.getWorldServer(this.myManager).getChunkFromChunkCoords(this.chunkLocation.chunkXPos, this.chunkLocation.chunkZPos);
+            par1EntityPlayerMP.serverForThisPlayer.sendPacketToPlayer(new Packet51MapChunk(chunk, true, 0));
             this.playersInChunk.remove(par1EntityPlayerMP);
             par1EntityPlayerMP.chunksToLoad.remove(this.chunkLocation);
 
@@ -63,6 +65,7 @@ class PlayerInstance
 
                 this.myManager.getWorldServer().theChunkProviderServer.unloadChunksIfNotNearSpawn(this.chunkLocation.chunkXPos, this.chunkLocation.chunkZPos);
             }
+
         }
 //        else System.out.println(this + " B");
     }
@@ -135,7 +138,22 @@ class PlayerInstance
                 	BigInteger var1, var2;
                     var1 = this.chunkLocation.chunkXPos.shiftLeft(4);
                     var2 = this.chunkLocation.chunkZPos.shiftLeft(4);
-                    this.sendToAllPlayersWatchingChunk(new Packet51MapChunk(PlayerManager.getWorldServer(this.myManager).getChunkFromChunkCoords(this.chunkLocation.chunkXPos, this.chunkLocation.chunkZPos), false, this.field_73260_f));
+                    Chunk chunk = PlayerManager.getWorldServer(this.myManager).getChunkFromChunkCoords(this.chunkLocation.chunkXPos, this.chunkLocation.chunkZPos);
+                    this.sendToAllPlayersWatchingChunk(new Packet51MapChunk(chunk, false, this.field_73260_f));
+                    LinkedList<ExtendedBlockStorage>[] extraStorageArray = chunk.getExtraStorageArray();
+                    for (int i = 0; i < extraStorageArray.length; i++) {
+						LinkedList<ExtendedBlockStorage> linkedList = extraStorageArray[i];
+						if (linkedList == null) continue;
+						Iterator<ExtendedBlockStorage> iterator = linkedList.iterator();
+						while (iterator.hasNext()) {
+							ExtendedBlockStorage blockStorage = iterator.next();
+							if (blockStorage.isPrototype) {
+								PlayerManager.getWorldServer(this.myManager).doDecorateExtraChunk(chunk,this.chunkLocation.chunkXPos, blockStorage.yBase, this.chunkLocation.chunkZPos, blockStorage);
+								continue;
+							}
+							sendToAllPlayersWatchingChunk(new Packet57ExtraChunk(this.chunkLocation.chunkXPos, blockStorage.yBase, this.chunkLocation.chunkZPos, blockStorage));
+						}
+					}
 
                     for (int var3 = 0; var3 < 16; ++var3)
                     {

src/minecraft/net/minecraft/src/PlayerManager.java

@@ -65,7 +65,7 @@ public class PlayerManager
         }
     }
 
-    private PlayerInstance getOrCreateChunkWatcher(BigInteger par1, BigInteger par2, boolean par3)
+    public PlayerInstance getOrCreateChunkWatcher(BigInteger par1, BigInteger par2, boolean par3)
     {
     	ChunkCoordIntPair pos = new ChunkCoordIntPair(par1, par2);
         PlayerInstance var6 = (PlayerInstance)this.allChunkWathers.get(pos);
@@ -101,8 +101,8 @@ public class PlayerManager
     	BigInteger var3 = MathHelper.toBigInteger(par1EntityPlayerMP.posZBig).shiftRight(4);
 //        int var2 = (int)par1EntityPlayerMP.posX >> 4;
 //        int var3 = (int)par1EntityPlayerMP.posZ >> 4;
-        par1EntityPlayerMP.field_71131_d = par1EntityPlayerMP.posXBig;
-        par1EntityPlayerMP.field_71132_e = par1EntityPlayerMP.posZBig;
+        par1EntityPlayerMP.lastTrackX = par1EntityPlayerMP.posXBig;
+        par1EntityPlayerMP.lastTrackZ = par1EntityPlayerMP.posZBig;
 
         for (int var4 = -this.playerViewDistance; var4 <= this.playerViewDistance; ++var4)
         {
@@ -207,38 +207,42 @@ public class PlayerManager
     public void func_72685_d(EntityPlayerMP par1EntityPlayerMP)
     {
     	// Edited
-    	BigInteger var2 = MathHelper.toBigInteger(par1EntityPlayerMP.posXBig).shiftRight(4);
-    	BigInteger var3 = MathHelper.toBigInteger(par1EntityPlayerMP.posZBig).shiftRight(4);
+    	BigInteger playerX = MathHelper.toBigInteger(par1EntityPlayerMP.posXBig).shiftRight(4);
+    	BigInteger playerZ = MathHelper.toBigInteger(par1EntityPlayerMP.posZBig).shiftRight(4);
 //        int var2 = (int)par1EntityPlayerMP.posX >> 4;
 //        int var3 = (int)par1EntityPlayerMP.posZ >> 4;
-        double var4 = par1EntityPlayerMP.field_71131_d.subtract(par1EntityPlayerMP.posXBig).doubleValue();
-        double var6 = par1EntityPlayerMP.field_71132_e.subtract(par1EntityPlayerMP.posZBig).doubleValue();
-        double var8 = var4 * var4 + var6 * var6;
+    	int playerY = (int)par1EntityPlayerMP.posY >> 4;
+        double diffX = par1EntityPlayerMP.lastTrackX.subtract(par1EntityPlayerMP.posXBig).doubleValue();
+        double diffZ = par1EntityPlayerMP.lastTrackZ.subtract(par1EntityPlayerMP.posZBig).doubleValue();
+        double diffY = par1EntityPlayerMP.lastTrackY - par1EntityPlayerMP.posY;
+        double dist = diffX * diffX + diffZ * diffZ + diffY * diffY;
 
-        if (var8 >= 64.0D)
+        if (dist >= 64.0D)
         {
-        	BigInteger var10 = MathHelper.toBigInteger(par1EntityPlayerMP.field_71131_d).shiftRight(4);
-        	BigInteger var11 = MathHelper.toBigInteger(par1EntityPlayerMP.field_71132_e).shiftRight(4);
-        	BigInteger var12 = BigInteger.valueOf(this.playerViewDistance);
-            BigInteger var13 = var2.subtract(var10);
-            BigInteger var14 = var3.subtract(var11);
+        	BigInteger lastTrackX = MathHelper.toBigInteger(par1EntityPlayerMP.lastTrackX).shiftRight(4);
+        	BigInteger lastTrackZ = MathHelper.toBigInteger(par1EntityPlayerMP.lastTrackZ).shiftRight(4);
+        	BigInteger playerViewDistance = BigInteger.valueOf(this.playerViewDistance);
+            BigInteger dx = playerX.subtract(lastTrackX);
+            BigInteger dz = playerZ.subtract(lastTrackZ);
+            int lastTrackY = (int) par1EntityPlayerMP.lastTrackY >> 4;
+            int dy = playerY - lastTrackY;
 
-            if (!var13.equals(BigInteger.ZERO) || !var14.equals(BigInteger.ZERO))
+            if (!dx.equals(BigInteger.ZERO) || !dz.equals(BigInteger.ZERO))
             {
-            	BigInteger targetX = var2.add(var12),
-            			   targetZ = var3.add(var12);
-                for (BigInteger var15 = var2.subtract(var12); var15.compareTo(targetX) <= 0; var15 = var15.add(BigInteger.ONE))
+            	BigInteger targetX = playerX.add(playerViewDistance),
+            			   targetZ = playerZ.add(playerViewDistance);
+                for (BigInteger xx = playerX.subtract(playerViewDistance); xx.compareTo(targetX) <= 0; xx = xx.add(BigInteger.ONE))
                 {
-                    for (BigInteger var16 = var3.subtract(var12); var16.compareTo(targetZ) <= 0; var16 = var16.add(BigInteger.ONE))
+                    for (BigInteger zz = playerZ.subtract(playerViewDistance); zz.compareTo(targetZ) <= 0; zz = zz.add(BigInteger.ONE))
                     {
-                        if (!this.func_72684_a(var15, var16, var10, var11, var12))
+                        if (!this.func_72684_a(xx, zz, lastTrackX, lastTrackZ, playerViewDistance))
                         {
-                            this.getOrCreateChunkWatcher(var15, var16, true).addPlayerToChunkWatchingList(par1EntityPlayerMP);
+                            this.getOrCreateChunkWatcher(xx, zz, true).addPlayerToChunkWatchingList(par1EntityPlayerMP);
                         }
 
-                        if (!this.func_72684_a(var15.subtract(var13), var16.subtract(var14), var2, var3, var12))
+                        if (!this.func_72684_a(xx.subtract(dx), zz.subtract(dz), playerX, playerZ, playerViewDistance))
                         {
-                            PlayerInstance var17 = this.getOrCreateChunkWatcher(var15.subtract(var13), var16.subtract(var14), false);
+                            PlayerInstance var17 = this.getOrCreateChunkWatcher(xx.subtract(dx), zz.subtract(dz), false);
 
                             if (var17 != null)
                             {
@@ -249,8 +253,24 @@ public class PlayerManager
                 }
 
                 this.func_72691_b(par1EntityPlayerMP);
-                par1EntityPlayerMP.field_71131_d = par1EntityPlayerMP.posXBig;
-                par1EntityPlayerMP.field_71132_e = par1EntityPlayerMP.posZBig;
+                par1EntityPlayerMP.lastTrackX = par1EntityPlayerMP.posXBig;
+                par1EntityPlayerMP.lastTrackZ = par1EntityPlayerMP.posZBig;
+                par1EntityPlayerMP.lastTrackY = par1EntityPlayerMP.posY;
+            }
+            if (dy != 0) {
+            	BigInteger targetX = playerX.add(playerViewDistance),
+            			   targetZ = playerZ.add(playerViewDistance);
+                for (BigInteger xx = playerX.subtract(playerViewDistance); xx.compareTo(targetX) <= 0; xx = xx.add(BigInteger.ONE))
+                {
+                    for (BigInteger zz = playerZ.subtract(playerViewDistance); zz.compareTo(targetZ) <= 0; zz = zz.add(BigInteger.ONE))
+                    {
+                    	Chunk chunk = theWorldServer.getChunkFromChunkCoords(xx, zz);
+                        for(int yy = playerY - this.playerViewDistance; yy <= playerY + this.playerViewDistance; yy++) {
+                        	chunk.getBlockStorage(yy);
+                        }
+                    }
+                }
+            	par1EntityPlayerMP.lastTrackY = par1EntityPlayerMP.posY;
             }
         }
     }

src/minecraft/net/minecraft/src/RenderGlobal.java

@@ -125,7 +125,7 @@ public class RenderGlobal implements IWorldAccess
     private List glRenderLists = new ArrayList();
 
     /** All render lists (fixed length 4) */
-    private RenderList[] allRenderLists = new RenderList[] {new RenderList(), new RenderList(), new RenderList(), new RenderList()};
+    private RenderList[] allRenderLists = new RenderList[] {new RenderList(), new RenderList(), new RenderList(), new RenderList(), new RenderList(), new RenderList(), new RenderList(), new RenderList(), new RenderList(), new RenderList(), new RenderList(), new RenderList()};
 
     /**
      * Previous x position when the renderers were sorted. (Once the distance moves more than 4 units they will be
@@ -551,9 +551,17 @@ public class RenderGlobal implements IWorldAccess
 //                    this.maxBlockZ = var10;
 //                }
 
+                int sdfvhsdbvfhsdhkbdkjsakjdb = this.renderChunksTall * 16;
+                int kshdjiajdfjosjofjsdhvfssd = sdfvhsdbvfhsdhkbdkjsakjdb / 2;
                 for (int var12 = 0; var12 < this.renderChunksTall; ++var12)
                 {
                     int var13 = var12 * 16;
+                    int var1000000000000000000000000 = var13 + kshdjiajdfjosjofjsdhvfssd - par2;
+                    if (var1000000000000000000000000 < 0) {
+                    	var1000000000000000000000000 -= sdfvhsdbvfhsdhkbdkjsakjdb - 1;
+                    }
+                    var1000000000000000000000000 /= sdfvhsdbvfhsdhkbdkjsakjdb;
+                    int y = var13 - var1000000000000000000000000 * sdfvhsdbvfhsdhkbdkjsakjdb;
 
 //                    if (var13 < this.minBlockY)
 //                    {
@@ -567,7 +575,7 @@ public class RenderGlobal implements IWorldAccess
 
                     WorldRenderer var14 = this.worldRenderers[(var9 * this.renderChunksTall + var12) * this.renderChunksWide + var6];
                     boolean var15 = var14.needsUpdate;
-                    var14.setPosition(x, var13, z);
+                    var14.setPosition(x, y, z);
 
                     if (!var15 && var14.needsUpdate)
                     { // WTF this is a unreachable code.
@@ -862,6 +870,7 @@ public class RenderGlobal implements IWorldAccess
             if (var17 < 0)
             {
                 var17 = var14++;
+                if(var17 >= this.allRenderLists.length) var17 = this.allRenderLists.length - 1;
                 this.allRenderLists[var17].func_78422_a(var22.posXMinus, var22.posYMinus, var22.posZMinus, var20, var10, var12);
             }
         }

src/minecraft/net/minecraft/src/RenderList.java

@@ -59,7 +59,7 @@ public class RenderList
             {
                 GL11.glPushMatrix();
                 if(profiler != null) profiler.startSection("translate");
-                GL11.glTranslatef((float)(MathHelper.toBigDecimal(this.field_78429_a).subtract(this.field_78425_d).floatValue()), (float)((double)this.field_78427_b - this.field_78426_e), (float)(MathHelper.toBigDecimal(this.field_78428_c).subtract(this.field_78423_f).floatValue()));
+                GL11.glTranslated((float)(MathHelper.toBigDecimal(this.field_78429_a).subtract(this.field_78425_d).floatValue()), (this.field_78427_b - this.field_78426_e), (float)(MathHelper.toBigDecimal(this.field_78428_c).subtract(this.field_78423_f).floatValue()));
                 if(profiler != null) profiler.endStartSection("opengl");
                 GL11.glCallLists(this.field_78424_g);
                 if(profiler != null) profiler.endSection();

src/minecraft/net/minecraft/src/ServerConfigurationManager.java

@@ -145,10 +145,10 @@ public abstract class ServerConfigurationManager
         this.playerEntityList.add(par1EntityPlayerMP);
         WorldServer var2 = this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension);
 
-        while (!var2.getCollidingBoundingBoxes(par1EntityPlayerMP, ((Entity)par1EntityPlayerMP).boundingBox).isEmpty())
-        {
-            par1EntityPlayerMP.setPosition(par1EntityPlayerMP.posX, par1EntityPlayerMP.posY + 1.0D, par1EntityPlayerMP.posZ);
-        }
+//        while (!var2.getCollidingBoundingBoxes(par1EntityPlayerMP, ((Entity)par1EntityPlayerMP).boundingBox).isEmpty())
+//        {
+//            par1EntityPlayerMP.setPosition(par1EntityPlayerMP.posX, par1EntityPlayerMP.posY + 1.0D, par1EntityPlayerMP.posZ);
+//        }
 
         var2.spawnEntityInWorld(par1EntityPlayerMP);
         this.func_72375_a(par1EntityPlayerMP, (WorldServer)null);

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

@@ -256,7 +256,6 @@ public abstract class World implements IBlockAccess
      */
     public int getBlockId(BigInteger par1, int par2, BigInteger par3)
     {
-    	if(par2 > 256 || par2 < 0) return 0;
         return this.getChunkFromChunkCoords(par1.shiftRight(4), par3.shiftRight(4)).getBlockID(par1.intValue() & 0xF, par2, par3.intValue() & 0xF);
     }
 
@@ -344,16 +343,6 @@ public abstract class World implements IBlockAccess
      * metadata, needsUpdate
      */
     public boolean setBlockAndMetadataWithUpdate(BigInteger par1, int par2, BigInteger par3, int par4, int par5, boolean par6)
-    {
-    	if (par2 < 0)
-        {
-            return false;
-        }
-        else if (par2 >= 256)
-        {
-            return false;
-        }
-        else
     {
     	Chunk var7 = this.getChunkFromChunkCoords(par1.shiftRight(4), par3.shiftRight(4));
         boolean var8 = var7.setBlockIDWithMetadata(par1.intValue() & 0xF, par2, par3.intValue() & 0xF, par4, par5);
@@ -368,22 +357,11 @@ public abstract class World implements IBlockAccess
 
         return var8;
     }
-    }
 
     /**
      * Sets the block to the specified blockID at the block coordinates Args x, y, z, blockID
      */
     public boolean setBlock(BigInteger par1, int par2, BigInteger par3, int par4)
-    {
-    	if (par2 < 0)
-        {
-            return false;
-        }
-        else if (par2 >= 256)
-        {
-            return false;
-        }
-        else
     {
     	Chunk var5 = this.getChunkFromChunkCoords(par1.shiftRight(4), par3.shiftRight(4));
         boolean var6 = var5.setBlockID(par1.intValue() & 0xF, par2, par3.intValue() & 0xF, par4);
@@ -398,7 +376,6 @@ public abstract class World implements IBlockAccess
 
         return var6;
     }
-    }
 
     /**
      * Returns the block's material.
@@ -413,21 +390,10 @@ public abstract class World implements IBlockAccess
      * Returns the block metadata at coords x,y,z
      */
     public int getBlockMetadata(BigInteger par1, int par2, BigInteger par3)
-    {
-    	if (par2 < 0)
-        {
-            return 0;
-        }
-        else if (par2 >= 256)
-        {
-            return 0;
-        }
-        else
     {
     	Chunk var4 = this.getChunkFromChunkCoords(par1.shiftRight(4), par3.shiftRight(4));
         return var4.getBlockMetadata(par1.intValue() & 0xF, par2, par3.intValue() & 0xF);
     }
-    }
 
     /**
      * Sets the blocks metadata and if set will then notify blocks that this block changed. Args: x, y, z, metadata
@@ -444,16 +410,6 @@ public abstract class World implements IBlockAccess
      * Set the metadata of a block in global coordinates
      */
     public boolean setBlockMetadata(BigInteger par1, int par2, BigInteger par3, int par4)
-    {
-    	if (par2 < 0)
-        {
-            return false;
-        }
-        else if (par2 >= 256)
-        {
-            return false;
-        }
-        else
     {
     	Chunk var5 = this.getChunkFromChunkCoords(par1.shiftRight(4), par3.shiftRight(4));
         int var6 = par1.intValue() & 0xF;
@@ -467,7 +423,6 @@ public abstract class World implements IBlockAccess
 
         return var8;
     }
-    }
 
     /**
      * Sets a block and notifies relevant systems with the block change  Args: x, y, z, blockID
@@ -1366,7 +1321,7 @@ public abstract class World implements IBlockAccess
         BigInteger var8 = MathHelper.floor_double_BigInteger(par2AxisAlignedBB.maxZ + 1.0D);
         
         // temporary fix
-        if(var3.subtract(var4).abs().compareTo(BigInteger.valueOf(1024)) == 1 || var7.subtract(var8).abs().compareTo(BigInteger.valueOf(1024)) == 1) return collidingBoundingBoxes;
+        if(var3.subtract(var4).abs().compareTo(BigInteger.valueOf(1024)) == 1 || var7.subtract(var8).abs().compareTo(BigInteger.valueOf(1024)) == 1 || Math.abs(var6 - var5) > 1024) return collidingBoundingBoxes;
 
         for (BigInteger var9 = var3; var9.compareTo(var4) == -1; var9 = var9.add(BigInteger.ONE))
         {
@@ -3878,4 +3833,12 @@ public abstract class World implements IBlockAccess
             var7.destroyBlockPartially(par1, par2, par3, par4, par5);
         }
     }
+
+	public void addExtraChunk(BigInteger x, int y, BigInteger z, ExtendedBlockStorage blockStorage) {
+		chunkProvider.generateExtraBlockStorage(x, y, z, blockStorage);
+	}
+
+	public void doDecorateExtraChunk(Chunk chunk, BigInteger x, int y, BigInteger z, ExtendedBlockStorage blockStorage) {
+		chunkProvider.decorateExtraChunk(chunk, x, y, z, blockStorage);
+	}
 }

src/minecraft/net/minecraft/src/WorldRenderer.java

@@ -107,7 +107,7 @@ public class WorldRenderer
             this.posYPlus = par2 + 8;
             this.posZPlus = par3.add(BigInteger.valueOf(8));
             this.posXClip = par1.intValue() & 1023;
-            this.posYClip = par2;
+            this.posYClip = par2 & 1023;
             this.posZClip = par3.intValue() & 1023;
             this.posXMinus = par1.subtract(BigInteger.valueOf(posXClip));
             this.posYMinus = par2 - this.posYClip;
@@ -317,7 +317,9 @@ public class WorldRenderer
 
     public void updateInFrustum(ICamera par1ICamera)
     {
+//    	long time = System.currentTimeMillis();
         this.isInFrustum = par1ICamera.isBoundingBoxInFrustum(this.rendererBoundingBox);
+//        System.out.println("> " + (System.currentTimeMillis() - time));
     }
 
     /**

src/minecraft/net/minecraft/src/WorldServer.java

@@ -554,6 +554,26 @@ public class WorldServer extends World
         return this.theChunkProviderServer;
     }
     
+    public void addExtraChunk(BigInteger x, int y, BigInteger z, ExtendedBlockStorage blockStorage) {
+//    	long time = System.currentTimeMillis();
+    	super.addExtraChunk(x, y, z, blockStorage);
+//    	System.out.println(System.currentTimeMillis() - time);
+//    	if(thePlayerManager == null || blockStorage.isEmpty()) return;
+//    	PlayerInstance instance = thePlayerManager.getOrCreateChunkWatcher(x, z, false);
+//    	if(instance != null) {
+//    		instance.sendToAllPlayersWatchingChunk(new Packet57ExtraChunk(x, y, z, blockStorage));
+//    	}
+    }
+    
+    public void doDecorateExtraChunk(Chunk chunk, BigInteger x, int y, BigInteger z, ExtendedBlockStorage blockStorage) {
+    	super.doDecorateExtraChunk(chunk, x, y, z, blockStorage);
+    	if(thePlayerManager == null || blockStorage.isEmpty()) return;
+    	PlayerInstance instance = thePlayerManager.getOrCreateChunkWatcher(x, z, false);
+    	if(instance != null) {
+    		instance.sendToAllPlayersWatchingChunk(new Packet57ExtraChunk(x, y, z, blockStorage));
+    	}
+    }
+
     /**
      * pars: min x,y,z , max x,y,z
      */