protected boolean fill(EnumFacing side, @Nonnull IFluidHandler handler, int amount) { FluidStack fluid = tank.getUsableFluid(); // make sure we do not allow more than the fluid allows fluid.amount = Math.min(fluid.amount, amount); int filled = fluid.amount == 0 ? 0 : handler.fill(fluid, false); if(filled > 0) { setFlow(side, true); filled = handler.fill(fluid, true); tank.drainInternal(filled, true); return true; } setFlow(side, false); return false; }
protected void pour() { if(drained == null) { return; } IFluidHandler toFill = getFluidHandler(pos.down(), EnumFacing.UP); if(toFill != null) { FluidStack fillStack = drained.copy(); fillStack.amount = Math.min(drained.amount, LIQUID_TRANSFER); // can we fill? int filled = toFill.fill(fillStack, false); if(filled > 0) { // transfer it this.drained.amount -= filled; fillStack.amount = filled; toFill.fill(fillStack, true); } } else { // filling TE got lost. reset. all liquid buffered is lost. reset(); } }
@Override public IAEFluidStack injectItems( final IAEFluidStack input, final Actionable type, final IActionSource src ) { final int filled = this.handler.fill( input.getFluidStack(), type == Actionable.MODULATE ); if( filled == 0 ) { return input.copy(); } if( type == Actionable.MODULATE ) { this.onTick(); } if( filled == input.getStackSize() ) { return null; } final IAEFluidStack o = input.copy(); o.setStackSize( input.getStackSize() - filled ); return o; }
protected boolean tryInsertSigilFluid(IFluidHandler destination, boolean doTransfer) { if (destination == null) return false; return destination.fill(sigilFluid, doTransfer) > 0; }
public boolean canOutputFluid(IFluidHandler fluidHandler) { if (fluidOutput == null) return true; if (fluidHandler == null) return false; return fluidHandler.fill(fluidOutput, false) == fluidOutput.amount; }
public static boolean addFluidsToFluidHandler(IFluidHandler handler, boolean simulate, List<FluidStack> items) { boolean filledAll = true; for (FluidStack stack : items) { int filled = handler.fill(stack, !simulate); filledAll &= filled == stack.amount; if (!filledAll && simulate) return false; } return filledAll; }
@Override public IAEFluidStack injectItems( IAEFluidStack input, Actionable type, IActionSource src ) { FluidStack fluidStack = input.getFluidStack(); // Insert int wasFillled = this.fluidHandler.fill( fluidStack, type != Actionable.SIMULATE ); int remaining = fluidStack.amount - wasFillled; if( fluidStack.amount == remaining ) { // The stack was unmodified, target tank is full return input; } if( type == Actionable.MODULATE ) { try { this.proxyable.getProxy().getTick().alertDevice( this.proxyable.getProxy().getNode() ); } catch( GridAccessException ignore ) { // meh } } fluidStack.amount = remaining; return AEFluidStack.fromFluidStack( fluidStack ); }
protected void doTransfer() { // still got content left if(drained != null) { return; } IFluidHandler toDrain = getFluidHandler(pos.offset(direction), direction.getOpposite()); IFluidHandler toFill = getFluidHandler(pos.down(), EnumFacing.UP); if(toDrain != null && toFill != null) { // can we drain? FluidStack drained = toDrain.drain(TRANSACTION_AMOUNT, false); if(drained != null) { // can we fill? int filled = toFill.fill(drained, false); if(filled > 0) { // drain the liquid and transfer it, buffer the amount for delay this.drained = toDrain.drain(filled, true); this.isPouring = true; pour(); // sync to clients if(!getWorld().isRemote && getWorld() instanceof WorldServer) { TinkerNetwork.sendToClients((WorldServer) getWorld(), pos, new FaucetActivationPacket(pos, drained)); } return; } } } // draining unsuccessful reset(); }
@Override public int fill(FluidStack resource, boolean doFill) { if (!canFill(side)) return 0; return tank.fill(resource, doFill); }
@Override public boolean canSlotAccept(int slotIndex, ItemStack itemStack) { if (slotIndex == SLOT_RESOURCE) { IFluidHandler fluidHandler = FluidUtil.getFluidHandler(itemStack); if (fluidHandler != null) { return fluidHandler.fill(new FluidStack(FluidRegistry.WATER, Integer.MAX_VALUE), false) > 0; } } return false; }
public ItemStack getContainer(EnumContainerType type, Fluid fluid) { ItemStack container = new ItemStack(containers.get(type)); IFluidHandler fluidHandler = FluidUtil.getFluidHandler(container); if (fluidHandler != null) { fluidHandler.fill(new FluidStack(fluid, Integer.MAX_VALUE), true); return container; } else { return ItemStack.EMPTY; } }
public static void tryFillTank(TileEntity tile, Fluid fluid, EnumFacing side, int quantity) { if (tile.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, side)) { IFluidHandler handler = tile.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, side); handler.fill(new FluidStack(fluid, quantity), true); } } }
/** * Fill a given Blood Extractor with a given amount of blood. * @param itemStack The ItemStack that is a Blood Extractor to fill. * @param amount The amount to fill. * @param doFill If the container really has to be filled, otherwise just simulated. * @return The amount of blood that was filled with. */ public int fillBloodExtractor(ItemStack itemStack, int amount, boolean doFill) { IFluidHandler fluidHandler = FluidUtil.getFluidHandler(itemStack); return fluidHandler.fill(new FluidStack(Blood.getInstance(), amount), doFill); }
int wasInserted = fh.fill( out.getFluidStack(), true );
public void saveFluid(@Nullable FluidStack fluid, final ItemStack stack) { NBTTagCompound nbt = stack.getTagCompound(); if (nbt == null) { stack.setTagCompound(nbt = new NBTTagCompound()); } if (fluid == null) { nbt.removeTag(FLUID_NBT_KEY); } else { IFluidHandler handler = stack.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); handler.fill(fluid, true); } }
public static ItemStack getPatternForFluid(Fluid fluid) { ItemStack itemStack = new ItemStack(ItemEnum.FLUIDPATTERN.getItem(), 1); IFluidHandler fluidHandler = FluidUtil.getFluidHandler(itemStack); if (fluidHandler == null) { return itemStack; } fluidHandler.fill(new FluidStack(fluid, Fluid.BUCKET_VOLUME), true); return itemStack; }
@Override public EnumActionResult onItemUseFirst(EntityPlayer player, World world, BlockPos pos, EnumFacing side, float hitX, float hitY, float hitZ, EnumHand hand) { ItemStack stack = player.getHeldItem(hand); IFluidHandler handler = TileHelpers.getCapability(world, pos, side, CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY); if(handler != null && !world.isRemote) { handler.fill(new FluidStack(FluidRegistry.WATER, Fluid.BUCKET_VOLUME), true); return EnumActionResult.SUCCESS; } return super.onItemUseFirst(player, world, pos, side, hitX, hitY, hitZ, hand); }
public static int insertFluidIntoAdjacentFluidHandler(World world, BlockPos pos, EnumFacing side, FluidStack fluid, boolean doFill) { TileEntity handler = BlockHelper.getAdjacentTileEntity(world, pos, side); if (handler != null && handler.hasCapability(FLUID_HANDLER, side.getOpposite())) { IFluidHandler cap = handler.getCapability(FLUID_HANDLER, side.getOpposite()); return cap != null ? cap.fill(fluid, doFill) : 0; } return 0; }
@SuppressWarnings("ConstantConditions") private boolean attemptToFill(World world, EntityPlayer player, ItemStack stack) { RayTraceResult rayTraceResult = this.rayTrace(world, player, true); if (rayTraceResult != null && rayTraceResult.typeOfHit == RayTraceResult.Type.BLOCK) { IBlockState state = world.getBlockState(rayTraceResult.getBlockPos()); if (state.getMaterial() == Material.WATER) { return getCapability(stack).fill(new FluidStack(FluidRegistry.WATER, 128), true) > 0; } } return false; }