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

--- ../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
@@ -1,5 +1,6 @@
 package net.minecraft.src;
 
+import java.util.ArrayList;
 import java.util.Random;
 
 public class Item
@@ -191,6 +192,9 @@
 
     /** full name of item from language file */
     private String itemName;
+    
+    /** FORGE: To disable repair recipes. */
+    protected boolean canRepair = true;
 
     protected Item(int par1)
     {
@@ -492,6 +496,10 @@
         float var18 = var15 * var16;
         float var20 = var14 * var16;
         double var21 = 5.0D;
+        if (par2EntityPlayer instanceof EntityPlayerMP)
+        {
+            var21 = ((EntityPlayerMP)par2EntityPlayer).itemInWorldManager.getBlockReachDistance();
+        }
         Vec3D var23 = var13.addVector((double)var18 * var21, (double)var17 * var21, (double)var20 * var21);
         MovingObjectPosition var24 = par1World.rayTraceBlocks_do_do(var13, var23, par3, !par3);
         return var24;
@@ -509,4 +517,149 @@
     {
         StatList.initStats();
     }
+    
+    /* =========================================================== FORGE START ===============================================================*/
+    
+    /**
+     * Called when a new CreativeContainer is opened, populate the list 
+     * with all of the items for this item you want a player in creative mode
+     * to have access to.
+     * 
+     * @param itemList The list of items currently in the creative inventory
+     */
+    public void addCreativeItems(ArrayList itemList)
+    {       
+        if (this.shiftedIndex != Item.potion.shiftedIndex && this.shiftedIndex != Item.monsterPlacer.shiftedIndex)
+        {
+            itemList.add(new ItemStack(this, 1));
+        }
+    }
+    
+    /**
+     * Called when a player drops the item into the world,
+     * returning false from this will prevent the item from
+     * being removed from the players inventory and spawning
+     * in the world
+     * 
+     * @param player The player that dropped the item
+     * @param item The item stack, before the item is removed.
+     */
+    public boolean onDroppedByPlayer(ItemStack item, EntityPlayer player)
+    {
+        return true;
+    }
+
+    /**
+     * This is called when the item is used, before the block is activated.
+     * @param stack The Item Stack
+     * @param player The Player that used the item
+     * @param world The Current World
+     * @param X Target X Position
+     * @param Y Target Y Position
+     * @param Z Target Z Position
+     * @param side The side of the target hit
+     * @return Return true to prevent any further processing.
+     */
+    public boolean onItemUseFirst(ItemStack stack, EntityPlayer player, World world, int X, int Y, int Z, int side) 
+    {
+        return false;
+    }
+
+    /**
+     * Metadata-sensitive version of getStrVsBlock
+     * @param itemstack The Item Stack
+     * @param block The block the item is trying to break
+     * @param metadata The items current metadata
+     * @return The damage strength
+     */
+    public float getStrVsBlock(ItemStack itemstack, Block block, int metadata)
+    {
+        return getStrVsBlock(itemstack, block);
+    }
+    
+    /**
+     * Called by CraftingManager to determine if an item is reparable.
+     * @return True if reparable
+     */
+    public boolean isRepairable() 
+    {
+        return canRepair && isDamageable();
+    }
+
+    /**
+     * Call to disable repair recipes.
+     * @return The current Item instance
+     */
+    public Item setNoRepair() 
+    {
+        canRepair = false;
+        return this;
+    }
+    
+    /**
+     * 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!
+     * 
+     * @param itemstack The current ItemStack
+     * @param X The X Position
+     * @param Y The X Position
+     * @param Z The X Position
+     * @param player The Player that is wielding the item
+     * @return True to prevent harvesting, false to continue as normal
+     */
+    public boolean onBlockStartBreak(ItemStack itemstack, int X, int Y, int Z, EntityPlayer player) 
+    {
+        return false;
+    }
+
+    /**
+     * Called each tick while using an item.
+     * @param stack The Item being used
+     * @param player The Player using the item
+     * @param count The amount of time in tick the item has been used for continuously
+     */
+    public void onUsingItemTick(ItemStack stack, EntityPlayer player, int count) 
+    {
+    }
+    
+    /**
+     * Called when the player Left Clicks (attacks) an entity.
+     * Processed before damage is done, if return value is true further processing is canceled
+     * and the entity is not attacked.
+     * 
+     * @param stack The Item being used
+     * @param player The player that is attacking
+     * @param entity The entity being attacked
+     * @return True to cancel the rest of the interaction.
+     */
+    public boolean onLeftClickEntity(ItemStack stack, EntityPlayer player, Entity entity) 
+    {
+        return false;
+    }
+    
+    /**
+     * Player, Render pass, and item usage sensitive version of getIconIndex.
+     *   
+     * @param stack The item stack to get the icon for. (Usually this, and usingItem will be the same if usingItem is not null)
+     * @param renderPass The pass to get the icon for, 0 is default.
+     * @param player The player holding the item
+     * @param usingItem The item the player is actively using. Can be null if not using anything.
+     * @param useRemaining The ticks remaining for the active item.
+     * @return The icon index
+     */
+    public int getIconIndex(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining)
+    {
+        /*
+         * Here is an example usage for Vanilla bows.
+        if (usingItem != null && usingItem.getItem().shiftedIndex == Item.bow.shiftedIndex)
+        {
+            int k = usingItem.getMaxItemUseDuration() - useRemaining;
+            if (k >= 18) return 133;
+            if (k >  13) return 117;
+            if (k >   0) return 101;
+        }
+         */
+        return 0;
+    }
 }