@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 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; }
@Override public IFluidTankProperties[] getTankProperties() { if(hasParent()) { IFluidHandler iFluidHandler = parent.get(); assert iFluidHandler != null; IFluidTankProperties[] iFluidTankPropertiesArray = iFluidHandler.getTankProperties(); if(iFluidTankPropertiesArray.length > 0) { IFluidTankProperties fluidTankProperties = iFluidHandler.getTankProperties()[0]; return new IFluidTankProperties[]{new FluidTankProperties(fluidTankProperties.getContents(), fluidTankProperties.getCapacity(), true, false)}; } } return EmptyFluidHandler.EMPTY_TANK_PROPERTIES_ARRAY; }
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(); }
public static void drainContainerIntoHandler(ItemStack from, IFluidHandler into) { if (isFluidContainer(from)) { IFluidHandler fromCapability = FluidUtil.getFluidHandler(from); if (fromCapability != null) { for (IFluidTankProperties fromTank : fromCapability.getTankProperties()) fromCapability.drain(into.fill(fromTank.getContents(), true), 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 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 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(); } }
public List<IAEFluidStack> update() final IFluidTankProperties[] tankProperties = this.fluidHandler.getTankProperties(); final int slots = tankProperties.length;
protected boolean tryRemoveFluid(IFluidHandler source, int amount, boolean doTransfer) { if (source == null) return false; return source.drain(amount, doTransfer) != null; }
private int createHandlerHash( TileEntity target ) { if( target == null ) { return 0; } final EnumFacing targetSide = this.getSide().getFacing().getOpposite(); if( target.hasCapability( Capabilities.STORAGE_MONITORABLE_ACCESSOR, targetSide ) ) { return Objects.hash( target, target.getCapability( Capabilities.STORAGE_MONITORABLE_ACCESSOR, targetSide ) ); } final IFluidHandler fluidHandler = target.getCapability( CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, targetSide ); if( fluidHandler != null ) { return Objects.hash( target, fluidHandler, fluidHandler.getTankProperties().length ); } return 0; }
@Override public FluidStack drain(int maxDrain, boolean doDrain) { for(IFluidHandler tank : myTanks) { FluidStack ret = tank.drain(maxDrain, doDrain); if(ret != null && ret.amount != 0) { return ret; } } return null; } };
@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; }
@Override public List<String> getWailaBody(ItemStack itemStack, List<String> currenttip, IWailaDataAccessor accessor, IWailaConfigHandler config) { if(config.getConfig(WailaRegistrar.CONFIG_TANK)) { TileEntity te = accessor.getTileEntity(); if(te.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, null)) { IFluidHandler fluidHandler = te.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, null); assert fluidHandler != null; IFluidTankProperties[] fluidHandlerTankProperties = fluidHandler.getTankProperties(); for(IFluidTankProperties fluidTankProperties : fluidHandlerTankProperties) { FluidStack fluidStack = fluidTankProperties.getContents(); if(fluidStack != null) { currenttip.add(Util.translateFormatted("gui.waila.tank.fluid", fluidStack.getLocalizedName())); currenttip.add(Util.translateFormatted("gui.waila.tank.amount", fluidStack.amount, fluidTankProperties.getCapacity())); } else { currenttip.add(Util.translate("gui.waila.tank.empty")); } } } } return currenttip; }
@Override public FluidStack drain(FluidStack resource, boolean doDrain) { for(IFluidHandler tank : myTanks) { FluidStack ret = tank.drain(resource, doDrain); if(ret != null && ret.amount != 0) { return ret; } } return null; }
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; }
boolean changed = false; final IFluidTankProperties[] props = this.handler.getTankProperties(); for( int slot = 0; slot < this.handler.getTankProperties().length; ++slot )
@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 ); }