1st commit

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

@@ -9,18 +9,18 @@ import com.glodblock.github.client.gui.container.ContainerPatternValueAmount;
 import com.glodblock.github.common.item.ItemWirelessUltraTerminal;
 import com.glodblock.github.common.parts.PartFluidPatternTerminal;
 import com.glodblock.github.common.parts.PartFluidPatternTerminalEx;
+import com.glodblock.github.common.tile.TileSuperStoker;
 import com.glodblock.github.inventory.gui.GuiType;
 import com.glodblock.github.inventory.item.IWirelessTerminal;
 import com.glodblock.github.inventory.item.WirelessPatternTerminalInventory;
 import com.glodblock.github.loader.ItemAndBlockHolder;
 import com.glodblock.github.network.CPacketPatternValueSet;
 
-import appeng.api.storage.ITerminalHost;
 import appeng.core.localization.GuiText;
 
 public class GuiPatternValueAmount extends FCGuiAmount {
 
-    public GuiPatternValueAmount(final InventoryPlayer inventoryPlayer, final ITerminalHost te) {
+    public GuiPatternValueAmount(final InventoryPlayer inventoryPlayer, final Object te) {
         super(new ContainerPatternValueAmount(inventoryPlayer, te));
     }
 
@@ -77,6 +77,9 @@ public class GuiPatternValueAmount extends FCGuiAmount {
         } else if (target instanceof WirelessPatternTerminalInventory) {
             this.myIcon = ItemAndBlockHolder.WIRELESS_PATTERN_TERM.stack();
             this.originalGui = GuiType.WIRELESS_FLUID_PATTERN_TERMINAL;
+        } else if (target instanceof TileSuperStoker) {
+            this.myIcon = ItemAndBlockHolder.SUPER_STOKER.stack();
+            this.originalGui = GuiType.GUI_SUPER_STOKER;
         }
     }
 

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

@@ -0,0 +1,127 @@
+package com.glodblock.github.client.gui;
+
+import appeng.api.storage.data.IAEStack;
+import appeng.util.Platform;
+import appeng.util.item.AEStack;
+import com.glodblock.github.client.gui.container.ContainerFluidAutoFiller;
+import com.glodblock.github.common.item.ItemFluidPacket;
+import com.glodblock.github.inventory.slot.OptionalFluidSlotFake;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+
+import org.lwjgl.opengl.GL11;
+
+import com.glodblock.github.FluidCraft;
+import com.glodblock.github.client.gui.container.ContainerSuperStoker;
+import com.glodblock.github.common.tile.TileSuperStoker;
+import com.glodblock.github.network.CPacketInventoryAction;
+
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.client.gui.AEBaseGui;
+import appeng.container.AEBaseContainer;
+import appeng.container.slot.SlotFake;
+import appeng.core.localization.GuiText;
+import appeng.helpers.InventoryAction;
+import appeng.util.item.AEItemStack;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+
+public class GuiSuperStoker extends AEBaseGui {
+
+    private static final ResourceLocation TEX_BG = FluidCraft.resource("textures/gui/superStoker.png");
+    private final ContainerSuperStoker cont;
+    private final TileSuperStoker tile;
+    private Map<Integer, IAEStack<?>> list = new HashMap<>();
+
+    public GuiSuperStoker(InventoryPlayer ipl, TileSuperStoker tile) {
+        super(new ContainerSuperStoker(ipl, tile));
+        this.tile = tile;
+        this.cont = (ContainerSuperStoker) inventorySlots;
+        this.ySize = 251;
+        this.xSize = 216;
+    }
+
+    @Override
+    protected void handleMouseClick(Slot slot, int slotIdx, int ctrlDown, int mouseButton) {
+        if (mouseButton == 3) {
+            if (slot instanceof SlotFake) {
+                if (slot.getHasStack()) {
+                    InventoryAction action = InventoryAction.SET_PATTERN_VALUE;
+                    IAEItemStack stack = AEItemStack.create(slot.getStack());
+                    ((AEBaseContainer) this.inventorySlots).setTargetStack(stack);
+                    for (int i = 0; i < this.inventorySlots.inventorySlots.size(); i++) {
+                        if (slot.equals(this.inventorySlots.inventorySlots.get(i))) {
+                            FluidCraft.proxy.netHandler.sendToServer(new CPacketInventoryAction(action, i, 0, stack));
+                        }
+                    }
+                    return;
+                }
+            }
+        }
+        super.handleMouseClick(slot, slotIdx, ctrlDown, mouseButton);
+    }
+
+    @Override
+    public void func_146977_a(Slot s) {
+        if (s instanceof SlotFake) {
+            this.drawFillStatus(s);
+        }
+        super.func_146977_a(s);
+    }
+
+    private void drawFillStatus(Slot slotIn) {
+        int offsetX = slotIn.xDisplayPosition - 8;
+        int offsetY = slotIn.yDisplayPosition - 11;
+        ItemStack itemstack = slotIn.getStack();
+        int slotInt = slotIn.slotNumber;
+        if (itemstack != null) {
+            String s = "0%";
+            if (slotInt > 0 && slotInt < 9) {
+                IAEStack<?> aeStack = list.get(slotInt - 1);
+                if (aeStack != null) s = (int) (((float) aeStack.getStackSize() / ItemFluidPacket.getFluidAmount(itemstack)) * 100) + "%";
+            } else if (slotInt > 9 && slotInt < 73){
+                IAEStack<?> aeStack = list.get(slotInt + 90);
+                if (aeStack != null && itemstack.stackSize > 0) {
+                    long i = aeStack.getStackSize();
+                    s = (int) (((float) i / itemstack.stackSize) * 100) + "%";
+                }
+            }
+
+            float scale = 0.5f;
+            float shiftX = 2;
+            float shiftY = 1;
+            final float inverseScaleFactor = 1.0f / scale;
+
+            final int X = (int) (((float) offsetX - shiftX
+                + 16.0f
+                + 1.0f
+                - this.fontRendererObj.getStringWidth(s) * scale) * inverseScaleFactor);
+            final int Y = (int) (((float) offsetY - shiftY + 16.0f - 7.0f * scale) * inverseScaleFactor);
+            GL11.glTranslatef(0.0f, 0.0f, 200.0f);
+            GL11.glScaled(scale, scale, scale);
+            this.fontRendererObj.drawStringWithShadow(s, X, Y, 16777215);
+            GL11.glScaled(inverseScaleFactor, inverseScaleFactor, inverseScaleFactor);
+            GL11.glTranslatef(0.0f, 0.0f, -200.0f);
+        }
+    }
+
+    @Override
+    public void drawFG(int offsetX, int offsetY, int mouseX, int mouseY) {
+        fontRendererObj.drawString(GuiText.inventory.getLocal(), 8, ySize - 94, 0x404040);
+    }
+
+    @Override
+    public void drawBG(int offsetX, int offsetY, int mouseX, int mouseY) {
+        this.bindTexture(TEX_BG);
+        this.drawTexturedModalRect(offsetX, offsetY, 0, 0, xSize, ySize);
+    }
+
+    public void update(Map<Integer, IAEStack<?>> map) {
+        this.list = map;
+    }
+}

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

@@ -4,7 +4,6 @@ import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.inventory.Slot;
 
 import appeng.api.config.SecurityPermissions;
-import appeng.api.storage.ITerminalHost;
 import appeng.container.AEBaseContainer;
 import appeng.container.guisync.GuiSync;
 import appeng.container.slot.SlotInaccessible;
@@ -17,7 +16,7 @@ public class ContainerPatternValueAmount extends AEBaseContainer {
     @GuiSync(11)
     public int valueIndex;
 
-    public ContainerPatternValueAmount(final InventoryPlayer ip, final ITerminalHost te) {
+    public ContainerPatternValueAmount(final InventoryPlayer ip, final Object te) {
         super(ip, te);
         this.patternValue = new SlotInaccessible(new AppEngInternalInventory(null, 1), 0, 34, 53);
         this.addSlotToContainer(patternValue);

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

@@ -0,0 +1,144 @@
+package com.glodblock.github.client.gui.container;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import appeng.api.storage.data.IAEStack;
+import com.glodblock.github.network.SPacketSuperStokerUpdate;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
+
+import com.glodblock.github.FluidCraft;
+import com.glodblock.github.common.item.ItemBasicFluidStorageCell;
+import com.glodblock.github.common.item.ItemFluidPacket;
+import com.glodblock.github.common.tile.TileSuperStoker;
+import com.glodblock.github.inventory.slot.OptionalFluidSlotFake;
+import com.glodblock.github.network.SPacketFluidUpdate;
+
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.container.AEBaseContainer;
+import appeng.container.slot.IOptionalSlotHost;
+import appeng.container.slot.SlotPatternOutputs;
+import appeng.container.slot.SlotRestrictedInput;
+import appeng.items.storage.ItemBasicStorageCell;
+import appeng.util.item.AEFluidStack;
+
+public class ContainerSuperStoker extends AEBaseContainer implements IOptionalSlotHost {
+
+    private final TileSuperStoker tile;
+    private IInventory configFluids;
+    private IInventory configItems;
+    private Map<Integer, IAEStack<?>> list;
+
+    public ContainerSuperStoker(InventoryPlayer ipl, TileSuperStoker tile) {
+        super(ipl, tile);
+        this.tile = tile;
+        configFluids = tile.getConfigFluid();
+        configItems = tile.getConfigItems();
+        final IInventory cell = tile.getCell();
+
+        final int x = 8;
+        final int fy = 8;
+
+        this.addSlotToContainer(
+                new SlotRestrictedInput(
+                        SlotRestrictedInput.PlacableItemType.WORKBENCH_CELL,
+                        cell,
+                        0,
+                        173,
+                        fy,
+                        this.getInventoryPlayer()));
+
+        for (int i = 0; i < 9; i++) {
+            addSlotToContainer(new OptionalFluidSlotFake(configFluids, this, i, x, fy, i, 0, 0));
+        }
+
+        final int io = 29;
+        for (int y = 0; y < 7; y++) {
+            for (int ix = 0; ix < 9; ix++) {
+                this.addSlotToContainer(new SlotPatternOutputs(configItems, this, y * 9 + ix, x, io, ix, y, y));
+            }
+        }
+
+        bindPlayerInventory(ipl, 0, 251 - 82);
+    }
+
+    @Override
+    public ItemStack slotClick(int slotId, int clickedButton, int mode, EntityPlayer player) {
+        if (slotId == 0 && player.inventory.getItemStack() == null && isConfigurated()) {
+            return null;
+        }
+        return super.slotClick(slotId, clickedButton, mode, player);
+    }
+
+    @Override
+    public boolean isSlotEnabled(int idx) {
+        return true;
+    }
+
+    @Override
+    public void detectAndSendChanges() {
+        super.detectAndSendChanges();
+        Map<Integer, IAEStack<?>> tmp = new HashMap<>();
+        for (int i = 0; i < tile.getInternalFluid().getSlots(); i++) {
+            tmp.put(i, tile.getInternalFluid().getFluidInSlot(i));
+        }
+        for (int i = 0; i < tile.getInternalInventory().getSizeInventory(); i++) {
+            tmp.put(
+                    i + 100,
+                    tile.getInternalAEInventory().getAEStackInSlot(i));
+        }
+        for (final Object g : this.crafters) {
+            if (g instanceof EntityPlayer) {
+                FluidCraft.proxy.netHandler.sendTo(new SPacketSuperStokerUpdate(tmp), (EntityPlayerMP) g);
+            }
+        }
+    }
+
+    private boolean isConfigurated() {
+        for (int i = 0; i < configItems.getSizeInventory(); i++) {
+            if (configItems.getStackInSlot(i) != null) {
+                return true;
+            }
+        }
+        for (int i = 0; i < configFluids.getSizeInventory(); i++) {
+            if (configFluids.getStackInSlot(i) != null) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean isValidForSlot(Slot s, ItemStack is) {
+        if (s.slotNumber == 0 && s.getHasStack() && isConfigurated()) {
+            long currentBytes = 0;
+            long newBytes = 0;
+
+            if (s.getStack().getItem() instanceof ItemBasicStorageCell ibsc) {
+                currentBytes = ibsc.getBytesLong(is);
+            } else if (s.getStack().getItem() instanceof ItemBasicFluidStorageCell ibfsc) {
+                currentBytes = ibfsc.getBytes(is);
+            }
+
+            if (is.getItem() instanceof ItemBasicStorageCell ibsc) {
+                newBytes = ibsc.getBytesLong(is);
+            } else if (is.getItem() instanceof ItemBasicFluidStorageCell ibfsc) {
+                newBytes = ibfsc.getBytes(is);
+            }
+
+            if (currentBytes > newBytes) {
+                return false;
+            }
+        }
+        return super.isValidForSlot(s, is);
+    }
+
+    public TileSuperStoker getTile() {
+        return tile;
+    }
+}

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

@@ -0,0 +1,69 @@
+package com.glodblock.github.common.block;
+
+import appeng.tile.crafting.TileCraftingTile;
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import com.glodblock.github.common.tabs.FluidCraftingTabs;
+import com.glodblock.github.common.tile.TileSuperStoker;
+import com.glodblock.github.inventory.InventoryHandler;
+import com.glodblock.github.inventory.gui.GuiType;
+import com.glodblock.github.util.BlockPos;
+
+import appeng.block.AEBaseItemBlock;
+import cpw.mods.fml.common.registry.GameRegistry;
+
+import java.util.ArrayList;
+
+public class BlockSuperStoker extends FCBaseBlock {
+
+    public BlockSuperStoker() {
+        super(Material.iron, "SuperStoker");
+        setTileEntity(TileSuperStoker.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;
+        }
+        TileSuperStoker tile = getTileEntity(world, x, y, z);
+        if (tile != null) {
+            if (!world.isRemote) {
+                InventoryHandler.openGui(
+                        player,
+                        world,
+                        new BlockPos(x, y, z),
+                        ForgeDirection.getOrientation(facing),
+                        GuiType.GUI_SUPER_STOKER);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void breakBlock(World w, int x, int y, int z, Block a, int b) {
+        final TileSuperStoker tss = this.getTileEntity(w, x, y, z);
+        if (tss != null) {
+            tss.fullRefund();
+        }
+        super.breakBlock(w, x, y, z, a, b);
+    }
+
+    @Override
+    public BlockSuperStoker register() {
+        GameRegistry.registerBlock(this, AEBaseItemBlock.class, "SuperStoker");
+        GameRegistry.registerTileEntity(TileSuperStoker.class, "SuperStoker");
+        setCreativeTab(FluidCraftingTabs.INSTANCE);
+        return this;
+    }
+}

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

@@ -0,0 +1,438 @@
+package com.glodblock.github.common.tile;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.stream.IntStream;
+
+import javax.annotation.Nonnull;
+
+import appeng.tile.inventory.AppEngInternalAEInventory;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+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 com.glodblock.github.common.item.ItemBasicFluidStorageCell;
+import com.glodblock.github.common.item.ItemFluidPacket;
+import com.glodblock.github.inventory.AEFluidInventory;
+import com.glodblock.github.inventory.IAEFluidInventory;
+import com.glodblock.github.inventory.IAEFluidTank;
+
+import appeng.api.config.Actionable;
+import appeng.api.config.PowerMultiplier;
+import appeng.api.implementations.IPowerChannelState;
+import appeng.api.networking.GridFlags;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.events.MENetworkBootingStatusChange;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.events.MENetworkPowerStatusChange;
+import appeng.api.networking.security.BaseActionSource;
+import appeng.api.networking.security.MachineSource;
+import appeng.api.networking.ticking.IGridTickable;
+import appeng.api.networking.ticking.TickRateModulation;
+import appeng.api.networking.ticking.TickingRequest;
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.api.util.AECableType;
+import appeng.api.util.DimensionalCoord;
+import appeng.items.storage.ItemBasicStorageCell;
+import appeng.me.GridAccessException;
+import appeng.tile.TileEvent;
+import appeng.tile.events.TileEventType;
+import appeng.tile.grid.AENetworkInvTile;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.InvOperation;
+import appeng.util.item.AEFluidStack;
+import appeng.util.item.AEItemStack;
+import cpw.mods.fml.common.network.ByteBufUtils;
+import io.netty.buffer.ByteBuf;
+
+public class TileSuperStoker extends AENetworkInvTile
+        implements IAEFluidInventory, IFluidHandler, IPowerChannelState, IGridTickable {
+
+    private final AppEngInternalInventory cell = new AppEngInternalInventory(this, 1);
+    private final AppEngInternalAEInventory invItems = new AppEngInternalAEInventory(this, 63);
+    private final AEFluidInventory invFluids = new AEFluidInventory(this, 9, Long.MAX_VALUE);
+    private final AppEngInternalAEInventory configFluids = new AppEngInternalAEInventory(this, 9);
+    private final AppEngInternalAEInventory configItems = new AppEngInternalAEInventory(this, 63);
+    private final BaseActionSource source;
+    private boolean isPowered;
+    private long totalBytes;
+    private long storedFluidCount;
+    private long storedItemCount;
+
+    public TileSuperStoker() {
+        getProxy().setIdlePowerUsage(2D);
+        getProxy().setFlags(GridFlags.REQUIRE_CHANNEL);
+        this.source = new MachineSource(this);
+    }
+
+    private TickRateModulation doWork() {
+        for (int i = 0; i < 9; i++) {
+            IAEFluidStack invFluid = invFluids.getFluidInSlot(i);
+            IAEItemStack configFluid = configFluids.getAEStackInSlot(i);
+            if (configFluid != null) {
+                IAEFluidStack fs = AEFluidStack.create(ItemFluidPacket.getFluidStack(configFluid));
+                if (invFluid == null) requestFluid(fs, i);
+                else if (invFluid.equals(fs)) {
+                    if (invFluid.getStackSize() < fs.getStackSize() / 2) {
+                        fs.setStackSize(fs.getStackSize() - invFluid.getStackSize());
+                        requestFluid(fs, i);
+                    } else if (invFluid.getStackSize() > fs.getStackSize()) {
+                        returnFluid(i, invFluid.getStackSize() - fs.getStackSize());
+                    }
+                } else {
+                    returnFluid(i, Long.MAX_VALUE);
+                }
+            } else if (invFluid != null) {
+                returnFluid(i, Long.MAX_VALUE);
+            }
+        }
+
+        for (int i = 0; i < 63; i++) {
+            IAEItemStack invItem = invItems.getAEStackInSlot(i);
+            IAEItemStack configItem = configItems.getAEStackInSlot(i);
+
+            if (configItem != null) {
+                IAEItemStack is = configItem.copy();
+                if (invItem == null) requestItem(is, i);
+                else if (invItem.getItem() == is.getItem()) {
+                    if (invItem.getStackSize() < is.getStackSize() / 2) {
+                        is.setStackSize(is.getStackSize() - invItem.getStackSize());
+                        requestItem(is, i);
+                    } else if (invItem.getStackSize() > is.getStackSize()) {
+                        returnItem(i, invItem.getStackSize() - is.getStackSize());
+                    }
+                } else {
+                    returnItem(i, Long.MAX_VALUE);
+                }
+            } else if (invItem != null) {
+                returnItem(i, Long.MAX_VALUE);
+            }
+        }
+        return TickRateModulation.SAME;
+    }
+
+    private void returnFluid(int index, long amount) {
+        try {
+            IAEFluidStack ias = invFluids.drain(index, amount, true);
+            storedFluidCount -= ias.getStackSize();
+            IAEFluidStack notInserted = this.getProxy().getStorage().getFluidInventory()
+                    .injectItems(ias, Actionable.MODULATE, this.source);
+            if (notInserted != null) {
+                invFluids.fill(index, notInserted, true);
+                storedFluidCount += ias.getStackSize();
+            }
+        } catch (final GridAccessException ignored) {}
+    }
+
+    private void requestFluid(IAEFluidStack fs, int index) {
+        if (getRemainingFluidCount() == 0) return;
+        try {
+            long remFluid = getRemainingFluidCount();
+            if (fs.getStackSize() > remFluid) fs.setStackSize(remFluid);
+            IAEFluidStack extracted = this.getProxy().getStorage().getFluidInventory()
+                    .extractItems(fs, Actionable.MODULATE, this.source);
+            if (extracted != null) {
+                storedFluidCount += extracted.getStackSize();
+                invFluids.fill(index, extracted, true);
+            }
+        } catch (final GridAccessException ignored) {}
+    }
+
+    private void returnItem(int index, long amount) {
+        try {
+            IAEItemStack ias = invItems.getAEStackInSlot(index);
+            if (amount != Long.MAX_VALUE) {
+                ias.decStackSize(amount);
+                ias = ias.copy();
+                ias.setStackSize(amount);
+            } else {
+                amount = ias.getStackSize();
+                invItems.setInventorySlotContents(index, null);
+            }
+            storedItemCount -= amount;
+            IAEItemStack notInserted = this.getProxy().getStorage().getItemInventory()
+                    .injectItems(ias, Actionable.MODULATE, this.source);
+            if (notInserted != null) {
+                invItems.setInventorySlotContents(index, notInserted.getItemStack());
+                invItems.getAEStackInSlot(index).setStackSize(notInserted.getStackSize());
+                storedItemCount += notInserted.getStackSize();
+            }
+        } catch (final GridAccessException ignored) {}
+    }
+
+    private void requestItem(IAEItemStack is, int index) {
+        if (getRemainingItemCount() == 0) return;
+        try {
+            long remItem = getRemainingItemCount();
+            if (is.getStackSize() > remItem) is.setStackSize(remItem);
+            IAEItemStack extracted = this.getProxy().getStorage().getItemInventory()
+                    .extractItems(is, Actionable.MODULATE, this.source);
+            if (extracted != null) {
+                if (invItems.getAEStackInSlot(index) != null) invItems.getAEStackInSlot(index).add(extracted);
+                else { invItems.setInventorySlotContents(index, extracted.getItemStack()); invItems.getAEStackInSlot(index).setStackSize(extracted.getStackSize()); }
+                storedItemCount += extracted.getStackSize();
+            }
+        } catch (final GridAccessException ignored) {}
+    }
+
+    @Override
+    public int[] getAccessibleSlotsBySide(ForgeDirection whichSide) {
+        return IntStream.rangeClosed(0, 62).toArray();
+    }
+
+    @Nonnull
+    @Override
+    public IInventory getInternalInventory() {
+        return invItems;
+    }
+
+    public AppEngInternalAEInventory getInternalAEInventory() {
+        return invItems;
+    }
+
+    public AppEngInternalAEInventory getConfigFluid() {
+        return configFluids;
+    }
+
+    public AppEngInternalAEInventory getConfigItems() {
+        return configItems;
+    }
+
+    public AppEngInternalInventory getCell() {
+        return cell;
+    }
+
+    public long getFreeBytes() {
+        return totalBytes - (((storedItemCount + getUnusedItemCount()) / 8) + ((storedFluidCount + getUnusedFluidCount()) / 2048));
+    }
+
+    public long getRemainingFluidCount() {
+        final double remaining = (double) getFreeBytes() * 2048 + this.getUnusedFluidCount();
+        if (remaining > Long.MAX_VALUE) return Long.MAX_VALUE;
+        return remaining > 0 ? (long) remaining : 0;
+    }
+
+    public int getUnusedFluidCount() {
+        final int div = (int) (storedFluidCount % 2048);
+        if (div == 0) {
+            return 0;
+        }
+        return 2048 - div;
+    }
+
+    public long getRemainingItemCount() {
+        final long remaining = getFreeBytes() * 8 + this.getUnusedItemCount();
+
+        return remaining > 0 ? remaining : 0;
+    }
+
+    public int getUnusedItemCount() {
+        final long div = storedItemCount % 8;
+
+        if (div == 0) {
+            return 0;
+        }
+
+        return (int) (8 - div);
+    }
+
+    @Override
+    public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added) {
+        switch (mc) {
+            case setInventorySlotContents -> {
+                if (inv == cell) {
+                    if (added.getItem() instanceof ItemBasicStorageCell ibsc) {
+                        totalBytes = ibsc.getBytesLong(added);
+                    } else if (added.getItem() instanceof ItemBasicFluidStorageCell ibfsc) {
+                        totalBytes = ibfsc.getBytes(added);
+                    }
+                }
+            }
+            case decreaseStackSize -> {
+                if (inv == cell) totalBytes = 0;
+                if (inv == invItems && invItems.getAEStackInSlot(slot) != null) invItems.getAEStackInSlot(slot).decStackSize(removed.stackSize);
+            }
+            case markDirty -> {
+
+            }
+        }
+        markForUpdate();
+    }
+
+    public void fullRefund() {
+        for (int i = 0; i < 9; i++) {
+            if ( invFluids.getFluidStackInSlot(i) != null) {
+                returnFluid(i, Integer.MAX_VALUE);
+            }
+        }
+
+        for (int i = 0; i < 63; i++) {
+            if (invItems.getAEStackInSlot(i) != null) {
+                returnItem(i, Integer.MAX_VALUE);
+            }
+        }
+    }
+
+    @Override
+    public void getDrops(World w, int x, int y, int z, List<ItemStack> drops) {
+        for (int i = 0; i < 9; i++) {
+           ItemStack ifp = ItemFluidPacket.newStack(invFluids.getFluidStackInSlot(i));
+           if (ifp != null) drops.add(ifp);
+        }
+        super.getDrops(w, x, y, z, drops);
+    }
+
+    @Override
+    public boolean canInsertItem(int slotIndex, ItemStack insertingItem, int side) {
+        return false;
+    }
+
+    @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 false;
+    }
+
+    @Override
+    public boolean canDrain(ForgeDirection from, Fluid fluid) {
+        return invFluids.canDrain(from, fluid);
+    }
+
+    @Override
+    public FluidTankInfo[] getTankInfo(ForgeDirection from) {
+        return invFluids.getTankInfo(from);
+    }
+
+    @Override
+    public void onFluidInventoryChanged(IAEFluidTank inv, int slot) {
+        saveChanges();
+        markForUpdate();
+    }
+
+    @Override
+    public AEFluidInventory getInternalFluid() {
+        return this.invFluids;
+    }
+
+    @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));
+        }
+        this.invFluids.writeToBuf(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;
+            }
+        }
+        changed |= this.invFluids.readFromBuf(data);
+        return changed;
+    }
+
+    @TileEvent(TileEventType.WORLD_NBT_READ)
+    public void readFromNBTEvent(NBTTagCompound data) {
+        invItems.readFromNBT(data, "ItemInv");
+        invFluids.readFromNBT(data, "FluidInv");
+        configItems.readFromNBT(data, "configItems");
+        configFluids.readFromNBT(data, "configFluids");
+        cell.readFromNBT(data, "cellHolder");
+        totalBytes = data.getLong("totalBytes");
+        storedFluidCount = data.getLong("storedFluidCount");
+        storedItemCount = data.getLong("storedItemCount");
+    }
+
+    @TileEvent(TileEventType.WORLD_NBT_WRITE)
+    public NBTTagCompound writeToNBTEvent(NBTTagCompound data) {
+        invItems.writeToNBT(data, "ItemInv");
+        invFluids.writeToNBT(data, "FluidInv");
+        configItems.writeToNBT(data, "configItems");
+        configFluids.writeToNBT(data, "configFluids");
+        cell.writeToNBT(data, "cellHolder");
+        data.setLong("totalBytes", totalBytes);
+        data.setLong("storedFluidCount", storedFluidCount);
+        data.setLong("storedItemCount", storedItemCount);
+        return data;
+    }
+
+    @MENetworkEventSubscribe
+    public void stateChange(final MENetworkPowerStatusChange p) {
+        this.updatePowerState();
+    }
+
+    @MENetworkEventSubscribe
+    public final void bootingRender(final MENetworkBootingStatusChange c) {
+        this.updatePowerState();
+    }
+
+    @Override
+    public boolean isPowered() {
+        return this.isPowered;
+    }
+
+    @Override
+    public boolean isActive() {
+        return this.isPowered;
+    }
+
+    private void updatePowerState() {
+        boolean newState = false;
+        try {
+            newState = this.getProxy().isActive()
+                    && this.getProxy().getEnergy().extractAEPower(1, Actionable.SIMULATE, PowerMultiplier.CONFIG)
+                            > 0.0001;
+        } catch (final GridAccessException ignored) {}
+        if (newState != this.isPowered) {
+            this.isPowered = newState;
+            this.markForUpdate();
+        }
+    }
+
+    @Override
+    public DimensionalCoord getLocation() {
+        return new DimensionalCoord(this);
+    }
+
+    @Override
+    public AECableType getCableConnectionType(ForgeDirection dir) {
+        return AECableType.SMART;
+    }
+
+    @Override
+    public TickingRequest getTickingRequest(IGridNode node) {
+        return new TickingRequest(120, 120, false, false);
+    }
+
+    @Override
+    public TickRateModulation tickingRequest(IGridNode node, int TicksSinceLastCall) {
+        return doWork();
+    }
+}

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

@@ -22,12 +22,21 @@ public class AEFluidInventory implements IAEFluidTank {
     private final IAEFluidStack[] fluids;
     private final IAEFluidInventory handler;
     private final int capacity;
+    private final long capacityLong;
     public int lastIndex;
 
     public AEFluidInventory(final IAEFluidInventory handler, final int slots, final int capcity) {
         this.fluids = new IAEFluidStack[slots];
         this.handler = handler;
         this.capacity = capcity;
+        this.capacityLong = capcity;
+    }
+
+    public AEFluidInventory(final IAEFluidInventory handler, final int slots, final long capcity) {
+        this.fluids = new IAEFluidStack[slots];
+        this.handler = handler;
+        this.capacity = Integer.MAX_VALUE;
+        this.capacityLong = capcity;
     }
 
     public AEFluidInventory(final IAEFluidInventory handler, final int slots) {
@@ -122,6 +131,37 @@ public class AEFluidInventory implements IAEFluidTank {
         return amountToStore;
     }
 
+    public long fill(final int slot, final IAEFluidStack resource, final boolean doFill) {
+        if (resource == null || resource.getStackSize() <= 0) {
+            return 0;
+        }
+
+        final IAEFluidStack fluid = this.fluids[slot];
+
+        if (fluid != null && !(fluid.getFluid() == resource.getFluid())) {
+            return 0;
+        }
+
+        long amountToStore = this.capacityLong;
+
+        if (fluid != null) {
+            amountToStore -= fluid.getStackSize();
+        }
+
+        amountToStore = Math.min(amountToStore, resource.getStackSize());
+
+        if (doFill) {
+            if (fluid == null) {
+                this.setFluidInSlot(slot, resource);
+            } else {
+                fluid.setStackSize(fluid.getStackSize() + amountToStore);
+                this.onContentChanged(slot);
+            }
+        }
+
+        return amountToStore;
+    }
+
     public FluidStack drain(final int slot, final FluidStack resource, final boolean doDrain) {
         final IAEFluidStack fluid = this.fluids[slot];
         if (fluid == null || !fluid.getFluidStack().isFluidEqual(resource)) {
@@ -152,6 +192,28 @@ public class AEFluidInventory implements IAEFluidTank {
         return stack;
     }
 
+    public IAEFluidStack drain(final int slot, final long maxDrain, boolean doDrain) {
+        final IAEFluidStack fluid = this.fluids[slot];
+        if (fluid == null || maxDrain <= 0) {
+            return null;
+        }
+
+        long drained = maxDrain;
+        if (fluid.getStackSize() < drained) {
+            drained = fluid.getStackSize();
+        }
+
+        IAEFluidStack stack = fluid.copy().setStackSize(drained);
+        if (doDrain) {
+            fluid.setStackSize(fluid.getStackSize() - drained);
+            if (fluid.getStackSize() <= 0) {
+                this.fluids[slot] = null;
+            }
+            this.onContentChanged(slot);
+        }
+        return stack;
+    }
+
     @Override
     public int fill(ForgeDirection from, final FluidStack fluid, final boolean doFill) {
         if (fluid == null || fluid.amount <= 0) {

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

@@ -5,6 +5,7 @@ import java.util.List;
 import javax.annotation.Nullable;
 
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.tileentity.TileEntity;
 
 import com.glodblock.github.client.gui.GuiCraftingStatus;
 import com.glodblock.github.client.gui.GuiDualInterface;
@@ -37,6 +38,7 @@ import com.glodblock.github.client.gui.GuiOCPatternEditor;
 import com.glodblock.github.client.gui.GuiPatternMulti;
 import com.glodblock.github.client.gui.GuiPatternValueAmount;
 import com.glodblock.github.client.gui.GuiRenamer;
+import com.glodblock.github.client.gui.GuiSuperStoker;
 import com.glodblock.github.client.gui.container.ContainerCraftingWireless;
 import com.glodblock.github.client.gui.container.ContainerDualInterface;
 import com.glodblock.github.client.gui.container.ContainerEssentiaMonitor;
@@ -65,6 +67,7 @@ import com.glodblock.github.client.gui.container.ContainerOCPatternEditor;
 import com.glodblock.github.client.gui.container.ContainerPatternMulti;
 import com.glodblock.github.client.gui.container.ContainerPatternValueAmount;
 import com.glodblock.github.client.gui.container.ContainerRenamer;
+import com.glodblock.github.client.gui.container.ContainerSuperStoker;
 import com.glodblock.github.common.parts.PartFluidLevelEmitter;
 import com.glodblock.github.common.parts.PartFluidStorageBus;
 import com.glodblock.github.common.parts.base.FCPart;
@@ -76,6 +79,7 @@ import com.glodblock.github.common.tile.TileIngredientBuffer;
 import com.glodblock.github.common.tile.TileLargeIngredientBuffer;
 import com.glodblock.github.common.tile.TileLevelMaintainer;
 import com.glodblock.github.common.tile.TileOCPatternEditor;
+import com.glodblock.github.common.tile.TileSuperStoker;
 import com.glodblock.github.inventory.IDualHost;
 import com.glodblock.github.inventory.item.IFluidPortableCell;
 import com.glodblock.github.inventory.item.IWirelessTerminal;
@@ -515,6 +519,18 @@ public enum GuiType {
             return new GuiPatternValueAmount(player.inventory, inv);
         }
     }),
+    PATTERN_VALUE_SET_TILE(new TileGuiFactory<>(TileEntity.class) {
+
+        @Override
+        protected Object createServerGui(EntityPlayer player, TileEntity inv) {
+            return new ContainerPatternValueAmount(player.inventory, inv);
+        }
+
+        @Override
+        protected Object createClientGui(EntityPlayer player, TileEntity inv) {
+            return new GuiPatternValueAmount(player.inventory, inv);
+        }
+    }),
 
     GUI_PATTERN_MULTI(new PartOrItemGuiFactory<>(ITerminalHost.class) {
 
@@ -527,6 +543,19 @@ public enum GuiType {
         protected Object createClientGui(EntityPlayer player, ITerminalHost inv) {
             return new GuiPatternMulti(player.inventory, inv);
         }
+    }),
+
+    GUI_SUPER_STOKER(new TileGuiFactory<>(TileSuperStoker.class) {
+
+        @Override
+        protected Object createServerGui(EntityPlayer player, TileSuperStoker inv) {
+            return new ContainerSuperStoker(player.inventory, inv);
+        }
+
+        @Override
+        protected Object createClientGui(EntityPlayer player, TileSuperStoker inv) {
+            return new GuiSuperStoker(player.inventory, inv);
+        }
     });
 
     public static final List<GuiType> VALUES = ImmutableList.copyOf(values());

src/main/java/com/glodblock/github/inventory/slot/OptionalFluidSlotFake.java

@@ -0,0 +1,28 @@
+package com.glodblock.github.inventory.slot;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+import com.glodblock.github.common.item.ItemFluidPacket;
+import com.glodblock.github.util.Util;
+
+import appeng.container.slot.IOptionalSlotHost;
+import appeng.container.slot.OptionalSlotFake;
+
+public class OptionalFluidSlotFake extends OptionalSlotFake {
+
+    public OptionalFluidSlotFake(final IInventory inv, final IOptionalSlotHost containerBus, final int idx, final int x,
+            final int y, final int offX, final int offY, final int groupNum) {
+        super(inv, containerBus, idx, x, y, offX, offY, groupNum);
+    }
+
+    @Override
+    public void putStack(ItemStack is) {
+        if (is == null) super.putStack(null);
+        FluidStack fluidStack = Util.getFluidFromItem(is);
+        if (fluidStack != null) {
+            super.putStack(ItemFluidPacket.newStack(fluidStack));
+        }
+    }
+}

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

@@ -1,5 +1,6 @@
 package com.glodblock.github.loader;
 
+import com.glodblock.github.network.SPacketSuperStokerUpdate;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.network.Packet;
 import net.minecraft.world.World;
@@ -59,6 +60,7 @@ public class ChannelLoader implements Runnable {
         netHandler.registerMessage(new CPacketTransferRecipe.Handler(), CPacketTransferRecipe.class, id++, Side.SERVER);
         netHandler.registerMessage(new CPacketDumpTank.Handler(), CPacketDumpTank.class, id++, Side.SERVER);
         netHandler.registerMessage(new SPacketFluidUpdate.Handler(), SPacketFluidUpdate.class, id++, Side.CLIENT);
+        netHandler.registerMessage(new SPacketSuperStokerUpdate.Handler(), SPacketSuperStokerUpdate.class, id++, Side.CLIENT);
         netHandler
                 .registerMessage(new CPacketPatternValueSet.Handler(), CPacketPatternValueSet.class, id++, Side.SERVER);
         netHandler.registerMessage(new CPacketValueConfig.Handler(), CPacketValueConfig.class, id++, Side.SERVER);

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

@@ -14,6 +14,7 @@ import com.glodblock.github.common.block.BlockIngredientBuffer;
 import com.glodblock.github.common.block.BlockLargeIngredientBuffer;
 import com.glodblock.github.common.block.BlockLevelMaintainer;
 import com.glodblock.github.common.block.BlockOCPatternEditor;
+import com.glodblock.github.common.block.BlockSuperStoker;
 import com.glodblock.github.common.block.BlockWalrus;
 import com.glodblock.github.common.item.ItemBasicFluidStorageCell;
 import com.glodblock.github.common.item.ItemBasicFluidStoragePart;
@@ -65,6 +66,7 @@ public class ItemAndBlockHolder {
     public static BlockLargeIngredientBuffer LARGE_BUFFER = new BlockLargeIngredientBuffer().register();
     public static BlockOCPatternEditor OC_EDITOR = new BlockOCPatternEditor().register();
     public static BlockWalrus WALRUS = new BlockWalrus().register();
+    public static BlockSuperStoker SUPER_STOKER = new BlockSuperStoker().register();
     public static ItemFluidDrop DROP = new ItemFluidDrop().register();
     public static ItemFluidEncodedPattern PATTERN = new ItemFluidEncodedPattern().register();
     public static ItemPartFluidTerminal FLUID_TERM = new ItemPartFluidTerminal().register();

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

@@ -25,6 +25,7 @@ import appeng.container.AEBaseContainer;
 import appeng.container.ContainerOpenContext;
 import appeng.container.implementations.ContainerCraftAmount;
 import appeng.helpers.InventoryAction;
+import appeng.tile.networking.TileCableBus;
 import appeng.util.item.AEItemStack;
 import cpw.mods.fml.common.network.simpleimpl.IMessage;
 import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
@@ -130,12 +131,21 @@ public class CPacketInventoryAction implements IMessage {
                     if (context != null && message.stack != null) {
                         final TileEntity te = context.getTile();
                         if (te != null) {
-                            InventoryHandler.openGui(
+                            if (te instanceof TileCableBus) {
+                                InventoryHandler.openGui(
                                     sender,
                                     te.getWorldObj(),
                                     new BlockPos(te),
                                     Objects.requireNonNull(baseContainer.getOpenContext().getSide()),
                                     GuiType.PATTERN_VALUE_SET);
+                            } else {
+                                InventoryHandler.openGui(
+                                    sender,
+                                    te.getWorldObj(),
+                                    new BlockPos(te),
+                                    Objects.requireNonNull(baseContainer.getOpenContext().getSide()),
+                                    GuiType.PATTERN_VALUE_SET_TILE);
+                            }
                         } else if (target instanceof IWirelessTerminal wt) {
                             InventoryHandler.openGui(
                                     sender,

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

@@ -9,6 +9,7 @@ import net.minecraft.tileentity.TileEntity;
 import net.minecraftforge.fluids.FluidStack;
 
 import com.glodblock.github.client.gui.container.ContainerPatternValueAmount;
+import com.glodblock.github.client.gui.container.ContainerSuperStoker;
 import com.glodblock.github.client.gui.container.base.FCContainerEncodeTerminal;
 import com.glodblock.github.common.item.ItemFluidPacket;
 import com.glodblock.github.inventory.InventoryHandler;
@@ -92,7 +93,8 @@ public class CPacketPatternValueSet implements IMessage {
                                     Objects.requireNonNull(context.getSide()),
                                     message.originGui);
                         }
-                        if (player.openContainer instanceof FCContainerEncodeTerminal) {
+                        if (player.openContainer instanceof FCContainerEncodeTerminal
+                                || player.openContainer instanceof ContainerSuperStoker) {
                             Slot slot = player.openContainer.getSlot(message.valueIndex);
                             if (slot instanceof SlotFake) {
                                 ItemStack stack = slot.getStack().copy();

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

@@ -0,0 +1,71 @@
+package com.glodblock.github.network;
+
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.api.storage.data.IAEStack;
+import appeng.util.Platform;
+import appeng.util.item.AEItemStack;
+import appeng.util.item.AEStack;
+import com.glodblock.github.client.gui.GuiEssentiaTerminal;
+import com.glodblock.github.client.gui.GuiFluidIO;
+import com.glodblock.github.client.gui.GuiFluidInterface;
+import com.glodblock.github.client.gui.GuiFluidLevelEmitter;
+import com.glodblock.github.client.gui.GuiFluidStorageBus;
+import com.glodblock.github.client.gui.GuiFluidTerminal;
+import com.glodblock.github.client.gui.GuiIngredientBuffer;
+import com.glodblock.github.client.gui.GuiLargeIngredientBuffer;
+import com.glodblock.github.client.gui.GuiSuperStoker;
+import com.glodblock.github.util.Util;
+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 net.minecraft.item.ItemStack;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+public class SPacketSuperStokerUpdate implements IMessage {
+
+    private Map<Integer, IAEStack<?>> list;
+
+    public SPacketSuperStokerUpdate() {}
+
+    public SPacketSuperStokerUpdate(Map<Integer, IAEStack<?>> data) {
+        this.list = data;
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+        this.list = new HashMap<>();
+        try {
+            Util.readAEStackMapFromBuf(this.list, buf);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        try {
+            Util.writeAEStackMapToBuf(this.list, buf);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static class Handler implements IMessageHandler<SPacketSuperStokerUpdate, IMessage> {
+
+        @Override
+        public IMessage onMessage(SPacketSuperStokerUpdate message, MessageContext ctx) {
+            final GuiScreen gs = Minecraft.getMinecraft().currentScreen;
+            if (gs instanceof GuiSuperStoker gss) {
+                gss.update(message.list);
+            }
+            return null;
+        }
+    }
+}

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

@@ -9,6 +9,9 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
+import appeng.api.storage.data.IAEStack;
+import appeng.util.item.AEItemStack;
+import appeng.util.item.AEStack;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.init.Items;
@@ -382,6 +385,36 @@ public final class Util {
         }
     }
 
+    public static void writeAEStackMapToBuf(Map<Integer, IAEStack<?>> list, ByteBuf buf) throws IOException {
+        buf.writeInt(list.size());
+        for (Map.Entry<Integer, IAEStack<?>> as : list.entrySet()) {
+            buf.writeInt(as.getKey());
+            if (as.getValue() == null) buf.writeBoolean(false);
+            else {
+                buf.writeBoolean(true);
+                as.getValue().writeToPacket(buf);
+            }
+        }
+    }
+
+    public static void readAEStackMapFromBuf(Map<Integer, IAEStack<?>> list, ByteBuf buf) throws IOException {
+        int size = buf.readInt();
+        for (int i = 0; i < size; i++) {
+            int id = buf.readInt();
+            boolean isNull = buf.readBoolean();
+            if (!isNull) list.put(id, null);
+            else {
+                IAEStack<?> as;
+                if (id > 99) {
+                    as = AEItemStack.loadItemStackFromPacket(buf);
+                } else {
+                    as = AEFluidStack.loadFluidStackFromPacket(buf);
+                }
+                list.put(id, as);
+            }
+        }
+    }
+
     public static class GuiHelper {
 
         public enum GuiType {