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

boolean placeFluid(PumpCoord pc, Fluid fluid) {
    at.w = worldObj;
    at.set(pc.pos);
    if (!at.isReplacable()) return false;
    Block block = fluid.getBlock();
    if (block == null) return false;
    if (drainBlock(pc, false) != null) return false;
    if (block == Blocks.water) block = Blocks.flowing_water;
    else if (block == Blocks.lava) block = Blocks.flowing_lava;

    if (block == Blocks.flowing_water) {
        ((ItemBucket) Items.water_bucket).tryPlaceContainedLiquid(at.w, pos);
    } else {
        // NORELEASE: Is there a 1.8-ish way of placing fluid blocks now?
        at.setIdMd(block, block instanceof BlockFluidFinite ? 0xF : 0, true);
    }
    buffer.setFluid(null);
    at.notifyBlockChange();
    return true;
}

@Override
public void placeBlock(World world, int x, int y, int z, ForgeDirection direction, EntityPlayer player,
                       ItemStack placing, IToggleController controller) // TODO: Add storage item index as parameter?
{
    if (FluidContainerRegistry.isFilledContainer(placing))
    {
        FluidStack fluidStack = FluidContainerRegistry.getFluidForFilledItem(placing);
        Fluid fluid = fluidStack.getFluid();
        if (fluidStack.getFluid().canBePlacedInWorld())
        {
            Block fluidBlock = fluid.getBlock();
            world.setBlock(x, y, z, fluidBlock);
            world.notifyBlockChange(x, y, z, fluidBlock);
            fluidBlock.onBlockAdded(world, x, y, z);
            ItemStack drainedContainer = FluidContainerRegistry.drainFluidContainer(placing);
            placing.stackSize--;
            controller.getStorageHandler().addItemStackToStorage(drainedContainer);
        }
    } else if (placing.getItem() instanceof ItemBucket)
    {
        ItemBucket item = (ItemBucket) placing.getItem();
        item.tryPlaceContainedLiquid(world, x, y, z);
    }
}

public final static boolean addToWhiteList(String id){
    String[] parts = id.split(":", 4);
    if(parts.length < 1)
        return false;
    ItemStack stack = GameRegistry.findItemStack(parts.length==1 ? "minecraft" : parts[0], parts.length==1 ? parts[0] : parts[1], 1);
    if(stack == null)
        return false;
    if((stack.getItem() instanceof ItemBlock) || (stack.getItem() instanceof ItemPotion) || (stack.getItem() instanceof ItemArmor) || (stack.getItem() instanceof ItemBucket))
        return false;
    int meta=OreDictionary.WILDCARD_VALUE;
    if(parts.length >= 3){
        try{
            meta=Integer.parseInt(parts[2]);
        }catch(NumberFormatException e){
            meta=OreDictionary.WILDCARD_VALUE;
        }
    }
    return addToWhiteList(new ItemData(stack.getItem(), meta));
}

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);
}

/**
 * Dispense the specified stack, play the dispense sound and spawn particles.
 */
public ItemStack dispenseStack(IBlockSource par1IBlockSource, ItemStack par2ItemStack)
{
    ItemBucket itembucket = (ItemBucket)par2ItemStack.getItem();
    int i = par1IBlockSource.getXInt();
    int j = par1IBlockSource.getYInt();
    int k = par1IBlockSource.getZInt();
    EnumFacing enumfacing = BlockDispenser.getFacing(par1IBlockSource.getBlockMetadata());

    if (itembucket.tryPlaceContainedLiquid(par1IBlockSource.getWorld(), i + enumfacing.getFrontOffsetX(), j + enumfacing.getFrontOffsetY(), k + enumfacing.getFrontOffsetZ()))
    {
        par2ItemStack.itemID = Item.bucketEmpty.itemID;
        par2ItemStack.stackSize = 1;
        return par2ItemStack;
    }
    else
    {
        return this.defaultDispenserItemBehavior.dispense(par1IBlockSource, par2ItemStack);
    }
}

/**
 * Dispense the specified stack, play the dispense sound and spawn particles.
 */
public ItemStack dispenseStack(IBlockSource par1IBlockSource, ItemStack par2ItemStack)
{
    ItemBucket itembucket = (ItemBucket)par2ItemStack.getItem();
    int i = par1IBlockSource.getXInt();
    int j = par1IBlockSource.getYInt();
    int k = par1IBlockSource.getZInt();
    EnumFacing enumfacing = BlockDispenser.getFacing(par1IBlockSource.getBlockMetadata());

    if (itembucket.tryPlaceContainedLiquid(par1IBlockSource.getWorld(), i + enumfacing.getFrontOffsetX(), j + enumfacing.getFrontOffsetY(), k + enumfacing.getFrontOffsetZ()))
    {
        par2ItemStack.itemID = Item.bucketEmpty.itemID;
        par2ItemStack.stackSize = 1;
        return par2ItemStack;
    }
    else
    {
        return this.defaultDispenserItemBehavior.dispense(par1IBlockSource, par2ItemStack);
    }
}

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";
}

@SubscribeEvent
public void onItemTooltip(ItemTooltipEvent event) {
    if (event.getItemStack().getItem() instanceof IProgrammable) {
        handleProgrammableTooltip(event);
    } else if (event.getItemStack().getItem() instanceof ItemBucket || event.getItemStack().getItem() instanceof UniversalBucket) {
        handleFluidContainerTooltip(event);
    }
}

private void decrVanillaGrid(int amount) {
    for (int i = 1; i < 10; i++) {
        if (slots[i] != null) {
            if (slots[i].stackSize == amount) {
                if (slots[i].getItem() instanceof ItemBucket) {
                    slots[i] = new ItemStack(Items.BUCKET);
                } else {
                    slots[i] = null;
                }
            } else if (slots[i].stackSize > amount) {
                slots[i].stackSize -= amount;
            }
        }
    }
}

private void decrAllGrid(int amount) {
    for (int i = 1; i <= 17; i++) {
        if (slots[i] != null) {
            if (slots[i].stackSize == amount) {
                if (slots[i].getItem() instanceof ItemBucket) {
                    slots[i] = new ItemStack(Items.BUCKET);
                } else {
                    slots[i] = null;
                }
            } else if (slots[i].stackSize > amount) {
                slots[i].stackSize -= amount;
            }
        }
    }
}

@Patch.Exception
@Hook("net.minecraft.item.ItemBucket#func_77659_a")
public static Hook.Result onItemRightClick(ItemBucket item, ItemStack stack, World world, EntityPlayer player, EnumHand hand) {
    if (item == Items.LAVA_BUCKET) {
        RayTraceResult rayTrace = item.rayTrace(world, player, false);
        if (rayTrace == null) {
            player.setActiveHand(hand);
            return new Hook.Result(new ActionResult(EnumActionResult.SUCCESS, stack));
        }
    }
    return Hook.Result.VOID;
}

@Patch.Exception
    @Hook("net.minecraft.item.ItemBucket#func_77654_b")
    public static Hook.Result onItemUseFinish(ItemBucket item, ItemStack stack, World world, EntityLivingBase living) {
        if (item == Items.LAVA_BUCKET) {
            living.attackEntityFrom(DamageSource.LAVA, 10);
            living.setFire(30);
//          if (living instanceof EntityPlayer) {
//              EntityPlayer player = (EntityPlayer) living;
//          }
            return new Hook.Result(new ItemStack(Items.BUCKET));
        } else
            return Hook.Result.VOID;
    }

public boolean hasBucketInStacks() {
    for (int i = 0; i < this.stackList.length; ++i) {
        if (this.stackList[i] != null && this.stackList[i].getItem() instanceof ItemBucket) {
            return true;
        }
    }
    return false;
}

@Override
public boolean isItemValid(ItemStack stack) {
    if (stack != null) {
        if (stack.getItem() instanceof ItemBucket) {
            return !this.inv.hasBucketInStacks();
        } else if (stack.getItem().getContainerItem() != null) {
            return !this.inv.hasItemsHasContainerItem();
        } else {
            return true;
        }
    }
    return false;
}

protected void importFuel() {
  ItemStack itemstack = this.getStackInSlot(this.fuelSlot);
  //pull in item from fuel slot, if it has fuel burn time
  int fuelFromStack = FUEL_FACTOR * TileEntityFurnace.getItemBurnTime(itemstack);
  if (fuelFromStack > 0 && this.energyStorage.emptyCapacity() >= fuelFromStack
      && world.isRemote == false) {
    int newEnergy = Math.min(this.getFuelMax(), this.getFuelCurrent() + fuelFromStack);
    this.energyStorage.setEnergyStored(newEnergy);
    if (itemstack.getItem() instanceof ItemBucket && itemstack.getCount() == 1) {
      this.setInventorySlotContents(this.fuelSlot, new ItemStack(Items.BUCKET));
    }
    else {
      itemstack.shrink(1);
    }
  }
  //what if item in fuel slot is an RF battery type item? start draining it ya
  if (itemstack.hasCapability(CapabilityEnergy.ENERGY, null)) {
    IEnergyStorage storage = itemstack.getCapability(CapabilityEnergy.ENERGY, null);
    if (storage != null && storage.getEnergyStored() > 0) {
      int canWithdraw = Math.min(EnergyStore.MAX_INPUT, storage.getEnergyStored());
      if (canWithdraw > 0 && this.getFuelCurrent() + canWithdraw <= this.getFuelMax()) {
        storage.extractEnergy(canWithdraw, false);
        this.setFuelCurrent(this.getFuelCurrent() + canWithdraw);
      }
    }
  }
}

public static final boolean isValidTool(ItemStack stack){
    if((stack.getItem() instanceof ItemBlock) || (stack.getItem() instanceof ItemPotion) || (stack.getItem() instanceof ItemArmor) || (stack.getItem() instanceof ItemBucket))
        return false;
    if(isWhiteListed(stack))
        return true;
    if(isBlackListed(stack))
        return false;
    return stack.getMaxStackSize() == 1 && !(stack.getItem() instanceof ItemBlock) && !(stack.getItem() instanceof ItemPotion) && !(stack.getItem() instanceof ItemArmor) && !(stack.getItem() instanceof ItemBucket);
}

@Override
    protected void handleInTileState(Block block, EnumFacing facing) {
        BlockPos blockpos = new BlockPos(this.xTile, this.yTile, this.zTile);
        BlockPos facingBlockPos = facingBlock(blockpos, facing);
//      worldObj.setBlockState(facingBlockPos, Blocks.water.getDefaultState());
        ItemBucket waterBucket = (ItemBucket)(Items.WATER_BUCKET);
        waterBucket.tryPlaceContainedLiquid((EntityPlayer)this.shootingEntity, this.world, facingBlockPos);
        this.setDead();
    }

@Override
    protected void handleEntityHit(Entity entity) {
        BlockPos blockpos = new BlockPos(this.posX, this.posY, this.posZ);
//      Block.spawnAsEntity(worldObj, blockpos, new ItemStack(ModFreneticFolly.waterArrow));
        ItemBucket waterBucket = (ItemBucket)(Items.WATER_BUCKET);
//      FFLogger.info("EntityWaterArrow handleEntityHit: trying to place a block of water at " + blockpos);
        waterBucket.tryPlaceContainedLiquid((EntityPlayer)this.shootingEntity, this.world, blockpos);
        this.setDead();
    }

@Override
    protected void handleInTileState(Block block, EnumFacing facing) {
        BlockPos blockpos = new BlockPos(this.xTile, this.yTile, this.zTile);
        BlockPos facingBlockPos = facingBlock(blockpos, facing);
//      worldObj.setBlockState(facingBlockPos, Blocks.water.getDefaultState());
        ItemBucket waterBucket = (ItemBucket)(Items.LAVA_BUCKET);
        waterBucket.tryPlaceContainedLiquid((EntityPlayer)this.shootingEntity, this.world, facingBlockPos);
        this.setDead();
    }

@Override
    protected void handleEntityHit(Entity entity) {
        BlockPos blockpos = new BlockPos(this.posX, this.posY, this.posZ);
//      Block.spawnAsEntity(worldObj, blockpos, new ItemStack(ModFreneticFolly.waterArrow));
        ItemBucket waterBucket = (ItemBucket)(Items.LAVA_BUCKET);
//      FFLogger.info("EntityLavaArrow handleEntityHit: trying to place a block of lava at " + blockpos);
        waterBucket.tryPlaceContainedLiquid((EntityPlayer)this.shootingEntity, this.world, blockpos);
        this.setDead();
    }

/**
 * Initialize Items
 */
public static void init()
{
    wrench = new ItemWrench().setUnlocalizedName("wrench").setTextureName("wrench");
    energizedWaterBucket = new ItemBucket(ModBlocks.energizedWater).setUnlocalizedName("energizedWaterBucket").setTextureName(Reference.MOD_ID + ":" + "bucket_energized_water").setCreativeTab(EnergizedPowerTabs.mainTab).setContainerItem(Items.bucket);

    GameRegistry.registerItem(wrench, "wrench");
    GameRegistry.registerItem(energizedWaterBucket, "bucket_energized_water");

    debug = new ItemDebug().setUnlocalizedName("debug").setTextureName("debug");
    GameRegistry.registerItem(debug, "debug");
}

public static boolean canItemAcceptSockets(ItemStack stack) {
    Item item = stack.getItem();
    if (item == PhysisItems.socketable) {
        return false;
    }
    if (item instanceof ItemBlock
        || item instanceof ItemReed
        || item instanceof ItemBed
        || item instanceof ItemFood
        || item instanceof ItemPotion
        || item instanceof ItemMinecart
        || item instanceof ItemBoat
        || item instanceof ItemEnchantedBook
        || item instanceof ItemWritableBook
        || item instanceof ItemBucket
        || item instanceof ItemBucketMilk
        || item instanceof ItemDoor) {
        return false;
    }
    if (item.getItemStackLimit(stack) > 1) {
        return false;
    }
    if (item.hasContainerItem(stack)){
        ItemStack container = item.getContainerItem(stack);
        if (container != null && container.getItem() instanceof ItemBucket) {
            return false;
        }
    }
    if (item.getUnlocalizedName(stack).toLowerCase().contains("bucket")) {
        return false;
    }
    return true;
}

public ItemStack func_82487_b(IBlockSource p_82487_1_, ItemStack p_82487_2_) {
   ItemBucket var3 = (ItemBucket)p_82487_2_.func_77973_b();
   int var4 = p_82487_1_.func_82623_d();
   int var5 = p_82487_1_.func_82622_e();
   int var6 = p_82487_1_.func_82621_f();
   EnumFacing var7 = BlockDispenser.func_100009_j_(p_82487_1_.func_82620_h());
   if(var3.func_77875_a(p_82487_1_.func_82618_k(), var4 + var7.func_82601_c(), var5 + var7.func_96559_d(), var6 + var7.func_82599_e())) {
      p_82487_2_.field_77993_c = Item.field_77788_aw.field_77779_bT;
      p_82487_2_.field_77994_a = 1;
      return p_82487_2_;
   } else {
      return this.field_96459_b.func_82482_a(p_82487_1_, p_82487_2_);
   }
}

private static void initializeFluidBlocksAndBuckets(){
    for(final Fluid fluid : fluids) {
        //FluidRegistry.registerFluid(fluid); (The constructor of FluidPneumaticCrafts registers the fluid.
        Block fluidBlock = fluid.getBlock();
        Blockss.registerBlock(fluidBlock);
        fluidToBlockMap.put(fluid.getName(), fluidBlock);

        Item fluidBucket = new ItemBucket(fluidBlock){
            @Override
            public void addInformation(ItemStack p_77624_1_, net.minecraft.entity.player.EntityPlayer p_77624_2_, List p_77624_3_, boolean p_77624_4_){
                super.addInformation(p_77624_1_, p_77624_2_, p_77624_3_, p_77624_4_);
                ItemPneumatic.addTooltip(p_77624_1_, p_77624_2_, p_77624_3_);
            };

            @Override
            @SideOnly(Side.CLIENT)
            public void getSubItems(Item item, CreativeTabs creativeTab, List items){
                if(FluidRegistry.isFluidDefault(fluid)) super.getSubItems(item, creativeTab, items);
            }
        }.setContainerItem(Items.bucket).setCreativeTab(PneumaticCraft.tabPneumaticCraft).setTextureName(Textures.ICON_LOCATION + fluid.getName() + "Bucket").setUnlocalizedName(fluid.getName() + "Bucket");

        Itemss.registerItem(fluidBucket);

        fluidBlockToBucketMap.put(fluidBlock, fluidBucket);

        FluidContainerRegistry.registerFluidContainer(new FluidStack(fluid, 1000), new ItemStack(fluidBucket), new ItemStack(Items.bucket));
    }
}

@Override
public void register(IModRegistry registry) {
    if (BlockRegistry.sludgeRefinerBlock.isEnabled()) {
        int maxWeight = WeightedRandom.getTotalWeight(BlockRegistry.sludgeRefinerBlock.getItems());
        List<SludgeRefinerRecipeWrapper> wrapperList = new ArrayList<>();
        BlockRegistry.sludgeRefinerBlock.getItems().forEach(itemStackWeightedItem -> wrapperList.add(new SludgeRefinerRecipeWrapper(itemStackWeightedItem, maxWeight)));
        registry.addRecipes(wrapperList, sludgeRefinerRecipeCategory.getUid());
        registry.addRecipeCatalyst(new ItemStack(BlockRegistry.sludgeRefinerBlock), sludgeRefinerRecipeCategory.getUid());
    }
    if (BlockRegistry.bioReactorBlock.isEnabled()) {
        List<ReactorRecipeWrapper> bioreactor = new ArrayList<>();
        BioReactorEntry.BIO_REACTOR_ENTRIES.forEach(entry -> bioreactor.add(new ReactorRecipeWrapper(entry.getStack(), FluidsRegistry.BIOFUEL, BlockRegistry.bioReactorBlock.getBaseAmount())));
        registry.addRecipes(bioreactor, bioReactorRecipeCategory.getUid());
        registry.addRecipeCatalyst(new ItemStack(BlockRegistry.bioReactorBlock), bioReactorRecipeCategory.getUid());
    }
    if (BlockRegistry.proteinReactorBlock.isEnabled()) {
        List<ReactorRecipeWrapper> proteinreactor = new ArrayList<>();
        ProteinReactorEntry.PROTEIN_REACTOR_ENTRIES.forEach(entry -> proteinreactor.add(new ReactorRecipeWrapper(entry.getStack(), FluidsRegistry.PROTEIN, BlockRegistry.proteinReactorBlock.getBaseAmount())));
        registry.addRecipes(proteinreactor, proteinReactorRecipeCategory.getUid());
        registry.addRecipeCatalyst(new ItemStack(BlockRegistry.proteinReactorBlock), proteinReactorRecipeCategory.getUid());
    }
    if (BlockRegistry.laserBaseBlock.isEnabled() || BlockRegistry.laserDrillBlock.isEnabled()) {
        List<ItemStackWeightedItem> item = new ArrayList<>();
        LaserDrillEntry.LASER_DRILL_ENTRIES.forEach(entry -> item.add(new ItemStackWeightedItem(entry.getStack(), entry.getWeight())));
        final int laserMaxWeight = WeightedRandom.getTotalWeight(item);
        List<LaserRecipeWrapper> laserRecipeWrappers = new ArrayList<>();
        LaserDrillEntry.LASER_DRILL_ENTRIES.forEach(entry -> laserRecipeWrappers.add(new LaserRecipeWrapper(new ItemStackWeightedItem(entry.getStack(), entry.getWeight()), laserMaxWeight, entry.getLaserMeta())));
        registry.addRecipes(laserRecipeWrappers, laserRecipeCategory.getUid());
        registry.addRecipeCatalyst(new ItemStack(BlockRegistry.laserDrillBlock), laserRecipeCategory.getUid());
        registry.addRecipeCatalyst(new ItemStack(BlockRegistry.laserBaseBlock), laserRecipeCategory.getUid());
    }
    if (BlockRegistry.resourcefulFurnaceBlock.isEnabled())
        registry.addRecipeCatalyst(new ItemStack(BlockRegistry.resourcefulFurnaceBlock), VanillaRecipeCategoryUid.SMELTING);
    if (BlockRegistry.potionEnervatorBlock.isEnabled())
        registry.addRecipeCatalyst(new ItemStack(BlockRegistry.potionEnervatorBlock), VanillaRecipeCategoryUid.BREWING);

    registry.addRecipes(Arrays.asList(
            new MachineProduceWrapper(BlockRegistry.sporesRecreatorBlock, new ItemStack(Blocks.BROWN_MUSHROOM)),
            new MachineProduceWrapper(BlockRegistry.sporesRecreatorBlock, new ItemStack(Blocks.RED_MUSHROOM)),
            new MachineProduceWrapper(BlockRegistry.sewageCompostSolidiferBlock, new ItemStack(ItemRegistry.fertilizer)),
            new MachineProduceWrapper(BlockRegistry.dyeMixerBlock, new ItemStack(Items.DYE, 1, OreDictionary.WILDCARD_VALUE)),
            new MachineProduceWrapper(BlockRegistry.lavaFabricatorBlock, new ItemStack(Items.LAVA_BUCKET)),
            new MachineProduceWrapper(BlockRegistry.waterResourcesCollectorBlock, new ItemStack(Items.FISH, 1, OreDictionary.WILDCARD_VALUE)),
            new MachineProduceWrapper(BlockRegistry.mobRelocatorBlock, FluidUtil.getFilledBucket(new FluidStack(FluidsRegistry.ESSENCE, 1000))),
            new MachineProduceWrapper(BlockRegistry.cropRecolectorBlock, FluidUtil.getFilledBucket(new FluidStack(FluidsRegistry.SLUDGE, 1000))),
            new MachineProduceWrapper(BlockRegistry.waterCondensatorBlock, FluidUtil.getFilledBucket(new FluidStack(FluidRegistry.WATER, 1000))),
            new MachineProduceWrapper(BlockRegistry.animalResourceHarvesterBlock, FluidUtil.getFilledBucket(new FluidStack(FluidsRegistry.MILK, 1000))),
            new MachineProduceWrapper(BlockRegistry.mobSlaughterFactoryBlock, FluidUtil.getFilledBucket(new FluidStack(FluidsRegistry.MEAT, 1000))),
            new MachineProduceWrapper(BlockRegistry.mobSlaughterFactoryBlock, FluidUtil.getFilledBucket(new FluidStack(FluidsRegistry.PINK_SLIME, 1000))),
            new MachineProduceWrapper(BlockRegistry.treeFluidExtractorBlock, FluidUtil.getFilledBucket(new FluidStack(FluidsRegistry.LATEX, 1000))),
            new MachineProduceWrapper(BlockRegistry.latexProcessingUnitBlock, new ItemStack(ItemRegistry.tinyDryRubber)),
            new MachineProduceWrapper(BlockRegistry.animalByproductRecolectorBlock, FluidUtil.getFilledBucket(new FluidStack(FluidsRegistry.SEWAGE, 1000))),
            new MachineProduceWrapper(BlockRegistry.lavaFabricatorBlock, FluidUtil.getFilledBucket(new FluidStack(FluidRegistry.LAVA, 1000))),
            new MachineProduceWrapper(BlockRegistry.proteinReactorBlock, FluidUtil.getFilledBucket(new FluidStack(FluidsRegistry.PROTEIN, 1000)))).stream().filter(machineProduceWrapper -> ((CustomOrientedBlock) machineProduceWrapper.getBlock()).isEnabled()).collect(Collectors.toList()),
            machineProduceCategory.getUid());

    if (BlockRegistry.materialStoneWorkFactoryBlock.isEnabled()) {
        NonNullList<ItemStack> wrappers = NonNullList.create();
        findAllStoneWorkOutputs(wrappers, new ItemStack(Blocks.COBBLESTONE), 0);
        wrappers.stream().filter(stack -> !stack.isEmpty()).forEach(stack -> registry.addRecipes(Collections.singletonList(new MachineProduceWrapper(BlockRegistry.materialStoneWorkFactoryBlock, stack)), machineProduceCategory.getUid()));
    }
    if (BlockRegistry.petrifiedFuelGeneratorBlock.isEnabled()) {
        List<PetrifiedBurnTimeWrapper> petrifiedBurnTimeWrappers = new ArrayList<>();
        registry.getIngredientRegistry().getFuels().stream().filter(stack -> !(stack.getItem() instanceof ItemBucket)).forEach(stack -> petrifiedBurnTimeWrappers.add(new PetrifiedBurnTimeWrapper(stack, TileEntityFurnace.getItemBurnTime(stack))));
        registry.addRecipes(petrifiedBurnTimeWrappers, petrifiedBurnTimeCategory.getUid());
        registry.addRecipeCatalyst(new ItemStack(BlockRegistry.petrifiedFuelGeneratorBlock), petrifiedBurnTimeCategory.getUid());
    }
    if (CustomConfiguration.enableBookEntriesInJEI) {
        for (BookCategory category : BookCategory.values()) {
            registry.addRecipes(category.getEntries().values().stream().map(ManualWrapper::new).collect(Collectors.toList()), manualCategory.getUid());
        }
        registry.addRecipeCatalyst(new ItemStack(ItemRegistry.bookManualItem), manualCategory.getUid());
    }
}

@Patch.Exception
@Hook("net.minecraft.item.ItemBucket#func_77661_b")
public static Hook.Result getItemUseAction(ItemBucket item, ItemStack stack) {
    return item == Items.LAVA_BUCKET ? new Hook.Result(EnumAction.DRINK) : Hook.Result.VOID;
}

@Patch.Exception
@Hook("net.minecraft.item.ItemBucket#func_77626_a")
public static Hook.Result getMaxItemUseDuration(ItemBucket item, ItemStack stack) {
    return item == Items.LAVA_BUCKET ? new Hook.Result(32) : Hook.Result.VOID;
}

public ItemBucket makeBucket(){
    return new ItemBucket(block);
}

public void registerBucket(ItemBucket bucket){
    bucket.setUnlocalizedName(unlocalizedName+"_bucket");
    GameRegistry.registerItem(bucket, unlocalizedName+"_bucket");
    FluidContainerRegistry.registerFluidContainer(this, new ItemStack(bucket), new ItemStack(Items.bucket));
}

@Override
    public boolean canPlaceBlock(World world, int x, int y, int z, ItemStack placing, IToggleController controller)
    {
        return FluidContainerRegistry.isFilledContainer(placing) || placing.getItem() instanceof ItemBucket;
//        return placing.getItem() instanceof ItemBucket && placing.getItem() != Items.bucket;
    }

protected void initSlots(TileEntityMothershipEngineAbstract tile) {
    this.addSlotToContainer(new SlotSpecific(tile, 0, 8, 7, ItemFluidContainer.class, ItemBucket.class));
}

public static void init() {
        diamondApple = new ItemDiamondApple();


        record_MusicSpring = new ItemPLRecord("record_musicspring", PLSounds.recordMusicSpring);
        salt = new ItemPLFood("salt", 0, 10F, true);
        gravityRay = new ItemGravityRay();

        //MultiMetaItem registry
        itemOre = new ItemOre();
        itemCrafting = new ItemCrafting();


        // special registry TODO: Better registry system

        packagedSalt = new ItemPL("packaged_salt") {
            /**
             * Called whenever this item is equipped and the right mouse button is pressed. Args: itemStack, world, entityPlayer
             */
            @Override
            public ActionResult<ItemStack> onItemRightClick(ItemStack itemStack, World world, EntityPlayer player, EnumHand hand) {
                if (PLConfig.instance.throwablePackagedSalt) {
                    if (!player.capabilities.isCreativeMode) {
                        --itemStack.stackSize;
                    }
                    world.playSound(null, player.posX, player.posY, player.posZ, SoundEvents.ENTITY_SNOWBALL_THROW, SoundCategory.NEUTRAL, 0.5F, 0.4F / (itemRand.nextFloat() * 0.4F + 0.8F));
                    if (!world.isRemote) {
                        world.spawnEntity(new EntityThrownItem(world, player, itemStack));
                    }
                }

                return new ActionResult<>(EnumActionResult.SUCCESS, itemStack);
            }

        };

        saltWaterBucket = new ItemBucket(Blocks.WATER);
        saltWaterBucket.setCreativeTab(ProductionLine.creativeTabPL)
                .setUnlocalizedName(MOD_ID + ".saltwater_bucket");

//        iridiumPickaxe = ToolPL.registerPickaxe(PLToolMaterial.iridium, "iridium_pickaxe");
//        iridiumAxe = ToolPL.registerAxe(PLToolMaterial.iridium, "iridium_axe");
//        iridiumSpade = ToolPL.registerSpade(PLToolMaterial.iridium, "iridium_spade");
//        iridiumSword = ToolPL.registerSword(PLToolMaterial.iridium, "iridium_sword");

        // TODO: Better registry system
        GameRegistry.<Item>register(saltWaterBucket, new ResourceLocation(MOD_ID, "saltwater_bucket"));
        GameRegistry.registerFuelHandler(new PLItems());
    }

@Override
public boolean isItemValid(ItemStack stack)
{
    // Grab the recipe archive object array.
    TileEntityFactoryProduct possibleMachine = TileEntityFactory.instance().getMachineInfo( machineName );

    // Prevent multiple queries.
    if (registeredMachine == null)
    {
        this.registeredMachine = possibleMachine;
    }

    if (this.registeredMachine != null)
    {
        // Check if this slot is for buckets (filled or unfilled).
        ContainerTemplate[] containerSlots = this.registeredMachine.getContainerTemplate();
        for (ContainerTemplate machineSlot : containerSlots)
        {
            if (machineSlot.getSlotType().name().toLowerCase().contains( "bucket" ) &&
                stack.getItem() instanceof ItemBucket)
            {
                return true;
            }
        }

        // Loop through all of the machines internal recipes and look for matches to item for any input slot.
        RecipeArchive[] recipeArchiveArray = this.registeredMachine.getRecipeArchive();
        for (RecipeArchive machineRecipe : recipeArchiveArray)
        {
            RecipeComponent[] inputIngredients = machineRecipe.getInputIngredientsArray();
            for (RecipeComponent recipeResult : inputIngredients)
            {
                if (! recipeResult.isLoaded())
                {
                    continue;
                }

                // Determine if this recipe result matches anything in ingredient list.
                if (recipeResult.getAssociatedItemStack().getItem().equals( stack.getItem() ))
                {
                    return true;
                }
            }
        }
    }

    // Ensure that we return false in the event something goes wrong before this.
    return false;
}

public ItemBucket makeBucket(){
    return new ItemBucket(block);
}

public void registerBucket(ItemBucket bucket){
    bucket.setUnlocalizedName(unlocalizedName+"_bucket");
    GameRegistry.registerItem(bucket, unlocalizedName+"_bucket");
    FluidContainerRegistry.registerFluidContainer(this, new ItemStack(bucket), new ItemStack(Items.bucket));
}

/**
 * Flip the sheathed item
 * @param stack
 */
private void onRenderSheathedItem(ItemStack stack){
    if (stack.getItem() instanceof ItemBucket || stack.getItem() instanceof ItemPotion || stack.getItem() instanceof IArrowContainer2) {
        GlStateManager.rotate(180F, 0.0F, 0.0F, 1.0F);
    }
}

/**
 * Register a fluid bucket with forge
 *  @param fluid      fluid for bucket to register
 * @param fluidBlock fluidBlock for bucket to register
 * @param bucket     bucket item to use
 * @param name       name for bucket
 * @return returns used itemBucket due register things
 */
public static ItemBucket registerFluidBucket(Fluid fluid, Block fluidBlock, ItemBucket bucket, String name) {
    GameRegistry.registerItem(bucket, name);
    FluidContainerRegistry.registerFluidContainer(fluid, new ItemStack(bucket), new ItemStack(Items.bucket));
    BucketHandler.INSTANCE.buckets.put(fluidBlock, bucket);
    return bucket;
}

/**public static void addMaterial(String itemname, String blockname, String orename, int blockhard, int blocklevel, Material blockmaterial, int orehard, int orelevel, Material orematerial, boolean oredropitem) {
    item = new ItemBasic(itemname,TMCreativeTabs.item);
    block = new BlockBasic(blockname, blockmaterial, TMCreativeTabs.block, blocklevel, blockhard);
    ore = new BlockBasic(orename, orematerial, TMCreativeTabs.block, orelevel, orehard);

    GameRegistry.registerItem(item, itemname);
    GameRegistry.registerBlock(block, blockname);
    GameRegistry.registerBlock(ore, orename);
    OreDictionary.registerOre(itemname, item);
    GameRegistry.addSmelting(ore, new ItemStack(item), 5);
    GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(block), true, new Object[]{"xxx", "xxx", "xxx", Character.valueOf('x'), itemname}));
    GameRegistry.addShapelessRecipe(new ItemStack(item, 9), new ItemStack(block));
}*/

public static ItemBucket registerBucket(ItemBucket bucket, String name, Fluid fluid, Block block) {
    GameRegistry.registerItem(bucket, name);
    FluidContainerRegistry.registerFluidContainer(new FluidStack(fluid, 1000), new ItemStack(bucket), new ItemStack(Items.bucket));
    BucketHandler.INSTANCE.buckets.put(block, bucket);
    return bucket;
}