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

@Override
public boolean isItemValid(ItemStack stack) {
    if(!stack.isEmpty())
    {
        boolean flag = false;
        int[] ids = OreDictionary.getOreIDs(stack);
        for(int id: ids)
            if(OreDictionary.getOreName(id).contains("food")){
                flag = true;
                break;
            }
        if(stack.getItem() instanceof ItemFood || flag)
        {
            if(!FurnaceRecipes.instance().getSmeltingResult(stack).isEmpty())
            {
                return true;
            }
        }
    }
    return false;
}

@Override
public boolean matches(InventoryCrafting inv, World worldIn) {
    // Make sure the first item is a Simic Slaw
    ItemStack stack0 = inv.getStackInSlot(0);
    if (stack0.getItem() != ModItems.simic_slaw) {
        return false;
    }

    // Make sure the slaw isn't full
    if (stack0.hasTagCompound()) {
        byte foodAdditions = stack0.getTagCompound().getByte("additions");
        if (foodAdditions > 5) {
            return false;
        }
    }

    // Make sure we're putting food into the slaw
    ItemStack stack1 = inv.getStackInSlot(1);
    if (!(stack1.getItem() instanceof ItemFood)) {
        return false;
    }

    return true;
}

@EventHandler
public void postInit(FMLPostInitializationEvent event) {
    Items.blaze_rod.setFull3D();
    Blocks.trapped_chest.setCreativeTab(CreativeTabs.tabRedstone);

    if (enableUpdatedFoodValues) {
        setFinalField(ItemFood.class, Items.carrot, 3, "healAmount", "field_77853_b");
        setFinalField(ItemFood.class, Items.baked_potato, 5, "healAmount", "field_77853_b");
    }

    if (enableUpdatedHarvestLevels) {
        Blocks.packed_ice.setHarvestLevel("pickaxe", 0);
        Blocks.ladder.setHarvestLevel("axe", 0);
        Blocks.melon_block.setHarvestLevel("axe", 0);
    }
}

public boolean instanceOf(IItemType type) {
    if (type.equals(IItemType.ItemFishingRod)) {
        return item instanceof ItemFishingRod;
    } else if (type.equals(IItemType.ItemPotion)) {
        return item instanceof ItemPotion;
    } else if (type.equals(IItemType.ItemFood)) {
        return item instanceof ItemFood;
    } else if (type.equals(IItemType.ItemSword)) {
        return item instanceof ItemSword;
    } else if (type.equals(IItemType.ItemTool)) {
        return item instanceof ItemTool;
    } else if (type.equals(IItemType.ItemNameTag)) {
        return item instanceof ItemNameTag;
    } else if (type.equals(IItemType.ItemBlock)) {
        return item instanceof ItemBlock;
    } else if (type.equals(IItemType.ItemHoe)) {
        return item instanceof ItemHoe;
    }
    return false;
}

@Override
public boolean canAdvance(World world, BlockPos pos, IBlockState state) {

    List<EntityItem> items = world.getEntitiesWithinAABB(EntityItem.class, new AxisAlignedBB(pos, pos.add(1, 1, 1)));
    for (EntityItem item : items) {
        if (!item.isDead && item.getEntityItem() != null) {
            if (item.getEntityItem().getItem() instanceof ItemFood)
            {
                UCPacketHandler.sendToNearbyPlayers(world, pos, new PacketUCEffect(EnumParticleTypes.CLOUD, pos.getX(), pos.getY(), pos.getZ(), 6));
                item.getEntityItem().stackSize--;
                if (item.getEntityItem().stackSize <= 0)
                    item.setDead();
                return true;
            }
        }
    }
    return false;
}

private void eatFood() {

    for(int slot = 44; slot >= 9; slot--) {
        ItemStack stack = Wrapper.getPlayer().inventoryContainer.getSlot(slot).getStack();


        if(stack != null) {
            if(slot >= 36 && slot <= 44) {
                if(stack.getItem() instanceof ItemFood 
                        && !(stack.getItem() instanceof ItemAppleGold)) {
                    Wrapper.getPlayer().inventory.currentItem = slot - 36;
                    Wrapper.getMinecraft().gameSettings.keyBindUseItem.pressed = true;
                    return;
                }
            } else if(stack.getItem() instanceof ItemFood 
                    && !(stack.getItem() instanceof ItemAppleGold)) {
                int itemSlot = slot;
                int currentSlot = Wrapper.getPlayer().inventory.currentItem + 36;
                Wrapper.getMinecraft().playerController.windowClick(0, slot, 0, ClickType.PICKUP, Wrapper.getPlayer());
                Wrapper.getMinecraft().playerController.windowClick(0, currentSlot, 0, ClickType.PICKUP, Wrapper.getPlayer());
                Wrapper.getMinecraft().playerController.windowClick(0, slot, 0, ClickType.PICKUP, Wrapper.getPlayer());
                return;
            }
        }
    }
}

public static void tweakVanilla()
{
    ((ItemFood) Items.BEEF).setPotionEffect(new PotionEffect(MobEffects.HUNGER, 20, 0), 20);
    ((ItemFood) Items.PORKCHOP).setPotionEffect(new PotionEffect(MobEffects.HUNGER, 25, 0), 25);
    ((ItemFood) Items.FISH).setPotionEffect(new PotionEffect(MobEffects.HUNGER, 30, 1), 60); // Both fish types here
    ((ItemFood) Items.MUTTON).setPotionEffect(new PotionEffect(MobEffects.HUNGER, 20, 0), 25);
    ((ItemFood) Items.RABBIT).setPotionEffect(new PotionEffect(MobEffects.HUNGER, 25, 0), 30);

    if(BBConfig.makeStuffStackable)
    {
        // Let's face it, the vanilla stack sizes for these suck.
        Items.MINECART.setMaxStackSize(16);
        // Strangely enough the oak one doesn't change name.
        Items.OAK_DOOR.setMaxStackSize(16);
        Items.SPRUCE_DOOR.setMaxStackSize(16);
        Items.BIRCH_DOOR.setMaxStackSize(16);
        Items.ACACIA_DOOR.setMaxStackSize(16);
        Items.DARK_OAK_DOOR.setMaxStackSize(16);
        Items.IRON_DOOR.setMaxStackSize(16);
    }

    if(BBConfig.moduleFurnaces) Items.FURNACE_MINECART.setUnlocalizedName(ModMain.MODID + ".kilnCart");
}

@Load
public void loadLiqueurs() {
    ForgeRegistries.ITEMS.getKeys().stream().filter(s -> s.getResourcePath().contains("liqueur")).map(ForgeRegistries.ITEMS::getValue).forEach(liqueur -> {
        for (LiqueurType liqueurType : LiqueurTypes.values()) {
            if (liqueurType == LiqueurTypes.NORMAL)
                continue;
            ItemLiqueur typedLiqueur = new ItemLiqueur(MathHelper.floor(liqueurType.getHealModifier() * ((ItemFood) liqueur).getHealAmount(new ItemStack(liqueur))));
            typedLiqueur.setLiqueurType(liqueurType);
            typedLiqueur.setRegistryName(liqueur.getRegistryName().getResourceDomain(), liqueurType.getUnlocalizedName() + "_" + liqueur.getRegistryName().getResourcePath());
            typedLiqueur.setUnlocalizedName(liqueur.getUnlocalizedName());
            ForgeRegistries.ITEMS.register(typedLiqueur);
            OreDictionary.registerOre("listAll" + StringUtils.capitalize(liqueurType.getUnlocalizedName()) + "liqueur", typedLiqueur);
            OreDictionary.registerOre("listAllliqueur", typedLiqueur);
            OreDictionary.registerOre("listAllfoods", typedLiqueur);
            cachedLiqueurs.add(typedLiqueur);
        }
    });
}

@SubscribeEvent
public void OnFinish(LivingEntityUseItemEvent.Finish e) //Why not PlayerUseItemEvent.Finish... FORGE 1.9
{
    if (e.getEntity() instanceof EntityPlayer && e.getItem() != null && e.getItem().getItem() instanceof ItemFood) {
        ItemFood food = (ItemFood) e.getItem().getItem();
        World world = e.getEntity().getEntityWorld();

        if (!world.isRemote) {
            String unlocName = food.getUnlocalizedName().substring(5).toLowerCase();
            if (unlocName.startsWith("raw") || unlocName.endsWith("raw") || unlocName.equals("fish")) {
                if (world.rand.nextFloat() > 0.3F)
                    ((EntityPlayer) e.getEntity()).addPotionEffect(new PotionEffect(MobEffects.hunger, 600, 0));
            }
        }
    }
}

public static BasicMachineRecipe getRecipe(ItemStack input){
    if (ItemStackTools.isNullStack(input)) {
        return null;
    }
    for(ItemStack stack : recipeMap.keySet()){
        if(ItemUtil.stackMatchUseOre(input, stack)){
            return recipeMap.get(stack);
        }
    }
    if(ItemStackTools.isValid(FurnaceRecipes.instance().getSmeltingResult(input))){
        ItemStack output = FurnaceRecipes.instance().getSmeltingResult(input).copy();
        int i = 1600;
        if ((output.getItem() instanceof ItemFood)) {
            i /= 2;
        }
        if ((input.getItem() instanceof ItemFood)) {
            i /= 2;
        }
        if ((ItemUtil.isDust(output)) && (ItemUtil.isIngot(output))) {
            i = 1000;
        }
        return new BasicMachineRecipe(input, output, i);
    }
    return null;
}

@Override
public void updateTask() {
    --eatCooldown;
    if(eatingFood != ItemStack.EMPTY) {
        if (foodEatTime > 0) {
            if (--foodEatTime % 4 == 0) {
                PacketHandler.getChannel().sendToAllAround(
                    new WolfEatMessage(entity.getEntityId(), eatingFood),
                    new TargetPoint(entity.dimension, entity.posX, entity.posY, entity.posZ, 60));
                this.entity.playSound(SoundEvents.ENTITY_GENERIC_EAT,
                        0.5F,
                        (this.entity.getRNG().nextFloat() - this.entity.getRNG().nextFloat()) * 0.2F + 1);
            }
        } else if (!hasHealedSinceLastReset) {
            hasHealedSinceLastReset = true;
            PacketHandler.getChannel().sendToAllAround(
                new WolfHealMessage(entity.getEntityId()),
                new TargetPoint(entity.dimension, entity.posX, entity.posY, entity.posZ, 60));
            this.entity.heal((float) ((ItemFood) eatingFood.getItem()).getHealAmount(eatingFood));
            this.eatingFood.shrink(1);
        }
    }
}

@Override
public void updateTask() {
    if (!meat.isDead & Math.pow(living.posX - meat.posX, 2) + Math.pow(living.posZ - meat.posZ, 2) < 32 * 32 &&
            meat.getPosition().distanceSq(living.getPosition()) < 2 && apply(meat)) {
        ItemStack food = meat.getItem();
        food.setCount(food.getCount() - 1);
        if (food.getCount() < 1)
            meat.setDead();
        living.heal(((ItemFood) food.getItem()).getHealAmount(food));
        living.getEntityData().setInteger(NBT_KEY_LAST_MEAL, living.ticksExisted);
        List<Double6IntArrayPackage> d6iaps = new LinkedList<Double6IntArrayPackage>();
        for (int i = 0; i < 7; i++)
            d6iaps.add(new Double6IntArrayPackage(
                    living.posX + (living.rand.nextFloat() * living.width * 2.0F) - living.width,
                    living.posY + 0.5D + living.rand.nextFloat() * living.height,
                    living.posZ + (living.rand.nextFloat() * living.width * 2.0F) - living.width,
                    living.rand.nextGaussian() * 0.02D, living.rand.nextGaussian() * 0.02D, living.rand.nextGaussian() * 0.02D));
        AlchemyNetworkHandler.spawnParticle(EnumParticleTypes.HEART,
                AABBHelper.getAABBFromEntity(living, AlchemyNetworkHandler.getParticleRange()), living.world, d6iaps);
    }
}

int getFoodValue(ItemStack is) {
    if (is == null) {
        return 0;
    }
    Item it = is.getItem();
    int heal = 0;
    double sat = 0;

    FoodInfo fi = lookup(is);
    if (fi != null) {
        heal = fi.heal;
        sat = fi.sat;
    } else if (it instanceof ItemFood) {
        ItemFood nom = (ItemFood) it;
        heal = nom.getHealAmount(is);
        sat = nom.getSaturationModifier(is);
    }
    if (heal < sat) {
        double swapah = heal;
        heal = (int) sat;
        sat = swapah;
    }
    heal += Math.min(0, heal*2*sat);
    int r = (int)(heal*(heal/4F));
    return Math.max(heal, r);
}

@Override
public void onUpdate() {
    if (!AutoEatMod.this.isActive() || Minecraft.getMinecraft().thePlayer.capabilities.isCreativeMode ||
            Minecraft.getMinecraft().thePlayer.getFoodStats().getFoodLevel() >= 20) {
        stop();
        return;
    }
    ItemStack item = Minecraft.getMinecraft().thePlayer.inventory.getStackInSlot(bestSlot);
    if (item == null || !(item.getItem() instanceof ItemFood)) {
        stop();
        return;
    }
    Minecraft.getMinecraft().thePlayer.inventory.currentItem = bestSlot;
    Minecraft.getMinecraft().playerController
            .sendUseItem(Minecraft.getMinecraft().thePlayer, Minecraft.getMinecraft().theWorld, item);
    Minecraft.getMinecraft().gameSettings.keyBindUseItem.pressed = true;
}

public static void addNutrition(FoodStats fs, ItemStack is)
{
    IFoodStatsTFC stats = (IFoodStatsTFC)fs;
    TFCFood food = FoodRegistry.getInstance().getFood(is.getItem(), is.getItemDamage());
    if(food != null && is.getItem() instanceof ItemFood)
    {
        ItemFood item = (ItemFood)is.getItem();
        Iterator iter = food.foodGroup.iterator();
        while(iter.hasNext())
        {
            FoodGroupPair pair = (FoodGroupPair) iter.next();
            float amount = pair.amount;
            if(pair.foodGroup != EnumFoodGroup.None)
            {
                amount = Math.min(stats.getNutritionMap().get(pair.foodGroup) + (item.getHealAmount(is) * (pair.amount / 100f)*0.25f), 20);
                stats.getNutritionMap().put(pair.foodGroup, amount);
            }
        }
    }
}

@Override
public void onCraftMatrixChanged(IInventory inventoryIn) {
    ItemStack stack1 = this.craftMatrix.getStackInSlot(0);
    ItemStack stack2 = this.craftMatrix.getStackInSlot(1);
    if (this.findRecipeAndAddToResultSlot(stack1, stack2) || this.findRecipeAndAddToResultSlot(stack2, stack1)) {
        return;
    }
    if (stack1 != null && stack2 != null) {
        ItemStack food = null;
        if (stack1.getItem() instanceof ItemFood && !(stack1.getItem() instanceof ICondiment)) {
            food = stack1;
        } else if (stack2.getItem() instanceof ItemFood && !(stack2.getItem() instanceof ICondiment)) {
            food = stack2;
        }
        if (CondimentsHandler.instance().isFoodCooked(food)) {
            if (this.addCondimentToItem(stack1, stack2) || this.addCondimentToItem(stack2, stack1)) {
                return;
            }
        }
    }
}

public boolean addCondimentToItem(ItemStack item, ItemStack condiment) {
    if (item != null && item.stackSize > 0 && item.getItem() instanceof ItemFood && condiment != null && condiment.stackSize > 0) {
        ItemStack newItem = item.copy();
        newItem.stackSize = 1;
        if (condiment.getItem() instanceof ICondiment) {
            CondimentsHandler.instance().addCondimentToFood(((ICondiment) condiment.getItem()).getID(), newItem);
        } else if (condiment.getItem() == Items.sugar) {
            CondimentsHandler.instance().addCondimentToFood(ModCondimentIDs.SUGER_ID.ordinal(), newItem);
        } else {
            return false;
        }
        this.craftResult.setInventorySlotContents(0, newItem);
        return true;
    } else {
        this.craftResult.setInventorySlotContents(0, null);
        return false;
    }
}

@SideOnly(Side.CLIENT)
@SubscribeEvent
public void onItemTooltipEvent(ItemTooltipEvent event) {
  if (Keyboard.isCreated()
      && (Keyboard.isKeyDown(Keyboard.KEY_LSHIFT) || Keyboard.isKeyDown(Keyboard.KEY_RSHIFT))) {
    // https://www.reddit.com/r/minecraftsuggestions/comments/3brh7v/when_hovering_over_a_food_it_shows_how_many_food/
    ItemStack itemStack = event.getItemStack();
    if (itemStack == null || itemStack.getItem() == null) {
      return;
    }
    if (foodDetails && itemStack.getItem() instanceof ItemFood) {
      ItemFood food = (ItemFood) itemStack.getItem();
      int hunger = food.getHealAmount(itemStack);
      float satur = food.getSaturationModifier(itemStack);
      if (hunger > 0 || satur > 0) {
        event.getToolTip().add(hunger + " (" + satur + ")");
      }
    }
    if (fuelDetails) {
      int burnTime = TileEntityFurnace.getItemBurnTime(itemStack);
      if (burnTime > 0) {
        event.getToolTip().add(UtilChat.lang("tooltip.burntime") + burnTime);
      }
    }
  }
}

private static void initFoods() {
    for( FoodDefinition def : FoodDefinition.values() ) {
        if( !def.settings.enabled ) continue;
        final ItemFood item = new ItemFood(def.hunger, def.saturation, def.dogfood);
        item.setMaxStackSize(def.stackSize);
        item.setTextureName(Version.TEXTURE_PREFIX + def.texture);
        item.setUnlocalizedName(Version.MOD_ID.toLowerCase() + "." + def.texture);
        item.setCreativeTab(CreativeTabs.tabFood);

        // save the reference :)
        def.item = item;
        GameRegistry.registerItem(item, def.texture);
        for( String oreName : def.oreDict ) {
            OreDictionary.registerOre(oreName, item);
        }
    }
}

/**
 * Player gets food eaten effect and the barrel "takes damage"
 */
@Override
public ItemStack onEaten(ItemStack stack, World world, EntityPlayer player)
{
    int damage = stack.getItemDamage();
    int maxdamage = stack.getMaxDamage();
    int replenishment = maxdamage - damage;
    if (replenishment > 4)
    {
        replenishment = 4;
    }
    if (replenishment > 0)
    {
        player.getFoodStats().func_151686_a(new ItemFood(replenishment, 0.6F, false), stack);
        world.playSoundAtEntity(player, "random.burp", 0.5F, world.rand.nextFloat() * 0.1F + 0.9F);
    }

    return new ItemStack(stack.getItem(), 1, damage + replenishment);
}

/**
 * Iterates through furnace recipes removes those I don't want TODO use for
 * something worthwhile
 */
public static void recipeRemover()
{
    Map<Integer, ItemStack> recipes = FurnaceRecipes.smelting().getSmeltingList();

    Iterator current = recipes.entrySet().iterator();

    while (current.hasNext())
    {
        Map.Entry<Integer, ItemStack> entry = (Entry<Integer, ItemStack>) current.next();
        ItemStack stack = (ItemStack) entry.getValue();
        if (ItemFood.class.isAssignableFrom(stack.getItem().getClass()))
        {
            current.remove();
        }
        else if (stack.getItem() == Items.iron_ingot)
        {
            current.remove();
        }
    }

    return;
}

@EventHandler
public void postInit(FMLPostInitializationEvent event) {
    Items.blaze_rod.setFull3D();
    Blocks.trapped_chest.setCreativeTab(CreativeTabs.tabRedstone);

    if (enableUpdatedFoodValues) {
        setFinalField(ItemFood.class, Items.carrot, 3, "healAmount", "field_77853_b");
        setFinalField(ItemFood.class, Items.baked_potato, 5, "healAmount", "field_77853_b");
    }

    if (enableUpdatedHarvestLevels) {
        Blocks.packed_ice.setHarvestLevel("pickaxe", 0);
        Blocks.ladder.setHarvestLevel("axe", 0);
        Blocks.melon_block.setHarvestLevel("axe", 0);
    }
}

public boolean isBreedingItem(ItemStack stack)
  {
if(isCarnivore){
       return stack == null ? false : (!(stack.getItem() instanceof ItemFood) ? false : ((ItemFood)stack.getItem()).isWolfsFavoriteMeat());

}else{
    if(stack != null){
        if(stack.getItem() != null){
            if(stack.getItem() == this.getHerbivoreItem()){
                return true;
            }
        }
    }
}
return false;
  }

public static void initializeItems(){

    timeToolMaterial = EnumHelper.addToolMaterial("timeToolMaterial", 6, 1620, 8.0F, 4.0F, 7);
    pheromoneArmor = EnumHelper.addArmorMaterial("pheromoneArmor", 12, new int[]{2, 4, 2, 1}, 9);

    fossil_Shard = new Item().setUnlocalizedName("iat.fossil_Shard").setTextureName("iat:fossil").setCreativeTab(ItsAboutTime.iatTab);
    rockPick = new ItemRockPick().setUnlocalizedName("iat.rockPick").setTextureName("iat:rockPick").setCreativeTab(ItsAboutTime.iatTab);
    fossil_Broken = new ItemFossilBroken().setUnlocalizedName("iat.fossil_Broken").setCreativeTab(ItsAboutTime.iatTab);
    fossil = new ItemFossil().setUnlocalizedName("iat.fossil").setCreativeTab(ItsAboutTime.iatTab);
    for (int i = 0; i < EnumFossilSkeleton.values().length; i++) {
        EnumFossilSkeleton.values()[i].fossilItem = new Item().setTextureName("iat:fossil").setUnlocalizedName("iat.fossil" + EnumFossilSkeleton.values()[i].name).setCreativeTab(ItsAboutTime.iatTab);
        EnumFossilSkeleton.values()[i].fossilBrokenItem = new Item().setTextureName("iat:fossil").setUnlocalizedName("iat.fossil_Broken" + EnumFossilSkeleton.values()[i].name).setCreativeTab(ItsAboutTime.iatTab);
    }
    amber = new ItemAmber().setUnlocalizedName("iat.amber").setCreativeTab(ItsAboutTime.iatTab);
    plaster_Ball = new Item().setUnlocalizedName("iat.plaster_Ball").setTextureName("iat:plaster").setCreativeTab(ItsAboutTime.iatTab);
    time_Crystal = new ItemTimeCrystal().setUnlocalizedName("iat.time_Crystal").setTextureName("iat:time_Crystal").setCreativeTab(ItsAboutTime.iatTab);
    time_Shovel = new ItemModSpade(timeToolMaterial).setUnlocalizedName("iat.time_Shovel").setTextureName("iat:time_Shovel").setCreativeTab(ItsAboutTime.iatTab);
    time_Pickaxe = new ItemModPickaxe(timeToolMaterial).setUnlocalizedName("iat.time_Pickaxe").setTextureName("iat:time_Pickaxe").setCreativeTab(ItsAboutTime.iatTab);
    time_Axe = new ItemModAxe(timeToolMaterial).setUnlocalizedName("iat.time_Axe").setTextureName("iat:time_Axe").setCreativeTab(ItsAboutTime.iatTab);
    time_Sword = new ItemSword(timeToolMaterial).setUnlocalizedName("iat.time_Sword").setTextureName("iat:time_Sword").setCreativeTab(ItsAboutTime.iatTab);
    time_Hoe = new ItemHoe(timeToolMaterial).setUnlocalizedName("iat.time_Hoe").setTextureName("iat:time_Hoe").setCreativeTab(ItsAboutTime.iatTab);
    pheromoneChest = new ItemPheromoneArmor(pheromoneArmor, 0, 1).setUnlocalizedName("iat.pheromoneCanester").setTextureName("iat:pheromoneCanester").setCreativeTab(ItsAboutTime.iatTab);
    bucket_Time = new ItemBucket(ModBlocks.fluidTimeBlock).setUnlocalizedName("iat.bucket_Time").setTextureName("iat:bucket_Time").setContainerItem(Items.bucket);
    ginkoNuts = new ItemFood(2, 0.2F, false).setPotionEffect(Potion.hunger.id, 30, 0, 0.3F).setUnlocalizedName("iat.ginkoNut").setTextureName("iat:ginko_nut").setCreativeTab(ItsAboutTime.iatTab);
}

@Override
public void onOutwardPacket(EventOnOutwardPacket event){
    if(!invoker.isOnGround()) return;
       Packet packet = event.getPacket();
       if (packet instanceof C08PacketPlayerBlockPlacement) {
        if(!(invoker.getCurrentItem().getItem() instanceof ItemFood)) return;
           C08PacketPlayerBlockPlacement packetBlockPlacement = (C08PacketPlayerBlockPlacement) packet;
           if (packetBlockPlacement.func_149576_c() != -1 || packetBlockPlacement.func_149571_d() != -1 || packetBlockPlacement.func_149570_e() != -1 || packetBlockPlacement.func_149568_f() != 255) {
               return;
           }
           event.addPacketToList(new C09PacketHeldItemChange(Minecraft.getMinecraft().thePlayer.inventory.currentItem));
           for (int i = 0; i < 40; i++) {
            event.addPacketToList(new C03PacketPlayer(false));
           }

           event.addPacketToList(new C07PacketPlayerDigging(5, 0, 0, 0, 255));
       }
}

@Override
public void onUpdate(EventOnUpdate event){
    if(prevSlot != -1 && finished && goOnce){
        invoker.setInvSlot(prevSlot);
        invoker.setUseItemKeyPressed(false);
        goOnce = false;
    }
    if(invoker.getFoodLevel() < 18){
        for(int i=0; i<9; i++){
            ItemStack item = invoker.getItemAtSlotHotbar(i);
            if(item != null && item.getItem() instanceof ItemFood){
                prevSlot = invoker.getCurInvSlot();
                invoker.setInvSlot(i);
                invoker.setUseItemKeyPressed(true);
                if(invoker.getFoodLevel() > 16){
                    goOnce = true;
                    finished = true;
                }
            }
        }
    }
}

/**
 * @param input1 The ItemStack to get result of.
 * @return Returns the result of the item stack when cooked in the Oven. Returns null when nothing was found
 */
public static ItemStack getCookingResult(ItemStack input1)
{
    for (Map.Entry<ItemStack, ItemStack> entry : customOvenRecipes.entrySet())
    {
        ItemStack input2 = entry.getKey();
        if (input1.isItemEqual(input2))
            return entry.getValue().copy();
    }

    ItemStack furnaceOutput = FurnaceRecipes.smelting().getSmeltingResult(input1);
    if (furnaceOutput != null && furnaceOutput.getItem() instanceof ItemFood)
        furnaceOutput.copy();

    /*for (int i = 0; i < customOvenRecipes[0].size(); i++)
    {
        ItemStack stack = customOvenRecipes[0].get(i);
        if (itemStack.isItemEqual(stack))
            return customOvenRecipes[1].get(i);
    }*/

    return null;
}

public boolean isTempting(ItemStack item)
{
    if(item != null)
    {
        if(item.itemID == Item.bone.itemID)
        {
            return true;
        }
        if(item.getItem() instanceof ItemFood)
        {
            if(((ItemFood)item.getItem()).isWolfsFavoriteMeat())
            {
                return true;
            }
        }
    }
    return false;
}

@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int i1, float f1, float f2, float f3) {
    ItemStack itemstack = player.inventory.getCurrentItem();
    TileEntityDogBowl tile = (TileEntityDogBowl) world.getBlockTileEntity(x, y, z);

    if (!world.isRemote && tile != null && itemstack != null && itemstack.getItem() instanceof ItemFood)
    {
        ItemFood food = (ItemFood) itemstack.getItem();
        if (food.isWolfsFavoriteMeat() && tile.canPutFood()) 
        {
            tile.addFood(food.getHealAmount());
            if(!player.capabilities.isCreativeMode)
            itemstack.stackSize--;
            player.swingItem();
            return true;
        }
    }
    return false;
}

public ItemStack getResult(ItemStack item) 
   {
    ItemStack result = OvenRecipes.getSmeltingResult(item);

    if(result != null)
    {
        return result;
    }
    result = FurnaceRecipes.smelting().getSmeltingResult(item);

    if(result != null && result.getItem() instanceof ItemFood)
    {
        return result;
    }
    return null;
}

@Override
public void onUpdate(ItemStack stack, World world, Entity entity, int par4, boolean par5) {
    if(world.isRemote){
    NBTTagCompound tag = ItemUtils.getItemTag(stack);
    tag.setInteger("hungerStorage", 0);
    tag.setInteger("maxHungerStorage", 0);
    EntityPlayer player = (EntityPlayer)entity;
    if(Keyboard.isKeyDown(Keyboard.KEY_F)){
        if(tag.getInteger("hungerStorage") < tag.getInteger("maxHungerStorage")){
        tag.setInteger("hungerStorage", tag.getInteger("hungerStorage")+((ItemFood) foodFunc(stack, player)).func_150905_g(stack));
        player.inventory.consumeInventoryItem(foodFunc(stack, player));             
        }
    }
    if(player.getFoodStats().getFoodLevel() < 20 && player.getFoodStats().needFood() && tag.getInteger("hungerStorage") > 20 - player.getFoodStats().getFoodLevel()){
        player.getFoodStats().setFoodLevel(20 - player.getFoodStats().getFoodLevel());
        tag.setInteger("hungerStorage", 20 - player.getFoodStats().getFoodLevel());
        }
    }
}

public static void addNutrition(FoodStats fs, ItemStack is)
{
    IFoodStatsTFC stats = (IFoodStatsTFC)fs;
    TFCFood food = FoodRegistry.getInstance().getFood(is.getItem(), is.getItemDamage());
    if(food != null && is.getItem() instanceof ItemFood)
    {
        ItemFood item = (ItemFood)is.getItem();
        Iterator iter = food.foodGroup.iterator();
        while(iter.hasNext())
        {
            FoodGroupPair pair = (FoodGroupPair) iter.next();
            float amount = pair.amount;
            if(pair.foodGroup != EnumFoodGroup.None)
            {
                amount = Math.min(stats.getNutritionMap().get(pair.foodGroup) + (item.getHealAmount(is) * (pair.amount / 100f)*0.25f), 20);
                stats.getNutritionMap().put(pair.foodGroup, amount);
            }
        }
    }
}

public int getFirstDogFoodStack(EntityZertumEntity dog) {
    for (int i = 0; i < 5; i++) {
        if (bowlContents[i] == null)
            continue;

        Item item = bowlContents[i].getItem();

        if (item == null || !(item instanceof ItemFood))
            continue;

        ItemStack itemstack = getStackInSlot(i);

        if(dog.foodValue(itemstack) != 0)
            return i;
    }

    return -1;
}

private boolean ContainsFood()
{
    for (int i = 0; i < 5; i++)
    {
        if (bowlContents[i] == null)
        {
            continue;
        }

        Item item = bowlContents[i].getItem();

        if (item != null && (item instanceof ItemFood))
        {
            return true;
        }
    }

    return false;
}

@SubscribeEvent
public void finishItemUse(PlayerUseItemEvent.Finish event) {
    if (FMLCommonHandler.instance().getSide() == Side.SERVER) {
        EntityPlayer player = event.entityPlayer;
        ItemStack stack = event.item;
        if (Rings.proxy.manaHandler.playerHasSession(player) && !player.capabilities.isCreativeMode) {
            if (stack.getItem() instanceof ItemFood) {
                int foodPoints = ((ItemFood) stack.getItem()).func_150905_g(stack) * 2;
                IPlayerSession playerSession = Rings.proxy.manaHandler.getPlayerSession(player);
                playerSession.adjustMana(foodPoints, false);
                Rings.proxy.manaHandler.updatePlayerSession(playerSession, player.getEntityWorld().provider.dimensionId);
            }
        }
        /*
        if (MagicHandler.getMagicHandler().getPlayerTag(player) != null && !player.capabilities.isCreativeMode) {
            if (stack.getItem() instanceof ItemFood) {
                int foodPoints = ((ItemFood) stack.getItem()).func_150905_g(stack) * 2;
                Rings.pktHandler.sendToServer(new PacketModifyMp(player, foodPoints, 0));
            }
        }*/
    }
}

@Override
public void onUpdate(EntityPlayer player, Side side) {
    if (player.worldObj.getTotalWorldTime() % 40 == 0 && side.isServer()) {
        InventoryPlayer inventoryPlayer = player.inventory;
        player.addPotionEffect(new PotionEffect(Potion.hunger.id, 40));
        for (int i = 0; i < inventoryPlayer.getSizeInventory(); i++) {
            ItemStack itemStack = inventoryPlayer.getStackInSlot(i);
            if (itemStack != null && itemStack.getItem() instanceof ItemFood) {
                inventoryPlayer.setInventorySlotContents(i, itemStack.onFoodEaten(player.worldObj, player).stackSize <= 0 ? null : itemStack);
                player.worldObj.playSoundAtEntity(player, "random.eat", 0.5F + 0.5F * (float) player.getRNG().nextInt(2), (player.getRNG().nextFloat() - player.getRNG().nextFloat()) * 0.2F + 1.0F);
                this.playerCount.add(player.getCommandSenderName());
                break;
            }
        }
        if (player.worldObj.getTotalWorldTime() % 80 == 0) this.playerCount.add(player.getCommandSenderName());
    }
}

private void init () {
    registerCompostMaterial(new ItemStack(Blocks.melon_block), defaultMaterial);
    registerCompostMaterial(new ItemStack(Blocks.pumpkin), defaultMaterial);
    registerCompostMaterial(new ItemStack(Blocks.hay_block), defaultMaterial);
    registerCompostMaterial(new ItemStack(Items.string), new StandardCompostMaterial(100, 0.0625f));
    registerCompostMaterial(new ItemStack(Items.wheat), new StandardCompostMaterial(100, 0.125f));
    registerCompostMaterial(new ItemStack(Items.reeds), new StandardCompostMaterial(150, 0.125f));
    registerCompostMaterial(new ItemStack(Items.feather), new StandardCompostMaterial(50, 0.0625f));
    registerCompostMaterial(new ItemStack(Items.rotten_flesh), new StandardCompostMaterial(150, 0.125f));
    registerCompostMaterial(new ItemStack(Items.leather), new StandardCompostMaterial(150, 0.125f));

    registerCompostMaterial("treeWood", new StandardCompostMaterial(300, 0.25f));
    registerCompostMaterial("logWood", new StandardCompostMaterial(300, 0.25f));
    registerCompostMaterial("treeLeaves", defaultMaterial);
    registerCompostMaterial("treeSapling", defaultMaterial);
    registerCompostMaterial("stickWood", defaultMaterial);

    registerCompostMaterial(IPlantable.class, defaultMaterial);
    registerCompostMaterial(IGrowable.class, defaultMaterial);
    registerCompostMaterial(BlockLeavesBase.class, defaultMaterial);
    registerCompostMaterial(BlockVine.class, defaultMaterial);
    registerCompostMaterial(ItemFood.class, defaultMaterial);
}

@Override
public boolean interact(EntityPlayer player, ItemStack item) {
    // eat only if hurt
    if (dragon.isServer() && dragon.getHealthRelative() < 1) {
        ItemFood food = (ItemFood) ItemUtils.consumeEquipped(player,
                dragon.getBreed().getFoodItems());

        // heal only if the food was actually consumed
        if (food != null) {
            dragon.heal(food.getHealAmount(item));
            dragon.playSound(dragon.getSoundManager().getEatSound(), 0.7f, 1);
            return true;
        }
    }

    return false;
}

/**
 * Called to tick armor in the armor slot. Override to do something
 *
 * @param world
 * @param player
 * @param itemStack
 */
public void onArmorTick(World world, EntityPlayer player, ItemStack itemStack)
{
    if(itemStack!=null)
    {
        RebreatherInv inv = new RebreatherInv(itemStack);
        if(player.getFoodStats().needFood())
        {
            for(int i = 0; i < inv.INV_SIZE/2; i++)
            {
                if(inv.getStackInSlot(i)!= null && inv.getStackInSlot(i).getItem() instanceof ItemFood)
                {
                if(player.getFoodStats().getFoodLevel()+((ItemFood) inv.getStackInSlot(i).getItem()).func_150905_g(inv.getStackInSlot(i)) <= 20)
                {
                    player.getFoodStats().setFoodLevel(player.getFoodStats().getFoodLevel()+((ItemFood) inv.getStackInSlot(i).getItem()).func_150905_g(inv.getStackInSlot(i)));
                    player.getFoodStats().setFoodSaturationLevel(player.getFoodStats().getSaturationLevel()+((ItemFood) inv.getStackInSlot(i).getItem()).func_150906_h(inv.getStackInSlot(i)));
                    inv.decrStackSize(i, 1);
                }
                }
            }
        }

    }
}

@Override
public int onWornTick(ItemStack stack, EntityLivingBase entity, ITrinket item) {
    if (!entity.worldObj.isRemote && entity instanceof EntityPlayer) {
        EntityPlayer player = (EntityPlayer) entity;
        for (int i = 0; i < player.inventory.getSizeInventory(); i++) {
            ItemStack foodStack = player.inventory.getStackInSlot(i);
            if (player.getFoodStats().getFoodLevel() < 20 && foodStack != null && foodStack.getItem() instanceof ItemFood) {
                ItemFood food = (ItemFood) foodStack.getItem();

                if (hasEnergy(item, foodStack, getUsage()) && player.getFoodStats().getFoodLevel() + food.func_150905_g(player.inventory.getStackInSlot(i)) <= 20) {
                    food.onEaten(new ItemStack(food), entity.worldObj, player);
                    player.inventory.getStackInSlot(i).stackSize--;
                    if (player.inventory.getStackInSlot(i).stackSize == 0) {
                        player.inventory.setInventorySlotContents(i, null);
                    }
                    return getUsage();
                }
            }
        }
    }
    return 0;
}