@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; }
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 IFluidTankProperties[] getTankProperties() { // if the size is 0 (no fluids) simply return an empty properties // some other mods expect having at least 1 value here if(liquids.size() == 0) { return new IFluidTankProperties[]{ new FluidTankProperties(null, maxCapacity, true, true) }; } IFluidTankProperties[] properties = new IFluidTankProperties[liquids.size()]; for(int i = 0; i < liquids.size(); i++) { boolean first = i == 0; int capacity = liquids.get(i).amount; if(first) { capacity += getCapacity() - getFluidAmount(); } properties[i] = new FluidTankProperties(liquids.get(i), capacity, first, first); } return properties; }
@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; }
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(); } }
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 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; }
boolean changed = false; final IFluidTankProperties[] props = this.handler.getTankProperties(); for( int slot = 0; slot < this.handler.getTankProperties().length; ++slot ) final FluidStack newIS = !props[slot].canDrain() && this.getMode() == StorageFilter.EXTRACTABLE_ONLY ? null : props[slot].getContents(); final FluidStack oldIS = old == null ? null : old.fluidStack;
public List<IAEFluidStack> update() final IFluidTankProperties[] tankProperties = this.fluidHandler.getTankProperties(); final int slots = tankProperties.length; final FluidStack newFS = tankProperties[slot].getContents();
@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 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 void drawButton( final Minecraft mc, final int mouseX, final int mouseY, final float partialTicks ) { if( this.visible ) { GlStateManager.disableBlend(); GlStateManager.disableLighting(); drawRect( this.x, this.y, this.x + this.width, this.y + this.height, AEColor.GRAY.blackVariant | 0xFF000000 ); final IAEFluidStack fluid = this.tank.getFluidInSlot( this.slot ); if( fluid != null && fluid.getStackSize() > 0 ) { mc.getTextureManager().bindTexture( TextureMap.LOCATION_BLOCKS_TEXTURE ); float red = ( fluid.getFluid().getColor() >> 16 & 255 ) / 255.0F; float green = ( fluid.getFluid().getColor() >> 8 & 255 ) / 255.0F; float blue = ( fluid.getFluid().getColor() & 255 ) / 255.0F; GlStateManager.color( red, green, blue ); TextureAtlasSprite sprite = mc.getTextureMapBlocks().getAtlasSprite( fluid.getFluid().getStill().toString() ); final int scaledHeight = (int) ( this.height * ( (float) fluid.getStackSize() / this.tank.getTankProperties()[this.slot].getCapacity() ) ); int iconHeightRemainder = scaledHeight % 16; if( iconHeightRemainder > 0 ) { this.drawTexturedModalRect( this.x, this.y + this.height - iconHeightRemainder, sprite, 16, iconHeightRemainder ); } for( int i = 0; i < scaledHeight / 16; i++ ) { this.drawTexturedModalRect( this.x, this.y + this.height - iconHeightRemainder - ( i + 1 ) * 16, sprite, 16, 16 ); } } } }
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; }
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; }
@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 ); }
@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; }
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; }
@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 ); }
int wasInserted = fh.fill( out.getFluidStack(), true );