Java 类net.minecraft.item.ItemShears 实例源码

@Override
public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumHand hand, EnumFacing face, float hitX, float hitY, float hitZ){
    ItemStack heldItem = player.getHeldItem(hand);
    if (heldItem.getItem() instanceof ItemShears){
        if (state.getBlock() == this){
            if (!state.getValue(CLIPPED) && state.getValue(TYPE) != 0){
                ItemStack stack = heldItem.copy();
                ((ItemShears)heldItem.getItem()).setDamage(stack, ((ItemShears)heldItem.getItem()).getDamage(stack)+1);
                if (((ItemShears)heldItem.getItem()).getDamage(stack) > ((ItemShears)heldItem.getItem()).getMaxDamage()){
                    player.setHeldItem(hand, ItemStack.EMPTY);
                }
                else {
                    player.setHeldItem(hand, stack);
                }
                this.dropBlockAsItem(world, pos, state, 0);
                world.setBlockState(pos, state.withProperty(CLIPPED, true), 8);
                world.notifyBlockUpdate(pos, state, state.withProperty(CLIPPED, true), 8);
                return true;
            }
        }
    }
    return false;
}

private static boolean isUsingShears(EntityPlayer player)
{
    ItemStack stack = player.getHeldItemMainhand();
    if (!stack.isEmpty() && stack.getItem() instanceof ItemShears)
    {
        return true;
    }

    stack = player.getHeldItemOffhand();
    if (!stack.isEmpty() && stack.getItem() instanceof ItemShears)
    {
        return true;
    }

    return false;
}

@SubscribeEvent
public void onSheared(EntityInteractSpecific event) {

    ItemStack rainbow = BaublesApi.getBaublesHandler((EntityPlayer)event.getEntityPlayer()).getStackInSlot(6);
    if (rainbow == null || (rainbow != null && rainbow.getItem() != this)) return;

    if (!(event.getTarget() instanceof IShearable)) return;
    if (!(event.getTarget() instanceof EntitySheep) || (event.getTarget() instanceof EntitySheep && ((EntitySheep)event.getTarget()).getSheared())) return;
    if (event.getItemStack() == null || (event.getItemStack() != null && !(event.getItemStack().getItem() instanceof ItemShears))) return;

    int fortune = EnchantmentHelper.getEnchantmentLevel(Enchantments.FORTUNE, event.getItemStack());
    if (!event.getWorld().isRemote) {
        List<ItemStack> wools = ((IShearable)event.getTarget()).onSheared(event.getItemStack(), event.getWorld(), event.getPos(), fortune);
        for (ItemStack is : wools) {
            Random rand = new Random();
            is.setItemDamage(rand.nextInt(15));
            EntityItem wool = new EntityItem(event.getWorld(), event.getTarget().posX, event.getTarget().posY, event.getTarget().posZ, is);
            event.getWorld().spawnEntityInWorld(wool);
        }
    }
}

@SubscribeEvent(priority = EventPriority.NORMAL, receiveCanceled = true)
public void onItemCraft(ItemCraftedEvent event) {
    Item item = event.crafting.getItem();
    if (item == HFItems.seeds_hemp_crushed || item == HFItems.seeds_indica_crushed
            || item == HFItems.seeds_sativa_crushed) {
        for (int i = 0; i < event.craftMatrix.getSizeInventory(); i++) {
            if (event.craftMatrix.getStackInSlot(i) != null) {
                ItemStack stack = event.craftMatrix.getStackInSlot(i);
                if (stack.getItem() instanceof ItemShears) {
                    if (stack.getItemDamage() < stack.getMaxDamage()) {
                        stack.shrink(1);
                        stack.setItemDamage(stack.getItemDamage() + 1);
                        event.craftMatrix.setInventorySlotContents(i, stack);
                    }
                }
            }
        }
    }


}

@Override
protected boolean isItemValid(TileEntity tileEntity, ItemStack itemStack)
{
    Class<?> cls = tileEntity.getClass();

    if(cls != TEToolRack.class)
        return false;

    Item item = itemStack.getItem();

    return item instanceof ItemTool ||
        item instanceof ItemWeapon ||
        item instanceof ItemHoe ||
        item instanceof ItemProPick ||
        item instanceof ItemBow ||
        item instanceof ItemSword ||
        item instanceof ItemAxe ||
        item instanceof ItemSpade ||
        item instanceof ItemShears ||
        item instanceof ItemSpindle
        ;
}

private static void registerShearingUpgrades() {
    if (ConfigurationLib.shearUpgradesEnabled) {
        for (String shearUpgrade : ConfigurationLib.shearUpgrades) {
            String[] string = shearUpgrade.split("-");
            int shearUpgradeID = Integer.parseInt(string[0]);
            String unlocalizedName = string[1];
            if (Item.itemRegistry.containsKey(unlocalizedName)) {
                Object object = Item.itemRegistry.getObject(unlocalizedName);
                if (object != null && object instanceof ItemShears) {
                    ItemStack shears = new ItemStack((Item) object);
                    ComputerCraftAPI.registerTurtleUpgrade(new ShearingUpgrade(shearUpgradeID, shears));
                }
            }
        }
    }
}

public static void preInit() {
    for (final Object o : IceAndShadow2.getPreRegistrationHandlers()) {
        IaSRegistry.doAdd(o);
    }
    setPrimarilyTransfusionTarget(ItemArmor.class);
    setPrimarilyTransfusionTarget(ItemTool.class);
    setPrimarilyTransfusionTarget(ItemSword.class);
    setPrimarilyTransfusionTarget(ItemHoe.class);
    setPrimarilyTransfusionTarget(ItemShears.class);
    setPrimarilyTransfusionTarget(ItemFlintAndSteel.class);
    setPrimarilyTransfusionTarget(ItemBow.class);
    setPrimarilyTransfusionTarget(ItemFishingRod.class);
    setPrimarilyTransfusionTarget(IaSItemEchirArmorActive.class);
    setPrimarilyTransfusionTarget(IaSItemEchirKnifeActive.class);
    setPrimarilyTransfusionTarget(IaSItemEchirToolActive.class);
    setPrimarilyTransfusionTarget(IaSItemToolBroken.class);
    setPrimarilyTransfusionTarget(NyxBaseItemBow.class);
    setPrimarilyTransfusionTarget(NyxItemFlask.class);
    setPrimarilyTransfusionTarget(NyxItemSwordFrost.class);

    addGrenadeLogic(new NyxGrenadeExplosive());
    addGrenadeLogic(new NyxGrenadeIceWall());
    addGrenadeLogic(new NyxGrenadeShadow());
}

public static boolean damageTool(ItemStack tool, World world, int x, int y, int z) {
    if ( (tool.getItem() instanceof ItemShears) || (tool.getItem() instanceof ItemTool) || 
            (tool.getItem() instanceof ItemHoe) || (tool.getItem() instanceof ItemSword) ) {
        if (tool.attemptDamageItem(1, RND)) {
            return true;
        }
    } else {
        Block mineBlock = world.getBlockState(new BlockPos(x, y, z)).getBlock();
        PlayerFake fakePlayer = new PlayerFake((WorldServer)world);
        if (tinkersType(tool.getItem())==TYPE_HOE) {
            tool.attemptDamageItem(1, RND);
        } else {
            tool.getItem().onBlockDestroyed(tool, world, mineBlock.getDefaultState(), new BlockPos(x, y, z), fakePlayer);
        }
        if (tinkersIsBroken(tool)) return true;
    }
    return false;
}

private static String identityType(@Nonnull ItemStack stack) {
    Item item = stack.getItem();
    if (item instanceof ItemArmor) {
        switch (((ItemArmor)item).armorType) {
            case HEAD:
                return "helmet";
            case CHEST:
                return "chestplate";
            case LEGS:
                return "leggings";
            case FEET:
                return "boots";
            default:
                break;
        }
    } else if (item instanceof ItemPickaxe) return "pickaxe";
    else if (item instanceof ItemShears) return "shears";
    else if (item instanceof ItemAxe) return "axe";
    else if (item instanceof ItemSpade) return "shovel";
    else if (item instanceof ItemBlock) return "block";
    else if (item instanceof ItemBucket) return "bucket";

    return "gizmo";
}

@Override
public void harvestBlock(World worldIn, EntityPlayer player, BlockPos pos, IBlockState state, @Nullable TileEntity te, ItemStack stack) {
    if (!worldIn.isRemote && stack.getItem() instanceof ItemShears) {
        player.addStat(StatList.getBlockStats(this));
        spawnAsEntity(worldIn, pos, new ItemStack(Item.getItemFromBlock(this)));
    } else {
        super.harvestBlock(worldIn, player, pos, state, te, stack);
    }
}

@SubscribeEvent
public void harvestEvent(BlockEvent.HarvestDropsEvent event) {
    if (EtFuturum.enableSilkTouchingMushrooms && event.isSilkTouching)
        if (event.block == Blocks.brown_mushroom_block) {
            event.drops.clear();
            event.drops.add(new ItemStack(ModBlocks.brown_mushroom_block));
        } else if (event.block == Blocks.red_mushroom_block) {
            event.drops.clear();
            event.drops.add(new ItemStack(ModBlocks.red_mushroom_block));
        }

    if (EtFuturum.enableSticksFromDeadBushes)
        if (event.block == Blocks.deadbush) {
            boolean isShears = event.harvester != null && event.harvester.getCurrentEquippedItem() != null && event.harvester.getCurrentEquippedItem().getItem() instanceof ItemShears;
            if (event.harvester == null || event.harvester.getCurrentEquippedItem() == null || !isShears)
                for (int i = 0; i < event.world.rand.nextInt(3); i++)
                    event.drops.add(new ItemStack(Items.stick));
        }

    if (EtFuturum.enableShearableCobwebs)
        if (event.block == Blocks.web && event.harvester != null) {
            ItemStack stack = event.harvester.getCurrentEquippedItem();
            if (stack != null && stack.getItem() instanceof ItemShears) {
                event.drops.clear();
                event.drops.add(new ItemStack(Blocks.web));
            }
        }
}

@SubscribeEvent
public void onShearEvent(PlayerInteractEvent.EntityInteractSpecific event)
{
    if(!InteractionBWM.HARDCORE_SHEARING)
        return;

    World world = event.getWorld();
    BlockPos pos = event.getEntity().getPosition();
    ItemStack tool = event.getItemStack();
    EntityPlayer player = event.getEntityPlayer();
    if(!world.isRemote && event.getTarget() instanceof EntitySheep && tool.getItem() instanceof ItemShears)
    {
        EntitySheep sheep = (EntitySheep) event.getTarget();
        if(!sheep.isShearable(tool,world,pos))
            return;
        java.util.Random rand = new java.util.Random();
        for(ItemStack stack : InteractionBWM.convertShearedWool(sheep.onSheared(tool,world,pos, EnchantmentHelper.getEnchantmentLevel(Enchantments.FORTUNE,tool))))
        {
            EntityItem ent = sheep.entityDropItem(stack, 1.0F);
            ent.motionY += rand.nextFloat() * 0.05F;
            ent.motionX += (rand.nextFloat() - rand.nextFloat()) * 0.1F;
            ent.motionZ += (rand.nextFloat() - rand.nextFloat()) * 0.1F;
        }
        tool.damageItem(1, player);
        event.setCanceled(true);
        event.setCancellationResult(EnumActionResult.SUCCESS);
    }
}

public boolean giveShears(EntityMinionWorker worker) {
    if(worker.getHeldItemMainhand() == null){
        int[] slots = this.inventory.getRawIndices(RelativeSide.BOTTOM);
        for(int i = 0; i < slots.length; i++){
            int slot = slots[i];
            ItemStack shears = inventory.getStackInSlot(slot);
            if(ItemStackTools.isValid(shears) && shears.getItem() instanceof ItemShears && !ToolUtil.isEmptyRfTool(shears)){
                worker.setItemStackToSlot(EntityEquipmentSlot.MAINHAND, shears);
                this.inventory.setInventorySlotContents(slot, ItemStackTools.getEmptyStack());
                return true;
            }
        }
    }
    return false;
}

@SuppressWarnings({"ConstantConditions", "MethodWithMoreThanThreeNegations"})
@SubscribeEvent(priority = EventPriority.LOWEST)
public void onPlayerInteractionWithEntity(EntityInteract event)
{
    //Process for shearing a sheep
    if (event.getWorld().isRemote) return;
    if (event.getHand() != EnumHand.MAIN_HAND) return;
    if (!(event.getTarget() instanceof EntitySheep)) return;
    final ItemStack itemStack = event.getItemStack();
    if (itemStack == null) {
        checkSpecialSheepInteraction(event);
        return;
    }
    if (!(itemStack.getItem() instanceof ItemShears)) return;

    final EntitySheep sheep = (EntitySheep) event.getTarget();
    if (!sheep.isShearable(itemStack, event.getWorld(), event.getPos())) return;

    final IChiseledSheepCapability capability = sheep.getCapability(Capability.CHISELED_SHEEP, null);
    if (capability == null) return;
    if (!capability.isChiseled()) return;

    //Ok, we have a chiseled sheep, cancel vanilla.
    event.setCanceled(true);

    Shearing.shearSheep(itemStack, sheep, capability);
}

@Override
public ItemStack[] getRemainingItems(InventoryCrafting inv) {
    ItemStack[] ret = new ItemStack[inv.getSizeInventory()];
    for (int i = 0; i < ret.length; i++) {
        ItemStack is = inv.getStackInSlot(i);
        if (is == null) continue;
        if (is.getItem() instanceof ItemShears) {
            ItemStack s = is.copy();
            if (!s.attemptDamageItem(1, rng)) {
                ret[i] = s;
            }
        }
    }
    return ret;
}

@SubscribeEvent
public void harvestEvent(BlockEvent.HarvestDropsEvent event) {
    if (EtFuturum.enableSilkTouchingMushrooms && event.isSilkTouching)
        if (event.block == Blocks.brown_mushroom_block) {
            event.drops.clear();
            event.drops.add(new ItemStack(ModBlocks.brown_mushroom_block));
        } else if (event.block == Blocks.red_mushroom_block) {
            event.drops.clear();
            event.drops.add(new ItemStack(ModBlocks.red_mushroom_block));
        }

    if (EtFuturum.enableSticksFromDeadBushes)
        if (event.block == Blocks.deadbush) {
            boolean isShears = event.harvester != null && event.harvester.getCurrentEquippedItem() != null && event.harvester.getCurrentEquippedItem().getItem() instanceof ItemShears;
            if (event.harvester == null || event.harvester.getCurrentEquippedItem() == null || !isShears)
                for (int i = 0; i < event.world.rand.nextInt(3); i++)
                    event.drops.add(new ItemStack(Items.stick));
        }

    if (EtFuturum.enableShearableCobwebs)
        if (event.block == Blocks.web && event.harvester != null) {
            ItemStack stack = event.harvester.getCurrentEquippedItem();
            if (stack != null && stack.getItem() instanceof ItemShears) {
                event.drops.clear();
                event.drops.add(new ItemStack(Blocks.web));
            }
        }
}

private boolean use(TileEntityTanningRack tile, EntityPlayer player)
{
    ItemStack held = player.getHeldItem();
    ItemStack hung = tile.getHung();

    EnumToolType tool = null;
    float efficiency = 1.0F;
    if(held != null && hung != null)
    {
        if(held.getItem() instanceof ItemShears)
        {
            tool = EnumToolType.CUTTER;
            efficiency = EnumToolMaterial.IRON.getEfficiencyOnProperMaterial();
        }
        if(held.getItem() instanceof ITanningItem)
        {
            tool = ((ITanningItem)held.getItem()).getType();
            efficiency = ((ITanningItem)held.getItem()).getQuality();
        }

        if(tool != null)
        {
            tile.use(player, tool, efficiency);
            return true;
        }
    }
    return false;
}

private static int getItemBurnTime(ItemStack itemstack)
{
    if (itemstack == null)
    {
        return 0;
    }
    else
    {
        Item item = itemstack.getItem();
        if (item == Items.stick) return 200;
        if (item == Items.blaze_rod) return 800;
        if (item instanceof ItemShears) return 3200;
        return 0;
    }
}

@Override
public boolean isItemValid(ItemStack itemStack) {
    if (upgrateEntity.hasUpgrade(upgradeRequired)) {
        return itemStack.getItem() instanceof ItemShears;
    }
    return false;
}

@Override
public boolean isMachineItemValidForSlot(int slot, @Nonnull ItemStack itemstack) {
  if (Prep.isInvalid(itemstack)) {
    return false;
  }
  if (!slotDefinition.isInputSlot(slot)) {
    return false;
  }
  if (slot == axeIndex) {
    return itemstack.getItem() instanceof ItemAxe;
  }
  if (slot == shearsIndex) {
    return itemstack.getItem() instanceof ItemShears;
  }

  ItemStack currentStackInSlot = getStackInSlot(slot);
  if (Prep.isValid(currentStackInSlot)) {
    return currentStackInSlot.isItemEqual(itemstack);
  }

  int numSlotsFilled = 0;
  for (int i = slotDefinition.getMinInputSlot(); i <= slotDefinition.getMaxInputSlot(); i++) {
    if (i >= 0 && i < inventory.length && i != axeIndex && i != shearsIndex) {
      if (Prep.isValid(getStackInSlot(i))) {
        numSlotsFilled++;
      }
    }
  }
  List<IMachineRecipe> recipes = MachineRecipeRegistry.instance.getRecipesForInput(getMachineName(), MachineRecipeInput.create(slot, itemstack));

  return isValidInputForAlloyRecipe(slot, itemstack, numSlotsFilled, recipes);
}

@Override
public boolean run(EntityMinionWorker worker, TileWorksiteBase worksite) {
    if(worker.getEntityWorld().isRemote) return false;
    if(this.animalToShear == null || this.animalToShear.isDead || !(this.animalToShear instanceof IShearable)) return true;
    if(worksite == null || !(worksite instanceof WorksiteAnimalFarm)) return true;
    WorksiteAnimalFarm aFarm = (WorksiteAnimalFarm)worksite;


    destroyTool(worker);
    aFarm.giveShears(worker);
    ItemStack held = worker.getHeldItemMainhand();
    if(held == null || !(held.getItem() instanceof ItemShears)){
        return true;
    }
    worker.getLookHelper().setLookPositionWithEntity(animalToShear, 10, 40);
    double d = worker.getDistanceToEntity(animalToShear);
    if(d <= 2.5D){
        IShearable shearable = (IShearable)this.animalToShear;
        BlockPos shearPos = new BlockPos(animalToShear);
        if(shearable.isShearable(held, worker.getEntityWorld(), shearPos)){
            worker.swingArm(EnumHand.MAIN_HAND);

            int fourtune = EnchantmentHelper.getEnchantmentLevel(Enchantments.FORTUNE, held);
            if(fourtune < 2)fourtune += aFarm.getUpgrades().contains(WorksiteUpgrade.ENCHANTED_TOOLS_1)? 1 : aFarm.getUpgrades().contains(WorksiteUpgrade.ENCHANTED_TOOLS_2)? 2 : aFarm.getUpgrades().contains(WorksiteUpgrade.ENCHANTED_TOOLS_3) ? 3 : 0;

            List<ItemStack> stacks = shearable.onSheared(held, worker.getEntityWorld(), shearPos, fourtune);
            for(ItemStack item : stacks){
                if(item !=null){
                    aFarm.addStackToInventory(item, RelativeSide.TOP);
                }
            }
            held.damageItem(1, worker);
            destroyTool(worker);
            animalToShear = null;
            return true;
        }
    } else {
        if(worker.getNavigator().noPath()){
            worker.getNavigator().tryMoveToEntityLiving(animalToShear, MinionConstants.SPEED_WALK);
        }
    }

    return false;
}

public WorksiteAnimalFarm() {
    this.shouldCountResources = true;

    this.inventory = new InventorySided(this, RotationType.FOUR_WAY, 33) {
        @Override
        public void markDirty() {
            super.markDirty();
            shouldCountResources = true;
        }
    };
    int[] topIndices = ItemUtil.getIndiceArrayForSpread(0, 27);
    int[] frontIndices = ItemUtil.getIndiceArrayForSpread(27, 3);
    int[] bottomIndices = ItemUtil.getIndiceArrayForSpread(30, 3);
    this.inventory.setAccessibleSideDefault(RelativeSide.TOP,
            RelativeSide.TOP, topIndices);
    this.inventory.setAccessibleSideDefault(RelativeSide.FRONT,
            RelativeSide.FRONT, frontIndices);// feed
    this.inventory.setAccessibleSideDefault(RelativeSide.BOTTOM,
            RelativeSide.BOTTOM, bottomIndices);// buckets/shears
    ItemSlotFilter filter = new ItemSlotFilter() {
        @Override
        public boolean isItemValid(ItemStack stack) {
            if (!ItemStackTools.isValid(stack)) {
                return true;
            }
            Item item = stack.getItem();
            if (item == Items.WHEAT_SEEDS || item == Items.WHEAT
                    || item == Items.CARROT) {
                return true;
            }
            return false;
        }

        @Override
        public String toString() {
            return "Anon filter -- wheat / seeds / carrot";
        }
    };
    inventory.setFilterForSlots(filter, frontIndices);

    filter = new ItemSlotFilter() {
        @Override
        public boolean isItemValid(ItemStack stack) {
            if (!ItemStackTools.isValid(stack)) {
                return true;
            }
            Item item = stack.getItem();
            if (item == Items.BUCKET || item instanceof ItemShears || item instanceof ItemSword) {
                return true;
            }
            return false;
        }

        @Override
        public String toString() {
            return "Anon filter -- bucket / shears / sword";
        }
    };
    inventory.setFilterForSlots(filter, bottomIndices);
}

@Override
public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumHand hand, EnumFacing side, float hitX, float hitY, float hitZ) {
    TileEntityMemorial te = (TileEntityMemorial) world.getTileEntity(pos);

    if (te != null) {
        ItemStack item = player.inventory.getCurrentItem();
        if (item != null) {
            if (te.isMossy()) {
                if (item.getItem() instanceof ItemShears) {
                    if (!world.isRemote) {
                        GraveInventory.dropItem(new ItemStack(Blocks.VINE, 1), world, pos);
                    }
                    te.setMossy(false);
                    return false;
                }
            } else {
                if (net.minecraft.block.Block.getBlockFromItem(item.getItem()) instanceof BlockVine) {
                    te.setMossy(true);
                    player.inventory.getCurrentItem().setCount(player.inventory.getCurrentItem().getCount() - 1);
                    return true;
                }
            }
        }

        if (world.isRemote) {
            String name;
            String killerName;
            String deathText = te.getDeathTextComponent().getDeathText();

            if (deathText.length() != 0) {
                if (te.getDeathTextComponent().isLocalized()) {
                    name = ModGravestoneExtended.proxy.getLocalizedEntityName(te.getDeathTextComponent().getName());
                    if (name.length() != 0) {
                        killerName = ModGravestoneExtended.proxy.getLocalizedEntityName(te.getDeathTextComponent().getKillerName());

                        if (killerName.length() == 0) {
                            player.sendMessage(new TextComponentTranslation(deathText, new Object[]{name}));
                        } else {
                            player.sendMessage(new TextComponentTranslation(deathText, new Object[]{name, killerName}));
                        }
                        return false;
                    }
                }
                player.sendMessage(new TextComponentTranslation(deathText));
            }
        }
    }

    return false;
}

private static AdditionalCosts getAdditionalCosts (final Item output)
{
    int index = 0;

    if (output instanceof ItemArmor)
    {
        index = ((ItemArmor) output).armorType;
    }
    else if (output instanceof ItemPickaxe)
    {
        index = 4;
    }
    else if (output instanceof ItemSword)
    {
        index = 5;
    }
    else if (output instanceof ItemAxe)
    {
        index = 6;
    }
    else if (output instanceof ItemSpade)
    {
        index = 7;
    }
    else if (output instanceof ItemHoe)
    {
        index = 8;
    }
    else if (output instanceof ItemBow)
    {
        index = 9;
    }
    else if (output instanceof ItemShears)
    {
        index = 10;
    }
    else if (output instanceof ItemFishingRod)
    {
        index = 11;
    }

    return AdditionalCosts.values()[index];
}

@Override
public boolean isShearable(ItemStack item, IBlockAccess world, int x, int y, int z) {
    return !isSheared() && item.getItem() instanceof ItemShears && item.getItemDamage() < (item.getMaxDamage() - 3) && rand.nextInt(100) > 66;
}

@Override
  public boolean onBlockStartBreak(ItemStack itemstack, int x, int y, int z, EntityPlayer player)
  {
      /*
      if (player.worldObj.isRemote)
      {
          return false;
      }
      int id = player.worldObj.getBlockId(x, y, z);
      for(ItemStack stacky : OreDictionary.getOres("treeLeaves")){
    if (stacky.itemID == id) return false;
}

      if (Block.blocksList[id] instanceof IShearable )
      {
          IShearable target = (IShearable)Block.blocksList[id];
          if (target.isShearable(itemstack, player.worldObj, x, y, z))
          {
              ArrayList<ItemStack> drops = target.onSheared(itemstack, player.worldObj, x, y, z,
                    EnchantmentHelper.getEnchantmentLevel(Enchantment.fortune.effectId, itemstack));
              Random rand = new Random();

              for(ItemStack stack : drops)
              {
                  float f = 0.7F;
                  double d  = (double)(rand.nextFloat() * f) + (double)(1.0F - f) * 0.5D;
                  double d1 = (double)(rand.nextFloat() * f) + (double)(1.0F - f) * 0.5D;
                  double d2 = (double)(rand.nextFloat() * f) + (double)(1.0F - f) * 0.5D;
                  EntityItem entityitem = new EntityItem(player.worldObj, (double)x + d, (double)y + d1, (double)z + d2, stack);
                  entityitem.delayBeforeCanPickup = 10;
                  player.worldObj.spawnEntityInWorld(entityitem);
              }

              itemstack.damageItem(1, player);
              player.addStat(StatList.mineBlockStatArray[id], 1);
          }
      }
      return false;
       */
      return new ItemStack(new ItemShears()).getItem().onBlockStartBreak(itemstack, x, y, z, player);
  }

@SubscribeEvent
public static void interact(EntityInteract event) {

    ItemStack itemstack = event.getItemStack();
    EntityPlayer player = event.getEntityPlayer();
    Entity entity = event.getTarget();
    World world = event.getWorld();

    if (world.isRemote || itemstack.equals(ItemStack.EMPTY)) {

        return;

    }

    if ( entity instanceof EntityOcelot && ((EntityOcelot) entity).isSitting() && !entity.isDead && itemstack.getItem() instanceof ItemShears) {

        if (itemstack.getItemDamage() > 1) {

            itemstack.damageItem(2, player);
            world.spawnEntity(new EntityItem(world, entity.posX, entity.posY, entity.lastTickPosZ, new ItemStack(ModItems.itemcathair)));

        } else {

            itemstack.damageItem(1, player);
            if (Math.random() > .5) {

                world.spawnEntity(new EntityItem(world, entity.posX, entity.posY, entity.lastTickPosZ, new ItemStack(ModItems.itemcathair)));

            }

        }

        if (itemstack.getMaxDamage() <= -1) {

            entity.onKillCommand();

        } else {

            if (100 / (((itemstack.getMaxDamage() + 1) / (itemstack.getItemDamage() + 1))) * Math.random() * 2 >= Math.random() * 50) {

                DamageSource killedByShears = new ModDeath("killedByShears", player);

                entity.attackEntityFrom(killedByShears, 1);

            }

        }

        event.setCanceled(true);

    }

}