Add Fluid Formation/Annihilation Planes (#3591)

Fixes #3572
2018-07-08 16:54:22 +02:00
parent 96af371882
commit e5ab9df086
28 changed files with 1341 additions and 241 deletions
@@ -0,0 +1,90 @@
+
+package appeng.fluids.client.gui;
+
+
+import java.io.IOException;
+
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.entity.player.InventoryPlayer;
+
+import appeng.client.gui.implementations.GuiUpgradeable;
+import appeng.client.gui.widgets.GuiTabButton;
+import appeng.core.localization.GuiText;
+import appeng.core.sync.GuiBridge;
+import appeng.core.sync.network.NetworkHandler;
+import appeng.core.sync.packets.PacketSwitchGuis;
+import appeng.fluids.client.gui.widgets.GuiFluidSlot;
+import appeng.fluids.client.gui.widgets.GuiOptionalFluidSlot;
+import appeng.fluids.container.ContainerFluidFormationPlane;
+import appeng.fluids.parts.PartFluidFormationPlane;
+import appeng.fluids.util.IAEFluidTank;
+
+
+public class GuiFluidFormationPlane extends GuiUpgradeable
+{
+	private final PartFluidFormationPlane plane;
+	private GuiTabButton priority;
+
+	public GuiFluidFormationPlane( InventoryPlayer inventoryPlayer, PartFluidFormationPlane te )
+	{
+		super( new ContainerFluidFormationPlane( inventoryPlayer, te ) );
+		this.ySize = 251;
+		this.plane = te;
+	}
+
+	@Override
+	public void initGui()
+	{
+		super.initGui();
+
+		final int xo = 8;
+		final int yo = 23 + 6;
+
+		final IAEFluidTank config = this.plane.getConfig();
+		final ContainerFluidFormationPlane container = (ContainerFluidFormationPlane) this.inventorySlots;
+
+		for( int y = 0; y < 7; y++ )
+		{
+			for( int x = 0; x < 9; x++ )
+			{
+				final int idx = y * 9 + x;
+				if( y < 2 )
+				{
+					this.guiSlots.add( new GuiFluidSlot( config, idx, idx, xo + x * 18, yo + y * 18 ) );
+				}
+				else
+				{
+					this.guiSlots.add( new GuiOptionalFluidSlot( config, container, idx, idx, y - 2, xo, yo, x, y ) );
+				}
+			}
+		}
+	}
+
+	@Override
+	protected void addButtons()
+	{
+		this.buttonList.add( this.priority = new GuiTabButton( this.guiLeft + 154, this.guiTop, 2 + 4 * 16, GuiText.Priority.getLocal(), this.itemRender ) );
+	}
+
+	@Override
+	protected String getBackground()
+	{
+		return "guis/storagebus.png";
+	}
+
+	@Override
+	protected void actionPerformed( final GuiButton btn ) throws IOException
+	{
+		super.actionPerformed( btn );
+		if( btn == this.priority )
+		{
+			NetworkHandler.instance().sendToServer( new PacketSwitchGuis( GuiBridge.GUI_PRIORITY ) );
+		}
+	}
+	
+	@Override
+	protected GuiText getName()
+	{
+		return GuiText.FluidFormationPlane;
+	}
+}
@@ -0,0 +1,103 @@
+
+package appeng.fluids.container;
+
+
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraftforge.items.IItemHandler;
+
+import appeng.api.config.SecurityPermissions;
+import appeng.api.config.Upgrades;
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.container.slot.SlotRestrictedInput;
+import appeng.fluids.parts.PartFluidFormationPlane;
+import appeng.fluids.util.IAEFluidTank;
+
+
+public class ContainerFluidFormationPlane extends ContainerFluidConfigurable
+{
+	private final PartFluidFormationPlane plane;
+
+	public ContainerFluidFormationPlane( final InventoryPlayer ip, final PartFluidFormationPlane te )
+	{
+		super( ip, te );
+		this.plane = te;
+	}
+
+	@Override
+	protected int getHeight()
+	{
+		return 251;
+	}
+
+	@Override
+	public IAEFluidTank getFluidConfigInventory()
+	{
+		return plane.getConfig();
+	}
+
+	@Override
+	protected void setupConfig()
+	{
+		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
+	public void detectAndSendChanges()
+	{
+		this.verifyPermissions( SecurityPermissions.BUILD, false );
+		this.checkToolbox();
+		this.standardDetectAndSendChanges();
+	}
+
+	@Override
+	protected boolean isValidForConfig( int slot, IAEFluidStack fs )
+	{
+		if( this.supportCapacity() )
+		{
+			final int upgrades = this.getUpgradeable().getInstalledUpgrades( Upgrades.CAPACITY );
+
+			final int y = slot / 9;
+
+			if( y >= upgrades + 2 )
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	@Override
+	public boolean isSlotEnabled( final int idx )
+	{
+		final int upgrades = this.getUpgradeable().getInstalledUpgrades( Upgrades.CAPACITY );
+
+		return upgrades > idx;
+	}
+
+	@Override
+	protected boolean supportCapacity()
+	{
+		return true;
+	}
+
+	@Override
+	public int availableUpgrades()
+	{
+		return 5;
+	}
+}
@@ -0,0 +1,322 @@
+
+package appeng.fluids.parts;
+
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockLiquid;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.fluids.FluidUtil;
+import net.minecraftforge.fluids.IFluidBlock;
+import net.minecraftforge.fluids.capability.IFluidHandler;
+
+import appeng.api.AEApi;
+import appeng.api.config.Actionable;
+import appeng.api.config.PowerMultiplier;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.energy.IEnergyGrid;
+import appeng.api.networking.events.MENetworkChannelsChanged;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.events.MENetworkPowerStatusChange;
+import appeng.api.networking.security.IActionSource;
+import appeng.api.networking.storage.IStorageGrid;
+import appeng.api.networking.ticking.IGridTickable;
+import appeng.api.networking.ticking.TickRateModulation;
+import appeng.api.networking.ticking.TickingRequest;
+import appeng.api.parts.IPart;
+import appeng.api.parts.IPartCollisionHelper;
+import appeng.api.parts.IPartHost;
+import appeng.api.parts.IPartModel;
+import appeng.api.storage.IMEInventory;
+import appeng.api.storage.channels.IFluidStorageChannel;
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.api.util.AECableType;
+import appeng.api.util.AEPartLocation;
+import appeng.core.AppEng;
+import appeng.core.settings.TickRates;
+import appeng.core.sync.packets.PacketTransitionEffect;
+import appeng.fluids.util.AEFluidStack;
+import appeng.items.parts.PartModels;
+import appeng.me.GridAccessException;
+import appeng.me.helpers.MachineSource;
+import appeng.parts.PartBasicState;
+import appeng.parts.automation.PlaneConnections;
+import appeng.parts.automation.PlaneModels;
+import appeng.util.Platform;
+
+
+public class PartFluidAnnihilationPlane extends PartBasicState implements IGridTickable
+{
+	private static final PlaneModels MODELS = new PlaneModels( "part/fluid_annihilation_plane_", "part/fluid_annihilation_plane_on_" );
+
+	@PartModels
+	public static List<IPartModel> getModels()
+	{
+		return MODELS.getModels();
+	}
+
+	private final IActionSource mySrc = new MachineSource( this );
+
+	public PartFluidAnnihilationPlane( final ItemStack is )
+	{
+		super( is );
+	}
+
+	@Override
+	public void getBoxes( final IPartCollisionHelper bch )
+	{
+		int minX = 1;
+		int minY = 1;
+		int maxX = 15;
+		int maxY = 15;
+
+		final IPartHost host = this.getHost();
+		if( host != null )
+		{
+			final TileEntity te = host.getTile();
+
+			final BlockPos pos = te.getPos();
+
+			final EnumFacing e = bch.getWorldX();
+			final EnumFacing u = bch.getWorldY();
+
+			if( this.isAnnihilationPlane( te.getWorld().getTileEntity( pos.offset( e.getOpposite() ) ), this.getSide() ) )
+			{
+				minX = 0;
+			}
+
+			if( this.isAnnihilationPlane( te.getWorld().getTileEntity( pos.offset( e ) ), this.getSide() ) )
+			{
+				maxX = 16;
+			}
+
+			if( this.isAnnihilationPlane( te.getWorld().getTileEntity( pos.offset( u.getOpposite() ) ), this.getSide() ) )
+			{
+				minY = 0;
+			}
+
+			if( this.isAnnihilationPlane( te.getWorld().getTileEntity( pos.offset( e ) ), this.getSide() ) )
+			{
+				maxY = 16;
+			}
+		}
+
+		bch.addBox( 5, 5, 14, 11, 11, 15 );
+		bch.addBox( minX, minY, 15, maxX, maxY, 16 );
+	}
+
+	public PlaneConnections getConnections()
+	{
+
+		final EnumFacing facingRight, facingUp;
+		AEPartLocation location = this.getSide();
+		switch( location )
+		{
+			case UP:
+				facingRight = EnumFacing.EAST;
+				facingUp = EnumFacing.NORTH;
+				break;
+			case DOWN:
+				facingRight = EnumFacing.WEST;
+				facingUp = EnumFacing.NORTH;
+				break;
+			case NORTH:
+				facingRight = EnumFacing.WEST;
+				facingUp = EnumFacing.UP;
+				break;
+			case SOUTH:
+				facingRight = EnumFacing.EAST;
+				facingUp = EnumFacing.UP;
+				break;
+			case WEST:
+				facingRight = EnumFacing.SOUTH;
+				facingUp = EnumFacing.UP;
+				break;
+			case EAST:
+				facingRight = EnumFacing.NORTH;
+				facingUp = EnumFacing.UP;
+				break;
+			default:
+			case INTERNAL:
+				return PlaneConnections.of( false, false, false, false );
+		}
+
+		boolean left = false, right = false, down = false, up = false;
+
+		final IPartHost host = this.getHost();
+		if( host != null )
+		{
+			final TileEntity te = host.getTile();
+
+			final BlockPos pos = te.getPos();
+
+			if( this.isAnnihilationPlane( te.getWorld().getTileEntity( pos.offset( facingRight.getOpposite() ) ), this.getSide() ) )
+			{
+				left = true;
+			}
+
+			if( this.isAnnihilationPlane( te.getWorld().getTileEntity( pos.offset( facingRight ) ), this.getSide() ) )
+			{
+				right = true;
+			}
+
+			if( this.isAnnihilationPlane( te.getWorld().getTileEntity( pos.offset( facingUp.getOpposite() ) ), this.getSide() ) )
+			{
+				down = true;
+			}
+
+			if( this.isAnnihilationPlane( te.getWorld().getTileEntity( pos.offset( facingUp ) ), this.getSide() ) )
+			{
+				up = true;
+			}
+		}
+
+		return PlaneConnections.of( up, right, down, left );
+	}
+
+	@Override
+	public void onNeighborChanged( IBlockAccess w, BlockPos pos, BlockPos neighbor )
+	{
+		if( pos.offset( this.getSide().getFacing() ).equals( neighbor ) )
+		{
+			this.refresh();
+		}
+	}
+
+	@Override
+	public float getCableConnectionLength( AECableType cable )
+	{
+		return 1;
+	}
+
+	private boolean isAnnihilationPlane( final TileEntity blockTileEntity, final AEPartLocation side )
+	{
+		if( blockTileEntity instanceof IPartHost )
+		{
+			final IPart p = ( (IPartHost) blockTileEntity ).getPart( side );
+			return p != null && p.getClass() == this.getClass();
+		}
+		return false;
+	}
+
+	private void refresh()
+	{
+		try
+		{
+			this.getProxy().getTick().alertDevice( this.getProxy().getNode() );
+		}
+		catch( final GridAccessException e )
+		{
+			// :P
+		}
+	}
+
+	@Override
+	@MENetworkEventSubscribe
+	public void chanRender( final MENetworkChannelsChanged c )
+	{
+		this.refresh();
+		this.getHost().markForUpdate();
+	}
+
+	@Override
+	@MENetworkEventSubscribe
+	public void powerRender( final MENetworkPowerStatusChange c )
+	{
+		this.refresh();
+		this.getHost().markForUpdate();
+	}
+
+	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 TickingRequest getTickingRequest( final IGridNode node )
+	{
+		return new TickingRequest( TickRates.AnnihilationPlane.getMin(), TickRates.AnnihilationPlane.getMax(), false, true );
+	}
+
+	@Override
+	public TickRateModulation tickingRequest( final IGridNode node, final int ticksSinceLastCall )
+	{
+		return this.pickupFluid();
+	}
+
+	private boolean storeFluid( IAEFluidStack stack, boolean modulate )
+	{
+		try
+		{
+			final IStorageGrid storage = this.getProxy().getStorage();
+			final IMEInventory<IAEFluidStack> inv = storage.getInventory( AEApi.instance().storage().getStorageChannel( IFluidStorageChannel.class ) );
+
+			if( modulate )
+			{
+				final IEnergyGrid energy = this.getProxy().getEnergy();
+				return Platform.poweredInsert( energy, inv, stack, this.mySrc ) == null;
+			}
+			else
+			{
+				final float requiredPower = (float) stack.getStackSize() / Math.min( 1.0f, stack.getChannel().transferFactor() );
+				final IEnergyGrid energy = this.getProxy().getEnergy();
+
+				if( energy.extractAEPower( requiredPower, Actionable.SIMULATE, PowerMultiplier.CONFIG ) < requiredPower )
+				{
+					return false;
+				}
+				return inv.injectItems( stack, Actionable.SIMULATE, this.mySrc ) == null;
+			}
+		}
+		catch( final GridAccessException e )
+		{
+			// :P
+		}
+		return false;
+	}
+
+	@Override
+	public IPartModel getStaticModels()
+	{
+		return MODELS.getModel( this.getConnections(), this.isPowered(), this.isActive() );
+	}
+}
@@ -0,0 +1,242 @@
+
+package appeng.fluids.parts;
+
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockLiquid;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.World;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTank;
+import net.minecraftforge.fluids.FluidUtil;
+import net.minecraftforge.fluids.IFluidBlock;
+
+import appeng.api.AEApi;
+import appeng.api.config.AccessRestriction;
+import appeng.api.config.Actionable;
+import appeng.api.config.IncludeExclude;
+import appeng.api.config.Upgrades;
+import appeng.api.networking.events.MENetworkCellArrayUpdate;
+import appeng.api.networking.events.MENetworkChannelsChanged;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.events.MENetworkPowerStatusChange;
+import appeng.api.networking.security.IActionSource;
+import appeng.api.parts.IPartModel;
+import appeng.api.storage.IMEInventoryHandler;
+import appeng.api.storage.IStorageChannel;
+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.core.sync.GuiBridge;
+import appeng.fluids.util.AEFluidInventory;
+import appeng.fluids.util.IAEFluidInventory;
+import appeng.fluids.util.IAEFluidTank;
+import appeng.items.parts.PartModels;
+import appeng.me.GridAccessException;
+import appeng.me.storage.MEInventoryHandler;
+import appeng.parts.automation.PartAbstractFormationPlane;
+import appeng.parts.automation.PlaneModels;
+import appeng.util.Platform;
+import appeng.util.prioritylist.PrecisePriorityList;
+
+
+public class PartFluidFormationPlane extends PartAbstractFormationPlane<IAEFluidStack> implements IAEFluidInventory
+{
+	private static final PlaneModels MODELS = new PlaneModels( "part/fluid_formation_plane_", "part/fluid_formation_plane_on_" );
+
+	@PartModels
+	public static List<IPartModel> getModels()
+	{
+		return MODELS.getModels();
+	}
+
+	private final MEInventoryHandler<IAEFluidStack> myHandler = new MEInventoryHandler<>( this, AEApi.instance()
+			.storage()
+			.getStorageChannel( IFluidStorageChannel.class ) );
+	private final AEFluidInventory config = new AEFluidInventory( this, 63 );
+
+	public PartFluidFormationPlane( final ItemStack is )
+	{
+		super( is );
+		this.updateHandler();
+	}
+
+	@Override
+	protected void updateHandler()
+	{
+		this.myHandler.setBaseAccess( AccessRestriction.WRITE );
+		this.myHandler.setWhitelist( this.getInstalledUpgrades( Upgrades.INVERTER ) > 0 ? IncludeExclude.BLACKLIST : IncludeExclude.WHITELIST );
+		this.myHandler.setPriority( this.getPriority() );
+
+		final IItemList<IAEFluidStack> priorityList = AEApi.instance().storage().getStorageChannel( IFluidStorageChannel.class ).createList();
+
+		final int slotsToUse = 18 + this.getInstalledUpgrades( Upgrades.CAPACITY ) * 9;
+		for( int x = 0; x < this.config.getSlots() && x < slotsToUse; x++ )
+		{
+			final IAEFluidStack is = this.config.getFluidInSlot( x );
+			if( is != null )
+			{
+				priorityList.add( is );
+			}
+		}
+		this.myHandler.setPartitionList( new PrecisePriorityList<IAEFluidStack>( priorityList ) );
+
+		try
+		{
+			this.getProxy().getGrid().postEvent( new MENetworkCellArrayUpdate() );
+		}
+		catch( final GridAccessException e )
+		{
+			// :P
+		}
+	}
+
+	@Override
+	public IAEFluidStack injectItems( IAEFluidStack input, Actionable type, IActionSource src )
+	{
+		if( this.blocked || input == null || input.getStackSize() < Fluid.BUCKET_VOLUME )
+		{
+			// need a full bucket
+			return input;
+		}
+
+		final TileEntity te = this.getHost().getTile();
+		final World w = te.getWorld();
+		final AEPartLocation side = this.getSide();
+		final BlockPos pos = te.getPos().offset( side.getFacing() );
+		final IBlockState state = w.getBlockState( pos );
+
+		if( this.canReplace( w, state, state.getBlock(), pos ) )
+		{
+			if( type == Actionable.MODULATE )
+			{
+				final FluidStack fs = input.getFluidStack();
+				fs.amount = Fluid.BUCKET_VOLUME;
+
+				final FluidTank tank = new FluidTank( fs, Fluid.BUCKET_VOLUME );
+				if( !FluidUtil.tryPlaceFluid( null, w, pos, tank, fs ) )
+				{
+					return input;
+				}
+			}
+			final IAEFluidStack ret = input.copy();
+			ret.setStackSize( input.getStackSize() - Fluid.BUCKET_VOLUME );
+			return ret.getStackSize() == 0 ? null : ret;
+		}
+		this.blocked = true;
+		return input;
+	}
+
+	private boolean canReplace( World w, IBlockState state, Block block, BlockPos pos )
+	{
+		return block.isReplaceable( w, pos ) && !( block instanceof IFluidBlock ) && !( block instanceof BlockLiquid ) && !state.getMaterial().isLiquid();
+	}
+
+	@Override
+	public void onFluidInventoryChanged( IAEFluidTank inv, int slot )
+	{
+		if( inv == this.config )
+		{
+			this.updateHandler();
+		}
+	}
+
+	@Override
+	public void readFromNBT( final NBTTagCompound data )
+	{
+		super.readFromNBT( data );
+		this.config.readFromNBT( data, "config" );
+		this.updateHandler();
+	}
+
+	@Override
+	public void writeToNBT( final NBTTagCompound data )
+	{
+		super.writeToNBT( data );
+		this.config.writeToNBT( data, "config" );
+	}
+
+	@Override
+	@MENetworkEventSubscribe
+	public void powerRender( final MENetworkPowerStatusChange c )
+	{
+		this.stateChanged();
+	}
+
+	@MENetworkEventSubscribe
+	public void updateChannels( final MENetworkChannelsChanged changedChannels )
+	{
+		this.stateChanged();
+	}
+
+	@Override
+	public boolean onPartActivate( final EntityPlayer player, final EnumHand hand, final Vec3d pos )
+	{
+		if( !player.isSneaking() )
+		{
+			if( Platform.isClient() )
+			{
+				return true;
+			}
+
+			Platform.openGUI( player, this.getHost().getTile(), this.getSide(), GuiBridge.GUI_FLUID_FORMATION_PLANE );
+			return true;
+		}
+
+		return false;
+	}
+
+	@Override
+	public IStorageChannel<IAEFluidStack> getChannel()
+	{
+		return AEApi.instance().storage().getStorageChannel( IFluidStorageChannel.class );
+	}
+
+	@Override
+	public List<IMEInventoryHandler> getCellArray( final IStorageChannel channel )
+	{
+		if( this.getProxy().isActive() && channel == AEApi.instance().storage().getStorageChannel( IFluidStorageChannel.class ) )
+		{
+			final List<IMEInventoryHandler> handler = new ArrayList<>( 1 );
+			handler.add( this.myHandler );
+			return handler;
+		}
+		return Collections.emptyList();
+	}
+
+	@Override
+	public IPartModel getStaticModels()
+	{
+		return MODELS.getModel( this.getConnections(), this.isPowered(), this.isActive() );
+	}
+
+	public IAEFluidTank getConfig()
+	{
+		return this.config;
+	}
+
+	@Override
+	public ItemStack getItemStackRepresentation()
+	{
+		return AEApi.instance().definitions().parts().fluidFormationnPlane().maybeStack( 1 ).orElse( ItemStack.EMPTY );
+	}
+
+	@Override
+	public GuiBridge getGuiBridge()
+	{
+		return GuiBridge.GUI_FLUID_FORMATION_PLANE;
+	}
+}