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(); }
IFluidHandlerItem fluidHandler = stack.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); FluidStack drainWater = fluidHandler.drain(new FluidStack(FluidRegistry.WATER, Fluid.BUCKET_VOLUME), false); FluidStack drainLava = fluidHandler.drain(new FluidStack(FluidRegistry.LAVA, Fluid.BUCKET_VOLUME), false); fluidHandler.drain(new FluidStack(FluidRegistry.WATER, Fluid.BUCKET_VOLUME), true); item.setItem(fluidHandler.getContainer()); return true; setLava(true); 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 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(); }
@Override public boolean hitEntity(ItemStack itemStack, EntityLivingBase attacked, EntityLivingBase attacker) { if(attacker instanceof EntityPlayer && isUsable(itemStack, (EntityPlayer) attacker)) { FluidUtil.getFluidHandler(itemStack).drain(hitUsage, true); } return true; }
/** * Tries to drain the given amount out of the stack. * * @param doDrain actually drain * @param exact If only the exact amount should be drained or if less is ok too * @return Drained amount */ public static int drain(@Nonnull ItemStack stack, int amount, boolean doDrain, boolean exact) { if (exact && doDrain) { if (drain(stack, amount, false, false) != amount) return 0; } IFluidHandlerItem handler = FluidUtil.getFluidHandler(stack); if (handler != null) { FluidStack fluidStack = handler.drain(amount, doDrain); return fluidStack == null ? 0 : fluidStack.amount; } return 0; }
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); }
@Override public ItemStack onItemUseFinish(ItemStack itemStack, World world, EntityLivingBase entity) { FluidUtil.getFluidHandler(itemStack).drain(RejuvenatedFleshConfig.biteUsage, true); if(entity instanceof EntityPlayer) { ((EntityPlayer) entity).getFoodStats().addStats(3, 0.5F); } world.playSound(null, entity.posX, entity.posY, entity.posZ, SoundEvents.ENTITY_PLAYER_BURP, SoundCategory.PLAYERS, 0.5F, world.rand.nextFloat() * 0.1F + 0.9F); return itemStack; }
@Override public void handleClientAction(int id, PacketBuffer buffer) { if(id == 1) { ItemStack itemStack = gui.entityPlayer.inventory.getItemStack().copy(); if(!itemStack.isEmpty()) { itemStack.setCount(1); IFluidHandlerItem fluidHandler = itemStack.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); if(fluidHandler != null) { FluidStack resultFluid = fluidHandler.drain(Integer.MAX_VALUE, false); fluidStackUpdater.accept(resultFluid); } } else { fluidStackUpdater.accept(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; }
@SideOnly(Side.CLIENT) protected int getColorForItemStack(ItemStack stack, int tintIndex) { IFluidHandlerItem fluidContainerItem = ItemHandlerHelper.copyStackWithSize(stack, 1) .getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); if(tintIndex == 0 && fluidContainerItem != null) { FluidStack fluidStack = fluidContainerItem.drain(Integer.MAX_VALUE, false); return fluidStack == null ? 0x666666 : RenderUtil.getFluidColor(fluidStack); } return 0xFFFFFF; }
@Override public boolean apply(@Nullable ItemStack input) { if (input == null || input.isEmpty()) { return false; } IFluidHandlerItem handler = input.getCount() > 1 ? FluidUtil.getFluidHandler(ItemHelper.cloneStack(input, 1)) : FluidUtil.getFluidHandler(input); if (handler == null) { return false; } return fluid.isFluidStackIdentical(handler.drain(Fluid.BUCKET_VOLUME, false)); }
public static FluidStack getFluidTypeFromItem(@Nonnull ItemStack stack) { if (stack.isEmpty()) { return null; } ItemStack copy = stack.copy(); copy.setCount(1); IFluidHandlerItem handler = getFluidHandlerCapability(copy); if (handler != null) { return handler.drain(Fluid.BUCKET_VOLUME, false); } if (Block.getBlockFromItem(copy.getItem()) instanceof IFluidBlock) { Fluid fluid = ((IFluidBlock) Block.getBlockFromItem(copy.getItem())).getFluid(); if (fluid != null) { return new FluidStack(fluid, 1000); } } return null; }
private boolean canStartHandler() { if (!FluidHelper.isFluidHandler(inventory[1])) { hasFluidHandler = false; return false; } if (energyStorage.getEnergyStored() <= 0) { return false; } if (!inventory[2].isEmpty()) { ContainerOverride override = TransposerManager.getContainerOverride(inventory[1]); if (override == null || !inventory[2].isItemEqual(override.getOutput())) { return false; } } IFluidHandlerItem handler = inventory[1].getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); if (handler == null) { return false; } if (!extractMode) { return tank.getFluid() != null && tank.getFluidAmount() > 0 && handler.fill(new FluidStack(tank.getFluid(), Math.min(tank.getFluidAmount(), Fluid.BUCKET_VOLUME)), false) > 0; } else { return tank.fill(handler.drain(Math.min(tank.getSpace(), Fluid.BUCKET_VOLUME), false), false) > 0; } }
@Override @SideOnly(Side.CLIENT) public String getItemStackDisplayName(ItemStack stack) { if (stack.getItemDamage() >= metaItemOffset) { T item = getItem(stack); if(item == null) { return "unnamed"; } IFluidHandlerItem fluidHandlerItem = ItemHandlerHelper.copyStackWithSize(stack, 1) .getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); if(fluidHandlerItem != null) { FluidStack fluidInside = fluidHandlerItem.drain(Integer.MAX_VALUE, false); String name = fluidInside == null ? "metaitem.fluid_cell.empty" : fluidInside.getUnlocalizedName(); return I18n.format("metaitem." + item.unlocalizedName + ".name", I18n.format(name)); } return I18n.format("metaitem." + item.unlocalizedName + ".name"); } return super.getItemStackDisplayName(stack); }
@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 void update() { super.update(); if(!getWorld().isRemote && getTimer() % 5 == 0) { ItemStack itemStack = containerInventory.getStackInSlot(0); Capability<IFluidHandlerItem> capability = CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY; if(!itemStack.isEmpty() && itemStack.hasCapability(capability, null)) { //if we can't drain anything, try filling container. Otherwise, drain it into the quantum chest tank if(itemStack.getCapability(capability, null).drain(Integer.MAX_VALUE, false) == null) { fillContainerFromInternalTank(containerInventory, containerInventory, 0, 1); pushFluidsIntoNearbyHandlers(getFrontFacing()); } else { fillInternalTankFromFluidContainer(containerInventory, containerInventory, 0, 1); pullFluidsFromNearbyHandlers(getFrontFacing()); } } } }
@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; } }