private ItemStack drain(Fluid fluid, ItemStack stack) { IFluidHandlerItem handler = stack.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); handler.drain(new FluidStack(fluid, Fluid.BUCKET_VOLUME), true); return handler.getContainer(); }
@Override public ItemStack getResult(ItemStack cast, Fluid fluid) { ItemStack output = new ItemStack(bucket); IFluidHandlerItem fluidHandler = FluidUtil.getFluidHandler(output); assert fluidHandler != null; fluidHandler.fill(getFluid(cast, fluid), true); return fluidHandler.getContainer(); }
public static ItemStack drainOneBucket(ItemStack d) { IFluidHandlerItem fluidHandler = FluidUtil.getFluidHandler(d); if (fluidHandler == null) { return d; } //its empty, ok no problem fluidHandler.drain(Fluid.BUCKET_VOLUME, true); return fluidHandler.getContainer(); }
world.updateComparatorOutputLevel(pos, world.getBlockState(pos).getBlock()); fluidHandler.drain(new FluidStack(FluidRegistry.WATER, Fluid.BUCKET_VOLUME), true); item.setItem(fluidHandler.getContainer()); return true; } else if(drainLava != null && drainLava.getFluid() == FluidRegistry.LAVA && drainLava.amount == Fluid.BUCKET_VOLUME) { world.updateComparatorOutputLevel(pos, world.getBlockState(pos).getBlock()); fluidHandler.drain(new FluidStack(FluidRegistry.LAVA, Fluid.BUCKET_VOLUME), true); item.setItem(fluidHandler.getContainer()); return true;
public static Pair<ItemStack, FluidStack> getFluid(ItemStack stack, boolean simulate) { // We won't have the capability on stacks with size bigger than 1. if (stack.getCount() > 1) { stack = ItemHandlerHelper.copyStackWithSize(stack, 1); } if (stack.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null)) { IFluidHandlerItem fluidHandler = stack.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); FluidStack result = fluidHandler.drain(Fluid.BUCKET_VOLUME, !simulate); return Pair.of(fluidHandler.getContainer(), result); } return Pair.of(null, null); }
player.inventory.setItemStack( fh.getContainer() ); this.updateHeld( player ); player.inventory.setItemStack( fh.getContainer() ); this.updateHeld( player );
@Nullable public static ItemStack getContainer(FluidStack fluidStack) { ItemStack[] containers = { new ItemStack(Items.GLASS_BOTTLE), new ItemStack(Items.BUCKET) }; for (ItemStack container : containers) { IFluidHandlerItem fluidHandler = FluidUtil.getFluidHandler(container); if (fluidHandler != null && fluidHandler.fill(fluidStack, true) > 0) { return fluidHandler.getContainer(); } } return null; } }
@Nullable public static BottlerRecipe createEmptyingRecipe(ItemStack filled) { ItemStack empty = filled.copy(); empty.setCount(1); IFluidHandlerItem fluidHandler = FluidUtil.getFluidHandler(empty); if (fluidHandler == null) { return null; } FluidStack drained = fluidHandler.drain(Integer.MAX_VALUE, true); if (drained != null && drained.amount > 0) { return new BottlerRecipe(fluidHandler.getContainer(), drained, filled, false); } return null; }
protected ItemStack getFluidBucket(FluidStack fluidStack) { ItemStack itemStack = new ItemStack(Items.BUCKET); IFluidHandlerItem fluidHandler = itemStack.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); fluidHandler.fill(new FluidStack(fluidStack, Fluid.BUCKET_VOLUME), true); return fluidHandler.getContainer(); }
/** * Tries to fill a container item in a player inventory. * @param toDrain The item handler to drain from. * @param toFill The container to try to fill. * @param tickFluid The fluid to fill with. * @param player The player that is the owner of toFill. * @return The filled container */ public static ItemStack tryFillContainerForPlayer(IFluidHandlerItem toDrain, ItemStack toFill, FluidStack tickFluid, EntityPlayer player) { int maxFill = MB_FILL_PERTICK; if (toFill.getItem() == Items.BUCKET) { maxFill = Fluid.BUCKET_VOLUME; } if(!toFill.isEmpty() && toFill != toDrain.getContainer() && FluidUtil.getFluidHandler(toFill) != null && player.getItemInUseCount() == 0 && FluidUtil.tryFillContainer(toFill, toDrain, Math.min(maxFill, tickFluid.amount), player, false).isSuccess()) { return FluidUtil.tryFillContainer(toFill, toDrain, Math.min(maxFill, tickFluid.amount), player, true).getResult(); } return ItemStack.EMPTY; }
@Nullable public static BottlerRecipe createFillingRecipe(Fluid res, ItemStack empty) { ItemStack filled = empty.copy(); filled.setCount(1); IFluidHandlerItem fluidHandler = FluidUtil.getFluidHandler(filled); if (fluidHandler == null) { return null; } int fillAmount = fluidHandler.fill(new FluidStack(res, Integer.MAX_VALUE), true); if (fillAmount > 0) { return new BottlerRecipe(empty, new FluidStack(res, fillAmount), fluidHandler.getContainer(), true); } return null; }
@SideOnly(Side.CLIENT) @Override public void getSubItems(CreativeTabs tab, NonNullList<ItemStack> subItems) { if (this.isInCreativeTab(tab)) { // empty subItems.add(new ItemStack(this)); // filled for (Fluid fluid : FluidRegistry.getRegisteredFluids().values()) { ItemStack itemStack = new ItemStack(this); IFluidHandlerItem fluidHandler = new FluidHandlerItemForestry(itemStack, type); if (fluidHandler.fill(new FluidStack(fluid, Fluid.BUCKET_VOLUME), true) == Fluid.BUCKET_VOLUME) { ItemStack filled = fluidHandler.getContainer(); subItems.add(filled); } } } }
/** * Fill all the Blood Extractors on a player's hotbar for a given fluid amount. * It will fill Blood Extractors until the predefined blood amount is depleted. * (It fills on at a time). * @param player The player to the the Blood Extractors for. * @param minimumMB The minimum amount to fill. (inclusive) * @param maximumMB The maximum amount to fill. (exclusive) */ public void fillForAllBloodExtractors(EntityPlayer player, int minimumMB, int maximumMB) { int toFill = minimumMB + itemRand.nextInt(Math.max(1, maximumMB - minimumMB)); PlayerInventoryIterator it = new PlayerInventoryIterator(player); while(it.hasNext() && toFill > 0) { ItemStack itemStack = it.next(); if(!itemStack.isEmpty() && itemStack.getItem() == BloodExtractor.getInstance()) { IFluidHandlerItem fluidHandler = FluidUtil.getFluidHandler(itemStack); toFill -= fluidHandler.fill(new FluidStack(Blood.getInstance(), toFill), true); it.replace(fluidHandler.getContainer()); } } }
@Override public void getSubItems(@Nullable final CreativeTabs tab, final NonNullList<ItemStack> subItems) { if (!this.isInCreativeTab(tab)) return; subItems.add(empty); for (final Fluid fluid : FluidRegistry.getRegisteredFluids().values()) { // Add all fluids that the bucket can be filled with final FluidStack fs = new FluidStack(fluid, getCapacity()); final ItemStack stack = new ItemStack(this); if (!stack.hasTagCompound()) stack.setTagCompound(new NBTTagCompound()); final IFluidHandlerItem fluidHandler = stack.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); if (fluidHandler != null && fluidHandler.fill(fs, true) == fs.amount) { final ItemStack filled = fluidHandler.getContainer(); subItems.add(filled); } } }
private boolean fillHandler() { IFluidHandlerItem handler = inventory[1].getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); int filled = tank.getFluid() == null ? 0 : handler.fill(new FluidStack(tank.getFluid(), Math.min(tank.getFluidAmount(), Fluid.BUCKET_VOLUME)), true); IFluidTankProperties[] tankProperties = handler.getTankProperties(); if (tankProperties == null || tankProperties.length < 1) { return true; } if (filled > 0) { tank.drain(filled, true); inventory[1] = handler.getContainer(); return tankProperties[0].getContents() != null && tankProperties[0].getContents().amount >= tankProperties[0].getCapacity(); } return true; }
@Override protected void autofill(int itemSlot, IFluidHandlerItem source, World world, Entity entity) { if(entity instanceof EntityPlayer && !world.isRemote) { EntityPlayer player = (EntityPlayer) entity; FluidStack tickFluid; PlayerExtendedInventoryIterator it = new PlayerExtendedInventoryIterator(player); do { tickFluid = FluidHelpers.getFluid(source); ItemStack toFill = it.next(); if (tickFluid != null && !toFill.isEmpty() && toFill.getCount() == 1) { ItemStack filled = ItemHelpers.tryFillContainerForPlayer(source, toFill, tickFluid, player); if (!filled.isEmpty()) { it.replace(filled); player.inventory.setInventorySlotContents(itemSlot, source.getContainer()); } } } while(tickFluid != null && tickFluid.amount > 0 && it.hasNext()); } }
@Override public NonNullList<ItemStack> getRemainingItems(InventoryCrafting inv) { NonNullList<ItemStack> ret = NonNullList.withSize(inv.getSizeInventory(), ItemStack.EMPTY); for (int i = 0; i < ret.size(); i++) { ItemStack stack = inv.getStackInSlot(i); IFluidHandlerItem handler = stack.getCount() > 1 ? FluidUtil.getFluidHandler(ItemHelper.cloneStack(stack, 1)) : FluidUtil.getFluidHandler(stack); if (handler == null) { ret.set(i, ForgeHooks.getContainerItem(stack)); } else { handler.drain(Fluid.BUCKET_VOLUME, true); ret.set(i, handler.getContainer().copy()); } } return ret; }
public ItemStack fillTankWithBucket(ItemStack bucket) { if (tank.getFluidAmount() <= tank.getCapacity() - Fluid.BUCKET_VOLUME) if (FluidUtil.getFluidHandler(bucket) != null && FluidUtil.getFluidContained(bucket) != null && FluidUtil.getFluidContained(bucket).getFluid() == FluidRegistry.LAVA) if (bucket.getCount() == 1) { tank.fill(new FluidStack(FluidRegistry.LAVA, Fluid.BUCKET_VOLUME), true); IFluidHandlerItem cap = bucket.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); cap.drain(new FluidStack(FluidUtil.getFluidContained(bucket), Fluid.BUCKET_VOLUME), true); return FluidUtil.getFluidHandler(bucket).getContainer().copy(); } return bucket; }
@Override public NonNullList<ItemStack> getRemainingItems(InventoryCrafting inv) { NonNullList<ItemStack> ret = NonNullList.withSize(inv.getSizeInventory(), ItemStack.EMPTY); for (int i = 0; i < ret.size(); i++) { ItemStack stack = inv.getStackInSlot(i); IFluidHandlerItem handler = stack.getCount() > 1 ? FluidUtil.getFluidHandler(ItemHelper.cloneStack(stack, 1)) : FluidUtil.getFluidHandler(stack); if (handler == null) { ret.set(i, ForgeHooks.getContainerItem(stack)); } else { handler.drain(Fluid.BUCKET_VOLUME, true); ret.set(i, handler.getContainer().copy()); } } return ret; }
@Override public NonNullList<ItemStack> getRemainingItems(InventoryCrafting inv) { NonNullList<ItemStack> remains = ForgeHooks.defaultRecipeGetRemainingItems(inv); for (int i = 0; i < height * width; i++) { ItemStack stack = inv.getStackInSlot(i); NonNullList<Ingredient> matchedIngredients = this.input; if (matchedIngredients.get(i) instanceof IngredientFluidStack) { if (!stack.isEmpty()) { ItemStack copy = stack.copy(); copy.setCount(1); remains.set(i, copy); } IFluidHandlerItem handler = FluidUtil.getFluidHandler(remains.get(i)); if (handler != null) { FluidStack fluid = ((IngredientFluidStack) matchedIngredients.get(i)).getFluid(); handler.drain(fluid.amount, true); remains.set(i, handler.getContainer()); } } } return remains; } }