@Override public IAEFluidStack extractItems( final IAEFluidStack request, final Actionable type, final IActionSource src ) { final FluidStack removed = this.handler.drain( request.getFluidStack(), type == Actionable.MODULATE ); if( removed == null || removed.amount == 0 ) { return null; } if( type == Actionable.MODULATE ) { this.onTick(); } final IAEFluidStack o = request.copy(); o.setStackSize( removed.amount ); return o; }
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(); }
private boolean isValidWaterContainer(ItemStack stack) { if(stack.isEmpty() || stack.getCount() != 1) return false; if(stack.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null)) { IFluidHandler handler = stack.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); FluidStack simulate = handler.drain(new FluidStack(FluidRegistry.WATER, Fluid.BUCKET_VOLUME), false); if(simulate != null && simulate.getFluid() == FluidRegistry.WATER && simulate.amount == Fluid.BUCKET_VOLUME) return true; } return false; }
protected boolean tryRemoveFluid(IFluidHandler source, int amount, boolean doTransfer) { if (source == null) return false; return source.drain(amount, doTransfer) != null; }
@Override public IAEFluidStack extractItems( IAEFluidStack request, Actionable mode, IActionSource src ) { FluidStack requestedFluidStack = request.getFluidStack(); final boolean doDrain = ( mode == Actionable.MODULATE ); // Drain the fluid from the tank FluidStack gathered = this.fluidHandler.drain( requestedFluidStack, doDrain ); if( gathered == null ) { // If nothing was pulled from the tank, return null return null; } if( mode == Actionable.MODULATE ) { try { this.proxyable.getProxy().getTick().alertDevice( this.proxyable.getProxy().getNode() ); } catch( GridAccessException ignore ) { // meh } } return AEFluidStack.fromFluidStack( gathered ); }
@Nullable @Override public FluidStack drain(FluidStack resource, boolean doDrain) { return internalFluidHandler.drain(resource, doDrain); }
@Nullable @Override public FluidStack drain(int maxDrain, boolean doDrain) { return internalFluidHandler.drain(maxDrain, doDrain); }
@Nullable @Override public FluidStack drain(int maxDrain, boolean doDrain) { return delegate.drain(maxDrain, doDrain); } }
@Override @Nullable public FluidStack drain(FluidStack resource) { return fluidHandler.drain(resource, true); }
private void safelyFillAndDrain(IFluidHandler toFill, IFluidHandler toDrain) { FluidStack firstDrain = toDrain.drain(transferAmount, false); if (firstDrain != null) { int testFill = toFill.fill(firstDrain, false); if (testFill > 0) { FluidStack secondDrain = toDrain.drain(testFill, false); if (secondDrain != null) { toDrain.drain(toFill.fill(firstDrain, true), true); } } } }
private TickRateModulation pickupFluid() { if( !this.getProxy().isActive() ) { return TickRateModulation.SLEEP; } final TileEntity te = this.getTile(); final World w = te.getWorld(); final BlockPos pos = te.getPos().offset( this.getSide().getFacing() ); final IBlockState state = w.getBlockState( pos ); final Block block = state.getBlock(); if( block instanceof IFluidBlock || block instanceof BlockLiquid ) { final IFluidHandler fh = FluidUtil.getFluidHandler( w, pos, null ); final IAEFluidStack blockFluid = AEFluidStack.fromFluidStack( fh.drain( Integer.MAX_VALUE, false ) ); if( blockFluid != null ) { if( this.storeFluid( blockFluid, false ) ) { this.storeFluid( AEFluidStack.fromFluidStack( fh.drain( Integer.MAX_VALUE, true ) ), true ); AppEng.proxy.sendToAllNearExcept( null, pos.getX(), pos.getY(), pos.getZ(), 64, w, new PacketTransitionEffect( pos.getX(), pos.getY(), pos.getZ(), this.getSide(), true ) ); return TickRateModulation.URGENT; } return TickRateModulation.IDLE; } } // nothing to do here :) return TickRateModulation.SLEEP; }
@Nullable @Override public FluidStack extract(@Nonnull FluidStack stack, int size, int flags, Action action) { IFluidHandler handler = handlerSupplier.get(); if (handler == null) { return null; } return handler.drain(StackUtils.copy(stack, size), action == Action.PERFORM); }
@Override @SideOnly(Side.CLIENT) public void addInformation(ItemStack stack, @Nullable World worldIn, List<String> tooltip, ITooltipFlag flagIn) { FluidStack result = stack.getCapability(FLUID_HANDLER_CAPABILITY, null).drain(1000, false); int amount = result == null ? 0 : result.amount; tooltip.add("Amount: " + amount); }
@Override public String getUnlocalizedName(ItemStack stack) { FluidStack result = stack.getCapability(FLUID_HANDLER_CAPABILITY, null).drain(1000, false); return super.getUnlocalizedName(stack) + (result == null ? "_empty" : "_full"); }
@Override public FluidStack drain(FluidStack resource, boolean doDrain) { if (resource == null || !canDrain(resource.getFluid())) { return null; } return tank.drain(resource.amount, doDrain); }
@Nullable protected FluidStack getContained(ItemStack itemStack) { if (itemStack.getCount() != 1) { itemStack = itemStack.copy(); itemStack.setCount(1); } IFluidHandler fluidHandler = new FluidHandlerItemForestry(itemStack, type); return fluidHandler.drain(Integer.MAX_VALUE, false); }
public static ItemStack getEmptyContainer(ItemStack container) { ItemStack empty = container.copy(); empty.setCount(1); IFluidHandler fluidHandler = FluidUtil.getFluidHandler(empty); if (fluidHandler == null) { return ItemStack.EMPTY; } if (fluidHandler.drain(Integer.MAX_VALUE, true) != null) { return empty; } return ItemStack.EMPTY; }
@Nullable protected FluidStack getContained(ItemStack itemStack) { if (itemStack.getCount() != 1) { itemStack = itemStack.copy(); itemStack.setCount(1); } IFluidHandler fluidHandler = new FluidHandlerItemBinnie(itemStack, container); return fluidHandler.drain(Integer.MAX_VALUE, false); }
public static ItemStack getEmptyContainer(ItemStack container) { ItemStack empty = container.copy(); empty.setCount(1); IFluidHandler fluidHandler = FluidUtil.getFluidHandler(empty); if (fluidHandler == null) { return null; } if (fluidHandler.drain(Integer.MAX_VALUE, true) != null) { return empty; } return null; }