tagged 1.2.5

Added a new hook to support custom enchantments.

forge/forge_client/.classpath

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="src" path="forge_common"/>
-	<classpathentry kind="src" path="minecraft"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
-	<classpathentry kind="lib" path="../../jars/bin/jinput.jar"/>
-	<classpathentry kind="lib" path="../../jars/bin/lwjgl.jar"/>
-	<classpathentry kind="lib" path="../../jars/bin/lwjgl_util.jar"/>
-	<classpathentry kind="lib" path="../../jars/bin/minecraft.jar"/>
-	<classpathentry kind="output" path="bin"/>
-</classpath>

forge/forge_client/.project

@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>forge_client</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-	</natures>
-	<linkedResources>
-		<link>
-			<name>forge_common</name>
-			<type>2</type>
-			<locationURI>PARENT-1-PROJECT_LOC/forge_common</locationURI>
-		</link>
-		<link>
-			<name>minecraft</name>
-			<type>2</type>
-			<locationURI>PARENT-1-WORKSPACE_LOC/src_work/minecraft</locationURI>
-		</link>
-	</linkedResources>
-</projectDescription>

forge/forge_common/net/minecraft/src/forge/MinecraftForge.java

@@ -1,368 +0,0 @@
-/**
- * This software is provided under the terms of the Minecraft Forge Public 
- * License v1.0.
- */
-
-package net.minecraft.src.forge;
-
-import net.minecraft.src.Block;
-import net.minecraft.src.Item;
-import net.minecraft.src.ItemStack;
-import net.minecraft.src.World;
-
-import java.util.*;
-
-public class MinecraftForge {
-
-    private static LinkedList<IBucketHandler> bucketHandlers = new LinkedList<IBucketHandler>();
-    /**
-     * Register a new custom bucket handler.
-     */
-    public static void registerCustomBucketHandler(IBucketHandler handler) {
-        bucketHandlers.add(handler);
-    }
-
-    /**
-     * Registers a new sleeping handler.
-     */
-    public static void registerSleepHandler(ISleepHandler handler) {
-	ForgeHooks.sleepHandlers.add(handler);
-    }
-
-    /**
-     * Registers a new bonemeal handler.
-     */
-    public static void registerBonemealHandler(IBonemealHandler handler) {
-	ForgeHooks.bonemealHandlers.add(handler);
-    }
-
-    /**
-     * Registers a new hoe handler.
-     */
-    public static void registerHoeHandler(IHoeHandler handler) {
-	ForgeHooks.hoeHandlers.add(handler);
-    }
-
-    /**
-     * Registers a new destroy tool handler.
-     */
-    public static void registerDestroyToolHandler(IDestroyToolHandler handler) {
-	ForgeHooks.destroyToolHandlers.add(handler);
-    }
-
-    /**
-     * Registers a new crafting handler.
-     */
-    public static void registerCraftingHandler(ICraftingHandler handler) {
-        ForgeHooks.craftingHandlers.add(handler);
-    }
-
-    /**
-     * This is not supposed to be called outside of Minecraft internals.
-     */
-    public static ItemStack fillCustomBucket(World w, int i, int j, int k) {
-        for (IBucketHandler handler : bucketHandlers) {
-            ItemStack stack = handler.fillCustomBucket(w, i, j, k);
-
-            if (stack != null) {
-                return stack;
-            }
-        }
-
-        return null;
-    }
-
-    // Ore Dictionary
-    // ------------------------------------------------------------
-    private static LinkedList<IOreHandler> oreHandlers = new LinkedList<IOreHandler>();
-    private static TreeMap<String,List<ItemStack>> oreDict=
-	    new TreeMap<String,List<ItemStack>>();
-
-    /** Register a new ore handler.  This will automatically call the handler
-     * with all current ores during registration, and every time a new ore is
-     * added later.
-     */
-    public static void registerOreHandler(IOreHandler handler) {
-	    oreHandlers.add(handler);
-
-	    for(String key : oreDict.keySet()) {
-		    List<ItemStack> val=oreDict.get(key);
-		    for(ItemStack ist : val) {
-			    handler.registerOre(key,ist);
-		    }
-	    }
-    }
-
-    /** Register a new item with the ore dictionary.
-     * @param oreClass The string class of the ore.
-     * @param ore The ItemStack for the ore.
-     */
-    public static void registerOre(String oreClass, ItemStack ore) {
-	    List<ItemStack> orelist=oreDict.get(oreClass);
-	    if(orelist==null) {
-		    orelist=new ArrayList<ItemStack>();
-		    oreDict.put(oreClass,orelist);
-	    }
-	    orelist.add(ore);
-	    for(IOreHandler ioh : oreHandlers) {
-		    ioh.registerOre(oreClass,ore);
-	    }
-    }
-
-    /** Get the list of ores in a given class.
-     */
-    public static List<ItemStack> getOreClass(String oreClass) {
-	    return oreDict.get(oreClass);
-    }
-
-    public static class OreQuery implements Iterable<Object[]> {
-	    Object[] proto;
-
-	    public class OreQueryIterator implements Iterator<Object[]> {
-		    LinkedList itering;
-		    LinkedList output;
-
-		    private OreQueryIterator() {
-			    itering=new LinkedList();
-			    output=new LinkedList();
-
-			    for(int i=0; i<proto.length; i++) {
-				    if(proto[i] instanceof Collection) {
-					    Iterator it=((Collection)proto[i])
-						    .iterator();
-					    if(!it.hasNext()) {
-						    output=null; break;
-					    }
-					    itering.addLast(it);
-					    output.addLast(it.next());
-				    } else {
-					    itering.addLast(proto[i]);
-					    output.addLast(proto[i]);
-				    }
-			    }
-		    }
-
-		    public boolean hasNext() {
-			    return output!=null;
-		    }
-
-		    public Object[] next() {
-			    Object[] tr=output.toArray();
-
-			    Object to;
-			    while(true) {
-				    if(itering.size()==0) {
-					    output=null;
-					    return tr;
-				    }
-				    to=itering.getLast();
-				    output.removeLast();
-				    if(to instanceof Iterator) {
-					    Iterator it=(Iterator)to;
-					    if(it.hasNext()) {
-						    output.addLast(it.next());
-						    break;
-					    }
-				    }
-				    itering.removeLast();
-			    }
-			    for(int i=itering.size(); i<proto.length; i++) {
-				    if(proto[i] instanceof Collection) {
-					    Iterator it=((Collection)proto[i])
-						    .iterator();
-					    if(!it.hasNext()) {
-						    output=null; break;
-					    }
-					    itering.addLast(it);
-					    output.addLast(it.next());
-				    } else {
-					    itering.addLast(proto[i]);
-					    output.addLast(proto[i]);
-				    }
-			    }
-			    return tr;
-		    }
-
-		    public void remove() {}
-	    }
-
-	    private OreQuery(Object[] pattern) {
-		    proto=pattern;
-	    }
-
-	    public Iterator<Object[]> iterator() {
-		    return new OreQueryIterator();
-	    }
-    }
-
-    /** Generate all valid legal recipe combinations.  Any Lists in pattern
-     * will be fully expanded to all valid combinations.
-     */
-    public static OreQuery generateRecipes(Object... pattern) {
-	    return new OreQuery(pattern);
-    }
-
-    // ------------------------------------------------------------
-
-    /** Register a new plant to be planted when bonemeal is used on grass.
-     * @param bid The block ID to plant.
-     * @param md The metadata to plant.
-     * @param prop The relative probability of the plant, where red flowers are
-     * 10 and yellow flowers are 20.
-     */
-    public static void addGrassPlant(int item, int md, int prop) {
-	    ForgeHooks.addPlantGrass(item,md,prop);
-    }
-
-    /** Register a new seed to be dropped when breaking tall grass.
-     * @param bid The item ID of the seeds.
-     * @param md The metadata of the seeds.
-     * @param qty The quantity of seeds to drop.
-     * @param prop The relative probability of the seeds, where wheat seeds are
-     * 10.
-     */
-    public static void addGrassSeed(int item, int md, int qty, int prop) {
-	    ForgeHooks.addGrassSeed(item,md,qty,prop);
-    }
-
-    /** Register a tool as a tool class with a given harvest level.
-     *
-     * @param tool The custom tool to register.
-     * @param tclass The tool class to register as.  The predefined tool
-     * clases are "pickaxe", "shovel", "axe".  You can add others for custom
-     * tools.
-     * @param hlevel The harvest level of the tool.
-     */
-    public static void setToolClass(Item tool, String tclass, int hlevel) {
-	    ForgeHooks.initTools();
-	    ForgeHooks.toolClasses.put(tool.shiftedIndex,
-		Arrays.asList(tclass,hlevel));
-    }
-
-    /** Register a block to be harvested by a tool class.  This is the metadata
-     * sensitive version, use it if your blocks are using metadata variants.
-     * By default, this sets the block class as effective against that type.
-     *
-     * @param bl The block to register.
-     * @param md The metadata for the block subtype.
-     * @param tclass The tool class to register as able to remove this block.
-     * You may register the same block multiple times with different tool
-     * classes, if multiple tool types can be used to harvest this block.
-     * @param hlevel The minimum tool harvest level required to successfully
-     * harvest the block.
-     * @see setToolClass for details on tool classes.
-     */
-    public static void setBlockHarvestLevel(Block bl, int md, String tclass, 
-		int hlevel) {
-	    ForgeHooks.initTools();
-	    List key=Arrays.asList(bl.blockID,md,tclass);
-	    ForgeHooks.toolHarvestLevels.put(key,hlevel);
-	    ForgeHooks.toolEffectiveness.add(key);
-    }
-
-    /** Remove a block effectiveness mapping.  Since setBlockHarvestLevel
-     * makes the tool class effective against the block by default, this can be
-     * used to remove that mapping.  This will force a block to be harvested at
-     * the same speed regardless of tool quality, while still requiring a given
-     * harvesting level.
-     * @param bl The block to remove effectiveness from.
-     * @param md The metadata for the block subtype.
-     * @param tclass The tool class to remove the effectiveness mapping from.
-     * @see setToolClass for details on tool classes.
-     */
-    public static void removeBlockEffectiveness(Block bl, int md,
-		    String tclass) {
-	    ForgeHooks.initTools();
-	    List key=Arrays.asList(bl.blockID,md,tclass);
-	    ForgeHooks.toolEffectiveness.remove(key);
-    }
-
-    /** Register a block to be harvested by a tool class.
-     * By default, this sets the block class as effective against that type.
-     *
-     * @param bl The block to register.
-     * @param tclass The tool class to register as able to remove this block.
-     * You may register the same block multiple times with different tool
-     * classes, if multiple tool types can be used to harvest this block.
-     * @param hlevel The minimum tool harvest level required to successfully
-     * harvest the block.
-     * @see setToolClass for details on tool classes.
-     */
-    public static void setBlockHarvestLevel(Block bl, String tclass, 
-		int hlevel) {
-	    ForgeHooks.initTools();
-	    for(int md=0; md<16; md++) {
-		    List key=Arrays.asList(bl.blockID,md,tclass);
-		    ForgeHooks.toolHarvestLevels.put(key,hlevel);
-		    ForgeHooks.toolEffectiveness.add(key);
-	    }
-    }
-
-    /** Remove a block effectiveness mapping.  Since setBlockHarvestLevel
-     * makes the tool class effective against the block by default, this can be
-     * used to remove that mapping.  This will force a block to be harvested at
-     * the same speed regardless of tool quality, while still requiring a given
-     * harvesting level.
-     * @param bl The block to remove effectiveness from.
-     * @param tclass The tool class to remove the effectiveness mapping from.
-     * @see setToolClass for details on tool classes.
-     */
-    public static void removeBlockEffectiveness(Block bl, String tclass) {
-	    ForgeHooks.initTools();
-	    for(int md=0; md<16; md++) {
-		    List key=Arrays.asList(bl.blockID,md,tclass);
-		    ForgeHooks.toolEffectiveness.remove(key);
-	    }
-    }
-
-    /**
-     * Kill minecraft with an error message.
-     */
-    public static void killMinecraft(String modname, String msg) {
-	    throw new RuntimeException(modname+": "+msg);
-    }
-
-    /**
-     * Version checking.  Ensures that a sufficiently recent version of Forge
-     * is installed.  Will result in a fatal error if the major versions
-     * mismatch or if the version is too old.  Will print a warning message if
-     * the minor versions don't match.
-     */
-    public static void versionDetect(String modname,
-		    int major, int minor, int revision) {
-	    if(major!=ForgeHooks.majorVersion) {
-		    killMinecraft(modname,"MinecraftForge Major Version Mismatch, expecting "+major+".x.x");
-	    } else if(minor!=ForgeHooks.minorVersion) {
-		    if(minor>ForgeHooks.minorVersion) {
-			    killMinecraft(modname,"MinecraftForge Too Old, need at least "+major+"."+minor+"."+revision);
-		    } else {
-			    System.out.println(modname + ": MinecraftForge minor version mismatch, expecting "+major+"."+minor+".x, may lead to unexpected behavior");
-		    }
-	    } else if(revision>ForgeHooks.revisionVersion) {
-		    killMinecraft(modname,"MinecraftForge Too Old, need at least "+major+"."+minor+"."+revision);
-	    }
-    }
-
-    /**
-     * Strict version checking.  Ensures that a sufficiently recent version of
-     * Forge is installed.  Will result in a fatal error if the major or minor 
-     * versions mismatch or if the version is too old.  Use this function for
-     * mods that use recent, new, or unstable APIs to prevent
-     * incompatibilities.
-     */
-    public static void versionDetectStrict(String modname,
-		    int major, int minor, int revision) {
-	    if(major!=ForgeHooks.majorVersion) {
-		    killMinecraft(modname,"MinecraftForge Major Version Mismatch, expecting "+major+".x.x");
-	    } else if(minor!=ForgeHooks.minorVersion) {
-		    if(minor>ForgeHooks.minorVersion) {
-			    killMinecraft(modname,"MinecraftForge Too Old, need at least "+major+"."+minor+"."+revision);
-		    } else {
-			    killMinecraft(modname,"MinecraftForge minor version mismatch, expecting "+major+"."+minor+".x");
-		    }
-	    } else if(revision>ForgeHooks.revisionVersion) {
-		    killMinecraft(modname,"MinecraftForge Too Old, need at least "+major+"."+minor+"."+revision);
-	    }
-    }
-
-}

forge/patches/minecraft/net/minecraft/src/BlockRail.java.patch

@@ -1,55 +0,0 @@
---- ../src_base/minecraft/net/minecraft/src/BlockRail.java	0000-00-00 00:00:00.000000000 -0000
-+++ ../src_work/minecraft/net/minecraft/src/BlockRail.java	0000-00-00 00:00:00.000000000 -0000
-@@ -18,12 +18,12 @@
-     public static final boolean isRailBlockAt(World world, int i, int j, int k)
-     {
-         int l = world.getBlockId(i, j, k);
--        return l == Block.rail.blockID || l == Block.railPowered.blockID || l == Block.railDetector.blockID;
-+	return Block.blocksList[l] instanceof BlockRail;
-     }
- 
-     public static final boolean isRailBlock(int i)
-     {
--        return i == Block.rail.blockID || i == Block.railPowered.blockID || i == Block.railDetector.blockID;
-+	return Block.blocksList[i] instanceof BlockRail;
-     }
- 
-     protected BlockRail(int i, int j, boolean flag)
-@@ -99,7 +99,7 @@
- 
-     public boolean canPlaceBlockAt(World world, int i, int j, int k)
-     {
--        return world.isBlockNormalCube(i, j - 1, k);
-+        return world.isBlockSolidOnSide(i, j - 1, k,1);
-     }
- 
-     public void onBlockAdded(World world, int i, int j, int k)
-@@ -123,23 +123,23 @@
-             j1 &= 7;
-         }
-         boolean flag = false;
--        if(!world.isBlockNormalCube(i, j - 1, k))
-+        if(!world.isBlockSolidOnSide(i, j - 1, k,1))
-         {
-             flag = true;
-         }
--        if(j1 == 2 && !world.isBlockNormalCube(i + 1, j, k))
-+        if(j1 == 2 && !world.isBlockSolidOnSide(i + 1, j, k,1))
-         {
-             flag = true;
-         }
--        if(j1 == 3 && !world.isBlockNormalCube(i - 1, j, k))
-+        if(j1 == 3 && !world.isBlockSolidOnSide(i - 1, j, k,1))
-         {
-             flag = true;
-         }
--        if(j1 == 4 && !world.isBlockNormalCube(i, j, k - 1))
-+        if(j1 == 4 && !world.isBlockSolidOnSide(i, j, k - 1,1))
-         {
-             flag = true;
-         }
--        if(j1 == 5 && !world.isBlockNormalCube(i, j, k + 1))
-+        if(j1 == 5 && !world.isBlockSolidOnSide(i, j, k + 1,1))
-         {
-             flag = true;
-         }

forge/patches/minecraft_server/net/minecraft/src/BlockRail.java.patch

@@ -1,55 +0,0 @@
---- ../src_base/minecraft_server/net/minecraft/src/BlockRail.java	0000-00-00 00:00:00.000000000 -0000
-+++ ../src_work/minecraft_server/net/minecraft/src/BlockRail.java	0000-00-00 00:00:00.000000000 -0000
-@@ -18,12 +18,12 @@
-     public static final boolean isRailBlockAt(World world, int i, int j, int k)
-     {
-         int l = world.getBlockId(i, j, k);
--        return l == Block.rail.blockID || l == Block.railPowered.blockID || l == Block.railDetector.blockID;
-+ 	return Block.blocksList[l] instanceof BlockRail;
-     }
- 
-     public static final boolean isRailBlock(int i)
-     {
--        return i == Block.rail.blockID || i == Block.railPowered.blockID || i == Block.railDetector.blockID;
-+ 	return Block.blocksList[i] instanceof BlockRail;
-     }
- 
-     protected BlockRail(int i, int j, boolean flag)
-@@ -99,7 +99,7 @@
- 
-     public boolean canPlaceBlockAt(World world, int i, int j, int k)
-     {
--        return world.isBlockNormalCube(i, j - 1, k);
-+        return world.isBlockSolidOnSide(i, j - 1, k,1);
-     }
- 
-     public void onBlockAdded(World world, int i, int j, int k)
-@@ -123,23 +123,23 @@
-             j1 &= 7;
-         }
-         boolean flag = false;
--        if(!world.isBlockNormalCube(i, j - 1, k))
-+        if(!world.isBlockSolidOnSide(i, j - 1, k,1))
-         {
-             flag = true;
-         }
--        if(j1 == 2 && !world.isBlockNormalCube(i + 1, j, k))
-+        if(j1 == 2 && !world.isBlockSolidOnSide(i + 1, j, k,1))
-         {
-             flag = true;
-         }
--        if(j1 == 3 && !world.isBlockNormalCube(i - 1, j, k))
-+        if(j1 == 3 && !world.isBlockSolidOnSide(i - 1, j, k,1))
-         {
-             flag = true;
-         }
--        if(j1 == 4 && !world.isBlockNormalCube(i, j, k - 1))
-+        if(j1 == 4 && !world.isBlockSolidOnSide(i, j, k - 1,1))
-         {
-             flag = true;
-         }
--        if(j1 == 5 && !world.isBlockNormalCube(i, j, k + 1))
-+        if(j1 == 5 && !world.isBlockSolidOnSide(i, j, k + 1,1))
-         {
-             flag = true;
-         }

forge/patches/minecraft_server/net/minecraft/src/Item.java.patch

@@ -1,56 +0,0 @@
---- ../src_base/minecraft_server/net/minecraft/src/Item.java	0000-00-00 00:00:00.000000000 -0000
-+++ ../src_work/minecraft_server/net/minecraft/src/Item.java	0000-00-00 00:00:00.000000000 -0000
-@@ -175,6 +175,9 @@
-     private String potionInfo;
-     private String itemName;
- 
-+    // FORGE: To disable repair recipes.
-+    protected boolean canRepair=true;
-+
-     protected Item(int i)
-     {
-         maxStackSize = 64;
-@@ -219,6 +222,13 @@
-         return 1.0F;
-     }
- 
-+    /* FORGE: Metadata-sensitive version of getStrVsBlock
-+     */
-+    public float getStrVsBlock(ItemStack itemstack, Block block, int md)
-+    {
-+	    return getStrVsBlock(itemstack,block);
-+    }
-+
-     public ItemStack onItemRightClick(ItemStack itemstack, World world, EntityPlayer entityplayer)
-     {
-         return itemstack;
-@@ -266,6 +276,29 @@
-         return maxDamage > 0 && !hasSubtypes;
-     }
- 
-+    /* FORGE: Called by CraftingManager to determine if an item is repairable.
-+     */
-+    public boolean isRepairable() {
-+	    return canRepair && isDamageable();
-+    }
-+
-+    /* FORGE: Call to disable repair recipes.
-+     */
-+    public Item setNoRepair() {
-+	    canRepair=false;
-+	    return this;
-+    }
-+
-+    /* FORGE: Called before a block is broken.  Return true to prevent default
-+     * block harvesting.
-+     *
-+     * Note: In SMP, this is called on both client and server sides!
-+     */
-+    public boolean onBlockStartBreak(ItemStack itemstack, int i, int j, int k,
-+		    EntityPlayer player) {
-+	    return false;
-+    }
-+
-     public boolean hitEntity(ItemStack itemstack, EntityLiving entityliving, EntityLiving entityliving1)
-     {
-         return false;

forge_client/.classpath

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry including="*.java" kind="src" path="start"/>
+	<classpathentry kind="src" path="forge_common"/>
+	<classpathentry kind="src" path="minecraft"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+	<classpathentry kind="lib" path="../../jars/bin/jinput.jar">
+		<attributes>
+			<attribute name="org.eclipse.jdt.launching.CLASSPATH_ATTR_LIBRARY_PATH_ENTRY" value="forge_client/jars/bin/natives"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="lib" path="../../jars/bin/lwjgl.jar">
+		<attributes>
+			<attribute name="org.eclipse.jdt.launching.CLASSPATH_ATTR_LIBRARY_PATH_ENTRY" value="forge_client/jars/bin/natives"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="lib" path="../../jars/bin/lwjgl_util.jar">
+		<attributes>
+			<attribute name="org.eclipse.jdt.launching.CLASSPATH_ATTR_LIBRARY_PATH_ENTRY" value="forge_client/jars/bin/natives"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="lib" path="../../jars/bin/minecraft.jar"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

forge_client/.project

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>forge_client</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+	<linkedResources>
+		<link>
+			<name>forge_common</name>
+			<type>2</type>
+			<locationURI>PARENT-1-PROJECT_LOC/forge_common</locationURI>
+		</link>
+		<link>
+			<name>jars</name>
+			<type>2</type>
+			<locationURI>MCP_LOC/jars</locationURI>
+		</link>
+		<link>
+			<name>minecraft</name>
+			<type>2</type>
+			<locationURI>PARENT-1-WORKSPACE_LOC/src_work/minecraft</locationURI>
+		</link>
+		<link>
+			<name>start</name>
+			<type>2</type>
+			<locationURI>MCP_LOC/conf/patches</locationURI>
+		</link>
+	</linkedResources>
+	<filteredResources>
+		<filter>
+			<id>1324024223159</id>
+			<name>jars</name>
+			<type>9</type>
+			<matcher>
+				<id>org.eclipse.ui.ide.multiFilter</id>
+				<arguments>1.0-name-matches-false-false-bin</arguments>
+			</matcher>
+		</filter>
+		<filter>
+			<id>1324024223163</id>
+			<name>jars</name>
+			<type>6</type>
+			<matcher>
+				<id>org.eclipse.ui.ide.multiFilter</id>
+				<arguments>1.0-name-matches-false-false-*</arguments>
+			</matcher>
+		</filter>
+		<filter>
+			<id>1324022795404</id>
+			<name>start</name>
+			<type>5</type>
+			<matcher>
+				<id>org.eclipse.ui.ide.multiFilter</id>
+				<arguments>1.0-name-matches-false-false-*.java</arguments>
+			</matcher>
+		</filter>
+		<filter>
+			<id>1324024144075</id>
+			<name>jars/bin</name>
+			<type>5</type>
+			<matcher>
+				<id>org.eclipse.ui.ide.multiFilter</id>
+				<arguments>1.0-name-matches-false-false-*.jar</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
+	<variableList>
+		<variable>
+			<name>MCP_LOC</name>
+			<value>$%7BPARENT-1-WORKSPACE_LOC%7D</value>
+		</variable>
+	</variableList>
+</projectDescription>

forge_client/src/net/minecraft/src/forge/ForgeHooksClient.java

@@ -30,7 +30,16 @@ public class ForgeHooksClient {
 		return false;
 	}
 
-	static LinkedList<IHighlightHandler> highlightHandlers = new LinkedList<IHighlightHandler>();
+	public static void onRenderWorldLast(RenderGlobal rg, float f) {
+		for (IRenderWorldLastHandler handler : renderWorldLastHandlers) {
+			handler.onRenderWorldLast(rg,f);
+		}
+	}
+
+	static LinkedList<IHighlightHandler> highlightHandlers =
+		new LinkedList<IHighlightHandler>();
+	static LinkedList<IRenderWorldLastHandler> renderWorldLastHandlers =
+		new LinkedList<IRenderWorldLastHandler>();
 
 	public static boolean canRenderInPass(Block block, int pass) {
 		if(block instanceof IMultipassRender) {
@@ -41,25 +50,54 @@ public class ForgeHooksClient {
 		return false;
 	}
 
-	static HashMap tessellators=new HashMap();
-	static HashMap textures=new HashMap();
+	private static class TesKey implements Comparable<TesKey> {
+		public TesKey(int t, int s) { tex=t; sub=s; }
+		public int compareTo(TesKey key) {
+			if(sub==key.sub) return tex-key.tex;
+			return sub-key.sub;
+		}
+		public boolean equals(Object obj) {
+			return compareTo((TesKey)obj)==0;
+		}
+		public int hashCode() {
+			int c1=Integer.valueOf(tex).hashCode();
+			int c2=Integer.valueOf(sub).hashCode();
+			return c1+31*c2;
+		}
+		public int tex, sub;
+	}
+
+	static HashMap<TesKey,Tessellator> tessellators=
+		new HashMap<TesKey,Tessellator>();
+	static HashMap<String,Integer> textures=new HashMap<String,Integer>();
 	static boolean inWorld=false;
-	static HashSet renderTextureTest=new HashSet();
-	static ArrayList<List> renderTextureList=new ArrayList();
+	static TreeSet<TesKey> renderTextures=new TreeSet<TesKey>();
 	static Tessellator defaultTessellator=null;
+	static HashMap<TesKey,IRenderContextHandler> renderHandlers=new
+		HashMap<TesKey,IRenderContextHandler>();
+
+	protected static void registerRenderContextHandler(String tex, int sub,
+			IRenderContextHandler handler) {
+		Integer n;
+		n=textures.get(tex);
+		if(n==null) {
+			n=ModLoader.getMinecraftInstance().renderEngine
+				.getTexture(tex);
+			textures.put(tex,n);
+		}
+		renderHandlers.put(new TesKey(n,sub),handler);
+	}
 
 	protected static void bindTessellator(int tex, int sub) {
-		List key=Arrays.asList(tex,sub);
+		TesKey key=new TesKey(tex,sub);
 		Tessellator t;
-		if(!tessellators.containsKey(key)) {
+		t=tessellators.get(key);
+		if(t==null) {
 			t=new Tessellator();
 			tessellators.put(key,t);
-		} else {
-			t=(Tessellator)tessellators.get(key);
 		}
-		if(inWorld && !renderTextureTest.contains(key)) {
-			renderTextureTest.add(key);
-			renderTextureList.add(key);
+		if(inWorld && !renderTextures.contains(key)) {
+			renderTextures.add(key);
 			t.startDrawingQuads();
 			t.setTranslationD(defaultTessellator.xOffset,
 				defaultTessellator.yOffset,
@@ -68,22 +106,30 @@ public class ForgeHooksClient {
 		Tessellator.instance=t;
 	}
 
+	static IRenderContextHandler unbindContext=null;
 	protected static void bindTexture(String name, int sub) {
-		int n;
-		if(!textures.containsKey(name)) {
+		Integer n;
+		n=textures.get(name);
+		if(n==null) {
 			n=ModLoader.getMinecraftInstance().renderEngine
 				.getTexture(name);
 			textures.put(name,n);
-		} else {
-			n=(Integer)textures.get(name);
 		}
 		if(!inWorld) {
+			if(unbindContext!=null) {
+				unbindContext.afterRenderContext();
+				unbindContext=null;
+			}
 			if(Tessellator.instance.isDrawing) {
 				int mode=Tessellator.instance.drawMode;
 				Tessellator.instance.draw();
 				Tessellator.instance.startDrawing(mode);
 			}
 			GL11.glBindTexture(3553 /* GL_TEXTURE_2D */,n);
+			unbindContext=renderHandlers.get(new TesKey(n,sub));
+			if(unbindContext!=null) {
+				unbindContext.beforeRenderContext();
+			}
 			return;
 		}
 		bindTessellator(n,sub);
@@ -96,6 +142,10 @@ public class ForgeHooksClient {
 			if(Tessellator.instance.isDrawing) {
 				int mode=Tessellator.instance.drawMode;
 				Tessellator.instance.draw();
+				if(unbindContext!=null) {
+					unbindContext.afterRenderContext();
+					unbindContext=null;
+				}
 				Tessellator.instance.startDrawing(mode);
 			}
 			GL11.glBindTexture(3553 /* GL_TEXTURE_2D */, ModLoader
@@ -113,25 +163,31 @@ public class ForgeHooksClient {
 		GL11.glBindTexture(3553 /* GL_TEXTURE_2D */, ModLoader
 			.getMinecraftInstance().renderEngine
 			.getTexture("/terrain.png"));
-		renderTextureTest.clear();
-		renderTextureList.clear();
+		renderTextures.clear();
 		inWorld=true;
 	}
 
 	public static void afterRenderPass(int pass) {
 		renderPass=-1;
 		inWorld=false;
-		for(List l : renderTextureList) {
-			// TODO: call appropriate client hooks
-			Integer[] tn=(Integer[])l.toArray();
-			GL11.glBindTexture(GL11.GL_TEXTURE_2D,tn[0]);
-			Tessellator t=(Tessellator)tessellators.get(l);
-			t.draw();
+		for(TesKey tk : renderTextures) {
+			IRenderContextHandler irch=renderHandlers.get(tk);
+			GL11.glBindTexture(GL11.GL_TEXTURE_2D,tk.tex);
+			Tessellator t=tessellators.get(tk);
+			if(irch==null) {
+				t.draw();
+			} else {
+				Tessellator.instance=t;
+				irch.beforeRenderContext();
+				t.draw();
+				irch.afterRenderContext();
+			}
 		}
 		GL11.glBindTexture(3553 /* GL_TEXTURE_2D */, ModLoader
 			.getMinecraftInstance().renderEngine
 			.getTexture("/terrain.png"));
 		Tessellator.renderingWorldRenderer=false;
+		Tessellator.instance=defaultTessellator;
 	}
 
 	public static void beforeBlockRender(Block block,
@@ -171,7 +227,7 @@ public class ForgeHooksClient {
 			return def;
 		}
 	}
-	
+
 	public static void renderCustomItem(ICustomItemRenderer customRenderer, RenderBlocks renderBlocks,int itemID, int meta, float f) {
 		Tessellator tessellator = Tessellator.instance;
 		if (renderBlocks.useInventoryTint) {

forge_client/src/net/minecraft/src/forge/IRenderContextHandler.java

@@ -0,0 +1,16 @@
+/*
+ * This software is provided under the terms of the Minecraft Forge Public 
+ * License v1.0.
+ */
+package net.minecraft.src.forge;
+
+public interface IRenderContextHandler {
+	/** Run before the specified rendering context.
+	 */
+	public void beforeRenderContext();
+
+	/** Run after the specified rendering context.
+	 */
+	public void afterRenderContext();
+}
+

forge_client/src/net/minecraft/src/forge/IRenderWorldLastHandler.java

@@ -0,0 +1,17 @@
+/*
+ * This software is provided under the terms of the Minecraft Forge Public 
+ * License v1.0.
+ */
+package net.minecraft.src.forge;
+
+import net.minecraft.src.RenderGlobal;
+
+public interface IRenderWorldLastHandler {
+	/** Called after rendering all the 3D data of the world.  This is
+	 * called before the user's tool is rendered, but otherwise after all
+	 * 3D content.  It is called twice in anaglyph mode.  This is intended
+	 * for rendering visual effect overlays into the world.
+	 */
+	void onRenderWorldLast(RenderGlobal rg, float f);
+}
+

forge_client/src/net/minecraft/src/forge/MinecraftForgeClient.java

@@ -18,6 +18,20 @@ public class MinecraftForgeClient {
 		ForgeHooksClient.highlightHandlers.add(handler);
 	}
 
+	/** Register a new render context handler.  A render context is a block
+	 * of rendering performed with similar OpenGL modes, for example,
+	 * texture name.
+	 * @param tex The name of the texture for this render context.
+	 * @param sub The subid of this render context.  0 is the default pass
+	 * for normal rendering, higher subids render later.  All subids of 0
+	 * will render before all subids of 1, etc.
+	 * @param handler The handler to register.
+	 */
+	public static void registerRenderContextHandler(String tex, int sub,
+			IRenderContextHandler handler) {
+		ForgeHooksClient.registerRenderContextHandler(tex,sub,handler);
+	}
+
 	/** Bind a texture.  This is used to bind a texture file when
 	 * performing your own rendering, rather than using ITextureProvider.
 	 *

forge_common/net/minecraft/src/forge/DungeonLoot.java

@@ -0,0 +1,51 @@
+package net.minecraft.src.forge;
+
+import java.util.Random;
+import net.minecraft.src.ItemStack;
+
+/**
+ * 
+ * Used to hold a list of all items that can be spawned in a world dungeon
+ *
+ */
+public class DungeonLoot
+{
+	private ItemStack item;
+	private int minCount = 1;
+	private int maxCount = 1;
+	
+	/**
+	 * @param item A item stack
+	 * @param min Minimum stack size when randomly generating
+	 * @param max Maximum stack size when randomly generating
+	 */
+	public DungeonLoot(ItemStack item, int min, int max)
+	{
+		this.item = item;
+		minCount = min;
+		maxCount = max;
+	}
+	
+	/**
+	 * Grabs a ItemStack ready to be added to the dungeon chest,
+	 * the stack size will be between minCount and maxCount
+	 * @param rand World gen random number generator
+	 * @return The ItemStack to be added to the chest
+	 */
+	public ItemStack generateStack(Random rand)
+	{
+		ItemStack ret = this.item.copy();
+		ret.stackSize = minCount + (rand.nextInt(maxCount - minCount + 1));
+		return ret;    		
+	}
+
+	public boolean equals(ItemStack item, int min, int max)
+	{
+		return (min == minCount && max == maxCount && item.isItemEqual(this.item));
+	}
+	
+	public boolean equals(ItemStack item)
+	{
+		return item.isItemEqual(this.item);
+	}
+}

forge_common/net/minecraft/src/forge/EnumHelper.java

@@ -309,7 +309,7 @@ public class EnumHelper {
 			else
 			{
 				if ((field.getModifiers() & flags) == flags &&
-					field.getType().getName().equals(valueType))
+					field.getType().getName().replace('.', '/').equals(valueType)) //Apparently some JVMs return .'s and some don't..
 				{
 					valuesField = field;
 					break;

forge_common/net/minecraft/src/forge/ForgeHooks.java

@@ -6,11 +6,14 @@
 package net.minecraft.src.forge;
 
 import net.minecraft.src.Block;
+import net.minecraft.src.Entity;
+import net.minecraft.src.EntityMinecart;
 import net.minecraft.src.EntityPlayer;
 import net.minecraft.src.IInventory;
 import net.minecraft.src.ItemStack;
 import net.minecraft.src.Item;
 import net.minecraft.src.EnumStatus;
+import net.minecraft.src.ModLoader;
 import net.minecraft.src.World;
 
 import java.util.*;
@@ -70,6 +73,36 @@ public class ForgeHooks {
 	}
 
 	static LinkedList<ISleepHandler> sleepHandlers = new LinkedList<ISleepHandler>();
+	
+
+	public static void onMinecartUpdate(EntityMinecart minecart, int x, int y, int z)
+	{
+		for (IMinecartHandler handler : minecartHandlers)
+		{
+			handler.onMinecartUpdate(minecart, x, y, z);
+		}
+	}
+	
+	public static void onMinecartEntityCollision(EntityMinecart minecart, Entity entity)
+	{
+		for (IMinecartHandler handler : minecartHandlers)
+		{
+			handler.onMinecartEntityCollision(minecart, entity);
+		}
+	}
+	
+	public static boolean onMinecartInteract(EntityMinecart minecart, EntityPlayer player)
+	{
+		boolean canceled = true;
+		for (IMinecartHandler handler : minecartHandlers)
+		{
+			boolean tmp = handler.onMinecartInteract(minecart, player, canceled);
+			canceled = canceled && tmp;
+		}
+		return canceled;
+	}
+	
+	static LinkedList<IMinecartHandler> minecartHandlers = new LinkedList<IMinecartHandler>();
 
 	// Plant Management
 	// ------------------------------------------------------------
@@ -179,72 +212,100 @@ public class ForgeHooks {
 	}
 
 	public static boolean isToolEffective(ItemStack ist, Block bl, int md) {
-		List tc=(List)toolClasses.get(ist.itemID);
-		if(tc==null) return false;
-		Object[] ta=tc.toArray();
-		String cls=(String)ta[0];
-
-		return toolEffectiveness.contains(Arrays.asList(
-			bl.blockID,md,cls));
+		List tc = (List)toolClasses.get(ist.itemID);
+		if (tc == null) 
+		{
+			return false;
+		}
+		Object[] ta = tc.toArray();
+		String cls = (String)ta[0];
+		return toolEffectiveness.contains(Arrays.asList(bl.blockID, md, cls));
 	}
 
 	static void initTools() {
-		if(toolInit) return;
-		toolInit=true;
+		if(toolInit) 
+		{
+			return;
+		}
+		toolInit = true;
 
-		MinecraftForge.setToolClass(Item.pickaxeWood,"pickaxe",0);
-		MinecraftForge.setToolClass(Item.pickaxeStone,"pickaxe",1);
-		MinecraftForge.setToolClass(Item.pickaxeSteel,"pickaxe",2);
-		MinecraftForge.setToolClass(Item.pickaxeGold,"pickaxe",0);
-		MinecraftForge.setToolClass(Item.pickaxeDiamond,"pickaxe",3);
+		MinecraftForge.setToolClass(Item.pickaxeWood,    "pickaxe", 0);
+		MinecraftForge.setToolClass(Item.pickaxeStone,   "pickaxe", 1);
+		MinecraftForge.setToolClass(Item.pickaxeSteel,   "pickaxe", 2);
+		MinecraftForge.setToolClass(Item.pickaxeGold,    "pickaxe", 0);
+		MinecraftForge.setToolClass(Item.pickaxeDiamond, "pickaxe", 3);
 
-		MinecraftForge.setToolClass(Item.axeWood,"axe",0);
-		MinecraftForge.setToolClass(Item.axeStone,"axe",1);
-		MinecraftForge.setToolClass(Item.axeSteel,"axe",2);
-		MinecraftForge.setToolClass(Item.axeGold,"axe",0);
-		MinecraftForge.setToolClass(Item.axeDiamond,"axe",3);
+		MinecraftForge.setToolClass(Item.axeWood,    "axe", 0);
+		MinecraftForge.setToolClass(Item.axeStone,   "axe", 1);
+		MinecraftForge.setToolClass(Item.axeSteel,   "axe", 2);
+		MinecraftForge.setToolClass(Item.axeGold,    "axe", 0);
+		MinecraftForge.setToolClass(Item.axeDiamond, "axe", 3);
 
-		MinecraftForge.setToolClass(Item.shovelWood,"shovel",0);
-		MinecraftForge.setToolClass(Item.shovelStone,"shovel",1);
-		MinecraftForge.setToolClass(Item.shovelSteel,"shovel",2);
-		MinecraftForge.setToolClass(Item.shovelGold,"shovel",0);
-		MinecraftForge.setToolClass(Item.shovelDiamond,"shovel",3);
+		MinecraftForge.setToolClass(Item.shovelWood,    "shovel", 0);
+		MinecraftForge.setToolClass(Item.shovelStone,   "shovel", 1);
+		MinecraftForge.setToolClass(Item.shovelSteel,   "shovel", 2);
+		MinecraftForge.setToolClass(Item.shovelGold,    "shovel", 0);
+		MinecraftForge.setToolClass(Item.shovelDiamond, "shovel", 3);
 
-		MinecraftForge.setBlockHarvestLevel(Block.obsidian,"pickaxe",3);
-		MinecraftForge.setBlockHarvestLevel(Block.oreDiamond,"pickaxe",2);
-		MinecraftForge.setBlockHarvestLevel(Block.blockDiamond,"pickaxe",2);
-		MinecraftForge.setBlockHarvestLevel(Block.oreGold,"pickaxe",2);
-		MinecraftForge.setBlockHarvestLevel(Block.blockGold,"pickaxe",2);
-		MinecraftForge.setBlockHarvestLevel(Block.oreIron,"pickaxe",1);
-		MinecraftForge.setBlockHarvestLevel(Block.blockSteel,"pickaxe",1);
-		MinecraftForge.setBlockHarvestLevel(Block.oreLapis,"pickaxe",1);
-		MinecraftForge.setBlockHarvestLevel(Block.blockLapis,"pickaxe",1);
-		MinecraftForge.setBlockHarvestLevel(Block.oreRedstone,"pickaxe",2);
-		MinecraftForge.setBlockHarvestLevel(Block.oreRedstoneGlowing,"pickaxe",2);
-		MinecraftForge.removeBlockEffectiveness(Block.oreRedstone,"pickaxe");
-		MinecraftForge.removeBlockEffectiveness(Block.oreRedstoneGlowing,"pickaxe");
-		MinecraftForge.removeBlockEffectiveness(Block.obsidian,"pickaxe");
+		MinecraftForge.setBlockHarvestLevel(Block.obsidian,     "pickaxe", 3);
+		MinecraftForge.setBlockHarvestLevel(Block.oreDiamond,   "pickaxe", 2);
+		MinecraftForge.setBlockHarvestLevel(Block.blockDiamond, "pickaxe", 2);
+		MinecraftForge.setBlockHarvestLevel(Block.oreGold,      "pickaxe", 2);
+		MinecraftForge.setBlockHarvestLevel(Block.blockGold,    "pickaxe", 2);
+		MinecraftForge.setBlockHarvestLevel(Block.oreIron,      "pickaxe", 1);
+		MinecraftForge.setBlockHarvestLevel(Block.blockSteel,   "pickaxe", 1);
+		MinecraftForge.setBlockHarvestLevel(Block.oreLapis,     "pickaxe", 1);
+		MinecraftForge.setBlockHarvestLevel(Block.blockLapis,   "pickaxe", 1);
+		MinecraftForge.setBlockHarvestLevel(Block.oreRedstone,  "pickaxe", 2);
+		MinecraftForge.setBlockHarvestLevel(Block.oreRedstoneGlowing, "pickaxe", 2);
+		MinecraftForge.removeBlockEffectiveness(Block.oreRedstone, "pickaxe");
+		MinecraftForge.removeBlockEffectiveness(Block.obsidian,    "pickaxe");
+		MinecraftForge.removeBlockEffectiveness(Block.oreRedstoneGlowing, "pickaxe");
 
-		Block[] pickeff ={
+		Block[] pickeff = {
 			Block.cobblestone, Block.stairDouble,
-			Block.stairSingle, Block.stone, Block.sandStone,
-			Block.cobblestoneMossy,
-			Block.oreCoal,
-			Block.ice, Block.netherrack, Block.oreLapis,
+			Block.stairSingle, Block.stone, 
+			Block.sandStone,   Block.cobblestoneMossy,
+			Block.oreCoal,     Block.ice, 
+			Block.netherrack,  Block.oreLapis,
 			Block.blockLapis
-				};
-		for(Block bl : pickeff) {
-			MinecraftForge.setBlockHarvestLevel(bl,"pickaxe",0);
+		};
+		for (Block bl : pickeff) 
+		{
+			MinecraftForge.setBlockHarvestLevel(bl, "pickaxe", 0);
+		}
+		
+		Block[] spadeEff = {
+			Block.grass,     Block.dirt, 
+			Block.sand,      Block.gravel, 
+			Block.snow,      Block.blockSnow, 
+			Block.blockClay, Block.tilledField, 
+			Block.slowSand,  Block.mycelium
+		};
+		for (Block bl : spadeEff) 
+		{
+			MinecraftForge.setBlockHarvestLevel(bl, "shovel", 0);
+		}
+		
+		Block[] axeEff = {
+			Block.planks,      Block.bookShelf, 
+			Block.wood,        Block.chest, 
+			Block.stairDouble, Block.stairSingle, 
+			Block.pumpkin,     Block.pumpkinLantern
+		};
+		for (Block bl : axeEff) 
+		{
+			MinecraftForge.setBlockHarvestLevel(bl, "axe", 0);
 		}
 
-		// TODO: add other tool tables.
 	}
 
 	public static final int majorVersion=1;
 	public static final int minorVersion=2;
-	public static final int revisionVersion=2;
+	public static final int revisionVersion=5;
 	static {
-		System.out.printf("MinecraftForge V%d.%d.%d Initialized\n",majorVersion,minorVersion,revisionVersion);
+		System.out.printf("MinecraftForge V%d.%d.%d Initialized\n", majorVersion, minorVersion, revisionVersion);
+		ModLoader.getLogger().info(String.format("MinecraftForge V%d.%d.%d Initialized\n", majorVersion, minorVersion, revisionVersion));
 	}
 
 	static boolean toolInit=false;

forge_common/net/minecraft/src/forge/IMinecartCollisionHandler.java

@@ -0,0 +1,50 @@
+package net.minecraft.src.forge;
+
+import net.minecraft.src.AxisAlignedBB;
+import net.minecraft.src.Entity;
+import net.minecraft.src.EntityMinecart;
+
+/**
+ * This class defines a replacement for the default minecart collision code.
+ * Only one handler can be registered at a time. It it registered with EntityMinecart.registerCollisionHandler().
+ * If you use this, make it a configuration option.
+ * @author CovertJaguar
+ */
+public interface IMinecartCollisionHandler
+{
+
+    /**
+     * This basically replaces the function of the same name in EnityMinecart.
+     * Code in IMinecartHooks.applyEntityCollisionHook is still run.
+     * @param cart The cart that called the collision.
+     * @param other The object it collided with.
+     */
+    public void onEntityCollision(EntityMinecart cart, Entity other);
+
+    /**
+     * This function replaced the function of the same name in EntityMinecart.
+     * It is used to define whether minecarts collide with specific entities,
+     * for example items.
+     * @param cart The cart for which the collision box was requested.
+     * @param other The entity requesting the collision box.
+     * @return The collision box or null.
+     */
+    public AxisAlignedBB getCollisionBox(EntityMinecart cart, Entity other);
+
+    /**
+     * This function is used to define the box used for detecting minecart collisions.
+     * It is generally bigger that the normal collision box.
+     * @param cart The cart for which the collision box was requested.
+     * @return The collision box, cannot be null.
+     */
+    public AxisAlignedBB getMinecartCollisionBox(EntityMinecart cart);
+
+    /**
+     * This function replaces the function of the same name in EntityMinecart.
+     * It defines whether minecarts are solid to the player.
+     * @param cart The cart for which the bounding box was requested.
+     * @return The bounding box or null.
+     */
+    public AxisAlignedBB getBoundingBox(EntityMinecart cart);
+}
+

forge_common/net/minecraft/src/forge/IMinecartHandler.java

@@ -0,0 +1,38 @@
+package net.minecraft.src.forge;
+
+import net.minecraft.src.Entity;
+import net.minecraft.src.EntityMinecart;
+import net.minecraft.src.EntityPlayer;
+
+public interface IMinecartHandler {
+
+    /**
+     * This functions is called at the end of every minecart's doUpdate loop.
+     * If you override EntityMinecart.doUpdate(), is recommended that you retain the code that calls this function.
+     * @param cart The cart that called the function.
+     * @param i X coordinate of the rail
+     * @param j Y coordinate of the rail
+     * @param k Z coordinate of the rail
+     */
+	public void onMinecartUpdate(EntityMinecart minecart, int x, int y, int z);
+
+    /**
+     * This function allows several mods to add code into the collision routine at the same time regardless of the collision handler registered.
+     * If you override EntityMinecart.applyEntityCollision(), is recommended that you retain the code that calls this function.
+     * @param cart The cart that called the function.
+     * @param other
+     */
+	public void onMinecartEntityCollision(EntityMinecart minecart, Entity entity);
+
+    /**
+     * This function is called whenever a player attempts to interact with a minecart. 
+     * The primary reason for this hook is to fix a few bugs and put restrictions on how a minecart can be used under certain circumstances.
+     * If you override EntityMinecart.interact(), is recommended that you retain the code that calls this function.
+     * @param cart The cart that called the function.
+     * @param player The player that tried to interact with the minecart.
+     * @param canceled Wither or not a pervious hook has canceled the interaction of a player.
+     * @return Whether the player can interact with the minecart.
+     */
+	public boolean onMinecartInteract(EntityMinecart minecart, EntityPlayer player, boolean canceled);
+	
+}

forge_common/net/minecraft/src/forge/IUseItemFirst.java

@@ -14,6 +14,9 @@ import net.minecraft.src.World;
  * This interface is to be implemented by item classes. It will allow an item
  * to perform a use before the block is activated.
  *
+ * @deprecated This interface is no longer used, the function has been moved to
+ * Item.  The functionality remains, it simply does not require this interface
+ * any further.
  * @see Item
  */
 public interface IUseItemFirst {

forge_common/net/minecraft/src/forge/MinecartKey.java

@@ -0,0 +1,49 @@
+package net.minecraft.src.forge;
+
+import net.minecraft.src.EntityMinecart;
+
+/**
+ * Used to create hashmap values for Minecart/type pairs
+ * Written by CovertJaguar
+ */
+public class MinecartKey {
+    public final Class<? extends EntityMinecart> minecart;
+    public final int type;
+
+    public MinecartKey(Class<? extends EntityMinecart> c, int t)
+    {
+        minecart = c;
+        type = t;
+    }
+
+    @Override
+    public boolean equals(Object obj)
+    {
+        if(obj == null) 
+        {
+            return false;
+        }
+        
+        if(getClass() != obj.getClass()) 
+        {
+            return false;
+        }
+        
+        final MinecartKey other = (MinecartKey)obj;
+        if(this.minecart != other.minecart && (this.minecart == null || !this.minecart.equals(other.minecart))) 
+        {
+            return false;
+        }
+        
+        return (this.type == other.type);
+    }
+
+    @Override
+    public int hashCode()
+    {
+        int hash = 7;
+        hash = 59 * hash + (this.minecart != null ? this.minecart.hashCode() : 0);
+        hash = 59 * hash + this.type;
+        return hash;
+    }
+}

forge_common/net/minecraft/src/forge/MinecraftForge.java

@@ -0,0 +1,766 @@
+/**
+ * This software is provided under the terms of the Minecraft Forge Public 
+ * License v1.0.
+ */
+
+package net.minecraft.src.forge;
+
+import net.minecraft.src.Block;
+import net.minecraft.src.EntityMinecart;
+import net.minecraft.src.Item;
+import net.minecraft.src.ItemStack;
+import net.minecraft.src.World;
+
+import java.util.*;
+
+public class MinecraftForge {
+
+    private static LinkedList<IBucketHandler> bucketHandlers = new LinkedList<IBucketHandler>();
+    /**
+     * Register a new custom bucket handler.
+     */
+    public static void registerCustomBucketHandler(IBucketHandler handler) {
+        bucketHandlers.add(handler);
+    }
+
+    /**
+     * Registers a new sleeping handler.
+     */
+    public static void registerSleepHandler(ISleepHandler handler) {
+	ForgeHooks.sleepHandlers.add(handler);
+    }
+
+    /**
+     * Registers a new bonemeal handler.
+     */
+    public static void registerBonemealHandler(IBonemealHandler handler) {
+	ForgeHooks.bonemealHandlers.add(handler);
+    }
+
+    /**
+     * Registers a new hoe handler.
+     */
+    public static void registerHoeHandler(IHoeHandler handler) {
+	ForgeHooks.hoeHandlers.add(handler);
+    }
+
+    /**
+     * Registers a new destroy tool handler.
+     */
+    public static void registerDestroyToolHandler(IDestroyToolHandler handler) {
+	ForgeHooks.destroyToolHandlers.add(handler);
+    }
+
+    /**
+     * Registers a new crafting handler.
+     */
+    public static void registerCraftingHandler(ICraftingHandler handler) {
+        ForgeHooks.craftingHandlers.add(handler);
+    }
+    
+    /**
+     * Registers a new minecart handler
+     * @param handler The Handler to be registered
+     */
+    public static void registerMinecartHandler(IMinecartHandler handler)
+    {
+    	ForgeHooks.minecartHandlers.add(handler);
+    }
+
+    /**
+     * This is not supposed to be called outside of Minecraft internals.
+     */
+    public static ItemStack fillCustomBucket(World w, int i, int j, int k) {
+        for (IBucketHandler handler : bucketHandlers) {
+            ItemStack stack = handler.fillCustomBucket(w, i, j, k);
+
+            if (stack != null) {
+                return stack;
+            }
+        }
+
+        return null;
+    }
+
+    // Ore Dictionary
+    // ------------------------------------------------------------
+    private static LinkedList<IOreHandler> oreHandlers = new LinkedList<IOreHandler>();
+    private static TreeMap<String,List<ItemStack>> oreDict=
+	    new TreeMap<String,List<ItemStack>>();
+
+    /** Register a new ore handler.  This will automatically call the handler
+     * with all current ores during registration, and every time a new ore is
+     * added later.
+     */
+    public static void registerOreHandler(IOreHandler handler) {
+	    oreHandlers.add(handler);
+
+	    for(String key : oreDict.keySet()) {
+		    List<ItemStack> val=oreDict.get(key);
+		    for(ItemStack ist : val) {
+			    handler.registerOre(key,ist);
+		    }
+	    }
+    }
+
+    /** Register a new item with the ore dictionary.
+     * @param oreClass The string class of the ore.
+     * @param ore The ItemStack for the ore.
+     */
+    public static void registerOre(String oreClass, ItemStack ore) {
+	    List<ItemStack> orelist=oreDict.get(oreClass);
+	    if(orelist==null) {
+		    orelist=new ArrayList<ItemStack>();
+		    oreDict.put(oreClass,orelist);
+	    }
+	    orelist.add(ore);
+	    for(IOreHandler ioh : oreHandlers) {
+		    ioh.registerOre(oreClass,ore);
+	    }
+    }
+
+    /** Get the list of ores in a given class.
+     */
+    public static List<ItemStack> getOreClass(String oreClass) {
+	    return oreDict.get(oreClass);
+    }
+
+    public static class OreQuery implements Iterable<Object[]> {
+	    Object[] proto;
+
+	    public class OreQueryIterator implements Iterator<Object[]> {
+		    LinkedList itering;
+		    LinkedList output;
+
+		    private OreQueryIterator() {
+			    itering=new LinkedList();
+			    output=new LinkedList();
+
+			    for(int i=0; i<proto.length; i++) {
+				    if(proto[i] instanceof Collection) {
+					    Iterator it=((Collection)proto[i])
+						    .iterator();
+					    if(!it.hasNext()) {
+						    output=null; break;
+					    }
+					    itering.addLast(it);
+					    output.addLast(it.next());
+				    } else {
+					    itering.addLast(proto[i]);
+					    output.addLast(proto[i]);
+				    }
+			    }
+		    }
+
+		    public boolean hasNext() {
+			    return output!=null;
+		    }
+
+		    public Object[] next() {
+			    Object[] tr=output.toArray();
+
+			    Object to;
+			    while(true) {
+				    if(itering.size()==0) {
+					    output=null;
+					    return tr;
+				    }
+				    to=itering.getLast();
+				    output.removeLast();
+				    if(to instanceof Iterator) {
+					    Iterator it=(Iterator)to;
+					    if(it.hasNext()) {
+						    output.addLast(it.next());
+						    break;
+					    }
+				    }
+				    itering.removeLast();
+			    }
+			    for(int i=itering.size(); i<proto.length; i++) {
+				    if(proto[i] instanceof Collection) {
+					    Iterator it=((Collection)proto[i])
+						    .iterator();
+					    if(!it.hasNext()) {
+						    output=null; break;
+					    }
+					    itering.addLast(it);
+					    output.addLast(it.next());
+				    } else {
+					    itering.addLast(proto[i]);
+					    output.addLast(proto[i]);
+				    }
+			    }
+			    return tr;
+		    }
+
+		    public void remove() {}
+	    }
+
+	    private OreQuery(Object[] pattern) {
+		    proto=pattern;
+	    }
+
+	    public Iterator<Object[]> iterator() {
+		    return new OreQueryIterator();
+	    }
+    }
+
+    /** Generate all valid legal recipe combinations.  Any Lists in pattern
+     * will be fully expanded to all valid combinations.
+     */
+    public static OreQuery generateRecipes(Object... pattern) {
+	    return new OreQuery(pattern);
+    }
+
+    // ------------------------------------------------------------
+
+    /** Register a new plant to be planted when bonemeal is used on grass.
+     * @param bid The block ID to plant.
+     * @param md The metadata to plant.
+     * @param prop The relative probability of the plant, where red flowers are
+     * 10 and yellow flowers are 20.
+     */
+    public static void addGrassPlant(int item, int md, int prop) {
+	    ForgeHooks.addPlantGrass(item,md,prop);
+    }
+
+    /** Register a new seed to be dropped when breaking tall grass.
+     * @param bid The item ID of the seeds.
+     * @param md The metadata of the seeds.
+     * @param qty The quantity of seeds to drop.
+     * @param prop The relative probability of the seeds, where wheat seeds are
+     * 10.
+     */
+    public static void addGrassSeed(int item, int md, int qty, int prop) {
+	    ForgeHooks.addGrassSeed(item,md,qty,prop);
+    }
+
+    /** Register a tool as a tool class with a given harvest level.
+     *
+     * @param tool The custom tool to register.
+     * @param tclass The tool class to register as.  The predefined tool
+     * clases are "pickaxe", "shovel", "axe".  You can add others for custom
+     * tools.
+     * @param hlevel The harvest level of the tool.
+     */
+    public static void setToolClass(Item tool, String tclass, int hlevel) {
+	    ForgeHooks.initTools();
+	    ForgeHooks.toolClasses.put(tool.shiftedIndex,
+		Arrays.asList(tclass,hlevel));
+    }
+
+    /** Register a block to be harvested by a tool class.  This is the metadata
+     * sensitive version, use it if your blocks are using metadata variants.
+     * By default, this sets the block class as effective against that type.
+     *
+     * @param bl The block to register.
+     * @param md The metadata for the block subtype.
+     * @param tclass The tool class to register as able to remove this block.
+     * You may register the same block multiple times with different tool
+     * classes, if multiple tool types can be used to harvest this block.
+     * @param hlevel The minimum tool harvest level required to successfully
+     * harvest the block.
+     * @see setToolClass for details on tool classes.
+     */
+    public static void setBlockHarvestLevel(Block bl, int md, String tclass, 
+		int hlevel) {
+	    ForgeHooks.initTools();
+	    List key=Arrays.asList(bl.blockID,md,tclass);
+	    ForgeHooks.toolHarvestLevels.put(key,hlevel);
+	    ForgeHooks.toolEffectiveness.add(key);
+    }
+
+    /** Remove a block effectiveness mapping.  Since setBlockHarvestLevel
+     * makes the tool class effective against the block by default, this can be
+     * used to remove that mapping.  This will force a block to be harvested at
+     * the same speed regardless of tool quality, while still requiring a given
+     * harvesting level.
+     * @param bl The block to remove effectiveness from.
+     * @param md The metadata for the block subtype.
+     * @param tclass The tool class to remove the effectiveness mapping from.
+     * @see setToolClass for details on tool classes.
+     */
+    public static void removeBlockEffectiveness(Block bl, int md,
+		    String tclass) {
+	    ForgeHooks.initTools();
+	    List key=Arrays.asList(bl.blockID,md,tclass);
+	    ForgeHooks.toolEffectiveness.remove(key);
+    }
+
+    /** Register a block to be harvested by a tool class.
+     * By default, this sets the block class as effective against that type.
+     *
+     * @param bl The block to register.
+     * @param tclass The tool class to register as able to remove this block.
+     * You may register the same block multiple times with different tool
+     * classes, if multiple tool types can be used to harvest this block.
+     * @param hlevel The minimum tool harvest level required to successfully
+     * harvest the block.
+     * @see setToolClass for details on tool classes.
+     */
+    public static void setBlockHarvestLevel(Block bl, String tclass, 
+		int hlevel) {
+	    ForgeHooks.initTools();
+	    for(int md=0; md<16; md++) {
+		    List key=Arrays.asList(bl.blockID,md,tclass);
+		    ForgeHooks.toolHarvestLevels.put(key,hlevel);
+		    ForgeHooks.toolEffectiveness.add(key);
+	    }
+    }
+
+    /** Remove a block effectiveness mapping.  Since setBlockHarvestLevel
+     * makes the tool class effective against the block by default, this can be
+     * used to remove that mapping.  This will force a block to be harvested at
+     * the same speed regardless of tool quality, while still requiring a given
+     * harvesting level.
+     * @param bl The block to remove effectiveness from.
+     * @param tclass The tool class to remove the effectiveness mapping from.
+     * @see setToolClass for details on tool classes.
+     */
+    public static void removeBlockEffectiveness(Block bl, String tclass) {
+	    ForgeHooks.initTools();
+	    for(int md=0; md<16; md++) {
+		    List key=Arrays.asList(bl.blockID,md,tclass);
+		    ForgeHooks.toolEffectiveness.remove(key);
+	    }
+    }
+
+    /**
+     * Kill minecraft with an error message.
+     */
+    public static void killMinecraft(String modname, String msg) {
+	    throw new RuntimeException(modname+": "+msg);
+    }
+
+    /**
+     * Version checking.  Ensures that a sufficiently recent version of Forge
+     * is installed.  Will result in a fatal error if the major versions
+     * mismatch or if the version is too old.  Will print a warning message if
+     * the minor versions don't match.
+     */
+    public static void versionDetect(String modname,
+		    int major, int minor, int revision) {
+	    if(major!=ForgeHooks.majorVersion) {
+		    killMinecraft(modname,"MinecraftForge Major Version Mismatch, expecting "+major+".x.x");
+	    } else if(minor!=ForgeHooks.minorVersion) {
+		    if(minor>ForgeHooks.minorVersion) {
+			    killMinecraft(modname,"MinecraftForge Too Old, need at least "+major+"."+minor+"."+revision);
+		    } else {
+			    System.out.println(modname + ": MinecraftForge minor version mismatch, expecting "+major+"."+minor+".x, may lead to unexpected behavior");
+		    }
+	    } else if(revision>ForgeHooks.revisionVersion) {
+		    killMinecraft(modname,"MinecraftForge Too Old, need at least "+major+"."+minor+"."+revision);
+	    }
+    }
+
+    /**
+     * Strict version checking.  Ensures that a sufficiently recent version of
+     * Forge is installed.  Will result in a fatal error if the major or minor 
+     * versions mismatch or if the version is too old.  Use this function for
+     * mods that use recent, new, or unstable APIs to prevent
+     * incompatibilities.
+     */
+    public static void versionDetectStrict(String modname,
+		    int major, int minor, int revision) {
+	    if(major!=ForgeHooks.majorVersion) {
+		    killMinecraft(modname,"MinecraftForge Major Version Mismatch, expecting "+major+".x.x");
+	    } else if(minor!=ForgeHooks.minorVersion) {
+		    if(minor>ForgeHooks.minorVersion) {
+			    killMinecraft(modname,"MinecraftForge Too Old, need at least "+major+"."+minor+"."+revision);
+		    } else {
+			    killMinecraft(modname,"MinecraftForge minor version mismatch, expecting "+major+"."+minor+".x");
+		    }
+	    } else if(revision>ForgeHooks.revisionVersion) {
+		    killMinecraft(modname,"MinecraftForge Too Old, need at least "+major+"."+minor+"."+revision);
+	    }
+    }
+
+	private static int dungeonLootAttempts = 8;
+	private static ArrayList<ObjectPair<Float, String>> dungeonMobs = new ArrayList<ObjectPair<Float, String>>();
+	private static ArrayList<ObjectPair<Float, DungeonLoot>> dungeonLoot = new ArrayList<ObjectPair<Float, DungeonLoot>>();
+    /**
+     * Set the number of item stacks that will be attempted to be added to each Dungeon chest.
+     * Note: Due to random number generation, you will not always get this amount per chest.
+     * @param number The maximum number of item stacks to add to a chest.
+     */
+    public static void setDungeonLootTries(int number)
+    {
+    	dungeonLootAttempts = number;
+    }
+    
+    /**
+     * @return The max number of item stacks found in each dungeon chest.
+     */
+    public static int getDungeonLootTries()
+    {
+    	return dungeonLootAttempts;
+    }
+    
+    /**
+     * Adds a mob to the possible list of creatures the spawner will create.
+     * If the mob is already in the spawn list, the rarity will be added to the existing one,
+     * causing the mob to be more common.
+     *  
+     * @param name The name of the monster, use the same name used when registering the entity.
+     * @param rarity The rarity of selecting this mob over others. Must be greater then 0.
+     *        Vanilla Minecraft has the following mobs:
+     *        Spider   1
+     *        Skeleton 1
+     *        Zombie   2
+     *        Meaning, Zombies are twice as common as spiders or skeletons.
+     * @return The new rarity of the monster,         
+     */
+    public static float addDungeonMob(String name, float rarity)
+    {
+    	if (rarity <= 0)
+    	{
+    		throw new IllegalArgumentException("Rarity must be greater then zero");
+    	}
+    	
+    	for(ObjectPair<Float, String> mob : dungeonMobs)
+    	{
+    		if (name.equals(mob.getValue2()))
+    		{
+    			mob.setValue1(mob.getValue1() + rarity);
+    			return mob.getValue1();
+    		}
+    	}
+
+    	dungeonMobs.add(new ObjectPair<Float, String>(rarity, name));
+    	return rarity;
+    }
+    
+    /**
+     * Will completely remove a Mob from the dungeon spawn list.
+     * 
+     * @param name The name of the mob to remove
+     * @return The rarity of the removed mob, prior to being removed.
+     */
+    public static float removeDungeonMob(String name)
+    {
+    	for (ObjectPair<Float, String> mob : dungeonMobs)
+    	{
+    		if (name.equals(name))
+    		{
+    			dungeonMobs.remove(mob);
+    			return mob.getValue1();
+    		}
+    	}
+    	return 0;
+    }
+    
+    /**
+     * Gets a random mob name from the list.
+     * @param rand World generation random number generator
+     * @return The mob name
+     */
+    public static String getRandomDungeonMob(Random rand)
+    {
+    	float maxRarity = 0f;
+    	for (ObjectPair<Float, String> mob : dungeonMobs)
+    	{
+    		maxRarity += mob.getValue1();
+    	}
+    	
+    	float targetRarity = rand.nextFloat() * maxRarity;
+    	for (ObjectPair<Float, String> mob : dungeonMobs)
+    	{
+    		if (targetRarity < mob.getValue1()) 
+    		{
+    			return mob.getValue2();
+    		}
+    		targetRarity -= mob.getValue1();
+    	}
+    	
+    	return "";
+    }
+    
+    /**
+     * Adds a item stack to the dungeon loot list with a stack size
+     * of 1.
+     * 
+     * @param item The ItemStack to be added to the loot list
+     * @param rarity The relative chance that this item will spawn, Vanilla has 
+     * 			most of its items set to 1. Like the saddle, bread, silk, wheat, etc..
+     * 			Rarer items are set to lower values, EXA: Golden Apple 0.01
+     */
+    public static void addDungeonLoot(ItemStack item, float rarity)
+    {
+    	addDungeonLoot(item, rarity, 1, 1);
+    }
+    
+    /**
+     * Adds a item stack, with a range of sizes, to the dungeon loot list.
+     * If a stack matching the same item, and size range, is already in the list
+     * the rarities will be added together making the item more common.
+     * 
+     * @param item The ItemStack to be added to the loot list
+     * @param rarity The relative chance that this item will spawn, Vanilla has 
+     * 			most of its items set to 1. Like the saddle, bread, silk, wheat, etc..
+     * 			Rarer items are set to lower values, EXA: Golden Apple 0.01
+     * @param minCount When this item does generate, the minimum number that is in the stack
+     * @param maxCount When this item does generate, the maximum number that can bein the stack
+     * @return The new rarity of the loot. 
+     */
+    public static float addDungeonLoot(ItemStack item, float rarity, int minCount, int maxCount)
+    {
+    	for (ObjectPair<Float, DungeonLoot> loot : dungeonLoot)
+    	{
+    		if (loot.getValue2().equals(item, minCount, maxCount))
+    		{
+    			loot.setValue1(loot.getValue1() + rarity);
+    			return loot.getValue1();
+    		}
+    	}
+    	
+    	dungeonLoot.add(new ObjectPair<Float, DungeonLoot>(rarity, new DungeonLoot(item, minCount, maxCount)));
+    	return rarity;    	
+    }
+    /**
+     * Removes a item stack from the dungeon loot list, this will remove all items
+     * as long as the item stack matches, it will not care about matching the stack
+     * size ranges perfectly.
+     * 
+     * @param item The item stack to remove
+     * @return The total rarity of all items removed
+     */
+    public static float removeDungeonLoot(ItemStack item)
+    {
+    	return removeDungeonLoot(item, -1, 0);
+    }
+    
+    /**
+     * Removes a item stack from the dungeon loot list. If 'minCount' parameter 
+     * is greater then 0, it will only remove loot items that have the same exact 
+     * stack size range as passed in by parameters.
+     * 
+     * @param item The item stack to remove
+     * @param minCount The minimum count for the match check, if less then 0, 
+     * 			the size check is skipped
+     * @param maxCount The max count used in match check when 'minCount' is >= 0
+     * @return The total rarity of all items removed
+     */
+    public static float removeDungeonLoot(ItemStack item, int minCount, int maxCount)
+    {
+    	float rarity = 0;
+    	ArrayList<ObjectPair<Float, DungeonLoot>> lootTmp = (ArrayList<ObjectPair<Float, DungeonLoot>>)dungeonLoot.clone();
+    	if (minCount < 0)
+    	{
+	    	for (ObjectPair<Float, DungeonLoot> loot : lootTmp)
+	    	{
+	    		if (loot.getValue2().equals(item))
+	    		{
+	    			dungeonLoot.remove(loot);
+	    			rarity += loot.getValue1();
+	    		}
+	    	}
+    	}
+    	else
+    	{
+	    	for (ObjectPair<Float, DungeonLoot> loot : lootTmp)
+	    	{
+	    		if (loot.getValue2().equals(item, minCount, maxCount))
+	    		{
+	    			dungeonLoot.remove(loot);
+	    			rarity += loot.getValue1();
+	    		}
+	    	}
+    	}
+    	
+    	return rarity;  
+    }
+
+    /**
+     * Gets a random item stack to place in a dungeon chest during world generation
+     * @param rand World generation random number generator
+     * @return The item stack
+     */
+    public static ItemStack getRandomDungeonLoot(Random rand)
+    {
+    	float maxRarity = 0f;
+    	for (ObjectPair<Float, DungeonLoot> loot : dungeonLoot)
+    	{
+    		maxRarity += loot.getValue1();
+    	}
+    	
+    	float targetRarity = rand.nextFloat() * maxRarity;
+    	for (ObjectPair<Float, DungeonLoot> loot : dungeonLoot)
+    	{
+    		if (targetRarity < loot.getValue1()) 
+    		{
+    			return loot.getValue2().generateStack(rand);
+    		}
+    		targetRarity -= loot.getValue1();
+    	}
+    	
+    	return null;
+    }
+    
+
+    //Minecart Dictionary --------------------------------------
+    private static Map<MinecartKey, ItemStack> itemForMinecart = new HashMap<MinecartKey, ItemStack>();
+    private static Map<ItemStack, MinecartKey> minecartForItem = new HashMap<ItemStack, MinecartKey>();
+    /**
+     * Registers a custom minecart and its corresponding item.
+     * This should be the item used to place the minecart by the user,
+     * not the item dropped by the cart.
+     * @param cart The minecart.
+     * @param item The item used to place the cart.
+     */
+    public static void registerMinecart(Class<? extends EntityMinecart> cart, ItemStack item)
+    {
+        registerMinecart(cart, 0, item);
+    }
+
+    /**
+     * Registers a minecart and its corresponding item.
+     * This should be the item used to place the minecart by the user,
+     * not the item dropped by the cart.
+     * @param minecart The minecart.
+     * @param type The minecart type, used to differentiate carts that have the same class.
+     * @param item The item used to place the cart.
+     */
+    public static void registerMinecart(Class<? extends EntityMinecart> minecart, int type, ItemStack item)
+    {
+        MinecartKey k = new MinecartKey(minecart, type);
+        itemForMinecart.put(k, item);
+        minecartForItem.put(item, k);
+    }    
+    
+    /**
+     * Removes a previously registered Minecart. Useful for replacing the vanilla minecarts.
+     * @param minecart
+     * @param type 
+     */
+    public static void removeMinecart(Class<? extends EntityMinecart> minecart, int type)
+    {
+        MinecartKey k = new MinecartKey(minecart, type);
+        ItemStack item = itemForMinecart.remove(k);
+        if(item != null) 
+        {
+            minecartForItem.remove(item);
+        }
+    }    
+    
+    /**
+     * This function returns an ItemStack that represents this cart.
+     * The player should be able to use this item to place the minecart.
+     * This is the item that was registered with the cart via the registerMinecart function,
+     * but is not necessary the item the cart drops when destroyed.
+     * @param minecart The cart class
+     * @return An ItemStack that can be used to place the cart.
+     */
+    public static ItemStack getItemForCart(Class<? extends EntityMinecart> minecart)
+    {
+        return getItemForCart(minecart, 0);
+    }
+
+    /**
+     * This function returns an ItemStack that represents this cart.
+     * The player should be able to use this item to place the minecart.
+     * This is the item that was registered with the cart via the registerMinecart function,
+     * but is not necessary the item the cart drops when destroyed.
+     * @param minecart The cart class
+     * @param type The minecartType value
+     * @return An ItemStack that can be used to place the cart.
+     */
+    public static ItemStack getItemForCart(Class<? extends EntityMinecart> minecart, int type)
+    {
+        ItemStack item = itemForMinecart.get(new MinecartKey(minecart, type));
+        if (item == null)
+        {
+        	return null;
+        }
+        return item.copy();
+    }
+
+    /**
+     * This function returns an ItemStack that represents this cart.
+     * The player should be able to use this item to place the minecart.
+     * This is the item that was registered with the cart via the registerMinecart function,
+     * but is not necessary the item the cart drops when destroyed.
+     * @param cart The cart entity
+     * @return An ItemStack that can be used to place the cart.
+     */
+    public static ItemStack getItemForCart(EntityMinecart cart)
+    {
+        if(cart.getClass() == EntityMinecart.class) 
+        {
+            return getItemForCart(cart.getClass(), cart.getMinecartType());
+        }
+        return getItemForCart(cart.getClass(), 0);
+    }
+
+    /**
+     * The function will return the cart class for a given item.
+     * If the item was not registered via the registerMinecart function it will return null.
+     * @param item The item to test.
+     * @return Cart if mapping exists, null if not.
+     */
+    public static Class<? extends EntityMinecart> getCartClassForItem(ItemStack item)
+    {
+        MinecartKey k = minecartForItem.get(item);
+        if(k != null) 
+        {
+            return k.minecart;
+        }
+        return null;
+    }
+
+    /**
+     * The function will return the cart type for a given item.
+     * Will return -1 if the mapping doesn't exist.
+     * If the item was not registered via the registerMinecart function it will return null.
+     * @param item The item to test.
+     * @return the cart minecartType value.
+     */
+    public static int getCartTypeForItem(ItemStack item)
+    {
+        MinecartKey k = minecartForItem.get(item);
+        if(k != null) 
+        {
+            return k.type;
+        }
+        return -1;
+    }
+
+    /**
+     * Will return a set of all registered minecart items.
+     * @return a copy of the set of all minecart items
+     */
+    public static Set<ItemStack> getAllCartItems()
+    {
+    	Set<ItemStack> ret = new HashSet<ItemStack>();
+    	for(ItemStack item : minecartForItem.keySet())
+    	{
+    		ret.add(item.copy());
+    	}
+        return ret;
+    }
+  
+        
+    static 
+    {
+    	addDungeonMob("Skeleton", 1.0f);
+    	addDungeonMob("Zombie",   2.0f);
+    	addDungeonMob("Spider",   1.0f);
+    	
+    	addDungeonLoot(new ItemStack(Item.saddle),          1.00f      );
+    	addDungeonLoot(new ItemStack(Item.ingotIron),       1.00f, 1, 4);
+    	addDungeonLoot(new ItemStack(Item.bread),           1.00f      );
+    	addDungeonLoot(new ItemStack(Item.wheat),           1.00f, 1, 4);
+    	addDungeonLoot(new ItemStack(Item.gunpowder),       1.00f, 1, 4);
+    	addDungeonLoot(new ItemStack(Item.silk),            1.00f, 1, 4);
+    	addDungeonLoot(new ItemStack(Item.bucketEmpty),     1.00f      );
+    	addDungeonLoot(new ItemStack(Item.appleGold),       0.01f      );
+    	addDungeonLoot(new ItemStack(Item.redstone),        0.50f, 1, 4);
+    	addDungeonLoot(new ItemStack(Item.record13),        0.05f      );
+    	addDungeonLoot(new ItemStack(Item.recordCat),       0.05f      );
+    	addDungeonLoot(new ItemStack(Item.dyePowder, 1, 3), 1.00f      );
+    	
+        registerMinecart(EntityMinecart.class, 0, new ItemStack(Item.minecartEmpty));
+        registerMinecart(EntityMinecart.class, 1, new ItemStack(Item.minecartCrate));
+        registerMinecart(EntityMinecart.class, 2, new ItemStack(Item.minecartPowered));
+    }
+
+}

forge_common/net/minecraft/src/forge/ObjectPair.java

@@ -0,0 +1,40 @@
+package net.minecraft.src.forge;
+
+/**
+ * A class that holds two generic values, can be used as a Key/Value pair, 
+ * but is used in forge as a frequency/object pair.
+ *
+ * @param <T1> The type of the first value
+ * @param <T2> The Type of the second value
+ */
+public class ObjectPair<T1, T2> 
+{
+	private T1 object1;
+	private T2 object2;
+	
+	public ObjectPair(T1 obj1, T2 obj2)
+	{
+		this.object1 = obj1;
+		this.object2 = obj2;
+	}
+	
+	public T1 getValue1()
+	{
+		return this.object1;
+	}
+	
+	public T2 getValue2()
+	{
+		return this.object2;
+	}
+	
+	public void setValue1(T1 value)
+	{
+		object1 = value;
+	}
+	
+	public void setValue2(T2 value)
+	{
+		object2 = value;
+	}
+}

patches/minecraft/net/minecraft/src/Block.java.patch

@@ -35,7 +35,7 @@
 +     */
 +    public int quantityDropped(int meta, int fortune, Random random)
 +    {
-+        return func_40198_a(fortune, random);
++        return quantityDroppedWithBonus(fortune, random);
 +    }
 +    
 +    /* FORGE: Metadata-sensitive version.
@@ -112,11 +112,11 @@
          {
              return;
          }
--        int j1 = func_40198_a(i1, world.rand);
+-        int j1 = quantityDroppedWithBonus(i1, world.rand);
 -        for(int k1 = 0; k1 < j1; k1++)
 -        {
-+        ArrayList<ItemStack> ar = getBlockDropped(world, i, j, k, l, i1);
-+        for (ItemStack ist : ar) {
++	ArrayList<ItemStack> ar = getBlockDropped(world, i, j, k, l, i1);
++	for (ItemStack ist : ar) {
              if(world.rand.nextFloat() > f)
              {
                  continue;
@@ -126,11 +126,20 @@
 -            {
 -                dropBlockAsItem_do(world, i, j, k, new ItemStack(l1, 1, damageDropped(l)));
 -            }
-+        	dropBlockAsItem_do(world, i, j, k, ist);
++	    dropBlockAsItem_do(world, i, j, k, ist);
          }
  
      }
-@@ -805,6 +848,107 @@
+@@ -726,7 +769,7 @@
+     {
+         entityplayer.addStat(StatList.mineBlockStatArray[blockID], 1);
+         entityplayer.addExhaustion(0.025F);
+-        if(renderAsNormalBlock() && !isBlockContainer[blockID] && EnchantmentHelper.getSilkTouchModifier(entityplayer.inventory))
++        if(renderAsNormalBlock() && !hasTileEntity(l) && EnchantmentHelper.getSilkTouchModifier(entityplayer.inventory))
+         {
+             ItemStack itemstack = createStackedBlock(l);
+             if(itemstack != null)
+@@ -805,6 +848,248 @@
          return iblockaccess.isBlockNormalCube(i, j, k) ? 0.2F : 1.0F;
      }
  
@@ -142,11 +151,21 @@
 +
 +    /* FORGE: Implement and return true if you wish this block to behave
 +     * like a ladder when the player is inside.
++     *
++     * This is deprecated in favor of the more flexible version below.
 +     */
++    @Deprecated
 +    public boolean isLadder() {
 +	return false;
 +    }
 +
++    /* FORGE: Implement and return true if you wish this block to behave
++     * like a ladder when the player is inside.
++     */
++    public boolean isLadder(World world, int i, int j, int k) {
++	return isLadder();
++    }
++
 +    /* FORGE: Return true if the block is a normal, solid cube.  This
 +     * determines indirect power state, entity ejection from blocks, and a few
 +     * others.
@@ -234,6 +253,137 @@
 +    public void addCreativeItems(ArrayList itemList)
 +    {    	
 +    }
++    
++    protected static int blockFireSpreadSpeed[] = new int[256];
++    protected static int blockFlammability[] = new int[256];
++    
++    /**
++     * Chance that fire will spread and consume this block.
++     * 300 being a 100% chance, 0, being a 0% chance.
++     * 
++     * @param world The current world
++     * @param x The blocks X position
++     * @param y The blocks Y position
++     * @param z The blocks Z position
++     * @param metadata The blocks current metadata
++     * @param face The face that the fire is coming from
++     * @return A number ranging from 0 to 300 relating used to determine if the block will be consumed by fire
++     */
++    public int getFlammability(IBlockAccess world, int x, int y, int z, int metadata, int face)
++    {
++    	return blockFlammability[blockID];
++    }
++    
++    /**
++     * Called when fire is updating, checks if a block face can catch fire.
++     * 
++     * 
++     * @param world The current world
++     * @param x The blocks X position
++     * @param y The blocks Y position
++     * @param z The blocks Z position
++     * @param metadata The blocks current metadata
++     * @param face The face that the fire is coming from
++     * @return True if the face can be on fire, false otherwise.
++     */
++    public boolean isFlammable(IBlockAccess world, int x, int y, int z, int metadata, int face)
++    {
++    	return getFlammability(world, x, y, z, metadata, face) > 0;
++    }
++    
++    /**
++     * Called when fire is updating on a neighbor block.
++     * The higher the number returned, the faster fire will spread around this block.
++     * 
++     * @param world The current world
++     * @param x The blocks X position
++     * @param y The blocks Y position
++     * @param z The blocks Z position
++     * @param metadata The blocks current metadata
++     * @param face The face that the fire is coming from
++     * @return A number that is used to determine the speed of fire growth around the block
++     */
++    public int getFireSpreadSpeed(World world, int x, int y, int z, int metadata, int face)
++    {
++    	return blockFireSpreadSpeed[blockID];
++    }
++    
++    /**
++     * Currently only called by fire when it is on top of this block.
++     * Returning true will prevent the fire from naturally dying during updating.
++     * Also prevents firing from dying from rain.
++     * 
++     * @param world The current world
++     * @param x The blocks X position
++     * @param y The blocks Y position
++     * @param z The blocks Z position
++     * @param metadata The blocks current metadata
++     * @param face The face that the fire is coming from
++     * @return 
++     */
++    public boolean isFireSource(World world, int x, int y, int z, int metadata, int face)
++    {
++    	if (blockID == Block.netherrack.blockID && face == 0)
++    	{
++    		return true;
++    	}
++    	if ((world.worldProvider instanceof WorldProviderEnd) && blockID == Block.bedrock.blockID && face == 0)
++    	{
++    		return true;
++    	}
++    	return false;
++    }
++
++    /**
++     * Called by BlockFire to setup the burn values of vanilla blocks.
++     * @param id The block id
++     * @param encouragement How much the block encourages fire to spread
++     * @param flammability how easy a block is to catch fire
++     */
++    public static void setBurnProperties(int id, int encouragement, int flammability)
++    {
++    	blockFireSpreadSpeed[id] = encouragement;
++    	blockFlammability[id] = flammability;
++    }
++
++    /**
++     * Called throughout the code as a replacement for block instanceof BlockContainer
++     * Moving this to the Block base class allows for mods that wish to extend vinella 
++     * blocks, and also want to have a tile entity on that block, may.
++     * 
++     * Return true from this function to specify this block has a tile entity.
++     * 
++     * @param metadata Metadata of the current block
++     * @return True if block has a tile entity, false otherwise
++     */
++    public boolean hasTileEntity(int metadata)
++    {
++    	if (isBlockContainer[blockID])
++    	{
++     		return true;
++    	}
++    	else
++    	{
++    		return false;
++    	}
++    }
++    
++    /**
++     * Called throughout the code as a replacement for BlockContainer.getBlockEntity
++     * Return the same thing you would from that function.
++     * This will fall back to BlockContainer.getBlockEntity if this block is a BlockContainer.
++     * 
++     * @param metadata The Metadata of the current block
++     * @return A instance of a class extending TileEntity
++     */
++    public TileEntity getTileEntity(int metadata)
++    {
++    	if (this instanceof BlockContainer)
++    	{
++    		return ((BlockContainer)this).getBlockEntity(metadata);
++    	}
++    	return null;
++    }
 +
      static Class _mthclass$(String s)
      {

patches/minecraft/net/minecraft/src/BlockCrops.java.patch

@@ -27,7 +27,7 @@
 -        int j1 = 3 + i1;
 -        for(int k1 = 0; k1 < j1; k1++)
 +            
-+        for(int n = 0; n < 3; n++) 
++        for(int n = 0; n < 3+fortune; n++) 
          {
 -            if(world.rand.nextInt(15) <= l)
 +            if (world.rand.nextInt(15) <= md)
@@ -38,7 +38,7 @@
 -                float f4 = world.rand.nextFloat() * f1 + (1.0F - f1) * 0.5F;
 -                EntityItem entityitem = new EntityItem(world, (float)i + f2, (float)j + f3, (float)k + f4, new ItemStack(Item.seeds));
 -                entityitem.delayBeforeCanPickup = 10;
--                world.entityJoinedWorld(entityitem);
+-                world.spawnEntityInWorld(entityitem);
 +                tr.add(new ItemStack(Item.seeds));
              }
          }

patches/minecraft/net/minecraft/src/BlockFire.java.patch

@@ -0,0 +1,286 @@
+--- ../src_base/minecraft/net/minecraft/src/BlockFire.java	0000-00-00 00:00:00.000000000 -0000
++++ ../src_work/minecraft/net/minecraft/src/BlockFire.java	0000-00-00 00:00:00.000000000 -0000
+@@ -14,14 +14,14 @@
+ public class BlockFire extends Block
+ {
+ 
+-    private int chanceToEncourageFire[];
+-    private int abilityToCatchFire[];
+-
++	private int chanceToEncourageFire[]; 
++	private int abilityToCatchFire[];
++	
+     protected BlockFire(int i, int j)
+     {
+         super(i, j, Material.fire);
+-        chanceToEncourageFire = new int[256];
+-        abilityToCatchFire = new int[256];
++        chanceToEncourageFire = Block.blockFireSpreadSpeed;
++        abilityToCatchFire = Block.blockFlammability;
+         setTickOnLoad(true);
+     }
+ 
+@@ -38,11 +38,10 @@
+         setBurnRate(Block.cloth.blockID, 30, 60);
+         setBurnRate(Block.vine.blockID, 15, 100);
+     }
+-
++    
+     private void setBurnRate(int i, int j, int k)
+     {
+-        chanceToEncourageFire[i] = j;
+-        abilityToCatchFire[i] = k;
++    	Block.setBurnProperties(i, j, k);
+     }
+ 
+     public AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int i, int j, int k)
+@@ -77,11 +76,9 @@
+ 
+     public void updateTick(World world, int i, int j, int k, Random random)
+     {
+-        boolean flag = world.getBlockId(i, j - 1, k) == Block.netherrack.blockID;
+-        if((world.worldProvider instanceof WorldProviderEnd) && world.getBlockId(i, j - 1, k) == Block.bedrock.blockID)
+-        {
+-            flag = true;
+-        }
++        Block base = Block.blocksList[world.getBlockId(i,  j - 1, k)];
++        boolean flag = (base != null && base.isFireSource(world, i, j - 1, k, world.getBlockMetadata(i, j - 1, k), 0));
++        
+         if(!canPlaceBlockAt(world, i, j, k))
+         {
+             world.setBlockWithNotify(i, j, k, 0);
+@@ -99,23 +96,23 @@
+         world.scheduleBlockUpdate(i, j, k, blockID, tickRate());
+         if(!flag && !func_263_h(world, i, j, k))
+         {
+-            if(!world.isBlockNormalCube(i, j - 1, k) || l > 3)
++            if(!world.isBlockSolidOnSide(i, j - 1, k, 0) || l > 3)
+             {
+                 world.setBlockWithNotify(i, j, k, 0);
+             }
+             return;
+         }
+-        if(!flag && !canBlockCatchFire(world, i, j - 1, k) && l == 15 && random.nextInt(4) == 0)
++        if(!flag && !canBlockCatchFire(world, i, j - 1, k, 0) && l == 15 && random.nextInt(4) == 0)
+         {
+             world.setBlockWithNotify(i, j, k, 0);
+             return;
+         }
+-        tryToCatchBlockOnFire(world, i + 1, j, k, 300, random, l);
+-        tryToCatchBlockOnFire(world, i - 1, j, k, 300, random, l);
+-        tryToCatchBlockOnFire(world, i, j - 1, k, 250, random, l);
+-        tryToCatchBlockOnFire(world, i, j + 1, k, 250, random, l);
+-        tryToCatchBlockOnFire(world, i, j, k - 1, 300, random, l);
+-        tryToCatchBlockOnFire(world, i, j, k + 1, 300, random, l);
++        tryToCatchBlockOnFire(world, i + 1, j, k, 300, random, l, 4);
++        tryToCatchBlockOnFire(world, i - 1, j, k, 300, random, l, 5);
++        tryToCatchBlockOnFire(world, i, j - 1, k, 250, random, l, 1);
++        tryToCatchBlockOnFire(world, i, j + 1, k, 250, random, l, 0);
++        tryToCatchBlockOnFire(world, i, j, k - 1, 300, random, l, 3);
++        tryToCatchBlockOnFire(world, i, j, k + 1, 300, random, l, 2);
+         for(int i1 = i - 1; i1 <= i + 1; i1++)
+         {
+             for(int j1 = k - 1; j1 <= k + 1; j1++)
+@@ -155,9 +152,23 @@
+ 
+     }
+ 
++    /*
++     * Added for backwards compatibility, should not be called by anyone who is making a mod for forge
++     */
++    @Deprecated
+     private void tryToCatchBlockOnFire(World world, int i, int j, int k, int l, Random random, int i1)
+     {
+-        int j1 = abilityToCatchFire[world.getBlockId(i, j, k)];
++    	tryToCatchBlockOnFire(world, i, j, k, l, random, i1, 0);
++    }
++    
++    private void tryToCatchBlockOnFire(World world, int i, int j, int k, int l, Random random, int i1, int face)
++    {
++        Block block = Block.blocksList[world.getBlockId(i, j, k)];
++        int j1 = 0;
++        if (block != null) 
++        {
++        	j1 = block.getFlammability(world, i, j, k, world.getBlockMetadata(i, j, k), face);
++        }
+         if(random.nextInt(l) < j1)
+         {
+             boolean flag = world.getBlockId(i, j, k) == Block.tnt.blockID;
+@@ -182,27 +193,27 @@
+ 
+     private boolean func_263_h(World world, int i, int j, int k)
+     {
+-        if(canBlockCatchFire(world, i + 1, j, k))
++        if(canBlockCatchFire(world, i + 1, j, k, 4))
+         {
+             return true;
+         }
+-        if(canBlockCatchFire(world, i - 1, j, k))
++        if(canBlockCatchFire(world, i - 1, j, k, 5))
+         {
+             return true;
+         }
+-        if(canBlockCatchFire(world, i, j - 1, k))
++        if(canBlockCatchFire(world, i, j - 1, k, 1))
+         {
+             return true;
+         }
+-        if(canBlockCatchFire(world, i, j + 1, k))
++        if(canBlockCatchFire(world, i, j + 1, k, 0))
+         {
+             return true;
+         }
+-        if(canBlockCatchFire(world, i, j, k - 1))
++        if(canBlockCatchFire(world, i, j, k - 1, 3))
+         {
+             return true;
+         }
+-        return canBlockCatchFire(world, i, j, k + 1);
++        return canBlockCatchFire(world, i, j, k + 1, 2);
+     }
+ 
+     private int getChanceOfNeighborsEncouragingFire(World world, int i, int j, int k)
+@@ -213,12 +224,12 @@
+             return 0;
+         } else
+         {
+-            l = getChanceToEncourageFire(world, i + 1, j, k, l);
+-            l = getChanceToEncourageFire(world, i - 1, j, k, l);
+-            l = getChanceToEncourageFire(world, i, j - 1, k, l);
+-            l = getChanceToEncourageFire(world, i, j + 1, k, l);
+-            l = getChanceToEncourageFire(world, i, j, k - 1, l);
+-            l = getChanceToEncourageFire(world, i, j, k + 1, l);
++            l = getChanceToEncourageFire(world, i + 1, j, k, l, 4);
++            l = getChanceToEncourageFire(world, i - 1, j, k, l, 5);
++            l = getChanceToEncourageFire(world, i, j - 1, k, l, 1);
++            l = getChanceToEncourageFire(world, i, j + 1, k, l, 0);
++            l = getChanceToEncourageFire(world, i, j, k - 1, l, 3);
++            l = getChanceToEncourageFire(world, i, j, k + 1, l, 2);
+             return l;
+         }
+     }
+@@ -227,15 +238,43 @@
+     {
+         return false;
+     }
+-
++    
++    /*
++     * Added for backwards compatibility, should not be called by anyone who is making a mod for forge
++     */
++    @Deprecated
+     public boolean canBlockCatchFire(IBlockAccess iblockaccess, int i, int j, int k)
+     {
+-        return chanceToEncourageFire[iblockaccess.getBlockId(i, j, k)] > 0;
++    	return canBlockCatchFire(iblockaccess, i, j, k, 0);
+     }
+ 
++    public boolean canBlockCatchFire(IBlockAccess world, int i, int j, int k, int face)
++    {
++    	Block block = Block.blocksList[world.getBlockId(i, j, k)];
++    	if (block != null)
++    	{
++    		return block.isFlammable(world, i, j, k, world.getBlockMetadata(i, j, k), face);
++    	}
++    	return false;
++    }
++
++    /*
++     * Added for backwards compatibility, should not be called by anyone who is making a mod for forge
++     */
++    @Deprecated
+     public int getChanceToEncourageFire(World world, int i, int j, int k, int l)
+     {
+-        int i1 = chanceToEncourageFire[world.getBlockId(i, j, k)];
++    	return getChanceToEncourageFire(world, i, j, k, l, 0);
++    }
++    
++    public int getChanceToEncourageFire(World world, int i, int j, int k, int l, int face)
++    {
++    	int i1 = 0;
++    	Block block = Block.blocksList[world.getBlockId(i, j, k)];
++    	if (block != null)
++    	{
++    		i1 = block.getFireSpreadSpeed(world, i, j, k, world.getBlockMetadata(i, j, k), face);
++    	}
+         if(i1 > l)
+         {
+             return i1;
+@@ -247,12 +286,12 @@
+ 
+     public boolean canPlaceBlockAt(World world, int i, int j, int k)
+     {
+-        return world.isBlockNormalCube(i, j - 1, k) || func_263_h(world, i, j, k);
++        return world.isBlockSolidOnSide(i, j - 1, k, 1) || func_263_h(world, i, j, k);
+     }
+ 
+     public void onNeighborBlockChange(World world, int i, int j, int k, int l)
+     {
+-        if(!world.isBlockNormalCube(i, j - 1, k) && !func_263_h(world, i, j, k))
++        if(!world.isBlockSolidOnSide(i, j - 1, k, 1) && !func_263_h(world, i, j, k))
+         {
+             world.setBlockWithNotify(i, j, k, 0);
+             return;
+@@ -268,7 +307,7 @@
+         {
+             return;
+         }
+-        if(!world.isBlockNormalCube(i, j - 1, k) && !func_263_h(world, i, j, k))
++        if(!world.isBlockSolidOnSide(i, j - 1, k, 0) && !func_263_h(world, i, j, k))
+         {
+             world.setBlockWithNotify(i, j, k, 0);
+             return;
+@@ -285,7 +324,7 @@
+         {
+             world.playSoundEffect((float)i + 0.5F, (float)j + 0.5F, (float)k + 0.5F, "fire.fire", 1.0F + random.nextFloat(), random.nextFloat() * 0.7F + 0.3F);
+         }
+-        if(world.isBlockNormalCube(i, j - 1, k) || Block.fire.canBlockCatchFire(world, i, j - 1, k))
++        if(world.isBlockSolidOnSide(i, j - 1, k, 1) || Block.fire.canBlockCatchFire(world, i, j - 1, k, 1))
+         {
+             for(int l = 0; l < 3; l++)
+             {
+@@ -297,7 +336,7 @@
+ 
+         } else
+         {
+-            if(Block.fire.canBlockCatchFire(world, i - 1, j, k))
++            if(Block.fire.canBlockCatchFire(world, i - 1, j, k, 5))
+             {
+                 for(int i1 = 0; i1 < 2; i1++)
+                 {
+@@ -308,7 +347,7 @@
+                 }
+ 
+             }
+-            if(Block.fire.canBlockCatchFire(world, i + 1, j, k))
++            if(Block.fire.canBlockCatchFire(world, i + 1, j, k, 4))
+             {
+                 for(int j1 = 0; j1 < 2; j1++)
+                 {
+@@ -319,7 +358,7 @@
+                 }
+ 
+             }
+-            if(Block.fire.canBlockCatchFire(world, i, j, k - 1))
++            if(Block.fire.canBlockCatchFire(world, i, j, k - 1, 3))
+             {
+                 for(int k1 = 0; k1 < 2; k1++)
+                 {
+@@ -330,7 +369,7 @@
+                 }
+ 
+             }
+-            if(Block.fire.canBlockCatchFire(world, i, j, k + 1))
++            if(Block.fire.canBlockCatchFire(world, i, j, k + 1, 2))
+             {
+                 for(int l1 = 0; l1 < 2; l1++)
+                 {
+@@ -341,7 +380,7 @@
+                 }
+ 
+             }
+-            if(Block.fire.canBlockCatchFire(world, i, j + 1, k))
++            if(Block.fire.canBlockCatchFire(world, i, j + 1, k, 0))
+             {
+                 for(int i2 = 0; i2 < 2; i2++)
+                 {

patches/minecraft/net/minecraft/src/BlockLadder.java.patch

@@ -5,7 +5,7 @@
      }
  
 +    /* FORGE: Implemented base method, see Block.isLadder */
-+    public boolean isLadder() {
++    public boolean isLadder(World world, int i, int j, int k) {
 +	return true;
 +    }
 +

patches/minecraft/net/minecraft/src/BlockNetherStalk.java.patch

@@ -0,0 +1,56 @@
+--- ../src_base/minecraft/net/minecraft/src/BlockNetherStalk.java	0000-00-00 00:00:00.000000000 -0000
++++ ../src_work/minecraft/net/minecraft/src/BlockNetherStalk.java	0000-00-00 00:00:00.000000000 -0000
+@@ -4,6 +4,7 @@
+ 
+ package net.minecraft.src;
+ 
++import java.util.ArrayList;
+ import java.util.Random;
+ 
+ // Referenced classes of package net.minecraft.src:
+@@ -65,26 +66,26 @@
+         return 6;
+     }
+ 
+-    public void dropBlockAsItemWithChance(World world, int i, int j, int k, int l, float f, int i1)
++    @Override
++    public ArrayList<ItemStack> getBlockDropped(World world, int i, int j, int k, int md, int fortune) 
+     {
+-        if(world.multiplayerWorld)
+-        {
+-            return;
+-        }
+-        int j1 = 1;
+-        if(l >= 3)
+-        {
+-            j1 = 2 + world.rand.nextInt(3);
+-            if(i1 > 0)
+-            {
+-                j1 += world.rand.nextInt(i1 + 1);
+-            }
+-        }
+-        for(int k1 = 0; k1 < j1; k1++)
+-        {
+-            dropBlockAsItem_do(world, i, j, k, new ItemStack(Item.netherStalkSeeds));
+-        }
+-
++    	ArrayList<ItemStack> ret = new ArrayList<ItemStack>();
++    	
++    	int count = 1;
++    	if (md >= 3)
++    	{
++    		count = 2 + world.rand.nextInt(3);
++    		if (fortune > 0)
++    		{
++    			count += world.rand.nextInt(fortune + 1);
++    		}
++    	}
++    	for (int n = 0; n < count; n++)
++    	{
++    		ret.add(new ItemStack(Item.netherStalkSeeds));
++    	}
++    	return ret;
++    	
+     }
+ 
+     public int idDropped(int i, Random random, int j)

patches/minecraft/net/minecraft/src/BlockPistonBase.java.patch

@@ -0,0 +1,11 @@
+--- ../src_base/minecraft/net/minecraft/src/BlockPistonBase.java	0000-00-00 00:00:00.000000000 -0000
++++ ../src_work/minecraft/net/minecraft/src/BlockPistonBase.java	0000-00-00 00:00:00.000000000 -0000
+@@ -361,7 +361,7 @@
+                 return false;
+             }
+         }
+-        return !(Block.blocksList[i] instanceof BlockContainer);
++        return !(Block.blocksList[i] != null &&  Block.blocksList[i].hasTileEntity(world.getBlockMetadata(j, k, l)));
+     }
+ 
+     private static boolean canExtend(World world, int i, int j, int k, int l)

patches/minecraft/net/minecraft/src/BlockRail.java.patch

@@ -0,0 +1,200 @@
+--- ../src_base/minecraft/net/minecraft/src/BlockRail.java	0000-00-00 00:00:00.000000000 -0000
++++ ../src_work/minecraft/net/minecraft/src/BlockRail.java	0000-00-00 00:00:00.000000000 -0000
+@@ -14,16 +14,29 @@
+ {
+ 
+     private final boolean isPowered;
++    
++    /**
++     * Forge: Moved render type to a field and a setter.
++     * This allows for a mod to change the render type
++     * for vanilla rails, and any mod rails that extend
++     * this class.
++     */
++    private int renderType = 9;
++    
++    public void setRenderType(int value)
++    {
++    	renderType = value;
++    }
+ 
+     public static final boolean isRailBlockAt(World world, int i, int j, int k)
+     {
+         int l = world.getBlockId(i, j, k);
+-        return l == Block.rail.blockID || l == Block.railPowered.blockID || l == Block.railDetector.blockID;
++        return Block.blocksList[l] instanceof BlockRail;
+     }
+ 
+     public static final boolean isRailBlock(int i)
+     {
+-        return i == Block.rail.blockID || i == Block.railPowered.blockID || i == Block.railDetector.blockID;
++    	return Block.blocksList[i] instanceof BlockRail;
+     }
+ 
+     protected BlockRail(int i, int j, boolean flag)
+@@ -89,7 +102,7 @@
+ 
+     public int getRenderType()
+     {
+-        return 9;
++        return renderType;
+     }
+ 
+     public int quantityDropped(Random random)
+@@ -99,7 +112,7 @@
+ 
+     public boolean canPlaceBlockAt(World world, int i, int j, int k)
+     {
+-        return world.isBlockNormalCube(i, j - 1, k);
++        return world.isBlockSolidOnSide(i, j - 1, k,1);
+     }
+ 
+     public void onBlockAdded(World world, int i, int j, int k)
+@@ -123,23 +136,23 @@
+             j1 &= 7;
+         }
+         boolean flag = false;
+-        if(!world.isBlockNormalCube(i, j - 1, k))
++        if(!world.isBlockSolidOnSide(i, j - 1, k,1))
+         {
+             flag = true;
+         }
+-        if(j1 == 2 && !world.isBlockNormalCube(i + 1, j, k))
++        if(j1 == 2 && !world.isBlockSolidOnSide(i + 1, j, k,1))
+         {
+             flag = true;
+         }
+-        if(j1 == 3 && !world.isBlockNormalCube(i - 1, j, k))
++        if(j1 == 3 && !world.isBlockSolidOnSide(i - 1, j, k,1))
+         {
+             flag = true;
+         }
+-        if(j1 == 4 && !world.isBlockNormalCube(i, j, k - 1))
++        if(j1 == 4 && !world.isBlockSolidOnSide(i, j, k - 1,1))
+         {
+             flag = true;
+         }
+-        if(j1 == 5 && !world.isBlockNormalCube(i, j, k + 1))
++        if(j1 == 5 && !world.isBlockSolidOnSide(i, j, k + 1,1))
+         {
+             flag = true;
+         }
+@@ -313,8 +326,118 @@
+         return 0;
+     }
+ 
++    /**
++     * This function is no longer called by Minecraft
++     */
+     static boolean isPoweredBlockRail(BlockRail blockrail)
+     {
+         return blockrail.isPowered;
+     }
++    
++    /**
++     * Return true if the rail can make corners.
++     * Used by placement logic.
++     * @param world The world.
++     * @param i The rail X coordinate.
++     * @param j The rail Y coordinate.
++     * @param k The rail Z coordinate.
++     * @return True if the rail can make corners.
++     */
++    public boolean isFlexibleRail(World world, int i, int j, int k)
++    {
++        return !isPowered;
++    }
++
++    /**
++     * Returns true if the rail can make up and down slopes.
++     * Used by placement logic.
++     * @param world The world.
++     * @param i The rail X coordinate.
++     * @param j The rail Y coordinate.
++     * @param k The rail Z coordinate.
++     * @return True if the rail can make slopes.
++     */
++    public boolean canMakeSlopes(World world, int i, int j, int k)
++    {
++        return true;
++    }
++
++    /**
++     * Return the rails metadata (without the power bit if the rail uses one).
++     * Can be used to make the cart think the rail something other than it is,
++     * for example when making diamond junctions or switches.
++     * The cart parameter will often be null unless it it called from EntityMinecart.
++     * 
++     * Valid rail metadata is defined as follows:
++     * 0x0: flat track going North-South
++     * 0x1: flat track going West-East
++     * 0x2: track ascending to the East
++     * 0x3: track ascending to the West
++     * 0x4: track ascending to the North
++     * 0x5: track ascending to the South
++     * 0x6: WestNorth corner (connecting East and South)
++     * 0x7: EastNorth corner (connecting West and South)
++     * 0x8: EastSouth corner (connecting West and North)
++     * 0x9: WestSouth corner (connecting East and North)
++     * 
++     * All directions are Notch defined.
++     * In MC Beta 1.8.3 the Sun rises in the North.
++     * In MC 1.0.0 the Sun rises in the East.
++     * @param world The world.
++     * @param cart The cart asking for the metadata, null if it is not called by EntityMinecart.
++     * @param i The rail X coordinate.
++     * @param j The rail Y coordinate.
++     * @param k The rail Z coordinate.
++     * @return The metadata.
++     */
++    public int getBasicRailMetadata(IBlockAccess world, EntityMinecart cart, int i, int j, int k)
++    {
++        int meta = world.getBlockMetadata(i, j, k);
++        if(isPowered) {
++            meta = meta & 7;
++        }
++        return meta;
++    }
++	 
++    /**
++     * Returns the max speed of the rail at [i, j, k].
++     * @param world The world.
++     * @param cart The cart on the rail, may be null.
++     * @param i The rail X coordinate.
++     * @param j The rail Y coordinate.
++     * @param k The rail Z coordinate.
++     * @return The max speed of the current rail.
++     */
++    public float getRailMaxSpeed(World world, EntityMinecart cart, int i, int j, int k)
++    {
++        return 0.4f;
++    }
++	 
++    /**
++     * This function is called by any minecart that passes over this rail.
++     * It is called once per update tick that the minecart is on the rail.
++     * @param world The world.
++     * @param cart The cart on the rail.
++     * @param i The rail X coordinate.
++     * @param j The rail Y coordinate.
++     * @param k The rail Z coordinate.
++     */
++    public void onMinecartPass(World world, EntityMinecart cart, int i, int j, int k)
++    {
++    }
++    
++    /**
++     * Return true if this rail uses the 4th bit as a power bit.
++     * Avoid using this function when getBasicRailMetadata() can be used instead.
++     * The only reason to use this function is if you wish to change the rails metadata.
++     * @param world The world.
++     * @param i The rail X coordinate.
++     * @param j The rail Y coordinate.
++     * @param k The rail Z coordinate.
++     * @return True if the 4th bit is a power bit.
++     */
++    public boolean hasPowerBit(World world, int i, int j, int k)
++    {
++        return isPowered;
++    }
+ }

patches/minecraft/net/minecraft/src/BlockSnow.java.patch

@@ -0,0 +1,29 @@
+--- ../src_base/minecraft/net/minecraft/src/BlockSnow.java	0000-00-00 00:00:00.000000000 -0000
++++ ../src_work/minecraft/net/minecraft/src/BlockSnow.java	0000-00-00 00:00:00.000000000 -0000
+@@ -82,15 +82,8 @@
+ 
+     public void harvestBlock(World world, EntityPlayer entityplayer, int i, int j, int k, int l)
+     {
+-        int i1 = Item.snowball.shiftedIndex;
+-        float f = 0.7F;
+-        double d = (double)(world.rand.nextFloat() * f) + (double)(1.0F - f) * 0.5D;
+-        double d1 = (double)(world.rand.nextFloat() * f) + (double)(1.0F - f) * 0.5D;
+-        double d2 = (double)(world.rand.nextFloat() * f) + (double)(1.0F - f) * 0.5D;
+-        EntityItem entityitem = new EntityItem(world, (double)i + d, (double)j + d1, (double)k + d2, new ItemStack(i1, 1, 0));
+-        entityitem.delayBeforeCanPickup = 10;
+-        world.spawnEntityInWorld(entityitem);
+-        world.setBlockWithNotify(i, j, k, 0);
++
++	dropBlockAsItem(world,i,j,k,l,0);
+         entityplayer.addStat(StatList.mineBlockStatArray[blockID], 1);
+     }
+ 
+@@ -101,7 +94,7 @@
+ 
+     public int quantityDropped(Random random)
+     {
+-        return 0;
++        return 1;
+     }
+ 
+     public void updateTick(World world, int i, int j, int k, Random random)

patches/minecraft/net/minecraft/src/BlockTallGrass.java.patch

@@ -42,4 +42,4 @@
 +	    return tr;
      }
  
-     public int func_40198_a(int i, Random random)
+     public int quantityDroppedWithBonus(int i, Random random)