add buffer

src/main/java/com/glodblock/github/client/gui/GuiIngredientBuffer.java

@@ -0,0 +1,102 @@
+package com.glodblock.github.client.gui;
+
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.client.gui.AEBaseGui;
+import appeng.core.localization.GuiText;
+import com.glodblock.github.FluidCraft;
+import com.glodblock.github.client.gui.container.ContainerIngredientBuffer;
+import com.glodblock.github.common.tile.TileIngredientBuffer;
+import com.glodblock.github.inventory.IAEFluidTank;
+import com.glodblock.github.inventory.gui.ButtonMouseHandler;
+import com.glodblock.github.inventory.gui.MouseRegionManager;
+import com.glodblock.github.inventory.gui.TankMouseHandler;
+import com.glodblock.github.util.GlStateManager;
+import com.glodblock.github.util.NameConst;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.texture.TextureMap;
+import net.minecraft.client.resources.I18n;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.common.util.ForgeDirection;
+import org.lwjgl.opengl.GL11;
+
+import javax.annotation.Nullable;
+
+public class GuiIngredientBuffer extends AEBaseGui {
+
+    private static final ResourceLocation TEX_BG = FluidCraft.resource("textures/gui/ingredient_buffer.png");
+    private static final int TANK_X = 47, TANK_X_OFF = 22, TANK_Y = 18;
+    private static final int TANK_WIDTH = 16, TANK_HEIGHT = 74;
+
+    private final ContainerIngredientBuffer cont;
+    private final MouseRegionManager mouseRegions = new MouseRegionManager(this, this.fontRendererObj);
+
+    public GuiIngredientBuffer(InventoryPlayer ipl, TileIngredientBuffer tile) {
+        super(new ContainerIngredientBuffer(ipl, tile));
+        this.cont = (ContainerIngredientBuffer) inventorySlots;
+        this.ySize = 222;
+        for (int i = 0; i < 4; i++) {
+            mouseRegions.addRegion(TANK_X + TANK_X_OFF * i, TANK_Y, TANK_WIDTH, TANK_HEIGHT,
+                new TankMouseHandler(cont.getTile().getFluidInventory(), i));
+            mouseRegions.addRegion(TANK_X + 10 + 22 * i, TANK_Y + TANK_HEIGHT + 2, 7, 7,
+                ButtonMouseHandler.dumpTank(cont, i));
+        }
+    }
+
+    @Override
+    protected void mouseClicked(int xCoord, int yCoord, int btn) {
+        if (mouseRegions.onClick(xCoord, yCoord, btn)) {
+            super.mouseClicked(xCoord, yCoord, btn);
+        }
+    }
+
+    @Override
+    public void drawBG(int offsetX, int offsetY, int mouseX, int mouseY) {
+        mc.getTextureManager().bindTexture(TEX_BG);
+        drawTexturedModalRect(offsetX, offsetY, 0, 0, 176, ySize);
+    }
+
+    @Override
+    public void drawFG(int offsetX, int offsetY, int mouseX, int mouseY) {
+        fontRendererObj.drawString(getGuiDisplayName(I18n.format(NameConst.GUI_INGREDIENT_BUFFER)), 8, 6, 0x404040);
+        fontRendererObj.drawString(GuiText.inventory.getLocal(), 8, ySize - 94, 0x404040);
+        GlStateManager.color(1F, 1F, 1F, 1F);
+
+        IAEFluidTank fluidInv = cont.getTile().getFluidInventory();
+        mc.getTextureManager().bindTexture(TextureMap.locationBlocksTexture);
+        Tessellator tess = Tessellator.instance;
+        for (int i = 0; i < 4; i++) {
+            renderFluidIntoGui(tess, TANK_X + i * TANK_X_OFF, TANK_Y, TANK_WIDTH, TANK_HEIGHT,
+                fluidInv.getFluidInSlot(i), fluidInv.getTankInfo(ForgeDirection.UNKNOWN)[i].capacity);
+        }
+        GlStateManager.color(1F, 1F, 1F, 1F);
+
+        mouseRegions.render(mouseX, mouseY);
+    }
+
+    public void renderFluidIntoGui(Tessellator tess, int x, int y, int width, int height,
+                                          @Nullable IAEFluidStack aeFluidStack, int capacity) {
+        if (aeFluidStack != null) {
+            GL11.glDisable(2896);
+            GL11.glColor3f(1.0F, 1.0F, 1.0F);
+            int hi = (int) (height * ((double) aeFluidStack.getStackSize() / capacity));
+            if (aeFluidStack.getStackSize() > 0 && hi > 0) {
+                Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationBlocksTexture);
+                IIcon fluidIcon = aeFluidStack.getFluid().getStillIcon();
+                GL11.glColor3f((float)(aeFluidStack.getFluid().getColor() >> 16 & 255) / 255.0F, (float)(aeFluidStack.getFluid().getColor() >> 8 & 255) / 255.0F, (float)(aeFluidStack.getFluid().getColor() & 255) / 255.0F);
+                for (int th = 0; th <= hi; th += 16) {
+                    if (hi - th <= 0) break;
+                    this.drawTexturedModelRectFromIcon(x, y + height - Math.min(16, hi - th) - th, fluidIcon, width, Math.min(16, hi - th));
+                }
+                GL11.glColor3f(1.0F, 1.0F, 1.0F);
+            }
+        }
+    }
+
+    public void update(int slot, IAEFluidStack aeFluidStack) {
+        cont.getTile().getFluidInventory().setFluidInSlot(slot, aeFluidStack);
+    }
+
+}

src/main/java/com/glodblock/github/client/gui/TankDumpable.java

@@ -0,0 +1,9 @@
+package com.glodblock.github.client.gui;
+
+public interface TankDumpable {
+
+    boolean canDumpTank(int index);
+
+    void dumpTank(int index);
+
+}

src/main/java/com/glodblock/github/client/gui/container/ContainerIngredientBuffer.java

@@ -0,0 +1,64 @@
+package com.glodblock.github.client.gui.container;
+
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.container.AEBaseContainer;
+import appeng.container.slot.SlotNormal;
+import com.glodblock.github.FluidCraft;
+import com.glodblock.github.client.gui.TankDumpable;
+import com.glodblock.github.common.tile.TileIngredientBuffer;
+import com.glodblock.github.network.SPacketFluidUpdate;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.IInventory;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class ContainerIngredientBuffer extends AEBaseContainer implements TankDumpable {
+
+    private final TileIngredientBuffer tile;
+
+    public ContainerIngredientBuffer(InventoryPlayer ipl, TileIngredientBuffer tile) {
+        super(ipl, tile);
+        this.tile = tile;
+        IInventory inv = tile.getInternalInventory();
+        for (int i = 0; i < 9; i++) {
+            addSlotToContainer(new SlotNormal(inv, i, 8 + 18 * i, 108));
+        }
+        bindPlayerInventory(ipl, 0, 140);
+    }
+
+    public TileIngredientBuffer getTile() {
+        return tile;
+    }
+
+    @Override
+    public boolean canDumpTank(int index) {
+        return tile.getFluidInventory().getFluidInSlot(index) != null;
+    }
+
+    @Override
+    public void dumpTank(int index) {
+        if (index >= 0 && index < tile.getFluidInventory().getSlots()) {
+            tile.getFluidInventory().setFluidInSlot(index, null);
+        }
+    }
+
+    @Override
+    public void detectAndSendChanges()
+    {
+        super.detectAndSendChanges();
+        Map<Integer, IAEFluidStack> tmp = new HashMap<>();
+        for (int i = 0; i < tile.getFluidInventory().getSlots(); i ++) {
+            tmp.put(i, tile.getFluidInventory().getFluidInSlot(i));
+        }
+        for( final Object g : this.crafters )
+        {
+            if( g instanceof EntityPlayer)
+            {
+                FluidCraft.proxy.netHandler.sendTo(new SPacketFluidUpdate(tmp), (EntityPlayerMP) g);
+            }
+        }
+    }
+}

src/main/java/com/glodblock/github/common/block/BlockIngredientBuffer.java

@@ -0,0 +1,55 @@
+package com.glodblock.github.common.block;
+
+import appeng.block.AEBaseItemBlock;
+import com.glodblock.github.common.tile.TileIngredientBuffer;
+import com.glodblock.github.inventory.InventoryHandler;
+import com.glodblock.github.inventory.gui.GuiType;
+import com.glodblock.github.util.BlockPos;
+import com.glodblock.github.util.NameConst;
+import cpw.mods.fml.common.registry.GameRegistry;
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.world.World;
+
+public class BlockIngredientBuffer extends FCBaseBlock {
+
+    public BlockIngredientBuffer() {
+        super(Material.iron, NameConst.BLOCK_INGREDIENT_BUFFER);
+        setTileEntity(TileIngredientBuffer.class);
+        setOpaque(false);
+        setFullBlock(false);
+        this.lightOpacity = 4;
+    }
+
+    @Override
+    public boolean onActivated(World world, int x, int y, int z, EntityPlayer player, int facing, float hitX, float hitY, float hitZ) {
+        if (player.isSneaking()) {
+            return false;
+        }
+        TileIngredientBuffer tile = getTileEntity(world, x, y, z);
+        if (tile != null) {
+            if (!world.isRemote) {
+                InventoryHandler.openGui(player, world, new BlockPos(x, y, z), EnumFacing.getFront(facing), GuiType.INGREDIENT_BUFFER);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    public BlockIngredientBuffer register() {
+        GameRegistry.registerBlock(this, AEBaseItemBlock.class, NameConst.BLOCK_INGREDIENT_BUFFER);
+        GameRegistry.registerTileEntity(TileIngredientBuffer.class, NameConst.BLOCK_INGREDIENT_BUFFER);
+        return this;
+    }
+
+    public ItemStack stack(int size) {
+        return new ItemStack(this, size);
+    }
+
+    public ItemStack stack() {
+        return new ItemStack(this, 1);
+    }
+
+}

src/main/java/com/glodblock/github/common/tile/TileIngredientBuffer.java

@@ -0,0 +1,154 @@
+package com.glodblock.github.common.tile;
+
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.tile.AEBaseInvTile;
+import appeng.tile.TileEvent;
+import appeng.tile.events.TileEventType;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.InvOperation;
+import appeng.util.item.AEFluidStack;
+import com.glodblock.github.inventory.AEFluidInventory;
+import com.glodblock.github.inventory.IAEFluidInventory;
+import com.glodblock.github.inventory.IAEFluidTank;
+import cpw.mods.fml.common.network.ByteBufUtils;
+import io.netty.buffer.ByteBuf;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+import net.minecraftforge.fluids.IFluidHandler;
+
+import javax.annotation.Nonnull;
+import java.io.IOException;
+
+public class TileIngredientBuffer extends AEBaseInvTile implements IAEFluidInventory, IFluidHandler {
+
+    private final AppEngInternalInventory invItems = new AppEngInternalInventory(this, 9);
+    private final AEFluidInventory invFluids = new AEFluidInventory(this, 4, 64000);
+
+    @Nonnull
+    @Override
+    public IInventory getInternalInventory() {
+        return invItems;
+    }
+
+    public IAEFluidTank getFluidInventory() {
+        return invFluids;
+    }
+
+    @Override
+    public boolean canBeRotated() {
+        return false;
+    }
+
+    @Override
+    public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added) {
+        markForUpdate();
+    }
+
+    @Override
+    public int[] getAccessibleSlotsBySide(ForgeDirection whichSide) {
+        return new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8};
+    }
+
+    @Override
+    public void onFluidInventoryChanged(IAEFluidTank inv, int slot) {
+        saveChanges();
+        markForUpdate();
+    }
+
+    @TileEvent( TileEventType.NETWORK_WRITE )
+    protected void writeToStream(ByteBuf data) throws IOException {
+        for (int i = 0; i < invItems.getSizeInventory(); i++) {
+            ByteBufUtils.writeItemStack(data, invItems.getStackInSlot(i));
+        }
+        int fluidMask = 0;
+        for (int i = 0; i < invFluids.getSlots(); i++) {
+            if (invFluids.getFluidInSlot(i) != null) {
+                fluidMask |= 1 << i;
+            }
+        }
+        data.writeByte(fluidMask);
+        for (int i = 0; i < invFluids.getSlots(); i++) {
+            IAEFluidStack fluid = invFluids.getFluidInSlot(i);
+            if (fluid != null) {
+                fluid.writeToPacket(data);
+            }
+        }
+    }
+
+    @TileEvent( TileEventType.NETWORK_READ )
+    protected boolean readFromStream(ByteBuf data) throws IOException {
+        boolean changed = false;
+        for (int i = 0; i < invItems.getSizeInventory(); i++) {
+            ItemStack stack = ByteBufUtils.readItemStack(data);
+            if (!ItemStack.areItemStacksEqual(stack, invItems.getStackInSlot(i))) {
+                invItems.setInventorySlotContents(i, stack);
+                changed = true;
+            }
+        }
+        int fluidMask = data.readByte();
+        for (int i = 0; i < invFluids.getSlots(); i++) {
+            if ((fluidMask & (1 << i)) != 0) {
+                IAEFluidStack fluid = AEFluidStack.loadFluidStackFromPacket(data);
+                if (fluid != null) { // this shouldn't happen, but better safe than sorry
+                    IAEFluidStack origFluid = invFluids.getFluidInSlot(i);
+                    if (!fluid.equals(origFluid) || fluid.getStackSize() != origFluid.getStackSize()) {
+                        invFluids.setFluidInSlot(i, fluid);
+                        changed = true;
+                    }
+                }
+            } else if (invFluids.getFluidInSlot(i) != null) {
+                invFluids.setFluidInSlot(i, null);
+                changed = true;
+            }
+        }
+        return changed;
+    }
+
+    @TileEvent( TileEventType.WORLD_NBT_READ )
+    public void readFromNBTEvent(NBTTagCompound data) {
+        invItems.readFromNBT(data, "ItemInv");
+        invFluids.readFromNBT(data, "FluidInv");
+    }
+
+    @TileEvent( TileEventType.WORLD_NBT_WRITE )
+    public NBTTagCompound writeToNBTEvent(NBTTagCompound data) {
+        invItems.writeToNBT(data, "ItemInv");
+        invFluids.writeToNBT(data, "FluidInv");
+        return data;
+    }
+
+    @Override
+    public int fill(ForgeDirection from, FluidStack resource, boolean doFill) {
+        return invFluids.fill(from, resource, doFill);
+    }
+
+    @Override
+    public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) {
+        return invFluids.drain(from, resource, doDrain);
+    }
+
+    @Override
+    public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) {
+        return invFluids.drain(from, maxDrain, doDrain);
+    }
+
+    @Override
+    public boolean canFill(ForgeDirection from, Fluid fluid) {
+        return invFluids.canFill(from, fluid);
+    }
+
+    @Override
+    public boolean canDrain(ForgeDirection from, Fluid fluid) {
+        return invFluids.canDrain(from, fluid);
+    }
+
+    @Override
+    public FluidTankInfo[] getTankInfo(ForgeDirection from) {
+        return invFluids.getTankInfo(ForgeDirection.UNKNOWN);
+    }
+}

src/main/java/com/glodblock/github/inventory/AEFluidInventory.java

@@ -4,6 +4,7 @@ import appeng.api.storage.data.IAEFluidStack;
 import appeng.core.AELog;
 import appeng.util.Platform;
 import appeng.util.item.AEFluidStack;
+import com.glodblock.github.util.Util;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.fluids.Fluid;
@@ -334,7 +335,7 @@ public class AEFluidInventory implements IAEFluidTank
 
                 if( c != null )
                 {
-                    this.fluids[x] = AEFluidStack.loadFluidStackFromNBT( c );
+                    this.fluids[x] = Util.loadFluidStackFromNBT( c );
                 }
             }
             catch( final Exception e )

src/main/java/com/glodblock/github/inventory/AeStackInventoryImpl.java

@@ -6,6 +6,7 @@ import appeng.tile.inventory.IAEAppEngInventory;
 import appeng.util.item.AEFluidStack;
 import appeng.util.item.AEItemStack;
 import com.glodblock.github.util.ObjectArrayIterator;
+import com.glodblock.github.util.Util;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.nbt.NBTTagList;
 import net.minecraftforge.common.util.Constants;
@@ -90,7 +91,7 @@ public class AeStackInventoryImpl <T extends IAEStack<T>> implements AeStackInve
                 inv[i] = stackTag == null ? null : (T) AEItemStack.loadItemStackFromNBT(stackTag);
             }
             else {
-                inv[i] = stackTag == null ? null : (T) AEFluidStack.loadFluidStackFromNBT(stackTag);
+                inv[i] = stackTag == null ? null : (T) Util.loadFluidStackFromNBT(stackTag);
             }
         }
     }

src/main/java/com/glodblock/github/inventory/gui/ButtonMouseHandler.java

@@ -0,0 +1,47 @@
+package com.glodblock.github.inventory.gui;
+
+import com.glodblock.github.FluidCraft;
+import com.glodblock.github.client.gui.TankDumpable;
+import com.glodblock.github.network.CPacketDumpTank;
+import com.glodblock.github.util.NameConst;
+import net.minecraft.client.resources.I18n;
+
+import javax.annotation.Nullable;
+import java.util.Collections;
+import java.util.List;
+
+public class ButtonMouseHandler implements MouseRegionManager.Handler {
+
+    @Nullable
+    private final String tooltipKey;
+    private final Runnable callback;
+
+    public ButtonMouseHandler(@Nullable String tooltipKey, Runnable callback) {
+        this.tooltipKey = tooltipKey;
+        this.callback = callback;
+    }
+
+    @Nullable
+    @Override
+    public List<String> getTooltip() {
+        return tooltipKey != null ? Collections.singletonList(I18n.format(tooltipKey)) : null;
+    }
+
+    @Override
+    public boolean onClick(int button) {
+        if (button == 0) {
+            callback.run();
+            return true;
+        }
+        return false;
+    }
+
+    public static ButtonMouseHandler dumpTank(TankDumpable host, int index) {
+        return new ButtonMouseHandler(NameConst.TT_DUMP_TANK, () -> {
+            if (host.canDumpTank(index)) {
+                FluidCraft.proxy.netHandler.sendToServer(new CPacketDumpTank(index));
+            }
+        });
+    }
+
+}

src/main/java/com/glodblock/github/inventory/gui/GuiType.java

@@ -8,6 +8,7 @@ import com.glodblock.github.client.gui.container.*;
 import com.glodblock.github.common.parts.FCBasePart;
 import com.glodblock.github.common.tile.TileFluidPacketDecoder;
 import com.glodblock.github.common.tile.TileFluidPatternEncoder;
+import com.glodblock.github.common.tile.TileIngredientBuffer;
 import com.google.common.collect.ImmutableList;
 import net.minecraft.entity.player.EntityPlayer;
 
@@ -16,6 +17,18 @@ import java.util.List;
 
 public enum GuiType {
 
+    INGREDIENT_BUFFER(new TileGuiFactory<TileIngredientBuffer>(TileIngredientBuffer.class) {
+        @Override
+        protected Object createServerGui(EntityPlayer player, TileIngredientBuffer inv) {
+            return new ContainerIngredientBuffer(player.inventory, inv);
+        }
+
+        @Override
+        protected Object createClientGui(EntityPlayer player, TileIngredientBuffer inv) {
+            return new GuiIngredientBuffer(player.inventory, inv);
+        }
+    }),
+
     FLUID_PAT_TERM_CRAFTING_STATUS(new PartGuiFactory<FCBasePart>(FCBasePart.class) {
         @Override
         protected Object createServerGui(EntityPlayer player, FCBasePart inv) {

src/main/java/com/glodblock/github/inventory/gui/TankMouseHandler.java

@@ -0,0 +1,34 @@
+package com.glodblock.github.inventory.gui;
+
+import appeng.api.storage.data.IAEFluidStack;
+import com.glodblock.github.inventory.IAEFluidTank;
+import com.glodblock.github.util.NameConst;
+import net.minecraft.client.resources.I18n;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import javax.annotation.Nullable;
+import java.util.Arrays;
+import java.util.List;
+
+public class TankMouseHandler implements MouseRegionManager.Handler {
+
+    private final IAEFluidTank tank;
+    private final int index;
+
+    public TankMouseHandler(IAEFluidTank tank, int index) {
+        this.tank = tank;
+        this.index = index;
+    }
+
+    @Nullable
+    @Override
+    public List<String> getTooltip() {
+        IAEFluidStack fluid = tank.getFluidInSlot(index);
+        return Arrays.asList(
+            fluid != null ? fluid.getFluidStack().getLocalizedName() : I18n.format(NameConst.TT_EMPTY),
+            EnumChatFormatting.GRAY + String.format("%,d / %,d mB",
+                fluid != null ? fluid.getStackSize() : 0L, tank.getTankInfo(ForgeDirection.UNKNOWN)[index].capacity));
+    }
+
+}

src/main/java/com/glodblock/github/loader/ChannelLoader.java

@@ -18,5 +18,7 @@ public class ChannelLoader implements Runnable {
         FluidCraft.proxy.netHandler.registerMessage(new CPacketSwitchGuis.Handler(), CPacketSwitchGuis.class, id ++, Side.CLIENT);
         FluidCraft.proxy.netHandler.registerMessage(new SPacketFluidSlot.Handler(), SPacketFluidSlot.class, id ++, Side.SERVER);
         FluidCraft.proxy.netHandler.registerMessage(new CPacketTransferRecipe.Handler(), CPacketTransferRecipe.class, id ++, Side.SERVER);
+        FluidCraft.proxy.netHandler.registerMessage(new CPacketDumpTank.Handler(), CPacketDumpTank.class, id ++, Side.SERVER);
+        FluidCraft.proxy.netHandler.registerMessage(new SPacketFluidUpdate.Handler(), SPacketFluidUpdate.class, id ++, Side.CLIENT);
     }
 }

src/main/java/com/glodblock/github/loader/ItemAndBlockHolder.java

@@ -1,10 +1,7 @@
 package com.glodblock.github.loader;
 
 import com.glodblock.github.common.Config;
-import com.glodblock.github.common.block.BlockFluidDiscretizer;
-import com.glodblock.github.common.block.BlockFluidInterface;
-import com.glodblock.github.common.block.BlockFluidPacketDecoder;
-import com.glodblock.github.common.block.BlockFluidPatternEncoder;
+import com.glodblock.github.common.block.*;
 import com.glodblock.github.common.item.*;
 import com.glodblock.github.common.storage.CellType;
 
@@ -29,6 +26,7 @@ public class ItemAndBlockHolder {
     public static BlockFluidPatternEncoder ENCODER = new BlockFluidPatternEncoder().register();
     public static BlockFluidPacketDecoder DECODER = new BlockFluidPacketDecoder().register();
     public static BlockFluidInterface INTERFACE = new BlockFluidInterface().register();
+    public static BlockIngredientBuffer BUFFER = new BlockIngredientBuffer().register();
 
     public static void loadSetting() {
         if (!Config.fluidCells) return;

src/main/java/com/glodblock/github/loader/RecipeLoader.java

@@ -5,6 +5,7 @@ import com.glodblock.github.common.item.ItemBasicFluidStorageCell;
 import com.glodblock.github.common.storage.CellType;
 import cpw.mods.fml.common.registry.GameRegistry;
 import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.oredict.OreDictionary;
 import net.minecraftforge.oredict.ShapedOreRecipe;
@@ -27,6 +28,9 @@ public class RecipeLoader implements Runnable {
     public final static ItemStack AE2_QUARTZ_GLASS = GameRegistry.findItemStack("appliedenergistics2", "tile.BlockQuartzGlass", 1);
     public final static ItemStack AE2_LAMP_GLASS = GameRegistry.findItemStack("appliedenergistics2", "tile.BlockQuartzLamp", 1);
     public final static ItemStack AE2_CELL_HOUSING = new ItemStack(GameRegistry.findItem("appliedenergistics2", "item.ItemMultiMaterial"), 1, 39);
+    public final static ItemStack AE2_CELL_1K = new ItemStack(GameRegistry.findItem("appliedenergistics2", "item.ItemMultiMaterial"), 1, 35);
+    public final static ItemStack AE2_CORE_ANN = new ItemStack(GameRegistry.findItem("appliedenergistics2", "item.ItemMultiMaterial"), 1, 44);
+    public final static ItemStack AE2_CORE_FOM = new ItemStack(GameRegistry.findItem("appliedenergistics2", "item.ItemMultiMaterial"), 1, 43);
 
     @Override
     public void run() {
@@ -38,6 +42,7 @@ public class RecipeLoader implements Runnable {
         GameRegistry.addRecipe(new ShapedOreRecipe(ENCODER.stack(), "LPL", "IWI", "III", 'I', "ingotIron", 'L', "blockLapis", 'P', AE2_PROCESS_ENG, 'W', AE2_WORK_BENCH));
         GameRegistry.addShapelessRecipe(FLUID_TERMINAL.stack(), AE2_PATTERN_TERM, ENCODER);
         GameRegistry.addShapelessRecipe(FLUID_TERMINAL_EX.stack(), FLUID_TERMINAL.stack(), AE2_PROCESS_CAL, AE2_PROCESS_ENG, AE2_PROCESS_LOG);
+        GameRegistry.addRecipe(new ShapedOreRecipe(BUFFER.stack(), "ILI", "AGF", "IBI", 'I', "ingotIron", 'G', AE2_QUARTZ_GLASS, 'L', AE2_CELL_1K, 'A', AE2_CORE_ANN, 'F', AE2_CORE_FOM, 'B', Items.bucket));
 
         if (Config.fluidCells) {
             OreDictionary.registerOre("anyCertusCrystal", AE2_PURE_CERTUS);

src/main/java/com/glodblock/github/network/CPacketDumpTank.java

@@ -0,0 +1,48 @@
+package com.glodblock.github.network;
+
+import com.glodblock.github.client.gui.TankDumpable;
+import cpw.mods.fml.common.network.simpleimpl.IMessage;
+import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
+import cpw.mods.fml.common.network.simpleimpl.MessageContext;
+import io.netty.buffer.ByteBuf;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+import javax.annotation.Nullable;
+
+public class CPacketDumpTank implements IMessage {
+
+    private int index;
+
+    public CPacketDumpTank(int index) {
+        this.index = index;
+    }
+
+    public CPacketDumpTank() {
+        // NO-OP
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        buf.writeShort(index);
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+        index = buf.readShort();
+    }
+
+    public static class Handler implements IMessageHandler<CPacketDumpTank, IMessage> {
+
+        @Nullable
+        @Override
+        public IMessage onMessage(CPacketDumpTank message, MessageContext ctx) {
+            EntityPlayerMP player = ctx.getServerHandler().playerEntity;
+            if (player.openContainer instanceof TankDumpable) {
+                ((TankDumpable)player.openContainer).dumpTank(message.index);
+            }
+            return null;
+        }
+
+    }
+
+}

src/main/java/com/glodblock/github/network/SPacketFluidUpdate.java

@@ -0,0 +1,81 @@
+package com.glodblock.github.network;
+
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.util.item.AEFluidStack;
+import com.glodblock.github.client.gui.GuiIngredientBuffer;
+import cpw.mods.fml.common.network.simpleimpl.IMessage;
+import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
+import cpw.mods.fml.common.network.simpleimpl.MessageContext;
+import io.netty.buffer.ByteBuf;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiScreen;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+public class SPacketFluidUpdate implements IMessage {
+
+    private Map<Integer, IAEFluidStack> list;
+
+    public SPacketFluidUpdate() {
+    }
+
+    public SPacketFluidUpdate(Map<Integer, IAEFluidStack> data) {
+        this.list = data;
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+        int size = buf.readInt();
+        this.list = new HashMap<>();
+        try {
+            for (int i = 0; i < size; i ++) {
+                int id = buf.readInt();
+                boolean isNull = buf.readBoolean();
+                if (!isNull)
+                    list.put(id, null);
+                else {
+                    IAEFluidStack fluid = AEFluidStack.loadFluidStackFromPacket(buf);
+                    list.put(id, fluid);
+                }
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        buf.writeInt(list.size());
+        try {
+            for (Map.Entry<Integer, IAEFluidStack> fs : list.entrySet()) {
+                buf.writeInt(fs.getKey());
+                if (fs.getValue() == null)
+                    buf.writeBoolean(false);
+                else {
+                    buf.writeBoolean(true);
+                    fs.getValue().writeToPacket(buf);
+                }
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static class Handler implements IMessageHandler<SPacketFluidUpdate, IMessage> {
+
+        @Override
+        public IMessage onMessage(SPacketFluidUpdate message, MessageContext ctx) {
+            final GuiScreen gs = Minecraft.getMinecraft().currentScreen;
+            if( gs instanceof GuiIngredientBuffer)
+            {
+                for (Map.Entry<Integer, IAEFluidStack> e : message.list.entrySet() ) {
+                    ( (GuiIngredientBuffer) gs ).update(e.getKey(), e.getValue());
+                }
+            }
+            return null;
+        }
+
+    }
+}

src/main/java/com/glodblock/github/util/NameConst.java

@@ -8,6 +8,7 @@ public class NameConst {
     public static final String BLOCK_FLUID_PATTERN_ENCODER = "fluid_pattern_encoder";
     public static final String BLOCK_FLUID_PACKET_DECODER = "fluid_packet_decoder";
     public static final String BLOCK_FLUID_INTERFACE = "fluid_interface";
+    public static final String BLOCK_INGREDIENT_BUFFER = "ingredient_buffer";
 
     public static final String ITEM_FLUID_DROP = "fluid_drop";
     public static final String ITEM_FLUID_ENCODED_PATTERN = "fluid_encoded_pattern";
@@ -22,6 +23,8 @@ public class NameConst {
     public static final String TT_INVALID_FLUID = TT_KEY + "invalid_fluid";
     public static final String TT_FLUID_PACKET = TT_KEY + "fluid_packet";
     public static final String TT_ENCODE_PATTERN = TT_KEY + "encode_pattern";
+    public static final String TT_EMPTY = TT_KEY + "empty";
+    public static final String TT_DUMP_TANK = TT_KEY + "dump_tank";
 
     public static final String RES_KEY = FluidCraft.MODID + ":";
 
@@ -30,5 +33,6 @@ public class NameConst {
     public static final String GUI_FLUID_PATTERN_TERMINAL_EX = GUI_KEY + ITEM_PART_FLUID_PATTERN_TERMINAL_EX;
     public static final String GUI_FLUID_PATTERN_ENCODER = GUI_KEY + BLOCK_FLUID_PATTERN_ENCODER;
     public static final String GUI_FLUID_PACKET_DECODER = GUI_KEY + BLOCK_FLUID_PACKET_DECODER;
+    public static final String GUI_INGREDIENT_BUFFER = GUI_KEY + BLOCK_INGREDIENT_BUFFER;
 
 }

src/main/java/com/glodblock/github/util/Util.java

@@ -6,14 +6,15 @@ import appeng.api.networking.IGridHost;
 import appeng.api.networking.IGridNode;
 import appeng.api.networking.security.ISecurityGrid;
 import appeng.api.parts.IPart;
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.util.item.AEFluidStack;
 import com.glodblock.github.common.item.ItemFluidPacket;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.EnumFacing;
 import net.minecraftforge.common.util.ForgeDirection;
-import net.minecraftforge.fluids.FluidContainerRegistry;
-import net.minecraftforge.fluids.FluidStack;
-import net.minecraftforge.fluids.IFluidContainerItem;
+import net.minecraftforge.fluids.*;
 
 public final class Util {
 
@@ -104,4 +105,15 @@ public final class Util {
         return null;
     }
 
+    public static IAEFluidStack loadFluidStackFromNBT( final NBTTagCompound i )
+    {
+        //Fuck ae2
+        final FluidStack t = FluidRegistry.getFluidStack(i.getString("FluidName"), 1);
+        final AEFluidStack fluid = AEFluidStack.create( t );
+        fluid.setStackSize( i.getLong( "Cnt" ) );
+        fluid.setCountRequestable( i.getLong( "Req" ) );
+        fluid.setCraftable( i.getBoolean( "Craft" ) );
+        return fluid;
+    }
+
 }