int amountAllowed = fh.fill( stack.getFluidStack(), false ); stack.setStackSize( amountAllowed ); final int canFill = fh.fill( canPull.getFluidStack(), false ); if( canFill == 0 ) final int used = fh.fill( pulled.getFluidStack(), true ); player.inventory.setItemStack( fh.getContainer() ); this.updateHeld( player ); final FluidStack extract = fh.drain( Integer.MAX_VALUE, false ); if( extract == null || extract.amount < 1 ) final FluidStack storable = fh.drain( toStore, false ); final FluidStack drained = fh.drain( extract, true ); extract.amount = drained.amount; player.inventory.setItemStack( fh.getContainer() ); this.updateHeld( player );
@Override public boolean canPutStack(ItemStack stack) { IFluidHandlerItem fluidHandlerItem = FluidUtil.getFluidHandler(stack); return fluidHandlerItem != null && (!requireFilledContainer || fluidHandlerItem.getTankProperties()[0].getContents() != null); } }
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(); }
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; }
FluidStack drainStack = handler.drain(Math.min(tank.getSpace(), Fluid.BUCKET_VOLUME), true); int drained = drainStack == null ? 0 : drainStack.amount; IFluidTankProperties[] tankProperties = handler.getTankProperties(); inventory[1] = ItemHelper.cloneStack(override.getOutput()); } else { inventory[1] = handler.getContainer(); inventory[1] = handler.getContainer(); inventory[1] = handler.getContainer(); return false;
@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 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; }
/** * Checks if the given stack can store blood */ public static boolean canStoreBlood(@Nonnull ItemStack stack) { IFluidHandlerItem handler = FluidUtil.getFluidHandler(stack); return handler != null && handler.fill(new FluidStack(ModFluids.blood, 1000), false) > 0; }
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; } }
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(); }
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(); }
/** * 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; }
+ " and container fluid stack now = " + containerFluidStack.getFluid() + " " + containerFluidStack.amount); return ActionResult.newResult(EnumActionResult.SUCCESS, containerFluidHandler.getContainer());
public static int fill(@Nonnull ItemStack stack, int amount, boolean doFill) { IFluidHandlerItem handler = FluidUtil.getFluidHandler(stack); if (handler != null) { return handler.fill(new FluidStack(ModFluids.blood, amount), doFill); } return 0; }
FluidStack drainedFluid = fluidHandler.drain(Integer.MAX_VALUE, true); if (drainedFluid != null) { ItemStack drained = fluidHandler.getContainer(); recipes.add(new BottlerRecipeWrapper(stack, drainedFluid, drained, false)); IFluidHandlerItem fillingCapability = stack.copy().getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); if (fillingCapability != null) { int fill = fillingCapability.fill(new FluidStack(fluid, Integer.MAX_VALUE), true); if (fill > 0) { FluidStack filledFluid = new FluidStack(fluid, fill); ItemStack filled = fillingCapability.getContainer(); recipes.add(new BottlerRecipeWrapper(stack, filledFluid, filled, true));
@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; } }
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; } else if(drainLava != null && drainLava.getFluid() == FluidRegistry.LAVA && drainLava.amount == Fluid.BUCKET_VOLUME) { 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;
@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; }
return ActionResult.newResult(EnumActionResult.SUCCESS, containerFluidHandler.getContainer());