IItemHandler playerInventory = playerIn.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, EnumFacing.UP); FluidActionResult result = FluidUtil.tryEmptyContainerAndStow(heldItem, fluidHandler, playerInventory, Fluid.BUCKET_VOLUME, playerIn); if(result.isSuccess()) { playerIn.setHeldItem(hand, result.getResult()); return true;
/** * Drains a filled container and places the fluid. * * RETURN new item stack that has been drained after placing in world if it works null otherwise */ public static ItemStack dumpContainer(World world, BlockPos pos, ItemStack stackIn) { // BlockSourceImpl blocksourceimpl = new BlockSourceImpl(world, pos); ItemStack dispensedStack = stackIn.copy(); // dispensedStack.setCount(1); IFluidHandlerItem fluidHandler = FluidUtil.getFluidHandler(dispensedStack); if (fluidHandler == null) { ModCyclic.logger.log("CONTAINER ret null"); return ItemStack.EMPTY; } FluidStack fluidStack = fluidHandler.drain(Fluid.BUCKET_VOLUME, false); if (fluidStack != null && fluidStack.amount >= Fluid.BUCKET_VOLUME) { // FluidActionResult placeResult = FluidUtil.tryPlaceFluid(null, world, pos, dispensedStack, fluidStack); if (FluidUtil.tryPlaceFluid(null, world, pos, dispensedStack, fluidStack).isSuccess()) { //http://www.minecraftforge.net/forum/topic/56265-1112-fluidhandler-capability-on-buckets/ fluidHandler.drain(Fluid.BUCKET_VOLUME, true); ItemStack returnMe = fluidHandler.getContainer(); // stackIn.deserializeNBT(returnMe.serializeNBT()); ModCyclic.logger.log("CONTAINER returNMe" + returnMe); return returnMe; } } return fluidHandler.getContainer(); }
@Override public ItemStack willProduceItem(TileBloodInfuser tile) { ItemStack itemStack = tile.getInventory().getStackInSlot(tile.getConsumeSlot()); if (itemStack.isEmpty()) { return ItemStack.EMPTY; } if (FluidUtil.getFluidHandler(itemStack) instanceof FluidContainerItemWrapperWithSimulation) { return ItemStack.EMPTY; } ItemStack smallContainer = FluidUtil.tryFillContainer(itemStack, tile.getTank(), MB_PER_TICK, null, false).getResult(); if (!smallContainer.isEmpty()) { return smallContainer; } return FluidUtil.tryFillContainer(itemStack, tile.getTank(), Fluid.BUCKET_VOLUME, null, false).getResult(); }
IItemHandler itemHandler = new InvWrapper(this.origin); fluidActionResult = FluidUtil.tryEmptyContainerAndStow(singleCopy, fluidHandler, itemHandler, Fluid.BUCKET_VOLUME, player, doAdd); if (!fluidActionResult.isSuccess()) { fluidActionResult = FluidUtil.tryFillContainerAndStow(singleCopy, fluidHandler, itemHandler, Fluid.BUCKET_VOLUME, player, doAdd); if (!fluidActionResult.isSuccess()) { fluidActionResult = FluidUtil.tryFillContainer(singleCopy, fluidHandler, Fluid.BUCKET_VOLUME, player, doAdd); if (fluidActionResult.isSuccess()) { if (item.getCount() == 1) { return new TransferResult(fluidActionResult.result);
/** * Pickup or place fluid in the world * * @param targetPos * @return */ private boolean rightClickFluidAir(BlockPos targetPos) { FakePlayer player = fakePlayer.get(); ItemStack playerHeld = player.getHeldItemMainhand(); //item stack does not hve fluid handler //dispense stack so either pickup or place liquid if (UtilFluid.isEmptyOfFluid(playerHeld)) { FluidActionResult res = UtilFluid.fillContainer(world, targetPos, playerHeld, this.getCurrentFacing()); if (res != FluidActionResult.FAILURE) { player.setHeldItem(EnumHand.MAIN_HAND, res.getResult()); this.tryDumpFakePlayerInvo(true); // UtilItemStack.dropItemStackInWorld(world, getCurrentFacingPos(), res.getResult()); return true; } } else { ItemStack drainedStackOrNull = UtilFluid.dumpContainer(world, targetPos, playerHeld); if (!drainedStackOrNull.isItemEqual(playerHeld)) { player.setHeldItem(EnumHand.MAIN_HAND, drainedStackOrNull); this.tryDumpFakePlayerInvo(true); return true; } } return false; }
/** * Attempts to drain the item to an IFluidHandler. * * @param stack The stack to drain from. * @param handler The IFluidHandler to fill. * @param player The player using the item. * @param hand The hand the player is holding the item in. * @return If the interaction was successful. */ public static boolean drainItemToHandler(ItemStack stack, IFluidHandler handler, EntityPlayer player, EnumHand hand) { if (stack.isEmpty() || handler == null || player == null) { return false; } IItemHandler playerInv = new InvWrapper(player.inventory); FluidActionResult result = FluidUtil.tryEmptyContainerAndStow(stack, handler, playerInv, Integer.MAX_VALUE, player); if (result.isSuccess()) { player.setHeldItem(hand, result.getResult()); return true; } return false; }
if (filledResult.isSuccess()) { ItemHandlerHelper.giveItemToPlayer(player, filledResult.result);
@Override public void onTick(TileBloodInfuser tile, ItemStack itemStack, int slot, int tick) { ItemStack infuseStack = getInfuseStack(tile); if (!infuseStack.isEmpty()) { infuseStack = infuseStack.copy(); } IFluidHandler container = FluidUtil.getFluidHandler(infuseStack); FluidStack fluidStack = tile.getTank().getFluid().copy(); MutableInt duration = new MutableInt(MB_PER_TICK); Upgrades.sendEvent(tile, new UpgradeSensitiveEvent<MutableInt>(duration, TileBloodInfuser.UPGRADEEVENT_FILLBLOODPERTICK)); int minAmount = duration.getValue(); fluidStack.amount = Math.min(minAmount, fluidStack.amount); int filled = container.fill(fluidStack, true); if (filled > 0) { // Everything ok, filling the container bit by bit tile.getTank().drain(filled, true); tile.getInventory().setInventorySlotContents(tile.getConsumeSlot(), infuseStack); if (FluidHelpers.getFluid(container) != null && FluidHelpers.getAmount(FluidHelpers.getFluid(container)) == FluidHelpers.getCapacity(container)) { if (addToProduceSlot(tile, infuseStack)) { tile.getInventory().decrStackSize(tile.getConsumeSlot(), 1); } } } else { // We might be dealing with a bucket ItemStack result = FluidUtil.tryFillContainer(infuseStack, tile.getTank(), Integer.MAX_VALUE, null, true).getResult(); if (addToProduceSlot(tile, result)) { tile.getInventory().decrStackSize(tile.getConsumeSlot(), 1); } } }
/** * Attempts to fill the item from an IFluidHandler. * * @param stack The stack to fill. * @param handler The IFluidHandler to drain from. * @param player The player using the item. * @param hand The hand the player is holding the item in. * @return If the interaction was successful. */ public static boolean fillItemFromHandler(ItemStack stack, IFluidHandler handler, EntityPlayer player, EnumHand hand) { if (stack.isEmpty() || handler == null || player == null) { return false; } IItemHandler playerInv = new InvWrapper(player.inventory); FluidActionResult result = FluidUtil.tryFillContainerAndStow(stack, handler, playerInv, Integer.MAX_VALUE, player); if (result.isSuccess()) { player.setHeldItem(hand, result.getResult()); return true; } return false; }
if (filledResult.isSuccess()) { world.playSound(null, pos, SoundEvents.ITEM_BUCKET_FILL, SoundCategory.BLOCKS, 1.0F, 1.0F); final ItemStack filledBucket = filledResult.result;
public static boolean drainContainers(IFluidHandler fluidHandler, IInventory inv, int inputSlot) { ItemStack input = inv.getStackInSlot(inputSlot); if (input.isEmpty()) { return false; } FluidActionResult fluidActionSimulated = FluidUtil.tryEmptyContainer(input, fluidHandler, Fluid.BUCKET_VOLUME, null, false); if (!fluidActionSimulated.isSuccess()) { return false; } ItemStack drainedItemSimulated = fluidActionSimulated.getResult(); if (input.getCount() == 1 || drainedItemSimulated.isEmpty()) { FluidActionResult fluidActionResult = FluidUtil.tryEmptyContainer(input, fluidHandler, Fluid.BUCKET_VOLUME, null, true); if (fluidActionResult.isSuccess()) { ItemStack drainedItem = fluidActionResult.getResult(); if (!drainedItem.isEmpty()) { inv.setInventorySlotContents(inputSlot, drainedItem); } else { inv.decrStackSize(inputSlot, 1); } return true; } } return false; }
private static boolean bloodFluidHandler(TestInfo info) { info.world.setBlockState(info.pos, ModBlocks.blood_container.getDefaultState()); TileEntity t = info.world.getTileEntity(info.pos); IFluidHandler handler = t.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, EnumFacing.random(info.world.rand)); handler.fill(new FluidStack(ModFluids.blood, 10000000), true); int blood = BloodHelper.getBlood(handler); assert blood > 0 : "Could not fill blood container"; ItemStack bloodBottle1 = new ItemStack(ModItems.blood_bottle); ItemStack bloodBottle2 = new ItemStack(ModItems.blood_bottle); FluidActionResult result1 = FluidUtil.tryFillContainer(bloodBottle1, handler, Integer.MAX_VALUE, null, true); assert result1.isSuccess() : "Transaction 1 failed"; bloodBottle1 = result1.getResult(); FluidActionResult result2 = FluidUtil.tryFillContainer(bloodBottle2, handler, Integer.MAX_VALUE, null, true); assert result2.isSuccess() : "Transaction 2 failed"; bloodBottle2 = result2.getResult(); assert BloodHelper.getBlood(handler) < blood : "Failed to drain from container into bottles"; FluidActionResult result3 = FluidUtil.tryEmptyContainer(bloodBottle1, handler, Integer.MAX_VALUE, null, true); assert result3.isSuccess() : "Transaction 3 failed"; bloodBottle1 = result3.getResult(); FluidActionResult result4 = FluidUtil.tryEmptyContainer(bloodBottle2, handler, Integer.MAX_VALUE, null, true); assert result4.isSuccess() : "Transaction 4 failed"; bloodBottle2 = result4.getResult(); log("%d %d", BloodHelper.getBlood(handler), blood); assert BloodHelper.getBlood(handler) == blood : "Lost blood somewhere"; 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; }
@Override public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) { if (!worldIn.isRemote) { ItemStack stack = playerIn.getHeldItem(hand); if (!stack.isEmpty() && FluidLib.hasFluidItemCap(stack)) { TileBloodContainer bloodContainer = (TileBloodContainer) worldIn.getTileEntity(pos); IFluidHandler source = bloodContainer.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, null); if (playerIn.isSneaking()) { FluidActionResult result = FluidUtil.tryFillContainer(stack, source, Integer.MAX_VALUE, playerIn, true); if (result.isSuccess()) { playerIn.setHeldItem(hand, result.getResult()); } //fillContainerFromTank(worldIn, pos, playerIn, stack, bloodContainer); } else { FluidActionResult result = FluidUtil.tryEmptyContainer(stack, source, Integer.MAX_VALUE, playerIn, true); //drainContainerIntoTank(worldIn, pos, playerIn, stack, bloodContainer); if (result.isSuccess()) { playerIn.setHeldItem(hand, result.getResult()); } } return true; } } return true; }
@Nonnull private static ItemStack getStackFromLiquid(IBlockState state, IWailaDataAccessor accessor) { IFluidHandler fluidHandler = FluidUtil.getFluidHandler(accessor.getWorld(), accessor.getPosition(), accessor.getSide()); if (fluidHandler == null) return ItemStack.EMPTY; FluidStack stack = fluidHandler.drain(Fluid.BUCKET_VOLUME, false); if (stack == null) return ItemStack.EMPTY; ItemStack bucket = FluidUtil.getFilledBucket(stack); if (!bucket.isEmpty()) return bucket; FluidActionResult result = FluidUtil.tryFillContainer(new ItemStack(Items.BUCKET), fluidHandler, 1, null, false); return result.isSuccess() ? result.getResult() : ItemStack.EMPTY; }
public boolean fillContainerFromInternalTank(IItemHandlerModifiable importItems, IItemHandlerModifiable exportItems, int inputSlot, int outputSlot) { ItemStack emptyContainer = importItems.extractItem(inputSlot, 1, true); FluidActionResult result = FluidUtil.tryFillContainer(emptyContainer, exportFluids, Integer.MAX_VALUE, null, false); if(result.isSuccess()) { ItemStack remainingItem = result.getResult(); if(!remainingItem.isEmpty() && !exportItems.insertItem(outputSlot, remainingItem, true).isEmpty()) return false; FluidUtil.tryFillContainer(emptyContainer, exportFluids, Integer.MAX_VALUE, null, true); importItems.extractItem(inputSlot, 1, false); exportItems.insertItem(outputSlot, remainingItem, false); return true; } return false; }
ActionResult<ItemStack> doBucketFill(ItemStack stack, @Nonnull World world, @Nonnull EntityPlayer player, @Nonnull EnumHand hand) { if (getSpace(stack) < Fluid.BUCKET_VOLUME) { return ActionResult.newResult(EnumActionResult.PASS, stack); } RayTraceResult traceResult = RayTracer.retrace(player, true); if (traceResult == null || traceResult.sideHit == null || traceResult.typeOfHit != RayTraceResult.Type.BLOCK) { return ActionResult.newResult(EnumActionResult.PASS, stack); } BlockPos pos = traceResult.getBlockPos(); if (world.isBlockModifiable(player, pos)) { if (player.canPlayerEdit(pos, traceResult.sideHit, stack)) { FluidActionResult result = FluidUtil.tryPickUpFluid(stack, player, world, pos, traceResult.sideHit); if (result.isSuccess() && !player.capabilities.isCreativeMode) { player.addStat(StatList.getObjectUseStats(this)); return ActionResult.newResult(EnumActionResult.SUCCESS, result.getResult()); } } } return ActionResult.newResult(EnumActionResult.FAIL, stack); }
public boolean fillInternalTankFromFluidContainer(IItemHandlerModifiable importItems, IItemHandlerModifiable exportItems, int inputSlot, int outputSlot) { ItemStack inputContainerStack = importItems.extractItem(inputSlot, 1, true); FluidActionResult result = FluidUtil.tryEmptyContainer(inputContainerStack, importFluids, Integer.MAX_VALUE, null, false); if(result.isSuccess()) { ItemStack remainingItem = result.getResult(); if(ItemStack.areItemStacksEqual(inputContainerStack, remainingItem)) return false; //do not fill if item stacks match if(!remainingItem.isEmpty() && !exportItems.insertItem(outputSlot, remainingItem, true).isEmpty()) return false; //do not fill if can't put remaining item FluidUtil.tryEmptyContainer(inputContainerStack, importFluids, Integer.MAX_VALUE, null, true); importItems.extractItem(inputSlot, 1, false); exportItems.insertItem(outputSlot, remainingItem, false); return true; } return false; }
if(!player.isSneaking() && !tank.isFull() && itemFluidHandler != null) { // Fill the tank. FluidActionResult result = FluidUtil.tryEmptyContainer(itemStack, tank, Fluid.BUCKET_VOLUME, player, true); if (result.isSuccess() && !player.capabilities.isCreativeMode) { InventoryHelpers.tryReAddToStack(player, itemStack, result.getResult(), hand); if (result.isSuccess() && !player.capabilities.isCreativeMode) { InventoryHelpers.tryReAddToStack(player, itemStack, result.getResult(), hand);
ActionResult<ItemStack> doBucketEmpty(ItemStack stack, @Nonnull World world, @Nonnull EntityPlayer player, @Nonnull EnumHand hand) { if (getFluidAmount(stack) < Fluid.BUCKET_VOLUME) { return ActionResult.newResult(EnumActionResult.PASS, stack); } RayTraceResult traceResult = this.rayTrace(world, player, false); if (traceResult == null || traceResult.typeOfHit != RayTraceResult.Type.BLOCK) { return ActionResult.newResult(EnumActionResult.PASS, stack); } BlockPos pos = traceResult.getBlockPos(); if (world.isBlockModifiable(player, pos)) { BlockPos targetPos = pos.offset(traceResult.sideHit); if (player.canPlayerEdit(targetPos, traceResult.sideHit.getOpposite(), stack)) { FluidActionResult result = FluidUtil.tryPlaceFluid(player, world, targetPos, stack, new FluidStack(getFluid(stack), Fluid.BUCKET_VOLUME)); if (result.isSuccess() && !player.capabilities.isCreativeMode) { player.addStat(StatList.getObjectUseStats(this)); return ActionResult.newResult(EnumActionResult.SUCCESS, result.getResult()); } } } return ActionResult.newResult(EnumActionResult.FAIL, stack); }