Added fluid models (#3543)

2018-06-17 21:17:40 +02:00
parent dcd94b1cfa
commit 2c6e50d48a
32 changed files with 403 additions and 31 deletions
@@ -0,0 +1,49 @@
+/*
+ * 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.fluids.client.gui;
+
+
+import net.minecraft.entity.player.InventoryPlayer;
+
+import appeng.api.implementations.IUpgradeableHost;
+import appeng.client.gui.implementations.GuiUpgradeable;
+import appeng.core.localization.GuiText;
+import appeng.fluids.container.ContainerFluidIO;
+import appeng.fluids.parts.PartFluidImportBus;
+
+
+/**
+ * @author BrockWS
+ * @version rv5 - 1/05/2018
+ * @since rv5 1/05/2018
+ */
+public class GuiFluidIO extends GuiUpgradeable
+{
+
+	public GuiFluidIO( InventoryPlayer inventoryPlayer, IUpgradeableHost te )
+	{
+		super( new ContainerFluidIO( inventoryPlayer, te ) );
+	}
+
+	@Override
+	protected GuiText getName()
+	{
+		return this.bc instanceof PartFluidImportBus ? GuiText.ImportBusFluids : GuiText.ExportBusFluids;
+	}
+}
@@ -0,0 +1,154 @@
+/*
+ * 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.fluids.client.gui;
+
+
+import java.io.IOException;
+
+import org.lwjgl.input.Mouse;
+
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.entity.player.InventoryPlayer;
+
+import appeng.api.config.AccessRestriction;
+import appeng.api.config.ActionItems;
+import appeng.api.config.FuzzyMode;
+import appeng.api.config.Settings;
+import appeng.api.config.StorageFilter;
+import appeng.client.gui.implementations.GuiUpgradeable;
+import appeng.client.gui.widgets.GuiImgButton;
+import appeng.client.gui.widgets.GuiTabButton;
+import appeng.core.AELog;
+import appeng.core.localization.GuiText;
+import appeng.core.sync.GuiBridge;
+import appeng.core.sync.network.NetworkHandler;
+import appeng.core.sync.packets.PacketConfigButton;
+import appeng.core.sync.packets.PacketSwitchGuis;
+import appeng.core.sync.packets.PacketValueConfig;
+import appeng.fluids.container.ContainerFluidStorageBus;
+import appeng.fluids.parts.PartFluidStorageBus;
+
+
+/**
+ * @author BrockWS
+ * @version rv6 - 22/05/2018
+ * @since rv6 22/05/2018
+ */
+public class GuiFluidStorageBus extends GuiUpgradeable
+{
+	private GuiImgButton rwMode;
+	private GuiImgButton storageFilter;
+	private GuiTabButton priority;
+	private GuiImgButton partition;
+	private GuiImgButton clear;
+
+	public GuiFluidStorageBus( InventoryPlayer inventoryPlayer, PartFluidStorageBus te )
+	{
+		super( new ContainerFluidStorageBus( inventoryPlayer, te ) );
+		this.ySize = 251;
+	}
+
+	@Override
+	protected void addButtons()
+	{
+		this.clear = new GuiImgButton( this.guiLeft - 18, this.guiTop + 8, Settings.ACTIONS, ActionItems.CLOSE );
+		this.partition = new GuiImgButton( this.guiLeft - 18, this.guiTop + 28, Settings.ACTIONS, ActionItems.WRENCH );
+		this.rwMode = new GuiImgButton( this.guiLeft - 18, this.guiTop + 48, Settings.ACCESS, AccessRestriction.READ_WRITE );
+		this.storageFilter = new GuiImgButton( this.guiLeft - 18, this.guiTop + 68, Settings.STORAGE_FILTER, StorageFilter.EXTRACTABLE_ONLY );
+		this.fuzzyMode = new GuiImgButton( this.guiLeft - 18, this.guiTop + 88, Settings.FUZZY_MODE, FuzzyMode.IGNORE_ALL );
+
+		this.buttonList.add( this.priority = new GuiTabButton( this.guiLeft + 154, this.guiTop, 2 + 4 * 16, GuiText.Priority.getLocal(), this.itemRender ) );
+
+		this.buttonList.add( this.storageFilter );
+		this.buttonList.add( this.fuzzyMode );
+		this.buttonList.add( this.rwMode );
+		this.buttonList.add( this.partition );
+		this.buttonList.add( this.clear );
+	}
+
+	@Override
+	public void drawFG( final int offsetX, final int offsetY, final int mouseX, final int mouseY )
+	{
+		this.fontRenderer.drawString( this.getGuiDisplayName( this.getName().getLocal() ), 8, 6, 4210752 );
+		this.fontRenderer.drawString( GuiText.inventory.getLocal(), 8, this.ySize - 96 + 3, 4210752 );
+
+		if( this.fuzzyMode != null )
+		{
+			this.fuzzyMode.set( this.cvb.getFuzzyMode() );
+		}
+
+		if( this.storageFilter != null )
+		{
+			this.storageFilter.set( ( (ContainerFluidStorageBus) this.cvb ).getStorageFilter() );
+		}
+
+		if( this.rwMode != null )
+		{
+			this.rwMode.set( ( (ContainerFluidStorageBus) this.cvb ).getReadWriteMode() );
+		}
+	}
+
+	@Override
+	protected String getBackground()
+	{
+		return "guis/storagebus.png";
+	}
+
+	@Override
+	protected void actionPerformed( final GuiButton btn ) throws IOException
+	{
+		super.actionPerformed( btn );
+
+		final boolean backwards = Mouse.isButtonDown( 1 );
+
+		try
+		{
+			if( btn == this.partition )
+			{
+				NetworkHandler.instance().sendToServer( new PacketValueConfig( "StorageBus.Action", "Partition" ) );
+			}
+			else if( btn == this.clear )
+			{
+				NetworkHandler.instance().sendToServer( new PacketValueConfig( "StorageBus.Action", "Clear" ) );
+			}
+			else if( btn == this.priority )
+			{
+				NetworkHandler.instance().sendToServer( new PacketSwitchGuis( GuiBridge.GUI_PRIORITY ) );
+			}
+			else if( btn == this.rwMode )
+			{
+				NetworkHandler.instance().sendToServer( new PacketConfigButton( this.rwMode.getSetting(), backwards ) );
+			}
+			else if( btn == this.storageFilter )
+			{
+				NetworkHandler.instance().sendToServer( new PacketConfigButton( this.storageFilter.getSetting(), backwards ) );
+			}
+		}
+		catch( final IOException e )
+		{
+			AELog.debug( e );
+		}
+	}
+
+	@Override
+	protected GuiText getName()
+	{
+		return GuiText.StorageBusFluids;
+	}
+}
@@ -0,0 +1,362 @@
+/*
+ * 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.fluids.client.gui;
+
+
+import java.io.IOException;
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.lwjgl.input.Mouse;
+
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.ClickType;
+import net.minecraft.inventory.Slot;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fml.common.Loader;
+
+import appeng.api.config.Settings;
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.api.util.IConfigManager;
+import appeng.api.util.IConfigurableObject;
+import appeng.client.gui.AEBaseMEGui;
+import appeng.client.gui.widgets.GuiImgButton;
+import appeng.client.gui.widgets.GuiScrollbar;
+import appeng.client.gui.widgets.ISortSource;
+import appeng.client.gui.widgets.MEGuiTextField;
+import appeng.client.me.FluidRepo;
+import appeng.client.me.SlotFluidME;
+import appeng.client.me.InternalFluidSlotME;
+import appeng.container.slot.ISlotFluid;
+import appeng.core.AELog;
+import appeng.core.localization.GuiText;
+import appeng.core.sync.network.NetworkHandler;
+import appeng.core.sync.packets.PacketInventoryAction;
+import appeng.core.sync.packets.PacketValueConfig;
+import appeng.fluids.container.ContainerFluidTerminal;
+import appeng.fluids.parts.PartFluidTerminal;
+import appeng.helpers.InventoryAction;
+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 GuiFluidTerminal extends AEBaseMEGui implements ISortSource, IConfigManagerHost
+{
+	private final List<SlotFluidME> meFluidSlots = new LinkedList<>();
+	private final FluidRepo repo;
+	private final IConfigManager configSrc;
+	private final ContainerFluidTerminal container;
+	private final int offsetX = 9;
+	private int rows = 6;
+	private int maxRows = Integer.MAX_VALUE;
+	private int perRow = 9;
+
+	protected PartFluidTerminal terminal;
+
+	private MEGuiTextField searchField;
+	private GuiImgButton sortByBox;
+	private GuiImgButton sortDirBox;
+
+	public GuiFluidTerminal( InventoryPlayer inventoryPlayer, PartFluidTerminal terminal )
+	{
+		super( new ContainerFluidTerminal( inventoryPlayer, terminal ) );
+		this.terminal = terminal;
+		this.xSize = 185;
+		this.ySize = 222;
+		final GuiScrollbar scrollbar = new GuiScrollbar();
+		this.setScrollBar( scrollbar );
+		this.repo = new FluidRepo( scrollbar, this );
+		this.configSrc = ( (IConfigurableObject) this.inventorySlots ).getConfigManager();
+		( this.container = (ContainerFluidTerminal) this.inventorySlots ).setGui( this );
+	}
+
+	@Override
+	public void initGui()
+	{
+		this.mc.player.openContainer = this.inventorySlots;
+		this.guiLeft = ( this.width - this.xSize ) / 2;
+		this.guiTop = ( this.height - this.ySize ) / 2;
+
+		this.searchField = new MEGuiTextField( this.fontRenderer, this.guiLeft + Math.max( 80, this.offsetX ), this.guiTop + 4, 90, 12 );
+		this.searchField.setEnableBackgroundDrawing( false );
+		this.searchField.setMaxStringLength( 25 );
+		this.searchField.setTextColor( 0xFFFFFF );
+		this.searchField.setSelectionColor( 0xFF99FF99 );
+		this.searchField.setVisible( true );
+
+		int offset = this.guiTop;
+
+		this.buttonList.add( this.sortByBox = new GuiImgButton( this.guiLeft - 18, offset, Settings.SORT_BY, this.configSrc.getSetting( Settings.SORT_BY ) ) );
+		offset += 20;
+
+		this.buttonList.add( this.sortDirBox = new GuiImgButton( this.guiLeft - 18, offset, Settings.SORT_DIRECTION, this.configSrc.getSetting( Settings.SORT_DIRECTION ) ) );
+
+		for( int y = 0; y < this.rows; y++ )
+		{
+			for( int x = 0; x < this.perRow; x++ )
+			{
+				SlotFluidME slot = new SlotFluidME( new InternalFluidSlotME( this.repo, x + y * this.perRow, this.offsetX + x * 18, 18 + y * 18 ) );
+				this.getMeFluidSlots().add( slot );
+				this.inventorySlots.inventorySlots.add( slot );
+			}
+		}
+		this.setScrollBar();
+	}
+
+	@Override
+	public void drawFG( int offsetX, int offsetY, int mouseX, int mouseY )
+	{
+		this.fontRenderer.drawString( this.getGuiDisplayName( "Fluid Terminal" ), 8, 6, 4210752 );
+		this.fontRenderer.drawString( GuiText.inventory.getLocal(), 8, this.ySize - 96 + 3, 4210752 );
+	}
+
+	@Override
+	public void drawBG( int offsetX, int offsetY, int mouseX, int mouseY )
+	{
+		this.bindTexture( this.getBackground() );
+		final int x_width = 197;
+		this.drawTexturedModalRect( offsetX, offsetY, 0, 0, x_width, 18 );
+
+		for( int x = 0; x < 6; x++ )
+		{
+			this.drawTexturedModalRect( offsetX, offsetY + 18 + x * 18, 0, 18, x_width, 18 );
+		}
+
+		this.drawTexturedModalRect( offsetX, offsetY + 16 + 6 * 18, 0, 106 - 18 - 18, x_width, 99 + 77 );
+
+		if( this.searchField != null )
+		{
+			this.searchField.drawTextBox();
+		}
+	}
+
+	@Override
+	public void updateScreen()
+	{
+		this.repo.setPower( this.container.isPowered() );
+		super.updateScreen();
+	}
+
+	@Override
+	protected void renderHoveredToolTip( int mouseX, int mouseY )
+	{
+		Slot slot = this.getSlot( mouseX, mouseY );
+		if( slot != null && slot.isEnabled() && slot instanceof ISlotFluid )
+		{
+			ISlotFluid fluidSlot = (ISlotFluid) slot;
+			if( fluidSlot.getFluidInSlot() != null && fluidSlot.shouldRenderAsFluid() )
+			{
+				FluidStack fluidStack = fluidSlot.getFluidInSlot();
+				List<String> list = new ArrayList<>();
+				list.add( fluidStack.getLocalizedName() );
+				int amount = fluidStack.amount;
+				DecimalFormat formatter = new DecimalFormat( "#,###.##" );
+				String amountStr = formatter.format( amount ) + "mb";
+				if( amount >= 10000 )
+				{
+					amountStr += " ( ";
+					amountStr += formatter.format( amount / 1000 ) + "B";
+					amountStr += " )";
+				}
+				list.add( amountStr );
+				String modName = "";
+				modName += TextFormatting.BLUE;
+				modName += TextFormatting.ITALIC;
+				modName += Loader.instance().getIndexedModList().get( Platform.getModId( AEFluidStack.fromFluidStack( fluidStack ) ) ).getName();
+				list.add( modName );
+				this.drawHoveringText( list, mouseX, mouseY );
+				return;
+			}
+		}
+		super.renderHoveredToolTip( mouseX, mouseY );
+	}
+
+	@Override
+	protected void actionPerformed( GuiButton btn ) throws IOException
+	{
+		if( btn instanceof GuiImgButton )
+		{
+			final boolean backwards = Mouse.isButtonDown( 1 );
+
+			final GuiImgButton iBtn = (GuiImgButton) btn;
+			if( iBtn.getSetting() != Settings.ACTIONS )
+			{
+				final Enum cv = iBtn.getCurrentValue();
+				final Enum next = Platform.rotateEnum( cv, backwards, iBtn.getSetting().getPossibleValues() );
+
+				try
+				{
+					NetworkHandler.instance().sendToServer( new PacketValueConfig( iBtn.getSetting().name(), next.name() ) );
+				}
+				catch( final IOException e )
+				{
+					AELog.debug( e );
+				}
+
+				iBtn.set( next );
+			}
+		}
+	}
+
+	@Override
+	protected void handleMouseClick( Slot slot, int slotIdx, int mouseButton, ClickType clickType )
+	{
+		if( slot instanceof SlotFluidME )
+		{
+			SlotFluidME meSlot = (SlotFluidME) slot;
+			if( clickType == ClickType.PICKUP )
+			{
+				// TODO: Allow more options
+				if( mouseButton == 0 && meSlot.getHasStack() )
+				{
+					this.container.setTargetStack( meSlot.getAEStack() );
+					AELog.info( "mouse0 GUI STACK SIZE %s", meSlot.getAEStack().getStackSize() );
+					NetworkHandler.instance().sendToServer( new PacketInventoryAction( InventoryAction.FILL_ITEM, slot.slotNumber, 0 ) );
+				}
+				else
+				{
+					this.container.setTargetStack( meSlot.getAEStack() );
+					if( meSlot.getAEStack() != null )
+					{
+						AELog.info( "mouse1 GUI STACK SIZE %s", meSlot.getAEStack().getStackSize() );
+					}
+					NetworkHandler.instance().sendToServer( new PacketInventoryAction( InventoryAction.EMPTY_ITEM, slot.slotNumber, 0 ) );
+				}
+			}
+			return;
+		}
+		super.handleMouseClick( slot, slotIdx, mouseButton, clickType );
+	}
+
+	@Override
+	protected void keyTyped( final char character, final int key ) throws IOException
+	{
+		if( !this.checkHotbarKeys( key ) )
+		{
+			if( character == ' ' && this.searchField.getText().isEmpty() )
+			{
+				return;
+			}
+
+			if( this.searchField.textboxKeyTyped( character, key ) )
+			{
+				this.repo.setSearchString( this.searchField.getText() );
+				this.repo.updateView();
+				this.setScrollBar();
+			}
+			else
+			{
+				super.keyTyped( character, key );
+			}
+		}
+	}
+
+	@Override
+	protected void mouseClicked( final int xCoord, final int yCoord, final int btn ) throws IOException
+	{
+		this.searchField.mouseClicked( xCoord, yCoord, btn );
+
+		if( btn == 1 && this.searchField.isMouseIn( xCoord, yCoord ) )
+		{
+			this.searchField.setText( "" );
+			this.repo.setSearchString( "" );
+			this.repo.updateView();
+			this.setScrollBar();
+		}
+
+		super.mouseClicked( xCoord, yCoord, btn );
+	}
+
+	public void postUpdate( final List<IAEFluidStack> list )
+	{
+		for( final IAEFluidStack is : list )
+		{
+			this.repo.postUpdate( is );
+		}
+
+		this.repo.updateView();
+		this.setScrollBar();
+	}
+
+	private void setScrollBar()
+	{
+		this.getScrollBar().setTop( 18 ).setLeft( 175 ).setHeight( this.rows * 18 - 2 );
+		this.getScrollBar().setRange( 0, ( this.repo.size() + this.perRow - 1 ) / this.perRow - this.rows, Math.max( 1, this.rows / 6 ) );
+	}
+
+	@Override
+	public Enum getSortBy()
+	{
+		return this.configSrc.getSetting( Settings.SORT_BY );
+	}
+
+	@Override
+	public Enum getSortDir()
+	{
+		return this.configSrc.getSetting( Settings.SORT_DIRECTION );
+	}
+
+	@Override
+	public Enum getSortDisplay()
+	{
+		return this.configSrc.getSetting( Settings.VIEW_MODE );
+	}
+
+	@Override
+	public void updateSetting( IConfigManager manager, Enum settingName, Enum newValue )
+	{
+		if( this.sortByBox != null )
+		{
+			this.sortByBox.set( this.configSrc.getSetting( Settings.SORT_BY ) );
+		}
+
+		if( this.sortDirBox != null )
+		{
+			this.sortDirBox.set( this.configSrc.getSetting( Settings.SORT_DIRECTION ) );
+		}
+
+		this.repo.updateView();
+	}
+
+	protected List<SlotFluidME> getMeFluidSlots()
+	{
+		return this.meFluidSlots;
+	}
+
+	@Override
+	protected boolean isPowered()
+	{
+		return this.repo.hasPower();
+	}
+
+	protected String getBackground()
+	{
+		return "guis/terminal.png";
+	}
+}
@@ -0,0 +1,75 @@
+/*
+ * 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.fluids.container;
+
+
+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.implementations.ContainerUpgradeable;
+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 );
+	}
+}
@@ -0,0 +1,197 @@
+/*
+ * 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.fluids.container;
+
+
+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.implementations.ContainerUpgradeable;
+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;
+	}
+}
@@ -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.fluids.container;
+
+
+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.fluids.parts.PartFluidTerminal;
+import appeng.helpers.InventoryAction;
+import appeng.me.helpers.ChannelPowerSrc;
+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;
+	}
+}
@@ -0,0 +1,67 @@
+/*
+ * 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.fluids.parts;
+
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+
+import appeng.api.parts.IPartModel;
+import appeng.core.AppEng;
+import appeng.core.sync.GuiBridge;
+import appeng.items.parts.PartModels;
+import appeng.parts.PartModel;
+import appeng.parts.reporting.AbstractPartTerminal;
+
+
+/**
+ * @author BrockWS
+ * @version rv6 - 12/05/2018
+ * @since rv6 12/05/2018
+ */
+public class PartFluidTerminal extends AbstractPartTerminal
+{
+
+	@PartModels
+	public static final ResourceLocation MODEL_OFF = new ResourceLocation( AppEng.MOD_ID, "part/fluid_terminal_off" );
+	@PartModels
+	public static final ResourceLocation MODEL_ON = new ResourceLocation( AppEng.MOD_ID, "part/fluid_terminal_on" );
+
+	public static final IPartModel MODELS_OFF = new PartModel( MODEL_BASE, MODEL_OFF, MODEL_STATUS_OFF );
+	public static final IPartModel MODELS_ON = new PartModel( MODEL_BASE, MODEL_ON, MODEL_STATUS_ON );
+	public static final IPartModel MODELS_HAS_CHANNEL = new PartModel( MODEL_BASE, MODEL_ON, MODEL_STATUS_HAS_CHANNEL );
+
+	public PartFluidTerminal( ItemStack is )
+	{
+		super( is );
+	}
+
+	@Override
+	public GuiBridge getGui( EntityPlayer player )
+	{
+		return GuiBridge.GUI_FLUID_TERMINAL;
+	}
+
+	@Override
+	public IPartModel getStaticModels()
+	{
+		return this.selectModel( MODELS_OFF, MODELS_ON, MODELS_HAS_CHANNEL );
+	}
+}