001    package net.minecraft.src;
002    
003    import net.minecraftforge.common.ForgeHooks;
004    import cpw.mods.fml.common.Side;
005    import cpw.mods.fml.common.asm.SideOnly;
006    
007    public class ItemTool extends Item
008    {
009        /** Array of blocks the tool has extra effect against. */
010        private Block[] blocksEffectiveAgainst;
011        public float efficiencyOnProperMaterial = 4.0F;
012    
013        /** Damage versus entities. */
014        public int damageVsEntity;
015    
016        /** The material this tool is made from. */
017        protected EnumToolMaterial toolMaterial;
018    
019        protected ItemTool(int par1, int par2, EnumToolMaterial par3EnumToolMaterial, Block[] par4ArrayOfBlock)
020        {
021            super(par1);
022            this.toolMaterial = par3EnumToolMaterial;
023            this.blocksEffectiveAgainst = par4ArrayOfBlock;
024            this.maxStackSize = 1;
025            this.setMaxDamage(par3EnumToolMaterial.getMaxUses());
026            this.efficiencyOnProperMaterial = par3EnumToolMaterial.getEfficiencyOnProperMaterial();
027            this.damageVsEntity = par2 + par3EnumToolMaterial.getDamageVsEntity();
028            this.setCreativeTab(CreativeTabs.tabTools);
029        }
030    
031        /**
032         * Returns the strength of the stack against a given block. 1.0F base, (Quality+1)*2 if correct blocktype, 1.5F if
033         * sword
034         */
035        public float getStrVsBlock(ItemStack par1ItemStack, Block par2Block)
036        {
037            for (int var3 = 0; var3 < this.blocksEffectiveAgainst.length; ++var3)
038            {
039                if (this.blocksEffectiveAgainst[var3] == par2Block)
040                {
041                    return this.efficiencyOnProperMaterial;
042                }
043            }
044    
045            return 1.0F;
046        }
047    
048        /**
049         * Current implementations of this method in child classes do not use the entry argument beside ev. They just raise
050         * the damage on the stack.
051         */
052        public boolean hitEntity(ItemStack par1ItemStack, EntityLiving par2EntityLiving, EntityLiving par3EntityLiving)
053        {
054            par1ItemStack.damageItem(2, par3EntityLiving);
055            return true;
056        }
057    
058        public boolean onBlockDestroyed(ItemStack par1ItemStack, World par2World, int par3, int par4, int par5, int par6, EntityLiving par7EntityLiving)
059        {
060            if ((double)Block.blocksList[par3].getBlockHardness(par2World, par4, par5, par6) != 0.0D)
061            {
062                par1ItemStack.damageItem(1, par7EntityLiving);
063            }
064    
065            return true;
066        }
067    
068        /**
069         * Returns the damage against a given entity.
070         */
071        public int getDamageVsEntity(Entity par1Entity)
072        {
073            return this.damageVsEntity;
074        }
075    
076        @SideOnly(Side.CLIENT)
077    
078        /**
079         * Returns True is the item is renderer in full 3D when hold.
080         */
081        public boolean isFull3D()
082        {
083            return true;
084        }
085    
086        /**
087         * Return the enchantability factor of the item, most of the time is based on material.
088         */
089        public int getItemEnchantability()
090        {
091            return this.toolMaterial.getEnchantability();
092        }
093    
094        /**
095         * Return the name for this tool's material.
096         */
097        public String getToolMaterialName()
098        {
099            return this.toolMaterial.toString();
100        }
101    
102        /**
103         * Return whether this item is repairable in an anvil.
104         */
105        public boolean getIsRepairable(ItemStack par1ItemStack, ItemStack par2ItemStack)
106        {
107            return this.toolMaterial.getToolCraftingMaterial() == par2ItemStack.itemID ? true : super.getIsRepairable(par1ItemStack, par2ItemStack);
108        }
109    
110        /** FORGE: Overridden to allow custom tool effectiveness */
111        @Override
112        public float getStrVsBlock(ItemStack stack, Block block, int meta) 
113        {
114            if (ForgeHooks.isToolEffective(stack, block, meta))
115            {
116                return efficiencyOnProperMaterial;
117            }
118            return getStrVsBlock(stack, block);
119        }
120    }