Initial Fluid Integration (#3510)

* Added Fluid Storage Cells

* Added Fluid Import Bus

* Added Fluid Export Bus

* Added Fluid Storage Bus

* Added Fluid Terminal.
While holding a item with the FLUID_HANDLER_ITEM_CAPABILITY, such as a tank
Left click on a fluid to extract the fluid
Right click to insert the fluid

src/main/java/appeng/container/implementations/ContainerCellWorkbench.java

@@ -33,10 +33,12 @@ import appeng.api.AEApi;
 import appeng.api.config.CopyMode;
 import appeng.api.config.FuzzyMode;
 import appeng.api.config.Settings;
+import appeng.api.implementations.items.IStorageCell;
 import appeng.api.storage.ICellWorkbenchItem;
 import appeng.api.storage.IMEInventory;
+import appeng.api.storage.IStorageChannel;
 import appeng.api.storage.channels.IItemStorageChannel;
-import appeng.api.storage.data.IAEItemStack;
+import appeng.api.storage.data.IAEStack;
 import appeng.api.storage.data.IItemList;
 import appeng.container.guisync.GuiSync;
 import appeng.container.slot.OptionalSlotRestrictedInput;
@@ -219,17 +221,20 @@ public class ContainerCellWorkbench extends ContainerUpgradeable
 
 	public void partition()
 	{
+
 		final IItemHandler inv = this.getUpgradeable().getInventoryByName( "config" );
 
-		final IMEInventory<IAEItemStack> cellInv = AEApi.instance().registries().cell().getCellInventory(
-				this.getUpgradeable().getInventoryByName( "cell" ).getStackInSlot( 0 ), null,
-				AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ) );
+		final ItemStack is = this.getUpgradeable().getInventoryByName( "cell" ).getStackInSlot( 0 );
+		final IStorageChannel channel = is.getItem() instanceof IStorageCell ? ( (IStorageCell) is.getItem() ).getChannel() : AEApi.instance()
+				.storage()
+				.getStorageChannel( IItemStorageChannel.class );
 
-		Iterator<IAEItemStack> i = new NullIterator<>();
+		final IMEInventory cellInv = AEApi.instance().registries().cell().getCellInventory( is, null, channel );
+
+		Iterator<IAEStack> i = new NullIterator<>();
 		if( cellInv != null )
 		{
-			final IItemList<IAEItemStack> list = cellInv
-					.getAvailableItems( AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ).createList() );
+			final IItemList list = cellInv.getAvailableItems( channel.createList() );
 			i = list.iterator();
 		}
 

src/main/java/appeng/container/implementations/ContainerFluidIO.java

@@ -0,0 +1,74 @@
+/*
+ * This file is part of Applied Energistics 2.
+ * Copyright (c) 2013 - 2018, AlgorithmX2, All rights reserved.
+ *
+ * Applied Energistics 2 is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Applied Energistics 2 is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Applied Energistics 2.  If not, see <http://www.gnu.org/licenses/lgpl>.
+ */
+
+package appeng.container.implementations;
+
+
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
+import net.minecraftforge.items.IItemHandler;
+
+import appeng.api.implementations.IUpgradeableHost;
+import appeng.container.slot.OptionalSlotFakeFluid;
+import appeng.container.slot.SlotFakeFluid;
+
+
+/**
+ * @author BrockWS
+ * @version rv5 - 1/05/2018
+ * @since rv5 1/05/2018
+ */
+public class ContainerFluidIO extends ContainerUpgradeable
+{
+	public ContainerFluidIO( InventoryPlayer ip, IUpgradeableHost te )
+	{
+		super( ip, te );
+	}
+
+	@Override
+	protected void setupConfig()
+	{
+		this.setupUpgrades();
+
+		final IItemHandler inv = this.getUpgradeable().getInventoryByName( "config" );
+		final int y = 40;
+		final int x = 80;
+		this.addSlotToContainer( new SlotFakeFluid( inv, 0, x, y ) );
+
+		if( this.supportCapacity() )
+		{
+			this.addSlotToContainer( new OptionalSlotFakeFluid( inv, this, 1, x, y, -1, 0, 1 ) );
+			this.addSlotToContainer( new OptionalSlotFakeFluid( inv, this, 2, x, y, 1, 0, 1 ) );
+			this.addSlotToContainer( new OptionalSlotFakeFluid( inv, this, 3, x, y, 0, -1, 1 ) );
+			this.addSlotToContainer( new OptionalSlotFakeFluid( inv, this, 4, x, y, 0, 1, 1 ) );
+
+			this.addSlotToContainer( new OptionalSlotFakeFluid( inv, this, 5, x, y, -1, -1, 2 ) );
+			this.addSlotToContainer( new OptionalSlotFakeFluid( inv, this, 6, x, y, 1, -1, 2 ) );
+			this.addSlotToContainer( new OptionalSlotFakeFluid( inv, this, 7, x, y, -1, 1, 2 ) );
+			this.addSlotToContainer( new OptionalSlotFakeFluid( inv, this, 8, x, y, 1, 1, 2 ) );
+		}
+	}
+
+	@Override
+	public boolean isValidForSlot( Slot s, ItemStack i )
+	{
+		return s instanceof SlotFakeFluid ? i.hasCapability( CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null ) : super.isValidForSlot( s, i );
+	}
+}

src/main/java/appeng/container/implementations/ContainerFluidStorageBus.java

@@ -0,0 +1,196 @@
+/*
+ * This file is part of Applied Energistics 2.
+ * Copyright (c) 2013 - 2018, AlgorithmX2, All rights reserved.
+ *
+ * Applied Energistics 2 is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Applied Energistics 2 is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Applied Energistics 2.  If not, see <http://www.gnu.org/licenses/lgpl>.
+ */
+
+package appeng.container.implementations;
+
+
+import java.util.Iterator;
+
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.items.IItemHandler;
+
+import appeng.api.AEApi;
+import appeng.api.config.AccessRestriction;
+import appeng.api.config.FuzzyMode;
+import appeng.api.config.SecurityPermissions;
+import appeng.api.config.Settings;
+import appeng.api.config.StorageFilter;
+import appeng.api.config.Upgrades;
+import appeng.api.storage.IMEInventory;
+import appeng.api.storage.channels.IFluidStorageChannel;
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.api.storage.data.IItemList;
+import appeng.container.guisync.GuiSync;
+import appeng.container.slot.OptionalSlotFakeFluid;
+import appeng.container.slot.SlotFakeFluid;
+import appeng.container.slot.SlotRestrictedInput;
+import appeng.fluids.parts.PartFluidStorageBus;
+import appeng.util.Platform;
+import appeng.util.helpers.ItemHandlerUtil;
+import appeng.util.iterators.NullIterator;
+
+
+/**
+ * @author BrockWS
+ * @version rv6 - 22/05/2018
+ * @since rv6 22/05/2018
+ */
+public class ContainerFluidStorageBus extends ContainerUpgradeable
+{
+
+	private final PartFluidStorageBus storageBus;
+
+	@GuiSync( 3 )
+	public AccessRestriction rwMode = AccessRestriction.READ_WRITE;
+
+	@GuiSync( 4 )
+	public StorageFilter storageFilter = StorageFilter.EXTRACTABLE_ONLY;
+
+	public ContainerFluidStorageBus( InventoryPlayer ip, PartFluidStorageBus te )
+	{
+		super( ip, te );
+		this.storageBus = te;
+	}
+
+	@Override
+	protected int getHeight()
+	{
+		return 251;
+	}
+
+	@Override
+	protected void setupConfig()
+	{
+		final int xo = 8;
+		final int yo = 23 + 6;
+
+		final IItemHandler config = this.getUpgradeable().getInventoryByName( "config" );
+		for( int y = 0; y < 7; y++ )
+		{
+			for( int x = 0; x < 9; x++ )
+			{
+				if( y < 2 )
+				{
+					this.addSlotToContainer( new SlotFakeFluid( config, y * 9 + x, xo + x * 18, yo + y * 18 ) );
+				}
+				else
+				{
+					this.addSlotToContainer( new OptionalSlotFakeFluid( config, this, y * 9 + x, xo, yo, x, y, y - 2 ) );
+				}
+			}
+		}
+
+		final IItemHandler upgrades = this.getUpgradeable().getInventoryByName( "upgrades" );
+		this.addSlotToContainer( ( new SlotRestrictedInput( SlotRestrictedInput.PlacableItemType.UPGRADES, upgrades, 0, 187, 8, this.getInventoryPlayer() ) ).setNotDraggable() );
+		this.addSlotToContainer( ( new SlotRestrictedInput( SlotRestrictedInput.PlacableItemType.UPGRADES, upgrades, 1, 187, 8 + 18, this.getInventoryPlayer() ) ).setNotDraggable() );
+		this.addSlotToContainer( ( new SlotRestrictedInput( SlotRestrictedInput.PlacableItemType.UPGRADES, upgrades, 2, 187, 8 + 18 * 2, this.getInventoryPlayer() ) ).setNotDraggable() );
+		this.addSlotToContainer( ( new SlotRestrictedInput( SlotRestrictedInput.PlacableItemType.UPGRADES, upgrades, 3, 187, 8 + 18 * 3, this.getInventoryPlayer() ) ).setNotDraggable() );
+		this.addSlotToContainer( ( new SlotRestrictedInput( SlotRestrictedInput.PlacableItemType.UPGRADES, upgrades, 4, 187, 8 + 18 * 4, this.getInventoryPlayer() ) ).setNotDraggable() );
+	}
+
+	@Override
+	protected boolean supportCapacity()
+	{
+		return true;
+	}
+
+	@Override
+	public int availableUpgrades()
+	{
+		return 5;
+	}
+
+	@Override
+	public void detectAndSendChanges()
+	{
+		this.verifyPermissions( SecurityPermissions.BUILD, false );
+
+		if( Platform.isServer() )
+		{
+			this.setFuzzyMode( (FuzzyMode) this.getUpgradeable().getConfigManager().getSetting( Settings.FUZZY_MODE ) );
+			this.setReadWriteMode( (AccessRestriction) this.getUpgradeable().getConfigManager().getSetting( Settings.ACCESS ) );
+			this.setStorageFilter( (StorageFilter) this.getUpgradeable().getConfigManager().getSetting( Settings.STORAGE_FILTER ) );
+		}
+
+		this.standardDetectAndSendChanges();
+	}
+
+	@Override
+	public boolean isSlotEnabled( final int idx )
+	{
+		final int upgrades = this.getUpgradeable().getInstalledUpgrades( Upgrades.CAPACITY );
+
+		return upgrades > idx;
+	}
+
+	public void clear()
+	{
+		ItemHandlerUtil.clear( this.getUpgradeable().getInventoryByName( "config" ) );
+		this.detectAndSendChanges();
+	}
+
+	public void partition()
+	{
+		final IItemHandler inv = this.getUpgradeable().getInventoryByName( "config" );
+
+		final IMEInventory<IAEFluidStack> cellInv = this.storageBus.getInternalHandler();
+
+		Iterator<IAEFluidStack> i = new NullIterator<>();
+		if( cellInv != null )
+		{
+			final IItemList<IAEFluidStack> list = cellInv.getAvailableItems( AEApi.instance().storage().getStorageChannel( IFluidStorageChannel.class ).createList() );
+			i = list.iterator();
+		}
+
+		for( int x = 0; x < inv.getSlots(); x++ )
+		{
+			if( i.hasNext() && this.isSlotEnabled( ( x / 9 ) - 2 ) )
+			{
+				final ItemStack g = i.next().asItemStackRepresentation();
+				ItemHandlerUtil.setStackInSlot( inv, x, g );
+			}
+			else
+			{
+				ItemHandlerUtil.setStackInSlot( inv, x, ItemStack.EMPTY );
+			}
+		}
+
+		this.detectAndSendChanges();
+	}
+
+	public AccessRestriction getReadWriteMode()
+	{
+		return this.rwMode;
+	}
+
+	private void setReadWriteMode( final AccessRestriction rwMode )
+	{
+		this.rwMode = rwMode;
+	}
+
+	public StorageFilter getStorageFilter()
+	{
+		return this.storageFilter;
+	}
+
+	private void setStorageFilter( final StorageFilter storageFilter )
+	{
+		this.storageFilter = storageFilter;
+	}
+}

src/main/java/appeng/container/implementations/ContainerFluidTerminal.java

@@ -0,0 +1,478 @@
+/*
+ * This file is part of Applied Energistics 2.
+ * Copyright (c) 2013 - 2018, AlgorithmX2, All rights reserved.
+ *
+ * Applied Energistics 2 is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Applied Energistics 2 is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Applied Energistics 2.  If not, see <http://www.gnu.org/licenses/lgpl>.
+ */
+
+package appeng.container.implementations;
+
+
+import java.io.IOException;
+import java.nio.BufferOverflowException;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.init.Items;
+import net.minecraft.inventory.IContainerListener;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.ForgeModContainer;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidUtil;
+import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
+import net.minecraftforge.fluids.capability.IFluidHandlerItem;
+
+import appeng.api.AEApi;
+import appeng.api.config.Actionable;
+import appeng.api.config.PowerMultiplier;
+import appeng.api.config.Settings;
+import appeng.api.config.SortDir;
+import appeng.api.config.SortOrder;
+import appeng.api.config.ViewItems;
+import appeng.api.networking.IGrid;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.energy.IEnergyGrid;
+import appeng.api.networking.security.IActionSource;
+import appeng.api.networking.storage.IBaseMonitor;
+import appeng.api.storage.IMEMonitor;
+import appeng.api.storage.IMEMonitorHandlerReceiver;
+import appeng.api.storage.channels.IFluidStorageChannel;
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.api.storage.data.IItemList;
+import appeng.api.util.AEPartLocation;
+import appeng.api.util.IConfigManager;
+import appeng.api.util.IConfigurableObject;
+import appeng.container.AEBaseContainer;
+import appeng.container.guisync.GuiSync;
+import appeng.core.AELog;
+import appeng.core.sync.network.NetworkHandler;
+import appeng.core.sync.packets.PacketMEFluidInventoryUpdate;
+import appeng.core.sync.packets.PacketTargetFluidStack;
+import appeng.core.sync.packets.PacketValueConfig;
+import appeng.helpers.InventoryAction;
+import appeng.me.helpers.ChannelPowerSrc;
+import appeng.parts.reporting.PartFluidTerminal;
+import appeng.util.ConfigManager;
+import appeng.util.IConfigManagerHost;
+import appeng.util.Platform;
+import appeng.util.item.AEFluidStack;
+
+
+/**
+ * @author BrockWS
+ * @version rv6 - 12/05/2018
+ * @since rv6 12/05/2018
+ */
+public class ContainerFluidTerminal extends AEBaseContainer implements IConfigManagerHost, IConfigurableObject, IMEMonitorHandlerReceiver<IAEFluidStack>
+{
+	private final IConfigManager clientCM;
+	private final IMEMonitor<IAEFluidStack> monitor;
+	private final IItemList<IAEFluidStack> fluids = AEApi.instance().storage().getStorageChannel( IFluidStorageChannel.class ).createList();
+	@GuiSync( 99 )
+	public boolean hasPower = false;
+	private PartFluidTerminal terminal;
+	private IConfigManager serverCM;
+	private IConfigManagerHost gui;
+	private IGridNode networkNode;
+	// Holds the fluid the client wishes to extract, or null for insert
+	private IAEFluidStack clientRequestedTargetFluid = null;
+
+	public ContainerFluidTerminal( InventoryPlayer ip, PartFluidTerminal terminal )
+	{
+		super( ip, terminal );
+		this.terminal = terminal;
+		this.clientCM = new ConfigManager( this );
+
+		this.clientCM.registerSetting( Settings.SORT_BY, SortOrder.NAME );
+		this.clientCM.registerSetting( Settings.SORT_DIRECTION, SortDir.ASCENDING );
+		this.clientCM.registerSetting( Settings.VIEW_MODE, ViewItems.ALL );
+		if( Platform.isServer() )
+		{
+			this.serverCM = terminal.getConfigManager();
+			this.monitor = terminal.getInventory( AEApi.instance().storage().getStorageChannel( IFluidStorageChannel.class ) );
+			if( this.monitor != null )
+			{
+				this.monitor.addListener( this, null );
+				final IGridNode node = terminal.getGridNode( AEPartLocation.INTERNAL );
+				if( node != null )
+				{
+					this.networkNode = node;
+					final IGrid g = node.getGrid();
+					if( g != null )
+					{
+						this.setPowerSource( new ChannelPowerSrc( this.networkNode, g.getCache( IEnergyGrid.class ) ) );
+					}
+				}
+			}
+		}
+		else
+		{
+			this.monitor = null;
+		}
+		this.bindPlayerInventory( ip, 0, 222 - 82 );
+	}
+
+	@Override
+	public boolean isValid( Object verificationToken )
+	{
+		return true;
+	}
+
+	@Override
+	public void postChange( IBaseMonitor<IAEFluidStack> monitor, Iterable<IAEFluidStack> change, IActionSource actionSource )
+	{
+		for( final IAEFluidStack is : change )
+		{
+			this.fluids.add( is );
+		}
+	}
+
+	@Override
+	public void onListUpdate()
+	{
+		for( final IContainerListener c : this.listeners )
+		{
+			this.queueInventory( c );
+		}
+	}
+
+	@Override
+	public void addListener( IContainerListener listener )
+	{
+		super.addListener( listener );
+
+		this.queueInventory( listener );
+	}
+
+	@Override
+	public void onContainerClosed( final EntityPlayer player )
+	{
+		super.onContainerClosed( player );
+		if( this.monitor != null )
+		{
+			this.monitor.removeListener( this );
+		}
+	}
+
+	private void queueInventory( final IContainerListener c )
+	{
+		if( Platform.isServer() && c instanceof EntityPlayer && this.monitor != null )
+		{
+			try
+			{
+				PacketMEFluidInventoryUpdate piu = new PacketMEFluidInventoryUpdate();
+				final IItemList<IAEFluidStack> monitorCache = this.monitor.getStorageList();
+
+				for( final IAEFluidStack send : monitorCache )
+				{
+					try
+					{
+						piu.appendFluid( send );
+					}
+					catch( final BufferOverflowException boe )
+					{
+						NetworkHandler.instance().sendTo( piu, (EntityPlayerMP) c );
+
+						piu = new PacketMEFluidInventoryUpdate();
+						piu.appendFluid( send );
+					}
+				}
+
+				NetworkHandler.instance().sendTo( piu, (EntityPlayerMP) c );
+			}
+			catch( final IOException e )
+			{
+				AELog.debug( e );
+			}
+		}
+	}
+
+	@Override
+	public IConfigManager getConfigManager()
+	{
+		if( Platform.isServer() )
+		{
+			return this.serverCM;
+		}
+		return this.clientCM;
+	}
+
+	public void setTargetStack( final IAEFluidStack stack )
+	{
+		if( Platform.isClient() )
+		{
+			if( stack == null && this.clientRequestedTargetFluid == null )
+			{
+				return;
+			}
+			if( stack != null && this.clientRequestedTargetFluid != null && stack.getFluidStack()
+					.isFluidEqual( this.clientRequestedTargetFluid.getFluidStack() ) )
+			{
+				return;
+			}
+			NetworkHandler.instance().sendToServer( new PacketTargetFluidStack( (AEFluidStack) stack ) );
+		}
+
+		this.clientRequestedTargetFluid = stack == null ? null : stack.copy();
+	}
+
+	@Override
+	public void updateSetting( IConfigManager manager, Enum settingName, Enum newValue )
+	{
+		if( this.getGui() != null )
+		{
+			this.getGui().updateSetting( manager, settingName, newValue );
+		}
+	}
+
+	@Override
+	public void detectAndSendChanges()
+	{
+		if( Platform.isServer() )
+		{
+			if( this.monitor != this.terminal.getInventory( AEApi.instance().storage().getStorageChannel( IFluidStorageChannel.class ) ) )
+			{
+				this.setValidContainer( false );
+			}
+
+			for( final Settings set : this.serverCM.getSettings() )
+			{
+				final Enum<?> sideLocal = this.serverCM.getSetting( set );
+				final Enum<?> sideRemote = this.clientCM.getSetting( set );
+
+				if( sideLocal != sideRemote )
+				{
+					this.clientCM.putSetting( set, sideLocal );
+					for( final IContainerListener crafter : this.listeners )
+					{
+						if( crafter instanceof EntityPlayerMP )
+						{
+							try
+							{
+								NetworkHandler.instance().sendTo( new PacketValueConfig( set.name(), sideLocal.name() ), (EntityPlayerMP) crafter );
+							}
+							catch( final IOException e )
+							{
+								AELog.debug( e );
+							}
+						}
+					}
+				}
+			}
+
+			if( !this.fluids.isEmpty() )
+			{
+				try
+				{
+					final IItemList<IAEFluidStack> monitorCache = this.monitor.getStorageList();
+
+					final PacketMEFluidInventoryUpdate piu = new PacketMEFluidInventoryUpdate();
+
+					for( final IAEFluidStack is : this.fluids )
+					{
+						final IAEFluidStack send = monitorCache.findPrecise( is );
+						if( send == null )
+						{
+							is.setStackSize( 0 );
+							piu.appendFluid( is );
+						}
+						else
+						{
+							piu.appendFluid( send );
+						}
+					}
+
+					if( !piu.isEmpty() )
+					{
+						this.fluids.resetStatus();
+
+						for( final Object c : this.listeners )
+						{
+							if( c instanceof EntityPlayer )
+							{
+								NetworkHandler.instance().sendTo( piu, (EntityPlayerMP) c );
+							}
+						}
+					}
+				}
+				catch( final IOException e )
+				{
+					AELog.debug( e );
+				}
+			}
+			this.updatePowerStatus();
+
+			super.detectAndSendChanges();
+		}
+	}
+
+	@Override
+	public void doAction( EntityPlayerMP player, InventoryAction action, int slot, long id )
+	{
+		if( action != InventoryAction.FILL_ITEM && action != InventoryAction.EMPTY_ITEM )
+		{
+			super.doAction( player, action, slot, id );
+			return;
+		}
+		ItemStack held = player.inventory.getItemStack();
+		if( !held.hasCapability( CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null ) )
+		{ // For now only do simple i/o with held tanks
+			return;
+		}
+		IFluidHandlerItem fh = FluidUtil.getFluidHandler( held );
+		if( fh == null )
+		{
+			throw new NullPointerException( held.getDisplayName() + " did not give FLUID_HANDLER_ITEM_CAPABILITY" );
+		}
+		boolean isBucket = held.getItem() == Items.BUCKET ||
+				held.getItem() == Items.WATER_BUCKET ||
+				held.getItem() == Items.LAVA_BUCKET ||
+				held.getItem() == Items.MILK_BUCKET ||
+				held.getItem() == ForgeModContainer.getInstance().universalBucket;
+
+		if( action == InventoryAction.FILL_ITEM && this.clientRequestedTargetFluid != null )
+		{
+			AEFluidStack stack = (AEFluidStack) this.clientRequestedTargetFluid.copy();
+
+			AELog.info( "Filling %s with %s, %s mb", held.getDisplayName(), this.clientRequestedTargetFluid.getFluidStack().getLocalizedName(),
+					stack.getStackSize() );
+
+			if( isBucket && stack.getStackSize() < 1000 )
+			{ // Although buckets support less than a buckets worth of fluid, it does not display how much it holds
+				return;
+			}
+
+			// Check how much we can store in the item
+			stack.setStackSize( Integer.MAX_VALUE );
+			int amountAllowed = fh.fill( stack.getFluidStack(), false );
+			stack.setStackSize( amountAllowed );
+
+			// Check if we can pull out of the system
+			IAEFluidStack canPull = this.monitor.extractItems( stack, Actionable.SIMULATE, this.getActionSource() );
+			if( canPull == null || canPull.getStackSize() < 1 || ( isBucket && canPull.getStackSize() < 1000 ) )
+			{
+				// Either we couldn't pull out of the system,
+				// or we are using a bucket and can only pull out less than a buckets worth of fluid
+				return;
+			}
+
+			// Now actually pull out of the system
+			IAEFluidStack pulled = Platform.poweredExtraction( this.getPowerSource(), this.monitor, stack, this.getActionSource() );
+			if( pulled == null || pulled.getStackSize() < 1 )
+			{
+				// Something went wrong
+				AELog.error( "Unable to pull fluid out of the ME system even though the simulation said yes " );
+				return;
+			}
+
+			if( isBucket )
+			{
+				// We need to handle buckets separately
+				ItemStack filledBucket = FluidUtil.getFilledBucket( pulled.getFluidStack() );
+				player.inventory.setItemStack( filledBucket );
+			}
+			else
+			{
+				fh.fill( pulled.getFluidStack(), true );
+			}
+			this.updateHeld( player );
+		}
+		else if( action == InventoryAction.EMPTY_ITEM )
+		{
+			// Empty held item
+			AELog.info( "Emptying %s", held.getDisplayName() );
+
+			// See how much we can drain from the item
+			FluidStack extract = fh.drain( Integer.MAX_VALUE, false );
+			if( extract == null || extract.amount < 1 )
+			{
+				return;
+			}
+
+			// Check if we can push into the system
+			IAEFluidStack canPush = this.monitor.injectItems( AEFluidStack.fromFluidStack( extract ), Actionable.SIMULATE, this.getActionSource() );
+			if( isBucket && canPush != null && canPush.getStackSize() > 0 )
+			{
+				// We can't push enough for the bucket
+				return;
+			}
+
+			IAEFluidStack inserted = Platform.poweredInsert( this.getPowerSource(), this.monitor, AEFluidStack.fromFluidStack( extract ),
+					this.getActionSource() );
+			if( inserted != null && inserted.getStackSize() > 0 )
+			{
+				// Only try to extract the amount we DID insert
+				extract.amount -= Math.toIntExact( inserted.getStackSize() );
+			}
+
+			if( isBucket )
+			{
+				// Remove bucket and replace with EmptyBucket
+				player.inventory.setItemStack( new ItemStack( Items.BUCKET, 1 ) );
+			}
+			else
+			{
+				// Actually drain
+				fh.drain( extract, true );
+			}
+			this.updateHeld( player );
+		}
+	}
+
+	protected void updatePowerStatus()
+	{
+		try
+		{
+			if( this.networkNode != null )
+			{
+				this.setPowered( this.networkNode.isActive() );
+			}
+			else if( this.getPowerSource() instanceof IEnergyGrid )
+			{
+				this.setPowered( ( (IEnergyGrid) this.getPowerSource() ).isNetworkPowered() );
+			}
+			else
+			{
+				this.setPowered( this.getPowerSource().extractAEPower( 1, Actionable.SIMULATE, PowerMultiplier.CONFIG ) > 0.8 );
+			}
+		}
+		catch( final Exception ignore )
+		{
+			// :P
+		}
+	}
+
+	private IConfigManagerHost getGui()
+	{
+		return this.gui;
+	}
+
+	public void setGui( @Nonnull final IConfigManagerHost gui )
+	{
+		this.gui = gui;
+	}
+
+	public boolean isPowered()
+	{
+		return this.hasPower;
+	}
+
+	private void setPowered( final boolean isPowered )
+	{
+		this.hasPower = isPowered;
+	}
+}

src/main/java/appeng/container/slot/IOptionalSlot.java

@@ -0,0 +1,37 @@
+/*
+ * This file is part of Applied Energistics 2.
+ * Copyright (c) 2013 - 2018, AlgorithmX2, All rights reserved.
+ *
+ * Applied Energistics 2 is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Applied Energistics 2 is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Applied Energistics 2.  If not, see <http://www.gnu.org/licenses/lgpl>.
+ */
+
+package appeng.container.slot;
+
+
+/**
+ * @author BrockWS
+ * @version rv6 - 2/05/2018
+ * @since rv6 2/05/2018
+ */
+public interface IOptionalSlot
+{
+	default boolean isRenderDisabled()
+	{
+		return false;
+	}
+
+	int getSourceX();
+
+	int getSourceY();
+}

src/main/java/appeng/container/slot/ISlotFluid.java

@@ -0,0 +1,38 @@
+/*
+ * This file is part of Applied Energistics 2.
+ * Copyright (c) 2013 - 2018, AlgorithmX2, All rights reserved.
+ *
+ * Applied Energistics 2 is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Applied Energistics 2 is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Applied Energistics 2.  If not, see <http://www.gnu.org/licenses/lgpl>.
+ */
+
+package appeng.container.slot;
+
+
+import net.minecraftforge.fluids.FluidStack;
+
+
+/**
+ * @author BrockWS
+ * @version rv6 - 3/05/2018
+ * @since rv6 3/05/2018
+ */
+public interface ISlotFluid
+{
+	FluidStack getFluidInSlot();
+
+	default boolean shouldRenderAsFluid()
+	{
+		return true;
+	}
+}

src/main/java/appeng/container/slot/OptionalSlotFake.java

@@ -25,7 +25,7 @@ import net.minecraft.item.ItemStack;
 import net.minecraftforge.items.IItemHandler;
 
 
-public class OptionalSlotFake extends SlotFake
+public class OptionalSlotFake extends SlotFake implements IOptionalSlot
 {
 
 	private final int srcX;
@@ -69,12 +69,8 @@ public class OptionalSlotFake extends SlotFake
 		return this.host.isSlotEnabled( this.groupNum );
 	}
 
-	public boolean renderDisabled()
-	{
-		return this.isRenderDisabled();
-	}
-
-	private boolean isRenderDisabled()
+	@Override
+	public boolean isRenderDisabled()
 	{
 		return this.renderDisabled;
 	}

src/main/java/appeng/container/slot/OptionalSlotFakeFluid.java

@@ -0,0 +1,96 @@
+/*
+ * This file is part of Applied Energistics 2.
+ * Copyright (c) 2013 - 2018, AlgorithmX2, All rights reserved.
+ *
+ * Applied Energistics 2 is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Applied Energistics 2 is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Applied Energistics 2.  If not, see <http://www.gnu.org/licenses/lgpl>.
+ */
+
+package appeng.container.slot;
+
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.items.IItemHandler;
+
+
+/**
+ * @author BrockWS
+ * @version rv6 - 1/05/2018
+ * @since rv6 1/05/2018
+ */
+public class OptionalSlotFakeFluid extends SlotFakeFluid implements IOptionalSlot
+{
+
+	private final int srcX;
+	private final int srcY;
+	private final int groupNum;
+	private final IOptionalSlotHost host;
+	private boolean renderDisabled = true;
+
+	public OptionalSlotFakeFluid( final IItemHandler inv, final IOptionalSlotHost containerBus, final int idx, final int x, final int y, final int offX, final int offY, final int groupNum )
+	{
+		super( inv, idx, x + offX * 18, y + offY * 18 );
+		this.srcX = x;
+		this.srcY = y;
+		this.groupNum = groupNum;
+		this.host = containerBus;
+	}
+
+	@Override
+	@Nonnull
+	public ItemStack getStack()
+	{
+		if( !this.isSlotEnabled() )
+		{
+			if( !this.getDisplayStack().isEmpty() )
+			{
+				this.clearStack();
+			}
+		}
+
+		return super.getStack();
+	}
+
+	@Override
+	public boolean isSlotEnabled()
+	{
+		if( this.host == null )
+		{
+			return false;
+		}
+
+		return this.host.isSlotEnabled( this.groupNum );
+	}
+
+	public boolean isRenderDisabled()
+	{
+		return this.renderDisabled;
+	}
+
+	public void setRenderDisabled( final boolean renderDisabled )
+	{
+		this.renderDisabled = renderDisabled;
+	}
+
+	public int getSourceX()
+	{
+		return this.srcX;
+	}
+
+	public int getSourceY()
+	{
+		return this.srcY;
+	}
+}

src/main/java/appeng/container/slot/OptionalSlotNormal.java

@@ -22,7 +22,7 @@ package appeng.container.slot;
 import net.minecraftforge.items.IItemHandler;
 
 
-public class OptionalSlotNormal extends AppEngSlot
+public class OptionalSlotNormal extends AppEngSlot implements IOptionalSlot
 {
 
 	private final int groupNum;
@@ -45,4 +45,16 @@ public class OptionalSlotNormal extends AppEngSlot
 
 		return this.host.isSlotEnabled( this.groupNum );
 	}
+
+	@Override
+	public int getSourceX()
+	{
+		return this.xPos;
+	}
+
+	@Override
+	public int getSourceY()
+	{
+		return this.yPos;
+	}
 }

src/main/java/appeng/container/slot/SlotFakeFluid.java

@@ -0,0 +1,77 @@
+/*
+ * This file is part of Applied Energistics 2.
+ * Copyright (c) 2013 - 2018, AlgorithmX2, All rights reserved.
+ *
+ * Applied Energistics 2 is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Applied Energistics 2 is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Applied Energistics 2.  If not, see <http://www.gnu.org/licenses/lgpl>.
+ */
+
+package appeng.container.slot;
+
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
+import net.minecraftforge.fluids.capability.IFluidHandlerItem;
+import net.minecraftforge.items.IItemHandler;
+
+
+/**
+ * @author BrockWS
+ * @version rv6 - 1/05/2018
+ * @since rv6 1/05/2018
+ */
+public class SlotFakeFluid extends SlotFake implements ISlotFluid
+{
+	public SlotFakeFluid( IItemHandler inv, int idx, int x, int y )
+	{
+		super( inv, idx, x, y );
+		this.setIIcon( 12 * 16 + 15 );
+	}
+
+	@Override
+	public void putStack( ItemStack is )
+	{
+		if( this.isItemValid( is ) || is.isEmpty() )
+		{
+			super.putStack( is );
+		}
+	}
+
+	@Override
+	public boolean isItemValid( ItemStack stack )
+	{
+		return stack.hasCapability( CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null ) && this.getContainer().isValidForSlot( this, stack );
+	}
+
+	@Override
+	public boolean renderIconWithItem()
+	{
+		return true;
+	}
+
+	@Override
+	public FluidStack getFluidInSlot()
+	{
+		if( !this.getStack().isEmpty() )
+		{
+			IFluidHandlerItem fh = this.getStack().getCapability( CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null );
+			if( fh == null )
+			{
+				throw new NullPointerException( "Item did not give IFluidHandlerItem: " + this.getStack().getDisplayName() );
+			}
+			return fh.drain( Integer.MAX_VALUE, false );
+		}
+		return null;
+	}
+}