Add a "corrupted" world generation.

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

@@ -184,6 +184,7 @@ public class Chunk
     		for(ExtendedBlockStorage blockStorage : list) if(blockStorage.yBase == yBase) return blockStorage;
     		ExtendedBlockStorage blockStorage = new ExtendedBlockStorage(yBase);
     		list.add(blockStorage);
+    		worldObj.addExtraChunk(xPosition, yBase, zPosition, blockStorage);
     		return blockStorage;
     	} else {
     		ExtendedBlockStorage blockStorage;
@@ -1429,4 +1430,8 @@ public class Chunk
 //            }
 //        }
     }
+
+	public LinkedList<ExtendedBlockStorage>[] getExtraStorageArray() {
+		return extraStorageArray;
+	}
 }

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

@@ -205,7 +205,7 @@ public class ChunkProviderGenerate implements IChunkProvider
 
                     if (var16 <= 0 + this.rand.nextInt(5))
                     {
-                        par3ArrayOfByte[var17] = (byte)Block.bedrock.blockID;
+//                        par3ArrayOfByte[var17] = (byte)Block.bedrock.blockID;
                     }
                     else
                     {
@@ -464,6 +464,84 @@ public class ChunkProviderGenerate implements IChunkProvider
         return par1ArrayOfDouble;
     }
     
+    // FIXME
+    public void generateExtraBlockStorage(BigInteger x, int y, BigInteger z, ExtendedBlockStorage storage) {
+    	byte var4 = 4;
+        byte var5 = 2;
+        byte var6 = 63;
+        int var7 = var4 + 1;
+        byte var8 = 3;
+        int var9 = var4 + 1;
+        byte[] par3ArrayOfByte = storage.getBlockLSBArray();
+        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 * var4, z.multiply(BigInteger.valueOf(var4)), var7, var8, var9);
+    	 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;
+
+                     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;
+                     }
+                 }
+             }
+         }
+    }
+
     /**
      * Checks to see if a chunk exists at x, y
      */

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

@@ -333,4 +333,8 @@ 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);
+    }
 }

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

@@ -63,7 +63,7 @@ public class CommandServerTp extends CommandBase
                 int var5 = par2ArrayOfStr.length - 3;
                 int var6 = 30000000;
                 BigInteger var7 = parseBigInt(par1ICommandSender, par2ArrayOfStr[var5++]);
-                int var8 = parseIntBounded(par1ICommandSender, par2ArrayOfStr[var5++], 0, 256);
+                int var8 = parseInt(par1ICommandSender, par2ArrayOfStr[var5++]);
                 BigInteger var9 = parseBigInt(par1ICommandSender, par2ArrayOfStr[var5++]);
                 var4.serverForThisPlayer.setPlayerLocation(MathHelper.toBigDecimal(var7).add(BigDecimal.valueOf(0.5)), (double)var8, MathHelper.toBigDecimal(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

@@ -173,7 +173,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 +192,16 @@ 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) {
+        	            	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

@@ -46,6 +46,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);
     }
 
     /**

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

@@ -59,4 +59,6 @@ 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) {}
 }

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

@@ -582,6 +582,16 @@ public class NetClientHandler extends NetHandler
         this.worldClient.setBlockAndMetadataAndInvalidate(par1Packet53BlockChange.xPosition, par1Packet53BlockChange.yPosition, par1Packet53BlockChange.zPosition, par1Packet53BlockChange.type, par1Packet53BlockChange.metadata);
     }
     
+    public void handleAddExtraChunk(Packet57ExtraChunk packet) {
+    	ExtendedBlockStorage storage = this.worldClient.getChunkFromChunkCoords(packet.getX(), packet.getZ()).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);
+    	this.worldClient.markBlocksDirty(packet.getX().shiftLeft(4), packet.getY() << 4, packet.getZ().shiftLeft(4), (packet.getX().shiftLeft(4)).add(BigInteger.valueOf(15)), packet.getY() + 16, (packet.getZ().shiftLeft(4)).add(BigInteger.valueOf(15)));
+    }
+
     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/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,94 @@
+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;
+	
+	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;
+	}
+	
+	@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);
+	}
+
+	@Override
+	public void writePacketData(DataOutputStream var1) throws IOException {
+		writeBigInteger(var1, this.x);
+		var1.writeInt(this.y);
+		writeBigInteger(var1, this.z);
+		writeByteArray(var1, blockLSB);
+		writeByteArray(var1, blockMSB);
+		writeByteArray(var1, metadata);
+		writeByteArray(var1, skyLight);
+		writeByteArray(var1, blockLight);
+	}
+
+	@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;
+	}
+
+}

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

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);
@@ -211,6 +211,7 @@ public class PlayerManager
     	BigInteger var3 = MathHelper.toBigInteger(par1EntityPlayerMP.posZBig).shiftRight(4);
 //        int var2 = (int)par1EntityPlayerMP.posX >> 4;
 //        int var3 = (int)par1EntityPlayerMP.posZ >> 4;
+    	int y = (int)par1EntityPlayerMP.posY >> 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;
@@ -234,6 +235,10 @@ public class PlayerManager
                         if (!this.func_72684_a(var15, var16, var10, var11, var12))
                         {
                             this.getOrCreateChunkWatcher(var15, var16, true).addPlayerToChunkWatchingList(par1EntityPlayerMP);
+                            Chunk chunk = theWorldServer.getChunkFromChunkCoords(var15, var16);
+                            for(int var17 = y - this.playerViewDistance; var17 <= y + this.playerViewDistance; var17++) {
+                            	chunk.getBlockStorage(var17);
+                            }
                         }
 
                         if (!this.func_72684_a(var15.subtract(var13), var16.subtract(var14), var2, var3, var12))

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

@@ -3833,4 +3833,8 @@ 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);
+	}
 }

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

@@ -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,16 @@ 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);
+    	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
      */