initial source code commit

src/net/minecraft/client/ClientBrandRetriever.java

@@ -0,0 +1,7 @@
+package net.minecraft.client;
+
+public class ClientBrandRetriever {
+	public static String getClientModName() {
+		return "vanilla";
+	}
+}

src/net/minecraft/client/MinecraftApplet.java

@@ -0,0 +1,87 @@
+package net.minecraft.client;
+
+import java.applet.Applet;
+import java.awt.BorderLayout;
+import java.awt.Canvas;
+import net.minecraft.src.CanvasMinecraftApplet;
+import net.minecraft.src.MinecraftAppletImpl;
+import net.minecraft.src.Session;
+
+public class MinecraftApplet extends Applet {
+	private Canvas mcCanvas;
+	private Minecraft mc;
+	private Thread mcThread = null;
+
+	public void init() {
+		this.mcCanvas = new CanvasMinecraftApplet(this);
+		boolean var1 = "true".equalsIgnoreCase(this.getParameter("fullscreen"));
+		this.mc = new MinecraftAppletImpl(this, this.mcCanvas, this, this.getWidth(), this.getHeight(), var1);
+		this.mc.minecraftUri = this.getDocumentBase().getHost();
+		if(this.getDocumentBase().getPort() > 0) {
+			this.mc.minecraftUri = this.mc.minecraftUri + ":" + this.getDocumentBase().getPort();
+		}
+
+		if(this.getParameter("username") != null && this.getParameter("sessionid") != null) {
+			this.mc.session = new Session(this.getParameter("username"), this.getParameter("sessionid"));
+			this.mc.getLogAgent().logInfo("Setting user: " + this.mc.session.username);
+			System.out.println("(Session ID is " + this.mc.session.sessionId + ")");
+		} else {
+			this.mc.session = new Session("Player", "");
+		}
+
+		this.mc.setDemo("true".equals(this.getParameter("demo")));
+		if(this.getParameter("server") != null && this.getParameter("port") != null) {
+			this.mc.setServer(this.getParameter("server"), Integer.parseInt(this.getParameter("port")));
+		}
+
+		this.mc.hideQuitButton = !"true".equals(this.getParameter("stand-alone"));
+		this.setLayout(new BorderLayout());
+		this.add(this.mcCanvas, "Center");
+		this.mcCanvas.setFocusable(true);
+		this.mcCanvas.setFocusTraversalKeysEnabled(false);
+		this.validate();
+	}
+
+	public void startMainThread() {
+		if(this.mcThread == null) {
+			this.mcThread = new Thread(this.mc, "Minecraft main thread");
+			this.mcThread.start();
+		}
+	}
+
+	public void start() {
+		if(this.mc != null) {
+			this.mc.isGamePaused = false;
+		}
+
+	}
+
+	public void stop() {
+		if(this.mc != null) {
+			this.mc.isGamePaused = true;
+		}
+
+	}
+
+	public void destroy() {
+		this.shutdown();
+	}
+
+	public void shutdown() {
+		if(this.mcThread != null) {
+			this.mc.shutdown();
+
+			try {
+				this.mcThread.join(10000L);
+			} catch (InterruptedException var4) {
+				try {
+					this.mc.shutdownMinecraftApplet();
+				} catch (Exception var3) {
+					var3.printStackTrace();
+				}
+			}
+
+			this.mcThread = null;
+		}
+	}
+}

src/net/minecraft/server/MinecraftServer.java

@@ -0,0 +1,915 @@
+package net.minecraft.server;
+
+import java.awt.GraphicsEnvironment;
+import java.io.File;
+import java.io.IOException;
+import java.security.KeyPair;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.List;
+import net.minecraft.src.AnvilSaveConverter;
+import net.minecraft.src.AxisAlignedBB;
+import net.minecraft.src.CallableIsServerModded;
+import net.minecraft.src.CallableServerMemoryStats;
+import net.minecraft.src.CallableServerProfiler;
+import net.minecraft.src.ChunkCoordinates;
+import net.minecraft.src.CommandBase;
+import net.minecraft.src.ConvertingProgressUpdate;
+import net.minecraft.src.CrashReport;
+import net.minecraft.src.DemoWorldServer;
+import net.minecraft.src.DispenserBehaviors;
+import net.minecraft.src.EntityPlayer;
+import net.minecraft.src.EnumGameType;
+import net.minecraft.src.ICommandManager;
+import net.minecraft.src.ICommandSender;
+import net.minecraft.src.ILogAgent;
+import net.minecraft.src.IPlayerUsage;
+import net.minecraft.src.IProgressUpdate;
+import net.minecraft.src.ISaveFormat;
+import net.minecraft.src.ISaveHandler;
+import net.minecraft.src.IUpdatePlayerListBox;
+import net.minecraft.src.MathHelper;
+import net.minecraft.src.MinecraftException;
+import net.minecraft.src.NetworkListenThread;
+import net.minecraft.src.Packet;
+import net.minecraft.src.Packet4UpdateTime;
+import net.minecraft.src.PlayerUsageSnooper;
+import net.minecraft.src.Profiler;
+import net.minecraft.src.RConConsoleSource;
+import net.minecraft.src.ReportedException;
+import net.minecraft.src.ServerCommandManager;
+import net.minecraft.src.ServerConfigurationManager;
+import net.minecraft.src.StringTranslate;
+import net.minecraft.src.StringUtils;
+import net.minecraft.src.ThreadMinecraftServer;
+import net.minecraft.src.World;
+import net.minecraft.src.WorldInfo;
+import net.minecraft.src.WorldManager;
+import net.minecraft.src.WorldServer;
+import net.minecraft.src.WorldServerMulti;
+import net.minecraft.src.WorldSettings;
+import net.minecraft.src.WorldType;
+
+public abstract class MinecraftServer implements ICommandSender, Runnable, IPlayerUsage {
+	private static MinecraftServer mcServer = null;
+	private final ISaveFormat anvilConverterForAnvilFile;
+	private final PlayerUsageSnooper usageSnooper = new PlayerUsageSnooper("server", this);
+	private final File anvilFile;
+	private final List tickables = new ArrayList();
+	private final ICommandManager commandManager;
+	public final Profiler theProfiler = new Profiler();
+	private String hostname;
+	private int serverPort = -1;
+	public WorldServer[] worldServers;
+	private ServerConfigurationManager serverConfigManager;
+	private boolean serverRunning = true;
+	private boolean serverStopped = false;
+	private int tickCounter = 0;
+	public String currentTask;
+	public int percentDone;
+	private boolean onlineMode;
+	private boolean canSpawnAnimals;
+	private boolean canSpawnNPCs;
+	private boolean pvpEnabled;
+	private boolean allowFlight;
+	private String motd;
+	private int buildLimit;
+	private long lastSentPacketID;
+	private long lastSentPacketSize;
+	private long lastReceivedID;
+	private long lastReceivedSize;
+	public final long[] sentPacketCountArray = new long[100];
+	public final long[] sentPacketSizeArray = new long[100];
+	public final long[] receivedPacketCountArray = new long[100];
+	public final long[] receivedPacketSizeArray = new long[100];
+	public final long[] tickTimeArray = new long[100];
+	public long[][] timeOfLastDimensionTick;
+	private KeyPair serverKeyPair;
+	private String serverOwner;
+	private String folderName;
+	private String worldName;
+	private boolean isDemo;
+	private boolean enableBonusChest;
+	private boolean worldIsBeingDeleted;
+	private String texturePack = "";
+	private boolean serverIsRunning = false;
+	private long timeOfLastWarning;
+	private String userMessage;
+	private boolean startProfiling;
+	private boolean field_104057_T = false;
+
+	public MinecraftServer(File var1) {
+		mcServer = this;
+		this.anvilFile = var1;
+		this.commandManager = new ServerCommandManager();
+		this.anvilConverterForAnvilFile = new AnvilSaveConverter(var1);
+		this.registerDispenseBehaviors();
+	}
+
+	private void registerDispenseBehaviors() {
+		DispenserBehaviors.func_96467_a();
+	}
+
+	protected abstract boolean startServer() throws IOException;
+
+	protected void convertMapIfNeeded(String var1) {
+		if(this.getActiveAnvilConverter().isOldMapFormat(var1)) {
+			this.getLogAgent().logInfo("Converting map!");
+			this.setUserMessage("menu.convertingLevel");
+			this.getActiveAnvilConverter().convertMapFormat(var1, new ConvertingProgressUpdate(this));
+		}
+
+	}
+
+	protected synchronized void setUserMessage(String var1) {
+		this.userMessage = var1;
+	}
+
+	public synchronized String getUserMessage() {
+		return this.userMessage;
+	}
+
+	protected void loadAllWorlds(String var1, String var2, long var3, WorldType var5, String var6) {
+		this.convertMapIfNeeded(var1);
+		this.setUserMessage("menu.loadingLevel");
+		this.worldServers = new WorldServer[3];
+		this.timeOfLastDimensionTick = new long[this.worldServers.length][100];
+		ISaveHandler var7 = this.anvilConverterForAnvilFile.getSaveLoader(var1, true);
+		WorldInfo var9 = var7.loadWorldInfo();
+		WorldSettings var8;
+		if(var9 == null) {
+			var8 = new WorldSettings(var3, this.getGameType(), this.canStructuresSpawn(), this.isHardcore(), var5);
+			var8.func_82750_a(var6);
+		} else {
+			var8 = new WorldSettings(var9);
+		}
+
+		if(this.enableBonusChest) {
+			var8.enableBonusChest();
+		}
+
+		for(int var10 = 0; var10 < this.worldServers.length; ++var10) {
+			byte var11 = 0;
+			if(var10 == 1) {
+				var11 = -1;
+			}
+
+			if(var10 == 2) {
+				var11 = 1;
+			}
+
+			if(var10 == 0) {
+				if(this.isDemo()) {
+					this.worldServers[var10] = new DemoWorldServer(this, var7, var2, var11, this.theProfiler, this.getLogAgent());
+				} else {
+					this.worldServers[var10] = new WorldServer(this, var7, var2, var11, var8, this.theProfiler, this.getLogAgent());
+				}
+			} else {
+				this.worldServers[var10] = new WorldServerMulti(this, var7, var2, var11, var8, this.worldServers[0], this.theProfiler, this.getLogAgent());
+			}
+
+			this.worldServers[var10].addWorldAccess(new WorldManager(this, this.worldServers[var10]));
+			if(!this.isSinglePlayer()) {
+				this.worldServers[var10].getWorldInfo().setGameType(this.getGameType());
+			}
+
+			this.serverConfigManager.setPlayerManager(this.worldServers);
+		}
+
+		this.setDifficultyForAllWorlds(this.getDifficulty());
+		this.initialWorldChunkLoad();
+	}
+
+	protected void initialWorldChunkLoad() {
+		int var5 = 0;
+		this.setUserMessage("menu.generatingTerrain");
+		byte var6 = 0;
+		this.getLogAgent().logInfo("Preparing start region for level " + var6);
+		WorldServer var7 = this.worldServers[var6];
+		ChunkCoordinates var8 = var7.getSpawnPoint();
+		long var9 = System.currentTimeMillis();
+
+		for(int var11 = -192; var11 <= 192 && this.isServerRunning(); var11 += 16) {
+			for(int var12 = -192; var12 <= 192 && this.isServerRunning(); var12 += 16) {
+				long var13 = System.currentTimeMillis();
+				if(var13 - var9 > 1000L) {
+					this.outputPercentRemaining("Preparing spawn area", var5 * 100 / 625);
+					var9 = var13;
+				}
+
+				++var5;
+				var7.theChunkProviderServer.loadChunk(var8.posX + var11 >> 4, var8.posZ + var12 >> 4);
+			}
+		}
+
+		this.clearCurrentTask();
+	}
+
+	public abstract boolean canStructuresSpawn();
+
+	public abstract EnumGameType getGameType();
+
+	public abstract int getDifficulty();
+
+	public abstract boolean isHardcore();
+
+	protected void outputPercentRemaining(String var1, int var2) {
+		this.currentTask = var1;
+		this.percentDone = var2;
+		this.getLogAgent().logInfo(var1 + ": " + var2 + "%");
+	}
+
+	protected void clearCurrentTask() {
+		this.currentTask = null;
+		this.percentDone = 0;
+	}
+
+	protected void saveAllWorlds(boolean var1) {
+		if(!this.worldIsBeingDeleted) {
+			WorldServer[] var2 = this.worldServers;
+			int var3 = var2.length;
+
+			for(int var4 = 0; var4 < var3; ++var4) {
+				WorldServer var5 = var2[var4];
+				if(var5 != null) {
+					if(!var1) {
+						this.getLogAgent().logInfo("Saving chunks for level \'" + var5.getWorldInfo().getWorldName() + "\'/" + var5.provider.getDimensionName());
+					}
+
+					try {
+						var5.saveAllChunks(true, (IProgressUpdate)null);
+					} catch (MinecraftException var7) {
+						this.getLogAgent().logWarning(var7.getMessage());
+					}
+				}
+			}
+
+		}
+	}
+
+	public void stopServer() {
+		if(!this.worldIsBeingDeleted) {
+			this.getLogAgent().logInfo("Stopping server");
+			if(this.getNetworkThread() != null) {
+				this.getNetworkThread().stopListening();
+			}
+
+			if(this.serverConfigManager != null) {
+				this.getLogAgent().logInfo("Saving players");
+				this.serverConfigManager.saveAllPlayerData();
+				this.serverConfigManager.removeAllPlayers();
+			}
+
+			this.getLogAgent().logInfo("Saving worlds");
+			this.saveAllWorlds(false);
+
+			for(int var1 = 0; var1 < this.worldServers.length; ++var1) {
+				WorldServer var2 = this.worldServers[var1];
+				var2.flush();
+			}
+
+			if(this.usageSnooper != null && this.usageSnooper.isSnooperRunning()) {
+				this.usageSnooper.stopSnooper();
+			}
+
+		}
+	}
+
+	public String getServerHostname() {
+		return this.hostname;
+	}
+
+	public void setHostname(String var1) {
+		this.hostname = var1;
+	}
+
+	public boolean isServerRunning() {
+		return this.serverRunning;
+	}
+
+	public void initiateShutdown() {
+		this.serverRunning = false;
+	}
+
+	public void run() {
+		try {
+			if(this.startServer()) {
+				long var1 = System.currentTimeMillis();
+
+				for(long var50 = 0L; this.serverRunning; this.serverIsRunning = true) {
+					long var5 = System.currentTimeMillis();
+					long var7 = var5 - var1;
+					if(var7 > 2000L && var1 - this.timeOfLastWarning >= 15000L) {
+						this.getLogAgent().logWarning("Can\'t keep up! Did the system time change, or is the server overloaded?");
+						var7 = 2000L;
+						this.timeOfLastWarning = var1;
+					}
+
+					if(var7 < 0L) {
+						this.getLogAgent().logWarning("Time ran backwards! Did the system time change?");
+						var7 = 0L;
+					}
+
+					var50 += var7;
+					var1 = var5;
+					if(this.worldServers[0].areAllPlayersAsleep()) {
+						this.tick();
+						var50 = 0L;
+					} else {
+						while(var50 > 50L) {
+							var50 -= 50L;
+							this.tick();
+						}
+					}
+
+					Thread.sleep(1L);
+				}
+			} else {
+				this.finalTick((CrashReport)null);
+			}
+		} catch (Throwable var48) {
+			var48.printStackTrace();
+			this.getLogAgent().logSevereException("Encountered an unexpected exception " + var48.getClass().getSimpleName(), var48);
+			CrashReport var2 = null;
+			if(var48 instanceof ReportedException) {
+				var2 = this.addServerInfoToCrashReport(((ReportedException)var48).getCrashReport());
+			} else {
+				var2 = this.addServerInfoToCrashReport(new CrashReport("Exception in server tick loop", var48));
+			}
+
+			File var3 = new File(new File(this.getDataDirectory(), "crash-reports"), "crash-" + (new SimpleDateFormat("yyyy-MM-dd_HH.mm.ss")).format(new Date()) + "-server.txt");
+			if(var2.saveToFile(var3, this.getLogAgent())) {
+				this.getLogAgent().logSevere("This crash report has been saved to: " + var3.getAbsolutePath());
+			} else {
+				this.getLogAgent().logSevere("We were unable to save this crash report to disk.");
+			}
+
+			this.finalTick(var2);
+		} finally {
+			try {
+				this.stopServer();
+				this.serverStopped = true;
+			} catch (Throwable var46) {
+				var46.printStackTrace();
+			} finally {
+				this.systemExitNow();
+			}
+
+		}
+
+	}
+
+	protected File getDataDirectory() {
+		return new File(".");
+	}
+
+	protected void finalTick(CrashReport var1) {
+	}
+
+	protected void systemExitNow() {
+	}
+
+	public void tick() {
+		long var1 = System.nanoTime();
+		AxisAlignedBB.getAABBPool().cleanPool();
+		++this.tickCounter;
+		if(this.startProfiling) {
+			this.startProfiling = false;
+			this.theProfiler.profilingEnabled = true;
+			this.theProfiler.clearProfiling();
+		}
+
+		this.theProfiler.startSection("root");
+		this.updateTimeLightAndEntities();
+		if(this.tickCounter % 900 == 0) {
+			this.theProfiler.startSection("save");
+			this.serverConfigManager.saveAllPlayerData();
+			this.saveAllWorlds(true);
+			this.theProfiler.endSection();
+		}
+
+		this.theProfiler.startSection("tallying");
+		this.tickTimeArray[this.tickCounter % 100] = System.nanoTime() - var1;
+		this.sentPacketCountArray[this.tickCounter % 100] = Packet.sentID - this.lastSentPacketID;
+		this.lastSentPacketID = Packet.sentID;
+		this.sentPacketSizeArray[this.tickCounter % 100] = Packet.sentSize - this.lastSentPacketSize;
+		this.lastSentPacketSize = Packet.sentSize;
+		this.receivedPacketCountArray[this.tickCounter % 100] = Packet.receivedID - this.lastReceivedID;
+		this.lastReceivedID = Packet.receivedID;
+		this.receivedPacketSizeArray[this.tickCounter % 100] = Packet.receivedSize - this.lastReceivedSize;
+		this.lastReceivedSize = Packet.receivedSize;
+		this.theProfiler.endSection();
+		this.theProfiler.startSection("snooper");
+		if(!this.usageSnooper.isSnooperRunning() && this.tickCounter > 100) {
+			this.usageSnooper.startSnooper();
+		}
+
+		if(this.tickCounter % 6000 == 0) {
+			this.usageSnooper.addMemoryStatsToSnooper();
+		}
+
+		this.theProfiler.endSection();
+		this.theProfiler.endSection();
+	}
+
+	public void updateTimeLightAndEntities() {
+		this.theProfiler.startSection("levels");
+
+		int var1;
+		for(var1 = 0; var1 < this.worldServers.length; ++var1) {
+			long var2 = System.nanoTime();
+			if(var1 == 0 || this.getAllowNether()) {
+				WorldServer var4 = this.worldServers[var1];
+				this.theProfiler.startSection(var4.getWorldInfo().getWorldName());
+				this.theProfiler.startSection("pools");
+				var4.getWorldVec3Pool().clear();
+				this.theProfiler.endSection();
+				if(this.tickCounter % 20 == 0) {
+					this.theProfiler.startSection("timeSync");
+					this.serverConfigManager.sendPacketToAllPlayersInDimension(new Packet4UpdateTime(var4.getTotalWorldTime(), var4.getWorldTime()), var4.provider.dimensionId);
+					this.theProfiler.endSection();
+				}
+
+				this.theProfiler.startSection("tick");
+
+				CrashReport var6;
+				try {
+					var4.tick();
+				} catch (Throwable var8) {
+					var6 = CrashReport.makeCrashReport(var8, "Exception ticking world");
+					var4.addWorldInfoToCrashReport(var6);
+					throw new ReportedException(var6);
+				}
+
+				try {
+					var4.updateEntities();
+				} catch (Throwable var7) {
+					var6 = CrashReport.makeCrashReport(var7, "Exception ticking world entities");
+					var4.addWorldInfoToCrashReport(var6);
+					throw new ReportedException(var6);
+				}
+
+				this.theProfiler.endSection();
+				this.theProfiler.startSection("tracker");
+				var4.getEntityTracker().updateTrackedEntities();
+				this.theProfiler.endSection();
+				this.theProfiler.endSection();
+			}
+
+			this.timeOfLastDimensionTick[var1][this.tickCounter % 100] = System.nanoTime() - var2;
+		}
+
+		this.theProfiler.endStartSection("connection");
+		this.getNetworkThread().networkTick();
+		this.theProfiler.endStartSection("players");
+		this.serverConfigManager.sendPlayerInfoToAllPlayers();
+		this.theProfiler.endStartSection("tickables");
+
+		for(var1 = 0; var1 < this.tickables.size(); ++var1) {
+			((IUpdatePlayerListBox)this.tickables.get(var1)).update();
+		}
+
+		this.theProfiler.endSection();
+	}
+
+	public boolean getAllowNether() {
+		return true;
+	}
+
+	public void startServerThread() {
+		(new ThreadMinecraftServer(this, "Server thread")).start();
+	}
+
+	public File getFile(String var1) {
+		return new File(this.getDataDirectory(), var1);
+	}
+
+	public void logInfo(String var1) {
+		this.getLogAgent().logInfo(var1);
+	}
+
+	public void logWarning(String var1) {
+		this.getLogAgent().logWarning(var1);
+	}
+
+	public WorldServer worldServerForDimension(int var1) {
+		return var1 == -1 ? this.worldServers[1] : (var1 == 1 ? this.worldServers[2] : this.worldServers[0]);
+	}
+
+	public String getHostname() {
+		return this.hostname;
+	}
+
+	public int getPort() {
+		return this.serverPort;
+	}
+
+	public String getServerMOTD() {
+		return this.motd;
+	}
+
+	public String getMinecraftVersion() {
+		return "1.5.2";
+	}
+
+	public int getCurrentPlayerCount() {
+		return this.serverConfigManager.getCurrentPlayerCount();
+	}
+
+	public int getMaxPlayers() {
+		return this.serverConfigManager.getMaxPlayers();
+	}
+
+	public String[] getAllUsernames() {
+		return this.serverConfigManager.getAllUsernames();
+	}
+
+	public String getPlugins() {
+		return "";
+	}
+
+	public String executeCommand(String var1) {
+		RConConsoleSource.consoleBuffer.resetLog();
+		this.commandManager.executeCommand(RConConsoleSource.consoleBuffer, var1);
+		return RConConsoleSource.consoleBuffer.getChatBuffer();
+	}
+
+	public boolean isDebuggingEnabled() {
+		return false;
+	}
+
+	public void logSevere(String var1) {
+		this.getLogAgent().logSevere(var1);
+	}
+
+	public void logDebug(String var1) {
+		if(this.isDebuggingEnabled()) {
+			this.getLogAgent().logInfo(var1);
+		}
+
+	}
+
+	public String getServerModName() {
+		return "vanilla";
+	}
+
+	public CrashReport addServerInfoToCrashReport(CrashReport var1) {
+		var1.func_85056_g().addCrashSectionCallable("Profiler Position", new CallableIsServerModded(this));
+		if(this.worldServers != null && this.worldServers.length > 0 && this.worldServers[0] != null) {
+			var1.func_85056_g().addCrashSectionCallable("Vec3 Pool Size", new CallableServerProfiler(this));
+		}
+
+		if(this.serverConfigManager != null) {
+			var1.func_85056_g().addCrashSectionCallable("Player Count", new CallableServerMemoryStats(this));
+		}
+
+		return var1;
+	}
+
+	public List getPossibleCompletions(ICommandSender var1, String var2) {
+		ArrayList var3 = new ArrayList();
+		if(var2.startsWith("/")) {
+			var2 = var2.substring(1);
+			boolean var10 = !var2.contains(" ");
+			List var11 = this.commandManager.getPossibleCommands(var1, var2);
+			if(var11 != null) {
+				Iterator var12 = var11.iterator();
+
+				while(var12.hasNext()) {
+					String var13 = (String)var12.next();
+					if(var10) {
+						var3.add("/" + var13);
+					} else {
+						var3.add(var13);
+					}
+				}
+			}
+
+			return var3;
+		} else {
+			String[] var4 = var2.split(" ", -1);
+			String var5 = var4[var4.length - 1];
+			String[] var6 = this.serverConfigManager.getAllUsernames();
+			int var7 = var6.length;
+
+			for(int var8 = 0; var8 < var7; ++var8) {
+				String var9 = var6[var8];
+				if(CommandBase.doesStringStartWith(var5, var9)) {
+					var3.add(var9);
+				}
+			}
+
+			return var3;
+		}
+	}
+
+	public static MinecraftServer getServer() {
+		return mcServer;
+	}
+
+	public String getCommandSenderName() {
+		return "Server";
+	}
+
+	public void sendChatToPlayer(String var1) {
+		this.getLogAgent().logInfo(StringUtils.stripControlCodes(var1));
+	}
+
+	public boolean canCommandSenderUseCommand(int var1, String var2) {
+		return true;
+	}
+
+	public String translateString(String var1, Object... var2) {
+		return StringTranslate.getInstance().translateKeyFormat(var1, var2);
+	}
+
+	public ICommandManager getCommandManager() {
+		return this.commandManager;
+	}
+
+	public KeyPair getKeyPair() {
+		return this.serverKeyPair;
+	}
+
+	public int getServerPort() {
+		return this.serverPort;
+	}
+
+	public void setServerPort(int var1) {
+		this.serverPort = var1;
+	}
+
+	public String getServerOwner() {
+		return this.serverOwner;
+	}
+
+	public void setServerOwner(String var1) {
+		this.serverOwner = var1;
+	}
+
+	public boolean isSinglePlayer() {
+		return this.serverOwner != null;
+	}
+
+	public String getFolderName() {
+		return this.folderName;
+	}
+
+	public void setFolderName(String var1) {
+		this.folderName = var1;
+	}
+
+	public void setWorldName(String var1) {
+		this.worldName = var1;
+	}
+
+	public String getWorldName() {
+		return this.worldName;
+	}
+
+	public void setKeyPair(KeyPair var1) {
+		this.serverKeyPair = var1;
+	}
+
+	public void setDifficultyForAllWorlds(int var1) {
+		for(int var2 = 0; var2 < this.worldServers.length; ++var2) {
+			WorldServer var3 = this.worldServers[var2];
+			if(var3 != null) {
+				if(var3.getWorldInfo().isHardcoreModeEnabled()) {
+					var3.difficultySetting = 3;
+					var3.setAllowedSpawnTypes(true, true);
+				} else if(this.isSinglePlayer()) {
+					var3.difficultySetting = var1;
+					var3.setAllowedSpawnTypes(var3.difficultySetting > 0, true);
+				} else {
+					var3.difficultySetting = var1;
+					var3.setAllowedSpawnTypes(this.allowSpawnMonsters(), this.canSpawnAnimals);
+				}
+			}
+		}
+
+	}
+
+	protected boolean allowSpawnMonsters() {
+		return true;
+	}
+
+	public boolean isDemo() {
+		return this.isDemo;
+	}
+
+	public void setDemo(boolean var1) {
+		this.isDemo = var1;
+	}
+
+	public void canCreateBonusChest(boolean var1) {
+		this.enableBonusChest = var1;
+	}
+
+	public ISaveFormat getActiveAnvilConverter() {
+		return this.anvilConverterForAnvilFile;
+	}
+
+	public void deleteWorldAndStopServer() {
+		this.worldIsBeingDeleted = true;
+		this.getActiveAnvilConverter().flushCache();
+
+		for(int var1 = 0; var1 < this.worldServers.length; ++var1) {
+			WorldServer var2 = this.worldServers[var1];
+			if(var2 != null) {
+				var2.flush();
+			}
+		}
+
+		this.getActiveAnvilConverter().deleteWorldDirectory(this.worldServers[0].getSaveHandler().getWorldDirectoryName());
+		this.initiateShutdown();
+	}
+
+	public String getTexturePack() {
+		return this.texturePack;
+	}
+
+	public void setTexturePack(String var1) {
+		this.texturePack = var1;
+	}
+
+	public void addServerStatsToSnooper(PlayerUsageSnooper var1) {
+		var1.addData("whitelist_enabled", Boolean.valueOf(false));
+		var1.addData("whitelist_count", Integer.valueOf(0));
+		var1.addData("players_current", Integer.valueOf(this.getCurrentPlayerCount()));
+		var1.addData("players_max", Integer.valueOf(this.getMaxPlayers()));
+		var1.addData("players_seen", Integer.valueOf(this.serverConfigManager.getAvailablePlayerDat().length));
+		var1.addData("uses_auth", Boolean.valueOf(this.onlineMode));
+		var1.addData("gui_state", this.getGuiEnabled() ? "enabled" : "disabled");
+		var1.addData("avg_tick_ms", Integer.valueOf((int)(MathHelper.average(this.tickTimeArray) * 1.0E-6D)));
+		var1.addData("avg_sent_packet_count", Integer.valueOf((int)MathHelper.average(this.sentPacketCountArray)));
+		var1.addData("avg_sent_packet_size", Integer.valueOf((int)MathHelper.average(this.sentPacketSizeArray)));
+		var1.addData("avg_rec_packet_count", Integer.valueOf((int)MathHelper.average(this.receivedPacketCountArray)));
+		var1.addData("avg_rec_packet_size", Integer.valueOf((int)MathHelper.average(this.receivedPacketSizeArray)));
+		int var2 = 0;
+
+		for(int var3 = 0; var3 < this.worldServers.length; ++var3) {
+			if(this.worldServers[var3] != null) {
+				WorldServer var4 = this.worldServers[var3];
+				WorldInfo var5 = var4.getWorldInfo();
+				var1.addData("world[" + var2 + "][dimension]", Integer.valueOf(var4.provider.dimensionId));
+				var1.addData("world[" + var2 + "][mode]", var5.getGameType());
+				var1.addData("world[" + var2 + "][difficulty]", Integer.valueOf(var4.difficultySetting));
+				var1.addData("world[" + var2 + "][hardcore]", Boolean.valueOf(var5.isHardcoreModeEnabled()));
+				var1.addData("world[" + var2 + "][generator_name]", var5.getTerrainType().getWorldTypeName());
+				var1.addData("world[" + var2 + "][generator_version]", Integer.valueOf(var5.getTerrainType().getGeneratorVersion()));
+				var1.addData("world[" + var2 + "][height]", Integer.valueOf(this.buildLimit));
+				var1.addData("world[" + var2 + "][chunks_loaded]", Integer.valueOf(var4.getChunkProvider().getLoadedChunkCount()));
+				++var2;
+			}
+		}
+
+		var1.addData("worlds", Integer.valueOf(var2));
+	}
+
+	public void addServerTypeToSnooper(PlayerUsageSnooper var1) {
+		var1.addData("singleplayer", Boolean.valueOf(this.isSinglePlayer()));
+		var1.addData("server_brand", this.getServerModName());
+		var1.addData("gui_supported", GraphicsEnvironment.isHeadless() ? "headless" : "supported");
+		var1.addData("dedicated", Boolean.valueOf(this.isDedicatedServer()));
+	}
+
+	public boolean isSnooperEnabled() {
+		return true;
+	}
+
+	public int textureSize() {
+		return 16;
+	}
+
+	public abstract boolean isDedicatedServer();
+
+	public boolean isServerInOnlineMode() {
+		return this.onlineMode;
+	}
+
+	public void setOnlineMode(boolean var1) {
+		this.onlineMode = var1;
+	}
+
+	public boolean getCanSpawnAnimals() {
+		return this.canSpawnAnimals;
+	}
+
+	public void setCanSpawnAnimals(boolean var1) {
+		this.canSpawnAnimals = var1;
+	}
+
+	public boolean getCanSpawnNPCs() {
+		return this.canSpawnNPCs;
+	}
+
+	public void setCanSpawnNPCs(boolean var1) {
+		this.canSpawnNPCs = var1;
+	}
+
+	public boolean isPVPEnabled() {
+		return this.pvpEnabled;
+	}
+
+	public void setAllowPvp(boolean var1) {
+		this.pvpEnabled = var1;
+	}
+
+	public boolean isFlightAllowed() {
+		return this.allowFlight;
+	}
+
+	public void setAllowFlight(boolean var1) {
+		this.allowFlight = var1;
+	}
+
+	public abstract boolean isCommandBlockEnabled();
+
+	public String getMOTD() {
+		return this.motd;
+	}
+
+	public void setMOTD(String var1) {
+		this.motd = var1;
+	}
+
+	public int getBuildLimit() {
+		return this.buildLimit;
+	}
+
+	public void setBuildLimit(int var1) {
+		this.buildLimit = var1;
+	}
+
+	public boolean isServerStopped() {
+		return this.serverStopped;
+	}
+
+	public ServerConfigurationManager getConfigurationManager() {
+		return this.serverConfigManager;
+	}
+
+	public void setConfigurationManager(ServerConfigurationManager var1) {
+		this.serverConfigManager = var1;
+	}
+
+	public void setGameType(EnumGameType var1) {
+		for(int var2 = 0; var2 < this.worldServers.length; ++var2) {
+			getServer().worldServers[var2].getWorldInfo().setGameType(var1);
+		}
+
+	}
+
+	public abstract NetworkListenThread getNetworkThread();
+
+	public boolean serverIsInRunLoop() {
+		return this.serverIsRunning;
+	}
+
+	public boolean getGuiEnabled() {
+		return false;
+	}
+
+	public abstract String shareToLAN(EnumGameType var1, boolean var2);
+
+	public int getTickCounter() {
+		return this.tickCounter;
+	}
+
+	public void enableProfiling() {
+		this.startProfiling = true;
+	}
+
+	public PlayerUsageSnooper getPlayerUsageSnooper() {
+		return this.usageSnooper;
+	}
+
+	public ChunkCoordinates getPlayerCoordinates() {
+		return new ChunkCoordinates(0, 0, 0);
+	}
+
+	public int getSpawnProtectionSize() {
+		return 16;
+	}
+
+	public boolean func_96290_a(World var1, int var2, int var3, int var4, EntityPlayer var5) {
+		return false;
+	}
+
+	public abstract ILogAgent getLogAgent();
+
+	public void func_104055_i(boolean var1) {
+		this.field_104057_T = var1;
+	}
+
+	public boolean func_104056_am() {
+		return this.field_104057_T;
+	}
+
+	public static ServerConfigurationManager getServerConfigurationManager(MinecraftServer var0) {
+		return var0.serverConfigManager;
+	}
+}

src/net/minecraft/src/AABBLocalPool.java

@@ -0,0 +1,11 @@
+package net.minecraft.src;
+
+final class AABBLocalPool extends ThreadLocal {
+	protected AABBPool createNewDefaultPool() {
+		return new AABBPool(300, 2000);
+	}
+
+	protected Object initialValue() {
+		return this.createNewDefaultPool();
+	}
+}

src/net/minecraft/src/AABBPool.java

@@ -0,0 +1,64 @@
+package net.minecraft.src;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class AABBPool {
+	private final int maxNumCleans;
+	private final int numEntriesToRemove;
+	private final List listAABB = new ArrayList();
+	private int nextPoolIndex = 0;
+	private int maxPoolIndex = 0;
+	private int numCleans = 0;
+
+	public AABBPool(int var1, int var2) {
+		this.maxNumCleans = var1;
+		this.numEntriesToRemove = var2;
+	}
+
+	public AxisAlignedBB getAABB(double var1, double var3, double var5, double var7, double var9, double var11) {
+		AxisAlignedBB var13;
+		if(this.nextPoolIndex >= this.listAABB.size()) {
+			var13 = new AxisAlignedBB(var1, var3, var5, var7, var9, var11);
+			this.listAABB.add(var13);
+		} else {
+			var13 = (AxisAlignedBB)this.listAABB.get(this.nextPoolIndex);
+			var13.setBounds(var1, var3, var5, var7, var9, var11);
+		}
+
+		++this.nextPoolIndex;
+		return var13;
+	}
+
+	public void cleanPool() {
+		if(this.nextPoolIndex > this.maxPoolIndex) {
+			this.maxPoolIndex = this.nextPoolIndex;
+		}
+
+		if(this.numCleans++ == this.maxNumCleans) {
+			int var1 = Math.max(this.maxPoolIndex, this.listAABB.size() - this.numEntriesToRemove);
+
+			while(this.listAABB.size() > var1) {
+				this.listAABB.remove(var1);
+			}
+
+			this.maxPoolIndex = 0;
+			this.numCleans = 0;
+		}
+
+		this.nextPoolIndex = 0;
+	}
+
+	public void clearPool() {
+		this.nextPoolIndex = 0;
+		this.listAABB.clear();
+	}
+
+	public int getlistAABBsize() {
+		return this.listAABB.size();
+	}
+
+	public int getnextPoolIndex() {
+		return this.nextPoolIndex;
+	}
+}

src/net/minecraft/src/Achievement.java

@@ -0,0 +1,85 @@
+package net.minecraft.src;
+
+public class Achievement extends StatBase {
+	public final int displayColumn;
+	public final int displayRow;
+	public final Achievement parentAchievement;
+	private final String achievementDescription;
+	private IStatStringFormat statStringFormatter;
+	public final ItemStack theItemStack;
+	private boolean isSpecial;
+
+	public Achievement(int var1, String var2, int var3, int var4, Item var5, Achievement var6) {
+		this(var1, var2, var3, var4, new ItemStack(var5), var6);
+	}
+
+	public Achievement(int var1, String var2, int var3, int var4, Block var5, Achievement var6) {
+		this(var1, var2, var3, var4, new ItemStack(var5), var6);
+	}
+
+	public Achievement(int var1, String var2, int var3, int var4, ItemStack var5, Achievement var6) {
+		super(5242880 + var1, "achievement." + var2);
+		this.theItemStack = var5;
+		this.achievementDescription = "achievement." + var2 + ".desc";
+		this.displayColumn = var3;
+		this.displayRow = var4;
+		if(var3 < AchievementList.minDisplayColumn) {
+			AchievementList.minDisplayColumn = var3;
+		}
+
+		if(var4 < AchievementList.minDisplayRow) {
+			AchievementList.minDisplayRow = var4;
+		}
+
+		if(var3 > AchievementList.maxDisplayColumn) {
+			AchievementList.maxDisplayColumn = var3;
+		}
+
+		if(var4 > AchievementList.maxDisplayRow) {
+			AchievementList.maxDisplayRow = var4;
+		}
+
+		this.parentAchievement = var6;
+	}
+
+	public Achievement setIndependent() {
+		this.isIndependent = true;
+		return this;
+	}
+
+	public Achievement setSpecial() {
+		this.isSpecial = true;
+		return this;
+	}
+
+	public Achievement registerAchievement() {
+		super.registerStat();
+		AchievementList.achievementList.add(this);
+		return this;
+	}
+
+	public boolean isAchievement() {
+		return true;
+	}
+
+	public String getDescription() {
+		return this.statStringFormatter != null ? this.statStringFormatter.formatString(StatCollector.translateToLocal(this.achievementDescription)) : StatCollector.translateToLocal(this.achievementDescription);
+	}
+
+	public Achievement setStatStringFormatter(IStatStringFormat var1) {
+		this.statStringFormatter = var1;
+		return this;
+	}
+
+	public boolean getSpecial() {
+		return this.isSpecial;
+	}
+
+	public StatBase registerStat() {
+		return this.registerAchievement();
+	}
+
+	public StatBase initIndependentStat() {
+		return this.setIndependent();
+	}
+}

src/net/minecraft/src/AchievementList.java

@@ -0,0 +1,46 @@
+package net.minecraft.src;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class AchievementList {
+	public static int minDisplayColumn;
+	public static int minDisplayRow;
+	public static int maxDisplayColumn;
+	public static int maxDisplayRow;
+	public static List achievementList = new ArrayList();
+	public static Achievement openInventory = (new Achievement(0, "openInventory", 0, 0, Item.book, (Achievement)null)).setIndependent().registerAchievement();
+	public static Achievement mineWood = (new Achievement(1, "mineWood", 2, 1, Block.wood, openInventory)).registerAchievement();
+	public static Achievement buildWorkBench = (new Achievement(2, "buildWorkBench", 4, -1, Block.workbench, mineWood)).registerAchievement();
+	public static Achievement buildPickaxe = (new Achievement(3, "buildPickaxe", 4, 2, Item.pickaxeWood, buildWorkBench)).registerAchievement();
+	public static Achievement buildFurnace = (new Achievement(4, "buildFurnace", 3, 4, Block.furnaceIdle, buildPickaxe)).registerAchievement();
+	public static Achievement acquireIron = (new Achievement(5, "acquireIron", 1, 4, Item.ingotIron, buildFurnace)).registerAchievement();
+	public static Achievement buildHoe = (new Achievement(6, "buildHoe", 2, -3, Item.hoeWood, buildWorkBench)).registerAchievement();
+	public static Achievement makeBread = (new Achievement(7, "makeBread", -1, -3, Item.bread, buildHoe)).registerAchievement();
+	public static Achievement bakeCake = (new Achievement(8, "bakeCake", 0, -5, Item.cake, buildHoe)).registerAchievement();
+	public static Achievement buildBetterPickaxe = (new Achievement(9, "buildBetterPickaxe", 6, 2, Item.pickaxeStone, buildPickaxe)).registerAchievement();
+	public static Achievement cookFish = (new Achievement(10, "cookFish", 2, 6, Item.fishCooked, buildFurnace)).registerAchievement();
+	public static Achievement onARail = (new Achievement(11, "onARail", 2, 3, Block.rail, acquireIron)).setSpecial().registerAchievement();
+	public static Achievement buildSword = (new Achievement(12, "buildSword", 6, -1, Item.swordWood, buildWorkBench)).registerAchievement();
+	public static Achievement killEnemy = (new Achievement(13, "killEnemy", 8, -1, Item.bone, buildSword)).registerAchievement();
+	public static Achievement killCow = (new Achievement(14, "killCow", 7, -3, Item.leather, buildSword)).registerAchievement();
+	public static Achievement flyPig = (new Achievement(15, "flyPig", 8, -4, Item.saddle, killCow)).setSpecial().registerAchievement();
+	public static Achievement snipeSkeleton = (new Achievement(16, "snipeSkeleton", 7, 0, Item.bow, killEnemy)).setSpecial().registerAchievement();
+	public static Achievement diamonds = (new Achievement(17, "diamonds", -1, 5, Item.diamond, acquireIron)).registerAchievement();
+	public static Achievement portal = (new Achievement(18, "portal", -1, 7, Block.obsidian, diamonds)).registerAchievement();
+	public static Achievement ghast = (new Achievement(19, "ghast", -4, 8, Item.ghastTear, portal)).setSpecial().registerAchievement();
+	public static Achievement blazeRod = (new Achievement(20, "blazeRod", 0, 9, Item.blazeRod, portal)).registerAchievement();
+	public static Achievement potion = (new Achievement(21, "potion", 2, 8, Item.potion, blazeRod)).registerAchievement();
+	public static Achievement theEnd = (new Achievement(22, "theEnd", 3, 10, Item.eyeOfEnder, blazeRod)).setSpecial().registerAchievement();
+	public static Achievement theEnd2 = (new Achievement(23, "theEnd2", 4, 13, Block.dragonEgg, theEnd)).setSpecial().registerAchievement();
+	public static Achievement enchantments = (new Achievement(24, "enchantments", -4, 4, Block.enchantmentTable, diamonds)).registerAchievement();
+	public static Achievement overkill = (new Achievement(25, "overkill", -4, 1, Item.swordDiamond, enchantments)).setSpecial().registerAchievement();
+	public static Achievement bookcase = (new Achievement(26, "bookcase", -3, 6, Block.bookShelf, enchantments)).registerAchievement();
+
+	public static void init() {
+	}
+
+	static {
+		System.out.println(achievementList.size() + " achievements");
+	}
+}

src/net/minecraft/src/AchievementMap.java

@@ -0,0 +1,36 @@
+package net.minecraft.src;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.HashMap;
+import java.util.Map;
+
+public class AchievementMap {
+	public static AchievementMap instance = new AchievementMap();
+	private Map guidMap = new HashMap();
+
+	private AchievementMap() {
+		try {
+			BufferedReader var1 = new BufferedReader(new InputStreamReader(AchievementMap.class.getResourceAsStream("/achievement/map.txt")));
+
+			while(true) {
+				String var2 = var1.readLine();
+				if(var2 == null) {
+					var1.close();
+					break;
+				}
+
+				String[] var3 = var2.split(",");
+				int var4 = Integer.parseInt(var3[0]);
+				this.guidMap.put(Integer.valueOf(var4), var3[1]);
+			}
+		} catch (Exception var5) {
+			var5.printStackTrace();
+		}
+
+	}
+
+	public static String getGuid(int var0) {
+		return (String)instance.guidMap.get(Integer.valueOf(var0));
+	}
+}

src/net/minecraft/src/ActiveRenderInfo.java

@@ -0,0 +1,66 @@
+package net.minecraft.src;
+
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.util.glu.GLU;
+
+public class ActiveRenderInfo {
+	public static float objectX = 0.0F;
+	public static float objectY = 0.0F;
+	public static float objectZ = 0.0F;
+	private static IntBuffer viewport = GLAllocation.createDirectIntBuffer(16);
+	private static FloatBuffer modelview = GLAllocation.createDirectFloatBuffer(16);
+	private static FloatBuffer projection = GLAllocation.createDirectFloatBuffer(16);
+	private static FloatBuffer objectCoords = GLAllocation.createDirectFloatBuffer(3);
+	public static float rotationX;
+	public static float rotationXZ;
+	public static float rotationZ;
+	public static float rotationYZ;
+	public static float rotationXY;
+
+	public static void updateRenderInfo(EntityPlayer var0, boolean var1) {
+		GL11.glGetFloat(GL11.GL_MODELVIEW_MATRIX, modelview);
+		GL11.glGetFloat(GL11.GL_PROJECTION_MATRIX, projection);
+		GL11.glGetInteger(GL11.GL_VIEWPORT, viewport);
+		float var2 = (float)((viewport.get(0) + viewport.get(2)) / 2);
+		float var3 = (float)((viewport.get(1) + viewport.get(3)) / 2);
+		GLU.gluUnProject(var2, var3, 0.0F, modelview, projection, viewport, objectCoords);
+		objectX = objectCoords.get(0);
+		objectY = objectCoords.get(1);
+		objectZ = objectCoords.get(2);
+		int var4 = var1 ? 1 : 0;
+		float var5 = var0.rotationPitch;
+		float var6 = var0.rotationYaw;
+		rotationX = MathHelper.cos(var6 * (float)Math.PI / 180.0F) * (float)(1 - var4 * 2);
+		rotationZ = MathHelper.sin(var6 * (float)Math.PI / 180.0F) * (float)(1 - var4 * 2);
+		rotationYZ = -rotationZ * MathHelper.sin(var5 * (float)Math.PI / 180.0F) * (float)(1 - var4 * 2);
+		rotationXY = rotationX * MathHelper.sin(var5 * (float)Math.PI / 180.0F) * (float)(1 - var4 * 2);
+		rotationXZ = MathHelper.cos(var5 * (float)Math.PI / 180.0F);
+	}
+
+	public static Vec3 projectViewFromEntity(EntityLiving var0, double var1) {
+		double var3 = var0.prevPosX + (var0.posX - var0.prevPosX) * var1;
+		double var5 = var0.prevPosY + (var0.posY - var0.prevPosY) * var1 + (double)var0.getEyeHeight();
+		double var7 = var0.prevPosZ + (var0.posZ - var0.prevPosZ) * var1;
+		double var9 = var3 + (double)(objectX * 1.0F);
+		double var11 = var5 + (double)(objectY * 1.0F);
+		double var13 = var7 + (double)(objectZ * 1.0F);
+		return var0.worldObj.getWorldVec3Pool().getVecFromPool(var9, var11, var13);
+	}
+
+	public static int getBlockIdAtEntityViewpoint(World var0, EntityLiving var1, float var2) {
+		Vec3 var3 = projectViewFromEntity(var1, (double)var2);
+		ChunkPosition var4 = new ChunkPosition(var3);
+		int var5 = var0.getBlockId(var4.x, var4.y, var4.z);
+		if(var5 != 0 && Block.blocksList[var5].blockMaterial.isLiquid()) {
+			float var6 = BlockFluid.getFluidHeightPercent(var0.getBlockMetadata(var4.x, var4.y, var4.z)) - 1.0F / 9.0F;
+			float var7 = (float)(var4.y + 1) - var6;
+			if(var3.yCoord >= (double)var7) {
+				var5 = var0.getBlockId(var4.x, var4.y + 1, var4.z);
+			}
+		}
+
+		return var5;
+	}
+}

src/net/minecraft/src/AnvilChunkLoader.java

@@ -0,0 +1,316 @@
+package net.minecraft.src;
+
+import java.io.DataInput;
+import java.io.DataInputStream;
+import java.io.DataOutput;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+public class AnvilChunkLoader implements IChunkLoader, IThreadedFileIO {
+	private List chunksToRemove = new ArrayList();
+	private Set pendingAnvilChunksCoordinates = new HashSet();
+	private Object syncLockObject = new Object();
+	private final File chunkSaveLocation;
+
+	public AnvilChunkLoader(File var1) {
+		this.chunkSaveLocation = var1;
+	}
+
+	public Chunk loadChunk(World var1, int var2, int var3) throws IOException {
+		NBTTagCompound var4 = null;
+		ChunkCoordIntPair var5 = new ChunkCoordIntPair(var2, var3);
+		Object var6 = this.syncLockObject;
+		synchronized(var6) {
+			if(this.pendingAnvilChunksCoordinates.contains(var5)) {
+				for(int var7 = 0; var7 < this.chunksToRemove.size(); ++var7) {
+					if(((AnvilChunkLoaderPending)this.chunksToRemove.get(var7)).chunkCoordinate.equals(var5)) {
+						var4 = ((AnvilChunkLoaderPending)this.chunksToRemove.get(var7)).nbtTags;
+						break;
+					}
+				}
+			}
+		}
+
+		if(var4 == null) {
+			DataInputStream var10 = RegionFileCache.getChunkInputStream(this.chunkSaveLocation, var2, var3);
+			if(var10 == null) {
+				return null;
+			}
+
+			var4 = CompressedStreamTools.read((DataInput)var10);
+		}
+
+		return this.checkedReadChunkFromNBT(var1, var2, var3, var4);
+	}
+
+	protected Chunk checkedReadChunkFromNBT(World var1, int var2, int var3, NBTTagCompound var4) {
+		if(!var4.hasKey("Level")) {
+			var1.getWorldLogAgent().logSevere("Chunk file at " + var2 + "," + var3 + " is missing level data, skipping");
+			return null;
+		} else if(!var4.getCompoundTag("Level").hasKey("Sections")) {
+			var1.getWorldLogAgent().logSevere("Chunk file at " + var2 + "," + var3 + " is missing block data, skipping");
+			return null;
+		} else {
+			Chunk var5 = this.readChunkFromNBT(var1, var4.getCompoundTag("Level"));
+			if(!var5.isAtLocation(var2, var3)) {
+				var1.getWorldLogAgent().logSevere("Chunk file at " + var2 + "," + var3 + " is in the wrong location; relocating. (Expected " + var2 + ", " + var3 + ", got " + var5.xPosition + ", " + var5.zPosition + ")");
+				var4.setInteger("xPos", var2);
+				var4.setInteger("zPos", var3);
+				var5 = this.readChunkFromNBT(var1, var4.getCompoundTag("Level"));
+			}
+
+			return var5;
+		}
+	}
+
+	public void saveChunk(World var1, Chunk var2) throws IOException, MinecraftException {
+		var1.checkSessionLock();
+
+		try {
+			NBTTagCompound var3 = new NBTTagCompound();
+			NBTTagCompound var4 = new NBTTagCompound();
+			var3.setTag("Level", var4);
+			this.writeChunkToNBT(var2, var1, var4);
+			this.addChunkToPending(var2.getChunkCoordIntPair(), var3);
+		} catch (Exception var5) {
+			var5.printStackTrace();
+		}
+
+	}
+
+	protected void addChunkToPending(ChunkCoordIntPair var1, NBTTagCompound var2) {
+		Object var3 = this.syncLockObject;
+		synchronized(var3) {
+			if(this.pendingAnvilChunksCoordinates.contains(var1)) {
+				for(int var4 = 0; var4 < this.chunksToRemove.size(); ++var4) {
+					if(((AnvilChunkLoaderPending)this.chunksToRemove.get(var4)).chunkCoordinate.equals(var1)) {
+						this.chunksToRemove.set(var4, new AnvilChunkLoaderPending(var1, var2));
+						return;
+					}
+				}
+			}
+
+			this.chunksToRemove.add(new AnvilChunkLoaderPending(var1, var2));
+			this.pendingAnvilChunksCoordinates.add(var1);
+			ThreadedFileIOBase.threadedIOInstance.queueIO(this);
+		}
+	}
+
+	public boolean writeNextIO() {
+		AnvilChunkLoaderPending var1 = null;
+		Object var2 = this.syncLockObject;
+		synchronized(var2) {
+			if(this.chunksToRemove.isEmpty()) {
+				return false;
+			}
+
+			var1 = (AnvilChunkLoaderPending)this.chunksToRemove.remove(0);
+			this.pendingAnvilChunksCoordinates.remove(var1.chunkCoordinate);
+		}
+
+		if(var1 != null) {
+			try {
+				this.writeChunkNBTTags(var1);
+			} catch (Exception var4) {
+				var4.printStackTrace();
+			}
+		}
+
+		return true;
+	}
+
+	private void writeChunkNBTTags(AnvilChunkLoaderPending var1) throws IOException {
+		DataOutputStream var2 = RegionFileCache.getChunkOutputStream(this.chunkSaveLocation, var1.chunkCoordinate.chunkXPos, var1.chunkCoordinate.chunkZPos);
+		CompressedStreamTools.write(var1.nbtTags, (DataOutput)var2);
+		var2.close();
+	}
+
+	public void saveExtraChunkData(World var1, Chunk var2) {
+	}
+
+	public void chunkTick() {
+	}
+
+	public void saveExtraData() {
+		while(this.writeNextIO()) {
+		}
+
+	}
+
+	private void writeChunkToNBT(Chunk var1, World var2, NBTTagCompound var3) {
+		var3.setInteger("xPos", var1.xPosition);
+		var3.setInteger("zPos", var1.zPosition);
+		var3.setLong("LastUpdate", var2.getTotalWorldTime());
+		var3.setIntArray("HeightMap", var1.heightMap);
+		var3.setBoolean("TerrainPopulated", var1.isTerrainPopulated);
+		ExtendedBlockStorage[] var4 = var1.getBlockStorageArray();
+		NBTTagList var5 = new NBTTagList("Sections");
+		boolean var6 = !var2.provider.hasNoSky;
+		ExtendedBlockStorage[] var7 = var4;
+		int var8 = var4.length;
+
+		NBTTagCompound var11;
+		for(int var9 = 0; var9 < var8; ++var9) {
+			ExtendedBlockStorage var10 = var7[var9];
+			if(var10 != null) {
+				var11 = new NBTTagCompound();
+				var11.setByte("Y", (byte)(var10.getYLocation() >> 4 & 255));
+				var11.setByteArray("Blocks", var10.getBlockLSBArray());
+				if(var10.getBlockMSBArray() != null) {
+					var11.setByteArray("Add", var10.getBlockMSBArray().data);
+				}
+
+				var11.setByteArray("Data", var10.getMetadataArray().data);
+				var11.setByteArray("BlockLight", var10.getBlocklightArray().data);
+				if(var6) {
+					var11.setByteArray("SkyLight", var10.getSkylightArray().data);
+				} else {
+					var11.setByteArray("SkyLight", new byte[var10.getBlocklightArray().data.length]);
+				}
+
+				var5.appendTag(var11);
+			}
+		}
+
+		var3.setTag("Sections", var5);
+		var3.setByteArray("Biomes", var1.getBiomeArray());
+		var1.hasEntities = false;
+		NBTTagList var16 = new NBTTagList();
+
+		Iterator var18;
+		for(var8 = 0; var8 < var1.entityLists.length; ++var8) {
+			var18 = var1.entityLists[var8].iterator();
+
+			while(var18.hasNext()) {
+				Entity var20 = (Entity)var18.next();
+				var11 = new NBTTagCompound();
+				if(var20.addEntityID(var11)) {
+					var1.hasEntities = true;
+					var16.appendTag(var11);
+				}
+			}
+		}
+
+		var3.setTag("Entities", var16);
+		NBTTagList var17 = new NBTTagList();
+		var18 = var1.chunkTileEntityMap.values().iterator();
+
+		while(var18.hasNext()) {
+			TileEntity var21 = (TileEntity)var18.next();
+			var11 = new NBTTagCompound();
+			var21.writeToNBT(var11);
+			var17.appendTag(var11);
+		}
+
+		var3.setTag("TileEntities", var17);
+		List var19 = var2.getPendingBlockUpdates(var1, false);
+		if(var19 != null) {
+			long var22 = var2.getTotalWorldTime();
+			NBTTagList var12 = new NBTTagList();
+			Iterator var13 = var19.iterator();
+
+			while(var13.hasNext()) {
+				NextTickListEntry var14 = (NextTickListEntry)var13.next();
+				NBTTagCompound var15 = new NBTTagCompound();
+				var15.setInteger("i", var14.blockID);
+				var15.setInteger("x", var14.xCoord);
+				var15.setInteger("y", var14.yCoord);
+				var15.setInteger("z", var14.zCoord);
+				var15.setInteger("t", (int)(var14.scheduledTime - var22));
+				var15.setInteger("p", var14.field_82754_f);
+				var12.appendTag(var15);
+			}
+
+			var3.setTag("TileTicks", var12);
+		}
+
+	}
+
+	private Chunk readChunkFromNBT(World var1, NBTTagCompound var2) {
+		int var3 = var2.getInteger("xPos");
+		int var4 = var2.getInteger("zPos");
+		Chunk var5 = new Chunk(var1, var3, var4);
+		var5.heightMap = var2.getIntArray("HeightMap");
+		var5.isTerrainPopulated = var2.getBoolean("TerrainPopulated");
+		NBTTagList var6 = var2.getTagList("Sections");
+		byte var7 = 16;
+		ExtendedBlockStorage[] var8 = new ExtendedBlockStorage[var7];
+		boolean var9 = !var1.provider.hasNoSky;
+
+		for(int var10 = 0; var10 < var6.tagCount(); ++var10) {
+			NBTTagCompound var11 = (NBTTagCompound)var6.tagAt(var10);
+			byte var12 = var11.getByte("Y");
+			ExtendedBlockStorage var13 = new ExtendedBlockStorage(var12 << 4, var9);
+			var13.setBlockLSBArray(var11.getByteArray("Blocks"));
+			if(var11.hasKey("Add")) {
+				var13.setBlockMSBArray(new NibbleArray(var11.getByteArray("Add"), 4));
+			}
+
+			var13.setBlockMetadataArray(new NibbleArray(var11.getByteArray("Data"), 4));
+			var13.setBlocklightArray(new NibbleArray(var11.getByteArray("BlockLight"), 4));
+			if(var9) {
+				var13.setSkylightArray(new NibbleArray(var11.getByteArray("SkyLight"), 4));
+			}
+
+			var13.removeInvalidBlocks();
+			var8[var12] = var13;
+		}
+
+		var5.setStorageArrays(var8);
+		if(var2.hasKey("Biomes")) {
+			var5.setBiomeArray(var2.getByteArray("Biomes"));
+		}
+
+		NBTTagList var17 = var2.getTagList("Entities");
+		if(var17 != null) {
+			for(int var18 = 0; var18 < var17.tagCount(); ++var18) {
+				NBTTagCompound var20 = (NBTTagCompound)var17.tagAt(var18);
+				Entity var22 = EntityList.createEntityFromNBT(var20, var1);
+				var5.hasEntities = true;
+				if(var22 != null) {
+					var5.addEntity(var22);
+					Entity var14 = var22;
+
+					for(NBTTagCompound var15 = var20; var15.hasKey("Riding"); var15 = var15.getCompoundTag("Riding")) {
+						Entity var16 = EntityList.createEntityFromNBT(var15.getCompoundTag("Riding"), var1);
+						if(var16 != null) {
+							var5.addEntity(var16);
+							var14.mountEntity(var16);
+						}
+
+						var14 = var16;
+					}
+				}
+			}
+		}
+
+		NBTTagList var19 = var2.getTagList("TileEntities");
+		if(var19 != null) {
+			for(int var21 = 0; var21 < var19.tagCount(); ++var21) {
+				NBTTagCompound var24 = (NBTTagCompound)var19.tagAt(var21);
+				TileEntity var26 = TileEntity.createAndLoadEntity(var24);
+				if(var26 != null) {
+					var5.addTileEntity(var26);
+				}
+			}
+		}
+
+		if(var2.hasKey("TileTicks")) {
+			NBTTagList var23 = var2.getTagList("TileTicks");
+			if(var23 != null) {
+				for(int var25 = 0; var25 < var23.tagCount(); ++var25) {
+					NBTTagCompound var27 = (NBTTagCompound)var23.tagAt(var25);
+					var1.scheduleBlockUpdateFromLoad(var27.getInteger("x"), var27.getInteger("y"), var27.getInteger("z"), var27.getInteger("i"), var27.getInteger("t"), var27.getInteger("p"));
+				}
+			}
+		}
+
+		return var5;
+	}
+}

src/net/minecraft/src/AnvilChunkLoaderPending.java

@@ -0,0 +1,11 @@
+package net.minecraft.src;
+
+class AnvilChunkLoaderPending {
+	public final ChunkCoordIntPair chunkCoordinate;
+	public final NBTTagCompound nbtTags;
+
+	public AnvilChunkLoaderPending(ChunkCoordIntPair var1, NBTTagCompound var2) {
+		this.chunkCoordinate = var1;
+		this.nbtTags = var2;
+	}
+}

src/net/minecraft/src/AnvilConverterData.java

@@ -0,0 +1,21 @@
+package net.minecraft.src;
+
+public class AnvilConverterData {
+	public long lastUpdated;
+	public boolean terrainPopulated;
+	public byte[] heightmap;
+	public NibbleArrayReader blockLight;
+	public NibbleArrayReader skyLight;
+	public NibbleArrayReader data;
+	public byte[] blocks;
+	public NBTTagList entities;
+	public NBTTagList tileEntities;
+	public NBTTagList tileTicks;
+	public final int x;
+	public final int z;
+
+	public AnvilConverterData(int var1, int var2) {
+		this.x = var1;
+		this.z = var2;
+	}
+}

src/net/minecraft/src/AnvilConverterException.java

@@ -0,0 +1,7 @@
+package net.minecraft.src;
+
+public class AnvilConverterException extends Exception {
+	public AnvilConverterException(String var1) {
+		super(var1);
+	}
+}

src/net/minecraft/src/AnvilSaveConverter.java

@@ -0,0 +1,194 @@
+package net.minecraft.src;
+
+import java.io.DataInput;
+import java.io.DataInputStream;
+import java.io.DataOutput;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import net.minecraft.server.MinecraftServer;
+
+public class AnvilSaveConverter extends SaveFormatOld {
+	public AnvilSaveConverter(File var1) {
+		super(var1);
+	}
+
+	public List getSaveList() throws AnvilConverterException {
+		if(this.savesDirectory != null && this.savesDirectory.exists() && this.savesDirectory.isDirectory()) {
+			ArrayList var1 = new ArrayList();
+			File[] var2 = this.savesDirectory.listFiles();
+			File[] var3 = var2;
+			int var4 = var2.length;
+
+			for(int var5 = 0; var5 < var4; ++var5) {
+				File var6 = var3[var5];
+				if(var6.isDirectory()) {
+					String var7 = var6.getName();
+					WorldInfo var8 = this.getWorldInfo(var7);
+					if(var8 != null && (var8.getSaveVersion() == 19132 || var8.getSaveVersion() == 19133)) {
+						boolean var9 = var8.getSaveVersion() != this.getSaveVersion();
+						String var10 = var8.getWorldName();
+						if(var10 == null || MathHelper.stringNullOrLengthZero(var10)) {
+							var10 = var7;
+						}
+
+						long var11 = 0L;
+						var1.add(new SaveFormatComparator(var7, var10, var8.getLastTimePlayed(), var11, var8.getGameType(), var9, var8.isHardcoreModeEnabled(), var8.areCommandsAllowed()));
+					}
+				}
+			}
+
+			return var1;
+		} else {
+			throw new AnvilConverterException("Unable to read or access folder where game worlds are saved!");
+		}
+	}
+
+	protected int getSaveVersion() {
+		return 19133;
+	}
+
+	public void flushCache() {
+		RegionFileCache.clearRegionFileReferences();
+	}
+
+	public ISaveHandler getSaveLoader(String var1, boolean var2) {
+		return new AnvilSaveHandler(this.savesDirectory, var1, var2);
+	}
+
+	public boolean isOldMapFormat(String var1) {
+		WorldInfo var2 = this.getWorldInfo(var1);
+		return var2 != null && var2.getSaveVersion() != this.getSaveVersion();
+	}
+
+	public boolean convertMapFormat(String var1, IProgressUpdate var2) {
+		var2.setLoadingProgress(0);
+		ArrayList var3 = new ArrayList();
+		ArrayList var4 = new ArrayList();
+		ArrayList var5 = new ArrayList();
+		File var6 = new File(this.savesDirectory, var1);
+		File var7 = new File(var6, "DIM-1");
+		File var8 = new File(var6, "DIM1");
+		MinecraftServer.getServer().getLogAgent().logInfo("Scanning folders...");
+		this.addRegionFilesToCollection(var6, var3);
+		if(var7.exists()) {
+			this.addRegionFilesToCollection(var7, var4);
+		}
+
+		if(var8.exists()) {
+			this.addRegionFilesToCollection(var8, var5);
+		}
+
+		int var9 = var3.size() + var4.size() + var5.size();
+		MinecraftServer.getServer().getLogAgent().logInfo("Total conversion count is " + var9);
+		WorldInfo var10 = this.getWorldInfo(var1);
+		Object var11 = null;
+		if(var10.getTerrainType() == WorldType.FLAT) {
+			var11 = new WorldChunkManagerHell(BiomeGenBase.plains, 0.5F, 0.5F);
+		} else {
+			var11 = new WorldChunkManager(var10.getSeed(), var10.getTerrainType());
+		}
+
+		this.convertFile(new File(var6, "region"), var3, (WorldChunkManager)var11, 0, var9, var2);
+		this.convertFile(new File(var7, "region"), var4, new WorldChunkManagerHell(BiomeGenBase.hell, 1.0F, 0.0F), var3.size(), var9, var2);
+		this.convertFile(new File(var8, "region"), var5, new WorldChunkManagerHell(BiomeGenBase.sky, 0.5F, 0.0F), var3.size() + var4.size(), var9, var2);
+		var10.setSaveVersion(19133);
+		if(var10.getTerrainType() == WorldType.DEFAULT_1_1) {
+			var10.setTerrainType(WorldType.DEFAULT);
+		}
+
+		this.createFile(var1);
+		ISaveHandler var12 = this.getSaveLoader(var1, false);
+		var12.saveWorldInfo(var10);
+		return true;
+	}
+
+	private void createFile(String var1) {
+		File var2 = new File(this.savesDirectory, var1);
+		if(!var2.exists()) {
+			System.out.println("Warning: Unable to create level.dat_mcr backup");
+		} else {
+			File var3 = new File(var2, "level.dat");
+			if(!var3.exists()) {
+				System.out.println("Warning: Unable to create level.dat_mcr backup");
+			} else {
+				File var4 = new File(var2, "level.dat_mcr");
+				if(!var3.renameTo(var4)) {
+					System.out.println("Warning: Unable to create level.dat_mcr backup");
+				}
+
+			}
+		}
+	}
+
+	private void convertFile(File var1, Iterable var2, WorldChunkManager var3, int var4, int var5, IProgressUpdate var6) {
+		Iterator var7 = var2.iterator();
+
+		while(var7.hasNext()) {
+			File var8 = (File)var7.next();
+			this.convertChunks(var1, var8, var3, var4, var5, var6);
+			++var4;
+			int var9 = (int)Math.round(100.0D * (double)var4 / (double)var5);
+			var6.setLoadingProgress(var9);
+		}
+
+	}
+
+	private void convertChunks(File var1, File var2, WorldChunkManager var3, int var4, int var5, IProgressUpdate var6) {
+		try {
+			String var7 = var2.getName();
+			RegionFile var8 = new RegionFile(var2);
+			RegionFile var9 = new RegionFile(new File(var1, var7.substring(0, var7.length() - ".mcr".length()) + ".mca"));
+
+			for(int var10 = 0; var10 < 32; ++var10) {
+				int var11;
+				for(var11 = 0; var11 < 32; ++var11) {
+					if(var8.isChunkSaved(var10, var11) && !var9.isChunkSaved(var10, var11)) {
+						DataInputStream var12 = var8.getChunkDataInputStream(var10, var11);
+						if(var12 == null) {
+							MinecraftServer.getServer().getLogAgent().logWarning("Failed to fetch input stream");
+						} else {
+							NBTTagCompound var13 = CompressedStreamTools.read((DataInput)var12);
+							var12.close();
+							NBTTagCompound var14 = var13.getCompoundTag("Level");
+							AnvilConverterData var15 = ChunkLoader.load(var14);
+							NBTTagCompound var16 = new NBTTagCompound();
+							NBTTagCompound var17 = new NBTTagCompound();
+							var16.setTag("Level", var17);
+							ChunkLoader.convertToAnvilFormat(var15, var17, var3);
+							DataOutputStream var18 = var9.getChunkDataOutputStream(var10, var11);
+							CompressedStreamTools.write(var16, (DataOutput)var18);
+							var18.close();
+						}
+					}
+				}
+
+				var11 = (int)Math.round(100.0D * (double)(var4 * 1024) / (double)(var5 * 1024));
+				int var20 = (int)Math.round(100.0D * (double)((var10 + 1) * 32 + var4 * 1024) / (double)(var5 * 1024));
+				if(var20 > var11) {
+					var6.setLoadingProgress(var20);
+				}
+			}
+
+			var8.close();
+			var9.close();
+		} catch (IOException var19) {
+			var19.printStackTrace();
+		}
+
+	}
+
+	private void addRegionFilesToCollection(File var1, Collection var2) {
+		File var3 = new File(var1, "region");
+		File[] var4 = var3.listFiles(new AnvilSaveConverterFileFilter(this));
+		if(var4 != null) {
+			Collections.addAll(var2, var4);
+		}
+
+	}
+}

src/net/minecraft/src/AnvilSaveConverterFileFilter.java

@@ -0,0 +1,16 @@
+package net.minecraft.src;
+
+import java.io.File;
+import java.io.FilenameFilter;
+
+class AnvilSaveConverterFileFilter implements FilenameFilter {
+	final AnvilSaveConverter parent;
+
+	AnvilSaveConverterFileFilter(AnvilSaveConverter var1) {
+		this.parent = var1;
+	}
+
+	public boolean accept(File var1, String var2) {
+		return var2.endsWith(".mcr");
+	}
+}

src/net/minecraft/src/AnvilSaveHandler.java

@@ -0,0 +1,40 @@
+package net.minecraft.src;
+
+import java.io.File;
+
+public class AnvilSaveHandler extends SaveHandler {
+	public AnvilSaveHandler(File var1, String var2, boolean var3) {
+		super(var1, var2, var3);
+	}
+
+	public IChunkLoader getChunkLoader(WorldProvider var1) {
+		File var2 = this.getWorldDirectory();
+		File var3;
+		if(var1 instanceof WorldProviderHell) {
+			var3 = new File(var2, "DIM-1");
+			var3.mkdirs();
+			return new AnvilChunkLoader(var3);
+		} else if(var1 instanceof WorldProviderEnd) {
+			var3 = new File(var2, "DIM1");
+			var3.mkdirs();
+			return new AnvilChunkLoader(var3);
+		} else {
+			return new AnvilChunkLoader(var2);
+		}
+	}
+
+	public void saveWorldInfoWithPlayer(WorldInfo var1, NBTTagCompound var2) {
+		var1.setSaveVersion(19133);
+		super.saveWorldInfoWithPlayer(var1, var2);
+	}
+
+	public void flush() {
+		try {
+			ThreadedFileIOBase.threadedIOInstance.waitForFinish();
+		} catch (InterruptedException var2) {
+			var2.printStackTrace();
+		}
+
+		RegionFileCache.clearRegionFileReferences();
+	}
+}

src/net/minecraft/src/AxisAlignedBB.java

@@ -0,0 +1,319 @@
+package net.minecraft.src;
+
+public class AxisAlignedBB {
+	private static final ThreadLocal theAABBLocalPool = new AABBLocalPool();
+	public double minX;
+	public double minY;
+	public double minZ;
+	public double maxX;
+	public double maxY;
+	public double maxZ;
+
+	public static AxisAlignedBB getBoundingBox(double var0, double var2, double var4, double var6, double var8, double var10) {
+		return new AxisAlignedBB(var0, var2, var4, var6, var8, var10);
+	}
+
+	public static AABBPool getAABBPool() {
+		return (AABBPool)theAABBLocalPool.get();
+	}
+
+	protected AxisAlignedBB(double var1, double var3, double var5, double var7, double var9, double var11) {
+		this.minX = var1;
+		this.minY = var3;
+		this.minZ = var5;
+		this.maxX = var7;
+		this.maxY = var9;
+		this.maxZ = var11;
+	}
+
+	public AxisAlignedBB setBounds(double var1, double var3, double var5, double var7, double var9, double var11) {
+		this.minX = var1;
+		this.minY = var3;
+		this.minZ = var5;
+		this.maxX = var7;
+		this.maxY = var9;
+		this.maxZ = var11;
+		return this;
+	}
+
+	public AxisAlignedBB addCoord(double var1, double var3, double var5) {
+		double var7 = this.minX;
+		double var9 = this.minY;
+		double var11 = this.minZ;
+		double var13 = this.maxX;
+		double var15 = this.maxY;
+		double var17 = this.maxZ;
+		if(var1 < 0.0D) {
+			var7 += var1;
+		}
+
+		if(var1 > 0.0D) {
+			var13 += var1;
+		}
+
+		if(var3 < 0.0D) {
+			var9 += var3;
+		}
+
+		if(var3 > 0.0D) {
+			var15 += var3;
+		}
+
+		if(var5 < 0.0D) {
+			var11 += var5;
+		}
+
+		if(var5 > 0.0D) {
+			var17 += var5;
+		}
+
+		return getAABBPool().getAABB(var7, var9, var11, var13, var15, var17);
+	}
+
+	public AxisAlignedBB expand(double var1, double var3, double var5) {
+		double var7 = this.minX - var1;
+		double var9 = this.minY - var3;
+		double var11 = this.minZ - var5;
+		double var13 = this.maxX + var1;
+		double var15 = this.maxY + var3;
+		double var17 = this.maxZ + var5;
+		return getAABBPool().getAABB(var7, var9, var11, var13, var15, var17);
+	}
+
+	public AxisAlignedBB getOffsetBoundingBox(double var1, double var3, double var5) {
+		return getAABBPool().getAABB(this.minX + var1, this.minY + var3, this.minZ + var5, this.maxX + var1, this.maxY + var3, this.maxZ + var5);
+	}
+
+	public double calculateXOffset(AxisAlignedBB var1, double var2) {
+		if(var1.maxY > this.minY && var1.minY < this.maxY) {
+			if(var1.maxZ > this.minZ && var1.minZ < this.maxZ) {
+				double var4;
+				if(var2 > 0.0D && var1.maxX <= this.minX) {
+					var4 = this.minX - var1.maxX;
+					if(var4 < var2) {
+						var2 = var4;
+					}
+				}
+
+				if(var2 < 0.0D && var1.minX >= this.maxX) {
+					var4 = this.maxX - var1.minX;
+					if(var4 > var2) {
+						var2 = var4;
+					}
+				}
+
+				return var2;
+			} else {
+				return var2;
+			}
+		} else {
+			return var2;
+		}
+	}
+
+	public double calculateYOffset(AxisAlignedBB var1, double var2) {
+		if(var1.maxX > this.minX && var1.minX < this.maxX) {
+			if(var1.maxZ > this.minZ && var1.minZ < this.maxZ) {
+				double var4;
+				if(var2 > 0.0D && var1.maxY <= this.minY) {
+					var4 = this.minY - var1.maxY;
+					if(var4 < var2) {
+						var2 = var4;
+					}
+				}
+
+				if(var2 < 0.0D && var1.minY >= this.maxY) {
+					var4 = this.maxY - var1.minY;
+					if(var4 > var2) {
+						var2 = var4;
+					}
+				}
+
+				return var2;
+			} else {
+				return var2;
+			}
+		} else {
+			return var2;
+		}
+	}
+
+	public double calculateZOffset(AxisAlignedBB var1, double var2) {
+		if(var1.maxX > this.minX && var1.minX < this.maxX) {
+			if(var1.maxY > this.minY && var1.minY < this.maxY) {
+				double var4;
+				if(var2 > 0.0D && var1.maxZ <= this.minZ) {
+					var4 = this.minZ - var1.maxZ;
+					if(var4 < var2) {
+						var2 = var4;
+					}
+				}
+
+				if(var2 < 0.0D && var1.minZ >= this.maxZ) {
+					var4 = this.maxZ - var1.minZ;
+					if(var4 > var2) {
+						var2 = var4;
+					}
+				}
+
+				return var2;
+			} else {
+				return var2;
+			}
+		} else {
+			return var2;
+		}
+	}
+
+	public boolean intersectsWith(AxisAlignedBB var1) {
+		return var1.maxX > this.minX && var1.minX < this.maxX ? (var1.maxY > this.minY && var1.minY < this.maxY ? var1.maxZ > this.minZ && var1.minZ < this.maxZ : false) : false;
+	}
+
+	public AxisAlignedBB offset(double var1, double var3, double var5) {
+		this.minX += var1;
+		this.minY += var3;
+		this.minZ += var5;
+		this.maxX += var1;
+		this.maxY += var3;
+		this.maxZ += var5;
+		return this;
+	}
+
+	public boolean isVecInside(Vec3 var1) {
+		return var1.xCoord > this.minX && var1.xCoord < this.maxX ? (var1.yCoord > this.minY && var1.yCoord < this.maxY ? var1.zCoord > this.minZ && var1.zCoord < this.maxZ : false) : false;
+	}
+
+	public double getAverageEdgeLength() {
+		double var1 = this.maxX - this.minX;
+		double var3 = this.maxY - this.minY;
+		double var5 = this.maxZ - this.minZ;
+		return (var1 + var3 + var5) / 3.0D;
+	}
+
+	public AxisAlignedBB contract(double var1, double var3, double var5) {
+		double var7 = this.minX + var1;
+		double var9 = this.minY + var3;
+		double var11 = this.minZ + var5;
+		double var13 = this.maxX - var1;
+		double var15 = this.maxY - var3;
+		double var17 = this.maxZ - var5;
+		return getAABBPool().getAABB(var7, var9, var11, var13, var15, var17);
+	}
+
+	public AxisAlignedBB copy() {
+		return getAABBPool().getAABB(this.minX, this.minY, this.minZ, this.maxX, this.maxY, this.maxZ);
+	}
+
+	public MovingObjectPosition calculateIntercept(Vec3 var1, Vec3 var2) {
+		Vec3 var3 = var1.getIntermediateWithXValue(var2, this.minX);
+		Vec3 var4 = var1.getIntermediateWithXValue(var2, this.maxX);
+		Vec3 var5 = var1.getIntermediateWithYValue(var2, this.minY);
+		Vec3 var6 = var1.getIntermediateWithYValue(var2, this.maxY);
+		Vec3 var7 = var1.getIntermediateWithZValue(var2, this.minZ);
+		Vec3 var8 = var1.getIntermediateWithZValue(var2, this.maxZ);
+		if(!this.isVecInYZ(var3)) {
+			var3 = null;
+		}
+
+		if(!this.isVecInYZ(var4)) {
+			var4 = null;
+		}
+
+		if(!this.isVecInXZ(var5)) {
+			var5 = null;
+		}
+
+		if(!this.isVecInXZ(var6)) {
+			var6 = null;
+		}
+
+		if(!this.isVecInXY(var7)) {
+			var7 = null;
+		}
+
+		if(!this.isVecInXY(var8)) {
+			var8 = null;
+		}
+
+		Vec3 var9 = null;
+		if(var3 != null && (var9 == null || var1.squareDistanceTo(var3) < var1.squareDistanceTo(var9))) {
+			var9 = var3;
+		}
+
+		if(var4 != null && (var9 == null || var1.squareDistanceTo(var4) < var1.squareDistanceTo(var9))) {
+			var9 = var4;
+		}
+
+		if(var5 != null && (var9 == null || var1.squareDistanceTo(var5) < var1.squareDistanceTo(var9))) {
+			var9 = var5;
+		}
+
+		if(var6 != null && (var9 == null || var1.squareDistanceTo(var6) < var1.squareDistanceTo(var9))) {
+			var9 = var6;
+		}
+
+		if(var7 != null && (var9 == null || var1.squareDistanceTo(var7) < var1.squareDistanceTo(var9))) {
+			var9 = var7;
+		}
+
+		if(var8 != null && (var9 == null || var1.squareDistanceTo(var8) < var1.squareDistanceTo(var9))) {
+			var9 = var8;
+		}
+
+		if(var9 == null) {
+			return null;
+		} else {
+			byte var10 = -1;
+			if(var9 == var3) {
+				var10 = 4;
+			}
+
+			if(var9 == var4) {
+				var10 = 5;
+			}
+
+			if(var9 == var5) {
+				var10 = 0;
+			}
+
+			if(var9 == var6) {
+				var10 = 1;
+			}
+
+			if(var9 == var7) {
+				var10 = 2;
+			}
+
+			if(var9 == var8) {
+				var10 = 3;
+			}
+
+			return new MovingObjectPosition(0, 0, 0, var10, var9);
+		}
+	}
+
+	private boolean isVecInYZ(Vec3 var1) {
+		return var1 == null ? false : var1.yCoord >= this.minY && var1.yCoord <= this.maxY && var1.zCoord >= this.minZ && var1.zCoord <= this.maxZ;
+	}
+
+	private boolean isVecInXZ(Vec3 var1) {
+		return var1 == null ? false : var1.xCoord >= this.minX && var1.xCoord <= this.maxX && var1.zCoord >= this.minZ && var1.zCoord <= this.maxZ;
+	}
+
+	private boolean isVecInXY(Vec3 var1) {
+		return var1 == null ? false : var1.xCoord >= this.minX && var1.xCoord <= this.maxX && var1.yCoord >= this.minY && var1.yCoord <= this.maxY;
+	}
+
+	public void setBB(AxisAlignedBB var1) {
+		this.minX = var1.minX;
+		this.minY = var1.minY;
+		this.minZ = var1.minZ;
+		this.maxX = var1.maxX;
+		this.maxY = var1.maxY;
+		this.maxZ = var1.maxZ;
+	}
+
+	public String toString() {
+		return "box[" + this.minX + ", " + this.minY + ", " + this.minZ + " -> " + this.maxX + ", " + this.maxY + ", " + this.maxZ + "]";
+	}
+}

src/net/minecraft/src/BanEntry.java

@@ -0,0 +1,126 @@
+package net.minecraft.src;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.regex.Pattern;
+import net.minecraft.server.MinecraftServer;
+
+public class BanEntry {
+	public static final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss Z");
+	private final String username;
+	private Date banStartDate = new Date();
+	private String bannedBy = "(Unknown)";
+	private Date banEndDate = null;
+	private String reason = "Banned by an operator.";
+
+	public BanEntry(String var1) {
+		this.username = var1;
+	}
+
+	public String getBannedUsername() {
+		return this.username;
+	}
+
+	public Date getBanStartDate() {
+		return this.banStartDate;
+	}
+
+	public void setBanStartDate(Date var1) {
+		this.banStartDate = var1 != null ? var1 : new Date();
+	}
+
+	public String getBannedBy() {
+		return this.bannedBy;
+	}
+
+	public void setBannedBy(String var1) {
+		this.bannedBy = var1;
+	}
+
+	public Date getBanEndDate() {
+		return this.banEndDate;
+	}
+
+	public void setBanEndDate(Date var1) {
+		this.banEndDate = var1;
+	}
+
+	public boolean hasBanExpired() {
+		return this.banEndDate == null ? false : this.banEndDate.before(new Date());
+	}
+
+	public String getBanReason() {
+		return this.reason;
+	}
+
+	public void setBanReason(String var1) {
+		this.reason = var1;
+	}
+
+	public String buildBanString() {
+		StringBuilder var1 = new StringBuilder();
+		var1.append(this.getBannedUsername());
+		var1.append("|");
+		var1.append(dateFormat.format(this.getBanStartDate()));
+		var1.append("|");
+		var1.append(this.getBannedBy());
+		var1.append("|");
+		var1.append(this.getBanEndDate() == null ? "Forever" : dateFormat.format(this.getBanEndDate()));
+		var1.append("|");
+		var1.append(this.getBanReason());
+		return var1.toString();
+	}
+
+	public static BanEntry parse(String var0) {
+		if(var0.trim().length() < 2) {
+			return null;
+		} else {
+			String[] var1 = var0.trim().split(Pattern.quote("|"), 5);
+			BanEntry var2 = new BanEntry(var1[0].trim());
+			byte var3 = 0;
+			int var10000 = var1.length;
+			int var7 = var3 + 1;
+			if(var10000 <= var7) {
+				return var2;
+			} else {
+				try {
+					var2.setBanStartDate(dateFormat.parse(var1[var7].trim()));
+				} catch (ParseException var6) {
+					MinecraftServer.getServer().getLogAgent().logWarningException("Could not read creation date format for ban entry \'" + var2.getBannedUsername() + "\' (was: \'" + var1[var7] + "\')", var6);
+				}
+
+				var10000 = var1.length;
+				++var7;
+				if(var10000 <= var7) {
+					return var2;
+				} else {
+					var2.setBannedBy(var1[var7].trim());
+					var10000 = var1.length;
+					++var7;
+					if(var10000 <= var7) {
+						return var2;
+					} else {
+						try {
+							String var4 = var1[var7].trim();
+							if(!var4.equalsIgnoreCase("Forever") && var4.length() > 0) {
+								var2.setBanEndDate(dateFormat.parse(var4));
+							}
+						} catch (ParseException var5) {
+							MinecraftServer.getServer().getLogAgent().logWarningException("Could not read expiry date format for ban entry \'" + var2.getBannedUsername() + "\' (was: \'" + var1[var7] + "\')", var5);
+						}
+
+						var10000 = var1.length;
+						++var7;
+						if(var10000 <= var7) {
+							return var2;
+						} else {
+							var2.setBanReason(var1[var7].trim());
+							return var2;
+						}
+					}
+				}
+			}
+		}
+	}
+}

src/net/minecraft/src/BanList.java

@@ -0,0 +1,127 @@
+package net.minecraft.src;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.Map;
+import net.minecraft.server.MinecraftServer;
+
+public class BanList {
+	private final LowerStringMap theBanList = new LowerStringMap();
+	private final File fileName;
+	private boolean listActive = true;
+
+	public BanList(File var1) {
+		this.fileName = var1;
+	}
+
+	public boolean isListActive() {
+		return this.listActive;
+	}
+
+	public void setListActive(boolean var1) {
+		this.listActive = var1;
+	}
+
+	public Map getBannedList() {
+		this.removeExpiredBans();
+		return this.theBanList;
+	}
+
+	public boolean isBanned(String var1) {
+		if(!this.isListActive()) {
+			return false;
+		} else {
+			this.removeExpiredBans();
+			return this.theBanList.containsKey(var1);
+		}
+	}
+
+	public void put(BanEntry var1) {
+		this.theBanList.putLower(var1.getBannedUsername(), var1);
+		this.saveToFileWithHeader();
+	}
+
+	public void remove(String var1) {
+		this.theBanList.remove(var1);
+		this.saveToFileWithHeader();
+	}
+
+	public void removeExpiredBans() {
+		Iterator var1 = this.theBanList.values().iterator();
+
+		while(var1.hasNext()) {
+			BanEntry var2 = (BanEntry)var1.next();
+			if(var2.hasBanExpired()) {
+				var1.remove();
+			}
+		}
+
+	}
+
+	public void loadBanList() {
+		if(this.fileName.isFile()) {
+			BufferedReader var1;
+			try {
+				var1 = new BufferedReader(new FileReader(this.fileName));
+			} catch (FileNotFoundException var4) {
+				throw new Error();
+			}
+
+			try {
+				while(true) {
+					String var2 = var1.readLine();
+					if(var2 == null) {
+						break;
+					}
+
+					if(!var2.startsWith("#")) {
+						BanEntry var3 = BanEntry.parse(var2);
+						if(var3 != null) {
+							this.theBanList.putLower(var3.getBannedUsername(), var3);
+						}
+					}
+				}
+			} catch (IOException var5) {
+				MinecraftServer.getServer().getLogAgent().logSevereException("Could not load ban list", var5);
+			}
+
+		}
+	}
+
+	public void saveToFileWithHeader() {
+		this.saveToFile(true);
+	}
+
+	public void saveToFile(boolean var1) {
+		this.removeExpiredBans();
+
+		try {
+			PrintWriter var2 = new PrintWriter(new FileWriter(this.fileName, false));
+			if(var1) {
+				var2.println("# Updated " + (new SimpleDateFormat()).format(new Date()) + " by Minecraft " + "1.5.2");
+				var2.println("# victim name | ban date | banned by | banned until | reason");
+				var2.println();
+			}
+
+			Iterator var3 = this.theBanList.values().iterator();
+
+			while(var3.hasNext()) {
+				BanEntry var4 = (BanEntry)var3.next();
+				var2.println(var4.buildBanString());
+			}
+
+			var2.close();
+		} catch (IOException var5) {
+			MinecraftServer.getServer().getLogAgent().logSevereException("Could not save ban list", var5);
+		}
+
+	}
+}

src/net/minecraft/src/BehaviorDefaultDispenseItem.java

@@ -0,0 +1,45 @@
+package net.minecraft.src;
+
+public class BehaviorDefaultDispenseItem implements IBehaviorDispenseItem {
+	public final ItemStack dispense(IBlockSource var1, ItemStack var2) {
+		ItemStack var3 = this.dispenseStack(var1, var2);
+		this.playDispenseSound(var1);
+		this.spawnDispenseParticles(var1, BlockDispenser.getFacing(var1.getBlockMetadata()));
+		return var3;
+	}
+
+	protected ItemStack dispenseStack(IBlockSource var1, ItemStack var2) {
+		EnumFacing var3 = BlockDispenser.getFacing(var1.getBlockMetadata());
+		IPosition var4 = BlockDispenser.getIPositionFromBlockSource(var1);
+		ItemStack var5 = var2.splitStack(1);
+		doDispense(var1.getWorld(), var5, 6, var3, var4);
+		return var2;
+	}
+
+	public static void doDispense(World var0, ItemStack var1, int var2, EnumFacing var3, IPosition var4) {
+		double var5 = var4.getX();
+		double var7 = var4.getY();
+		double var9 = var4.getZ();
+		EntityItem var11 = new EntityItem(var0, var5, var7 - 0.3D, var9, var1);
+		double var12 = var0.rand.nextDouble() * 0.1D + 0.2D;
+		var11.motionX = (double)var3.getFrontOffsetX() * var12;
+		var11.motionY = (double)0.2F;
+		var11.motionZ = (double)var3.getFrontOffsetZ() * var12;
+		var11.motionX += var0.rand.nextGaussian() * (double)0.0075F * (double)var2;
+		var11.motionY += var0.rand.nextGaussian() * (double)0.0075F * (double)var2;
+		var11.motionZ += var0.rand.nextGaussian() * (double)0.0075F * (double)var2;
+		var0.spawnEntityInWorld(var11);
+	}
+
+	protected void playDispenseSound(IBlockSource var1) {
+		var1.getWorld().playAuxSFX(1000, var1.getXInt(), var1.getYInt(), var1.getZInt(), 0);
+	}
+
+	protected void spawnDispenseParticles(IBlockSource var1, EnumFacing var2) {
+		var1.getWorld().playAuxSFX(2000, var1.getXInt(), var1.getYInt(), var1.getZInt(), this.func_82488_a(var2));
+	}
+
+	private int func_82488_a(EnumFacing var1) {
+		return var1.getFrontOffsetX() + 1 + (var1.getFrontOffsetZ() + 1) * 3;
+	}
+}

src/net/minecraft/src/BehaviorDispenseArmor.java

@@ -0,0 +1,27 @@
+package net.minecraft.src;
+
+import java.util.List;
+
+final class BehaviorDispenseArmor extends BehaviorDefaultDispenseItem {
+	protected ItemStack dispenseStack(IBlockSource var1, ItemStack var2) {
+		EnumFacing var3 = BlockDispenser.getFacing(var1.getBlockMetadata());
+		int var4 = var1.getXInt() + var3.getFrontOffsetX();
+		int var5 = var1.getYInt() + var3.getFrontOffsetY();
+		int var6 = var1.getZInt() + var3.getFrontOffsetZ();
+		AxisAlignedBB var7 = AxisAlignedBB.getAABBPool().getAABB((double)var4, (double)var5, (double)var6, (double)(var4 + 1), (double)(var5 + 1), (double)(var6 + 1));
+		List var8 = var1.getWorld().selectEntitiesWithinAABB(EntityLiving.class, var7, new EntitySelectorArmoredMob(var2));
+		if(var8.size() > 0) {
+			EntityLiving var9 = (EntityLiving)var8.get(0);
+			int var10 = var9 instanceof EntityPlayer ? 1 : 0;
+			int var11 = EntityLiving.getArmorPosition(var2);
+			ItemStack var12 = var2.copy();
+			var12.stackSize = 1;
+			var9.setCurrentItemOrArmor(var11 - var10, var12);
+			var9.func_96120_a(var11, 2.0F);
+			--var2.stackSize;
+			return var2;
+		} else {
+			return super.dispenseStack(var1, var2);
+		}
+	}
+}

src/net/minecraft/src/BehaviorDispenseItemProvider.java

@@ -0,0 +1,7 @@
+package net.minecraft.src;
+
+final class BehaviorDispenseItemProvider implements IBehaviorDispenseItem {
+	public ItemStack dispense(IBlockSource var1, ItemStack var2) {
+		return var2;
+	}
+}

src/net/minecraft/src/BehaviorDispenseMinecart.java

@@ -0,0 +1,36 @@
+package net.minecraft.src;
+
+final class BehaviorDispenseMinecart extends BehaviorDefaultDispenseItem {
+	private final BehaviorDefaultDispenseItem field_96465_b = new BehaviorDefaultDispenseItem();
+
+	public ItemStack dispenseStack(IBlockSource var1, ItemStack var2) {
+		EnumFacing var3 = BlockDispenser.getFacing(var1.getBlockMetadata());
+		World var4 = var1.getWorld();
+		double var5 = var1.getX() + (double)((float)var3.getFrontOffsetX() * 1.125F);
+		double var7 = var1.getY() + (double)((float)var3.getFrontOffsetY() * 1.125F);
+		double var9 = var1.getZ() + (double)((float)var3.getFrontOffsetZ() * 1.125F);
+		int var11 = var1.getXInt() + var3.getFrontOffsetX();
+		int var12 = var1.getYInt() + var3.getFrontOffsetY();
+		int var13 = var1.getZInt() + var3.getFrontOffsetZ();
+		int var14 = var4.getBlockId(var11, var12, var13);
+		double var15;
+		if(BlockRailBase.isRailBlock(var14)) {
+			var15 = 0.0D;
+		} else {
+			if(var14 != 0 || !BlockRailBase.isRailBlock(var4.getBlockId(var11, var12 - 1, var13))) {
+				return this.field_96465_b.dispense(var1, var2);
+			}
+
+			var15 = -1.0D;
+		}
+
+		EntityMinecart var17 = EntityMinecart.createMinecart(var4, var5, var7 + var15, var9, ((ItemMinecart)var2.getItem()).minecartType);
+		var4.spawnEntityInWorld(var17);
+		var2.splitStack(1);
+		return var2;
+	}
+
+	protected void playDispenseSound(IBlockSource var1) {
+		var1.getWorld().playAuxSFX(1000, var1.getXInt(), var1.getYInt(), var1.getZInt(), 0);
+	}
+}

src/net/minecraft/src/BehaviorProjectileDispense.java

@@ -0,0 +1,28 @@
+package net.minecraft.src;
+
+public abstract class BehaviorProjectileDispense extends BehaviorDefaultDispenseItem {
+	public ItemStack dispenseStack(IBlockSource var1, ItemStack var2) {
+		World var3 = var1.getWorld();
+		IPosition var4 = BlockDispenser.getIPositionFromBlockSource(var1);
+		EnumFacing var5 = BlockDispenser.getFacing(var1.getBlockMetadata());
+		IProjectile var6 = this.getProjectileEntity(var3, var4);
+		var6.setThrowableHeading((double)var5.getFrontOffsetX(), (double)((float)var5.getFrontOffsetY() + 0.1F), (double)var5.getFrontOffsetZ(), this.func_82500_b(), this.func_82498_a());
+		var3.spawnEntityInWorld((Entity)var6);
+		var2.splitStack(1);
+		return var2;
+	}
+
+	protected void playDispenseSound(IBlockSource var1) {
+		var1.getWorld().playAuxSFX(1002, var1.getXInt(), var1.getYInt(), var1.getZInt(), 0);
+	}
+
+	protected abstract IProjectile getProjectileEntity(World var1, IPosition var2);
+
+	protected float func_82498_a() {
+		return 6.0F;
+	}
+
+	protected float func_82500_b() {
+		return 1.1F;
+	}
+}

src/net/minecraft/src/BiomeCache.java

@@ -0,0 +1,61 @@
+package net.minecraft.src;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class BiomeCache {
+	private final WorldChunkManager chunkManager;
+	private long lastCleanupTime = 0L;
+	private LongHashMap cacheMap = new LongHashMap();
+	private List cache = new ArrayList();
+
+	public BiomeCache(WorldChunkManager var1) {
+		this.chunkManager = var1;
+	}
+
+	public BiomeCacheBlock getBiomeCacheBlock(int var1, int var2) {
+		var1 >>= 4;
+		var2 >>= 4;
+		long var3 = (long)var1 & 4294967295L | ((long)var2 & 4294967295L) << 32;
+		BiomeCacheBlock var5 = (BiomeCacheBlock)this.cacheMap.getValueByKey(var3);
+		if(var5 == null) {
+			var5 = new BiomeCacheBlock(this, var1, var2);
+			this.cacheMap.add(var3, var5);
+			this.cache.add(var5);
+		}
+
+		var5.lastAccessTime = System.currentTimeMillis();
+		return var5;
+	}
+
+	public BiomeGenBase getBiomeGenAt(int var1, int var2) {
+		return this.getBiomeCacheBlock(var1, var2).getBiomeGenAt(var1, var2);
+	}
+
+	public void cleanupCache() {
+		long var1 = System.currentTimeMillis();
+		long var3 = var1 - this.lastCleanupTime;
+		if(var3 > 7500L || var3 < 0L) {
+			this.lastCleanupTime = var1;
+
+			for(int var5 = 0; var5 < this.cache.size(); ++var5) {
+				BiomeCacheBlock var6 = (BiomeCacheBlock)this.cache.get(var5);
+				long var7 = var1 - var6.lastAccessTime;
+				if(var7 > 30000L || var7 < 0L) {
+					this.cache.remove(var5--);
+					long var9 = (long)var6.xPosition & 4294967295L | ((long)var6.zPosition & 4294967295L) << 32;
+					this.cacheMap.remove(var9);
+				}
+			}
+		}
+
+	}
+
+	public BiomeGenBase[] getCachedBiomes(int var1, int var2) {
+		return this.getBiomeCacheBlock(var1, var2).biomes;
+	}
+
+	static WorldChunkManager getChunkManager(BiomeCache var0) {
+		return var0.chunkManager;
+	}
+}

src/net/minecraft/src/BiomeCacheBlock.java

@@ -0,0 +1,27 @@
+package net.minecraft.src;
+
+public class BiomeCacheBlock {
+	public float[] temperatureValues;
+	public float[] rainfallValues;
+	public BiomeGenBase[] biomes;
+	public int xPosition;
+	public int zPosition;
+	public long lastAccessTime;
+	final BiomeCache theBiomeCache;
+
+	public BiomeCacheBlock(BiomeCache var1, int var2, int var3) {
+		this.theBiomeCache = var1;
+		this.temperatureValues = new float[256];
+		this.rainfallValues = new float[256];
+		this.biomes = new BiomeGenBase[256];
+		this.xPosition = var2;
+		this.zPosition = var3;
+		BiomeCache.getChunkManager(var1).getTemperatures(this.temperatureValues, var2 << 4, var3 << 4, 16, 16);
+		BiomeCache.getChunkManager(var1).getRainfall(this.rainfallValues, var2 << 4, var3 << 4, 16, 16);
+		BiomeCache.getChunkManager(var1).getBiomeGenAt(this.biomes, var2 << 4, var3 << 4, 16, 16, false);
+	}
+
+	public BiomeGenBase getBiomeGenAt(int var1, int var2) {
+		return this.biomes[var1 & 15 | (var2 & 15) << 4];
+	}
+}

src/net/minecraft/src/BiomeDecorator.java

@@ -0,0 +1,251 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BiomeDecorator {
+	protected World currentWorld;
+	protected Random randomGenerator;
+	protected int chunk_X;
+	protected int chunk_Z;
+	protected BiomeGenBase biome;
+	protected WorldGenerator clayGen = new WorldGenClay(4);
+	protected WorldGenerator sandGen = new WorldGenSand(7, Block.sand.blockID);
+	protected WorldGenerator gravelAsSandGen = new WorldGenSand(6, Block.gravel.blockID);
+	protected WorldGenerator dirtGen = new WorldGenMinable(Block.dirt.blockID, 32);
+	protected WorldGenerator gravelGen = new WorldGenMinable(Block.gravel.blockID, 32);
+	protected WorldGenerator coalGen = new WorldGenMinable(Block.oreCoal.blockID, 16);
+	protected WorldGenerator ironGen = new WorldGenMinable(Block.oreIron.blockID, 8);
+	protected WorldGenerator goldGen = new WorldGenMinable(Block.oreGold.blockID, 8);
+	protected WorldGenerator redstoneGen = new WorldGenMinable(Block.oreRedstone.blockID, 7);
+	protected WorldGenerator diamondGen = new WorldGenMinable(Block.oreDiamond.blockID, 7);
+	protected WorldGenerator lapisGen = new WorldGenMinable(Block.oreLapis.blockID, 6);
+	protected WorldGenerator plantYellowGen = new WorldGenFlowers(Block.plantYellow.blockID);
+	protected WorldGenerator plantRedGen = new WorldGenFlowers(Block.plantRed.blockID);
+	protected WorldGenerator mushroomBrownGen = new WorldGenFlowers(Block.mushroomBrown.blockID);
+	protected WorldGenerator mushroomRedGen = new WorldGenFlowers(Block.mushroomRed.blockID);
+	protected WorldGenerator bigMushroomGen = new WorldGenBigMushroom();
+	protected WorldGenerator reedGen = new WorldGenReed();
+	protected WorldGenerator cactusGen = new WorldGenCactus();
+	protected WorldGenerator waterlilyGen = new WorldGenWaterlily();
+	protected int waterlilyPerChunk = 0;
+	protected int treesPerChunk = 0;
+	protected int flowersPerChunk = 2;
+	protected int grassPerChunk = 1;
+	protected int deadBushPerChunk = 0;
+	protected int mushroomsPerChunk = 0;
+	protected int reedsPerChunk = 0;
+	protected int cactiPerChunk = 0;
+	protected int sandPerChunk = 1;
+	protected int sandPerChunk2 = 3;
+	protected int clayPerChunk = 1;
+	protected int bigMushroomsPerChunk = 0;
+	public boolean generateLakes = true;
+
+	public BiomeDecorator(BiomeGenBase var1) {
+		this.biome = var1;
+	}
+
+	public void decorate(World var1, Random var2, int var3, int var4) {
+		if(this.currentWorld != null) {
+			throw new RuntimeException("Already decorating!!");
+		} else {
+			this.currentWorld = var1;
+			this.randomGenerator = var2;
+			this.chunk_X = var3;
+			this.chunk_Z = var4;
+			this.decorate();
+			this.currentWorld = null;
+			this.randomGenerator = null;
+		}
+	}
+
+	protected void decorate() {
+		this.generateOres();
+
+		int var1;
+		int var2;
+		int var3;
+		for(var1 = 0; var1 < this.sandPerChunk2; ++var1) {
+			var2 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+			var3 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+			this.sandGen.generate(this.currentWorld, this.randomGenerator, var2, this.currentWorld.getTopSolidOrLiquidBlock(var2, var3), var3);
+		}
+
+		for(var1 = 0; var1 < this.clayPerChunk; ++var1) {
+			var2 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+			var3 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+			this.clayGen.generate(this.currentWorld, this.randomGenerator, var2, this.currentWorld.getTopSolidOrLiquidBlock(var2, var3), var3);
+		}
+
+		for(var1 = 0; var1 < this.sandPerChunk; ++var1) {
+			var2 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+			var3 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+			this.sandGen.generate(this.currentWorld, this.randomGenerator, var2, this.currentWorld.getTopSolidOrLiquidBlock(var2, var3), var3);
+		}
+
+		var1 = this.treesPerChunk;
+		if(this.randomGenerator.nextInt(10) == 0) {
+			++var1;
+		}
+
+		int var4;
+		for(var2 = 0; var2 < var1; ++var2) {
+			var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+			var4 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+			WorldGenerator var5 = this.biome.getRandomWorldGenForTrees(this.randomGenerator);
+			var5.setScale(1.0D, 1.0D, 1.0D);
+			var5.generate(this.currentWorld, this.randomGenerator, var3, this.currentWorld.getHeightValue(var3, var4), var4);
+		}
+
+		for(var2 = 0; var2 < this.bigMushroomsPerChunk; ++var2) {
+			var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+			var4 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+			this.bigMushroomGen.generate(this.currentWorld, this.randomGenerator, var3, this.currentWorld.getHeightValue(var3, var4), var4);
+		}
+
+		int var7;
+		for(var2 = 0; var2 < this.flowersPerChunk; ++var2) {
+			var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+			var4 = this.randomGenerator.nextInt(128);
+			var7 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+			this.plantYellowGen.generate(this.currentWorld, this.randomGenerator, var3, var4, var7);
+			if(this.randomGenerator.nextInt(4) == 0) {
+				var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+				var4 = this.randomGenerator.nextInt(128);
+				var7 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+				this.plantRedGen.generate(this.currentWorld, this.randomGenerator, var3, var4, var7);
+			}
+		}
+
+		for(var2 = 0; var2 < this.grassPerChunk; ++var2) {
+			var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+			var4 = this.randomGenerator.nextInt(128);
+			var7 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+			WorldGenerator var6 = this.biome.getRandomWorldGenForGrass(this.randomGenerator);
+			var6.generate(this.currentWorld, this.randomGenerator, var3, var4, var7);
+		}
+
+		for(var2 = 0; var2 < this.deadBushPerChunk; ++var2) {
+			var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+			var4 = this.randomGenerator.nextInt(128);
+			var7 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+			(new WorldGenDeadBush(Block.deadBush.blockID)).generate(this.currentWorld, this.randomGenerator, var3, var4, var7);
+		}
+
+		for(var2 = 0; var2 < this.waterlilyPerChunk; ++var2) {
+			var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+			var4 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+
+			for(var7 = this.randomGenerator.nextInt(128); var7 > 0 && this.currentWorld.getBlockId(var3, var7 - 1, var4) == 0; --var7) {
+			}
+
+			this.waterlilyGen.generate(this.currentWorld, this.randomGenerator, var3, var7, var4);
+		}
+
+		for(var2 = 0; var2 < this.mushroomsPerChunk; ++var2) {
+			if(this.randomGenerator.nextInt(4) == 0) {
+				var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+				var4 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+				var7 = this.currentWorld.getHeightValue(var3, var4);
+				this.mushroomBrownGen.generate(this.currentWorld, this.randomGenerator, var3, var7, var4);
+			}
+
+			if(this.randomGenerator.nextInt(8) == 0) {
+				var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+				var4 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+				var7 = this.randomGenerator.nextInt(128);
+				this.mushroomRedGen.generate(this.currentWorld, this.randomGenerator, var3, var7, var4);
+			}
+		}
+
+		if(this.randomGenerator.nextInt(4) == 0) {
+			var2 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+			var3 = this.randomGenerator.nextInt(128);
+			var4 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+			this.mushroomBrownGen.generate(this.currentWorld, this.randomGenerator, var2, var3, var4);
+		}
+
+		if(this.randomGenerator.nextInt(8) == 0) {
+			var2 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+			var3 = this.randomGenerator.nextInt(128);
+			var4 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+			this.mushroomRedGen.generate(this.currentWorld, this.randomGenerator, var2, var3, var4);
+		}
+
+		for(var2 = 0; var2 < this.reedsPerChunk; ++var2) {
+			var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+			var4 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+			var7 = this.randomGenerator.nextInt(128);
+			this.reedGen.generate(this.currentWorld, this.randomGenerator, var3, var7, var4);
+		}
+
+		for(var2 = 0; var2 < 10; ++var2) {
+			var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+			var4 = this.randomGenerator.nextInt(128);
+			var7 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+			this.reedGen.generate(this.currentWorld, this.randomGenerator, var3, var4, var7);
+		}
+
+		if(this.randomGenerator.nextInt(32) == 0) {
+			var2 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+			var3 = this.randomGenerator.nextInt(128);
+			var4 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+			(new WorldGenPumpkin()).generate(this.currentWorld, this.randomGenerator, var2, var3, var4);
+		}
+
+		for(var2 = 0; var2 < this.cactiPerChunk; ++var2) {
+			var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+			var4 = this.randomGenerator.nextInt(128);
+			var7 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+			this.cactusGen.generate(this.currentWorld, this.randomGenerator, var3, var4, var7);
+		}
+
+		if(this.generateLakes) {
+			for(var2 = 0; var2 < 50; ++var2) {
+				var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+				var4 = this.randomGenerator.nextInt(this.randomGenerator.nextInt(120) + 8);
+				var7 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+				(new WorldGenLiquids(Block.waterMoving.blockID)).generate(this.currentWorld, this.randomGenerator, var3, var4, var7);
+			}
+
+			for(var2 = 0; var2 < 20; ++var2) {
+				var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+				var4 = this.randomGenerator.nextInt(this.randomGenerator.nextInt(this.randomGenerator.nextInt(112) + 8) + 8);
+				var7 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+				(new WorldGenLiquids(Block.lavaMoving.blockID)).generate(this.currentWorld, this.randomGenerator, var3, var4, var7);
+			}
+		}
+
+	}
+
+	protected void genStandardOre1(int var1, WorldGenerator var2, int var3, int var4) {
+		for(int var5 = 0; var5 < var1; ++var5) {
+			int var6 = this.chunk_X + this.randomGenerator.nextInt(16);
+			int var7 = this.randomGenerator.nextInt(var4 - var3) + var3;
+			int var8 = this.chunk_Z + this.randomGenerator.nextInt(16);
+			var2.generate(this.currentWorld, this.randomGenerator, var6, var7, var8);
+		}
+
+	}
+
+	protected void genStandardOre2(int var1, WorldGenerator var2, int var3, int var4) {
+		for(int var5 = 0; var5 < var1; ++var5) {
+			int var6 = this.chunk_X + this.randomGenerator.nextInt(16);
+			int var7 = this.randomGenerator.nextInt(var4) + this.randomGenerator.nextInt(var4) + (var3 - var4);
+			int var8 = this.chunk_Z + this.randomGenerator.nextInt(16);
+			var2.generate(this.currentWorld, this.randomGenerator, var6, var7, var8);
+		}
+
+	}
+
+	protected void generateOres() {
+		this.genStandardOre1(20, this.dirtGen, 0, 128);
+		this.genStandardOre1(10, this.gravelGen, 0, 128);
+		this.genStandardOre1(20, this.coalGen, 0, 128);
+		this.genStandardOre1(20, this.ironGen, 0, 64);
+		this.genStandardOre1(2, this.goldGen, 0, 32);
+		this.genStandardOre1(8, this.redstoneGen, 0, 16);
+		this.genStandardOre1(1, this.diamondGen, 0, 16);
+		this.genStandardOre2(1, this.lapisGen, 16, 16);
+	}
+}

src/net/minecraft/src/BiomeEndDecorator.java

@@ -0,0 +1,29 @@
+package net.minecraft.src;
+
+public class BiomeEndDecorator extends BiomeDecorator {
+	protected WorldGenerator spikeGen = new WorldGenSpikes(Block.whiteStone.blockID);
+
+	public BiomeEndDecorator(BiomeGenBase var1) {
+		super(var1);
+	}
+
+	protected void decorate() {
+		this.generateOres();
+		if(this.randomGenerator.nextInt(5) == 0) {
+			int var1 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+			int var2 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+			int var3 = this.currentWorld.getTopSolidOrLiquidBlock(var1, var2);
+			if(var3 > 0) {
+			}
+
+			this.spikeGen.generate(this.currentWorld, this.randomGenerator, var1, var3, var2);
+		}
+
+		if(this.chunk_X == 0 && this.chunk_Z == 0) {
+			EntityDragon var4 = new EntityDragon(this.currentWorld);
+			var4.setLocationAndAngles(0.0D, 128.0D, 0.0D, this.randomGenerator.nextFloat() * 360.0F, 0.0F);
+			this.currentWorld.spawnEntityInWorld(var4);
+		}
+
+	}
+}

src/net/minecraft/src/BiomeGenBase.java

@@ -0,0 +1,191 @@
+package net.minecraft.src;
+
+import java.awt.Color;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public abstract class BiomeGenBase {
+	public static final BiomeGenBase[] biomeList = new BiomeGenBase[256];
+	public static final BiomeGenBase ocean = (new BiomeGenOcean(0)).setColor(112).setBiomeName("Ocean").setMinMaxHeight(-1.0F, 0.4F);
+	public static final BiomeGenBase plains = (new BiomeGenPlains(1)).setColor(9286496).setBiomeName("Plains").setTemperatureRainfall(0.8F, 0.4F);
+	public static final BiomeGenBase desert = (new BiomeGenDesert(2)).setColor(16421912).setBiomeName("Desert").setDisableRain().setTemperatureRainfall(2.0F, 0.0F).setMinMaxHeight(0.1F, 0.2F);
+	public static final BiomeGenBase extremeHills = (new BiomeGenHills(3)).setColor(6316128).setBiomeName("Extreme Hills").setMinMaxHeight(0.3F, 1.5F).setTemperatureRainfall(0.2F, 0.3F);
+	public static final BiomeGenBase forest = (new BiomeGenForest(4)).setColor(353825).setBiomeName("Forest").func_76733_a(5159473).setTemperatureRainfall(0.7F, 0.8F);
+	public static final BiomeGenBase taiga = (new BiomeGenTaiga(5)).setColor(747097).setBiomeName("Taiga").func_76733_a(5159473).setEnableSnow().setTemperatureRainfall(0.05F, 0.8F).setMinMaxHeight(0.1F, 0.4F);
+	public static final BiomeGenBase swampland = (new BiomeGenSwamp(6)).setColor(522674).setBiomeName("Swampland").func_76733_a(9154376).setMinMaxHeight(-0.2F, 0.1F).setTemperatureRainfall(0.8F, 0.9F);
+	public static final BiomeGenBase river = (new BiomeGenRiver(7)).setColor(255).setBiomeName("River").setMinMaxHeight(-0.5F, 0.0F);
+	public static final BiomeGenBase hell = (new BiomeGenHell(8)).setColor(16711680).setBiomeName("Hell").setDisableRain().setTemperatureRainfall(2.0F, 0.0F);
+	public static final BiomeGenBase sky = (new BiomeGenEnd(9)).setColor(8421631).setBiomeName("Sky").setDisableRain();
+	public static final BiomeGenBase frozenOcean = (new BiomeGenOcean(10)).setColor(9474208).setBiomeName("FrozenOcean").setEnableSnow().setMinMaxHeight(-1.0F, 0.5F).setTemperatureRainfall(0.0F, 0.5F);
+	public static final BiomeGenBase frozenRiver = (new BiomeGenRiver(11)).setColor(10526975).setBiomeName("FrozenRiver").setEnableSnow().setMinMaxHeight(-0.5F, 0.0F).setTemperatureRainfall(0.0F, 0.5F);
+	public static final BiomeGenBase icePlains = (new BiomeGenSnow(12)).setColor(16777215).setBiomeName("Ice Plains").setEnableSnow().setTemperatureRainfall(0.0F, 0.5F);
+	public static final BiomeGenBase iceMountains = (new BiomeGenSnow(13)).setColor(10526880).setBiomeName("Ice Mountains").setEnableSnow().setMinMaxHeight(0.3F, 1.3F).setTemperatureRainfall(0.0F, 0.5F);
+	public static final BiomeGenBase mushroomIsland = (new BiomeGenMushroomIsland(14)).setColor(16711935).setBiomeName("MushroomIsland").setTemperatureRainfall(0.9F, 1.0F).setMinMaxHeight(0.2F, 1.0F);
+	public static final BiomeGenBase mushroomIslandShore = (new BiomeGenMushroomIsland(15)).setColor(10486015).setBiomeName("MushroomIslandShore").setTemperatureRainfall(0.9F, 1.0F).setMinMaxHeight(-1.0F, 0.1F);
+	public static final BiomeGenBase beach = (new BiomeGenBeach(16)).setColor(16440917).setBiomeName("Beach").setTemperatureRainfall(0.8F, 0.4F).setMinMaxHeight(0.0F, 0.1F);
+	public static final BiomeGenBase desertHills = (new BiomeGenDesert(17)).setColor(13786898).setBiomeName("DesertHills").setDisableRain().setTemperatureRainfall(2.0F, 0.0F).setMinMaxHeight(0.3F, 0.8F);
+	public static final BiomeGenBase forestHills = (new BiomeGenForest(18)).setColor(2250012).setBiomeName("ForestHills").func_76733_a(5159473).setTemperatureRainfall(0.7F, 0.8F).setMinMaxHeight(0.3F, 0.7F);
+	public static final BiomeGenBase taigaHills = (new BiomeGenTaiga(19)).setColor(1456435).setBiomeName("TaigaHills").setEnableSnow().func_76733_a(5159473).setTemperatureRainfall(0.05F, 0.8F).setMinMaxHeight(0.3F, 0.8F);
+	public static final BiomeGenBase extremeHillsEdge = (new BiomeGenHills(20)).setColor(7501978).setBiomeName("Extreme Hills Edge").setMinMaxHeight(0.2F, 0.8F).setTemperatureRainfall(0.2F, 0.3F);
+	public static final BiomeGenBase jungle = (new BiomeGenJungle(21)).setColor(5470985).setBiomeName("Jungle").func_76733_a(5470985).setTemperatureRainfall(1.2F, 0.9F).setMinMaxHeight(0.2F, 0.4F);
+	public static final BiomeGenBase jungleHills = (new BiomeGenJungle(22)).setColor(2900485).setBiomeName("JungleHills").func_76733_a(5470985).setTemperatureRainfall(1.2F, 0.9F).setMinMaxHeight(1.8F, 0.5F);
+	public String biomeName;
+	public int color;
+	public byte topBlock = (byte)Block.grass.blockID;
+	public byte fillerBlock = (byte)Block.dirt.blockID;
+	public int field_76754_C = 5169201;
+	public float minHeight = 0.1F;
+	public float maxHeight = 0.3F;
+	public float temperature = 0.5F;
+	public float rainfall = 0.5F;
+	public int waterColorMultiplier = 16777215;
+	public BiomeDecorator theBiomeDecorator;
+	protected List spawnableMonsterList = new ArrayList();
+	protected List spawnableCreatureList = new ArrayList();
+	protected List spawnableWaterCreatureList = new ArrayList();
+	protected List spawnableCaveCreatureList = new ArrayList();
+	private boolean enableSnow;
+	private boolean enableRain = true;
+	public final int biomeID;
+	protected WorldGenTrees worldGeneratorTrees = new WorldGenTrees(false);
+	protected WorldGenBigTree worldGeneratorBigTree = new WorldGenBigTree(false);
+	protected WorldGenForest worldGeneratorForest = new WorldGenForest(false);
+	protected WorldGenSwamp worldGeneratorSwamp = new WorldGenSwamp();
+
+	protected BiomeGenBase(int var1) {
+		this.biomeID = var1;
+		biomeList[var1] = this;
+		this.theBiomeDecorator = this.createBiomeDecorator();
+		this.spawnableCreatureList.add(new SpawnListEntry(EntitySheep.class, 12, 4, 4));
+		this.spawnableCreatureList.add(new SpawnListEntry(EntityPig.class, 10, 4, 4));
+		this.spawnableCreatureList.add(new SpawnListEntry(EntityChicken.class, 10, 4, 4));
+		this.spawnableCreatureList.add(new SpawnListEntry(EntityCow.class, 8, 4, 4));
+		this.spawnableMonsterList.add(new SpawnListEntry(EntitySpider.class, 10, 4, 4));
+		this.spawnableMonsterList.add(new SpawnListEntry(EntityZombie.class, 10, 4, 4));
+		this.spawnableMonsterList.add(new SpawnListEntry(EntitySkeleton.class, 10, 4, 4));
+		this.spawnableMonsterList.add(new SpawnListEntry(EntityCreeper.class, 10, 4, 4));
+		this.spawnableMonsterList.add(new SpawnListEntry(EntitySlime.class, 10, 4, 4));
+		this.spawnableMonsterList.add(new SpawnListEntry(EntityEnderman.class, 1, 1, 4));
+		this.spawnableWaterCreatureList.add(new SpawnListEntry(EntitySquid.class, 10, 4, 4));
+		this.spawnableCaveCreatureList.add(new SpawnListEntry(EntityBat.class, 10, 8, 8));
+	}
+
+	protected BiomeDecorator createBiomeDecorator() {
+		return new BiomeDecorator(this);
+	}
+
+	private BiomeGenBase setTemperatureRainfall(float var1, float var2) {
+		if(var1 > 0.1F && var1 < 0.2F) {
+			throw new IllegalArgumentException("Please avoid temperatures in the range 0.1 - 0.2 because of snow");
+		} else {
+			this.temperature = var1;
+			this.rainfall = var2;
+			return this;
+		}
+	}
+
+	private BiomeGenBase setMinMaxHeight(float var1, float var2) {
+		this.minHeight = var1;
+		this.maxHeight = var2;
+		return this;
+	}
+
+	private BiomeGenBase setDisableRain() {
+		this.enableRain = false;
+		return this;
+	}
+
+	public WorldGenerator getRandomWorldGenForTrees(Random var1) {
+		return (WorldGenerator)(var1.nextInt(10) == 0 ? this.worldGeneratorBigTree : this.worldGeneratorTrees);
+	}
+
+	public WorldGenerator getRandomWorldGenForGrass(Random var1) {
+		return new WorldGenTallGrass(Block.tallGrass.blockID, 1);
+	}
+
+	protected BiomeGenBase setEnableSnow() {
+		this.enableSnow = true;
+		return this;
+	}
+
+	protected BiomeGenBase setBiomeName(String var1) {
+		this.biomeName = var1;
+		return this;
+	}
+
+	protected BiomeGenBase func_76733_a(int var1) {
+		this.field_76754_C = var1;
+		return this;
+	}
+
+	protected BiomeGenBase setColor(int var1) {
+		this.color = var1;
+		return this;
+	}
+
+	public int getSkyColorByTemp(float var1) {
+		var1 /= 3.0F;
+		if(var1 < -1.0F) {
+			var1 = -1.0F;
+		}
+
+		if(var1 > 1.0F) {
+			var1 = 1.0F;
+		}
+
+		return Color.getHSBColor(224.0F / 360.0F - var1 * 0.05F, 0.5F + var1 * 0.1F, 1.0F).getRGB();
+	}
+
+	public List getSpawnableList(EnumCreatureType var1) {
+		return var1 == EnumCreatureType.monster ? this.spawnableMonsterList : (var1 == EnumCreatureType.creature ? this.spawnableCreatureList : (var1 == EnumCreatureType.waterCreature ? this.spawnableWaterCreatureList : (var1 == EnumCreatureType.ambient ? this.spawnableCaveCreatureList : null)));
+	}
+
+	public boolean getEnableSnow() {
+		return this.enableSnow;
+	}
+
+	public boolean canSpawnLightningBolt() {
+		return this.enableSnow ? false : this.enableRain;
+	}
+
+	public boolean isHighHumidity() {
+		return this.rainfall > 0.85F;
+	}
+
+	public float getSpawningChance() {
+		return 0.1F;
+	}
+
+	public final int getIntRainfall() {
+		return (int)(this.rainfall * 65536.0F);
+	}
+
+	public final int getIntTemperature() {
+		return (int)(this.temperature * 65536.0F);
+	}
+
+	public final float getFloatRainfall() {
+		return this.rainfall;
+	}
+
+	public final float getFloatTemperature() {
+		return this.temperature;
+	}
+
+	public void decorate(World var1, Random var2, int var3, int var4) {
+		this.theBiomeDecorator.decorate(var1, var2, var3, var4);
+	}
+
+	public int getBiomeGrassColor() {
+		double var1 = (double)MathHelper.clamp_float(this.getFloatTemperature(), 0.0F, 1.0F);
+		double var3 = (double)MathHelper.clamp_float(this.getFloatRainfall(), 0.0F, 1.0F);
+		return ColorizerGrass.getGrassColor(var1, var3);
+	}
+
+	public int getBiomeFoliageColor() {
+		double var1 = (double)MathHelper.clamp_float(this.getFloatTemperature(), 0.0F, 1.0F);
+		double var3 = (double)MathHelper.clamp_float(this.getFloatRainfall(), 0.0F, 1.0F);
+		return ColorizerFoliage.getFoliageColor(var1, var3);
+	}
+}

src/net/minecraft/src/BiomeGenBeach.java

@@ -0,0 +1,14 @@
+package net.minecraft.src;
+
+public class BiomeGenBeach extends BiomeGenBase {
+	public BiomeGenBeach(int var1) {
+		super(var1);
+		this.spawnableCreatureList.clear();
+		this.topBlock = (byte)Block.sand.blockID;
+		this.fillerBlock = (byte)Block.sand.blockID;
+		this.theBiomeDecorator.treesPerChunk = -999;
+		this.theBiomeDecorator.deadBushPerChunk = 0;
+		this.theBiomeDecorator.reedsPerChunk = 0;
+		this.theBiomeDecorator.cactiPerChunk = 0;
+	}
+}

src/net/minecraft/src/BiomeGenDesert.java

@@ -0,0 +1,27 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BiomeGenDesert extends BiomeGenBase {
+	public BiomeGenDesert(int var1) {
+		super(var1);
+		this.spawnableCreatureList.clear();
+		this.topBlock = (byte)Block.sand.blockID;
+		this.fillerBlock = (byte)Block.sand.blockID;
+		this.theBiomeDecorator.treesPerChunk = -999;
+		this.theBiomeDecorator.deadBushPerChunk = 2;
+		this.theBiomeDecorator.reedsPerChunk = 50;
+		this.theBiomeDecorator.cactiPerChunk = 10;
+	}
+
+	public void decorate(World var1, Random var2, int var3, int var4) {
+		super.decorate(var1, var2, var3, var4);
+		if(var2.nextInt(1000) == 0) {
+			int var5 = var3 + var2.nextInt(16) + 8;
+			int var6 = var4 + var2.nextInt(16) + 8;
+			WorldGenDesertWells var7 = new WorldGenDesertWells();
+			var7.generate(var1, var2, var5, var1.getHeightValue(var5, var6) + 1, var6);
+		}
+
+	}
+}

src/net/minecraft/src/BiomeGenEnd.java

@@ -0,0 +1,19 @@
+package net.minecraft.src;
+
+public class BiomeGenEnd extends BiomeGenBase {
+	public BiomeGenEnd(int var1) {
+		super(var1);
+		this.spawnableMonsterList.clear();
+		this.spawnableCreatureList.clear();
+		this.spawnableWaterCreatureList.clear();
+		this.spawnableCaveCreatureList.clear();
+		this.spawnableMonsterList.add(new SpawnListEntry(EntityEnderman.class, 10, 4, 4));
+		this.topBlock = (byte)Block.dirt.blockID;
+		this.fillerBlock = (byte)Block.dirt.blockID;
+		this.theBiomeDecorator = new BiomeEndDecorator(this);
+	}
+
+	public int getSkyColorByTemp(float var1) {
+		return 0;
+	}
+}

src/net/minecraft/src/BiomeGenForest.java

@@ -0,0 +1,16 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BiomeGenForest extends BiomeGenBase {
+	public BiomeGenForest(int var1) {
+		super(var1);
+		this.spawnableCreatureList.add(new SpawnListEntry(EntityWolf.class, 5, 4, 4));
+		this.theBiomeDecorator.treesPerChunk = 10;
+		this.theBiomeDecorator.grassPerChunk = 2;
+	}
+
+	public WorldGenerator getRandomWorldGenForTrees(Random var1) {
+		return (WorldGenerator)(var1.nextInt(5) == 0 ? this.worldGeneratorForest : (var1.nextInt(10) == 0 ? this.worldGeneratorBigTree : this.worldGeneratorTrees));
+	}
+}

src/net/minecraft/src/BiomeGenHell.java

@@ -0,0 +1,14 @@
+package net.minecraft.src;
+
+public class BiomeGenHell extends BiomeGenBase {
+	public BiomeGenHell(int var1) {
+		super(var1);
+		this.spawnableMonsterList.clear();
+		this.spawnableCreatureList.clear();
+		this.spawnableWaterCreatureList.clear();
+		this.spawnableCaveCreatureList.clear();
+		this.spawnableMonsterList.add(new SpawnListEntry(EntityGhast.class, 50, 4, 4));
+		this.spawnableMonsterList.add(new SpawnListEntry(EntityPigZombie.class, 100, 4, 4));
+		this.spawnableMonsterList.add(new SpawnListEntry(EntityMagmaCube.class, 1, 4, 4));
+	}
+}

src/net/minecraft/src/BiomeGenHills.java

@@ -0,0 +1,37 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BiomeGenHills extends BiomeGenBase {
+	private WorldGenerator theWorldGenerator = new WorldGenMinable(Block.silverfish.blockID, 8);
+
+	protected BiomeGenHills(int var1) {
+		super(var1);
+	}
+
+	public void decorate(World var1, Random var2, int var3, int var4) {
+		super.decorate(var1, var2, var3, var4);
+		int var5 = 3 + var2.nextInt(6);
+
+		int var6;
+		int var7;
+		int var8;
+		for(var6 = 0; var6 < var5; ++var6) {
+			var7 = var3 + var2.nextInt(16);
+			var8 = var2.nextInt(28) + 4;
+			int var9 = var4 + var2.nextInt(16);
+			int var10 = var1.getBlockId(var7, var8, var9);
+			if(var10 == Block.stone.blockID) {
+				var1.setBlock(var7, var8, var9, Block.oreEmerald.blockID, 0, 2);
+			}
+		}
+
+		for(var5 = 0; var5 < 7; ++var5) {
+			var6 = var3 + var2.nextInt(16);
+			var7 = var2.nextInt(64);
+			var8 = var4 + var2.nextInt(16);
+			this.theWorldGenerator.generate(var1, var2, var6, var7, var8);
+		}
+
+	}
+}

src/net/minecraft/src/BiomeGenJungle.java

@@ -0,0 +1,35 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BiomeGenJungle extends BiomeGenBase {
+	public BiomeGenJungle(int var1) {
+		super(var1);
+		this.theBiomeDecorator.treesPerChunk = 50;
+		this.theBiomeDecorator.grassPerChunk = 25;
+		this.theBiomeDecorator.flowersPerChunk = 4;
+		this.spawnableMonsterList.add(new SpawnListEntry(EntityOcelot.class, 2, 1, 1));
+		this.spawnableCreatureList.add(new SpawnListEntry(EntityChicken.class, 10, 4, 4));
+	}
+
+	public WorldGenerator getRandomWorldGenForTrees(Random var1) {
+		return (WorldGenerator)(var1.nextInt(10) == 0 ? this.worldGeneratorBigTree : (var1.nextInt(2) == 0 ? new WorldGenShrub(3, 0) : (var1.nextInt(3) == 0 ? new WorldGenHugeTrees(false, 10 + var1.nextInt(20), 3, 3) : new WorldGenTrees(false, 4 + var1.nextInt(7), 3, 3, true))));
+	}
+
+	public WorldGenerator getRandomWorldGenForGrass(Random var1) {
+		return var1.nextInt(4) == 0 ? new WorldGenTallGrass(Block.tallGrass.blockID, 2) : new WorldGenTallGrass(Block.tallGrass.blockID, 1);
+	}
+
+	public void decorate(World var1, Random var2, int var3, int var4) {
+		super.decorate(var1, var2, var3, var4);
+		WorldGenVines var5 = new WorldGenVines();
+
+		for(int var6 = 0; var6 < 50; ++var6) {
+			int var7 = var3 + var2.nextInt(16) + 8;
+			byte var8 = 64;
+			int var9 = var4 + var2.nextInt(16) + 8;
+			var5.generate(var1, var2, var7, var8, var9);
+		}
+
+	}
+}

src/net/minecraft/src/BiomeGenMushroomIsland.java

@@ -0,0 +1,17 @@
+package net.minecraft.src;
+
+public class BiomeGenMushroomIsland extends BiomeGenBase {
+	public BiomeGenMushroomIsland(int var1) {
+		super(var1);
+		this.theBiomeDecorator.treesPerChunk = -100;
+		this.theBiomeDecorator.flowersPerChunk = -100;
+		this.theBiomeDecorator.grassPerChunk = -100;
+		this.theBiomeDecorator.mushroomsPerChunk = 1;
+		this.theBiomeDecorator.bigMushroomsPerChunk = 1;
+		this.topBlock = (byte)Block.mycelium.blockID;
+		this.spawnableMonsterList.clear();
+		this.spawnableCreatureList.clear();
+		this.spawnableWaterCreatureList.clear();
+		this.spawnableCreatureList.add(new SpawnListEntry(EntityMooshroom.class, 8, 4, 8));
+	}
+}

src/net/minecraft/src/BiomeGenOcean.java

@@ -0,0 +1,8 @@
+package net.minecraft.src;
+
+public class BiomeGenOcean extends BiomeGenBase {
+	public BiomeGenOcean(int var1) {
+		super(var1);
+		this.spawnableCreatureList.clear();
+	}
+}

src/net/minecraft/src/BiomeGenPlains.java

@@ -0,0 +1,10 @@
+package net.minecraft.src;
+
+public class BiomeGenPlains extends BiomeGenBase {
+	protected BiomeGenPlains(int var1) {
+		super(var1);
+		this.theBiomeDecorator.treesPerChunk = -999;
+		this.theBiomeDecorator.flowersPerChunk = 4;
+		this.theBiomeDecorator.grassPerChunk = 10;
+	}
+}

src/net/minecraft/src/BiomeGenRiver.java

@@ -0,0 +1,8 @@
+package net.minecraft.src;
+
+public class BiomeGenRiver extends BiomeGenBase {
+	public BiomeGenRiver(int var1) {
+		super(var1);
+		this.spawnableCreatureList.clear();
+	}
+}

src/net/minecraft/src/BiomeGenSnow.java

@@ -0,0 +1,7 @@
+package net.minecraft.src;
+
+public class BiomeGenSnow extends BiomeGenBase {
+	public BiomeGenSnow(int var1) {
+		super(var1);
+	}
+}

src/net/minecraft/src/BiomeGenSwamp.java

@@ -0,0 +1,34 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BiomeGenSwamp extends BiomeGenBase {
+	protected BiomeGenSwamp(int var1) {
+		super(var1);
+		this.theBiomeDecorator.treesPerChunk = 2;
+		this.theBiomeDecorator.flowersPerChunk = -999;
+		this.theBiomeDecorator.deadBushPerChunk = 1;
+		this.theBiomeDecorator.mushroomsPerChunk = 8;
+		this.theBiomeDecorator.reedsPerChunk = 10;
+		this.theBiomeDecorator.clayPerChunk = 1;
+		this.theBiomeDecorator.waterlilyPerChunk = 4;
+		this.waterColorMultiplier = 14745518;
+		this.spawnableMonsterList.add(new SpawnListEntry(EntitySlime.class, 1, 1, 1));
+	}
+
+	public WorldGenerator getRandomWorldGenForTrees(Random var1) {
+		return this.worldGeneratorSwamp;
+	}
+
+	public int getBiomeGrassColor() {
+		double var1 = (double)this.getFloatTemperature();
+		double var3 = (double)this.getFloatRainfall();
+		return ((ColorizerGrass.getGrassColor(var1, var3) & 16711422) + 5115470) / 2;
+	}
+
+	public int getBiomeFoliageColor() {
+		double var1 = (double)this.getFloatTemperature();
+		double var3 = (double)this.getFloatRainfall();
+		return ((ColorizerFoliage.getFoliageColor(var1, var3) & 16711422) + 5115470) / 2;
+	}
+}

src/net/minecraft/src/BiomeGenTaiga.java

@@ -0,0 +1,16 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BiomeGenTaiga extends BiomeGenBase {
+	public BiomeGenTaiga(int var1) {
+		super(var1);
+		this.spawnableCreatureList.add(new SpawnListEntry(EntityWolf.class, 8, 4, 4));
+		this.theBiomeDecorator.treesPerChunk = 10;
+		this.theBiomeDecorator.grassPerChunk = 1;
+	}
+
+	public WorldGenerator getRandomWorldGenForTrees(Random var1) {
+		return (WorldGenerator)(var1.nextInt(3) == 0 ? new WorldGenTaiga1() : new WorldGenTaiga2(false));
+	}
+}

src/net/minecraft/src/Block.java

@@ -0,0 +1,844 @@
+package net.minecraft.src;
+
+import java.util.List;
+import java.util.Random;
+
+public class Block {
+	private CreativeTabs displayOnCreativeTab;
+	public static final StepSound soundPowderFootstep = new StepSound("stone", 1.0F, 1.0F);
+	public static final StepSound soundWoodFootstep = new StepSound("wood", 1.0F, 1.0F);
+	public static final StepSound soundGravelFootstep = new StepSound("gravel", 1.0F, 1.0F);
+	public static final StepSound soundGrassFootstep = new StepSound("grass", 1.0F, 1.0F);
+	public static final StepSound soundStoneFootstep = new StepSound("stone", 1.0F, 1.0F);
+	public static final StepSound soundMetalFootstep = new StepSound("stone", 1.0F, 1.5F);
+	public static final StepSound soundGlassFootstep = new StepSoundStone("stone", 1.0F, 1.0F);
+	public static final StepSound soundClothFootstep = new StepSound("cloth", 1.0F, 1.0F);
+	public static final StepSound soundSandFootstep = new StepSound("sand", 1.0F, 1.0F);
+	public static final StepSound soundSnowFootstep = new StepSound("snow", 1.0F, 1.0F);
+	public static final StepSound soundLadderFootstep = new StepSoundSand("ladder", 1.0F, 1.0F);
+	public static final StepSound soundAnvilFootstep = new StepSoundAnvil("anvil", 0.3F, 1.0F);
+	public static final Block[] blocksList = new Block[4096];
+	public static final boolean[] opaqueCubeLookup = new boolean[4096];
+	public static final int[] lightOpacity = new int[4096];
+	public static final boolean[] canBlockGrass = new boolean[4096];
+	public static final int[] lightValue = new int[4096];
+	public static boolean[] useNeighborBrightness = new boolean[4096];
+	public static final Block stone = (new BlockStone(1)).setHardness(1.5F).setResistance(10.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("stone");
+	public static final BlockGrass grass = (BlockGrass)(new BlockGrass(2)).setHardness(0.6F).setStepSound(soundGrassFootstep).setUnlocalizedName("grass");
+	public static final Block dirt = (new BlockDirt(3)).setHardness(0.5F).setStepSound(soundGravelFootstep).setUnlocalizedName("dirt");
+	public static final Block cobblestone = (new Block(4, Material.rock)).setHardness(2.0F).setResistance(10.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("stonebrick").setCreativeTab(CreativeTabs.tabBlock);
+	public static final Block planks = (new BlockWood(5)).setHardness(2.0F).setResistance(5.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("wood");
+	public static final Block sapling = (new BlockSapling(6)).setHardness(0.0F).setStepSound(soundGrassFootstep).setUnlocalizedName("sapling");
+	public static final Block bedrock = (new Block(7, Material.rock)).setBlockUnbreakable().setResistance(6000000.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("bedrock").disableStats().setCreativeTab(CreativeTabs.tabBlock);
+	public static final BlockFluid waterMoving = (BlockFluid)(new BlockFlowing(8, Material.water)).setHardness(100.0F).setLightOpacity(3).setUnlocalizedName("water").disableStats();
+	public static final Block waterStill = (new BlockStationary(9, Material.water)).setHardness(100.0F).setLightOpacity(3).setUnlocalizedName("water").disableStats();
+	public static final BlockFluid lavaMoving = (BlockFluid)(new BlockFlowing(10, Material.lava)).setHardness(0.0F).setLightValue(1.0F).setUnlocalizedName("lava").disableStats();
+	public static final Block lavaStill = (new BlockStationary(11, Material.lava)).setHardness(100.0F).setLightValue(1.0F).setUnlocalizedName("lava").disableStats();
+	public static final Block sand = (new BlockSand(12)).setHardness(0.5F).setStepSound(soundSandFootstep).setUnlocalizedName("sand");
+	public static final Block gravel = (new BlockGravel(13)).setHardness(0.6F).setStepSound(soundGravelFootstep).setUnlocalizedName("gravel");
+	public static final Block oreGold = (new BlockOre(14)).setHardness(3.0F).setResistance(5.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("oreGold");
+	public static final Block oreIron = (new BlockOre(15)).setHardness(3.0F).setResistance(5.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("oreIron");
+	public static final Block oreCoal = (new BlockOre(16)).setHardness(3.0F).setResistance(5.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("oreCoal");
+	public static final Block wood = (new BlockLog(17)).setHardness(2.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("log");
+	public static final BlockLeaves leaves = (BlockLeaves)(new BlockLeaves(18)).setHardness(0.2F).setLightOpacity(1).setStepSound(soundGrassFootstep).setUnlocalizedName("leaves");
+	public static final Block sponge = (new BlockSponge(19)).setHardness(0.6F).setStepSound(soundGrassFootstep).setUnlocalizedName("sponge");
+	public static final Block glass = (new BlockGlass(20, Material.glass, false)).setHardness(0.3F).setStepSound(soundGlassFootstep).setUnlocalizedName("glass");
+	public static final Block oreLapis = (new BlockOre(21)).setHardness(3.0F).setResistance(5.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("oreLapis");
+	public static final Block blockLapis = (new Block(22, Material.rock)).setHardness(3.0F).setResistance(5.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("blockLapis").setCreativeTab(CreativeTabs.tabBlock);
+	public static final Block dispenser = (new BlockDispenser(23)).setHardness(3.5F).setStepSound(soundStoneFootstep).setUnlocalizedName("dispenser");
+	public static final Block sandStone = (new BlockSandStone(24)).setStepSound(soundStoneFootstep).setHardness(0.8F).setUnlocalizedName("sandStone");
+	public static final Block music = (new BlockNote(25)).setHardness(0.8F).setUnlocalizedName("musicBlock");
+	public static final Block bed = (new BlockBed(26)).setHardness(0.2F).setUnlocalizedName("bed").disableStats();
+	public static final Block railPowered = (new BlockRailPowered(27)).setHardness(0.7F).setStepSound(soundMetalFootstep).setUnlocalizedName("goldenRail");
+	public static final Block railDetector = (new BlockDetectorRail(28)).setHardness(0.7F).setStepSound(soundMetalFootstep).setUnlocalizedName("detectorRail");
+	public static final BlockPistonBase pistonStickyBase = (BlockPistonBase)(new BlockPistonBase(29, true)).setUnlocalizedName("pistonStickyBase");
+	public static final Block web = (new BlockWeb(30)).setLightOpacity(1).setHardness(4.0F).setUnlocalizedName("web");
+	public static final BlockTallGrass tallGrass = (BlockTallGrass)(new BlockTallGrass(31)).setHardness(0.0F).setStepSound(soundGrassFootstep).setUnlocalizedName("tallgrass");
+	public static final BlockDeadBush deadBush = (BlockDeadBush)(new BlockDeadBush(32)).setHardness(0.0F).setStepSound(soundGrassFootstep).setUnlocalizedName("deadbush");
+	public static final BlockPistonBase pistonBase = (BlockPistonBase)(new BlockPistonBase(33, false)).setUnlocalizedName("pistonBase");
+	public static final BlockPistonExtension pistonExtension = new BlockPistonExtension(34);
+	public static final Block cloth = (new BlockCloth()).setHardness(0.8F).setStepSound(soundClothFootstep).setUnlocalizedName("cloth");
+	public static final BlockPistonMoving pistonMoving = new BlockPistonMoving(36);
+	public static final BlockFlower plantYellow = (BlockFlower)(new BlockFlower(37)).setHardness(0.0F).setStepSound(soundGrassFootstep).setUnlocalizedName("flower");
+	public static final BlockFlower plantRed = (BlockFlower)(new BlockFlower(38)).setHardness(0.0F).setStepSound(soundGrassFootstep).setUnlocalizedName("rose");
+	public static final BlockFlower mushroomBrown = (BlockFlower)(new BlockMushroom(39, "mushroom_brown")).setHardness(0.0F).setStepSound(soundGrassFootstep).setLightValue(2.0F / 16.0F).setUnlocalizedName("mushroom");
+	public static final BlockFlower mushroomRed = (BlockFlower)(new BlockMushroom(40, "mushroom_red")).setHardness(0.0F).setStepSound(soundGrassFootstep).setUnlocalizedName("mushroom");
+	public static final Block blockGold = (new BlockOreStorage(41)).setHardness(3.0F).setResistance(10.0F).setStepSound(soundMetalFootstep).setUnlocalizedName("blockGold");
+	public static final Block blockIron = (new BlockOreStorage(42)).setHardness(5.0F).setResistance(10.0F).setStepSound(soundMetalFootstep).setUnlocalizedName("blockIron");
+	public static final BlockHalfSlab stoneDoubleSlab = (BlockHalfSlab)(new BlockStep(43, true)).setHardness(2.0F).setResistance(10.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("stoneSlab");
+	public static final BlockHalfSlab stoneSingleSlab = (BlockHalfSlab)(new BlockStep(44, false)).setHardness(2.0F).setResistance(10.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("stoneSlab");
+	public static final Block brick = (new Block(45, Material.rock)).setHardness(2.0F).setResistance(10.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("brick").setCreativeTab(CreativeTabs.tabBlock);
+	public static final Block tnt = (new BlockTNT(46)).setHardness(0.0F).setStepSound(soundGrassFootstep).setUnlocalizedName("tnt");
+	public static final Block bookShelf = (new BlockBookshelf(47)).setHardness(1.5F).setStepSound(soundWoodFootstep).setUnlocalizedName("bookshelf");
+	public static final Block cobblestoneMossy = (new Block(48, Material.rock)).setHardness(2.0F).setResistance(10.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("stoneMoss").setCreativeTab(CreativeTabs.tabBlock);
+	public static final Block obsidian = (new BlockObsidian(49)).setHardness(50.0F).setResistance(2000.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("obsidian");
+	public static final Block torchWood = (new BlockTorch(50)).setHardness(0.0F).setLightValue(15.0F / 16.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("torch");
+	public static final BlockFire fire = (BlockFire)(new BlockFire(51)).setHardness(0.0F).setLightValue(1.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("fire").disableStats();
+	public static final Block mobSpawner = (new BlockMobSpawner(52)).setHardness(5.0F).setStepSound(soundMetalFootstep).setUnlocalizedName("mobSpawner").disableStats();
+	public static final Block stairsWoodOak = (new BlockStairs(53, planks, 0)).setUnlocalizedName("stairsWood");
+	public static final BlockChest chest = (BlockChest)(new BlockChest(54, 0)).setHardness(2.5F).setStepSound(soundWoodFootstep).setUnlocalizedName("chest");
+	public static final BlockRedstoneWire redstoneWire = (BlockRedstoneWire)(new BlockRedstoneWire(55)).setHardness(0.0F).setStepSound(soundPowderFootstep).setUnlocalizedName("redstoneDust").disableStats();
+	public static final Block oreDiamond = (new BlockOre(56)).setHardness(3.0F).setResistance(5.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("oreDiamond");
+	public static final Block blockDiamond = (new BlockOreStorage(57)).setHardness(5.0F).setResistance(10.0F).setStepSound(soundMetalFootstep).setUnlocalizedName("blockDiamond");
+	public static final Block workbench = (new BlockWorkbench(58)).setHardness(2.5F).setStepSound(soundWoodFootstep).setUnlocalizedName("workbench");
+	public static final Block crops = (new BlockCrops(59)).setUnlocalizedName("crops");
+	public static final Block tilledField = (new BlockFarmland(60)).setHardness(0.6F).setStepSound(soundGravelFootstep).setUnlocalizedName("farmland");
+	public static final Block furnaceIdle = (new BlockFurnace(61, false)).setHardness(3.5F).setStepSound(soundStoneFootstep).setUnlocalizedName("furnace").setCreativeTab(CreativeTabs.tabDecorations);
+	public static final Block furnaceBurning = (new BlockFurnace(62, true)).setHardness(3.5F).setStepSound(soundStoneFootstep).setLightValue(14.0F / 16.0F).setUnlocalizedName("furnace");
+	public static final Block signPost = (new BlockSign(63, TileEntitySign.class, true)).setHardness(1.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("sign").disableStats();
+	public static final Block doorWood = (new BlockDoor(64, Material.wood)).setHardness(3.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("doorWood").disableStats();
+	public static final Block ladder = (new BlockLadder(65)).setHardness(0.4F).setStepSound(soundLadderFootstep).setUnlocalizedName("ladder");
+	public static final Block rail = (new BlockRail(66)).setHardness(0.7F).setStepSound(soundMetalFootstep).setUnlocalizedName("rail");
+	public static final Block stairsCobblestone = (new BlockStairs(67, cobblestone, 0)).setUnlocalizedName("stairsStone");
+	public static final Block signWall = (new BlockSign(68, TileEntitySign.class, false)).setHardness(1.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("sign").disableStats();
+	public static final Block lever = (new BlockLever(69)).setHardness(0.5F).setStepSound(soundWoodFootstep).setUnlocalizedName("lever");
+	public static final Block pressurePlateStone = (new BlockPressurePlate(70, "stone", Material.rock, EnumMobType.mobs)).setHardness(0.5F).setStepSound(soundStoneFootstep).setUnlocalizedName("pressurePlate");
+	public static final Block doorIron = (new BlockDoor(71, Material.iron)).setHardness(5.0F).setStepSound(soundMetalFootstep).setUnlocalizedName("doorIron").disableStats();
+	public static final Block pressurePlatePlanks = (new BlockPressurePlate(72, "wood", Material.wood, EnumMobType.everything)).setHardness(0.5F).setStepSound(soundWoodFootstep).setUnlocalizedName("pressurePlate");
+	public static final Block oreRedstone = (new BlockRedstoneOre(73, false)).setHardness(3.0F).setResistance(5.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("oreRedstone").setCreativeTab(CreativeTabs.tabBlock);
+	public static final Block oreRedstoneGlowing = (new BlockRedstoneOre(74, true)).setLightValue(10.0F / 16.0F).setHardness(3.0F).setResistance(5.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("oreRedstone");
+	public static final Block torchRedstoneIdle = (new BlockRedstoneTorch(75, false)).setHardness(0.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("notGate");
+	public static final Block torchRedstoneActive = (new BlockRedstoneTorch(76, true)).setHardness(0.0F).setLightValue(0.5F).setStepSound(soundWoodFootstep).setUnlocalizedName("notGate").setCreativeTab(CreativeTabs.tabRedstone);
+	public static final Block stoneButton = (new BlockButtonStone(77)).setHardness(0.5F).setStepSound(soundStoneFootstep).setUnlocalizedName("button");
+	public static final Block snow = (new BlockSnow(78)).setHardness(0.1F).setStepSound(soundSnowFootstep).setUnlocalizedName("snow").setLightOpacity(0);
+	public static final Block ice = (new BlockIce(79)).setHardness(0.5F).setLightOpacity(3).setStepSound(soundGlassFootstep).setUnlocalizedName("ice");
+	public static final Block blockSnow = (new BlockSnowBlock(80)).setHardness(0.2F).setStepSound(soundSnowFootstep).setUnlocalizedName("snow");
+	public static final Block cactus = (new BlockCactus(81)).setHardness(0.4F).setStepSound(soundClothFootstep).setUnlocalizedName("cactus");
+	public static final Block blockClay = (new BlockClay(82)).setHardness(0.6F).setStepSound(soundGravelFootstep).setUnlocalizedName("clay");
+	public static final Block reed = (new BlockReed(83)).setHardness(0.0F).setStepSound(soundGrassFootstep).setUnlocalizedName("reeds").disableStats();
+	public static final Block jukebox = (new BlockJukeBox(84)).setHardness(2.0F).setResistance(10.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("jukebox");
+	public static final Block fence = (new BlockFence(85, "wood", Material.wood)).setHardness(2.0F).setResistance(5.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("fence");
+	public static final Block pumpkin = (new BlockPumpkin(86, false)).setHardness(1.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("pumpkin");
+	public static final Block netherrack = (new BlockNetherrack(87)).setHardness(0.4F).setStepSound(soundStoneFootstep).setUnlocalizedName("hellrock");
+	public static final Block slowSand = (new BlockSoulSand(88)).setHardness(0.5F).setStepSound(soundSandFootstep).setUnlocalizedName("hellsand");
+	public static final Block glowStone = (new BlockGlowStone(89, Material.glass)).setHardness(0.3F).setStepSound(soundGlassFootstep).setLightValue(1.0F).setUnlocalizedName("lightgem");
+	public static final BlockPortal portal = (BlockPortal)(new BlockPortal(90)).setHardness(-1.0F).setStepSound(soundGlassFootstep).setLightValue(12.0F / 16.0F).setUnlocalizedName("portal");
+	public static final Block pumpkinLantern = (new BlockPumpkin(91, true)).setHardness(1.0F).setStepSound(soundWoodFootstep).setLightValue(1.0F).setUnlocalizedName("litpumpkin");
+	public static final Block cake = (new BlockCake(92)).setHardness(0.5F).setStepSound(soundClothFootstep).setUnlocalizedName("cake").disableStats();
+	public static final BlockRedstoneRepeater redstoneRepeaterIdle = (BlockRedstoneRepeater)(new BlockRedstoneRepeater(93, false)).setHardness(0.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("diode").disableStats();
+	public static final BlockRedstoneRepeater redstoneRepeaterActive = (BlockRedstoneRepeater)(new BlockRedstoneRepeater(94, true)).setHardness(0.0F).setLightValue(10.0F / 16.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("diode").disableStats();
+	public static final Block lockedChest = (new BlockLockedChest(95)).setHardness(0.0F).setLightValue(1.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("lockedchest").setTickRandomly(true);
+	public static final Block trapdoor = (new BlockTrapDoor(96, Material.wood)).setHardness(3.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("trapdoor").disableStats();
+	public static final Block silverfish = (new BlockSilverfish(97)).setHardness(12.0F / 16.0F).setUnlocalizedName("monsterStoneEgg");
+	public static final Block stoneBrick = (new BlockStoneBrick(98)).setHardness(1.5F).setResistance(10.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("stonebricksmooth");
+	public static final Block mushroomCapBrown = (new BlockMushroomCap(99, Material.wood, 0)).setHardness(0.2F).setStepSound(soundWoodFootstep).setUnlocalizedName("mushroom");
+	public static final Block mushroomCapRed = (new BlockMushroomCap(100, Material.wood, 1)).setHardness(0.2F).setStepSound(soundWoodFootstep).setUnlocalizedName("mushroom");
+	public static final Block fenceIron = (new BlockPane(101, "fenceIron", "fenceIron", Material.iron, true)).setHardness(5.0F).setResistance(10.0F).setStepSound(soundMetalFootstep).setUnlocalizedName("fenceIron");
+	public static final Block thinGlass = (new BlockPane(102, "glass", "thinglass_top", Material.glass, false)).setHardness(0.3F).setStepSound(soundGlassFootstep).setUnlocalizedName("thinGlass");
+	public static final Block melon = (new BlockMelon(103)).setHardness(1.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("melon");
+	public static final Block pumpkinStem = (new BlockStem(104, pumpkin)).setHardness(0.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("pumpkinStem");
+	public static final Block melonStem = (new BlockStem(105, melon)).setHardness(0.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("pumpkinStem");
+	public static final Block vine = (new BlockVine(106)).setHardness(0.2F).setStepSound(soundGrassFootstep).setUnlocalizedName("vine");
+	public static final Block fenceGate = (new BlockFenceGate(107)).setHardness(2.0F).setResistance(5.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("fenceGate");
+	public static final Block stairsBrick = (new BlockStairs(108, brick, 0)).setUnlocalizedName("stairsBrick");
+	public static final Block stairsStoneBrick = (new BlockStairs(109, stoneBrick, 0)).setUnlocalizedName("stairsStoneBrickSmooth");
+	public static final BlockMycelium mycelium = (BlockMycelium)(new BlockMycelium(110)).setHardness(0.6F).setStepSound(soundGrassFootstep).setUnlocalizedName("mycel");
+	public static final Block waterlily = (new BlockLilyPad(111)).setHardness(0.0F).setStepSound(soundGrassFootstep).setUnlocalizedName("waterlily");
+	public static final Block netherBrick = (new Block(112, Material.rock)).setHardness(2.0F).setResistance(10.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("netherBrick").setCreativeTab(CreativeTabs.tabBlock);
+	public static final Block netherFence = (new BlockFence(113, "netherBrick", Material.rock)).setHardness(2.0F).setResistance(10.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("netherFence");
+	public static final Block stairsNetherBrick = (new BlockStairs(114, netherBrick, 0)).setUnlocalizedName("stairsNetherBrick");
+	public static final Block netherStalk = (new BlockNetherStalk(115)).setUnlocalizedName("netherStalk");
+	public static final Block enchantmentTable = (new BlockEnchantmentTable(116)).setHardness(5.0F).setResistance(2000.0F).setUnlocalizedName("enchantmentTable");
+	public static final Block brewingStand = (new BlockBrewingStand(117)).setHardness(0.5F).setLightValue(2.0F / 16.0F).setUnlocalizedName("brewingStand");
+	public static final BlockCauldron cauldron = (BlockCauldron)(new BlockCauldron(118)).setHardness(2.0F).setUnlocalizedName("cauldron");
+	public static final Block endPortal = (new BlockEndPortal(119, Material.portal)).setHardness(-1.0F).setResistance(6000000.0F);
+	public static final Block endPortalFrame = (new BlockEndPortalFrame(120)).setStepSound(soundGlassFootstep).setLightValue(2.0F / 16.0F).setHardness(-1.0F).setUnlocalizedName("endPortalFrame").setResistance(6000000.0F).setCreativeTab(CreativeTabs.tabDecorations);
+	public static final Block whiteStone = (new Block(121, Material.rock)).setHardness(3.0F).setResistance(15.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("whiteStone").setCreativeTab(CreativeTabs.tabBlock);
+	public static final Block dragonEgg = (new BlockDragonEgg(122)).setHardness(3.0F).setResistance(15.0F).setStepSound(soundStoneFootstep).setLightValue(2.0F / 16.0F).setUnlocalizedName("dragonEgg");
+	public static final Block redstoneLampIdle = (new BlockRedstoneLight(123, false)).setHardness(0.3F).setStepSound(soundGlassFootstep).setUnlocalizedName("redstoneLight").setCreativeTab(CreativeTabs.tabRedstone);
+	public static final Block redstoneLampActive = (new BlockRedstoneLight(124, true)).setHardness(0.3F).setStepSound(soundGlassFootstep).setUnlocalizedName("redstoneLight");
+	public static final BlockHalfSlab woodDoubleSlab = (BlockHalfSlab)(new BlockWoodSlab(125, true)).setHardness(2.0F).setResistance(5.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("woodSlab");
+	public static final BlockHalfSlab woodSingleSlab = (BlockHalfSlab)(new BlockWoodSlab(126, false)).setHardness(2.0F).setResistance(5.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("woodSlab");
+	public static final Block cocoaPlant = (new BlockCocoa(127)).setHardness(0.2F).setResistance(5.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("cocoa");
+	public static final Block stairsSandStone = (new BlockStairs(128, sandStone, 0)).setUnlocalizedName("stairsSandStone");
+	public static final Block oreEmerald = (new BlockOre(129)).setHardness(3.0F).setResistance(5.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("oreEmerald");
+	public static final Block enderChest = (new BlockEnderChest(130)).setHardness(22.5F).setResistance(1000.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("enderChest").setLightValue(0.5F);
+	public static final BlockTripWireSource tripWireSource = (BlockTripWireSource)(new BlockTripWireSource(131)).setUnlocalizedName("tripWireSource");
+	public static final Block tripWire = (new BlockTripWire(132)).setUnlocalizedName("tripWire");
+	public static final Block blockEmerald = (new BlockOreStorage(133)).setHardness(5.0F).setResistance(10.0F).setStepSound(soundMetalFootstep).setUnlocalizedName("blockEmerald");
+	public static final Block stairsWoodSpruce = (new BlockStairs(134, planks, 1)).setUnlocalizedName("stairsWoodSpruce");
+	public static final Block stairsWoodBirch = (new BlockStairs(135, planks, 2)).setUnlocalizedName("stairsWoodBirch");
+	public static final Block stairsWoodJungle = (new BlockStairs(136, planks, 3)).setUnlocalizedName("stairsWoodJungle");
+	public static final Block commandBlock = (new BlockCommandBlock(137)).setUnlocalizedName("commandBlock");
+	public static final BlockBeacon beacon = (BlockBeacon)(new BlockBeacon(138)).setUnlocalizedName("beacon").setLightValue(1.0F);
+	public static final Block cobblestoneWall = (new BlockWall(139, cobblestone)).setUnlocalizedName("cobbleWall");
+	public static final Block flowerPot = (new BlockFlowerPot(140)).setHardness(0.0F).setStepSound(soundPowderFootstep).setUnlocalizedName("flowerPot");
+	public static final Block carrot = (new BlockCarrot(141)).setUnlocalizedName("carrots");
+	public static final Block potato = (new BlockPotato(142)).setUnlocalizedName("potatoes");
+	public static final Block woodenButton = (new BlockButtonWood(143)).setHardness(0.5F).setStepSound(soundWoodFootstep).setUnlocalizedName("button");
+	public static final Block skull = (new BlockSkull(144)).setHardness(1.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("skull");
+	public static final Block anvil = (new BlockAnvil(145)).setHardness(5.0F).setStepSound(soundAnvilFootstep).setResistance(2000.0F).setUnlocalizedName("anvil");
+	public static final Block chestTrapped = (new BlockChest(146, 1)).setHardness(2.5F).setStepSound(soundWoodFootstep).setUnlocalizedName("chestTrap");
+	public static final Block pressurePlateGold = (new BlockPressurePlateWeighted(147, "blockGold", Material.iron, 64)).setHardness(0.5F).setStepSound(soundWoodFootstep).setUnlocalizedName("weightedPlate_light");
+	public static final Block pressurePlateIron = (new BlockPressurePlateWeighted(148, "blockIron", Material.iron, 640)).setHardness(0.5F).setStepSound(soundWoodFootstep).setUnlocalizedName("weightedPlate_heavy");
+	public static final BlockComparator redstoneComparatorIdle = (BlockComparator)(new BlockComparator(149, false)).setHardness(0.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("comparator").disableStats();
+	public static final BlockComparator redstoneComparatorActive = (BlockComparator)(new BlockComparator(150, true)).setHardness(0.0F).setLightValue(10.0F / 16.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("comparator").disableStats();
+	public static final BlockDaylightDetector daylightSensor = (BlockDaylightDetector)(new BlockDaylightDetector(151)).setHardness(0.2F).setStepSound(soundWoodFootstep).setUnlocalizedName("daylightDetector");
+	public static final Block blockRedstone = (new BlockPoweredOre(152)).setHardness(5.0F).setResistance(10.0F).setStepSound(soundMetalFootstep).setUnlocalizedName("blockRedstone");
+	public static final Block oreNetherQuartz = (new BlockOre(153)).setHardness(3.0F).setResistance(5.0F).setStepSound(soundStoneFootstep).setUnlocalizedName("netherquartz");
+	public static final BlockHopper hopperBlock = (BlockHopper)(new BlockHopper(154)).setHardness(3.0F).setResistance(8.0F).setStepSound(soundWoodFootstep).setUnlocalizedName("hopper");
+	public static final Block blockNetherQuartz = (new BlockQuartz(155)).setStepSound(soundStoneFootstep).setHardness(0.8F).setUnlocalizedName("quartzBlock");
+	public static final Block stairsNetherQuartz = (new BlockStairs(156, blockNetherQuartz, 0)).setUnlocalizedName("stairsQuartz");
+	public static final Block railActivator = (new BlockRailPowered(157)).setHardness(0.7F).setStepSound(soundMetalFootstep).setUnlocalizedName("activatorRail");
+	public static final Block dropper = (new BlockDropper(158)).setHardness(3.5F).setStepSound(soundStoneFootstep).setUnlocalizedName("dropper");
+	public final int blockID;
+	protected float blockHardness;
+	protected float blockResistance;
+	protected boolean blockConstructorCalled = true;
+	protected boolean enableStats = true;
+	protected boolean needsRandomTick;
+	protected boolean isBlockContainer;
+	protected double minX;
+	protected double minY;
+	protected double minZ;
+	protected double maxX;
+	protected double maxY;
+	protected double maxZ;
+	public StepSound stepSound = soundPowderFootstep;
+	public float blockParticleGravity = 1.0F;
+	public final Material blockMaterial;
+	public float slipperiness = 0.6F;
+	private String unlocalizedName;
+	protected Icon blockIcon;
+
+	protected Block(int var1, Material var2) {
+		if(blocksList[var1] != null) {
+			throw new IllegalArgumentException("Slot " + var1 + " is already occupied by " + blocksList[var1] + " when adding " + this);
+		} else {
+			this.blockMaterial = var2;
+			blocksList[var1] = this;
+			this.blockID = var1;
+			this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
+			opaqueCubeLookup[var1] = this.isOpaqueCube();
+			lightOpacity[var1] = this.isOpaqueCube() ? 255 : 0;
+			canBlockGrass[var1] = !var2.getCanBlockGrass();
+		}
+	}
+
+	protected void initializeBlock() {
+	}
+
+	protected Block setStepSound(StepSound var1) {
+		this.stepSound = var1;
+		return this;
+	}
+
+	protected Block setLightOpacity(int var1) {
+		lightOpacity[this.blockID] = var1;
+		return this;
+	}
+
+	protected Block setLightValue(float var1) {
+		lightValue[this.blockID] = (int)(15.0F * var1);
+		return this;
+	}
+
+	protected Block setResistance(float var1) {
+		this.blockResistance = var1 * 3.0F;
+		return this;
+	}
+
+	public static boolean isNormalCube(int var0) {
+		Block var1 = blocksList[var0];
+		return var1 == null ? false : var1.blockMaterial.isOpaque() && var1.renderAsNormalBlock() && !var1.canProvidePower();
+	}
+
+	public boolean renderAsNormalBlock() {
+		return true;
+	}
+
+	public boolean getBlocksMovement(IBlockAccess var1, int var2, int var3, int var4) {
+		return !this.blockMaterial.blocksMovement();
+	}
+
+	public int getRenderType() {
+		return 0;
+	}
+
+	protected Block setHardness(float var1) {
+		this.blockHardness = var1;
+		if(this.blockResistance < var1 * 5.0F) {
+			this.blockResistance = var1 * 5.0F;
+		}
+
+		return this;
+	}
+
+	protected Block setBlockUnbreakable() {
+		this.setHardness(-1.0F);
+		return this;
+	}
+
+	public float getBlockHardness(World var1, int var2, int var3, int var4) {
+		return this.blockHardness;
+	}
+
+	protected Block setTickRandomly(boolean var1) {
+		this.needsRandomTick = var1;
+		return this;
+	}
+
+	public boolean getTickRandomly() {
+		return this.needsRandomTick;
+	}
+
+	public boolean hasTileEntity() {
+		return this.isBlockContainer;
+	}
+
+	protected final void setBlockBounds(float var1, float var2, float var3, float var4, float var5, float var6) {
+		this.minX = (double)var1;
+		this.minY = (double)var2;
+		this.minZ = (double)var3;
+		this.maxX = (double)var4;
+		this.maxY = (double)var5;
+		this.maxZ = (double)var6;
+	}
+
+	public float getBlockBrightness(IBlockAccess var1, int var2, int var3, int var4) {
+		return var1.getBrightness(var2, var3, var4, lightValue[var1.getBlockId(var2, var3, var4)]);
+	}
+
+	public int getMixedBrightnessForBlock(IBlockAccess var1, int var2, int var3, int var4) {
+		return var1.getLightBrightnessForSkyBlocks(var2, var3, var4, lightValue[var1.getBlockId(var2, var3, var4)]);
+	}
+
+	public boolean shouldSideBeRendered(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return var5 == 0 && this.minY > 0.0D ? true : (var5 == 1 && this.maxY < 1.0D ? true : (var5 == 2 && this.minZ > 0.0D ? true : (var5 == 3 && this.maxZ < 1.0D ? true : (var5 == 4 && this.minX > 0.0D ? true : (var5 == 5 && this.maxX < 1.0D ? true : !var1.isBlockOpaqueCube(var2, var3, var4))))));
+	}
+
+	public boolean isBlockSolid(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return var1.getBlockMaterial(var2, var3, var4).isSolid();
+	}
+
+	public Icon getBlockTexture(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return this.getIcon(var5, var1.getBlockMetadata(var2, var3, var4));
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return this.blockIcon;
+	}
+
+	public final Icon getBlockTextureFromSide(int var1) {
+		return this.getIcon(var1, 0);
+	}
+
+	public AxisAlignedBB getSelectedBoundingBoxFromPool(World var1, int var2, int var3, int var4) {
+		return AxisAlignedBB.getAABBPool().getAABB((double)var2 + this.minX, (double)var3 + this.minY, (double)var4 + this.minZ, (double)var2 + this.maxX, (double)var3 + this.maxY, (double)var4 + this.maxZ);
+	}
+
+	public void addCollisionBoxesToList(World var1, int var2, int var3, int var4, AxisAlignedBB var5, List var6, Entity var7) {
+		AxisAlignedBB var8 = this.getCollisionBoundingBoxFromPool(var1, var2, var3, var4);
+		if(var8 != null && var5.intersectsWith(var8)) {
+			var6.add(var8);
+		}
+
+	}
+
+	public AxisAlignedBB getCollisionBoundingBoxFromPool(World var1, int var2, int var3, int var4) {
+		return AxisAlignedBB.getAABBPool().getAABB((double)var2 + this.minX, (double)var3 + this.minY, (double)var4 + this.minZ, (double)var2 + this.maxX, (double)var3 + this.maxY, (double)var4 + this.maxZ);
+	}
+
+	public boolean isOpaqueCube() {
+		return true;
+	}
+
+	public boolean canCollideCheck(int var1, boolean var2) {
+		return this.isCollidable();
+	}
+
+	public boolean isCollidable() {
+		return true;
+	}
+
+	public void updateTick(World var1, int var2, int var3, int var4, Random var5) {
+	}
+
+	public void randomDisplayTick(World var1, int var2, int var3, int var4, Random var5) {
+	}
+
+	public void onBlockDestroyedByPlayer(World var1, int var2, int var3, int var4, int var5) {
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+	}
+
+	public int tickRate(World var1) {
+		return 10;
+	}
+
+	public void onBlockAdded(World var1, int var2, int var3, int var4) {
+	}
+
+	public void breakBlock(World var1, int var2, int var3, int var4, int var5, int var6) {
+	}
+
+	public int quantityDropped(Random var1) {
+		return 1;
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		return this.blockID;
+	}
+
+	public float getPlayerRelativeBlockHardness(EntityPlayer var1, World var2, int var3, int var4, int var5) {
+		float var6 = this.getBlockHardness(var2, var3, var4, var5);
+		return var6 < 0.0F ? 0.0F : (!var1.canHarvestBlock(this) ? var1.getCurrentPlayerStrVsBlock(this, false) / var6 / 100.0F : var1.getCurrentPlayerStrVsBlock(this, true) / var6 / 30.0F);
+	}
+
+	public final void dropBlockAsItem(World var1, int var2, int var3, int var4, int var5, int var6) {
+		this.dropBlockAsItemWithChance(var1, var2, var3, var4, var5, 1.0F, var6);
+	}
+
+	public void dropBlockAsItemWithChance(World var1, int var2, int var3, int var4, int var5, float var6, int var7) {
+		if(!var1.isRemote) {
+			int var8 = this.quantityDroppedWithBonus(var7, var1.rand);
+
+			for(int var9 = 0; var9 < var8; ++var9) {
+				if(var1.rand.nextFloat() <= var6) {
+					int var10 = this.idDropped(var5, var1.rand, var7);
+					if(var10 > 0) {
+						this.dropBlockAsItem_do(var1, var2, var3, var4, new ItemStack(var10, 1, this.damageDropped(var5)));
+					}
+				}
+			}
+
+		}
+	}
+
+	protected void dropBlockAsItem_do(World var1, int var2, int var3, int var4, ItemStack var5) {
+		if(!var1.isRemote && var1.getGameRules().getGameRuleBooleanValue("doTileDrops")) {
+			float var6 = 0.7F;
+			double var7 = (double)(var1.rand.nextFloat() * var6) + (double)(1.0F - var6) * 0.5D;
+			double var9 = (double)(var1.rand.nextFloat() * var6) + (double)(1.0F - var6) * 0.5D;
+			double var11 = (double)(var1.rand.nextFloat() * var6) + (double)(1.0F - var6) * 0.5D;
+			EntityItem var13 = new EntityItem(var1, (double)var2 + var7, (double)var3 + var9, (double)var4 + var11, var5);
+			var13.delayBeforeCanPickup = 10;
+			var1.spawnEntityInWorld(var13);
+		}
+	}
+
+	protected void dropXpOnBlockBreak(World var1, int var2, int var3, int var4, int var5) {
+		if(!var1.isRemote) {
+			while(var5 > 0) {
+				int var6 = EntityXPOrb.getXPSplit(var5);
+				var5 -= var6;
+				var1.spawnEntityInWorld(new EntityXPOrb(var1, (double)var2 + 0.5D, (double)var3 + 0.5D, (double)var4 + 0.5D, var6));
+			}
+		}
+
+	}
+
+	public int damageDropped(int var1) {
+		return 0;
+	}
+
+	public float getExplosionResistance(Entity var1) {
+		return this.blockResistance / 5.0F;
+	}
+
+	public MovingObjectPosition collisionRayTrace(World var1, int var2, int var3, int var4, Vec3 var5, Vec3 var6) {
+		this.setBlockBoundsBasedOnState(var1, var2, var3, var4);
+		var5 = var5.addVector((double)(-var2), (double)(-var3), (double)(-var4));
+		var6 = var6.addVector((double)(-var2), (double)(-var3), (double)(-var4));
+		Vec3 var7 = var5.getIntermediateWithXValue(var6, this.minX);
+		Vec3 var8 = var5.getIntermediateWithXValue(var6, this.maxX);
+		Vec3 var9 = var5.getIntermediateWithYValue(var6, this.minY);
+		Vec3 var10 = var5.getIntermediateWithYValue(var6, this.maxY);
+		Vec3 var11 = var5.getIntermediateWithZValue(var6, this.minZ);
+		Vec3 var12 = var5.getIntermediateWithZValue(var6, this.maxZ);
+		if(!this.isVecInsideYZBounds(var7)) {
+			var7 = null;
+		}
+
+		if(!this.isVecInsideYZBounds(var8)) {
+			var8 = null;
+		}
+
+		if(!this.isVecInsideXZBounds(var9)) {
+			var9 = null;
+		}
+
+		if(!this.isVecInsideXZBounds(var10)) {
+			var10 = null;
+		}
+
+		if(!this.isVecInsideXYBounds(var11)) {
+			var11 = null;
+		}
+
+		if(!this.isVecInsideXYBounds(var12)) {
+			var12 = null;
+		}
+
+		Vec3 var13 = null;
+		if(var7 != null && (var13 == null || var5.squareDistanceTo(var7) < var5.squareDistanceTo(var13))) {
+			var13 = var7;
+		}
+
+		if(var8 != null && (var13 == null || var5.squareDistanceTo(var8) < var5.squareDistanceTo(var13))) {
+			var13 = var8;
+		}
+
+		if(var9 != null && (var13 == null || var5.squareDistanceTo(var9) < var5.squareDistanceTo(var13))) {
+			var13 = var9;
+		}
+
+		if(var10 != null && (var13 == null || var5.squareDistanceTo(var10) < var5.squareDistanceTo(var13))) {
+			var13 = var10;
+		}
+
+		if(var11 != null && (var13 == null || var5.squareDistanceTo(var11) < var5.squareDistanceTo(var13))) {
+			var13 = var11;
+		}
+
+		if(var12 != null && (var13 == null || var5.squareDistanceTo(var12) < var5.squareDistanceTo(var13))) {
+			var13 = var12;
+		}
+
+		if(var13 == null) {
+			return null;
+		} else {
+			byte var14 = -1;
+			if(var13 == var7) {
+				var14 = 4;
+			}
+
+			if(var13 == var8) {
+				var14 = 5;
+			}
+
+			if(var13 == var9) {
+				var14 = 0;
+			}
+
+			if(var13 == var10) {
+				var14 = 1;
+			}
+
+			if(var13 == var11) {
+				var14 = 2;
+			}
+
+			if(var13 == var12) {
+				var14 = 3;
+			}
+
+			return new MovingObjectPosition(var2, var3, var4, var14, var13.addVector((double)var2, (double)var3, (double)var4));
+		}
+	}
+
+	private boolean isVecInsideYZBounds(Vec3 var1) {
+		return var1 == null ? false : var1.yCoord >= this.minY && var1.yCoord <= this.maxY && var1.zCoord >= this.minZ && var1.zCoord <= this.maxZ;
+	}
+
+	private boolean isVecInsideXZBounds(Vec3 var1) {
+		return var1 == null ? false : var1.xCoord >= this.minX && var1.xCoord <= this.maxX && var1.zCoord >= this.minZ && var1.zCoord <= this.maxZ;
+	}
+
+	private boolean isVecInsideXYBounds(Vec3 var1) {
+		return var1 == null ? false : var1.xCoord >= this.minX && var1.xCoord <= this.maxX && var1.yCoord >= this.minY && var1.yCoord <= this.maxY;
+	}
+
+	public void onBlockDestroyedByExplosion(World var1, int var2, int var3, int var4, Explosion var5) {
+	}
+
+	public int getRenderBlockPass() {
+		return 0;
+	}
+
+	public boolean canPlaceBlockOnSide(World var1, int var2, int var3, int var4, int var5, ItemStack var6) {
+		return this.canPlaceBlockOnSide(var1, var2, var3, var4, var5);
+	}
+
+	public boolean canPlaceBlockOnSide(World var1, int var2, int var3, int var4, int var5) {
+		return this.canPlaceBlockAt(var1, var2, var3, var4);
+	}
+
+	public boolean canPlaceBlockAt(World var1, int var2, int var3, int var4) {
+		int var5 = var1.getBlockId(var2, var3, var4);
+		return var5 == 0 || blocksList[var5].blockMaterial.isReplaceable();
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		return false;
+	}
+
+	public void onEntityWalking(World var1, int var2, int var3, int var4, Entity var5) {
+	}
+
+	public int onBlockPlaced(World var1, int var2, int var3, int var4, int var5, float var6, float var7, float var8, int var9) {
+		return var9;
+	}
+
+	public void onBlockClicked(World var1, int var2, int var3, int var4, EntityPlayer var5) {
+	}
+
+	public void velocityToAddToEntity(World var1, int var2, int var3, int var4, Entity var5, Vec3 var6) {
+	}
+
+	public void setBlockBoundsBasedOnState(IBlockAccess var1, int var2, int var3, int var4) {
+	}
+
+	public final double getBlockBoundsMinX() {
+		return this.minX;
+	}
+
+	public final double getBlockBoundsMaxX() {
+		return this.maxX;
+	}
+
+	public final double getBlockBoundsMinY() {
+		return this.minY;
+	}
+
+	public final double getBlockBoundsMaxY() {
+		return this.maxY;
+	}
+
+	public final double getBlockBoundsMinZ() {
+		return this.minZ;
+	}
+
+	public final double getBlockBoundsMaxZ() {
+		return this.maxZ;
+	}
+
+	public int getBlockColor() {
+		return 16777215;
+	}
+
+	public int getRenderColor(int var1) {
+		return 16777215;
+	}
+
+	public int colorMultiplier(IBlockAccess var1, int var2, int var3, int var4) {
+		return 16777215;
+	}
+
+	public int isProvidingWeakPower(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return 0;
+	}
+
+	public boolean canProvidePower() {
+		return false;
+	}
+
+	public void onEntityCollidedWithBlock(World var1, int var2, int var3, int var4, Entity var5) {
+	}
+
+	public int isProvidingStrongPower(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return 0;
+	}
+
+	public void setBlockBoundsForItemRender() {
+	}
+
+	public void harvestBlock(World var1, EntityPlayer var2, int var3, int var4, int var5, int var6) {
+		var2.addStat(StatList.mineBlockStatArray[this.blockID], 1);
+		var2.addExhaustion(0.025F);
+		if(this.canSilkHarvest() && EnchantmentHelper.getSilkTouchModifier(var2)) {
+			ItemStack var8 = this.createStackedBlock(var6);
+			if(var8 != null) {
+				this.dropBlockAsItem_do(var1, var3, var4, var5, var8);
+			}
+		} else {
+			int var7 = EnchantmentHelper.getFortuneModifier(var2);
+			this.dropBlockAsItem(var1, var3, var4, var5, var6, var7);
+		}
+
+	}
+
+	protected boolean canSilkHarvest() {
+		return this.renderAsNormalBlock() && !this.isBlockContainer;
+	}
+
+	protected ItemStack createStackedBlock(int var1) {
+		int var2 = 0;
+		if(this.blockID >= 0 && this.blockID < Item.itemsList.length && Item.itemsList[this.blockID].getHasSubtypes()) {
+			var2 = var1;
+		}
+
+		return new ItemStack(this.blockID, 1, var2);
+	}
+
+	public int quantityDroppedWithBonus(int var1, Random var2) {
+		return this.quantityDropped(var2);
+	}
+
+	public boolean canBlockStay(World var1, int var2, int var3, int var4) {
+		return true;
+	}
+
+	public void onBlockPlacedBy(World var1, int var2, int var3, int var4, EntityLiving var5, ItemStack var6) {
+	}
+
+	public void onPostBlockPlaced(World var1, int var2, int var3, int var4, int var5) {
+	}
+
+	public Block setUnlocalizedName(String var1) {
+		this.unlocalizedName = var1;
+		return this;
+	}
+
+	public String getLocalizedName() {
+		return StatCollector.translateToLocal(this.getUnlocalizedName() + ".name");
+	}
+
+	public String getUnlocalizedName() {
+		return "tile." + this.unlocalizedName;
+	}
+
+	public String getUnlocalizedName2() {
+		return this.unlocalizedName;
+	}
+
+	public boolean onBlockEventReceived(World var1, int var2, int var3, int var4, int var5, int var6) {
+		return false;
+	}
+
+	public boolean getEnableStats() {
+		return this.enableStats;
+	}
+
+	protected Block disableStats() {
+		this.enableStats = false;
+		return this;
+	}
+
+	public int getMobilityFlag() {
+		return this.blockMaterial.getMaterialMobility();
+	}
+
+	public float getAmbientOcclusionLightValue(IBlockAccess var1, int var2, int var3, int var4) {
+		return var1.isBlockNormalCube(var2, var3, var4) ? 0.2F : 1.0F;
+	}
+
+	public void onFallenUpon(World var1, int var2, int var3, int var4, Entity var5, float var6) {
+	}
+
+	public int idPicked(World var1, int var2, int var3, int var4) {
+		return this.blockID;
+	}
+
+	public int getDamageValue(World var1, int var2, int var3, int var4) {
+		return this.damageDropped(var1.getBlockMetadata(var2, var3, var4));
+	}
+
+	public void getSubBlocks(int var1, CreativeTabs var2, List var3) {
+		var3.add(new ItemStack(var1, 1, 0));
+	}
+
+	public CreativeTabs getCreativeTabToDisplayOn() {
+		return this.displayOnCreativeTab;
+	}
+
+	public Block setCreativeTab(CreativeTabs var1) {
+		this.displayOnCreativeTab = var1;
+		return this;
+	}
+
+	public void onBlockHarvested(World var1, int var2, int var3, int var4, int var5, EntityPlayer var6) {
+	}
+
+	public void onSetBlockIDWithMetaData(World var1, int var2, int var3, int var4, int var5) {
+	}
+
+	public void fillWithRain(World var1, int var2, int var3, int var4) {
+	}
+
+	public boolean isFlowerPot() {
+		return false;
+	}
+
+	public boolean func_82506_l() {
+		return true;
+	}
+
+	public boolean canDropFromExplosion(Explosion var1) {
+		return true;
+	}
+
+	public boolean isAssociatedBlockID(int var1) {
+		return this.blockID == var1;
+	}
+
+	public static boolean isAssociatedBlockID(int var0, int var1) {
+		return var0 == var1 ? true : (var0 != 0 && var1 != 0 && blocksList[var0] != null && blocksList[var1] != null ? blocksList[var0].isAssociatedBlockID(var1) : false);
+	}
+
+	public boolean hasComparatorInputOverride() {
+		return false;
+	}
+
+	public int getComparatorInputOverride(World var1, int var2, int var3, int var4, int var5) {
+		return 0;
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.blockIcon = var1.registerIcon(this.unlocalizedName);
+	}
+
+	public String getItemIconName() {
+		return null;
+	}
+
+	static {
+		Item.itemsList[cloth.blockID] = (new ItemCloth(cloth.blockID - 256)).setUnlocalizedName("cloth");
+		Item.itemsList[wood.blockID] = (new ItemMultiTextureTile(wood.blockID - 256, wood, BlockLog.woodType)).setUnlocalizedName("log");
+		Item.itemsList[planks.blockID] = (new ItemMultiTextureTile(planks.blockID - 256, planks, BlockWood.woodType)).setUnlocalizedName("wood");
+		Item.itemsList[silverfish.blockID] = (new ItemMultiTextureTile(silverfish.blockID - 256, silverfish, BlockSilverfish.silverfishStoneTypes)).setUnlocalizedName("monsterStoneEgg");
+		Item.itemsList[stoneBrick.blockID] = (new ItemMultiTextureTile(stoneBrick.blockID - 256, stoneBrick, BlockStoneBrick.STONE_BRICK_TYPES)).setUnlocalizedName("stonebricksmooth");
+		Item.itemsList[sandStone.blockID] = (new ItemMultiTextureTile(sandStone.blockID - 256, sandStone, BlockSandStone.SAND_STONE_TYPES)).setUnlocalizedName("sandStone");
+		Item.itemsList[blockNetherQuartz.blockID] = (new ItemMultiTextureTile(blockNetherQuartz.blockID - 256, blockNetherQuartz, BlockQuartz.quartzBlockTypes)).setUnlocalizedName("quartzBlock");
+		Item.itemsList[stoneSingleSlab.blockID] = (new ItemSlab(stoneSingleSlab.blockID - 256, stoneSingleSlab, stoneDoubleSlab, false)).setUnlocalizedName("stoneSlab");
+		Item.itemsList[stoneDoubleSlab.blockID] = (new ItemSlab(stoneDoubleSlab.blockID - 256, stoneSingleSlab, stoneDoubleSlab, true)).setUnlocalizedName("stoneSlab");
+		Item.itemsList[woodSingleSlab.blockID] = (new ItemSlab(woodSingleSlab.blockID - 256, woodSingleSlab, woodDoubleSlab, false)).setUnlocalizedName("woodSlab");
+		Item.itemsList[woodDoubleSlab.blockID] = (new ItemSlab(woodDoubleSlab.blockID - 256, woodSingleSlab, woodDoubleSlab, true)).setUnlocalizedName("woodSlab");
+		Item.itemsList[sapling.blockID] = (new ItemMultiTextureTile(sapling.blockID - 256, sapling, BlockSapling.WOOD_TYPES)).setUnlocalizedName("sapling");
+		Item.itemsList[leaves.blockID] = (new ItemLeaves(leaves.blockID - 256)).setUnlocalizedName("leaves");
+		Item.itemsList[vine.blockID] = new ItemColored(vine.blockID - 256, false);
+		Item.itemsList[tallGrass.blockID] = (new ItemColored(tallGrass.blockID - 256, true)).setBlockNames(new String[]{"shrub", "grass", "fern"});
+		Item.itemsList[snow.blockID] = new ItemSnow(snow.blockID - 256, snow);
+		Item.itemsList[waterlily.blockID] = new ItemLilyPad(waterlily.blockID - 256);
+		Item.itemsList[pistonBase.blockID] = new ItemPiston(pistonBase.blockID - 256);
+		Item.itemsList[pistonStickyBase.blockID] = new ItemPiston(pistonStickyBase.blockID - 256);
+		Item.itemsList[cobblestoneWall.blockID] = (new ItemMultiTextureTile(cobblestoneWall.blockID - 256, cobblestoneWall, BlockWall.types)).setUnlocalizedName("cobbleWall");
+		Item.itemsList[anvil.blockID] = (new ItemAnvilBlock(anvil)).setUnlocalizedName("anvil");
+
+		for(int var0 = 0; var0 < 256; ++var0) {
+			if(blocksList[var0] != null) {
+				if(Item.itemsList[var0] == null) {
+					Item.itemsList[var0] = new ItemBlock(var0 - 256);
+					blocksList[var0].initializeBlock();
+				}
+
+				boolean var1 = false;
+				if(var0 > 0 && blocksList[var0].getRenderType() == 10) {
+					var1 = true;
+				}
+
+				if(var0 > 0 && blocksList[var0] instanceof BlockHalfSlab) {
+					var1 = true;
+				}
+
+				if(var0 == tilledField.blockID) {
+					var1 = true;
+				}
+
+				if(canBlockGrass[var0]) {
+					var1 = true;
+				}
+
+				if(lightOpacity[var0] == 0) {
+					var1 = true;
+				}
+
+				useNeighborBrightness[var0] = var1;
+			}
+		}
+
+		canBlockGrass[0] = true;
+		StatList.initBreakableStats();
+	}
+}

src/net/minecraft/src/BlockAnvil.java

@@ -0,0 +1,111 @@
+package net.minecraft.src;
+
+import java.util.List;
+
+public class BlockAnvil extends BlockSand {
+	public static final String[] statuses = new String[]{"intact", "slightlyDamaged", "veryDamaged"};
+	private static final String[] anvilIconNames = new String[]{"anvil_top", "anvil_top_damaged_1", "anvil_top_damaged_2"};
+	public int field_82521_b = 0;
+	private Icon[] iconArray;
+
+	protected BlockAnvil(int var1) {
+		super(var1, Material.anvil);
+		this.setLightOpacity(0);
+		this.setCreativeTab(CreativeTabs.tabDecorations);
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		if(this.field_82521_b == 3 && var1 == 1) {
+			int var3 = (var2 >> 2) % this.iconArray.length;
+			return this.iconArray[var3];
+		} else {
+			return this.blockIcon;
+		}
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.blockIcon = var1.registerIcon("anvil_base");
+		this.iconArray = new Icon[anvilIconNames.length];
+
+		for(int var2 = 0; var2 < this.iconArray.length; ++var2) {
+			this.iconArray[var2] = var1.registerIcon(anvilIconNames[var2]);
+		}
+
+	}
+
+	public void onBlockPlacedBy(World var1, int var2, int var3, int var4, EntityLiving var5, ItemStack var6) {
+		int var7 = MathHelper.floor_double((double)(var5.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;
+		int var8 = var1.getBlockMetadata(var2, var3, var4) >> 2;
+		++var7;
+		var7 %= 4;
+		if(var7 == 0) {
+			var1.setBlockMetadataWithNotify(var2, var3, var4, 2 | var8 << 2, 2);
+		}
+
+		if(var7 == 1) {
+			var1.setBlockMetadataWithNotify(var2, var3, var4, 3 | var8 << 2, 2);
+		}
+
+		if(var7 == 2) {
+			var1.setBlockMetadataWithNotify(var2, var3, var4, 0 | var8 << 2, 2);
+		}
+
+		if(var7 == 3) {
+			var1.setBlockMetadataWithNotify(var2, var3, var4, 1 | var8 << 2, 2);
+		}
+
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		if(var1.isRemote) {
+			return true;
+		} else {
+			var5.displayGUIAnvil(var2, var3, var4);
+			return true;
+		}
+	}
+
+	public int getRenderType() {
+		return 35;
+	}
+
+	public int damageDropped(int var1) {
+		return var1 >> 2;
+	}
+
+	public void setBlockBoundsBasedOnState(IBlockAccess var1, int var2, int var3, int var4) {
+		int var5 = var1.getBlockMetadata(var2, var3, var4) & 3;
+		if(var5 != 3 && var5 != 1) {
+			this.setBlockBounds(2.0F / 16.0F, 0.0F, 0.0F, 14.0F / 16.0F, 1.0F, 1.0F);
+		} else {
+			this.setBlockBounds(0.0F, 0.0F, 2.0F / 16.0F, 1.0F, 1.0F, 14.0F / 16.0F);
+		}
+
+	}
+
+	public void getSubBlocks(int var1, CreativeTabs var2, List var3) {
+		var3.add(new ItemStack(var1, 1, 0));
+		var3.add(new ItemStack(var1, 1, 1));
+		var3.add(new ItemStack(var1, 1, 2));
+	}
+
+	protected void onStartFalling(EntityFallingSand var1) {
+		var1.setIsAnvil(true);
+	}
+
+	public void onFinishFalling(World var1, int var2, int var3, int var4, int var5) {
+		var1.playAuxSFX(1022, var2, var3, var4, 0);
+	}
+
+	public boolean shouldSideBeRendered(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return true;
+	}
+}

src/net/minecraft/src/BlockBasePressurePlate.java

@@ -0,0 +1,160 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public abstract class BlockBasePressurePlate extends Block {
+	private String pressurePlateIconName;
+
+	protected BlockBasePressurePlate(int var1, String var2, Material var3) {
+		super(var1, var3);
+		this.pressurePlateIconName = var2;
+		this.setCreativeTab(CreativeTabs.tabRedstone);
+		this.setTickRandomly(true);
+		this.func_94353_c_(this.getMetaFromWeight(15));
+	}
+
+	public void setBlockBoundsBasedOnState(IBlockAccess var1, int var2, int var3, int var4) {
+		this.func_94353_c_(var1.getBlockMetadata(var2, var3, var4));
+	}
+
+	protected void func_94353_c_(int var1) {
+		boolean var2 = this.getPowerSupply(var1) > 0;
+		float var3 = 1.0F / 16.0F;
+		if(var2) {
+			this.setBlockBounds(var3, 0.0F, var3, 1.0F - var3, 0.03125F, 1.0F - var3);
+		} else {
+			this.setBlockBounds(var3, 0.0F, var3, 1.0F - var3, 1.0F / 16.0F, 1.0F - var3);
+		}
+
+	}
+
+	public int tickRate(World var1) {
+		return 20;
+	}
+
+	public AxisAlignedBB getCollisionBoundingBoxFromPool(World var1, int var2, int var3, int var4) {
+		return null;
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public boolean getBlocksMovement(IBlockAccess var1, int var2, int var3, int var4) {
+		return true;
+	}
+
+	public boolean canPlaceBlockAt(World var1, int var2, int var3, int var4) {
+		return var1.doesBlockHaveSolidTopSurface(var2, var3 - 1, var4) || BlockFence.isIdAFence(var1.getBlockId(var2, var3 - 1, var4));
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+		boolean var6 = false;
+		if(!var1.doesBlockHaveSolidTopSurface(var2, var3 - 1, var4) && !BlockFence.isIdAFence(var1.getBlockId(var2, var3 - 1, var4))) {
+			var6 = true;
+		}
+
+		if(var6) {
+			this.dropBlockAsItem(var1, var2, var3, var4, var1.getBlockMetadata(var2, var3, var4), 0);
+			var1.setBlockToAir(var2, var3, var4);
+		}
+
+	}
+
+	public void updateTick(World var1, int var2, int var3, int var4, Random var5) {
+		if(!var1.isRemote) {
+			int var6 = this.getPowerSupply(var1.getBlockMetadata(var2, var3, var4));
+			if(var6 > 0) {
+				this.setStateIfMobInteractsWithPlate(var1, var2, var3, var4, var6);
+			}
+
+		}
+	}
+
+	public void onEntityCollidedWithBlock(World var1, int var2, int var3, int var4, Entity var5) {
+		if(!var1.isRemote) {
+			int var6 = this.getPowerSupply(var1.getBlockMetadata(var2, var3, var4));
+			if(var6 == 0) {
+				this.setStateIfMobInteractsWithPlate(var1, var2, var3, var4, var6);
+			}
+
+		}
+	}
+
+	protected void setStateIfMobInteractsWithPlate(World var1, int var2, int var3, int var4, int var5) {
+		int var6 = this.getPlateState(var1, var2, var3, var4);
+		boolean var7 = var5 > 0;
+		boolean var8 = var6 > 0;
+		if(var5 != var6) {
+			var1.setBlockMetadataWithNotify(var2, var3, var4, this.getMetaFromWeight(var6), 2);
+			this.func_94354_b_(var1, var2, var3, var4);
+			var1.markBlockRangeForRenderUpdate(var2, var3, var4, var2, var3, var4);
+		}
+
+		if(!var8 && var7) {
+			var1.playSoundEffect((double)var2 + 0.5D, (double)var3 + 0.1D, (double)var4 + 0.5D, "random.click", 0.3F, 0.5F);
+		} else if(var8 && !var7) {
+			var1.playSoundEffect((double)var2 + 0.5D, (double)var3 + 0.1D, (double)var4 + 0.5D, "random.click", 0.3F, 0.6F);
+		}
+
+		if(var8) {
+			var1.scheduleBlockUpdate(var2, var3, var4, this.blockID, this.tickRate(var1));
+		}
+
+	}
+
+	protected AxisAlignedBB getSensitiveAABB(int var1, int var2, int var3) {
+		float var4 = 2.0F / 16.0F;
+		return AxisAlignedBB.getAABBPool().getAABB((double)((float)var1 + var4), (double)var2, (double)((float)var3 + var4), (double)((float)(var1 + 1) - var4), (double)var2 + 0.25D, (double)((float)(var3 + 1) - var4));
+	}
+
+	public void breakBlock(World var1, int var2, int var3, int var4, int var5, int var6) {
+		if(this.getPowerSupply(var6) > 0) {
+			this.func_94354_b_(var1, var2, var3, var4);
+		}
+
+		super.breakBlock(var1, var2, var3, var4, var5, var6);
+	}
+
+	protected void func_94354_b_(World var1, int var2, int var3, int var4) {
+		var1.notifyBlocksOfNeighborChange(var2, var3, var4, this.blockID);
+		var1.notifyBlocksOfNeighborChange(var2, var3 - 1, var4, this.blockID);
+	}
+
+	public int isProvidingWeakPower(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return this.getPowerSupply(var1.getBlockMetadata(var2, var3, var4));
+	}
+
+	public int isProvidingStrongPower(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return var5 == 1 ? this.getPowerSupply(var1.getBlockMetadata(var2, var3, var4)) : 0;
+	}
+
+	public boolean canProvidePower() {
+		return true;
+	}
+
+	public void setBlockBoundsForItemRender() {
+		float var1 = 0.5F;
+		float var2 = 2.0F / 16.0F;
+		float var3 = 0.5F;
+		this.setBlockBounds(0.5F - var1, 0.5F - var2, 0.5F - var3, 0.5F + var1, 0.5F + var2, 0.5F + var3);
+	}
+
+	public int getMobilityFlag() {
+		return 1;
+	}
+
+	protected abstract int getPlateState(World var1, int var2, int var3, int var4);
+
+	protected abstract int getPowerSupply(int var1);
+
+	protected abstract int getMetaFromWeight(int var1);
+
+	public void registerIcons(IconRegister var1) {
+		this.blockIcon = var1.registerIcon(this.pressurePlateIconName);
+	}
+}

src/net/minecraft/src/BlockBaseRailLogic.java

@@ -0,0 +1,335 @@
+package net.minecraft.src;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class BlockBaseRailLogic {
+	private World logicWorld;
+	private int railX;
+	private int railY;
+	private int railZ;
+	private final boolean isStraightRail;
+	private List railChunkPosition;
+	final BlockRailBase theRail;
+
+	public BlockBaseRailLogic(BlockRailBase var1, World var2, int var3, int var4, int var5) {
+		this.theRail = var1;
+		this.railChunkPosition = new ArrayList();
+		this.logicWorld = var2;
+		this.railX = var3;
+		this.railY = var4;
+		this.railZ = var5;
+		int var6 = var2.getBlockId(var3, var4, var5);
+		int var7 = var2.getBlockMetadata(var3, var4, var5);
+		if(((BlockRailBase)Block.blocksList[var6]).isPowered) {
+			this.isStraightRail = true;
+			var7 &= -9;
+		} else {
+			this.isStraightRail = false;
+		}
+
+		this.setBasicRail(var7);
+	}
+
+	private void setBasicRail(int var1) {
+		this.railChunkPosition.clear();
+		if(var1 == 0) {
+			this.railChunkPosition.add(new ChunkPosition(this.railX, this.railY, this.railZ - 1));
+			this.railChunkPosition.add(new ChunkPosition(this.railX, this.railY, this.railZ + 1));
+		} else if(var1 == 1) {
+			this.railChunkPosition.add(new ChunkPosition(this.railX - 1, this.railY, this.railZ));
+			this.railChunkPosition.add(new ChunkPosition(this.railX + 1, this.railY, this.railZ));
+		} else if(var1 == 2) {
+			this.railChunkPosition.add(new ChunkPosition(this.railX - 1, this.railY, this.railZ));
+			this.railChunkPosition.add(new ChunkPosition(this.railX + 1, this.railY + 1, this.railZ));
+		} else if(var1 == 3) {
+			this.railChunkPosition.add(new ChunkPosition(this.railX - 1, this.railY + 1, this.railZ));
+			this.railChunkPosition.add(new ChunkPosition(this.railX + 1, this.railY, this.railZ));
+		} else if(var1 == 4) {
+			this.railChunkPosition.add(new ChunkPosition(this.railX, this.railY + 1, this.railZ - 1));
+			this.railChunkPosition.add(new ChunkPosition(this.railX, this.railY, this.railZ + 1));
+		} else if(var1 == 5) {
+			this.railChunkPosition.add(new ChunkPosition(this.railX, this.railY, this.railZ - 1));
+			this.railChunkPosition.add(new ChunkPosition(this.railX, this.railY + 1, this.railZ + 1));
+		} else if(var1 == 6) {
+			this.railChunkPosition.add(new ChunkPosition(this.railX + 1, this.railY, this.railZ));
+			this.railChunkPosition.add(new ChunkPosition(this.railX, this.railY, this.railZ + 1));
+		} else if(var1 == 7) {
+			this.railChunkPosition.add(new ChunkPosition(this.railX - 1, this.railY, this.railZ));
+			this.railChunkPosition.add(new ChunkPosition(this.railX, this.railY, this.railZ + 1));
+		} else if(var1 == 8) {
+			this.railChunkPosition.add(new ChunkPosition(this.railX - 1, this.railY, this.railZ));
+			this.railChunkPosition.add(new ChunkPosition(this.railX, this.railY, this.railZ - 1));
+		} else if(var1 == 9) {
+			this.railChunkPosition.add(new ChunkPosition(this.railX + 1, this.railY, this.railZ));
+			this.railChunkPosition.add(new ChunkPosition(this.railX, this.railY, this.railZ - 1));
+		}
+
+	}
+
+	private void refreshConnectedTracks() {
+		for(int var1 = 0; var1 < this.railChunkPosition.size(); ++var1) {
+			BlockBaseRailLogic var2 = this.getRailLogic((ChunkPosition)this.railChunkPosition.get(var1));
+			if(var2 != null && var2.isRailChunkPositionCorrect(this)) {
+				this.railChunkPosition.set(var1, new ChunkPosition(var2.railX, var2.railY, var2.railZ));
+			} else {
+				this.railChunkPosition.remove(var1--);
+			}
+		}
+
+	}
+
+	private boolean isMinecartTrack(int var1, int var2, int var3) {
+		return BlockRailBase.isRailBlockAt(this.logicWorld, var1, var2, var3) ? true : (BlockRailBase.isRailBlockAt(this.logicWorld, var1, var2 + 1, var3) ? true : BlockRailBase.isRailBlockAt(this.logicWorld, var1, var2 - 1, var3));
+	}
+
+	private BlockBaseRailLogic getRailLogic(ChunkPosition var1) {
+		return BlockRailBase.isRailBlockAt(this.logicWorld, var1.x, var1.y, var1.z) ? new BlockBaseRailLogic(this.theRail, this.logicWorld, var1.x, var1.y, var1.z) : (BlockRailBase.isRailBlockAt(this.logicWorld, var1.x, var1.y + 1, var1.z) ? new BlockBaseRailLogic(this.theRail, this.logicWorld, var1.x, var1.y + 1, var1.z) : (BlockRailBase.isRailBlockAt(this.logicWorld, var1.x, var1.y - 1, var1.z) ? new BlockBaseRailLogic(this.theRail, this.logicWorld, var1.x, var1.y - 1, var1.z) : null));
+	}
+
+	private boolean isRailChunkPositionCorrect(BlockBaseRailLogic var1) {
+		for(int var2 = 0; var2 < this.railChunkPosition.size(); ++var2) {
+			ChunkPosition var3 = (ChunkPosition)this.railChunkPosition.get(var2);
+			if(var3.x == var1.railX && var3.z == var1.railZ) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	private boolean isPartOfTrack(int var1, int var2, int var3) {
+		for(int var4 = 0; var4 < this.railChunkPosition.size(); ++var4) {
+			ChunkPosition var5 = (ChunkPosition)this.railChunkPosition.get(var4);
+			if(var5.x == var1 && var5.z == var3) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	protected int getNumberOfAdjacentTracks() {
+		int var1 = 0;
+		if(this.isMinecartTrack(this.railX, this.railY, this.railZ - 1)) {
+			++var1;
+		}
+
+		if(this.isMinecartTrack(this.railX, this.railY, this.railZ + 1)) {
+			++var1;
+		}
+
+		if(this.isMinecartTrack(this.railX - 1, this.railY, this.railZ)) {
+			++var1;
+		}
+
+		if(this.isMinecartTrack(this.railX + 1, this.railY, this.railZ)) {
+			++var1;
+		}
+
+		return var1;
+	}
+
+	private boolean canConnectTo(BlockBaseRailLogic var1) {
+		return this.isRailChunkPositionCorrect(var1) ? true : (this.railChunkPosition.size() == 2 ? false : (this.railChunkPosition.isEmpty() ? true : true));
+	}
+
+	private void connectToNeighbor(BlockBaseRailLogic var1) {
+		this.railChunkPosition.add(new ChunkPosition(var1.railX, var1.railY, var1.railZ));
+		boolean var2 = this.isPartOfTrack(this.railX, this.railY, this.railZ - 1);
+		boolean var3 = this.isPartOfTrack(this.railX, this.railY, this.railZ + 1);
+		boolean var4 = this.isPartOfTrack(this.railX - 1, this.railY, this.railZ);
+		boolean var5 = this.isPartOfTrack(this.railX + 1, this.railY, this.railZ);
+		byte var6 = -1;
+		if(var2 || var3) {
+			var6 = 0;
+		}
+
+		if(var4 || var5) {
+			var6 = 1;
+		}
+
+		if(!this.isStraightRail) {
+			if(var3 && var5 && !var2 && !var4) {
+				var6 = 6;
+			}
+
+			if(var3 && var4 && !var2 && !var5) {
+				var6 = 7;
+			}
+
+			if(var2 && var4 && !var3 && !var5) {
+				var6 = 8;
+			}
+
+			if(var2 && var5 && !var3 && !var4) {
+				var6 = 9;
+			}
+		}
+
+		if(var6 == 0) {
+			if(BlockRailBase.isRailBlockAt(this.logicWorld, this.railX, this.railY + 1, this.railZ - 1)) {
+				var6 = 4;
+			}
+
+			if(BlockRailBase.isRailBlockAt(this.logicWorld, this.railX, this.railY + 1, this.railZ + 1)) {
+				var6 = 5;
+			}
+		}
+
+		if(var6 == 1) {
+			if(BlockRailBase.isRailBlockAt(this.logicWorld, this.railX + 1, this.railY + 1, this.railZ)) {
+				var6 = 2;
+			}
+
+			if(BlockRailBase.isRailBlockAt(this.logicWorld, this.railX - 1, this.railY + 1, this.railZ)) {
+				var6 = 3;
+			}
+		}
+
+		if(var6 < 0) {
+			var6 = 0;
+		}
+
+		int var7 = var6;
+		if(this.isStraightRail) {
+			var7 = this.logicWorld.getBlockMetadata(this.railX, this.railY, this.railZ) & 8 | var6;
+		}
+
+		this.logicWorld.setBlockMetadataWithNotify(this.railX, this.railY, this.railZ, var7, 3);
+	}
+
+	private boolean canConnectFrom(int var1, int var2, int var3) {
+		BlockBaseRailLogic var4 = this.getRailLogic(new ChunkPosition(var1, var2, var3));
+		if(var4 == null) {
+			return false;
+		} else {
+			var4.refreshConnectedTracks();
+			return var4.canConnectTo(this);
+		}
+	}
+
+	public void func_94511_a(boolean var1, boolean var2) {
+		boolean var3 = this.canConnectFrom(this.railX, this.railY, this.railZ - 1);
+		boolean var4 = this.canConnectFrom(this.railX, this.railY, this.railZ + 1);
+		boolean var5 = this.canConnectFrom(this.railX - 1, this.railY, this.railZ);
+		boolean var6 = this.canConnectFrom(this.railX + 1, this.railY, this.railZ);
+		byte var7 = -1;
+		if((var3 || var4) && !var5 && !var6) {
+			var7 = 0;
+		}
+
+		if((var5 || var6) && !var3 && !var4) {
+			var7 = 1;
+		}
+
+		if(!this.isStraightRail) {
+			if(var4 && var6 && !var3 && !var5) {
+				var7 = 6;
+			}
+
+			if(var4 && var5 && !var3 && !var6) {
+				var7 = 7;
+			}
+
+			if(var3 && var5 && !var4 && !var6) {
+				var7 = 8;
+			}
+
+			if(var3 && var6 && !var4 && !var5) {
+				var7 = 9;
+			}
+		}
+
+		if(var7 == -1) {
+			if(var3 || var4) {
+				var7 = 0;
+			}
+
+			if(var5 || var6) {
+				var7 = 1;
+			}
+
+			if(!this.isStraightRail) {
+				if(var1) {
+					if(var4 && var6) {
+						var7 = 6;
+					}
+
+					if(var5 && var4) {
+						var7 = 7;
+					}
+
+					if(var6 && var3) {
+						var7 = 9;
+					}
+
+					if(var3 && var5) {
+						var7 = 8;
+					}
+				} else {
+					if(var3 && var5) {
+						var7 = 8;
+					}
+
+					if(var6 && var3) {
+						var7 = 9;
+					}
+
+					if(var5 && var4) {
+						var7 = 7;
+					}
+
+					if(var4 && var6) {
+						var7 = 6;
+					}
+				}
+			}
+		}
+
+		if(var7 == 0) {
+			if(BlockRailBase.isRailBlockAt(this.logicWorld, this.railX, this.railY + 1, this.railZ - 1)) {
+				var7 = 4;
+			}
+
+			if(BlockRailBase.isRailBlockAt(this.logicWorld, this.railX, this.railY + 1, this.railZ + 1)) {
+				var7 = 5;
+			}
+		}
+
+		if(var7 == 1) {
+			if(BlockRailBase.isRailBlockAt(this.logicWorld, this.railX + 1, this.railY + 1, this.railZ)) {
+				var7 = 2;
+			}
+
+			if(BlockRailBase.isRailBlockAt(this.logicWorld, this.railX - 1, this.railY + 1, this.railZ)) {
+				var7 = 3;
+			}
+		}
+
+		if(var7 < 0) {
+			var7 = 0;
+		}
+
+		this.setBasicRail(var7);
+		int var8 = var7;
+		if(this.isStraightRail) {
+			var8 = this.logicWorld.getBlockMetadata(this.railX, this.railY, this.railZ) & 8 | var7;
+		}
+
+		if(var2 || this.logicWorld.getBlockMetadata(this.railX, this.railY, this.railZ) != var8) {
+			this.logicWorld.setBlockMetadataWithNotify(this.railX, this.railY, this.railZ, var8, 3);
+
+			for(int var9 = 0; var9 < this.railChunkPosition.size(); ++var9) {
+				BlockBaseRailLogic var10 = this.getRailLogic((ChunkPosition)this.railChunkPosition.get(var9));
+				if(var10 != null) {
+					var10.refreshConnectedTracks();
+					if(var10.canConnectTo(this)) {
+						var10.connectToNeighbor(this);
+					}
+				}
+			}
+		}
+
+	}
+}

src/net/minecraft/src/BlockBeacon.java

@@ -0,0 +1,57 @@
+package net.minecraft.src;
+
+public class BlockBeacon extends BlockContainer {
+	private Icon theIcon;
+
+	public BlockBeacon(int var1) {
+		super(var1, Material.glass);
+		this.setHardness(3.0F);
+		this.setCreativeTab(CreativeTabs.tabMisc);
+	}
+
+	public TileEntity createNewTileEntity(World var1) {
+		return new TileEntityBeacon();
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		if(var1.isRemote) {
+			return true;
+		} else {
+			TileEntityBeacon var10 = (TileEntityBeacon)var1.getBlockTileEntity(var2, var3, var4);
+			if(var10 != null) {
+				var5.displayGUIBeacon(var10);
+			}
+
+			return true;
+		}
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public int getRenderType() {
+		return 34;
+	}
+
+	public void registerIcons(IconRegister var1) {
+		super.registerIcons(var1);
+		this.theIcon = var1.registerIcon("beacon");
+	}
+
+	public Icon getBeaconIcon() {
+		return this.theIcon;
+	}
+
+	public void onBlockPlacedBy(World var1, int var2, int var3, int var4, EntityLiving var5, ItemStack var6) {
+		super.onBlockPlacedBy(var1, var2, var3, var4, var5, var6);
+		if(var6.hasDisplayName()) {
+			((TileEntityBeacon)var1.getBlockTileEntity(var2, var3, var4)).func_94047_a(var6.getDisplayName());
+		}
+
+	}
+}

src/net/minecraft/src/BlockBed.java

@@ -0,0 +1,218 @@
+package net.minecraft.src;
+
+import java.util.Iterator;
+import java.util.Random;
+
+public class BlockBed extends BlockDirectional {
+	public static final int[][] footBlockToHeadBlockMap = new int[][]{{0, 1}, {-1, 0}, {0, -1}, {1, 0}};
+	private Icon[] field_94472_b;
+	private Icon[] bedSideIcons;
+	private Icon[] bedTopIcons;
+
+	public BlockBed(int var1) {
+		super(var1, Material.cloth);
+		this.setBounds();
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		if(var1.isRemote) {
+			return true;
+		} else {
+			int var10 = var1.getBlockMetadata(var2, var3, var4);
+			if(!isBlockHeadOfBed(var10)) {
+				int var11 = getDirection(var10);
+				var2 += footBlockToHeadBlockMap[var11][0];
+				var4 += footBlockToHeadBlockMap[var11][1];
+				if(var1.getBlockId(var2, var3, var4) != this.blockID) {
+					return true;
+				}
+
+				var10 = var1.getBlockMetadata(var2, var3, var4);
+			}
+
+			if(var1.provider.canRespawnHere() && var1.getBiomeGenForCoords(var2, var4) != BiomeGenBase.hell) {
+				if(isBedOccupied(var10)) {
+					EntityPlayer var19 = null;
+					Iterator var12 = var1.playerEntities.iterator();
+
+					while(var12.hasNext()) {
+						EntityPlayer var21 = (EntityPlayer)var12.next();
+						if(var21.isPlayerSleeping()) {
+							ChunkCoordinates var14 = var21.playerLocation;
+							if(var14.posX == var2 && var14.posY == var3 && var14.posZ == var4) {
+								var19 = var21;
+							}
+						}
+					}
+
+					if(var19 != null) {
+						var5.addChatMessage("tile.bed.occupied");
+						return true;
+					}
+
+					setBedOccupied(var1, var2, var3, var4, false);
+				}
+
+				EnumStatus var20 = var5.sleepInBedAt(var2, var3, var4);
+				if(var20 == EnumStatus.OK) {
+					setBedOccupied(var1, var2, var3, var4, true);
+					return true;
+				} else {
+					if(var20 == EnumStatus.NOT_POSSIBLE_NOW) {
+						var5.addChatMessage("tile.bed.noSleep");
+					} else if(var20 == EnumStatus.NOT_SAFE) {
+						var5.addChatMessage("tile.bed.notSafe");
+					}
+
+					return true;
+				}
+			} else {
+				double var18 = (double)var2 + 0.5D;
+				double var13 = (double)var3 + 0.5D;
+				double var15 = (double)var4 + 0.5D;
+				var1.setBlockToAir(var2, var3, var4);
+				int var17 = getDirection(var10);
+				var2 += footBlockToHeadBlockMap[var17][0];
+				var4 += footBlockToHeadBlockMap[var17][1];
+				if(var1.getBlockId(var2, var3, var4) == this.blockID) {
+					var1.setBlockToAir(var2, var3, var4);
+					var18 = (var18 + (double)var2 + 0.5D) / 2.0D;
+					var13 = (var13 + (double)var3 + 0.5D) / 2.0D;
+					var15 = (var15 + (double)var4 + 0.5D) / 2.0D;
+				}
+
+				var1.newExplosion((Entity)null, (double)((float)var2 + 0.5F), (double)((float)var3 + 0.5F), (double)((float)var4 + 0.5F), 5.0F, true, true);
+				return true;
+			}
+		}
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		if(var1 == 0) {
+			return Block.planks.getBlockTextureFromSide(var1);
+		} else {
+			int var3 = getDirection(var2);
+			int var4 = Direction.bedDirection[var3][var1];
+			int var5 = isBlockHeadOfBed(var2) ? 1 : 0;
+			return (var5 != 1 || var4 != 2) && (var5 != 0 || var4 != 3) ? (var4 != 5 && var4 != 4 ? this.bedTopIcons[var5] : this.bedSideIcons[var5]) : this.field_94472_b[var5];
+		}
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.bedTopIcons = new Icon[]{var1.registerIcon("bed_feet_top"), var1.registerIcon("bed_head_top")};
+		this.field_94472_b = new Icon[]{var1.registerIcon("bed_feet_end"), var1.registerIcon("bed_head_end")};
+		this.bedSideIcons = new Icon[]{var1.registerIcon("bed_feet_side"), var1.registerIcon("bed_head_side")};
+	}
+
+	public int getRenderType() {
+		return 14;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public void setBlockBoundsBasedOnState(IBlockAccess var1, int var2, int var3, int var4) {
+		this.setBounds();
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+		int var6 = var1.getBlockMetadata(var2, var3, var4);
+		int var7 = getDirection(var6);
+		if(isBlockHeadOfBed(var6)) {
+			if(var1.getBlockId(var2 - footBlockToHeadBlockMap[var7][0], var3, var4 - footBlockToHeadBlockMap[var7][1]) != this.blockID) {
+				var1.setBlockToAir(var2, var3, var4);
+			}
+		} else if(var1.getBlockId(var2 + footBlockToHeadBlockMap[var7][0], var3, var4 + footBlockToHeadBlockMap[var7][1]) != this.blockID) {
+			var1.setBlockToAir(var2, var3, var4);
+			if(!var1.isRemote) {
+				this.dropBlockAsItem(var1, var2, var3, var4, var6, 0);
+			}
+		}
+
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		return isBlockHeadOfBed(var1) ? 0 : Item.bed.itemID;
+	}
+
+	private void setBounds() {
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 9.0F / 16.0F, 1.0F);
+	}
+
+	public static boolean isBlockHeadOfBed(int var0) {
+		return (var0 & 8) != 0;
+	}
+
+	public static boolean isBedOccupied(int var0) {
+		return (var0 & 4) != 0;
+	}
+
+	public static void setBedOccupied(World var0, int var1, int var2, int var3, boolean var4) {
+		int var5 = var0.getBlockMetadata(var1, var2, var3);
+		if(var4) {
+			var5 |= 4;
+		} else {
+			var5 &= -5;
+		}
+
+		var0.setBlockMetadataWithNotify(var1, var2, var3, var5, 4);
+	}
+
+	public static ChunkCoordinates getNearestEmptyChunkCoordinates(World var0, int var1, int var2, int var3, int var4) {
+		int var5 = var0.getBlockMetadata(var1, var2, var3);
+		int var6 = BlockDirectional.getDirection(var5);
+
+		for(int var7 = 0; var7 <= 1; ++var7) {
+			int var8 = var1 - footBlockToHeadBlockMap[var6][0] * var7 - 1;
+			int var9 = var3 - footBlockToHeadBlockMap[var6][1] * var7 - 1;
+			int var10 = var8 + 2;
+			int var11 = var9 + 2;
+
+			for(int var12 = var8; var12 <= var10; ++var12) {
+				for(int var13 = var9; var13 <= var11; ++var13) {
+					if(var0.doesBlockHaveSolidTopSurface(var12, var2 - 1, var13) && var0.isAirBlock(var12, var2, var13) && var0.isAirBlock(var12, var2 + 1, var13)) {
+						if(var4 <= 0) {
+							return new ChunkCoordinates(var12, var2, var13);
+						}
+
+						--var4;
+					}
+				}
+			}
+		}
+
+		return null;
+	}
+
+	public void dropBlockAsItemWithChance(World var1, int var2, int var3, int var4, int var5, float var6, int var7) {
+		if(!isBlockHeadOfBed(var5)) {
+			super.dropBlockAsItemWithChance(var1, var2, var3, var4, var5, var6, 0);
+		}
+
+	}
+
+	public int getMobilityFlag() {
+		return 1;
+	}
+
+	public int idPicked(World var1, int var2, int var3, int var4) {
+		return Item.bed.itemID;
+	}
+
+	public void onBlockHarvested(World var1, int var2, int var3, int var4, int var5, EntityPlayer var6) {
+		if(var6.capabilities.isCreativeMode && isBlockHeadOfBed(var5)) {
+			int var7 = getDirection(var5);
+			var2 -= footBlockToHeadBlockMap[var7][0];
+			var4 -= footBlockToHeadBlockMap[var7][1];
+			if(var1.getBlockId(var2, var3, var4) == this.blockID) {
+				var1.setBlockToAir(var2, var3, var4);
+			}
+		}
+
+	}
+}

src/net/minecraft/src/BlockBookshelf.java

@@ -0,0 +1,22 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockBookshelf extends Block {
+	public BlockBookshelf(int var1) {
+		super(var1, Material.wood);
+		this.setCreativeTab(CreativeTabs.tabBlock);
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return var1 != 1 && var1 != 0 ? super.getIcon(var1, var2) : Block.planks.getBlockTextureFromSide(var1);
+	}
+
+	public int quantityDropped(Random var1) {
+		return 3;
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		return Item.book.itemID;
+	}
+}

src/net/minecraft/src/BlockBreakable.java

@@ -0,0 +1,25 @@
+package net.minecraft.src;
+
+public class BlockBreakable extends Block {
+	private boolean localFlag;
+	private String breakableBlockIcon;
+
+	protected BlockBreakable(int var1, String var2, Material var3, boolean var4) {
+		super(var1, var3);
+		this.localFlag = var4;
+		this.breakableBlockIcon = var2;
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean shouldSideBeRendered(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		int var6 = var1.getBlockId(var2, var3, var4);
+		return !this.localFlag && var6 == this.blockID ? false : super.shouldSideBeRendered(var1, var2, var3, var4, var5);
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.blockIcon = var1.registerIcon(this.breakableBlockIcon);
+	}
+}

src/net/minecraft/src/BlockBrewingStand.java

@@ -0,0 +1,125 @@
+package net.minecraft.src;
+
+import java.util.List;
+import java.util.Random;
+
+public class BlockBrewingStand extends BlockContainer {
+	private Random rand = new Random();
+	private Icon theIcon;
+
+	public BlockBrewingStand(int var1) {
+		super(var1, Material.iron);
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public int getRenderType() {
+		return 25;
+	}
+
+	public TileEntity createNewTileEntity(World var1) {
+		return new TileEntityBrewingStand();
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public void addCollisionBoxesToList(World var1, int var2, int var3, int var4, AxisAlignedBB var5, List var6, Entity var7) {
+		this.setBlockBounds(7.0F / 16.0F, 0.0F, 7.0F / 16.0F, 9.0F / 16.0F, 14.0F / 16.0F, 9.0F / 16.0F);
+		super.addCollisionBoxesToList(var1, var2, var3, var4, var5, var6, var7);
+		this.setBlockBoundsForItemRender();
+		super.addCollisionBoxesToList(var1, var2, var3, var4, var5, var6, var7);
+	}
+
+	public void setBlockBoundsForItemRender() {
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 2.0F / 16.0F, 1.0F);
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		if(var1.isRemote) {
+			return true;
+		} else {
+			TileEntityBrewingStand var10 = (TileEntityBrewingStand)var1.getBlockTileEntity(var2, var3, var4);
+			if(var10 != null) {
+				var5.displayGUIBrewingStand(var10);
+			}
+
+			return true;
+		}
+	}
+
+	public void onBlockPlacedBy(World var1, int var2, int var3, int var4, EntityLiving var5, ItemStack var6) {
+		if(var6.hasDisplayName()) {
+			((TileEntityBrewingStand)var1.getBlockTileEntity(var2, var3, var4)).func_94131_a(var6.getDisplayName());
+		}
+
+	}
+
+	public void randomDisplayTick(World var1, int var2, int var3, int var4, Random var5) {
+		double var6 = (double)((float)var2 + 0.4F + var5.nextFloat() * 0.2F);
+		double var8 = (double)((float)var3 + 0.7F + var5.nextFloat() * 0.3F);
+		double var10 = (double)((float)var4 + 0.4F + var5.nextFloat() * 0.2F);
+		var1.spawnParticle("smoke", var6, var8, var10, 0.0D, 0.0D, 0.0D);
+	}
+
+	public void breakBlock(World var1, int var2, int var3, int var4, int var5, int var6) {
+		TileEntity var7 = var1.getBlockTileEntity(var2, var3, var4);
+		if(var7 instanceof TileEntityBrewingStand) {
+			TileEntityBrewingStand var8 = (TileEntityBrewingStand)var7;
+
+			for(int var9 = 0; var9 < var8.getSizeInventory(); ++var9) {
+				ItemStack var10 = var8.getStackInSlot(var9);
+				if(var10 != null) {
+					float var11 = this.rand.nextFloat() * 0.8F + 0.1F;
+					float var12 = this.rand.nextFloat() * 0.8F + 0.1F;
+					float var13 = this.rand.nextFloat() * 0.8F + 0.1F;
+
+					while(var10.stackSize > 0) {
+						int var14 = this.rand.nextInt(21) + 10;
+						if(var14 > var10.stackSize) {
+							var14 = var10.stackSize;
+						}
+
+						var10.stackSize -= var14;
+						EntityItem var15 = new EntityItem(var1, (double)((float)var2 + var11), (double)((float)var3 + var12), (double)((float)var4 + var13), new ItemStack(var10.itemID, var14, var10.getItemDamage()));
+						float var16 = 0.05F;
+						var15.motionX = (double)((float)this.rand.nextGaussian() * var16);
+						var15.motionY = (double)((float)this.rand.nextGaussian() * var16 + 0.2F);
+						var15.motionZ = (double)((float)this.rand.nextGaussian() * var16);
+						var1.spawnEntityInWorld(var15);
+					}
+				}
+			}
+		}
+
+		super.breakBlock(var1, var2, var3, var4, var5, var6);
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		return Item.brewingStand.itemID;
+	}
+
+	public int idPicked(World var1, int var2, int var3, int var4) {
+		return Item.brewingStand.itemID;
+	}
+
+	public boolean hasComparatorInputOverride() {
+		return true;
+	}
+
+	public int getComparatorInputOverride(World var1, int var2, int var3, int var4, int var5) {
+		return Container.calcRedstoneFromInventory((IInventory)var1.getBlockTileEntity(var2, var3, var4));
+	}
+
+	public void registerIcons(IconRegister var1) {
+		super.registerIcons(var1);
+		this.theIcon = var1.registerIcon("brewingStand_base");
+	}
+
+	public Icon getBrewingStandIcon() {
+		return this.theIcon;
+	}
+}

src/net/minecraft/src/BlockButton.java

@@ -0,0 +1,255 @@
+package net.minecraft.src;
+
+import java.util.List;
+import java.util.Random;
+
+public abstract class BlockButton extends Block {
+	private final boolean sensible;
+
+	protected BlockButton(int var1, boolean var2) {
+		super(var1, Material.circuits);
+		this.setTickRandomly(true);
+		this.setCreativeTab(CreativeTabs.tabRedstone);
+		this.sensible = var2;
+	}
+
+	public AxisAlignedBB getCollisionBoundingBoxFromPool(World var1, int var2, int var3, int var4) {
+		return null;
+	}
+
+	public int tickRate(World var1) {
+		return this.sensible ? 30 : 20;
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public boolean canPlaceBlockOnSide(World var1, int var2, int var3, int var4, int var5) {
+		return var5 == 2 && var1.isBlockNormalCube(var2, var3, var4 + 1) ? true : (var5 == 3 && var1.isBlockNormalCube(var2, var3, var4 - 1) ? true : (var5 == 4 && var1.isBlockNormalCube(var2 + 1, var3, var4) ? true : var5 == 5 && var1.isBlockNormalCube(var2 - 1, var3, var4)));
+	}
+
+	public boolean canPlaceBlockAt(World var1, int var2, int var3, int var4) {
+		return var1.isBlockNormalCube(var2 - 1, var3, var4) ? true : (var1.isBlockNormalCube(var2 + 1, var3, var4) ? true : (var1.isBlockNormalCube(var2, var3, var4 - 1) ? true : var1.isBlockNormalCube(var2, var3, var4 + 1)));
+	}
+
+	public int onBlockPlaced(World var1, int var2, int var3, int var4, int var5, float var6, float var7, float var8, int var9) {
+		int var10 = var1.getBlockMetadata(var2, var3, var4);
+		int var11 = var10 & 8;
+		var10 &= 7;
+		if(var5 == 2 && var1.isBlockNormalCube(var2, var3, var4 + 1)) {
+			var10 = 4;
+		} else if(var5 == 3 && var1.isBlockNormalCube(var2, var3, var4 - 1)) {
+			var10 = 3;
+		} else if(var5 == 4 && var1.isBlockNormalCube(var2 + 1, var3, var4)) {
+			var10 = 2;
+		} else if(var5 == 5 && var1.isBlockNormalCube(var2 - 1, var3, var4)) {
+			var10 = 1;
+		} else {
+			var10 = this.getOrientation(var1, var2, var3, var4);
+		}
+
+		return var10 + var11;
+	}
+
+	private int getOrientation(World var1, int var2, int var3, int var4) {
+		return var1.isBlockNormalCube(var2 - 1, var3, var4) ? 1 : (var1.isBlockNormalCube(var2 + 1, var3, var4) ? 2 : (var1.isBlockNormalCube(var2, var3, var4 - 1) ? 3 : (var1.isBlockNormalCube(var2, var3, var4 + 1) ? 4 : 1)));
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+		if(this.redundantCanPlaceBlockAt(var1, var2, var3, var4)) {
+			int var6 = var1.getBlockMetadata(var2, var3, var4) & 7;
+			boolean var7 = false;
+			if(!var1.isBlockNormalCube(var2 - 1, var3, var4) && var6 == 1) {
+				var7 = true;
+			}
+
+			if(!var1.isBlockNormalCube(var2 + 1, var3, var4) && var6 == 2) {
+				var7 = true;
+			}
+
+			if(!var1.isBlockNormalCube(var2, var3, var4 - 1) && var6 == 3) {
+				var7 = true;
+			}
+
+			if(!var1.isBlockNormalCube(var2, var3, var4 + 1) && var6 == 4) {
+				var7 = true;
+			}
+
+			if(var7) {
+				this.dropBlockAsItem(var1, var2, var3, var4, var1.getBlockMetadata(var2, var3, var4), 0);
+				var1.setBlockToAir(var2, var3, var4);
+			}
+		}
+
+	}
+
+	private boolean redundantCanPlaceBlockAt(World var1, int var2, int var3, int var4) {
+		if(!this.canPlaceBlockAt(var1, var2, var3, var4)) {
+			this.dropBlockAsItem(var1, var2, var3, var4, var1.getBlockMetadata(var2, var3, var4), 0);
+			var1.setBlockToAir(var2, var3, var4);
+			return false;
+		} else {
+			return true;
+		}
+	}
+
+	public void setBlockBoundsBasedOnState(IBlockAccess var1, int var2, int var3, int var4) {
+		int var5 = var1.getBlockMetadata(var2, var3, var4);
+		this.func_82534_e(var5);
+	}
+
+	private void func_82534_e(int var1) {
+		int var2 = var1 & 7;
+		boolean var3 = (var1 & 8) > 0;
+		float var4 = 6.0F / 16.0F;
+		float var5 = 10.0F / 16.0F;
+		float var6 = 3.0F / 16.0F;
+		float var7 = 2.0F / 16.0F;
+		if(var3) {
+			var7 = 1.0F / 16.0F;
+		}
+
+		if(var2 == 1) {
+			this.setBlockBounds(0.0F, var4, 0.5F - var6, var7, var5, 0.5F + var6);
+		} else if(var2 == 2) {
+			this.setBlockBounds(1.0F - var7, var4, 0.5F - var6, 1.0F, var5, 0.5F + var6);
+		} else if(var2 == 3) {
+			this.setBlockBounds(0.5F - var6, var4, 0.0F, 0.5F + var6, var5, var7);
+		} else if(var2 == 4) {
+			this.setBlockBounds(0.5F - var6, var4, 1.0F - var7, 0.5F + var6, var5, 1.0F);
+		}
+
+	}
+
+	public void onBlockClicked(World var1, int var2, int var3, int var4, EntityPlayer var5) {
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		int var10 = var1.getBlockMetadata(var2, var3, var4);
+		int var11 = var10 & 7;
+		int var12 = 8 - (var10 & 8);
+		if(var12 == 0) {
+			return true;
+		} else {
+			var1.setBlockMetadataWithNotify(var2, var3, var4, var11 + var12, 3);
+			var1.markBlockRangeForRenderUpdate(var2, var3, var4, var2, var3, var4);
+			var1.playSoundEffect((double)var2 + 0.5D, (double)var3 + 0.5D, (double)var4 + 0.5D, "random.click", 0.3F, 0.6F);
+			this.func_82536_d(var1, var2, var3, var4, var11);
+			var1.scheduleBlockUpdate(var2, var3, var4, this.blockID, this.tickRate(var1));
+			return true;
+		}
+	}
+
+	public void breakBlock(World var1, int var2, int var3, int var4, int var5, int var6) {
+		if((var6 & 8) > 0) {
+			int var7 = var6 & 7;
+			this.func_82536_d(var1, var2, var3, var4, var7);
+		}
+
+		super.breakBlock(var1, var2, var3, var4, var5, var6);
+	}
+
+	public int isProvidingWeakPower(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return (var1.getBlockMetadata(var2, var3, var4) & 8) > 0 ? 15 : 0;
+	}
+
+	public int isProvidingStrongPower(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		int var6 = var1.getBlockMetadata(var2, var3, var4);
+		if((var6 & 8) == 0) {
+			return 0;
+		} else {
+			int var7 = var6 & 7;
+			return var7 == 5 && var5 == 1 ? 15 : (var7 == 4 && var5 == 2 ? 15 : (var7 == 3 && var5 == 3 ? 15 : (var7 == 2 && var5 == 4 ? 15 : (var7 == 1 && var5 == 5 ? 15 : 0))));
+		}
+	}
+
+	public boolean canProvidePower() {
+		return true;
+	}
+
+	public void updateTick(World var1, int var2, int var3, int var4, Random var5) {
+		if(!var1.isRemote) {
+			int var6 = var1.getBlockMetadata(var2, var3, var4);
+			if((var6 & 8) != 0) {
+				if(this.sensible) {
+					this.func_82535_o(var1, var2, var3, var4);
+				} else {
+					var1.setBlockMetadataWithNotify(var2, var3, var4, var6 & 7, 3);
+					int var7 = var6 & 7;
+					this.func_82536_d(var1, var2, var3, var4, var7);
+					var1.playSoundEffect((double)var2 + 0.5D, (double)var3 + 0.5D, (double)var4 + 0.5D, "random.click", 0.3F, 0.5F);
+					var1.markBlockRangeForRenderUpdate(var2, var3, var4, var2, var3, var4);
+				}
+
+			}
+		}
+	}
+
+	public void setBlockBoundsForItemRender() {
+		float var1 = 3.0F / 16.0F;
+		float var2 = 2.0F / 16.0F;
+		float var3 = 2.0F / 16.0F;
+		this.setBlockBounds(0.5F - var1, 0.5F - var2, 0.5F - var3, 0.5F + var1, 0.5F + var2, 0.5F + var3);
+	}
+
+	public void onEntityCollidedWithBlock(World var1, int var2, int var3, int var4, Entity var5) {
+		if(!var1.isRemote) {
+			if(this.sensible) {
+				if((var1.getBlockMetadata(var2, var3, var4) & 8) == 0) {
+					this.func_82535_o(var1, var2, var3, var4);
+				}
+			}
+		}
+	}
+
+	private void func_82535_o(World var1, int var2, int var3, int var4) {
+		int var5 = var1.getBlockMetadata(var2, var3, var4);
+		int var6 = var5 & 7;
+		boolean var7 = (var5 & 8) != 0;
+		this.func_82534_e(var5);
+		List var9 = var1.getEntitiesWithinAABB(EntityArrow.class, AxisAlignedBB.getAABBPool().getAABB((double)var2 + this.minX, (double)var3 + this.minY, (double)var4 + this.minZ, (double)var2 + this.maxX, (double)var3 + this.maxY, (double)var4 + this.maxZ));
+		boolean var8 = !var9.isEmpty();
+		if(var8 && !var7) {
+			var1.setBlockMetadataWithNotify(var2, var3, var4, var6 | 8, 3);
+			this.func_82536_d(var1, var2, var3, var4, var6);
+			var1.markBlockRangeForRenderUpdate(var2, var3, var4, var2, var3, var4);
+			var1.playSoundEffect((double)var2 + 0.5D, (double)var3 + 0.5D, (double)var4 + 0.5D, "random.click", 0.3F, 0.6F);
+		}
+
+		if(!var8 && var7) {
+			var1.setBlockMetadataWithNotify(var2, var3, var4, var6, 3);
+			this.func_82536_d(var1, var2, var3, var4, var6);
+			var1.markBlockRangeForRenderUpdate(var2, var3, var4, var2, var3, var4);
+			var1.playSoundEffect((double)var2 + 0.5D, (double)var3 + 0.5D, (double)var4 + 0.5D, "random.click", 0.3F, 0.5F);
+		}
+
+		if(var8) {
+			var1.scheduleBlockUpdate(var2, var3, var4, this.blockID, this.tickRate(var1));
+		}
+
+	}
+
+	private void func_82536_d(World var1, int var2, int var3, int var4, int var5) {
+		var1.notifyBlocksOfNeighborChange(var2, var3, var4, this.blockID);
+		if(var5 == 1) {
+			var1.notifyBlocksOfNeighborChange(var2 - 1, var3, var4, this.blockID);
+		} else if(var5 == 2) {
+			var1.notifyBlocksOfNeighborChange(var2 + 1, var3, var4, this.blockID);
+		} else if(var5 == 3) {
+			var1.notifyBlocksOfNeighborChange(var2, var3, var4 - 1, this.blockID);
+		} else if(var5 == 4) {
+			var1.notifyBlocksOfNeighborChange(var2, var3, var4 + 1, this.blockID);
+		} else {
+			var1.notifyBlocksOfNeighborChange(var2, var3 - 1, var4, this.blockID);
+		}
+
+	}
+
+	public void registerIcons(IconRegister var1) {
+	}
+}

src/net/minecraft/src/BlockButtonStone.java

@@ -0,0 +1,11 @@
+package net.minecraft.src;
+
+public class BlockButtonStone extends BlockButton {
+	protected BlockButtonStone(int var1) {
+		super(var1, false);
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return Block.stone.getBlockTextureFromSide(1);
+	}
+}

src/net/minecraft/src/BlockButtonWood.java

@@ -0,0 +1,11 @@
+package net.minecraft.src;
+
+public class BlockButtonWood extends BlockButton {
+	protected BlockButtonWood(int var1) {
+		super(var1, true);
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return Block.planks.getBlockTextureFromSide(1);
+	}
+}

src/net/minecraft/src/BlockCactus.java

@@ -0,0 +1,96 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockCactus extends Block {
+	private Icon cactusTopIcon;
+	private Icon cactusBottomIcon;
+
+	protected BlockCactus(int var1) {
+		super(var1, Material.cactus);
+		this.setTickRandomly(true);
+		this.setCreativeTab(CreativeTabs.tabDecorations);
+	}
+
+	public void updateTick(World var1, int var2, int var3, int var4, Random var5) {
+		if(var1.isAirBlock(var2, var3 + 1, var4)) {
+			int var6;
+			for(var6 = 1; var1.getBlockId(var2, var3 - var6, var4) == this.blockID; ++var6) {
+			}
+
+			if(var6 < 3) {
+				int var7 = var1.getBlockMetadata(var2, var3, var4);
+				if(var7 == 15) {
+					var1.setBlock(var2, var3 + 1, var4, this.blockID);
+					var1.setBlockMetadataWithNotify(var2, var3, var4, 0, 4);
+					this.onNeighborBlockChange(var1, var2, var3 + 1, var4, this.blockID);
+				} else {
+					var1.setBlockMetadataWithNotify(var2, var3, var4, var7 + 1, 4);
+				}
+			}
+		}
+
+	}
+
+	public AxisAlignedBB getCollisionBoundingBoxFromPool(World var1, int var2, int var3, int var4) {
+		float var5 = 1.0F / 16.0F;
+		return AxisAlignedBB.getAABBPool().getAABB((double)((float)var2 + var5), (double)var3, (double)((float)var4 + var5), (double)((float)(var2 + 1) - var5), (double)((float)(var3 + 1) - var5), (double)((float)(var4 + 1) - var5));
+	}
+
+	public AxisAlignedBB getSelectedBoundingBoxFromPool(World var1, int var2, int var3, int var4) {
+		float var5 = 1.0F / 16.0F;
+		return AxisAlignedBB.getAABBPool().getAABB((double)((float)var2 + var5), (double)var3, (double)((float)var4 + var5), (double)((float)(var2 + 1) - var5), (double)(var3 + 1), (double)((float)(var4 + 1) - var5));
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return var1 == 1 ? this.cactusTopIcon : (var1 == 0 ? this.cactusBottomIcon : this.blockIcon);
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public int getRenderType() {
+		return 13;
+	}
+
+	public boolean canPlaceBlockAt(World var1, int var2, int var3, int var4) {
+		return !super.canPlaceBlockAt(var1, var2, var3, var4) ? false : this.canBlockStay(var1, var2, var3, var4);
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+		if(!this.canBlockStay(var1, var2, var3, var4)) {
+			var1.destroyBlock(var2, var3, var4, true);
+		}
+
+	}
+
+	public boolean canBlockStay(World var1, int var2, int var3, int var4) {
+		if(var1.getBlockMaterial(var2 - 1, var3, var4).isSolid()) {
+			return false;
+		} else if(var1.getBlockMaterial(var2 + 1, var3, var4).isSolid()) {
+			return false;
+		} else if(var1.getBlockMaterial(var2, var3, var4 - 1).isSolid()) {
+			return false;
+		} else if(var1.getBlockMaterial(var2, var3, var4 + 1).isSolid()) {
+			return false;
+		} else {
+			int var5 = var1.getBlockId(var2, var3 - 1, var4);
+			return var5 == Block.cactus.blockID || var5 == Block.sand.blockID;
+		}
+	}
+
+	public void onEntityCollidedWithBlock(World var1, int var2, int var3, int var4, Entity var5) {
+		var5.attackEntityFrom(DamageSource.cactus, 1);
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.blockIcon = var1.registerIcon("cactus_side");
+		this.cactusTopIcon = var1.registerIcon("cactus_top");
+		this.cactusBottomIcon = var1.registerIcon("cactus_bottom");
+	}
+}

src/net/minecraft/src/BlockCake.java

@@ -0,0 +1,112 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockCake extends Block {
+	private Icon cakeTopIcon;
+	private Icon cakeBottomIcon;
+	private Icon field_94382_c;
+
+	protected BlockCake(int var1) {
+		super(var1, Material.cake);
+		this.setTickRandomly(true);
+	}
+
+	public void setBlockBoundsBasedOnState(IBlockAccess var1, int var2, int var3, int var4) {
+		int var5 = var1.getBlockMetadata(var2, var3, var4);
+		float var6 = 1.0F / 16.0F;
+		float var7 = (float)(1 + var5 * 2) / 16.0F;
+		float var8 = 0.5F;
+		this.setBlockBounds(var7, 0.0F, var6, 1.0F - var6, var8, 1.0F - var6);
+	}
+
+	public void setBlockBoundsForItemRender() {
+		float var1 = 1.0F / 16.0F;
+		float var2 = 0.5F;
+		this.setBlockBounds(var1, 0.0F, var1, 1.0F - var1, var2, 1.0F - var1);
+	}
+
+	public AxisAlignedBB getCollisionBoundingBoxFromPool(World var1, int var2, int var3, int var4) {
+		int var5 = var1.getBlockMetadata(var2, var3, var4);
+		float var6 = 1.0F / 16.0F;
+		float var7 = (float)(1 + var5 * 2) / 16.0F;
+		float var8 = 0.5F;
+		return AxisAlignedBB.getAABBPool().getAABB((double)((float)var2 + var7), (double)var3, (double)((float)var4 + var6), (double)((float)(var2 + 1) - var6), (double)((float)var3 + var8 - var6), (double)((float)(var4 + 1) - var6));
+	}
+
+	public AxisAlignedBB getSelectedBoundingBoxFromPool(World var1, int var2, int var3, int var4) {
+		int var5 = var1.getBlockMetadata(var2, var3, var4);
+		float var6 = 1.0F / 16.0F;
+		float var7 = (float)(1 + var5 * 2) / 16.0F;
+		float var8 = 0.5F;
+		return AxisAlignedBB.getAABBPool().getAABB((double)((float)var2 + var7), (double)var3, (double)((float)var4 + var6), (double)((float)(var2 + 1) - var6), (double)((float)var3 + var8), (double)((float)(var4 + 1) - var6));
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return var1 == 1 ? this.cakeTopIcon : (var1 == 0 ? this.cakeBottomIcon : (var2 > 0 && var1 == 4 ? this.field_94382_c : this.blockIcon));
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.blockIcon = var1.registerIcon("cake_side");
+		this.field_94382_c = var1.registerIcon("cake_inner");
+		this.cakeTopIcon = var1.registerIcon("cake_top");
+		this.cakeBottomIcon = var1.registerIcon("cake_bottom");
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		this.eatCakeSlice(var1, var2, var3, var4, var5);
+		return true;
+	}
+
+	public void onBlockClicked(World var1, int var2, int var3, int var4, EntityPlayer var5) {
+		this.eatCakeSlice(var1, var2, var3, var4, var5);
+	}
+
+	private void eatCakeSlice(World var1, int var2, int var3, int var4, EntityPlayer var5) {
+		if(var5.canEat(false)) {
+			var5.getFoodStats().addStats(2, 0.1F);
+			int var6 = var1.getBlockMetadata(var2, var3, var4) + 1;
+			if(var6 >= 6) {
+				var1.setBlockToAir(var2, var3, var4);
+			} else {
+				var1.setBlockMetadataWithNotify(var2, var3, var4, var6, 2);
+			}
+		}
+
+	}
+
+	public boolean canPlaceBlockAt(World var1, int var2, int var3, int var4) {
+		return !super.canPlaceBlockAt(var1, var2, var3, var4) ? false : this.canBlockStay(var1, var2, var3, var4);
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+		if(!this.canBlockStay(var1, var2, var3, var4)) {
+			var1.setBlockToAir(var2, var3, var4);
+		}
+
+	}
+
+	public boolean canBlockStay(World var1, int var2, int var3, int var4) {
+		return var1.getBlockMaterial(var2, var3 - 1, var4).isSolid();
+	}
+
+	public int quantityDropped(Random var1) {
+		return 0;
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		return 0;
+	}
+
+	public int idPicked(World var1, int var2, int var3, int var4) {
+		return Item.cake.itemID;
+	}
+}

src/net/minecraft/src/BlockCarrot.java

@@ -0,0 +1,38 @@
+package net.minecraft.src;
+
+public class BlockCarrot extends BlockCrops {
+	private Icon[] iconArray;
+
+	public BlockCarrot(int var1) {
+		super(var1);
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		if(var2 < 7) {
+			if(var2 == 6) {
+				var2 = 5;
+			}
+
+			return this.iconArray[var2 >> 1];
+		} else {
+			return this.iconArray[3];
+		}
+	}
+
+	protected int getSeedItem() {
+		return Item.carrot.itemID;
+	}
+
+	protected int getCropItem() {
+		return Item.carrot.itemID;
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.iconArray = new Icon[4];
+
+		for(int var2 = 0; var2 < this.iconArray.length; ++var2) {
+			this.iconArray[var2] = var1.registerIcon("carrots_" + var2);
+		}
+
+	}
+}

src/net/minecraft/src/BlockCauldron.java

@@ -0,0 +1,127 @@
+package net.minecraft.src;
+
+import java.util.List;
+import java.util.Random;
+
+public class BlockCauldron extends Block {
+	private Icon field_94378_a;
+	private Icon cauldronTopIcon;
+	private Icon cauldronBottomIcon;
+
+	public BlockCauldron(int var1) {
+		super(var1, Material.iron);
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return var1 == 1 ? this.cauldronTopIcon : (var1 == 0 ? this.cauldronBottomIcon : this.blockIcon);
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.field_94378_a = var1.registerIcon("cauldron_inner");
+		this.cauldronTopIcon = var1.registerIcon("cauldron_top");
+		this.cauldronBottomIcon = var1.registerIcon("cauldron_bottom");
+		this.blockIcon = var1.registerIcon("cauldron_side");
+	}
+
+	public static Icon func_94375_b(String var0) {
+		return var0 == "cauldron_inner" ? Block.cauldron.field_94378_a : (var0 == "cauldron_bottom" ? Block.cauldron.cauldronBottomIcon : null);
+	}
+
+	public void addCollisionBoxesToList(World var1, int var2, int var3, int var4, AxisAlignedBB var5, List var6, Entity var7) {
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 5.0F / 16.0F, 1.0F);
+		super.addCollisionBoxesToList(var1, var2, var3, var4, var5, var6, var7);
+		float var8 = 2.0F / 16.0F;
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, var8, 1.0F, 1.0F);
+		super.addCollisionBoxesToList(var1, var2, var3, var4, var5, var6, var7);
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, var8);
+		super.addCollisionBoxesToList(var1, var2, var3, var4, var5, var6, var7);
+		this.setBlockBounds(1.0F - var8, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
+		super.addCollisionBoxesToList(var1, var2, var3, var4, var5, var6, var7);
+		this.setBlockBounds(0.0F, 0.0F, 1.0F - var8, 1.0F, 1.0F, 1.0F);
+		super.addCollisionBoxesToList(var1, var2, var3, var4, var5, var6, var7);
+		this.setBlockBoundsForItemRender();
+	}
+
+	public void setBlockBoundsForItemRender() {
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public int getRenderType() {
+		return 24;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		if(var1.isRemote) {
+			return true;
+		} else {
+			ItemStack var10 = var5.inventory.getCurrentItem();
+			if(var10 == null) {
+				return true;
+			} else {
+				int var11 = var1.getBlockMetadata(var2, var3, var4);
+				if(var10.itemID == Item.bucketWater.itemID) {
+					if(var11 < 3) {
+						if(!var5.capabilities.isCreativeMode) {
+							var5.inventory.setInventorySlotContents(var5.inventory.currentItem, new ItemStack(Item.bucketEmpty));
+						}
+
+						var1.setBlockMetadataWithNotify(var2, var3, var4, 3, 2);
+					}
+
+					return true;
+				} else {
+					if(var10.itemID == Item.glassBottle.itemID) {
+						if(var11 > 0) {
+							ItemStack var12 = new ItemStack(Item.potion, 1, 0);
+							if(!var5.inventory.addItemStackToInventory(var12)) {
+								var1.spawnEntityInWorld(new EntityItem(var1, (double)var2 + 0.5D, (double)var3 + 1.5D, (double)var4 + 0.5D, var12));
+							} else if(var5 instanceof EntityPlayerMP) {
+								((EntityPlayerMP)var5).sendContainerToPlayer(var5.inventoryContainer);
+							}
+
+							--var10.stackSize;
+							if(var10.stackSize <= 0) {
+								var5.inventory.setInventorySlotContents(var5.inventory.currentItem, (ItemStack)null);
+							}
+
+							var1.setBlockMetadataWithNotify(var2, var3, var4, var11 - 1, 2);
+						}
+					} else if(var11 > 0 && var10.getItem() instanceof ItemArmor && ((ItemArmor)var10.getItem()).getArmorMaterial() == EnumArmorMaterial.CLOTH) {
+						ItemArmor var13 = (ItemArmor)var10.getItem();
+						var13.removeColor(var10);
+						var1.setBlockMetadataWithNotify(var2, var3, var4, var11 - 1, 2);
+						return true;
+					}
+
+					return true;
+				}
+			}
+		}
+	}
+
+	public void fillWithRain(World var1, int var2, int var3, int var4) {
+		if(var1.rand.nextInt(20) == 1) {
+			int var5 = var1.getBlockMetadata(var2, var3, var4);
+			if(var5 < 3) {
+				var1.setBlockMetadataWithNotify(var2, var3, var4, var5 + 1, 2);
+			}
+
+		}
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		return Item.cauldron.itemID;
+	}
+
+	public int idPicked(World var1, int var2, int var3, int var4) {
+		return Item.cauldron.itemID;
+	}
+}

src/net/minecraft/src/BlockChest.java

@@ -0,0 +1,377 @@
+package net.minecraft.src;
+
+import java.util.Iterator;
+import java.util.Random;
+
+public class BlockChest extends BlockContainer {
+	private final Random random = new Random();
+	public final int isTrapped;
+
+	protected BlockChest(int var1, int var2) {
+		super(var1, Material.wood);
+		this.isTrapped = var2;
+		this.setCreativeTab(CreativeTabs.tabDecorations);
+		this.setBlockBounds(1.0F / 16.0F, 0.0F, 1.0F / 16.0F, 15.0F / 16.0F, 14.0F / 16.0F, 15.0F / 16.0F);
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public int getRenderType() {
+		return 22;
+	}
+
+	public void setBlockBoundsBasedOnState(IBlockAccess var1, int var2, int var3, int var4) {
+		if(var1.getBlockId(var2, var3, var4 - 1) == this.blockID) {
+			this.setBlockBounds(1.0F / 16.0F, 0.0F, 0.0F, 15.0F / 16.0F, 14.0F / 16.0F, 15.0F / 16.0F);
+		} else if(var1.getBlockId(var2, var3, var4 + 1) == this.blockID) {
+			this.setBlockBounds(1.0F / 16.0F, 0.0F, 1.0F / 16.0F, 15.0F / 16.0F, 14.0F / 16.0F, 1.0F);
+		} else if(var1.getBlockId(var2 - 1, var3, var4) == this.blockID) {
+			this.setBlockBounds(0.0F, 0.0F, 1.0F / 16.0F, 15.0F / 16.0F, 14.0F / 16.0F, 15.0F / 16.0F);
+		} else if(var1.getBlockId(var2 + 1, var3, var4) == this.blockID) {
+			this.setBlockBounds(1.0F / 16.0F, 0.0F, 1.0F / 16.0F, 1.0F, 14.0F / 16.0F, 15.0F / 16.0F);
+		} else {
+			this.setBlockBounds(1.0F / 16.0F, 0.0F, 1.0F / 16.0F, 15.0F / 16.0F, 14.0F / 16.0F, 15.0F / 16.0F);
+		}
+
+	}
+
+	public void onBlockAdded(World var1, int var2, int var3, int var4) {
+		super.onBlockAdded(var1, var2, var3, var4);
+		this.unifyAdjacentChests(var1, var2, var3, var4);
+		int var5 = var1.getBlockId(var2, var3, var4 - 1);
+		int var6 = var1.getBlockId(var2, var3, var4 + 1);
+		int var7 = var1.getBlockId(var2 - 1, var3, var4);
+		int var8 = var1.getBlockId(var2 + 1, var3, var4);
+		if(var5 == this.blockID) {
+			this.unifyAdjacentChests(var1, var2, var3, var4 - 1);
+		}
+
+		if(var6 == this.blockID) {
+			this.unifyAdjacentChests(var1, var2, var3, var4 + 1);
+		}
+
+		if(var7 == this.blockID) {
+			this.unifyAdjacentChests(var1, var2 - 1, var3, var4);
+		}
+
+		if(var8 == this.blockID) {
+			this.unifyAdjacentChests(var1, var2 + 1, var3, var4);
+		}
+
+	}
+
+	public void onBlockPlacedBy(World var1, int var2, int var3, int var4, EntityLiving var5, ItemStack var6) {
+		int var7 = var1.getBlockId(var2, var3, var4 - 1);
+		int var8 = var1.getBlockId(var2, var3, var4 + 1);
+		int var9 = var1.getBlockId(var2 - 1, var3, var4);
+		int var10 = var1.getBlockId(var2 + 1, var3, var4);
+		byte var11 = 0;
+		int var12 = MathHelper.floor_double((double)(var5.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;
+		if(var12 == 0) {
+			var11 = 2;
+		}
+
+		if(var12 == 1) {
+			var11 = 5;
+		}
+
+		if(var12 == 2) {
+			var11 = 3;
+		}
+
+		if(var12 == 3) {
+			var11 = 4;
+		}
+
+		if(var7 != this.blockID && var8 != this.blockID && var9 != this.blockID && var10 != this.blockID) {
+			var1.setBlockMetadataWithNotify(var2, var3, var4, var11, 3);
+		} else {
+			if((var7 == this.blockID || var8 == this.blockID) && (var11 == 4 || var11 == 5)) {
+				if(var7 == this.blockID) {
+					var1.setBlockMetadataWithNotify(var2, var3, var4 - 1, var11, 3);
+				} else {
+					var1.setBlockMetadataWithNotify(var2, var3, var4 + 1, var11, 3);
+				}
+
+				var1.setBlockMetadataWithNotify(var2, var3, var4, var11, 3);
+			}
+
+			if((var9 == this.blockID || var10 == this.blockID) && (var11 == 2 || var11 == 3)) {
+				if(var9 == this.blockID) {
+					var1.setBlockMetadataWithNotify(var2 - 1, var3, var4, var11, 3);
+				} else {
+					var1.setBlockMetadataWithNotify(var2 + 1, var3, var4, var11, 3);
+				}
+
+				var1.setBlockMetadataWithNotify(var2, var3, var4, var11, 3);
+			}
+		}
+
+		if(var6.hasDisplayName()) {
+			((TileEntityChest)var1.getBlockTileEntity(var2, var3, var4)).func_94043_a(var6.getDisplayName());
+		}
+
+	}
+
+	public void unifyAdjacentChests(World var1, int var2, int var3, int var4) {
+		if(!var1.isRemote) {
+			int var5 = var1.getBlockId(var2, var3, var4 - 1);
+			int var6 = var1.getBlockId(var2, var3, var4 + 1);
+			int var7 = var1.getBlockId(var2 - 1, var3, var4);
+			int var8 = var1.getBlockId(var2 + 1, var3, var4);
+			boolean var9 = true;
+			int var10;
+			int var11;
+			boolean var12;
+			byte var13;
+			int var14;
+			if(var5 != this.blockID && var6 != this.blockID) {
+				if(var7 != this.blockID && var8 != this.blockID) {
+					var13 = 3;
+					if(Block.opaqueCubeLookup[var5] && !Block.opaqueCubeLookup[var6]) {
+						var13 = 3;
+					}
+
+					if(Block.opaqueCubeLookup[var6] && !Block.opaqueCubeLookup[var5]) {
+						var13 = 2;
+					}
+
+					if(Block.opaqueCubeLookup[var7] && !Block.opaqueCubeLookup[var8]) {
+						var13 = 5;
+					}
+
+					if(Block.opaqueCubeLookup[var8] && !Block.opaqueCubeLookup[var7]) {
+						var13 = 4;
+					}
+				} else {
+					var10 = var1.getBlockId(var7 == this.blockID ? var2 - 1 : var2 + 1, var3, var4 - 1);
+					var11 = var1.getBlockId(var7 == this.blockID ? var2 - 1 : var2 + 1, var3, var4 + 1);
+					var13 = 3;
+					var12 = true;
+					if(var7 == this.blockID) {
+						var14 = var1.getBlockMetadata(var2 - 1, var3, var4);
+					} else {
+						var14 = var1.getBlockMetadata(var2 + 1, var3, var4);
+					}
+
+					if(var14 == 2) {
+						var13 = 2;
+					}
+
+					if((Block.opaqueCubeLookup[var5] || Block.opaqueCubeLookup[var10]) && !Block.opaqueCubeLookup[var6] && !Block.opaqueCubeLookup[var11]) {
+						var13 = 3;
+					}
+
+					if((Block.opaqueCubeLookup[var6] || Block.opaqueCubeLookup[var11]) && !Block.opaqueCubeLookup[var5] && !Block.opaqueCubeLookup[var10]) {
+						var13 = 2;
+					}
+				}
+			} else {
+				var10 = var1.getBlockId(var2 - 1, var3, var5 == this.blockID ? var4 - 1 : var4 + 1);
+				var11 = var1.getBlockId(var2 + 1, var3, var5 == this.blockID ? var4 - 1 : var4 + 1);
+				var13 = 5;
+				var12 = true;
+				if(var5 == this.blockID) {
+					var14 = var1.getBlockMetadata(var2, var3, var4 - 1);
+				} else {
+					var14 = var1.getBlockMetadata(var2, var3, var4 + 1);
+				}
+
+				if(var14 == 4) {
+					var13 = 4;
+				}
+
+				if((Block.opaqueCubeLookup[var7] || Block.opaqueCubeLookup[var10]) && !Block.opaqueCubeLookup[var8] && !Block.opaqueCubeLookup[var11]) {
+					var13 = 5;
+				}
+
+				if((Block.opaqueCubeLookup[var8] || Block.opaqueCubeLookup[var11]) && !Block.opaqueCubeLookup[var7] && !Block.opaqueCubeLookup[var10]) {
+					var13 = 4;
+				}
+			}
+
+			var1.setBlockMetadataWithNotify(var2, var3, var4, var13, 3);
+		}
+	}
+
+	public boolean canPlaceBlockAt(World var1, int var2, int var3, int var4) {
+		int var5 = 0;
+		if(var1.getBlockId(var2 - 1, var3, var4) == this.blockID) {
+			++var5;
+		}
+
+		if(var1.getBlockId(var2 + 1, var3, var4) == this.blockID) {
+			++var5;
+		}
+
+		if(var1.getBlockId(var2, var3, var4 - 1) == this.blockID) {
+			++var5;
+		}
+
+		if(var1.getBlockId(var2, var3, var4 + 1) == this.blockID) {
+			++var5;
+		}
+
+		return var5 > 1 ? false : (this.isThereANeighborChest(var1, var2 - 1, var3, var4) ? false : (this.isThereANeighborChest(var1, var2 + 1, var3, var4) ? false : (this.isThereANeighborChest(var1, var2, var3, var4 - 1) ? false : !this.isThereANeighborChest(var1, var2, var3, var4 + 1))));
+	}
+
+	private boolean isThereANeighborChest(World var1, int var2, int var3, int var4) {
+		return var1.getBlockId(var2, var3, var4) != this.blockID ? false : (var1.getBlockId(var2 - 1, var3, var4) == this.blockID ? true : (var1.getBlockId(var2 + 1, var3, var4) == this.blockID ? true : (var1.getBlockId(var2, var3, var4 - 1) == this.blockID ? true : var1.getBlockId(var2, var3, var4 + 1) == this.blockID)));
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+		super.onNeighborBlockChange(var1, var2, var3, var4, var5);
+		TileEntityChest var6 = (TileEntityChest)var1.getBlockTileEntity(var2, var3, var4);
+		if(var6 != null) {
+			var6.updateContainingBlockInfo();
+		}
+
+	}
+
+	public void breakBlock(World var1, int var2, int var3, int var4, int var5, int var6) {
+		TileEntityChest var7 = (TileEntityChest)var1.getBlockTileEntity(var2, var3, var4);
+		if(var7 != null) {
+			for(int var8 = 0; var8 < var7.getSizeInventory(); ++var8) {
+				ItemStack var9 = var7.getStackInSlot(var8);
+				if(var9 != null) {
+					float var10 = this.random.nextFloat() * 0.8F + 0.1F;
+					float var11 = this.random.nextFloat() * 0.8F + 0.1F;
+
+					EntityItem var14;
+					for(float var12 = this.random.nextFloat() * 0.8F + 0.1F; var9.stackSize > 0; var1.spawnEntityInWorld(var14)) {
+						int var13 = this.random.nextInt(21) + 10;
+						if(var13 > var9.stackSize) {
+							var13 = var9.stackSize;
+						}
+
+						var9.stackSize -= var13;
+						var14 = new EntityItem(var1, (double)((float)var2 + var10), (double)((float)var3 + var11), (double)((float)var4 + var12), new ItemStack(var9.itemID, var13, var9.getItemDamage()));
+						float var15 = 0.05F;
+						var14.motionX = (double)((float)this.random.nextGaussian() * var15);
+						var14.motionY = (double)((float)this.random.nextGaussian() * var15 + 0.2F);
+						var14.motionZ = (double)((float)this.random.nextGaussian() * var15);
+						if(var9.hasTagCompound()) {
+							var14.getEntityItem().setTagCompound((NBTTagCompound)var9.getTagCompound().copy());
+						}
+					}
+				}
+			}
+
+			var1.func_96440_m(var2, var3, var4, var5);
+		}
+
+		super.breakBlock(var1, var2, var3, var4, var5, var6);
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		if(var1.isRemote) {
+			return true;
+		} else {
+			IInventory var10 = this.getInventory(var1, var2, var3, var4);
+			if(var10 != null) {
+				var5.displayGUIChest(var10);
+			}
+
+			return true;
+		}
+	}
+
+	public IInventory getInventory(World var1, int var2, int var3, int var4) {
+		Object var5 = (TileEntityChest)var1.getBlockTileEntity(var2, var3, var4);
+		if(var5 == null) {
+			return null;
+		} else if(var1.isBlockNormalCube(var2, var3 + 1, var4)) {
+			return null;
+		} else if(isOcelotBlockingChest(var1, var2, var3, var4)) {
+			return null;
+		} else if(var1.getBlockId(var2 - 1, var3, var4) != this.blockID || !var1.isBlockNormalCube(var2 - 1, var3 + 1, var4) && !isOcelotBlockingChest(var1, var2 - 1, var3, var4)) {
+			if(var1.getBlockId(var2 + 1, var3, var4) != this.blockID || !var1.isBlockNormalCube(var2 + 1, var3 + 1, var4) && !isOcelotBlockingChest(var1, var2 + 1, var3, var4)) {
+				if(var1.getBlockId(var2, var3, var4 - 1) != this.blockID || !var1.isBlockNormalCube(var2, var3 + 1, var4 - 1) && !isOcelotBlockingChest(var1, var2, var3, var4 - 1)) {
+					if(var1.getBlockId(var2, var3, var4 + 1) != this.blockID || !var1.isBlockNormalCube(var2, var3 + 1, var4 + 1) && !isOcelotBlockingChest(var1, var2, var3, var4 + 1)) {
+						if(var1.getBlockId(var2 - 1, var3, var4) == this.blockID) {
+							var5 = new InventoryLargeChest("container.chestDouble", (TileEntityChest)var1.getBlockTileEntity(var2 - 1, var3, var4), (IInventory)var5);
+						}
+
+						if(var1.getBlockId(var2 + 1, var3, var4) == this.blockID) {
+							var5 = new InventoryLargeChest("container.chestDouble", (IInventory)var5, (TileEntityChest)var1.getBlockTileEntity(var2 + 1, var3, var4));
+						}
+
+						if(var1.getBlockId(var2, var3, var4 - 1) == this.blockID) {
+							var5 = new InventoryLargeChest("container.chestDouble", (TileEntityChest)var1.getBlockTileEntity(var2, var3, var4 - 1), (IInventory)var5);
+						}
+
+						if(var1.getBlockId(var2, var3, var4 + 1) == this.blockID) {
+							var5 = new InventoryLargeChest("container.chestDouble", (IInventory)var5, (TileEntityChest)var1.getBlockTileEntity(var2, var3, var4 + 1));
+						}
+
+						return (IInventory)var5;
+					} else {
+						return null;
+					}
+				} else {
+					return null;
+				}
+			} else {
+				return null;
+			}
+		} else {
+			return null;
+		}
+	}
+
+	public TileEntity createNewTileEntity(World var1) {
+		TileEntityChest var2 = new TileEntityChest();
+		return var2;
+	}
+
+	public boolean canProvidePower() {
+		return this.isTrapped == 1;
+	}
+
+	public int isProvidingWeakPower(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		if(!this.canProvidePower()) {
+			return 0;
+		} else {
+			int var6 = ((TileEntityChest)var1.getBlockTileEntity(var2, var3, var4)).numUsingPlayers;
+			return MathHelper.clamp_int(var6, 0, 15);
+		}
+	}
+
+	public int isProvidingStrongPower(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return var5 == 1 ? this.isProvidingWeakPower(var1, var2, var3, var4, var5) : 0;
+	}
+
+	private static boolean isOcelotBlockingChest(World var0, int var1, int var2, int var3) {
+		Iterator var4 = var0.getEntitiesWithinAABB(EntityOcelot.class, AxisAlignedBB.getAABBPool().getAABB((double)var1, (double)(var2 + 1), (double)var3, (double)(var1 + 1), (double)(var2 + 2), (double)(var3 + 1))).iterator();
+
+		EntityOcelot var6;
+		do {
+			if(!var4.hasNext()) {
+				return false;
+			}
+
+			EntityOcelot var5 = (EntityOcelot)var4.next();
+			var6 = (EntityOcelot)var5;
+		} while(!var6.isSitting());
+
+		return true;
+	}
+
+	public boolean hasComparatorInputOverride() {
+		return true;
+	}
+
+	public int getComparatorInputOverride(World var1, int var2, int var3, int var4, int var5) {
+		return Container.calcRedstoneFromInventory(this.getInventory(var1, var2, var3, var4));
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.blockIcon = var1.registerIcon("wood");
+	}
+}

src/net/minecraft/src/BlockClay.java

@@ -0,0 +1,18 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockClay extends Block {
+	public BlockClay(int var1) {
+		super(var1, Material.clay);
+		this.setCreativeTab(CreativeTabs.tabBlock);
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		return Item.clay.itemID;
+	}
+
+	public int quantityDropped(Random var1) {
+		return 4;
+	}
+}

src/net/minecraft/src/BlockCloth.java

@@ -0,0 +1,44 @@
+package net.minecraft.src;
+
+import java.util.List;
+
+public class BlockCloth extends Block {
+	private Icon[] iconArray;
+
+	public BlockCloth() {
+		super(35, Material.cloth);
+		this.setCreativeTab(CreativeTabs.tabBlock);
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return this.iconArray[var2 % this.iconArray.length];
+	}
+
+	public int damageDropped(int var1) {
+		return var1;
+	}
+
+	public static int getBlockFromDye(int var0) {
+		return ~var0 & 15;
+	}
+
+	public static int getDyeFromBlock(int var0) {
+		return ~var0 & 15;
+	}
+
+	public void getSubBlocks(int var1, CreativeTabs var2, List var3) {
+		for(int var4 = 0; var4 < 16; ++var4) {
+			var3.add(new ItemStack(var1, 1, var4));
+		}
+
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.iconArray = new Icon[16];
+
+		for(int var2 = 0; var2 < this.iconArray.length; ++var2) {
+			this.iconArray[var2] = var1.registerIcon("cloth_" + var2);
+		}
+
+	}
+}

src/net/minecraft/src/BlockCocoa.java

@@ -0,0 +1,148 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockCocoa extends BlockDirectional {
+	public static final String[] cocoaIcons = new String[]{"cocoa_0", "cocoa_1", "cocoa_2"};
+	private Icon[] iconArray;
+
+	public BlockCocoa(int var1) {
+		super(var1, Material.plants);
+		this.setTickRandomly(true);
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return this.iconArray[2];
+	}
+
+	public Icon func_94468_i_(int var1) {
+		if(var1 < 0 || var1 >= this.iconArray.length) {
+			var1 = this.iconArray.length - 1;
+		}
+
+		return this.iconArray[var1];
+	}
+
+	public void updateTick(World var1, int var2, int var3, int var4, Random var5) {
+		if(!this.canBlockStay(var1, var2, var3, var4)) {
+			this.dropBlockAsItem(var1, var2, var3, var4, var1.getBlockMetadata(var2, var3, var4), 0);
+			var1.setBlockToAir(var2, var3, var4);
+		} else if(var1.rand.nextInt(5) == 0) {
+			int var6 = var1.getBlockMetadata(var2, var3, var4);
+			int var7 = func_72219_c(var6);
+			if(var7 < 2) {
+				++var7;
+				var1.setBlockMetadataWithNotify(var2, var3, var4, var7 << 2 | getDirection(var6), 2);
+			}
+		}
+
+	}
+
+	public boolean canBlockStay(World var1, int var2, int var3, int var4) {
+		int var5 = getDirection(var1.getBlockMetadata(var2, var3, var4));
+		var2 += Direction.offsetX[var5];
+		var4 += Direction.offsetZ[var5];
+		int var6 = var1.getBlockId(var2, var3, var4);
+		return var6 == Block.wood.blockID && BlockLog.limitToValidMetadata(var1.getBlockMetadata(var2, var3, var4)) == 3;
+	}
+
+	public int getRenderType() {
+		return 28;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public AxisAlignedBB getCollisionBoundingBoxFromPool(World var1, int var2, int var3, int var4) {
+		this.setBlockBoundsBasedOnState(var1, var2, var3, var4);
+		return super.getCollisionBoundingBoxFromPool(var1, var2, var3, var4);
+	}
+
+	public AxisAlignedBB getSelectedBoundingBoxFromPool(World var1, int var2, int var3, int var4) {
+		this.setBlockBoundsBasedOnState(var1, var2, var3, var4);
+		return super.getSelectedBoundingBoxFromPool(var1, var2, var3, var4);
+	}
+
+	public void setBlockBoundsBasedOnState(IBlockAccess var1, int var2, int var3, int var4) {
+		int var5 = var1.getBlockMetadata(var2, var3, var4);
+		int var6 = getDirection(var5);
+		int var7 = func_72219_c(var5);
+		int var8 = 4 + var7 * 2;
+		int var9 = 5 + var7 * 2;
+		float var10 = (float)var8 / 2.0F;
+		switch(var6) {
+		case 0:
+			this.setBlockBounds((8.0F - var10) / 16.0F, (12.0F - (float)var9) / 16.0F, (15.0F - (float)var8) / 16.0F, (8.0F + var10) / 16.0F, 12.0F / 16.0F, 15.0F / 16.0F);
+			break;
+		case 1:
+			this.setBlockBounds(1.0F / 16.0F, (12.0F - (float)var9) / 16.0F, (8.0F - var10) / 16.0F, (1.0F + (float)var8) / 16.0F, 12.0F / 16.0F, (8.0F + var10) / 16.0F);
+			break;
+		case 2:
+			this.setBlockBounds((8.0F - var10) / 16.0F, (12.0F - (float)var9) / 16.0F, 1.0F / 16.0F, (8.0F + var10) / 16.0F, 12.0F / 16.0F, (1.0F + (float)var8) / 16.0F);
+			break;
+		case 3:
+			this.setBlockBounds((15.0F - (float)var8) / 16.0F, (12.0F - (float)var9) / 16.0F, (8.0F - var10) / 16.0F, 15.0F / 16.0F, 12.0F / 16.0F, (8.0F + var10) / 16.0F);
+		}
+
+	}
+
+	public void onBlockPlacedBy(World var1, int var2, int var3, int var4, EntityLiving var5, ItemStack var6) {
+		int var7 = ((MathHelper.floor_double((double)(var5.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3) + 0) % 4;
+		var1.setBlockMetadataWithNotify(var2, var3, var4, var7, 2);
+	}
+
+	public int onBlockPlaced(World var1, int var2, int var3, int var4, int var5, float var6, float var7, float var8, int var9) {
+		if(var5 == 1 || var5 == 0) {
+			var5 = 2;
+		}
+
+		return Direction.rotateOpposite[Direction.facingToDirection[var5]];
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+		if(!this.canBlockStay(var1, var2, var3, var4)) {
+			this.dropBlockAsItem(var1, var2, var3, var4, var1.getBlockMetadata(var2, var3, var4), 0);
+			var1.setBlockToAir(var2, var3, var4);
+		}
+
+	}
+
+	public static int func_72219_c(int var0) {
+		return (var0 & 12) >> 2;
+	}
+
+	public void dropBlockAsItemWithChance(World var1, int var2, int var3, int var4, int var5, float var6, int var7) {
+		int var8 = func_72219_c(var5);
+		byte var9 = 1;
+		if(var8 >= 2) {
+			var9 = 3;
+		}
+
+		for(int var10 = 0; var10 < var9; ++var10) {
+			this.dropBlockAsItem_do(var1, var2, var3, var4, new ItemStack(Item.dyePowder, 1, 3));
+		}
+
+	}
+
+	public int idPicked(World var1, int var2, int var3, int var4) {
+		return Item.dyePowder.itemID;
+	}
+
+	public int getDamageValue(World var1, int var2, int var3, int var4) {
+		return 3;
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.iconArray = new Icon[cocoaIcons.length];
+
+		for(int var2 = 0; var2 < this.iconArray.length; ++var2) {
+			this.iconArray[var2] = var1.registerIcon(cocoaIcons[var2]);
+		}
+
+	}
+}

src/net/minecraft/src/BlockCommandBlock.java

@@ -0,0 +1,68 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockCommandBlock extends BlockContainer {
+	public BlockCommandBlock(int var1) {
+		super(var1, Material.iron);
+	}
+
+	public TileEntity createNewTileEntity(World var1) {
+		return new TileEntityCommandBlock();
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+		if(!var1.isRemote) {
+			boolean var6 = var1.isBlockIndirectlyGettingPowered(var2, var3, var4);
+			int var7 = var1.getBlockMetadata(var2, var3, var4);
+			boolean var8 = (var7 & 1) != 0;
+			if(var6 && !var8) {
+				var1.setBlockMetadataWithNotify(var2, var3, var4, var7 | 1, 4);
+				var1.scheduleBlockUpdate(var2, var3, var4, this.blockID, this.tickRate(var1));
+			} else if(!var6 && var8) {
+				var1.setBlockMetadataWithNotify(var2, var3, var4, var7 & -2, 4);
+			}
+		}
+
+	}
+
+	public void updateTick(World var1, int var2, int var3, int var4, Random var5) {
+		TileEntity var6 = var1.getBlockTileEntity(var2, var3, var4);
+		if(var6 != null && var6 instanceof TileEntityCommandBlock) {
+			TileEntityCommandBlock var7 = (TileEntityCommandBlock)var6;
+			var7.func_96102_a(var7.executeCommandOnPowered(var1));
+			var1.func_96440_m(var2, var3, var4, this.blockID);
+		}
+
+	}
+
+	public int tickRate(World var1) {
+		return 1;
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		TileEntityCommandBlock var10 = (TileEntityCommandBlock)var1.getBlockTileEntity(var2, var3, var4);
+		if(var10 != null) {
+			var5.displayGUIEditSign(var10);
+		}
+
+		return true;
+	}
+
+	public boolean hasComparatorInputOverride() {
+		return true;
+	}
+
+	public int getComparatorInputOverride(World var1, int var2, int var3, int var4, int var5) {
+		TileEntity var6 = var1.getBlockTileEntity(var2, var3, var4);
+		return var6 != null && var6 instanceof TileEntityCommandBlock ? ((TileEntityCommandBlock)var6).func_96103_d() : 0;
+	}
+
+	public void onBlockPlacedBy(World var1, int var2, int var3, int var4, EntityLiving var5, ItemStack var6) {
+		TileEntityCommandBlock var7 = (TileEntityCommandBlock)var1.getBlockTileEntity(var2, var3, var4);
+		if(var6.hasDisplayName()) {
+			var7.setCommandSenderName(var6.getDisplayName());
+		}
+
+	}
+}

src/net/minecraft/src/BlockComparator.java

@@ -0,0 +1,174 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockComparator extends BlockRedstoneLogic implements ITileEntityProvider {
+	public BlockComparator(int var1, boolean var2) {
+		super(var1, var2);
+		this.isBlockContainer = true;
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		return Item.comparator.itemID;
+	}
+
+	public int idPicked(World var1, int var2, int var3, int var4) {
+		return Item.comparator.itemID;
+	}
+
+	protected int func_94481_j_(int var1) {
+		return 2;
+	}
+
+	protected BlockRedstoneLogic func_94485_e() {
+		return Block.redstoneComparatorActive;
+	}
+
+	protected BlockRedstoneLogic func_94484_i() {
+		return Block.redstoneComparatorIdle;
+	}
+
+	public int getRenderType() {
+		return 37;
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		boolean var3 = this.isRepeaterPowered || (var2 & 8) != 0;
+		return var1 == 0 ? (var3 ? Block.torchRedstoneActive.getBlockTextureFromSide(var1) : Block.torchRedstoneIdle.getBlockTextureFromSide(var1)) : (var1 == 1 ? (var3 ? Block.redstoneComparatorActive.blockIcon : this.blockIcon) : Block.stoneDoubleSlab.getBlockTextureFromSide(1));
+	}
+
+	protected boolean func_96470_c(int var1) {
+		return this.isRepeaterPowered || (var1 & 8) != 0;
+	}
+
+	protected int func_94480_d(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return this.getTileEntityComparator(var1, var2, var3, var4).func_96100_a();
+	}
+
+	private int func_94491_m(World var1, int var2, int var3, int var4, int var5) {
+		return !this.func_94490_c(var5) ? this.getInputStrength(var1, var2, var3, var4, var5) : Math.max(this.getInputStrength(var1, var2, var3, var4, var5) - this.func_94482_f(var1, var2, var3, var4, var5), 0);
+	}
+
+	public boolean func_94490_c(int var1) {
+		return (var1 & 4) == 4;
+	}
+
+	protected boolean func_94478_d(World var1, int var2, int var3, int var4, int var5) {
+		int var6 = this.getInputStrength(var1, var2, var3, var4, var5);
+		if(var6 >= 15) {
+			return true;
+		} else if(var6 == 0) {
+			return false;
+		} else {
+			int var7 = this.func_94482_f(var1, var2, var3, var4, var5);
+			return var7 == 0 ? true : var6 >= var7;
+		}
+	}
+
+	protected int getInputStrength(World var1, int var2, int var3, int var4, int var5) {
+		int var6 = super.getInputStrength(var1, var2, var3, var4, var5);
+		int var7 = getDirection(var5);
+		int var8 = var2 + Direction.offsetX[var7];
+		int var9 = var4 + Direction.offsetZ[var7];
+		int var10 = var1.getBlockId(var8, var3, var9);
+		if(var10 > 0) {
+			if(Block.blocksList[var10].hasComparatorInputOverride()) {
+				var6 = Block.blocksList[var10].getComparatorInputOverride(var1, var8, var3, var9, Direction.rotateOpposite[var7]);
+			} else if(var6 < 15 && Block.isNormalCube(var10)) {
+				var8 += Direction.offsetX[var7];
+				var9 += Direction.offsetZ[var7];
+				var10 = var1.getBlockId(var8, var3, var9);
+				if(var10 > 0 && Block.blocksList[var10].hasComparatorInputOverride()) {
+					var6 = Block.blocksList[var10].getComparatorInputOverride(var1, var8, var3, var9, Direction.rotateOpposite[var7]);
+				}
+			}
+		}
+
+		return var6;
+	}
+
+	public TileEntityComparator getTileEntityComparator(IBlockAccess var1, int var2, int var3, int var4) {
+		return (TileEntityComparator)var1.getBlockTileEntity(var2, var3, var4);
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		int var10 = var1.getBlockMetadata(var2, var3, var4);
+		boolean var11 = this.isRepeaterPowered | (var10 & 8) != 0;
+		boolean var12 = !this.func_94490_c(var10);
+		int var13 = var12 ? 4 : 0;
+		var13 |= var11 ? 8 : 0;
+		var1.playSoundEffect((double)var2 + 0.5D, (double)var3 + 0.5D, (double)var4 + 0.5D, "random.click", 0.3F, var12 ? 0.55F : 0.5F);
+		var1.setBlockMetadataWithNotify(var2, var3, var4, var13 | var10 & 3, 2);
+		this.func_96476_c(var1, var2, var3, var4, var1.rand);
+		return true;
+	}
+
+	protected void func_94479_f(World var1, int var2, int var3, int var4, int var5) {
+		if(!var1.isBlockTickScheduled(var2, var3, var4, this.blockID)) {
+			int var6 = var1.getBlockMetadata(var2, var3, var4);
+			int var7 = this.func_94491_m(var1, var2, var3, var4, var6);
+			int var8 = this.getTileEntityComparator(var1, var2, var3, var4).func_96100_a();
+			if(var7 != var8 || this.func_96470_c(var6) != this.func_94478_d(var1, var2, var3, var4, var6)) {
+				if(this.func_83011_d(var1, var2, var3, var4, var6)) {
+					var1.func_82740_a(var2, var3, var4, this.blockID, this.func_94481_j_(0), -1);
+				} else {
+					var1.func_82740_a(var2, var3, var4, this.blockID, this.func_94481_j_(0), 0);
+				}
+			}
+		}
+
+	}
+
+	private void func_96476_c(World var1, int var2, int var3, int var4, Random var5) {
+		int var6 = var1.getBlockMetadata(var2, var3, var4);
+		int var7 = this.func_94491_m(var1, var2, var3, var4, var6);
+		int var8 = this.getTileEntityComparator(var1, var2, var3, var4).func_96100_a();
+		this.getTileEntityComparator(var1, var2, var3, var4).func_96099_a(var7);
+		if(var8 != var7 || !this.func_94490_c(var6)) {
+			boolean var9 = this.func_94478_d(var1, var2, var3, var4, var6);
+			boolean var10 = this.isRepeaterPowered || (var6 & 8) != 0;
+			if(var10 && !var9) {
+				var1.setBlockMetadataWithNotify(var2, var3, var4, var6 & -9, 2);
+			} else if(!var10 && var9) {
+				var1.setBlockMetadataWithNotify(var2, var3, var4, var6 | 8, 2);
+			}
+
+			this.func_94483_i_(var1, var2, var3, var4);
+		}
+
+	}
+
+	public void updateTick(World var1, int var2, int var3, int var4, Random var5) {
+		if(this.isRepeaterPowered) {
+			int var6 = var1.getBlockMetadata(var2, var3, var4);
+			var1.setBlock(var2, var3, var4, this.func_94484_i().blockID, var6 | 8, 4);
+		}
+
+		this.func_96476_c(var1, var2, var3, var4, var5);
+	}
+
+	public void onBlockAdded(World var1, int var2, int var3, int var4) {
+		super.onBlockAdded(var1, var2, var3, var4);
+		var1.setBlockTileEntity(var2, var3, var4, this.createNewTileEntity(var1));
+	}
+
+	public void breakBlock(World var1, int var2, int var3, int var4, int var5, int var6) {
+		super.breakBlock(var1, var2, var3, var4, var5, var6);
+		var1.removeBlockTileEntity(var2, var3, var4);
+		this.func_94483_i_(var1, var2, var3, var4);
+	}
+
+	public boolean onBlockEventReceived(World var1, int var2, int var3, int var4, int var5, int var6) {
+		super.onBlockEventReceived(var1, var2, var3, var4, var5, var6);
+		TileEntity var7 = var1.getBlockTileEntity(var2, var3, var4);
+		return var7 != null ? var7.receiveClientEvent(var5, var6) : false;
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.blockIcon = var1.registerIcon(this.isRepeaterPowered ? "comparator_lit" : "comparator");
+	}
+
+	public TileEntity createNewTileEntity(World var1) {
+		return new TileEntityComparator();
+	}
+}

src/net/minecraft/src/BlockContainer.java

@@ -0,0 +1,23 @@
+package net.minecraft.src;
+
+public abstract class BlockContainer extends Block implements ITileEntityProvider {
+	protected BlockContainer(int var1, Material var2) {
+		super(var1, var2);
+		this.isBlockContainer = true;
+	}
+
+	public void onBlockAdded(World var1, int var2, int var3, int var4) {
+		super.onBlockAdded(var1, var2, var3, var4);
+	}
+
+	public void breakBlock(World var1, int var2, int var3, int var4, int var5, int var6) {
+		super.breakBlock(var1, var2, var3, var4, var5, var6);
+		var1.removeBlockTileEntity(var2, var3, var4);
+	}
+
+	public boolean onBlockEventReceived(World var1, int var2, int var3, int var4, int var5, int var6) {
+		super.onBlockEventReceived(var1, var2, var3, var4, var5, var6);
+		TileEntity var7 = var1.getBlockTileEntity(var2, var3, var4);
+		return var7 != null ? var7.receiveClientEvent(var5, var6) : false;
+	}
+}

src/net/minecraft/src/BlockCrops.java

@@ -0,0 +1,143 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockCrops extends BlockFlower {
+	private Icon[] iconArray;
+
+	protected BlockCrops(int var1) {
+		super(var1);
+		this.setTickRandomly(true);
+		float var2 = 0.5F;
+		this.setBlockBounds(0.5F - var2, 0.0F, 0.5F - var2, 0.5F + var2, 0.25F, 0.5F + var2);
+		this.setCreativeTab((CreativeTabs)null);
+		this.setHardness(0.0F);
+		this.setStepSound(soundGrassFootstep);
+		this.disableStats();
+	}
+
+	protected boolean canThisPlantGrowOnThisBlockID(int var1) {
+		return var1 == Block.tilledField.blockID;
+	}
+
+	public void updateTick(World var1, int var2, int var3, int var4, Random var5) {
+		super.updateTick(var1, var2, var3, var4, var5);
+		if(var1.getBlockLightValue(var2, var3 + 1, var4) >= 9) {
+			int var6 = var1.getBlockMetadata(var2, var3, var4);
+			if(var6 < 7) {
+				float var7 = this.getGrowthRate(var1, var2, var3, var4);
+				if(var5.nextInt((int)(25.0F / var7) + 1) == 0) {
+					++var6;
+					var1.setBlockMetadataWithNotify(var2, var3, var4, var6, 2);
+				}
+			}
+		}
+
+	}
+
+	public void fertilize(World var1, int var2, int var3, int var4) {
+		int var5 = var1.getBlockMetadata(var2, var3, var4) + MathHelper.getRandomIntegerInRange(var1.rand, 2, 5);
+		if(var5 > 7) {
+			var5 = 7;
+		}
+
+		var1.setBlockMetadataWithNotify(var2, var3, var4, var5, 2);
+	}
+
+	private float getGrowthRate(World var1, int var2, int var3, int var4) {
+		float var5 = 1.0F;
+		int var6 = var1.getBlockId(var2, var3, var4 - 1);
+		int var7 = var1.getBlockId(var2, var3, var4 + 1);
+		int var8 = var1.getBlockId(var2 - 1, var3, var4);
+		int var9 = var1.getBlockId(var2 + 1, var3, var4);
+		int var10 = var1.getBlockId(var2 - 1, var3, var4 - 1);
+		int var11 = var1.getBlockId(var2 + 1, var3, var4 - 1);
+		int var12 = var1.getBlockId(var2 + 1, var3, var4 + 1);
+		int var13 = var1.getBlockId(var2 - 1, var3, var4 + 1);
+		boolean var14 = var8 == this.blockID || var9 == this.blockID;
+		boolean var15 = var6 == this.blockID || var7 == this.blockID;
+		boolean var16 = var10 == this.blockID || var11 == this.blockID || var12 == this.blockID || var13 == this.blockID;
+
+		for(int var17 = var2 - 1; var17 <= var2 + 1; ++var17) {
+			for(int var18 = var4 - 1; var18 <= var4 + 1; ++var18) {
+				int var19 = var1.getBlockId(var17, var3 - 1, var18);
+				float var20 = 0.0F;
+				if(var19 == Block.tilledField.blockID) {
+					var20 = 1.0F;
+					if(var1.getBlockMetadata(var17, var3 - 1, var18) > 0) {
+						var20 = 3.0F;
+					}
+				}
+
+				if(var17 != var2 || var18 != var4) {
+					var20 /= 4.0F;
+				}
+
+				var5 += var20;
+			}
+		}
+
+		if(var16 || var14 && var15) {
+			var5 /= 2.0F;
+		}
+
+		return var5;
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		if(var2 < 0 || var2 > 7) {
+			var2 = 7;
+		}
+
+		return this.iconArray[var2];
+	}
+
+	public int getRenderType() {
+		return 6;
+	}
+
+	protected int getSeedItem() {
+		return Item.seeds.itemID;
+	}
+
+	protected int getCropItem() {
+		return Item.wheat.itemID;
+	}
+
+	public void dropBlockAsItemWithChance(World var1, int var2, int var3, int var4, int var5, float var6, int var7) {
+		super.dropBlockAsItemWithChance(var1, var2, var3, var4, var5, var6, 0);
+		if(!var1.isRemote) {
+			if(var5 >= 7) {
+				int var8 = 3 + var7;
+
+				for(int var9 = 0; var9 < var8; ++var9) {
+					if(var1.rand.nextInt(15) <= var5) {
+						this.dropBlockAsItem_do(var1, var2, var3, var4, new ItemStack(this.getSeedItem(), 1, 0));
+					}
+				}
+			}
+
+		}
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		return var1 == 7 ? this.getCropItem() : this.getSeedItem();
+	}
+
+	public int quantityDropped(Random var1) {
+		return 1;
+	}
+
+	public int idPicked(World var1, int var2, int var3, int var4) {
+		return this.getSeedItem();
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.iconArray = new Icon[8];
+
+		for(int var2 = 0; var2 < this.iconArray.length; ++var2) {
+			this.iconArray[var2] = var1.registerIcon("crops_" + var2);
+		}
+
+	}
+}

src/net/minecraft/src/BlockDaylightDetector.java

@@ -0,0 +1,82 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockDaylightDetector extends BlockContainer {
+	private Icon[] iconArray = new Icon[2];
+
+	public BlockDaylightDetector(int var1) {
+		super(var1, Material.wood);
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 6.0F / 16.0F, 1.0F);
+		this.setCreativeTab(CreativeTabs.tabRedstone);
+	}
+
+	public void setBlockBoundsBasedOnState(IBlockAccess var1, int var2, int var3, int var4) {
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 6.0F / 16.0F, 1.0F);
+	}
+
+	public int isProvidingWeakPower(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return var1.getBlockMetadata(var2, var3, var4);
+	}
+
+	public void updateTick(World var1, int var2, int var3, int var4, Random var5) {
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+	}
+
+	public void onBlockAdded(World var1, int var2, int var3, int var4) {
+	}
+
+	public void updateLightLevel(World var1, int var2, int var3, int var4) {
+		if(!var1.provider.hasNoSky) {
+			int var5 = var1.getBlockMetadata(var2, var3, var4);
+			int var6 = var1.getSavedLightValue(EnumSkyBlock.Sky, var2, var3, var4) - var1.skylightSubtracted;
+			float var7 = var1.getCelestialAngleRadians(1.0F);
+			if(var7 < (float)Math.PI) {
+				var7 += (0.0F - var7) * 0.2F;
+			} else {
+				var7 += ((float)Math.PI * 2.0F - var7) * 0.2F;
+			}
+
+			var6 = Math.round((float)var6 * MathHelper.cos(var7));
+			if(var6 < 0) {
+				var6 = 0;
+			}
+
+			if(var6 > 15) {
+				var6 = 15;
+			}
+
+			if(var5 != var6) {
+				var1.setBlockMetadataWithNotify(var2, var3, var4, var6, 3);
+			}
+
+		}
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean canProvidePower() {
+		return true;
+	}
+
+	public TileEntity createNewTileEntity(World var1) {
+		return new TileEntityDaylightDetector();
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return var1 == 1 ? this.iconArray[0] : this.iconArray[1];
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.iconArray[0] = var1.registerIcon("daylightDetector_top");
+		this.iconArray[1] = var1.registerIcon("daylightDetector_side");
+	}
+}

src/net/minecraft/src/BlockDeadBush.java

@@ -0,0 +1,29 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockDeadBush extends BlockFlower {
+	protected BlockDeadBush(int var1) {
+		super(var1, Material.vine);
+		float var2 = 0.4F;
+		this.setBlockBounds(0.5F - var2, 0.0F, 0.5F - var2, 0.5F + var2, 0.8F, 0.5F + var2);
+	}
+
+	protected boolean canThisPlantGrowOnThisBlockID(int var1) {
+		return var1 == Block.sand.blockID;
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		return -1;
+	}
+
+	public void harvestBlock(World var1, EntityPlayer var2, int var3, int var4, int var5, int var6) {
+		if(!var1.isRemote && var2.getCurrentEquippedItem() != null && var2.getCurrentEquippedItem().itemID == Item.shears.itemID) {
+			var2.addStat(StatList.mineBlockStatArray[this.blockID], 1);
+			this.dropBlockAsItem_do(var1, var3, var4, var5, new ItemStack(Block.deadBush, 1, var6));
+		} else {
+			super.harvestBlock(var1, var2, var3, var4, var5, var6);
+		}
+
+	}
+}

src/net/minecraft/src/BlockDetectorRail.java

@@ -0,0 +1,108 @@
+package net.minecraft.src;
+
+import java.util.List;
+import java.util.Random;
+
+public class BlockDetectorRail extends BlockRailBase {
+	private Icon[] iconArray;
+
+	public BlockDetectorRail(int var1) {
+		super(var1, true);
+		this.setTickRandomly(true);
+	}
+
+	public int tickRate(World var1) {
+		return 20;
+	}
+
+	public boolean canProvidePower() {
+		return true;
+	}
+
+	public void onEntityCollidedWithBlock(World var1, int var2, int var3, int var4, Entity var5) {
+		if(!var1.isRemote) {
+			int var6 = var1.getBlockMetadata(var2, var3, var4);
+			if((var6 & 8) == 0) {
+				this.setStateIfMinecartInteractsWithRail(var1, var2, var3, var4, var6);
+			}
+		}
+	}
+
+	public void updateTick(World var1, int var2, int var3, int var4, Random var5) {
+		if(!var1.isRemote) {
+			int var6 = var1.getBlockMetadata(var2, var3, var4);
+			if((var6 & 8) != 0) {
+				this.setStateIfMinecartInteractsWithRail(var1, var2, var3, var4, var6);
+			}
+		}
+	}
+
+	public int isProvidingWeakPower(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return (var1.getBlockMetadata(var2, var3, var4) & 8) != 0 ? 15 : 0;
+	}
+
+	public int isProvidingStrongPower(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return (var1.getBlockMetadata(var2, var3, var4) & 8) == 0 ? 0 : (var5 == 1 ? 15 : 0);
+	}
+
+	private void setStateIfMinecartInteractsWithRail(World var1, int var2, int var3, int var4, int var5) {
+		boolean var6 = (var5 & 8) != 0;
+		boolean var7 = false;
+		float var8 = 2.0F / 16.0F;
+		List var9 = var1.getEntitiesWithinAABB(EntityMinecart.class, AxisAlignedBB.getAABBPool().getAABB((double)((float)var2 + var8), (double)var3, (double)((float)var4 + var8), (double)((float)(var2 + 1) - var8), (double)((float)(var3 + 1) - var8), (double)((float)(var4 + 1) - var8)));
+		if(!var9.isEmpty()) {
+			var7 = true;
+		}
+
+		if(var7 && !var6) {
+			var1.setBlockMetadataWithNotify(var2, var3, var4, var5 | 8, 3);
+			var1.notifyBlocksOfNeighborChange(var2, var3, var4, this.blockID);
+			var1.notifyBlocksOfNeighborChange(var2, var3 - 1, var4, this.blockID);
+			var1.markBlockRangeForRenderUpdate(var2, var3, var4, var2, var3, var4);
+		}
+
+		if(!var7 && var6) {
+			var1.setBlockMetadataWithNotify(var2, var3, var4, var5 & 7, 3);
+			var1.notifyBlocksOfNeighborChange(var2, var3, var4, this.blockID);
+			var1.notifyBlocksOfNeighborChange(var2, var3 - 1, var4, this.blockID);
+			var1.markBlockRangeForRenderUpdate(var2, var3, var4, var2, var3, var4);
+		}
+
+		if(var7) {
+			var1.scheduleBlockUpdate(var2, var3, var4, this.blockID, this.tickRate(var1));
+		}
+
+		var1.func_96440_m(var2, var3, var4, this.blockID);
+	}
+
+	public void onBlockAdded(World var1, int var2, int var3, int var4) {
+		super.onBlockAdded(var1, var2, var3, var4);
+		this.setStateIfMinecartInteractsWithRail(var1, var2, var3, var4, var1.getBlockMetadata(var2, var3, var4));
+	}
+
+	public boolean hasComparatorInputOverride() {
+		return true;
+	}
+
+	public int getComparatorInputOverride(World var1, int var2, int var3, int var4, int var5) {
+		if((var1.getBlockMetadata(var2, var3, var4) & 8) > 0) {
+			float var6 = 2.0F / 16.0F;
+			List var7 = var1.selectEntitiesWithinAABB(EntityMinecart.class, AxisAlignedBB.getAABBPool().getAABB((double)((float)var2 + var6), (double)var3, (double)((float)var4 + var6), (double)((float)(var2 + 1) - var6), (double)((float)(var3 + 1) - var6), (double)((float)(var4 + 1) - var6)), IEntitySelector.selectInventories);
+			if(var7.size() > 0) {
+				return Container.calcRedstoneFromInventory((IInventory)var7.get(0));
+			}
+		}
+
+		return 0;
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.iconArray = new Icon[2];
+		this.iconArray[0] = var1.registerIcon("detectorRail");
+		this.iconArray[1] = var1.registerIcon("detectorRail_on");
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return (var2 & 8) != 0 ? this.iconArray[1] : this.iconArray[0];
+	}
+}

src/net/minecraft/src/BlockDirectional.java

@@ -0,0 +1,11 @@
+package net.minecraft.src;
+
+public abstract class BlockDirectional extends Block {
+	protected BlockDirectional(int var1, Material var2) {
+		super(var1, var2);
+	}
+
+	public static int getDirection(int var0) {
+		return var0 & 3;
+	}
+}

src/net/minecraft/src/BlockDirt.java

@@ -0,0 +1,8 @@
+package net.minecraft.src;
+
+public class BlockDirt extends Block {
+	protected BlockDirt(int var1) {
+		super(var1, Material.ground);
+		this.setCreativeTab(CreativeTabs.tabBlock);
+	}
+}

src/net/minecraft/src/BlockDispenser.java

@@ -0,0 +1,190 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockDispenser extends BlockContainer {
+	public static final IRegistry dispenseBehaviorRegistry = new RegistryDefaulted(new BehaviorDefaultDispenseItem());
+	protected Random random = new Random();
+	protected Icon furnaceTopIcon;
+	protected Icon furnaceFrontIcon;
+	protected Icon field_96473_e;
+
+	protected BlockDispenser(int var1) {
+		super(var1, Material.rock);
+		this.setCreativeTab(CreativeTabs.tabRedstone);
+	}
+
+	public int tickRate(World var1) {
+		return 4;
+	}
+
+	public void onBlockAdded(World var1, int var2, int var3, int var4) {
+		super.onBlockAdded(var1, var2, var3, var4);
+		this.setDispenserDefaultDirection(var1, var2, var3, var4);
+	}
+
+	private void setDispenserDefaultDirection(World var1, int var2, int var3, int var4) {
+		if(!var1.isRemote) {
+			int var5 = var1.getBlockId(var2, var3, var4 - 1);
+			int var6 = var1.getBlockId(var2, var3, var4 + 1);
+			int var7 = var1.getBlockId(var2 - 1, var3, var4);
+			int var8 = var1.getBlockId(var2 + 1, var3, var4);
+			byte var9 = 3;
+			if(Block.opaqueCubeLookup[var5] && !Block.opaqueCubeLookup[var6]) {
+				var9 = 3;
+			}
+
+			if(Block.opaqueCubeLookup[var6] && !Block.opaqueCubeLookup[var5]) {
+				var9 = 2;
+			}
+
+			if(Block.opaqueCubeLookup[var7] && !Block.opaqueCubeLookup[var8]) {
+				var9 = 5;
+			}
+
+			if(Block.opaqueCubeLookup[var8] && !Block.opaqueCubeLookup[var7]) {
+				var9 = 4;
+			}
+
+			var1.setBlockMetadataWithNotify(var2, var3, var4, var9, 2);
+		}
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		int var3 = var2 & 7;
+		return var1 == var3 ? (var3 != 1 && var3 != 0 ? this.furnaceFrontIcon : this.field_96473_e) : (var3 != 1 && var3 != 0 ? (var1 != 1 && var1 != 0 ? this.blockIcon : this.furnaceTopIcon) : this.furnaceTopIcon);
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.blockIcon = var1.registerIcon("furnace_side");
+		this.furnaceTopIcon = var1.registerIcon("furnace_top");
+		this.furnaceFrontIcon = var1.registerIcon("dispenser_front");
+		this.field_96473_e = var1.registerIcon("dispenser_front_vertical");
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		if(var1.isRemote) {
+			return true;
+		} else {
+			TileEntityDispenser var10 = (TileEntityDispenser)var1.getBlockTileEntity(var2, var3, var4);
+			if(var10 != null) {
+				var5.displayGUIDispenser(var10);
+			}
+
+			return true;
+		}
+	}
+
+	protected void dispense(World var1, int var2, int var3, int var4) {
+		BlockSourceImpl var5 = new BlockSourceImpl(var1, var2, var3, var4);
+		TileEntityDispenser var6 = (TileEntityDispenser)var5.getBlockTileEntity();
+		if(var6 != null) {
+			int var7 = var6.getRandomStackFromInventory();
+			if(var7 < 0) {
+				var1.playAuxSFX(1001, var2, var3, var4, 0);
+			} else {
+				ItemStack var8 = var6.getStackInSlot(var7);
+				IBehaviorDispenseItem var9 = this.getBehaviorForItemStack(var8);
+				if(var9 != IBehaviorDispenseItem.itemDispenseBehaviorProvider) {
+					ItemStack var10 = var9.dispense(var5, var8);
+					var6.setInventorySlotContents(var7, var10.stackSize == 0 ? null : var10);
+				}
+			}
+
+		}
+	}
+
+	protected IBehaviorDispenseItem getBehaviorForItemStack(ItemStack var1) {
+		return (IBehaviorDispenseItem)dispenseBehaviorRegistry.func_82594_a(var1.getItem());
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+		boolean var6 = var1.isBlockIndirectlyGettingPowered(var2, var3, var4) || var1.isBlockIndirectlyGettingPowered(var2, var3 + 1, var4);
+		int var7 = var1.getBlockMetadata(var2, var3, var4);
+		boolean var8 = (var7 & 8) != 0;
+		if(var6 && !var8) {
+			var1.scheduleBlockUpdate(var2, var3, var4, this.blockID, this.tickRate(var1));
+			var1.setBlockMetadataWithNotify(var2, var3, var4, var7 | 8, 4);
+		} else if(!var6 && var8) {
+			var1.setBlockMetadataWithNotify(var2, var3, var4, var7 & -9, 4);
+		}
+
+	}
+
+	public void updateTick(World var1, int var2, int var3, int var4, Random var5) {
+		if(!var1.isRemote) {
+			this.dispense(var1, var2, var3, var4);
+		}
+
+	}
+
+	public TileEntity createNewTileEntity(World var1) {
+		return new TileEntityDispenser();
+	}
+
+	public void onBlockPlacedBy(World var1, int var2, int var3, int var4, EntityLiving var5, ItemStack var6) {
+		int var7 = BlockPistonBase.determineOrientation(var1, var2, var3, var4, var5);
+		var1.setBlockMetadataWithNotify(var2, var3, var4, var7, 2);
+		if(var6.hasDisplayName()) {
+			((TileEntityDispenser)var1.getBlockTileEntity(var2, var3, var4)).setCustomName(var6.getDisplayName());
+		}
+
+	}
+
+	public void breakBlock(World var1, int var2, int var3, int var4, int var5, int var6) {
+		TileEntityDispenser var7 = (TileEntityDispenser)var1.getBlockTileEntity(var2, var3, var4);
+		if(var7 != null) {
+			for(int var8 = 0; var8 < var7.getSizeInventory(); ++var8) {
+				ItemStack var9 = var7.getStackInSlot(var8);
+				if(var9 != null) {
+					float var10 = this.random.nextFloat() * 0.8F + 0.1F;
+					float var11 = this.random.nextFloat() * 0.8F + 0.1F;
+					float var12 = this.random.nextFloat() * 0.8F + 0.1F;
+
+					while(var9.stackSize > 0) {
+						int var13 = this.random.nextInt(21) + 10;
+						if(var13 > var9.stackSize) {
+							var13 = var9.stackSize;
+						}
+
+						var9.stackSize -= var13;
+						EntityItem var14 = new EntityItem(var1, (double)((float)var2 + var10), (double)((float)var3 + var11), (double)((float)var4 + var12), new ItemStack(var9.itemID, var13, var9.getItemDamage()));
+						if(var9.hasTagCompound()) {
+							var14.getEntityItem().setTagCompound((NBTTagCompound)var9.getTagCompound().copy());
+						}
+
+						float var15 = 0.05F;
+						var14.motionX = (double)((float)this.random.nextGaussian() * var15);
+						var14.motionY = (double)((float)this.random.nextGaussian() * var15 + 0.2F);
+						var14.motionZ = (double)((float)this.random.nextGaussian() * var15);
+						var1.spawnEntityInWorld(var14);
+					}
+				}
+			}
+
+			var1.func_96440_m(var2, var3, var4, var5);
+		}
+
+		super.breakBlock(var1, var2, var3, var4, var5, var6);
+	}
+
+	public static IPosition getIPositionFromBlockSource(IBlockSource var0) {
+		EnumFacing var1 = getFacing(var0.getBlockMetadata());
+		double var2 = var0.getX() + 0.7D * (double)var1.getFrontOffsetX();
+		double var4 = var0.getY() + 0.7D * (double)var1.getFrontOffsetY();
+		double var6 = var0.getZ() + 0.7D * (double)var1.getFrontOffsetZ();
+		return new PositionImpl(var2, var4, var6);
+	}
+
+	public static EnumFacing getFacing(int var0) {
+		return EnumFacing.getFront(var0 & 7);
+	}
+
+	public boolean hasComparatorInputOverride() {
+		return true;
+	}
+
+	public int getComparatorInputOverride(World var1, int var2, int var3, int var4, int var5) {
+		return Container.calcRedstoneFromInventory((IInventory)var1.getBlockTileEntity(var2, var3, var4));
+	}
+}

src/net/minecraft/src/BlockDoor.java

@@ -0,0 +1,289 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockDoor extends Block {
+	private static final String[] doorIconNames = new String[]{"doorWood_lower", "doorWood_upper", "doorIron_lower", "doorIron_upper"};
+	private final int doorTypeForIcon;
+	private Icon[] iconArray;
+
+	protected BlockDoor(int var1, Material var2) {
+		super(var1, var2);
+		if(var2 == Material.iron) {
+			this.doorTypeForIcon = 2;
+		} else {
+			this.doorTypeForIcon = 0;
+		}
+
+		float var3 = 0.5F;
+		float var4 = 1.0F;
+		this.setBlockBounds(0.5F - var3, 0.0F, 0.5F - var3, 0.5F + var3, var4, 0.5F + var3);
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return this.iconArray[this.doorTypeForIcon];
+	}
+
+	public Icon getBlockTexture(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		if(var5 != 1 && var5 != 0) {
+			int var6 = this.getFullMetadata(var1, var2, var3, var4);
+			int var7 = var6 & 3;
+			boolean var8 = (var6 & 4) != 0;
+			boolean var9 = false;
+			boolean var10 = (var6 & 8) != 0;
+			if(var8) {
+				if(var7 == 0 && var5 == 2) {
+					var9 = !var9;
+				} else if(var7 == 1 && var5 == 5) {
+					var9 = !var9;
+				} else if(var7 == 2 && var5 == 3) {
+					var9 = !var9;
+				} else if(var7 == 3 && var5 == 4) {
+					var9 = !var9;
+				}
+			} else {
+				if(var7 == 0 && var5 == 5) {
+					var9 = !var9;
+				} else if(var7 == 1 && var5 == 3) {
+					var9 = !var9;
+				} else if(var7 == 2 && var5 == 4) {
+					var9 = !var9;
+				} else if(var7 == 3 && var5 == 2) {
+					var9 = !var9;
+				}
+
+				if((var6 & 16) != 0) {
+					var9 = !var9;
+				}
+			}
+
+			return this.iconArray[this.doorTypeForIcon + (var9 ? doorIconNames.length : 0) + (var10 ? 1 : 0)];
+		} else {
+			return this.iconArray[this.doorTypeForIcon];
+		}
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.iconArray = new Icon[doorIconNames.length * 2];
+
+		for(int var2 = 0; var2 < doorIconNames.length; ++var2) {
+			this.iconArray[var2] = var1.registerIcon(doorIconNames[var2]);
+			this.iconArray[var2 + doorIconNames.length] = new IconFlipped(this.iconArray[var2], true, false);
+		}
+
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean getBlocksMovement(IBlockAccess var1, int var2, int var3, int var4) {
+		int var5 = this.getFullMetadata(var1, var2, var3, var4);
+		return (var5 & 4) != 0;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public int getRenderType() {
+		return 7;
+	}
+
+	public AxisAlignedBB getSelectedBoundingBoxFromPool(World var1, int var2, int var3, int var4) {
+		this.setBlockBoundsBasedOnState(var1, var2, var3, var4);
+		return super.getSelectedBoundingBoxFromPool(var1, var2, var3, var4);
+	}
+
+	public AxisAlignedBB getCollisionBoundingBoxFromPool(World var1, int var2, int var3, int var4) {
+		this.setBlockBoundsBasedOnState(var1, var2, var3, var4);
+		return super.getCollisionBoundingBoxFromPool(var1, var2, var3, var4);
+	}
+
+	public void setBlockBoundsBasedOnState(IBlockAccess var1, int var2, int var3, int var4) {
+		this.setDoorRotation(this.getFullMetadata(var1, var2, var3, var4));
+	}
+
+	public int getDoorOrientation(IBlockAccess var1, int var2, int var3, int var4) {
+		return this.getFullMetadata(var1, var2, var3, var4) & 3;
+	}
+
+	public boolean isDoorOpen(IBlockAccess var1, int var2, int var3, int var4) {
+		return (this.getFullMetadata(var1, var2, var3, var4) & 4) != 0;
+	}
+
+	private void setDoorRotation(int var1) {
+		float var2 = 3.0F / 16.0F;
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 2.0F, 1.0F);
+		int var3 = var1 & 3;
+		boolean var4 = (var1 & 4) != 0;
+		boolean var5 = (var1 & 16) != 0;
+		if(var3 == 0) {
+			if(var4) {
+				if(!var5) {
+					this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, var2);
+				} else {
+					this.setBlockBounds(0.0F, 0.0F, 1.0F - var2, 1.0F, 1.0F, 1.0F);
+				}
+			} else {
+				this.setBlockBounds(0.0F, 0.0F, 0.0F, var2, 1.0F, 1.0F);
+			}
+		} else if(var3 == 1) {
+			if(var4) {
+				if(!var5) {
+					this.setBlockBounds(1.0F - var2, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
+				} else {
+					this.setBlockBounds(0.0F, 0.0F, 0.0F, var2, 1.0F, 1.0F);
+				}
+			} else {
+				this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, var2);
+			}
+		} else if(var3 == 2) {
+			if(var4) {
+				if(!var5) {
+					this.setBlockBounds(0.0F, 0.0F, 1.0F - var2, 1.0F, 1.0F, 1.0F);
+				} else {
+					this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, var2);
+				}
+			} else {
+				this.setBlockBounds(1.0F - var2, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
+			}
+		} else if(var3 == 3) {
+			if(var4) {
+				if(!var5) {
+					this.setBlockBounds(0.0F, 0.0F, 0.0F, var2, 1.0F, 1.0F);
+				} else {
+					this.setBlockBounds(1.0F - var2, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
+				}
+			} else {
+				this.setBlockBounds(0.0F, 0.0F, 1.0F - var2, 1.0F, 1.0F, 1.0F);
+			}
+		}
+
+	}
+
+	public void onBlockClicked(World var1, int var2, int var3, int var4, EntityPlayer var5) {
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		if(this.blockMaterial == Material.iron) {
+			return true;
+		} else {
+			int var10 = this.getFullMetadata(var1, var2, var3, var4);
+			int var11 = var10 & 7;
+			var11 ^= 4;
+			if((var10 & 8) == 0) {
+				var1.setBlockMetadataWithNotify(var2, var3, var4, var11, 2);
+				var1.markBlockRangeForRenderUpdate(var2, var3, var4, var2, var3, var4);
+			} else {
+				var1.setBlockMetadataWithNotify(var2, var3 - 1, var4, var11, 2);
+				var1.markBlockRangeForRenderUpdate(var2, var3 - 1, var4, var2, var3, var4);
+			}
+
+			var1.playAuxSFXAtEntity(var5, 1003, var2, var3, var4, 0);
+			return true;
+		}
+	}
+
+	public void onPoweredBlockChange(World var1, int var2, int var3, int var4, boolean var5) {
+		int var6 = this.getFullMetadata(var1, var2, var3, var4);
+		boolean var7 = (var6 & 4) != 0;
+		if(var7 != var5) {
+			int var8 = var6 & 7;
+			var8 ^= 4;
+			if((var6 & 8) == 0) {
+				var1.setBlockMetadataWithNotify(var2, var3, var4, var8, 2);
+				var1.markBlockRangeForRenderUpdate(var2, var3, var4, var2, var3, var4);
+			} else {
+				var1.setBlockMetadataWithNotify(var2, var3 - 1, var4, var8, 2);
+				var1.markBlockRangeForRenderUpdate(var2, var3 - 1, var4, var2, var3, var4);
+			}
+
+			var1.playAuxSFXAtEntity((EntityPlayer)null, 1003, var2, var3, var4, 0);
+		}
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+		int var6 = var1.getBlockMetadata(var2, var3, var4);
+		if((var6 & 8) == 0) {
+			boolean var7 = false;
+			if(var1.getBlockId(var2, var3 + 1, var4) != this.blockID) {
+				var1.setBlockToAir(var2, var3, var4);
+				var7 = true;
+			}
+
+			if(!var1.doesBlockHaveSolidTopSurface(var2, var3 - 1, var4)) {
+				var1.setBlockToAir(var2, var3, var4);
+				var7 = true;
+				if(var1.getBlockId(var2, var3 + 1, var4) == this.blockID) {
+					var1.setBlockToAir(var2, var3 + 1, var4);
+				}
+			}
+
+			if(var7) {
+				if(!var1.isRemote) {
+					this.dropBlockAsItem(var1, var2, var3, var4, var6, 0);
+				}
+			} else {
+				boolean var8 = var1.isBlockIndirectlyGettingPowered(var2, var3, var4) || var1.isBlockIndirectlyGettingPowered(var2, var3 + 1, var4);
+				if((var8 || var5 > 0 && Block.blocksList[var5].canProvidePower()) && var5 != this.blockID) {
+					this.onPoweredBlockChange(var1, var2, var3, var4, var8);
+				}
+			}
+		} else {
+			if(var1.getBlockId(var2, var3 - 1, var4) != this.blockID) {
+				var1.setBlockToAir(var2, var3, var4);
+			}
+
+			if(var5 > 0 && var5 != this.blockID) {
+				this.onNeighborBlockChange(var1, var2, var3 - 1, var4, var5);
+			}
+		}
+
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		return (var1 & 8) != 0 ? 0 : (this.blockMaterial == Material.iron ? Item.doorIron.itemID : Item.doorWood.itemID);
+	}
+
+	public MovingObjectPosition collisionRayTrace(World var1, int var2, int var3, int var4, Vec3 var5, Vec3 var6) {
+		this.setBlockBoundsBasedOnState(var1, var2, var3, var4);
+		return super.collisionRayTrace(var1, var2, var3, var4, var5, var6);
+	}
+
+	public boolean canPlaceBlockAt(World var1, int var2, int var3, int var4) {
+		return var3 >= 255 ? false : var1.doesBlockHaveSolidTopSurface(var2, var3 - 1, var4) && super.canPlaceBlockAt(var1, var2, var3, var4) && super.canPlaceBlockAt(var1, var2, var3 + 1, var4);
+	}
+
+	public int getMobilityFlag() {
+		return 1;
+	}
+
+	public int getFullMetadata(IBlockAccess var1, int var2, int var3, int var4) {
+		int var5 = var1.getBlockMetadata(var2, var3, var4);
+		boolean var6 = (var5 & 8) != 0;
+		int var7;
+		int var8;
+		if(var6) {
+			var7 = var1.getBlockMetadata(var2, var3 - 1, var4);
+			var8 = var5;
+		} else {
+			var7 = var5;
+			var8 = var1.getBlockMetadata(var2, var3 + 1, var4);
+		}
+
+		boolean var9 = (var8 & 1) != 0;
+		return var7 & 7 | (var6 ? 8 : 0) | (var9 ? 16 : 0);
+	}
+
+	public int idPicked(World var1, int var2, int var3, int var4) {
+		return this.blockMaterial == Material.iron ? Item.doorIron.itemID : Item.doorWood.itemID;
+	}
+
+	public void onBlockHarvested(World var1, int var2, int var3, int var4, int var5, EntityPlayer var6) {
+		if(var6.capabilities.isCreativeMode && (var5 & 8) != 0 && var1.getBlockId(var2, var3 - 1, var4) == this.blockID) {
+			var1.setBlockToAir(var2, var3 - 1, var4);
+		}
+
+	}
+}

src/net/minecraft/src/BlockDragonEgg.java

@@ -0,0 +1,108 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockDragonEgg extends Block {
+	public BlockDragonEgg(int var1) {
+		super(var1, Material.dragonEgg);
+		this.setBlockBounds(1.0F / 16.0F, 0.0F, 1.0F / 16.0F, 15.0F / 16.0F, 1.0F, 15.0F / 16.0F);
+	}
+
+	public void onBlockAdded(World var1, int var2, int var3, int var4) {
+		var1.scheduleBlockUpdate(var2, var3, var4, this.blockID, this.tickRate(var1));
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+		var1.scheduleBlockUpdate(var2, var3, var4, this.blockID, this.tickRate(var1));
+	}
+
+	public void updateTick(World var1, int var2, int var3, int var4, Random var5) {
+		this.fallIfPossible(var1, var2, var3, var4);
+	}
+
+	private void fallIfPossible(World var1, int var2, int var3, int var4) {
+		if(BlockSand.canFallBelow(var1, var2, var3 - 1, var4) && var3 >= 0) {
+			byte var5 = 32;
+			if(!BlockSand.fallInstantly && var1.checkChunksExist(var2 - var5, var3 - var5, var4 - var5, var2 + var5, var3 + var5, var4 + var5)) {
+				EntityFallingSand var6 = new EntityFallingSand(var1, (double)((float)var2 + 0.5F), (double)((float)var3 + 0.5F), (double)((float)var4 + 0.5F), this.blockID);
+				var1.spawnEntityInWorld(var6);
+			} else {
+				var1.setBlockToAir(var2, var3, var4);
+
+				while(BlockSand.canFallBelow(var1, var2, var3 - 1, var4) && var3 > 0) {
+					--var3;
+				}
+
+				if(var3 > 0) {
+					var1.setBlock(var2, var3, var4, this.blockID, 0, 2);
+				}
+			}
+		}
+
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		this.teleportNearby(var1, var2, var3, var4);
+		return true;
+	}
+
+	public void onBlockClicked(World var1, int var2, int var3, int var4, EntityPlayer var5) {
+		this.teleportNearby(var1, var2, var3, var4);
+	}
+
+	private void teleportNearby(World var1, int var2, int var3, int var4) {
+		if(var1.getBlockId(var2, var3, var4) == this.blockID) {
+			for(int var5 = 0; var5 < 1000; ++var5) {
+				int var6 = var2 + var1.rand.nextInt(16) - var1.rand.nextInt(16);
+				int var7 = var3 + var1.rand.nextInt(8) - var1.rand.nextInt(8);
+				int var8 = var4 + var1.rand.nextInt(16) - var1.rand.nextInt(16);
+				if(var1.getBlockId(var6, var7, var8) == 0) {
+					if(!var1.isRemote) {
+						var1.setBlock(var6, var7, var8, this.blockID, var1.getBlockMetadata(var2, var3, var4), 2);
+						var1.setBlockToAir(var2, var3, var4);
+					} else {
+						short var9 = 128;
+
+						for(int var10 = 0; var10 < var9; ++var10) {
+							double var11 = var1.rand.nextDouble();
+							float var13 = (var1.rand.nextFloat() - 0.5F) * 0.2F;
+							float var14 = (var1.rand.nextFloat() - 0.5F) * 0.2F;
+							float var15 = (var1.rand.nextFloat() - 0.5F) * 0.2F;
+							double var16 = (double)var6 + (double)(var2 - var6) * var11 + (var1.rand.nextDouble() - 0.5D) * 1.0D + 0.5D;
+							double var18 = (double)var7 + (double)(var3 - var7) * var11 + var1.rand.nextDouble() * 1.0D - 0.5D;
+							double var20 = (double)var8 + (double)(var4 - var8) * var11 + (var1.rand.nextDouble() - 0.5D) * 1.0D + 0.5D;
+							var1.spawnParticle("portal", var16, var18, var20, (double)var13, (double)var14, (double)var15);
+						}
+					}
+
+					return;
+				}
+			}
+
+		}
+	}
+
+	public int tickRate(World var1) {
+		return 5;
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public boolean shouldSideBeRendered(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return true;
+	}
+
+	public int getRenderType() {
+		return 27;
+	}
+
+	public int idPicked(World var1, int var2, int var3, int var4) {
+		return 0;
+	}
+}

src/net/minecraft/src/BlockDropper.java

@@ -0,0 +1,59 @@
+package net.minecraft.src;
+
+public class BlockDropper extends BlockDispenser {
+	private final IBehaviorDispenseItem dropperDefaultBehaviour = new BehaviorDefaultDispenseItem();
+
+	protected BlockDropper(int var1) {
+		super(var1);
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.blockIcon = var1.registerIcon("furnace_side");
+		this.furnaceTopIcon = var1.registerIcon("furnace_top");
+		this.furnaceFrontIcon = var1.registerIcon("dropper_front");
+		this.field_96473_e = var1.registerIcon("dropper_front_vertical");
+	}
+
+	protected IBehaviorDispenseItem getBehaviorForItemStack(ItemStack var1) {
+		return this.dropperDefaultBehaviour;
+	}
+
+	public TileEntity createNewTileEntity(World var1) {
+		return new TileEntityDropper();
+	}
+
+	protected void dispense(World var1, int var2, int var3, int var4) {
+		BlockSourceImpl var5 = new BlockSourceImpl(var1, var2, var3, var4);
+		TileEntityDispenser var6 = (TileEntityDispenser)var5.getBlockTileEntity();
+		if(var6 != null) {
+			int var7 = var6.getRandomStackFromInventory();
+			if(var7 < 0) {
+				var1.playAuxSFX(1001, var2, var3, var4, 0);
+			} else {
+				ItemStack var8 = var6.getStackInSlot(var7);
+				int var9 = var1.getBlockMetadata(var2, var3, var4) & 7;
+				IInventory var10 = TileEntityHopper.getInventoryAtLocation(var1, (double)(var2 + Facing.offsetsXForSide[var9]), (double)(var3 + Facing.offsetsYForSide[var9]), (double)(var4 + Facing.offsetsZForSide[var9]));
+				ItemStack var11;
+				if(var10 != null) {
+					var11 = TileEntityHopper.insertStack(var10, var8.copy().splitStack(1), Facing.oppositeSide[var9]);
+					if(var11 == null) {
+						var11 = var8.copy();
+						if(--var11.stackSize == 0) {
+							var11 = null;
+						}
+					} else {
+						var11 = var8.copy();
+					}
+				} else {
+					var11 = this.dropperDefaultBehaviour.dispense(var5, var8);
+					if(var11 != null && var11.stackSize == 0) {
+						var11 = null;
+					}
+				}
+
+				var6.setInventorySlotContents(var7, var11);
+			}
+
+		}
+	}
+}

src/net/minecraft/src/BlockEnchantmentTable.java

@@ -0,0 +1,80 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockEnchantmentTable extends BlockContainer {
+	private Icon field_94461_a;
+	private Icon field_94460_b;
+
+	protected BlockEnchantmentTable(int var1) {
+		super(var1, Material.rock);
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 12.0F / 16.0F, 1.0F);
+		this.setLightOpacity(0);
+		this.setCreativeTab(CreativeTabs.tabDecorations);
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public void randomDisplayTick(World var1, int var2, int var3, int var4, Random var5) {
+		super.randomDisplayTick(var1, var2, var3, var4, var5);
+
+		for(int var6 = var2 - 2; var6 <= var2 + 2; ++var6) {
+			for(int var7 = var4 - 2; var7 <= var4 + 2; ++var7) {
+				if(var6 > var2 - 2 && var6 < var2 + 2 && var7 == var4 - 1) {
+					var7 = var4 + 2;
+				}
+
+				if(var5.nextInt(16) == 0) {
+					for(int var8 = var3; var8 <= var3 + 1; ++var8) {
+						if(var1.getBlockId(var6, var8, var7) == Block.bookShelf.blockID) {
+							if(!var1.isAirBlock((var6 - var2) / 2 + var2, var8, (var7 - var4) / 2 + var4)) {
+								break;
+							}
+
+							var1.spawnParticle("enchantmenttable", (double)var2 + 0.5D, (double)var3 + 2.0D, (double)var4 + 0.5D, (double)((float)(var6 - var2) + var5.nextFloat()) - 0.5D, (double)((float)(var8 - var3) - var5.nextFloat() - 1.0F), (double)((float)(var7 - var4) + var5.nextFloat()) - 0.5D);
+						}
+					}
+				}
+			}
+		}
+
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return var1 == 0 ? this.field_94460_b : (var1 == 1 ? this.field_94461_a : this.blockIcon);
+	}
+
+	public TileEntity createNewTileEntity(World var1) {
+		return new TileEntityEnchantmentTable();
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		if(var1.isRemote) {
+			return true;
+		} else {
+			TileEntityEnchantmentTable var10 = (TileEntityEnchantmentTable)var1.getBlockTileEntity(var2, var3, var4);
+			var5.displayGUIEnchantment(var2, var3, var4, var10.func_94135_b() ? var10.func_94133_a() : null);
+			return true;
+		}
+	}
+
+	public void onBlockPlacedBy(World var1, int var2, int var3, int var4, EntityLiving var5, ItemStack var6) {
+		super.onBlockPlacedBy(var1, var2, var3, var4, var5, var6);
+		if(var6.hasDisplayName()) {
+			((TileEntityEnchantmentTable)var1.getBlockTileEntity(var2, var3, var4)).func_94134_a(var6.getDisplayName());
+		}
+
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.blockIcon = var1.registerIcon("enchantment_side");
+		this.field_94461_a = var1.registerIcon("enchantment_top");
+		this.field_94460_b = var1.registerIcon("enchantment_bottom");
+	}
+}

src/net/minecraft/src/BlockEndPortal.java

@@ -0,0 +1,79 @@
+package net.minecraft.src;
+
+import java.util.List;
+import java.util.Random;
+
+public class BlockEndPortal extends BlockContainer {
+	public static boolean bossDefeated = false;
+
+	protected BlockEndPortal(int var1, Material var2) {
+		super(var1, var2);
+		this.setLightValue(1.0F);
+	}
+
+	public TileEntity createNewTileEntity(World var1) {
+		return new TileEntityEndPortal();
+	}
+
+	public void setBlockBoundsBasedOnState(IBlockAccess var1, int var2, int var3, int var4) {
+		float var5 = 1.0F / 16.0F;
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, var5, 1.0F);
+	}
+
+	public boolean shouldSideBeRendered(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return var5 != 0 ? false : super.shouldSideBeRendered(var1, var2, var3, var4, var5);
+	}
+
+	public void addCollisionBoxesToList(World var1, int var2, int var3, int var4, AxisAlignedBB var5, List var6, Entity var7) {
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public int quantityDropped(Random var1) {
+		return 0;
+	}
+
+	public void onEntityCollidedWithBlock(World var1, int var2, int var3, int var4, Entity var5) {
+		if(var5.ridingEntity == null && var5.riddenByEntity == null && !var1.isRemote) {
+			var5.travelToDimension(1);
+		}
+
+	}
+
+	public void randomDisplayTick(World var1, int var2, int var3, int var4, Random var5) {
+		double var6 = (double)((float)var2 + var5.nextFloat());
+		double var8 = (double)((float)var3 + 0.8F);
+		double var10 = (double)((float)var4 + var5.nextFloat());
+		double var12 = 0.0D;
+		double var14 = 0.0D;
+		double var16 = 0.0D;
+		var1.spawnParticle("smoke", var6, var8, var10, var12, var14, var16);
+	}
+
+	public int getRenderType() {
+		return -1;
+	}
+
+	public void onBlockAdded(World var1, int var2, int var3, int var4) {
+		if(!bossDefeated) {
+			if(var1.provider.dimensionId != 0) {
+				var1.setBlockToAir(var2, var3, var4);
+			}
+
+		}
+	}
+
+	public int idPicked(World var1, int var2, int var3, int var4) {
+		return 0;
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.blockIcon = var1.registerIcon("portal");
+	}
+}

src/net/minecraft/src/BlockEndPortalFrame.java

@@ -0,0 +1,64 @@
+package net.minecraft.src;
+
+import java.util.List;
+import java.util.Random;
+
+public class BlockEndPortalFrame extends Block {
+	private Icon field_94400_a;
+	private Icon field_94399_b;
+
+	public BlockEndPortalFrame(int var1) {
+		super(var1, Material.rock);
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return var1 == 1 ? this.field_94400_a : (var1 == 0 ? Block.whiteStone.getBlockTextureFromSide(var1) : this.blockIcon);
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.blockIcon = var1.registerIcon("endframe_side");
+		this.field_94400_a = var1.registerIcon("endframe_top");
+		this.field_94399_b = var1.registerIcon("endframe_eye");
+	}
+
+	public Icon func_94398_p() {
+		return this.field_94399_b;
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public int getRenderType() {
+		return 26;
+	}
+
+	public void setBlockBoundsForItemRender() {
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 13.0F / 16.0F, 1.0F);
+	}
+
+	public void addCollisionBoxesToList(World var1, int var2, int var3, int var4, AxisAlignedBB var5, List var6, Entity var7) {
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 13.0F / 16.0F, 1.0F);
+		super.addCollisionBoxesToList(var1, var2, var3, var4, var5, var6, var7);
+		int var8 = var1.getBlockMetadata(var2, var3, var4);
+		if(isEnderEyeInserted(var8)) {
+			this.setBlockBounds(5.0F / 16.0F, 13.0F / 16.0F, 5.0F / 16.0F, 11.0F / 16.0F, 1.0F, 11.0F / 16.0F);
+			super.addCollisionBoxesToList(var1, var2, var3, var4, var5, var6, var7);
+		}
+
+		this.setBlockBoundsForItemRender();
+	}
+
+	public static boolean isEnderEyeInserted(int var0) {
+		return (var0 & 4) != 0;
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		return 0;
+	}
+
+	public void onBlockPlacedBy(World var1, int var2, int var3, int var4, EntityLiving var5, ItemStack var6) {
+		int var7 = ((MathHelper.floor_double((double)(var5.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3) + 2) % 4;
+		var1.setBlockMetadataWithNotify(var2, var3, var4, var7, 2);
+	}
+}

src/net/minecraft/src/BlockEnderChest.java

@@ -0,0 +1,105 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockEnderChest extends BlockContainer {
+	protected BlockEnderChest(int var1) {
+		super(var1, Material.rock);
+		this.setCreativeTab(CreativeTabs.tabDecorations);
+		this.setBlockBounds(1.0F / 16.0F, 0.0F, 1.0F / 16.0F, 15.0F / 16.0F, 14.0F / 16.0F, 15.0F / 16.0F);
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public int getRenderType() {
+		return 22;
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		return Block.obsidian.blockID;
+	}
+
+	public int quantityDropped(Random var1) {
+		return 8;
+	}
+
+	protected boolean canSilkHarvest() {
+		return true;
+	}
+
+	public void onBlockPlacedBy(World var1, int var2, int var3, int var4, EntityLiving var5, ItemStack var6) {
+		byte var7 = 0;
+		int var8 = MathHelper.floor_double((double)(var5.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;
+		if(var8 == 0) {
+			var7 = 2;
+		}
+
+		if(var8 == 1) {
+			var7 = 5;
+		}
+
+		if(var8 == 2) {
+			var7 = 3;
+		}
+
+		if(var8 == 3) {
+			var7 = 4;
+		}
+
+		var1.setBlockMetadataWithNotify(var2, var3, var4, var7, 2);
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		InventoryEnderChest var10 = var5.getInventoryEnderChest();
+		TileEntityEnderChest var11 = (TileEntityEnderChest)var1.getBlockTileEntity(var2, var3, var4);
+		if(var10 != null && var11 != null) {
+			if(var1.isBlockNormalCube(var2, var3 + 1, var4)) {
+				return true;
+			} else if(var1.isRemote) {
+				return true;
+			} else {
+				var10.setAssociatedChest(var11);
+				var5.displayGUIChest(var10);
+				return true;
+			}
+		} else {
+			return true;
+		}
+	}
+
+	public TileEntity createNewTileEntity(World var1) {
+		return new TileEntityEnderChest();
+	}
+
+	public void randomDisplayTick(World var1, int var2, int var3, int var4, Random var5) {
+		for(int var6 = 0; var6 < 3; ++var6) {
+			double var10000 = (double)((float)var2 + var5.nextFloat());
+			double var9 = (double)((float)var3 + var5.nextFloat());
+			var10000 = (double)((float)var4 + var5.nextFloat());
+			double var13 = 0.0D;
+			double var15 = 0.0D;
+			double var17 = 0.0D;
+			int var19 = var5.nextInt(2) * 2 - 1;
+			int var20 = var5.nextInt(2) * 2 - 1;
+			var13 = ((double)var5.nextFloat() - 0.5D) * 0.125D;
+			var15 = ((double)var5.nextFloat() - 0.5D) * 0.125D;
+			var17 = ((double)var5.nextFloat() - 0.5D) * 0.125D;
+			double var11 = (double)var4 + 0.5D + 0.25D * (double)var20;
+			var17 = (double)(var5.nextFloat() * 1.0F * (float)var20);
+			double var7 = (double)var2 + 0.5D + 0.25D * (double)var19;
+			var13 = (double)(var5.nextFloat() * 1.0F * (float)var19);
+			var1.spawnParticle("portal", var7, var9, var11, var13, var15, var17);
+		}
+
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.blockIcon = var1.registerIcon("obsidian");
+	}
+}

src/net/minecraft/src/BlockEventData.java

@@ -0,0 +1,56 @@
+package net.minecraft.src;
+
+public class BlockEventData {
+	private int coordX;
+	private int coordY;
+	private int coordZ;
+	private int blockID;
+	private int eventID;
+	private int eventParameter;
+
+	public BlockEventData(int var1, int var2, int var3, int var4, int var5, int var6) {
+		this.coordX = var1;
+		this.coordY = var2;
+		this.coordZ = var3;
+		this.eventID = var5;
+		this.eventParameter = var6;
+		this.blockID = var4;
+	}
+
+	public int getX() {
+		return this.coordX;
+	}
+
+	public int getY() {
+		return this.coordY;
+	}
+
+	public int getZ() {
+		return this.coordZ;
+	}
+
+	public int getEventID() {
+		return this.eventID;
+	}
+
+	public int getEventParameter() {
+		return this.eventParameter;
+	}
+
+	public int getBlockID() {
+		return this.blockID;
+	}
+
+	public boolean equals(Object var1) {
+		if(!(var1 instanceof BlockEventData)) {
+			return false;
+		} else {
+			BlockEventData var2 = (BlockEventData)var1;
+			return this.coordX == var2.coordX && this.coordY == var2.coordY && this.coordZ == var2.coordZ && this.eventID == var2.eventID && this.eventParameter == var2.eventParameter && this.blockID == var2.blockID;
+		}
+	}
+
+	public String toString() {
+		return "TE(" + this.coordX + "," + this.coordY + "," + this.coordZ + ")," + this.eventID + "," + this.eventParameter + "," + this.blockID;
+	}
+}

src/net/minecraft/src/BlockFarmland.java

@@ -0,0 +1,107 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockFarmland extends Block {
+	private Icon field_94441_a;
+	private Icon field_94440_b;
+
+	protected BlockFarmland(int var1) {
+		super(var1, Material.ground);
+		this.setTickRandomly(true);
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 15.0F / 16.0F, 1.0F);
+		this.setLightOpacity(255);
+	}
+
+	public AxisAlignedBB getCollisionBoundingBoxFromPool(World var1, int var2, int var3, int var4) {
+		return AxisAlignedBB.getAABBPool().getAABB((double)(var2 + 0), (double)(var3 + 0), (double)(var4 + 0), (double)(var2 + 1), (double)(var3 + 1), (double)(var4 + 1));
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return var1 == 1 ? (var2 > 0 ? this.field_94441_a : this.field_94440_b) : Block.dirt.getBlockTextureFromSide(var1);
+	}
+
+	public void updateTick(World var1, int var2, int var3, int var4, Random var5) {
+		if(!this.isWaterNearby(var1, var2, var3, var4) && !var1.canLightningStrikeAt(var2, var3 + 1, var4)) {
+			int var6 = var1.getBlockMetadata(var2, var3, var4);
+			if(var6 > 0) {
+				var1.setBlockMetadataWithNotify(var2, var3, var4, var6 - 1, 2);
+			} else if(!this.isCropsNearby(var1, var2, var3, var4)) {
+				var1.setBlock(var2, var3, var4, Block.dirt.blockID);
+			}
+		} else {
+			var1.setBlockMetadataWithNotify(var2, var3, var4, 7, 2);
+		}
+
+	}
+
+	public void onFallenUpon(World var1, int var2, int var3, int var4, Entity var5, float var6) {
+		if(!var1.isRemote && var1.rand.nextFloat() < var6 - 0.5F) {
+			if(!(var5 instanceof EntityPlayer) && !var1.getGameRules().getGameRuleBooleanValue("mobGriefing")) {
+				return;
+			}
+
+			var1.setBlock(var2, var3, var4, Block.dirt.blockID);
+		}
+
+	}
+
+	private boolean isCropsNearby(World var1, int var2, int var3, int var4) {
+		byte var5 = 0;
+
+		for(int var6 = var2 - var5; var6 <= var2 + var5; ++var6) {
+			for(int var7 = var4 - var5; var7 <= var4 + var5; ++var7) {
+				int var8 = var1.getBlockId(var6, var3 + 1, var7);
+				if(var8 == Block.crops.blockID || var8 == Block.melonStem.blockID || var8 == Block.pumpkinStem.blockID || var8 == Block.potato.blockID || var8 == Block.carrot.blockID) {
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+
+	private boolean isWaterNearby(World var1, int var2, int var3, int var4) {
+		for(int var5 = var2 - 4; var5 <= var2 + 4; ++var5) {
+			for(int var6 = var3; var6 <= var3 + 1; ++var6) {
+				for(int var7 = var4 - 4; var7 <= var4 + 4; ++var7) {
+					if(var1.getBlockMaterial(var5, var6, var7) == Material.water) {
+						return true;
+					}
+				}
+			}
+		}
+
+		return false;
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+		super.onNeighborBlockChange(var1, var2, var3, var4, var5);
+		Material var6 = var1.getBlockMaterial(var2, var3 + 1, var4);
+		if(var6.isSolid()) {
+			var1.setBlock(var2, var3, var4, Block.dirt.blockID);
+		}
+
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		return Block.dirt.idDropped(0, var2, var3);
+	}
+
+	public int idPicked(World var1, int var2, int var3, int var4) {
+		return Block.dirt.blockID;
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.field_94441_a = var1.registerIcon("farmland_wet");
+		this.field_94440_b = var1.registerIcon("farmland_dry");
+	}
+}

src/net/minecraft/src/BlockFence.java

@@ -0,0 +1,127 @@
+package net.minecraft.src;
+
+import java.util.List;
+
+public class BlockFence extends Block {
+	private final String field_94464_a;
+
+	public BlockFence(int var1, String var2, Material var3) {
+		super(var1, var3);
+		this.field_94464_a = var2;
+		this.setCreativeTab(CreativeTabs.tabDecorations);
+	}
+
+	public void addCollisionBoxesToList(World var1, int var2, int var3, int var4, AxisAlignedBB var5, List var6, Entity var7) {
+		boolean var8 = this.canConnectFenceTo(var1, var2, var3, var4 - 1);
+		boolean var9 = this.canConnectFenceTo(var1, var2, var3, var4 + 1);
+		boolean var10 = this.canConnectFenceTo(var1, var2 - 1, var3, var4);
+		boolean var11 = this.canConnectFenceTo(var1, var2 + 1, var3, var4);
+		float var12 = 6.0F / 16.0F;
+		float var13 = 10.0F / 16.0F;
+		float var14 = 6.0F / 16.0F;
+		float var15 = 10.0F / 16.0F;
+		if(var8) {
+			var14 = 0.0F;
+		}
+
+		if(var9) {
+			var15 = 1.0F;
+		}
+
+		if(var8 || var9) {
+			this.setBlockBounds(var12, 0.0F, var14, var13, 1.5F, var15);
+			super.addCollisionBoxesToList(var1, var2, var3, var4, var5, var6, var7);
+		}
+
+		var14 = 6.0F / 16.0F;
+		var15 = 10.0F / 16.0F;
+		if(var10) {
+			var12 = 0.0F;
+		}
+
+		if(var11) {
+			var13 = 1.0F;
+		}
+
+		if(var10 || var11 || !var8 && !var9) {
+			this.setBlockBounds(var12, 0.0F, var14, var13, 1.5F, var15);
+			super.addCollisionBoxesToList(var1, var2, var3, var4, var5, var6, var7);
+		}
+
+		if(var8) {
+			var14 = 0.0F;
+		}
+
+		if(var9) {
+			var15 = 1.0F;
+		}
+
+		this.setBlockBounds(var12, 0.0F, var14, var13, 1.0F, var15);
+	}
+
+	public void setBlockBoundsBasedOnState(IBlockAccess var1, int var2, int var3, int var4) {
+		boolean var5 = this.canConnectFenceTo(var1, var2, var3, var4 - 1);
+		boolean var6 = this.canConnectFenceTo(var1, var2, var3, var4 + 1);
+		boolean var7 = this.canConnectFenceTo(var1, var2 - 1, var3, var4);
+		boolean var8 = this.canConnectFenceTo(var1, var2 + 1, var3, var4);
+		float var9 = 6.0F / 16.0F;
+		float var10 = 10.0F / 16.0F;
+		float var11 = 6.0F / 16.0F;
+		float var12 = 10.0F / 16.0F;
+		if(var5) {
+			var11 = 0.0F;
+		}
+
+		if(var6) {
+			var12 = 1.0F;
+		}
+
+		if(var7) {
+			var9 = 0.0F;
+		}
+
+		if(var8) {
+			var10 = 1.0F;
+		}
+
+		this.setBlockBounds(var9, 0.0F, var11, var10, 1.0F, var12);
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public boolean getBlocksMovement(IBlockAccess var1, int var2, int var3, int var4) {
+		return false;
+	}
+
+	public int getRenderType() {
+		return 11;
+	}
+
+	public boolean canConnectFenceTo(IBlockAccess var1, int var2, int var3, int var4) {
+		int var5 = var1.getBlockId(var2, var3, var4);
+		if(var5 != this.blockID && var5 != Block.fenceGate.blockID) {
+			Block var6 = Block.blocksList[var5];
+			return var6 != null && var6.blockMaterial.isOpaque() && var6.renderAsNormalBlock() ? var6.blockMaterial != Material.pumpkin : false;
+		} else {
+			return true;
+		}
+	}
+
+	public static boolean isIdAFence(int var0) {
+		return var0 == Block.fence.blockID || var0 == Block.netherFence.blockID;
+	}
+
+	public boolean shouldSideBeRendered(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return true;
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.blockIcon = var1.registerIcon(this.field_94464_a);
+	}
+}

src/net/minecraft/src/BlockFenceGate.java

@@ -0,0 +1,98 @@
+package net.minecraft.src;
+
+public class BlockFenceGate extends BlockDirectional {
+	public BlockFenceGate(int var1) {
+		super(var1, Material.wood);
+		this.setCreativeTab(CreativeTabs.tabRedstone);
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return Block.planks.getBlockTextureFromSide(var1);
+	}
+
+	public boolean canPlaceBlockAt(World var1, int var2, int var3, int var4) {
+		return !var1.getBlockMaterial(var2, var3 - 1, var4).isSolid() ? false : super.canPlaceBlockAt(var1, var2, var3, var4);
+	}
+
+	public AxisAlignedBB getCollisionBoundingBoxFromPool(World var1, int var2, int var3, int var4) {
+		int var5 = var1.getBlockMetadata(var2, var3, var4);
+		return isFenceGateOpen(var5) ? null : (var5 != 2 && var5 != 0 ? AxisAlignedBB.getAABBPool().getAABB((double)((float)var2 + 6.0F / 16.0F), (double)var3, (double)var4, (double)((float)var2 + 10.0F / 16.0F), (double)((float)var3 + 1.5F), (double)(var4 + 1)) : AxisAlignedBB.getAABBPool().getAABB((double)var2, (double)var3, (double)((float)var4 + 6.0F / 16.0F), (double)(var2 + 1), (double)((float)var3 + 1.5F), (double)((float)var4 + 10.0F / 16.0F)));
+	}
+
+	public void setBlockBoundsBasedOnState(IBlockAccess var1, int var2, int var3, int var4) {
+		int var5 = getDirection(var1.getBlockMetadata(var2, var3, var4));
+		if(var5 != 2 && var5 != 0) {
+			this.setBlockBounds(6.0F / 16.0F, 0.0F, 0.0F, 10.0F / 16.0F, 1.0F, 1.0F);
+		} else {
+			this.setBlockBounds(0.0F, 0.0F, 6.0F / 16.0F, 1.0F, 1.0F, 10.0F / 16.0F);
+		}
+
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public boolean getBlocksMovement(IBlockAccess var1, int var2, int var3, int var4) {
+		return isFenceGateOpen(var1.getBlockMetadata(var2, var3, var4));
+	}
+
+	public int getRenderType() {
+		return 21;
+	}
+
+	public void onBlockPlacedBy(World var1, int var2, int var3, int var4, EntityLiving var5, ItemStack var6) {
+		int var7 = (MathHelper.floor_double((double)(var5.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3) % 4;
+		var1.setBlockMetadataWithNotify(var2, var3, var4, var7, 2);
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		int var10 = var1.getBlockMetadata(var2, var3, var4);
+		if(isFenceGateOpen(var10)) {
+			var1.setBlockMetadataWithNotify(var2, var3, var4, var10 & -5, 2);
+		} else {
+			int var11 = (MathHelper.floor_double((double)(var5.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3) % 4;
+			int var12 = getDirection(var10);
+			if(var12 == (var11 + 2) % 4) {
+				var10 = var11;
+			}
+
+			var1.setBlockMetadataWithNotify(var2, var3, var4, var10 | 4, 2);
+		}
+
+		var1.playAuxSFXAtEntity(var5, 1003, var2, var3, var4, 0);
+		return true;
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+		if(!var1.isRemote) {
+			int var6 = var1.getBlockMetadata(var2, var3, var4);
+			boolean var7 = var1.isBlockIndirectlyGettingPowered(var2, var3, var4);
+			if(var7 || var5 > 0 && Block.blocksList[var5].canProvidePower()) {
+				if(var7 && !isFenceGateOpen(var6)) {
+					var1.setBlockMetadataWithNotify(var2, var3, var4, var6 | 4, 2);
+					var1.playAuxSFXAtEntity((EntityPlayer)null, 1003, var2, var3, var4, 0);
+				} else if(!var7 && isFenceGateOpen(var6)) {
+					var1.setBlockMetadataWithNotify(var2, var3, var4, var6 & -5, 2);
+					var1.playAuxSFXAtEntity((EntityPlayer)null, 1003, var2, var3, var4, 0);
+				}
+			}
+
+		}
+	}
+
+	public static boolean isFenceGateOpen(int var0) {
+		return (var0 & 4) != 0;
+	}
+
+	public boolean shouldSideBeRendered(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return true;
+	}
+
+	public void registerIcons(IconRegister var1) {
+	}
+}

src/net/minecraft/src/BlockFire.java

@@ -0,0 +1,293 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockFire extends Block {
+	private int[] chanceToEncourageFire = new int[256];
+	private int[] abilityToCatchFire = new int[256];
+	private Icon[] iconArray;
+
+	protected BlockFire(int var1) {
+		super(var1, Material.fire);
+		this.setTickRandomly(true);
+	}
+
+	public void initializeBlock() {
+		this.setBurnRate(Block.planks.blockID, 5, 20);
+		this.setBurnRate(Block.woodDoubleSlab.blockID, 5, 20);
+		this.setBurnRate(Block.woodSingleSlab.blockID, 5, 20);
+		this.setBurnRate(Block.fence.blockID, 5, 20);
+		this.setBurnRate(Block.stairsWoodOak.blockID, 5, 20);
+		this.setBurnRate(Block.stairsWoodBirch.blockID, 5, 20);
+		this.setBurnRate(Block.stairsWoodSpruce.blockID, 5, 20);
+		this.setBurnRate(Block.stairsWoodJungle.blockID, 5, 20);
+		this.setBurnRate(Block.wood.blockID, 5, 5);
+		this.setBurnRate(Block.leaves.blockID, 30, 60);
+		this.setBurnRate(Block.bookShelf.blockID, 30, 20);
+		this.setBurnRate(Block.tnt.blockID, 15, 100);
+		this.setBurnRate(Block.tallGrass.blockID, 60, 100);
+		this.setBurnRate(Block.cloth.blockID, 30, 60);
+		this.setBurnRate(Block.vine.blockID, 15, 100);
+	}
+
+	private void setBurnRate(int var1, int var2, int var3) {
+		this.chanceToEncourageFire[var1] = var2;
+		this.abilityToCatchFire[var1] = var3;
+	}
+
+	public AxisAlignedBB getCollisionBoundingBoxFromPool(World var1, int var2, int var3, int var4) {
+		return null;
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public int getRenderType() {
+		return 3;
+	}
+
+	public int quantityDropped(Random var1) {
+		return 0;
+	}
+
+	public int tickRate(World var1) {
+		return 30;
+	}
+
+	public void updateTick(World var1, int var2, int var3, int var4, Random var5) {
+		if(var1.getGameRules().getGameRuleBooleanValue("doFireTick")) {
+			boolean var6 = var1.getBlockId(var2, var3 - 1, var4) == Block.netherrack.blockID;
+			if(var1.provider instanceof WorldProviderEnd && var1.getBlockId(var2, var3 - 1, var4) == Block.bedrock.blockID) {
+				var6 = true;
+			}
+
+			if(!this.canPlaceBlockAt(var1, var2, var3, var4)) {
+				var1.setBlockToAir(var2, var3, var4);
+			}
+
+			if(var6 || !var1.isRaining() || !var1.canLightningStrikeAt(var2, var3, var4) && !var1.canLightningStrikeAt(var2 - 1, var3, var4) && !var1.canLightningStrikeAt(var2 + 1, var3, var4) && !var1.canLightningStrikeAt(var2, var3, var4 - 1) && !var1.canLightningStrikeAt(var2, var3, var4 + 1)) {
+				int var7 = var1.getBlockMetadata(var2, var3, var4);
+				if(var7 < 15) {
+					var1.setBlockMetadataWithNotify(var2, var3, var4, var7 + var5.nextInt(3) / 2, 4);
+				}
+
+				var1.scheduleBlockUpdate(var2, var3, var4, this.blockID, this.tickRate(var1) + var5.nextInt(10));
+				if(!var6 && !this.canNeighborBurn(var1, var2, var3, var4)) {
+					if(!var1.doesBlockHaveSolidTopSurface(var2, var3 - 1, var4) || var7 > 3) {
+						var1.setBlockToAir(var2, var3, var4);
+					}
+
+				} else if(!var6 && !this.canBlockCatchFire(var1, var2, var3 - 1, var4) && var7 == 15 && var5.nextInt(4) == 0) {
+					var1.setBlockToAir(var2, var3, var4);
+				} else {
+					boolean var8 = var1.isBlockHighHumidity(var2, var3, var4);
+					byte var9 = 0;
+					if(var8) {
+						var9 = -50;
+					}
+
+					this.tryToCatchBlockOnFire(var1, var2 + 1, var3, var4, 300 + var9, var5, var7);
+					this.tryToCatchBlockOnFire(var1, var2 - 1, var3, var4, 300 + var9, var5, var7);
+					this.tryToCatchBlockOnFire(var1, var2, var3 - 1, var4, 250 + var9, var5, var7);
+					this.tryToCatchBlockOnFire(var1, var2, var3 + 1, var4, 250 + var9, var5, var7);
+					this.tryToCatchBlockOnFire(var1, var2, var3, var4 - 1, 300 + var9, var5, var7);
+					this.tryToCatchBlockOnFire(var1, var2, var3, var4 + 1, 300 + var9, var5, var7);
+
+					for(int var10 = var2 - 1; var10 <= var2 + 1; ++var10) {
+						for(int var11 = var4 - 1; var11 <= var4 + 1; ++var11) {
+							for(int var12 = var3 - 1; var12 <= var3 + 4; ++var12) {
+								if(var10 != var2 || var12 != var3 || var11 != var4) {
+									int var13 = 100;
+									if(var12 > var3 + 1) {
+										var13 += (var12 - (var3 + 1)) * 100;
+									}
+
+									int var14 = this.getChanceOfNeighborsEncouragingFire(var1, var10, var12, var11);
+									if(var14 > 0) {
+										int var15 = (var14 + 40 + var1.difficultySetting * 7) / (var7 + 30);
+										if(var8) {
+											var15 /= 2;
+										}
+
+										if(var15 > 0 && var5.nextInt(var13) <= var15 && (!var1.isRaining() || !var1.canLightningStrikeAt(var10, var12, var11)) && !var1.canLightningStrikeAt(var10 - 1, var12, var4) && !var1.canLightningStrikeAt(var10 + 1, var12, var11) && !var1.canLightningStrikeAt(var10, var12, var11 - 1) && !var1.canLightningStrikeAt(var10, var12, var11 + 1)) {
+											int var16 = var7 + var5.nextInt(5) / 4;
+											if(var16 > 15) {
+												var16 = 15;
+											}
+
+											var1.setBlock(var10, var12, var11, this.blockID, var16, 3);
+										}
+									}
+								}
+							}
+						}
+					}
+
+				}
+			} else {
+				var1.setBlockToAir(var2, var3, var4);
+			}
+		}
+	}
+
+	public boolean func_82506_l() {
+		return false;
+	}
+
+	private void tryToCatchBlockOnFire(World var1, int var2, int var3, int var4, int var5, Random var6, int var7) {
+		int var8 = this.abilityToCatchFire[var1.getBlockId(var2, var3, var4)];
+		if(var6.nextInt(var5) < var8) {
+			boolean var9 = var1.getBlockId(var2, var3, var4) == Block.tnt.blockID;
+			if(var6.nextInt(var7 + 10) < 5 && !var1.canLightningStrikeAt(var2, var3, var4)) {
+				int var10 = var7 + var6.nextInt(5) / 4;
+				if(var10 > 15) {
+					var10 = 15;
+				}
+
+				var1.setBlock(var2, var3, var4, this.blockID, var10, 3);
+			} else {
+				var1.setBlockToAir(var2, var3, var4);
+			}
+
+			if(var9) {
+				Block.tnt.onBlockDestroyedByPlayer(var1, var2, var3, var4, 1);
+			}
+		}
+
+	}
+
+	private boolean canNeighborBurn(World var1, int var2, int var3, int var4) {
+		return this.canBlockCatchFire(var1, var2 + 1, var3, var4) ? true : (this.canBlockCatchFire(var1, var2 - 1, var3, var4) ? true : (this.canBlockCatchFire(var1, var2, var3 - 1, var4) ? true : (this.canBlockCatchFire(var1, var2, var3 + 1, var4) ? true : (this.canBlockCatchFire(var1, var2, var3, var4 - 1) ? true : this.canBlockCatchFire(var1, var2, var3, var4 + 1)))));
+	}
+
+	private int getChanceOfNeighborsEncouragingFire(World var1, int var2, int var3, int var4) {
+		byte var5 = 0;
+		if(!var1.isAirBlock(var2, var3, var4)) {
+			return 0;
+		} else {
+			int var6 = this.getChanceToEncourageFire(var1, var2 + 1, var3, var4, var5);
+			var6 = this.getChanceToEncourageFire(var1, var2 - 1, var3, var4, var6);
+			var6 = this.getChanceToEncourageFire(var1, var2, var3 - 1, var4, var6);
+			var6 = this.getChanceToEncourageFire(var1, var2, var3 + 1, var4, var6);
+			var6 = this.getChanceToEncourageFire(var1, var2, var3, var4 - 1, var6);
+			var6 = this.getChanceToEncourageFire(var1, var2, var3, var4 + 1, var6);
+			return var6;
+		}
+	}
+
+	public boolean isCollidable() {
+		return false;
+	}
+
+	public boolean canBlockCatchFire(IBlockAccess var1, int var2, int var3, int var4) {
+		return this.chanceToEncourageFire[var1.getBlockId(var2, var3, var4)] > 0;
+	}
+
+	public int getChanceToEncourageFire(World var1, int var2, int var3, int var4, int var5) {
+		int var6 = this.chanceToEncourageFire[var1.getBlockId(var2, var3, var4)];
+		return var6 > var5 ? var6 : var5;
+	}
+
+	public boolean canPlaceBlockAt(World var1, int var2, int var3, int var4) {
+		return var1.doesBlockHaveSolidTopSurface(var2, var3 - 1, var4) || this.canNeighborBurn(var1, var2, var3, var4);
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+		if(!var1.doesBlockHaveSolidTopSurface(var2, var3 - 1, var4) && !this.canNeighborBurn(var1, var2, var3, var4)) {
+			var1.setBlockToAir(var2, var3, var4);
+		}
+
+	}
+
+	public void onBlockAdded(World var1, int var2, int var3, int var4) {
+		if(var1.provider.dimensionId > 0 || var1.getBlockId(var2, var3 - 1, var4) != Block.obsidian.blockID || !Block.portal.tryToCreatePortal(var1, var2, var3, var4)) {
+			if(!var1.doesBlockHaveSolidTopSurface(var2, var3 - 1, var4) && !this.canNeighborBurn(var1, var2, var3, var4)) {
+				var1.setBlockToAir(var2, var3, var4);
+			} else {
+				var1.scheduleBlockUpdate(var2, var3, var4, this.blockID, this.tickRate(var1) + var1.rand.nextInt(10));
+			}
+		}
+	}
+
+	public void randomDisplayTick(World var1, int var2, int var3, int var4, Random var5) {
+		if(var5.nextInt(24) == 0) {
+			var1.playSound((double)((float)var2 + 0.5F), (double)((float)var3 + 0.5F), (double)((float)var4 + 0.5F), "fire.fire", 1.0F + var5.nextFloat(), var5.nextFloat() * 0.7F + 0.3F, false);
+		}
+
+		int var6;
+		float var7;
+		float var8;
+		float var9;
+		if(!var1.doesBlockHaveSolidTopSurface(var2, var3 - 1, var4) && !Block.fire.canBlockCatchFire(var1, var2, var3 - 1, var4)) {
+			if(Block.fire.canBlockCatchFire(var1, var2 - 1, var3, var4)) {
+				for(var6 = 0; var6 < 2; ++var6) {
+					var7 = (float)var2 + var5.nextFloat() * 0.1F;
+					var8 = (float)var3 + var5.nextFloat();
+					var9 = (float)var4 + var5.nextFloat();
+					var1.spawnParticle("largesmoke", (double)var7, (double)var8, (double)var9, 0.0D, 0.0D, 0.0D);
+				}
+			}
+
+			if(Block.fire.canBlockCatchFire(var1, var2 + 1, var3, var4)) {
+				for(var6 = 0; var6 < 2; ++var6) {
+					var7 = (float)(var2 + 1) - var5.nextFloat() * 0.1F;
+					var8 = (float)var3 + var5.nextFloat();
+					var9 = (float)var4 + var5.nextFloat();
+					var1.spawnParticle("largesmoke", (double)var7, (double)var8, (double)var9, 0.0D, 0.0D, 0.0D);
+				}
+			}
+
+			if(Block.fire.canBlockCatchFire(var1, var2, var3, var4 - 1)) {
+				for(var6 = 0; var6 < 2; ++var6) {
+					var7 = (float)var2 + var5.nextFloat();
+					var8 = (float)var3 + var5.nextFloat();
+					var9 = (float)var4 + var5.nextFloat() * 0.1F;
+					var1.spawnParticle("largesmoke", (double)var7, (double)var8, (double)var9, 0.0D, 0.0D, 0.0D);
+				}
+			}
+
+			if(Block.fire.canBlockCatchFire(var1, var2, var3, var4 + 1)) {
+				for(var6 = 0; var6 < 2; ++var6) {
+					var7 = (float)var2 + var5.nextFloat();
+					var8 = (float)var3 + var5.nextFloat();
+					var9 = (float)(var4 + 1) - var5.nextFloat() * 0.1F;
+					var1.spawnParticle("largesmoke", (double)var7, (double)var8, (double)var9, 0.0D, 0.0D, 0.0D);
+				}
+			}
+
+			if(Block.fire.canBlockCatchFire(var1, var2, var3 + 1, var4)) {
+				for(var6 = 0; var6 < 2; ++var6) {
+					var7 = (float)var2 + var5.nextFloat();
+					var8 = (float)(var3 + 1) - var5.nextFloat() * 0.1F;
+					var9 = (float)var4 + var5.nextFloat();
+					var1.spawnParticle("largesmoke", (double)var7, (double)var8, (double)var9, 0.0D, 0.0D, 0.0D);
+				}
+			}
+		} else {
+			for(var6 = 0; var6 < 3; ++var6) {
+				var7 = (float)var2 + var5.nextFloat();
+				var8 = (float)var3 + var5.nextFloat() * 0.5F + 0.5F;
+				var9 = (float)var4 + var5.nextFloat();
+				var1.spawnParticle("largesmoke", (double)var7, (double)var8, (double)var9, 0.0D, 0.0D, 0.0D);
+			}
+		}
+
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.iconArray = new Icon[]{var1.registerIcon("fire_0"), var1.registerIcon("fire_1")};
+	}
+
+	public Icon func_94438_c(int var1) {
+		return this.iconArray[var1];
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return this.iconArray[0];
+	}
+}

src/net/minecraft/src/BlockFlower.java

@@ -0,0 +1,62 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockFlower extends Block {
+	protected BlockFlower(int var1, Material var2) {
+		super(var1, var2);
+		this.setTickRandomly(true);
+		float var3 = 0.2F;
+		this.setBlockBounds(0.5F - var3, 0.0F, 0.5F - var3, 0.5F + var3, var3 * 3.0F, 0.5F + var3);
+		this.setCreativeTab(CreativeTabs.tabDecorations);
+	}
+
+	protected BlockFlower(int var1) {
+		this(var1, Material.plants);
+	}
+
+	public boolean canPlaceBlockAt(World var1, int var2, int var3, int var4) {
+		return super.canPlaceBlockAt(var1, var2, var3, var4) && this.canThisPlantGrowOnThisBlockID(var1.getBlockId(var2, var3 - 1, var4));
+	}
+
+	protected boolean canThisPlantGrowOnThisBlockID(int var1) {
+		return var1 == Block.grass.blockID || var1 == Block.dirt.blockID || var1 == Block.tilledField.blockID;
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+		super.onNeighborBlockChange(var1, var2, var3, var4, var5);
+		this.checkFlowerChange(var1, var2, var3, var4);
+	}
+
+	public void updateTick(World var1, int var2, int var3, int var4, Random var5) {
+		this.checkFlowerChange(var1, var2, var3, var4);
+	}
+
+	protected final void checkFlowerChange(World var1, int var2, int var3, int var4) {
+		if(!this.canBlockStay(var1, var2, var3, var4)) {
+			this.dropBlockAsItem(var1, var2, var3, var4, var1.getBlockMetadata(var2, var3, var4), 0);
+			var1.setBlockToAir(var2, var3, var4);
+		}
+
+	}
+
+	public boolean canBlockStay(World var1, int var2, int var3, int var4) {
+		return (var1.getFullBlockLightValue(var2, var3, var4) >= 8 || var1.canBlockSeeTheSky(var2, var3, var4)) && this.canThisPlantGrowOnThisBlockID(var1.getBlockId(var2, var3 - 1, var4));
+	}
+
+	public AxisAlignedBB getCollisionBoundingBoxFromPool(World var1, int var2, int var3, int var4) {
+		return null;
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public int getRenderType() {
+		return 1;
+	}
+}

src/net/minecraft/src/BlockFlowerPot.java

@@ -0,0 +1,158 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockFlowerPot extends Block {
+	public BlockFlowerPot(int var1) {
+		super(var1, Material.circuits);
+		this.setBlockBoundsForItemRender();
+	}
+
+	public void setBlockBoundsForItemRender() {
+		float var1 = 6.0F / 16.0F;
+		float var2 = var1 / 2.0F;
+		this.setBlockBounds(0.5F - var2, 0.0F, 0.5F - var2, 0.5F + var2, var1, 0.5F + var2);
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public int getRenderType() {
+		return 33;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		ItemStack var10 = var5.inventory.getCurrentItem();
+		if(var10 == null) {
+			return false;
+		} else if(var1.getBlockMetadata(var2, var3, var4) != 0) {
+			return false;
+		} else {
+			int var11 = getMetaForPlant(var10);
+			if(var11 > 0) {
+				var1.setBlockMetadataWithNotify(var2, var3, var4, var11, 2);
+				if(!var5.capabilities.isCreativeMode && --var10.stackSize <= 0) {
+					var5.inventory.setInventorySlotContents(var5.inventory.currentItem, (ItemStack)null);
+				}
+
+				return true;
+			} else {
+				return false;
+			}
+		}
+	}
+
+	public int idPicked(World var1, int var2, int var3, int var4) {
+		ItemStack var5 = getPlantForMeta(var1.getBlockMetadata(var2, var3, var4));
+		return var5 == null ? Item.flowerPot.itemID : var5.itemID;
+	}
+
+	public int getDamageValue(World var1, int var2, int var3, int var4) {
+		ItemStack var5 = getPlantForMeta(var1.getBlockMetadata(var2, var3, var4));
+		return var5 == null ? Item.flowerPot.itemID : var5.getItemDamage();
+	}
+
+	public boolean isFlowerPot() {
+		return true;
+	}
+
+	public boolean canPlaceBlockAt(World var1, int var2, int var3, int var4) {
+		return super.canPlaceBlockAt(var1, var2, var3, var4) && var1.doesBlockHaveSolidTopSurface(var2, var3 - 1, var4);
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+		if(!var1.doesBlockHaveSolidTopSurface(var2, var3 - 1, var4)) {
+			this.dropBlockAsItem(var1, var2, var3, var4, var1.getBlockMetadata(var2, var3, var4), 0);
+			var1.setBlockToAir(var2, var3, var4);
+		}
+
+	}
+
+	public void dropBlockAsItemWithChance(World var1, int var2, int var3, int var4, int var5, float var6, int var7) {
+		super.dropBlockAsItemWithChance(var1, var2, var3, var4, var5, var6, var7);
+		if(var5 > 0) {
+			ItemStack var8 = getPlantForMeta(var5);
+			if(var8 != null) {
+				this.dropBlockAsItem_do(var1, var2, var3, var4, var8);
+			}
+		}
+
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		return Item.flowerPot.itemID;
+	}
+
+	public static ItemStack getPlantForMeta(int var0) {
+		switch(var0) {
+		case 1:
+			return new ItemStack(Block.plantRed);
+		case 2:
+			return new ItemStack(Block.plantYellow);
+		case 3:
+			return new ItemStack(Block.sapling, 1, 0);
+		case 4:
+			return new ItemStack(Block.sapling, 1, 1);
+		case 5:
+			return new ItemStack(Block.sapling, 1, 2);
+		case 6:
+			return new ItemStack(Block.sapling, 1, 3);
+		case 7:
+			return new ItemStack(Block.mushroomRed);
+		case 8:
+			return new ItemStack(Block.mushroomBrown);
+		case 9:
+			return new ItemStack(Block.cactus);
+		case 10:
+			return new ItemStack(Block.deadBush);
+		case 11:
+			return new ItemStack(Block.tallGrass, 1, 2);
+		default:
+			return null;
+		}
+	}
+
+	public static int getMetaForPlant(ItemStack var0) {
+		int var1 = var0.getItem().itemID;
+		if(var1 == Block.plantRed.blockID) {
+			return 1;
+		} else if(var1 == Block.plantYellow.blockID) {
+			return 2;
+		} else if(var1 == Block.cactus.blockID) {
+			return 9;
+		} else if(var1 == Block.mushroomBrown.blockID) {
+			return 8;
+		} else if(var1 == Block.mushroomRed.blockID) {
+			return 7;
+		} else if(var1 == Block.deadBush.blockID) {
+			return 10;
+		} else {
+			if(var1 == Block.sapling.blockID) {
+				switch(var0.getItemDamage()) {
+				case 0:
+					return 3;
+				case 1:
+					return 4;
+				case 2:
+					return 5;
+				case 3:
+					return 6;
+				}
+			}
+
+			if(var1 == Block.tallGrass.blockID) {
+				switch(var0.getItemDamage()) {
+				case 2:
+					return 11;
+				}
+			}
+
+			return 0;
+		}
+	}
+}

src/net/minecraft/src/BlockFlowing.java

@@ -0,0 +1,277 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockFlowing extends BlockFluid {
+	int numAdjacentSources = 0;
+	boolean[] isOptimalFlowDirection = new boolean[4];
+	int[] flowCost = new int[4];
+
+	protected BlockFlowing(int var1, Material var2) {
+		super(var1, var2);
+	}
+
+	private void updateFlow(World var1, int var2, int var3, int var4) {
+		int var5 = var1.getBlockMetadata(var2, var3, var4);
+		var1.setBlock(var2, var3, var4, this.blockID + 1, var5, 2);
+	}
+
+	public boolean getBlocksMovement(IBlockAccess var1, int var2, int var3, int var4) {
+		return this.blockMaterial != Material.lava;
+	}
+
+	public void updateTick(World var1, int var2, int var3, int var4, Random var5) {
+		int var6 = this.getFlowDecay(var1, var2, var3, var4);
+		byte var7 = 1;
+		if(this.blockMaterial == Material.lava && !var1.provider.isHellWorld) {
+			var7 = 2;
+		}
+
+		boolean var8 = true;
+		int var10;
+		if(var6 > 0) {
+			byte var9 = -100;
+			this.numAdjacentSources = 0;
+			int var12 = this.getSmallestFlowDecay(var1, var2 - 1, var3, var4, var9);
+			var12 = this.getSmallestFlowDecay(var1, var2 + 1, var3, var4, var12);
+			var12 = this.getSmallestFlowDecay(var1, var2, var3, var4 - 1, var12);
+			var12 = this.getSmallestFlowDecay(var1, var2, var3, var4 + 1, var12);
+			var10 = var12 + var7;
+			if(var10 >= 8 || var12 < 0) {
+				var10 = -1;
+			}
+
+			if(this.getFlowDecay(var1, var2, var3 + 1, var4) >= 0) {
+				int var11 = this.getFlowDecay(var1, var2, var3 + 1, var4);
+				if(var11 >= 8) {
+					var10 = var11;
+				} else {
+					var10 = var11 + 8;
+				}
+			}
+
+			if(this.numAdjacentSources >= 2 && this.blockMaterial == Material.water) {
+				if(var1.getBlockMaterial(var2, var3 - 1, var4).isSolid()) {
+					var10 = 0;
+				} else if(var1.getBlockMaterial(var2, var3 - 1, var4) == this.blockMaterial && var1.getBlockMetadata(var2, var3 - 1, var4) == 0) {
+					var10 = 0;
+				}
+			}
+
+			if(this.blockMaterial == Material.lava && var6 < 8 && var10 < 8 && var10 > var6 && var5.nextInt(4) != 0) {
+				var10 = var6;
+				var8 = false;
+			}
+
+			if(var10 == var6) {
+				if(var8) {
+					this.updateFlow(var1, var2, var3, var4);
+				}
+			} else {
+				var6 = var10;
+				if(var10 < 0) {
+					var1.setBlockToAir(var2, var3, var4);
+				} else {
+					var1.setBlockMetadataWithNotify(var2, var3, var4, var10, 2);
+					var1.scheduleBlockUpdate(var2, var3, var4, this.blockID, this.tickRate(var1));
+					var1.notifyBlocksOfNeighborChange(var2, var3, var4, this.blockID);
+				}
+			}
+		} else {
+			this.updateFlow(var1, var2, var3, var4);
+		}
+
+		if(this.liquidCanDisplaceBlock(var1, var2, var3 - 1, var4)) {
+			if(this.blockMaterial == Material.lava && var1.getBlockMaterial(var2, var3 - 1, var4) == Material.water) {
+				var1.setBlock(var2, var3 - 1, var4, Block.stone.blockID);
+				this.triggerLavaMixEffects(var1, var2, var3 - 1, var4);
+				return;
+			}
+
+			if(var6 >= 8) {
+				this.flowIntoBlock(var1, var2, var3 - 1, var4, var6);
+			} else {
+				this.flowIntoBlock(var1, var2, var3 - 1, var4, var6 + 8);
+			}
+		} else if(var6 >= 0 && (var6 == 0 || this.blockBlocksFlow(var1, var2, var3 - 1, var4))) {
+			boolean[] var13 = this.getOptimalFlowDirections(var1, var2, var3, var4);
+			var10 = var6 + var7;
+			if(var6 >= 8) {
+				var10 = 1;
+			}
+
+			if(var10 >= 8) {
+				return;
+			}
+
+			if(var13[0]) {
+				this.flowIntoBlock(var1, var2 - 1, var3, var4, var10);
+			}
+
+			if(var13[1]) {
+				this.flowIntoBlock(var1, var2 + 1, var3, var4, var10);
+			}
+
+			if(var13[2]) {
+				this.flowIntoBlock(var1, var2, var3, var4 - 1, var10);
+			}
+
+			if(var13[3]) {
+				this.flowIntoBlock(var1, var2, var3, var4 + 1, var10);
+			}
+		}
+
+	}
+
+	private void flowIntoBlock(World var1, int var2, int var3, int var4, int var5) {
+		if(this.liquidCanDisplaceBlock(var1, var2, var3, var4)) {
+			int var6 = var1.getBlockId(var2, var3, var4);
+			if(var6 > 0) {
+				if(this.blockMaterial == Material.lava) {
+					this.triggerLavaMixEffects(var1, var2, var3, var4);
+				} else {
+					Block.blocksList[var6].dropBlockAsItem(var1, var2, var3, var4, var1.getBlockMetadata(var2, var3, var4), 0);
+				}
+			}
+
+			var1.setBlock(var2, var3, var4, this.blockID, var5, 3);
+		}
+
+	}
+
+	private int calculateFlowCost(World var1, int var2, int var3, int var4, int var5, int var6) {
+		int var7 = 1000;
+
+		for(int var8 = 0; var8 < 4; ++var8) {
+			if((var8 != 0 || var6 != 1) && (var8 != 1 || var6 != 0) && (var8 != 2 || var6 != 3) && (var8 != 3 || var6 != 2)) {
+				int var9 = var2;
+				int var11 = var4;
+				if(var8 == 0) {
+					var9 = var2 - 1;
+				}
+
+				if(var8 == 1) {
+					++var9;
+				}
+
+				if(var8 == 2) {
+					var11 = var4 - 1;
+				}
+
+				if(var8 == 3) {
+					++var11;
+				}
+
+				if(!this.blockBlocksFlow(var1, var9, var3, var11) && (var1.getBlockMaterial(var9, var3, var11) != this.blockMaterial || var1.getBlockMetadata(var9, var3, var11) != 0)) {
+					if(!this.blockBlocksFlow(var1, var9, var3 - 1, var11)) {
+						return var5;
+					}
+
+					if(var5 < 4) {
+						int var12 = this.calculateFlowCost(var1, var9, var3, var11, var5 + 1, var8);
+						if(var12 < var7) {
+							var7 = var12;
+						}
+					}
+				}
+			}
+		}
+
+		return var7;
+	}
+
+	private boolean[] getOptimalFlowDirections(World var1, int var2, int var3, int var4) {
+		int var5;
+		int var6;
+		for(var5 = 0; var5 < 4; ++var5) {
+			this.flowCost[var5] = 1000;
+			var6 = var2;
+			int var8 = var4;
+			if(var5 == 0) {
+				var6 = var2 - 1;
+			}
+
+			if(var5 == 1) {
+				++var6;
+			}
+
+			if(var5 == 2) {
+				var8 = var4 - 1;
+			}
+
+			if(var5 == 3) {
+				++var8;
+			}
+
+			if(!this.blockBlocksFlow(var1, var6, var3, var8) && (var1.getBlockMaterial(var6, var3, var8) != this.blockMaterial || var1.getBlockMetadata(var6, var3, var8) != 0)) {
+				if(this.blockBlocksFlow(var1, var6, var3 - 1, var8)) {
+					this.flowCost[var5] = this.calculateFlowCost(var1, var6, var3, var8, 1, var5);
+				} else {
+					this.flowCost[var5] = 0;
+				}
+			}
+		}
+
+		var5 = this.flowCost[0];
+
+		for(var6 = 1; var6 < 4; ++var6) {
+			if(this.flowCost[var6] < var5) {
+				var5 = this.flowCost[var6];
+			}
+		}
+
+		for(var6 = 0; var6 < 4; ++var6) {
+			this.isOptimalFlowDirection[var6] = this.flowCost[var6] == var5;
+		}
+
+		return this.isOptimalFlowDirection;
+	}
+
+	private boolean blockBlocksFlow(World var1, int var2, int var3, int var4) {
+		int var5 = var1.getBlockId(var2, var3, var4);
+		if(var5 != Block.doorWood.blockID && var5 != Block.doorIron.blockID && var5 != Block.signPost.blockID && var5 != Block.ladder.blockID && var5 != Block.reed.blockID) {
+			if(var5 == 0) {
+				return false;
+			} else {
+				Material var6 = Block.blocksList[var5].blockMaterial;
+				return var6 == Material.portal ? true : var6.blocksMovement();
+			}
+		} else {
+			return true;
+		}
+	}
+
+	protected int getSmallestFlowDecay(World var1, int var2, int var3, int var4, int var5) {
+		int var6 = this.getFlowDecay(var1, var2, var3, var4);
+		if(var6 < 0) {
+			return var5;
+		} else {
+			if(var6 == 0) {
+				++this.numAdjacentSources;
+			}
+
+			if(var6 >= 8) {
+				var6 = 0;
+			}
+
+			return var5 >= 0 && var6 >= var5 ? var5 : var6;
+		}
+	}
+
+	private boolean liquidCanDisplaceBlock(World var1, int var2, int var3, int var4) {
+		Material var5 = var1.getBlockMaterial(var2, var3, var4);
+		return var5 == this.blockMaterial ? false : (var5 == Material.lava ? false : !this.blockBlocksFlow(var1, var2, var3, var4));
+	}
+
+	public void onBlockAdded(World var1, int var2, int var3, int var4) {
+		super.onBlockAdded(var1, var2, var3, var4);
+		if(var1.getBlockId(var2, var3, var4) == this.blockID) {
+			var1.scheduleBlockUpdate(var2, var3, var4, this.blockID, this.tickRate(var1));
+		}
+
+	}
+
+	public boolean func_82506_l() {
+		return false;
+	}
+}

src/net/minecraft/src/BlockFluid.java

@@ -0,0 +1,417 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public abstract class BlockFluid extends Block {
+	private Icon[] theIcon;
+
+	protected BlockFluid(int var1, Material var2) {
+		super(var1, var2);
+		float var3 = 0.0F;
+		float var4 = 0.0F;
+		this.setBlockBounds(0.0F + var4, 0.0F + var3, 0.0F + var4, 1.0F + var4, 1.0F + var3, 1.0F + var4);
+		this.setTickRandomly(true);
+	}
+
+	public boolean getBlocksMovement(IBlockAccess var1, int var2, int var3, int var4) {
+		return this.blockMaterial != Material.lava;
+	}
+
+	public int getBlockColor() {
+		return 16777215;
+	}
+
+	public int colorMultiplier(IBlockAccess var1, int var2, int var3, int var4) {
+		if(this.blockMaterial != Material.water) {
+			return 16777215;
+		} else {
+			int var5 = 0;
+			int var6 = 0;
+			int var7 = 0;
+
+			for(int var8 = -1; var8 <= 1; ++var8) {
+				for(int var9 = -1; var9 <= 1; ++var9) {
+					int var10 = var1.getBiomeGenForCoords(var2 + var9, var4 + var8).waterColorMultiplier;
+					var5 += (var10 & 16711680) >> 16;
+					var6 += (var10 & '\uff00') >> 8;
+					var7 += var10 & 255;
+				}
+			}
+
+			return (var5 / 9 & 255) << 16 | (var6 / 9 & 255) << 8 | var7 / 9 & 255;
+		}
+	}
+
+	public static float getFluidHeightPercent(int var0) {
+		if(var0 >= 8) {
+			var0 = 0;
+		}
+
+		return (float)(var0 + 1) / 9.0F;
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return var1 != 0 && var1 != 1 ? this.theIcon[1] : this.theIcon[0];
+	}
+
+	protected int getFlowDecay(World var1, int var2, int var3, int var4) {
+		return var1.getBlockMaterial(var2, var3, var4) == this.blockMaterial ? var1.getBlockMetadata(var2, var3, var4) : -1;
+	}
+
+	protected int getEffectiveFlowDecay(IBlockAccess var1, int var2, int var3, int var4) {
+		if(var1.getBlockMaterial(var2, var3, var4) != this.blockMaterial) {
+			return -1;
+		} else {
+			int var5 = var1.getBlockMetadata(var2, var3, var4);
+			if(var5 >= 8) {
+				var5 = 0;
+			}
+
+			return var5;
+		}
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean canCollideCheck(int var1, boolean var2) {
+		return var2 && var1 == 0;
+	}
+
+	public boolean isBlockSolid(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		Material var6 = var1.getBlockMaterial(var2, var3, var4);
+		return var6 == this.blockMaterial ? false : (var5 == 1 ? true : (var6 == Material.ice ? false : super.isBlockSolid(var1, var2, var3, var4, var5)));
+	}
+
+	public boolean shouldSideBeRendered(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		Material var6 = var1.getBlockMaterial(var2, var3, var4);
+		return var6 == this.blockMaterial ? false : (var5 == 1 ? true : (var6 == Material.ice ? false : super.shouldSideBeRendered(var1, var2, var3, var4, var5)));
+	}
+
+	public AxisAlignedBB getCollisionBoundingBoxFromPool(World var1, int var2, int var3, int var4) {
+		return null;
+	}
+
+	public int getRenderType() {
+		return 4;
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		return 0;
+	}
+
+	public int quantityDropped(Random var1) {
+		return 0;
+	}
+
+	private Vec3 getFlowVector(IBlockAccess var1, int var2, int var3, int var4) {
+		Vec3 var5 = var1.getWorldVec3Pool().getVecFromPool(0.0D, 0.0D, 0.0D);
+		int var6 = this.getEffectiveFlowDecay(var1, var2, var3, var4);
+
+		for(int var7 = 0; var7 < 4; ++var7) {
+			int var8 = var2;
+			int var10 = var4;
+			if(var7 == 0) {
+				var8 = var2 - 1;
+			}
+
+			if(var7 == 1) {
+				var10 = var4 - 1;
+			}
+
+			if(var7 == 2) {
+				++var8;
+			}
+
+			if(var7 == 3) {
+				++var10;
+			}
+
+			int var11 = this.getEffectiveFlowDecay(var1, var8, var3, var10);
+			int var12;
+			if(var11 < 0) {
+				if(!var1.getBlockMaterial(var8, var3, var10).blocksMovement()) {
+					var11 = this.getEffectiveFlowDecay(var1, var8, var3 - 1, var10);
+					if(var11 >= 0) {
+						var12 = var11 - (var6 - 8);
+						var5 = var5.addVector((double)((var8 - var2) * var12), (double)((var3 - var3) * var12), (double)((var10 - var4) * var12));
+					}
+				}
+			} else if(var11 >= 0) {
+				var12 = var11 - var6;
+				var5 = var5.addVector((double)((var8 - var2) * var12), (double)((var3 - var3) * var12), (double)((var10 - var4) * var12));
+			}
+		}
+
+		if(var1.getBlockMetadata(var2, var3, var4) >= 8) {
+			boolean var13 = false;
+			if(var13 || this.isBlockSolid(var1, var2, var3, var4 - 1, 2)) {
+				var13 = true;
+			}
+
+			if(var13 || this.isBlockSolid(var1, var2, var3, var4 + 1, 3)) {
+				var13 = true;
+			}
+
+			if(var13 || this.isBlockSolid(var1, var2 - 1, var3, var4, 4)) {
+				var13 = true;
+			}
+
+			if(var13 || this.isBlockSolid(var1, var2 + 1, var3, var4, 5)) {
+				var13 = true;
+			}
+
+			if(var13 || this.isBlockSolid(var1, var2, var3 + 1, var4 - 1, 2)) {
+				var13 = true;
+			}
+
+			if(var13 || this.isBlockSolid(var1, var2, var3 + 1, var4 + 1, 3)) {
+				var13 = true;
+			}
+
+			if(var13 || this.isBlockSolid(var1, var2 - 1, var3 + 1, var4, 4)) {
+				var13 = true;
+			}
+
+			if(var13 || this.isBlockSolid(var1, var2 + 1, var3 + 1, var4, 5)) {
+				var13 = true;
+			}
+
+			if(var13) {
+				var5 = var5.normalize().addVector(0.0D, -6.0D, 0.0D);
+			}
+		}
+
+		var5 = var5.normalize();
+		return var5;
+	}
+
+	public void velocityToAddToEntity(World var1, int var2, int var3, int var4, Entity var5, Vec3 var6) {
+		Vec3 var7 = this.getFlowVector(var1, var2, var3, var4);
+		var6.xCoord += var7.xCoord;
+		var6.yCoord += var7.yCoord;
+		var6.zCoord += var7.zCoord;
+	}
+
+	public int tickRate(World var1) {
+		return this.blockMaterial == Material.water ? 5 : (this.blockMaterial == Material.lava ? (var1.provider.hasNoSky ? 10 : 30) : 0);
+	}
+
+	public int getMixedBrightnessForBlock(IBlockAccess var1, int var2, int var3, int var4) {
+		int var5 = var1.getLightBrightnessForSkyBlocks(var2, var3, var4, 0);
+		int var6 = var1.getLightBrightnessForSkyBlocks(var2, var3 + 1, var4, 0);
+		int var7 = var5 & 255;
+		int var8 = var6 & 255;
+		int var9 = var5 >> 16 & 255;
+		int var10 = var6 >> 16 & 255;
+		return (var7 > var8 ? var7 : var8) | (var9 > var10 ? var9 : var10) << 16;
+	}
+
+	public float getBlockBrightness(IBlockAccess var1, int var2, int var3, int var4) {
+		float var5 = var1.getLightBrightness(var2, var3, var4);
+		float var6 = var1.getLightBrightness(var2, var3 + 1, var4);
+		return var5 > var6 ? var5 : var6;
+	}
+
+	public int getRenderBlockPass() {
+		return this.blockMaterial == Material.water ? 1 : 0;
+	}
+
+	public void randomDisplayTick(World var1, int var2, int var3, int var4, Random var5) {
+		int var6;
+		if(this.blockMaterial == Material.water) {
+			if(var5.nextInt(10) == 0) {
+				var6 = var1.getBlockMetadata(var2, var3, var4);
+				if(var6 <= 0 || var6 >= 8) {
+					var1.spawnParticle("suspended", (double)((float)var2 + var5.nextFloat()), (double)((float)var3 + var5.nextFloat()), (double)((float)var4 + var5.nextFloat()), 0.0D, 0.0D, 0.0D);
+				}
+			}
+
+			for(var6 = 0; var6 < 0; ++var6) {
+				int var7 = var5.nextInt(4);
+				int var8 = var2;
+				int var9 = var4;
+				if(var7 == 0) {
+					var8 = var2 - 1;
+				}
+
+				if(var7 == 1) {
+					++var8;
+				}
+
+				if(var7 == 2) {
+					var9 = var4 - 1;
+				}
+
+				if(var7 == 3) {
+					++var9;
+				}
+
+				if(var1.getBlockMaterial(var8, var3, var9) == Material.air && (var1.getBlockMaterial(var8, var3 - 1, var9).blocksMovement() || var1.getBlockMaterial(var8, var3 - 1, var9).isLiquid())) {
+					float var10 = 1.0F / 16.0F;
+					double var11 = (double)((float)var2 + var5.nextFloat());
+					double var13 = (double)((float)var3 + var5.nextFloat());
+					double var15 = (double)((float)var4 + var5.nextFloat());
+					if(var7 == 0) {
+						var11 = (double)((float)var2 - var10);
+					}
+
+					if(var7 == 1) {
+						var11 = (double)((float)(var2 + 1) + var10);
+					}
+
+					if(var7 == 2) {
+						var15 = (double)((float)var4 - var10);
+					}
+
+					if(var7 == 3) {
+						var15 = (double)((float)(var4 + 1) + var10);
+					}
+
+					double var17 = 0.0D;
+					double var19 = 0.0D;
+					if(var7 == 0) {
+						var17 = (double)(-var10);
+					}
+
+					if(var7 == 1) {
+						var17 = (double)var10;
+					}
+
+					if(var7 == 2) {
+						var19 = (double)(-var10);
+					}
+
+					if(var7 == 3) {
+						var19 = (double)var10;
+					}
+
+					var1.spawnParticle("splash", var11, var13, var15, var17, 0.0D, var19);
+				}
+			}
+		}
+
+		if(this.blockMaterial == Material.water && var5.nextInt(64) == 0) {
+			var6 = var1.getBlockMetadata(var2, var3, var4);
+			if(var6 > 0 && var6 < 8) {
+				var1.playSound((double)((float)var2 + 0.5F), (double)((float)var3 + 0.5F), (double)((float)var4 + 0.5F), "liquid.water", var5.nextFloat() * 0.25F + 12.0F / 16.0F, var5.nextFloat() * 1.0F + 0.5F, false);
+			}
+		}
+
+		double var21;
+		double var22;
+		double var23;
+		if(this.blockMaterial == Material.lava && var1.getBlockMaterial(var2, var3 + 1, var4) == Material.air && !var1.isBlockOpaqueCube(var2, var3 + 1, var4)) {
+			if(var5.nextInt(100) == 0) {
+				var21 = (double)((float)var2 + var5.nextFloat());
+				var22 = (double)var3 + this.maxY;
+				var23 = (double)((float)var4 + var5.nextFloat());
+				var1.spawnParticle("lava", var21, var22, var23, 0.0D, 0.0D, 0.0D);
+				var1.playSound(var21, var22, var23, "liquid.lavapop", 0.2F + var5.nextFloat() * 0.2F, 0.9F + var5.nextFloat() * 0.15F, false);
+			}
+
+			if(var5.nextInt(200) == 0) {
+				var1.playSound((double)var2, (double)var3, (double)var4, "liquid.lava", 0.2F + var5.nextFloat() * 0.2F, 0.9F + var5.nextFloat() * 0.15F, false);
+			}
+		}
+
+		if(var5.nextInt(10) == 0 && var1.doesBlockHaveSolidTopSurface(var2, var3 - 1, var4) && !var1.getBlockMaterial(var2, var3 - 2, var4).blocksMovement()) {
+			var21 = (double)((float)var2 + var5.nextFloat());
+			var22 = (double)var3 - 1.05D;
+			var23 = (double)((float)var4 + var5.nextFloat());
+			if(this.blockMaterial == Material.water) {
+				var1.spawnParticle("dripWater", var21, var22, var23, 0.0D, 0.0D, 0.0D);
+			} else {
+				var1.spawnParticle("dripLava", var21, var22, var23, 0.0D, 0.0D, 0.0D);
+			}
+		}
+
+	}
+
+	public static double getFlowDirection(IBlockAccess var0, int var1, int var2, int var3, Material var4) {
+		Vec3 var5 = null;
+		if(var4 == Material.water) {
+			var5 = Block.waterMoving.getFlowVector(var0, var1, var2, var3);
+		}
+
+		if(var4 == Material.lava) {
+			var5 = Block.lavaMoving.getFlowVector(var0, var1, var2, var3);
+		}
+
+		return var5.xCoord == 0.0D && var5.zCoord == 0.0D ? -1000.0D : Math.atan2(var5.zCoord, var5.xCoord) - Math.PI * 0.5D;
+	}
+
+	public void onBlockAdded(World var1, int var2, int var3, int var4) {
+		this.checkForHarden(var1, var2, var3, var4);
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+		this.checkForHarden(var1, var2, var3, var4);
+	}
+
+	private void checkForHarden(World var1, int var2, int var3, int var4) {
+		if(var1.getBlockId(var2, var3, var4) == this.blockID) {
+			if(this.blockMaterial == Material.lava) {
+				boolean var5 = false;
+				if(var5 || var1.getBlockMaterial(var2, var3, var4 - 1) == Material.water) {
+					var5 = true;
+				}
+
+				if(var5 || var1.getBlockMaterial(var2, var3, var4 + 1) == Material.water) {
+					var5 = true;
+				}
+
+				if(var5 || var1.getBlockMaterial(var2 - 1, var3, var4) == Material.water) {
+					var5 = true;
+				}
+
+				if(var5 || var1.getBlockMaterial(var2 + 1, var3, var4) == Material.water) {
+					var5 = true;
+				}
+
+				if(var5 || var1.getBlockMaterial(var2, var3 + 1, var4) == Material.water) {
+					var5 = true;
+				}
+
+				if(var5) {
+					int var6 = var1.getBlockMetadata(var2, var3, var4);
+					if(var6 == 0) {
+						var1.setBlock(var2, var3, var4, Block.obsidian.blockID);
+					} else if(var6 <= 4) {
+						var1.setBlock(var2, var3, var4, Block.cobblestone.blockID);
+					}
+
+					this.triggerLavaMixEffects(var1, var2, var3, var4);
+				}
+			}
+
+		}
+	}
+
+	protected void triggerLavaMixEffects(World var1, int var2, int var3, int var4) {
+		var1.playSoundEffect((double)((float)var2 + 0.5F), (double)((float)var3 + 0.5F), (double)((float)var4 + 0.5F), "random.fizz", 0.5F, 2.6F + (var1.rand.nextFloat() - var1.rand.nextFloat()) * 0.8F);
+
+		for(int var5 = 0; var5 < 8; ++var5) {
+			var1.spawnParticle("largesmoke", (double)var2 + Math.random(), (double)var3 + 1.2D, (double)var4 + Math.random(), 0.0D, 0.0D, 0.0D);
+		}
+
+	}
+
+	public void registerIcons(IconRegister var1) {
+		if(this.blockMaterial == Material.lava) {
+			this.theIcon = new Icon[]{var1.registerIcon("lava"), var1.registerIcon("lava_flow")};
+		} else {
+			this.theIcon = new Icon[]{var1.registerIcon("water"), var1.registerIcon("water_flow")};
+		}
+
+	}
+
+	public static Icon func_94424_b(String var0) {
+		return var0 == "water" ? Block.waterMoving.theIcon[0] : (var0 == "water_flow" ? Block.waterMoving.theIcon[1] : (var0 == "lava" ? Block.lavaMoving.theIcon[0] : (var0 == "lava_flow" ? Block.lavaMoving.theIcon[1] : null)));
+	}
+}

src/net/minecraft/src/BlockFurnace.java

@@ -0,0 +1,198 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockFurnace extends BlockContainer {
+	private final Random furnaceRand = new Random();
+	private final boolean isActive;
+	private static boolean keepFurnaceInventory = false;
+	private Icon furnaceIconTop;
+	private Icon furnaceIconFront;
+
+	protected BlockFurnace(int var1, boolean var2) {
+		super(var1, Material.rock);
+		this.isActive = var2;
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		return Block.furnaceIdle.blockID;
+	}
+
+	public void onBlockAdded(World var1, int var2, int var3, int var4) {
+		super.onBlockAdded(var1, var2, var3, var4);
+		this.setDefaultDirection(var1, var2, var3, var4);
+	}
+
+	private void setDefaultDirection(World var1, int var2, int var3, int var4) {
+		if(!var1.isRemote) {
+			int var5 = var1.getBlockId(var2, var3, var4 - 1);
+			int var6 = var1.getBlockId(var2, var3, var4 + 1);
+			int var7 = var1.getBlockId(var2 - 1, var3, var4);
+			int var8 = var1.getBlockId(var2 + 1, var3, var4);
+			byte var9 = 3;
+			if(Block.opaqueCubeLookup[var5] && !Block.opaqueCubeLookup[var6]) {
+				var9 = 3;
+			}
+
+			if(Block.opaqueCubeLookup[var6] && !Block.opaqueCubeLookup[var5]) {
+				var9 = 2;
+			}
+
+			if(Block.opaqueCubeLookup[var7] && !Block.opaqueCubeLookup[var8]) {
+				var9 = 5;
+			}
+
+			if(Block.opaqueCubeLookup[var8] && !Block.opaqueCubeLookup[var7]) {
+				var9 = 4;
+			}
+
+			var1.setBlockMetadataWithNotify(var2, var3, var4, var9, 2);
+		}
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return var1 == 1 ? this.furnaceIconTop : (var1 == 0 ? this.furnaceIconTop : (var1 != var2 ? this.blockIcon : this.furnaceIconFront));
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.blockIcon = var1.registerIcon("furnace_side");
+		this.furnaceIconFront = var1.registerIcon(this.isActive ? "furnace_front_lit" : "furnace_front");
+		this.furnaceIconTop = var1.registerIcon("furnace_top");
+	}
+
+	public void randomDisplayTick(World var1, int var2, int var3, int var4, Random var5) {
+		if(this.isActive) {
+			int var6 = var1.getBlockMetadata(var2, var3, var4);
+			float var7 = (float)var2 + 0.5F;
+			float var8 = (float)var3 + 0.0F + var5.nextFloat() * 6.0F / 16.0F;
+			float var9 = (float)var4 + 0.5F;
+			float var10 = 0.52F;
+			float var11 = var5.nextFloat() * 0.6F - 0.3F;
+			if(var6 == 4) {
+				var1.spawnParticle("smoke", (double)(var7 - var10), (double)var8, (double)(var9 + var11), 0.0D, 0.0D, 0.0D);
+				var1.spawnParticle("flame", (double)(var7 - var10), (double)var8, (double)(var9 + var11), 0.0D, 0.0D, 0.0D);
+			} else if(var6 == 5) {
+				var1.spawnParticle("smoke", (double)(var7 + var10), (double)var8, (double)(var9 + var11), 0.0D, 0.0D, 0.0D);
+				var1.spawnParticle("flame", (double)(var7 + var10), (double)var8, (double)(var9 + var11), 0.0D, 0.0D, 0.0D);
+			} else if(var6 == 2) {
+				var1.spawnParticle("smoke", (double)(var7 + var11), (double)var8, (double)(var9 - var10), 0.0D, 0.0D, 0.0D);
+				var1.spawnParticle("flame", (double)(var7 + var11), (double)var8, (double)(var9 - var10), 0.0D, 0.0D, 0.0D);
+			} else if(var6 == 3) {
+				var1.spawnParticle("smoke", (double)(var7 + var11), (double)var8, (double)(var9 + var10), 0.0D, 0.0D, 0.0D);
+				var1.spawnParticle("flame", (double)(var7 + var11), (double)var8, (double)(var9 + var10), 0.0D, 0.0D, 0.0D);
+			}
+
+		}
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		if(var1.isRemote) {
+			return true;
+		} else {
+			TileEntityFurnace var10 = (TileEntityFurnace)var1.getBlockTileEntity(var2, var3, var4);
+			if(var10 != null) {
+				var5.displayGUIFurnace(var10);
+			}
+
+			return true;
+		}
+	}
+
+	public static void updateFurnaceBlockState(boolean var0, World var1, int var2, int var3, int var4) {
+		int var5 = var1.getBlockMetadata(var2, var3, var4);
+		TileEntity var6 = var1.getBlockTileEntity(var2, var3, var4);
+		keepFurnaceInventory = true;
+		if(var0) {
+			var1.setBlock(var2, var3, var4, Block.furnaceBurning.blockID);
+		} else {
+			var1.setBlock(var2, var3, var4, Block.furnaceIdle.blockID);
+		}
+
+		keepFurnaceInventory = false;
+		var1.setBlockMetadataWithNotify(var2, var3, var4, var5, 2);
+		if(var6 != null) {
+			var6.validate();
+			var1.setBlockTileEntity(var2, var3, var4, var6);
+		}
+
+	}
+
+	public TileEntity createNewTileEntity(World var1) {
+		return new TileEntityFurnace();
+	}
+
+	public void onBlockPlacedBy(World var1, int var2, int var3, int var4, EntityLiving var5, ItemStack var6) {
+		int var7 = MathHelper.floor_double((double)(var5.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;
+		if(var7 == 0) {
+			var1.setBlockMetadataWithNotify(var2, var3, var4, 2, 2);
+		}
+
+		if(var7 == 1) {
+			var1.setBlockMetadataWithNotify(var2, var3, var4, 5, 2);
+		}
+
+		if(var7 == 2) {
+			var1.setBlockMetadataWithNotify(var2, var3, var4, 3, 2);
+		}
+
+		if(var7 == 3) {
+			var1.setBlockMetadataWithNotify(var2, var3, var4, 4, 2);
+		}
+
+		if(var6.hasDisplayName()) {
+			((TileEntityFurnace)var1.getBlockTileEntity(var2, var3, var4)).func_94129_a(var6.getDisplayName());
+		}
+
+	}
+
+	public void breakBlock(World var1, int var2, int var3, int var4, int var5, int var6) {
+		if(!keepFurnaceInventory) {
+			TileEntityFurnace var7 = (TileEntityFurnace)var1.getBlockTileEntity(var2, var3, var4);
+			if(var7 != null) {
+				for(int var8 = 0; var8 < var7.getSizeInventory(); ++var8) {
+					ItemStack var9 = var7.getStackInSlot(var8);
+					if(var9 != null) {
+						float var10 = this.furnaceRand.nextFloat() * 0.8F + 0.1F;
+						float var11 = this.furnaceRand.nextFloat() * 0.8F + 0.1F;
+						float var12 = this.furnaceRand.nextFloat() * 0.8F + 0.1F;
+
+						while(var9.stackSize > 0) {
+							int var13 = this.furnaceRand.nextInt(21) + 10;
+							if(var13 > var9.stackSize) {
+								var13 = var9.stackSize;
+							}
+
+							var9.stackSize -= var13;
+							EntityItem var14 = new EntityItem(var1, (double)((float)var2 + var10), (double)((float)var3 + var11), (double)((float)var4 + var12), new ItemStack(var9.itemID, var13, var9.getItemDamage()));
+							if(var9.hasTagCompound()) {
+								var14.getEntityItem().setTagCompound((NBTTagCompound)var9.getTagCompound().copy());
+							}
+
+							float var15 = 0.05F;
+							var14.motionX = (double)((float)this.furnaceRand.nextGaussian() * var15);
+							var14.motionY = (double)((float)this.furnaceRand.nextGaussian() * var15 + 0.2F);
+							var14.motionZ = (double)((float)this.furnaceRand.nextGaussian() * var15);
+							var1.spawnEntityInWorld(var14);
+						}
+					}
+				}
+
+				var1.func_96440_m(var2, var3, var4, var5);
+			}
+		}
+
+		super.breakBlock(var1, var2, var3, var4, var5, var6);
+	}
+
+	public boolean hasComparatorInputOverride() {
+		return true;
+	}
+
+	public int getComparatorInputOverride(World var1, int var2, int var3, int var4, int var5) {
+		return Container.calcRedstoneFromInventory((IInventory)var1.getBlockTileEntity(var2, var3, var4));
+	}
+
+	public int idPicked(World var1, int var2, int var3, int var4) {
+		return Block.furnaceIdle.blockID;
+	}
+}

src/net/minecraft/src/BlockGlass.java

@@ -0,0 +1,30 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockGlass extends BlockBreakable {
+	public BlockGlass(int var1, Material var2, boolean var3) {
+		super(var1, "glass", var2, var3);
+		this.setCreativeTab(CreativeTabs.tabBlock);
+	}
+
+	public int quantityDropped(Random var1) {
+		return 0;
+	}
+
+	public int getRenderBlockPass() {
+		return 0;
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	protected boolean canSilkHarvest() {
+		return true;
+	}
+}

src/net/minecraft/src/BlockGlowStone.java

@@ -0,0 +1,22 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockGlowStone extends Block {
+	public BlockGlowStone(int var1, Material var2) {
+		super(var1, var2);
+		this.setCreativeTab(CreativeTabs.tabBlock);
+	}
+
+	public int quantityDroppedWithBonus(int var1, Random var2) {
+		return MathHelper.clamp_int(this.quantityDropped(var2) + var2.nextInt(var1 + 1), 1, 4);
+	}
+
+	public int quantityDropped(Random var1) {
+		return 2 + var1.nextInt(3);
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		return Item.lightStoneDust.itemID;
+	}
+}

src/net/minecraft/src/BlockGrass.java

@@ -0,0 +1,91 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockGrass extends Block {
+	private Icon iconGrassTop;
+	private Icon iconSnowSide;
+	private Icon iconGrassSideOverlay;
+
+	protected BlockGrass(int var1) {
+		super(var1, Material.grass);
+		this.setTickRandomly(true);
+		this.setCreativeTab(CreativeTabs.tabBlock);
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return var1 == 1 ? this.iconGrassTop : (var1 == 0 ? Block.dirt.getBlockTextureFromSide(var1) : this.blockIcon);
+	}
+
+	public Icon getBlockTexture(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		if(var5 == 1) {
+			return this.iconGrassTop;
+		} else if(var5 == 0) {
+			return Block.dirt.getBlockTextureFromSide(var5);
+		} else {
+			Material var6 = var1.getBlockMaterial(var2, var3 + 1, var4);
+			return var6 != Material.snow && var6 != Material.craftedSnow ? this.blockIcon : this.iconSnowSide;
+		}
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.blockIcon = var1.registerIcon("grass_side");
+		this.iconGrassTop = var1.registerIcon("grass_top");
+		this.iconSnowSide = var1.registerIcon("snow_side");
+		this.iconGrassSideOverlay = var1.registerIcon("grass_side_overlay");
+	}
+
+	public int getBlockColor() {
+		double var1 = 0.5D;
+		double var3 = 1.0D;
+		return ColorizerGrass.getGrassColor(var1, var3);
+	}
+
+	public int getRenderColor(int var1) {
+		return this.getBlockColor();
+	}
+
+	public int colorMultiplier(IBlockAccess var1, int var2, int var3, int var4) {
+		int var5 = 0;
+		int var6 = 0;
+		int var7 = 0;
+
+		for(int var8 = -1; var8 <= 1; ++var8) {
+			for(int var9 = -1; var9 <= 1; ++var9) {
+				int var10 = var1.getBiomeGenForCoords(var2 + var9, var4 + var8).getBiomeGrassColor();
+				var5 += (var10 & 16711680) >> 16;
+				var6 += (var10 & '\uff00') >> 8;
+				var7 += var10 & 255;
+			}
+		}
+
+		return (var5 / 9 & 255) << 16 | (var6 / 9 & 255) << 8 | var7 / 9 & 255;
+	}
+
+	public void updateTick(World var1, int var2, int var3, int var4, Random var5) {
+		if(!var1.isRemote) {
+			if(var1.getBlockLightValue(var2, var3 + 1, var4) < 4 && Block.lightOpacity[var1.getBlockId(var2, var3 + 1, var4)] > 2) {
+				var1.setBlock(var2, var3, var4, Block.dirt.blockID);
+			} else if(var1.getBlockLightValue(var2, var3 + 1, var4) >= 9) {
+				for(int var6 = 0; var6 < 4; ++var6) {
+					int var7 = var2 + var5.nextInt(3) - 1;
+					int var8 = var3 + var5.nextInt(5) - 3;
+					int var9 = var4 + var5.nextInt(3) - 1;
+					int var10 = var1.getBlockId(var7, var8 + 1, var9);
+					if(var1.getBlockId(var7, var8, var9) == Block.dirt.blockID && var1.getBlockLightValue(var7, var8 + 1, var9) >= 4 && Block.lightOpacity[var10] <= 2) {
+						var1.setBlock(var7, var8, var9, Block.grass.blockID);
+					}
+				}
+			}
+
+		}
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		return Block.dirt.idDropped(0, var2, var3);
+	}
+
+	public static Icon getIconSideOverlay() {
+		return Block.grass.iconGrassSideOverlay;
+	}
+}

src/net/minecraft/src/BlockGravel.java

@@ -0,0 +1,17 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockGravel extends BlockSand {
+	public BlockGravel(int var1) {
+		super(var1);
+	}
+
+	public int idDropped(int var1, Random var2, int var3) {
+		if(var3 > 3) {
+			var3 = 3;
+		}
+
+		return var2.nextInt(10 - var3 * 3) == 0 ? Item.flint.itemID : this.blockID;
+	}
+}

src/net/minecraft/src/BlockHalfSlab.java

@@ -0,0 +1,96 @@
+package net.minecraft.src;
+
+import java.util.List;
+import java.util.Random;
+
+public abstract class BlockHalfSlab extends Block {
+	protected final boolean isDoubleSlab;
+
+	public BlockHalfSlab(int var1, boolean var2, Material var3) {
+		super(var1, var3);
+		this.isDoubleSlab = var2;
+		if(var2) {
+			opaqueCubeLookup[var1] = true;
+		} else {
+			this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.5F, 1.0F);
+		}
+
+		this.setLightOpacity(255);
+	}
+
+	public void setBlockBoundsBasedOnState(IBlockAccess var1, int var2, int var3, int var4) {
+		if(this.isDoubleSlab) {
+			this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
+		} else {
+			boolean var5 = (var1.getBlockMetadata(var2, var3, var4) & 8) != 0;
+			if(var5) {
+				this.setBlockBounds(0.0F, 0.5F, 0.0F, 1.0F, 1.0F, 1.0F);
+			} else {
+				this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.5F, 1.0F);
+			}
+		}
+
+	}
+
+	public void setBlockBoundsForItemRender() {
+		if(this.isDoubleSlab) {
+			this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
+		} else {
+			this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.5F, 1.0F);
+		}
+
+	}
+
+	public void addCollisionBoxesToList(World var1, int var2, int var3, int var4, AxisAlignedBB var5, List var6, Entity var7) {
+		this.setBlockBoundsBasedOnState(var1, var2, var3, var4);
+		super.addCollisionBoxesToList(var1, var2, var3, var4, var5, var6, var7);
+	}
+
+	public boolean isOpaqueCube() {
+		return this.isDoubleSlab;
+	}
+
+	public int onBlockPlaced(World var1, int var2, int var3, int var4, int var5, float var6, float var7, float var8, int var9) {
+		return this.isDoubleSlab ? var9 : (var5 != 0 && (var5 == 1 || (double)var7 <= 0.5D) ? var9 : var9 | 8);
+	}
+
+	public int quantityDropped(Random var1) {
+		return this.isDoubleSlab ? 2 : 1;
+	}
+
+	public int damageDropped(int var1) {
+		return var1 & 7;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return this.isDoubleSlab;
+	}
+
+	public boolean shouldSideBeRendered(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		if(this.isDoubleSlab) {
+			return super.shouldSideBeRendered(var1, var2, var3, var4, var5);
+		} else if(var5 != 1 && var5 != 0 && !super.shouldSideBeRendered(var1, var2, var3, var4, var5)) {
+			return false;
+		} else {
+			int var6 = var2 + Facing.offsetsXForSide[Facing.oppositeSide[var5]];
+			int var7 = var3 + Facing.offsetsYForSide[Facing.oppositeSide[var5]];
+			int var8 = var4 + Facing.offsetsZForSide[Facing.oppositeSide[var5]];
+			boolean var9 = (var1.getBlockMetadata(var6, var7, var8) & 8) != 0;
+			return var9 ? (var5 == 0 ? true : (var5 == 1 && super.shouldSideBeRendered(var1, var2, var3, var4, var5) ? true : !isBlockSingleSlab(var1.getBlockId(var2, var3, var4)) || (var1.getBlockMetadata(var2, var3, var4) & 8) == 0)) : (var5 == 1 ? true : (var5 == 0 && super.shouldSideBeRendered(var1, var2, var3, var4, var5) ? true : !isBlockSingleSlab(var1.getBlockId(var2, var3, var4)) || (var1.getBlockMetadata(var2, var3, var4) & 8) != 0));
+		}
+	}
+
+	private static boolean isBlockSingleSlab(int var0) {
+		return var0 == Block.stoneSingleSlab.blockID || var0 == Block.woodSingleSlab.blockID;
+	}
+
+	public abstract String getFullSlabName(int var1);
+
+	public int getDamageValue(World var1, int var2, int var3, int var4) {
+		return super.getDamageValue(var1, var2, var3, var4) & 7;
+	}
+
+	public int idPicked(World var1, int var2, int var3, int var4) {
+		return isBlockSingleSlab(this.blockID) ? this.blockID : (this.blockID == Block.stoneDoubleSlab.blockID ? Block.stoneSingleSlab.blockID : (this.blockID == Block.woodDoubleSlab.blockID ? Block.woodSingleSlab.blockID : Block.stoneSingleSlab.blockID));
+	}
+}

src/net/minecraft/src/BlockHopper.java

@@ -0,0 +1,182 @@
+package net.minecraft.src;
+
+import java.util.List;
+import java.util.Random;
+
+public class BlockHopper extends BlockContainer {
+	private final Random field_94457_a = new Random();
+	private Icon hopperIcon;
+	private Icon hopperTopIcon;
+	private Icon hopperInsideIcon;
+
+	public BlockHopper(int var1) {
+		super(var1, Material.iron);
+		this.setCreativeTab(CreativeTabs.tabRedstone);
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
+	}
+
+	public void setBlockBoundsBasedOnState(IBlockAccess var1, int var2, int var3, int var4) {
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
+	}
+
+	public void addCollisionBoxesToList(World var1, int var2, int var3, int var4, AxisAlignedBB var5, List var6, Entity var7) {
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 10.0F / 16.0F, 1.0F);
+		super.addCollisionBoxesToList(var1, var2, var3, var4, var5, var6, var7);
+		float var8 = 2.0F / 16.0F;
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, var8, 1.0F, 1.0F);
+		super.addCollisionBoxesToList(var1, var2, var3, var4, var5, var6, var7);
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, var8);
+		super.addCollisionBoxesToList(var1, var2, var3, var4, var5, var6, var7);
+		this.setBlockBounds(1.0F - var8, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
+		super.addCollisionBoxesToList(var1, var2, var3, var4, var5, var6, var7);
+		this.setBlockBounds(0.0F, 0.0F, 1.0F - var8, 1.0F, 1.0F, 1.0F);
+		super.addCollisionBoxesToList(var1, var2, var3, var4, var5, var6, var7);
+		this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
+	}
+
+	public int onBlockPlaced(World var1, int var2, int var3, int var4, int var5, float var6, float var7, float var8, int var9) {
+		int var10 = Facing.oppositeSide[var5];
+		if(var10 == 1) {
+			var10 = 0;
+		}
+
+		return var10;
+	}
+
+	public TileEntity createNewTileEntity(World var1) {
+		return new TileEntityHopper();
+	}
+
+	public void onBlockPlacedBy(World var1, int var2, int var3, int var4, EntityLiving var5, ItemStack var6) {
+		super.onBlockPlacedBy(var1, var2, var3, var4, var5, var6);
+		if(var6.hasDisplayName()) {
+			TileEntityHopper var7 = getHopperTile(var1, var2, var3, var4);
+			var7.setInventoryName(var6.getDisplayName());
+		}
+
+	}
+
+	public void onBlockAdded(World var1, int var2, int var3, int var4) {
+		super.onBlockAdded(var1, var2, var3, var4);
+		this.updateMetadata(var1, var2, var3, var4);
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		if(var1.isRemote) {
+			return true;
+		} else {
+			TileEntityHopper var10 = getHopperTile(var1, var2, var3, var4);
+			if(var10 != null) {
+				var5.displayGUIHopper(var10);
+			}
+
+			return true;
+		}
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+		this.updateMetadata(var1, var2, var3, var4);
+	}
+
+	private void updateMetadata(World var1, int var2, int var3, int var4) {
+		int var5 = var1.getBlockMetadata(var2, var3, var4);
+		int var6 = getDirectionFromMetadata(var5);
+		boolean var7 = !var1.isBlockIndirectlyGettingPowered(var2, var3, var4);
+		boolean var8 = getIsBlockNotPoweredFromMetadata(var5);
+		if(var7 != var8) {
+			var1.setBlockMetadataWithNotify(var2, var3, var4, var6 | (var7 ? 0 : 8), 4);
+		}
+
+	}
+
+	public void breakBlock(World var1, int var2, int var3, int var4, int var5, int var6) {
+		TileEntityHopper var7 = (TileEntityHopper)var1.getBlockTileEntity(var2, var3, var4);
+		if(var7 != null) {
+			for(int var8 = 0; var8 < var7.getSizeInventory(); ++var8) {
+				ItemStack var9 = var7.getStackInSlot(var8);
+				if(var9 != null) {
+					float var10 = this.field_94457_a.nextFloat() * 0.8F + 0.1F;
+					float var11 = this.field_94457_a.nextFloat() * 0.8F + 0.1F;
+					float var12 = this.field_94457_a.nextFloat() * 0.8F + 0.1F;
+
+					while(var9.stackSize > 0) {
+						int var13 = this.field_94457_a.nextInt(21) + 10;
+						if(var13 > var9.stackSize) {
+							var13 = var9.stackSize;
+						}
+
+						var9.stackSize -= var13;
+						EntityItem var14 = new EntityItem(var1, (double)((float)var2 + var10), (double)((float)var3 + var11), (double)((float)var4 + var12), new ItemStack(var9.itemID, var13, var9.getItemDamage()));
+						if(var9.hasTagCompound()) {
+							var14.getEntityItem().setTagCompound((NBTTagCompound)var9.getTagCompound().copy());
+						}
+
+						float var15 = 0.05F;
+						var14.motionX = (double)((float)this.field_94457_a.nextGaussian() * var15);
+						var14.motionY = (double)((float)this.field_94457_a.nextGaussian() * var15 + 0.2F);
+						var14.motionZ = (double)((float)this.field_94457_a.nextGaussian() * var15);
+						var1.spawnEntityInWorld(var14);
+					}
+				}
+			}
+
+			var1.func_96440_m(var2, var3, var4, var5);
+		}
+
+		super.breakBlock(var1, var2, var3, var4, var5, var6);
+	}
+
+	public int getRenderType() {
+		return 38;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean shouldSideBeRendered(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return true;
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return var1 == 1 ? this.hopperTopIcon : this.hopperIcon;
+	}
+
+	public static int getDirectionFromMetadata(int var0) {
+		return var0 & 7;
+	}
+
+	public static boolean getIsBlockNotPoweredFromMetadata(int var0) {
+		return (var0 & 8) != 8;
+	}
+
+	public boolean hasComparatorInputOverride() {
+		return true;
+	}
+
+	public int getComparatorInputOverride(World var1, int var2, int var3, int var4, int var5) {
+		return Container.calcRedstoneFromInventory(getHopperTile(var1, var2, var3, var4));
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.hopperIcon = var1.registerIcon("hopper");
+		this.hopperTopIcon = var1.registerIcon("hopper_top");
+		this.hopperInsideIcon = var1.registerIcon("hopper_inside");
+	}
+
+	public static Icon getHopperIcon(String var0) {
+		return var0 == "hopper" ? Block.hopperBlock.hopperIcon : (var0 == "hopper_inside" ? Block.hopperBlock.hopperInsideIcon : null);
+	}
+
+	public String getItemIconName() {
+		return "hopper";
+	}
+
+	public static TileEntityHopper getHopperTile(IBlockAccess var0, int var1, int var2, int var3) {
+		return (TileEntityHopper)var0.getBlockTileEntity(var1, var2, var3);
+	}
+}

src/net/minecraft/src/BlockIce.java

@@ -0,0 +1,65 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockIce extends BlockBreakable {
+	public BlockIce(int var1) {
+		super(var1, "ice", Material.ice, false);
+		this.slipperiness = 0.98F;
+		this.setTickRandomly(true);
+		this.setCreativeTab(CreativeTabs.tabBlock);
+	}
+
+	public int getRenderBlockPass() {
+		return 1;
+	}
+
+	public boolean shouldSideBeRendered(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return super.shouldSideBeRendered(var1, var2, var3, var4, 1 - var5);
+	}
+
+	public void harvestBlock(World var1, EntityPlayer var2, int var3, int var4, int var5, int var6) {
+		var2.addStat(StatList.mineBlockStatArray[this.blockID], 1);
+		var2.addExhaustion(0.025F);
+		if(this.canSilkHarvest() && EnchantmentHelper.getSilkTouchModifier(var2)) {
+			ItemStack var9 = this.createStackedBlock(var6);
+			if(var9 != null) {
+				this.dropBlockAsItem_do(var1, var3, var4, var5, var9);
+			}
+		} else {
+			if(var1.provider.isHellWorld) {
+				var1.setBlockToAir(var3, var4, var5);
+				return;
+			}
+
+			int var7 = EnchantmentHelper.getFortuneModifier(var2);
+			this.dropBlockAsItem(var1, var3, var4, var5, var6, var7);
+			Material var8 = var1.getBlockMaterial(var3, var4 - 1, var5);
+			if(var8.blocksMovement() || var8.isLiquid()) {
+				var1.setBlock(var3, var4, var5, Block.waterMoving.blockID);
+			}
+		}
+
+	}
+
+	public int quantityDropped(Random var1) {
+		return 0;
+	}
+
+	public void updateTick(World var1, int var2, int var3, int var4, Random var5) {
+		if(var1.getSavedLightValue(EnumSkyBlock.Block, var2, var3, var4) > 11 - Block.lightOpacity[this.blockID]) {
+			if(var1.provider.isHellWorld) {
+				var1.setBlockToAir(var2, var3, var4);
+				return;
+			}
+
+			this.dropBlockAsItem(var1, var2, var3, var4, var1.getBlockMetadata(var2, var3, var4), 0);
+			var1.setBlock(var2, var3, var4, Block.waterStill.blockID);
+		}
+
+	}
+
+	public int getMobilityFlag() {
+		return 0;
+	}
+}

src/net/minecraft/src/BlockJukeBox.java

@@ -0,0 +1,85 @@
+package net.minecraft.src;
+
+public class BlockJukeBox extends BlockContainer {
+	private Icon theIcon;
+
+	protected BlockJukeBox(int var1) {
+		super(var1, Material.wood);
+		this.setCreativeTab(CreativeTabs.tabDecorations);
+	}
+
+	public Icon getIcon(int var1, int var2) {
+		return var1 == 1 ? this.theIcon : this.blockIcon;
+	}
+
+	public boolean onBlockActivated(World var1, int var2, int var3, int var4, EntityPlayer var5, int var6, float var7, float var8, float var9) {
+		if(var1.getBlockMetadata(var2, var3, var4) == 0) {
+			return false;
+		} else {
+			this.ejectRecord(var1, var2, var3, var4);
+			return true;
+		}
+	}
+
+	public void insertRecord(World var1, int var2, int var3, int var4, ItemStack var5) {
+		if(!var1.isRemote) {
+			TileEntityRecordPlayer var6 = (TileEntityRecordPlayer)var1.getBlockTileEntity(var2, var3, var4);
+			if(var6 != null) {
+				var6.func_96098_a(var5.copy());
+				var1.setBlockMetadataWithNotify(var2, var3, var4, 1, 2);
+			}
+		}
+	}
+
+	public void ejectRecord(World var1, int var2, int var3, int var4) {
+		if(!var1.isRemote) {
+			TileEntityRecordPlayer var5 = (TileEntityRecordPlayer)var1.getBlockTileEntity(var2, var3, var4);
+			if(var5 != null) {
+				ItemStack var6 = var5.func_96097_a();
+				if(var6 != null) {
+					var1.playAuxSFX(1005, var2, var3, var4, 0);
+					var1.playRecord((String)null, var2, var3, var4);
+					var5.func_96098_a((ItemStack)null);
+					var1.setBlockMetadataWithNotify(var2, var3, var4, 0, 2);
+					float var7 = 0.7F;
+					double var8 = (double)(var1.rand.nextFloat() * var7) + (double)(1.0F - var7) * 0.5D;
+					double var10 = (double)(var1.rand.nextFloat() * var7) + (double)(1.0F - var7) * 0.2D + 0.6D;
+					double var12 = (double)(var1.rand.nextFloat() * var7) + (double)(1.0F - var7) * 0.5D;
+					ItemStack var14 = var6.copy();
+					EntityItem var15 = new EntityItem(var1, (double)var2 + var8, (double)var3 + var10, (double)var4 + var12, var14);
+					var15.delayBeforeCanPickup = 10;
+					var1.spawnEntityInWorld(var15);
+				}
+			}
+		}
+	}
+
+	public void breakBlock(World var1, int var2, int var3, int var4, int var5, int var6) {
+		this.ejectRecord(var1, var2, var3, var4);
+		super.breakBlock(var1, var2, var3, var4, var5, var6);
+	}
+
+	public void dropBlockAsItemWithChance(World var1, int var2, int var3, int var4, int var5, float var6, int var7) {
+		if(!var1.isRemote) {
+			super.dropBlockAsItemWithChance(var1, var2, var3, var4, var5, var6, 0);
+		}
+	}
+
+	public TileEntity createNewTileEntity(World var1) {
+		return new TileEntityRecordPlayer();
+	}
+
+	public void registerIcons(IconRegister var1) {
+		this.blockIcon = var1.registerIcon("musicBlock");
+		this.theIcon = var1.registerIcon("jukebox_top");
+	}
+
+	public boolean hasComparatorInputOverride() {
+		return true;
+	}
+
+	public int getComparatorInputOverride(World var1, int var2, int var3, int var4, int var5) {
+		ItemStack var6 = ((TileEntityRecordPlayer)var1.getBlockTileEntity(var2, var3, var4)).func_96097_a();
+		return var6 == null ? 0 : var6.itemID + 1 - Item.record13.itemID;
+	}
+}

src/net/minecraft/src/BlockLadder.java

@@ -0,0 +1,112 @@
+package net.minecraft.src;
+
+import java.util.Random;
+
+public class BlockLadder extends Block {
+	protected BlockLadder(int var1) {
+		super(var1, Material.circuits);
+		this.setCreativeTab(CreativeTabs.tabDecorations);
+	}
+
+	public AxisAlignedBB getCollisionBoundingBoxFromPool(World var1, int var2, int var3, int var4) {
+		this.setBlockBoundsBasedOnState(var1, var2, var3, var4);
+		return super.getCollisionBoundingBoxFromPool(var1, var2, var3, var4);
+	}
+
+	public AxisAlignedBB getSelectedBoundingBoxFromPool(World var1, int var2, int var3, int var4) {
+		this.setBlockBoundsBasedOnState(var1, var2, var3, var4);
+		return super.getSelectedBoundingBoxFromPool(var1, var2, var3, var4);
+	}
+
+	public void setBlockBoundsBasedOnState(IBlockAccess var1, int var2, int var3, int var4) {
+		this.updateLadderBounds(var1.getBlockMetadata(var2, var3, var4));
+	}
+
+	public void updateLadderBounds(int var1) {
+		float var3 = 2.0F / 16.0F;
+		if(var1 == 2) {
+			this.setBlockBounds(0.0F, 0.0F, 1.0F - var3, 1.0F, 1.0F, 1.0F);
+		}
+
+		if(var1 == 3) {
+			this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, var3);
+		}
+
+		if(var1 == 4) {
+			this.setBlockBounds(1.0F - var3, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
+		}
+
+		if(var1 == 5) {
+			this.setBlockBounds(0.0F, 0.0F, 0.0F, var3, 1.0F, 1.0F);
+		}
+
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public int getRenderType() {
+		return 8;
+	}
+
+	public boolean canPlaceBlockAt(World var1, int var2, int var3, int var4) {
+		return var1.isBlockNormalCube(var2 - 1, var3, var4) ? true : (var1.isBlockNormalCube(var2 + 1, var3, var4) ? true : (var1.isBlockNormalCube(var2, var3, var4 - 1) ? true : var1.isBlockNormalCube(var2, var3, var4 + 1)));
+	}
+
+	public int onBlockPlaced(World var1, int var2, int var3, int var4, int var5, float var6, float var7, float var8, int var9) {
+		int var10 = var9;
+		if((var9 == 0 || var5 == 2) && var1.isBlockNormalCube(var2, var3, var4 + 1)) {
+			var10 = 2;
+		}
+
+		if((var10 == 0 || var5 == 3) && var1.isBlockNormalCube(var2, var3, var4 - 1)) {
+			var10 = 3;
+		}
+
+		if((var10 == 0 || var5 == 4) && var1.isBlockNormalCube(var2 + 1, var3, var4)) {
+			var10 = 4;
+		}
+
+		if((var10 == 0 || var5 == 5) && var1.isBlockNormalCube(var2 - 1, var3, var4)) {
+			var10 = 5;
+		}
+
+		return var10;
+	}
+
+	public void onNeighborBlockChange(World var1, int var2, int var3, int var4, int var5) {
+		int var6 = var1.getBlockMetadata(var2, var3, var4);
+		boolean var7 = false;
+		if(var6 == 2 && var1.isBlockNormalCube(var2, var3, var4 + 1)) {
+			var7 = true;
+		}
+
+		if(var6 == 3 && var1.isBlockNormalCube(var2, var3, var4 - 1)) {
+			var7 = true;
+		}
+
+		if(var6 == 4 && var1.isBlockNormalCube(var2 + 1, var3, var4)) {
+			var7 = true;
+		}
+
+		if(var6 == 5 && var1.isBlockNormalCube(var2 - 1, var3, var4)) {
+			var7 = true;
+		}
+
+		if(!var7) {
+			this.dropBlockAsItem(var1, var2, var3, var4, var6, 0);
+			var1.setBlockToAir(var2, var3, var4);
+		}
+
+		super.onNeighborBlockChange(var1, var2, var3, var4, var5);
+	}
+
+	public int quantityDropped(Random var1) {
+		return 1;
+	}
+}