Renew Replenisher (#435)

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

@@ -1,101 +1,105 @@
 package com.glodblock.github.client.gui;
 
+import java.text.DecimalFormat;
 import java.util.HashMap;
 import java.util.Map;
 
 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.ContainerSuperStockReplenisher;
-import com.glodblock.github.common.item.ItemFluidPacket;
 import com.glodblock.github.common.tile.TileSuperStockReplenisher;
 
 import appeng.api.storage.StorageName;
-import appeng.api.storage.data.IAEItemStack;
 import appeng.api.storage.data.IAEStack;
+import appeng.api.storage.data.IAEStackType;
 import appeng.client.gui.AEBaseGui;
-import appeng.container.AEBaseContainer;
-import appeng.container.slot.SlotFake;
+import appeng.client.gui.slots.VirtualMEPhantomSlot;
+import appeng.client.gui.slots.VirtualMEPhantomSlotPrecise;
 import appeng.core.localization.GuiText;
-import appeng.core.sync.GuiBridge;
-import appeng.core.sync.network.NetworkHandler;
-import appeng.core.sync.packets.PacketSwitchGuis;
-import appeng.core.sync.packets.PacketVirtualSlot;
-import appeng.util.item.AEItemStack;
+import appeng.util.item.AEFluidStackType;
+import appeng.util.item.AEItemStackType;
 
 public class GuiSuperStockReplenisher extends AEBaseGui {
 
     private static final ResourceLocation TEX_BG = FluidCraft.resource("textures/gui/superStockReplenisher.png");
+    private final DecimalFormat df = new DecimalFormat("#.#");
     private Map<Integer, IAEStack<?>> list = new HashMap<>();
+    private final ContainerSuperStockReplenisher containerSuperStockReplenisher;
+
+    private final VirtualMEPhantomSlotPrecise[] configFluidsSlots = new VirtualMEPhantomSlotPrecise[9];
+    private final VirtualMEPhantomSlotPrecise[] configItemsSlots = new VirtualMEPhantomSlotPrecise[63];
 
     public GuiSuperStockReplenisher(InventoryPlayer ipl, TileSuperStockReplenisher tile) {
         super(new ContainerSuperStockReplenisher(ipl, tile));
+
+        this.containerSuperStockReplenisher = (ContainerSuperStockReplenisher) 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()) {
-                    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))) {
-                            NetworkHandler.instance
-                                    .sendToServer(new PacketSwitchGuis(GuiBridge.GUI_PATTERN_VALUE_AMOUNT));
-                            NetworkHandler.instance
-                                    .sendToServer(new PacketVirtualSlot(StorageName.CRAFTING_INPUT, i, stack));
-                        }
-                    }
-                    return;
-                }
+    public void initGui() {
+        super.initGui();
+        this.initSlots();
+    }
+
+    private void initSlots() {
+
+        final int xo = 8;
+        final int yo = 8;
+
+        for (int i = 0; i < 9; i++) {
+            VirtualMEPhantomSlotPrecise slot = new VirtualMEPhantomSlotPrecise(
+                    xo + i * 18,
+                    yo,
+                    this.containerSuperStockReplenisher.configFluidsSlots,
+                    i,
+                    this::acceptType);
+            this.configFluidsSlots[i] = slot;
+            this.registerVirtualSlots(slot);
+        }
+
+        final int iyo = 29;
+        for (int y = 0; y < 7; y++) {
+            for (int ix = 0; ix < 9; ix++) {
+                VirtualMEPhantomSlotPrecise slot = new VirtualMEPhantomSlotPrecise(
+                        xo + ix * 18,
+                        iyo + y * 18,
+                        this.containerSuperStockReplenisher.configItemsSlots,
+                        y * 9 + ix,
+                        this::acceptType);
+                this.configItemsSlots[y * 9 + ix] = slot;
+                this.registerVirtualSlots(slot);
             }
         }
-        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(VirtualMEPhantomSlotPrecise virtualSlot) {
+        final int offsetX = virtualSlot.getX() - 8;
+        final int offsetY = virtualSlot.getY() - 12;
+        final IAEStack<?> aes = virtualSlot.getAEStack();
+        final long stackSize = aes != null ? aes.getStackSize() : 0;
+        final int slotIndex = virtualSlot.getStorageName() == StorageName.NONE ? virtualSlot.getSlotIndex()
+                : virtualSlot.getSlotIndex() + 100;
 
-    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) {
+        if (stackSize != 0) {
             String s = "0%";
-            if (slotInt > 0 && slotInt < 10) {
-                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) + "%";
-                }
-            }
+            IAEStack<?> aeStack = list.get(slotIndex);
+
+            if (aeStack != null) s = df.format((float) aeStack.getStackSize() / 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 + 10.0f) * inverseScaleFactor);
-            final int Y = (int) (((float) offsetY - shiftY + 16.0f - 7.0f * scale) * inverseScaleFactor);
+            final int X = (int) (((float) offsetX - shiftX + 10.0f) * inverseScaleFactor) + 1;
+            final int Y = (int) (((float) offsetY - shiftY + 16.0f - 7.0f * scale) * inverseScaleFactor) + 2;
             GL11.glTranslatef(0.0f, 0.0f, 200.0f);
             GL11.glScaled(scale, scale, scale);
             this.fontRendererObj.drawStringWithShadow(s, X, Y, 16777215);
@@ -104,9 +108,15 @@ public class GuiSuperStockReplenisher extends AEBaseGui {
         }
     }
 
+    private void drawVirtualSlots() {
+        for (VirtualMEPhantomSlotPrecise slot : this.configFluidsSlots) this.drawFillStatus(slot);
+        for (VirtualMEPhantomSlotPrecise slot : this.configItemsSlots) this.drawFillStatus(slot);
+    }
+
     @Override
     public void drawFG(int offsetX, int offsetY, int mouseX, int mouseY) {
         fontRendererObj.drawString(GuiText.inventory.getLocal(), 8, ySize - 94, 0x404040);
+        this.drawVirtualSlots();
     }
 
     @Override
@@ -118,4 +128,9 @@ public class GuiSuperStockReplenisher extends AEBaseGui {
     public void update(Map<Integer, IAEStack<?>> map) {
         this.list = map;
     }
+
+    private boolean acceptType(VirtualMEPhantomSlot slot, IAEStackType<?> type, int mouseButton) {
+        if (slot.getStorageName() == StorageName.NONE) return type == AEFluidStackType.FLUID_STACK_TYPE;
+        else return type == AEItemStackType.ITEM_STACK_TYPE;
+    }
 }

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

@@ -3,63 +3,57 @@ package com.glodblock.github.client.gui.container;
 import java.util.HashMap;
 import java.util.Map;
 
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.GuiScreen;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.ICrafting;
 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.FCBaseItemCell;
-import com.glodblock.github.common.item.ItemFluidPacket;
 import com.glodblock.github.common.tile.TileSuperStockReplenisher;
 import com.glodblock.github.inventory.gui.GuiType;
-import com.glodblock.github.inventory.slot.OptionalFluidSlotFake;
 import com.glodblock.github.loader.ItemAndBlockHolder;
 import com.glodblock.github.network.SPacketSuperStockReplenisherUpdate;
 import com.glodblock.github.util.FluidPrimaryGui;
 
 import appeng.api.storage.StorageName;
-import appeng.api.storage.data.IAEItemStack;
 import appeng.api.storage.data.IAEStack;
-import appeng.client.gui.implementations.GuiPatternItemRenamer;
-import appeng.client.gui.implementations.GuiPatternValueAmount;
 import appeng.container.AEBaseContainer;
 import appeng.container.ContainerOpenContext;
 import appeng.container.PrimaryGui;
-import appeng.container.interfaces.IVirtualSlotHolder;
 import appeng.container.interfaces.IVirtualSlotSource;
-import appeng.container.slot.IOptionalSlotHost;
-import appeng.container.slot.SlotPatternOutputs;
 import appeng.container.slot.SlotRestrictedInput;
-import appeng.core.sync.network.NetworkHandler;
-import appeng.core.sync.packets.PacketVirtualSlot;
+import appeng.container.sync.SyncManager;
+import appeng.container.sync.handlers.AEStackInventorySyncHandler;
 import appeng.items.storage.ItemBasicStorageCell;
+import appeng.tile.inventory.IAEStackInventory;
 import appeng.util.Platform;
 import appeng.util.item.AEItemStack;
-import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 
-public class ContainerSuperStockReplenisher extends AEBaseContainer
-        implements IOptionalSlotHost, IVirtualSlotHolder, IVirtualSlotSource {
+public class ContainerSuperStockReplenisher extends AEBaseContainer implements IVirtualSlotSource {
 
     private final TileSuperStockReplenisher tile;
-    private final IInventory configFluids;
-    private final IInventory configItems;
-    private int lastUpdated = 0;
+
+    private int lastUpdated = 1337;
+
+    private final IAEStackInventory configFluids;
+    public final AEStackInventorySyncHandler configFluidsSlots;
+
+    private final IAEStackInventory configItems;
+    public final AEStackInventorySyncHandler configItemsSlots;
 
     public ContainerSuperStockReplenisher(InventoryPlayer ipl, TileSuperStockReplenisher tile) {
         super(ipl, tile);
         this.tile = tile;
-        configFluids = tile.getConfigFluid();
-        configItems = tile.getConfigItems();
+        this.configFluids = tile.getConfigFluids();
+        this.configItems = tile.getConfigItems();
         final IInventory cell = tile.getCell();
 
-        final int x = 8;
-        final int fy = 8;
+        final SyncManager sm = this.getSyncManager();
+        this.configFluidsSlots = sm.root().aeStackInventory("fluidConfig", this.configFluids);
+        this.configItemsSlots = sm.root().aeStackInventory("itemConfig", this.configItems);
 
         this.addSlotToContainer(
                 new SlotRestrictedInput(
@@ -67,56 +61,33 @@ public class ContainerSuperStockReplenisher extends AEBaseContainer
                         cell,
                         0,
                         173,
-                        fy,
+                        8,
                         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;
-        }
+        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 addCraftingToCrafters(ICrafting p_75132_1_) {
-        super.addCraftingToCrafters(p_75132_1_);
-        lastUpdated = 24;
-    }
-
     @Override
     public void detectAndSendChanges() {
         super.detectAndSendChanges();
+        if (Platform.isClient()) return;
 
-        if (lastUpdated > 20) {
-            lastUpdated = 0;
+        if (this.lastUpdated > 20) {
+            this.lastUpdated = 0;
             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 < this.tile.getInternalFluid().getSlots(); i++) {
+                tmp.put(i, this.tile.getInternalFluid().getFluidInSlot(i));
             }
 
-            for (int i = 0; i < tile.getInternalInventory().getSizeInventory(); i++) {
-                tmp.put(i + 100, AEItemStack.create(tile.getInternalInventory().getStackInSlot(i)));
+            for (int i = 0; i < this.tile.getInternalInventory().getSizeInventory(); i++) {
+                tmp.put(i + 100, AEItemStack.create(this.tile.getInternalInventory().getStackInSlot(i)));
             }
 
             for (final Object g : this.crafters) {
@@ -125,20 +96,16 @@ public class ContainerSuperStockReplenisher extends AEBaseContainer
                 }
             }
         }
-        lastUpdated++;
+
+        this.lastUpdated++;
     }
 
     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;
-            }
-        }
+        for (int i = 0; i < this.configItems.getSizeInventory(); i++)
+            if (this.configItems.getAEStackInSlot(i) != null) return true;
+
+        for (int i = 0; i < this.configFluids.getSizeInventory(); i++)
+            if (this.configFluids.getAEStackInSlot(i) != null) return true;
         return false;
     }
 
@@ -167,10 +134,6 @@ public class ContainerSuperStockReplenisher extends AEBaseContainer
         return super.isValidForSlot(s, is);
     }
 
-    public TileSuperStockReplenisher getTile() {
-        return tile;
-    }
-
     @Override
     public PrimaryGui createPrimaryGui() {
         ContainerOpenContext context = getOpenContext();
@@ -181,40 +144,18 @@ public class ContainerSuperStockReplenisher extends AEBaseContainer
                 context.getSide());
     }
 
-    @Override
-    public void receiveSlotStacks(StorageName invName, Int2ObjectMap<IAEStack<?>> slotStacks) {
-        var entry = slotStacks.int2ObjectEntrySet().iterator().next();
-        IAEStack<?> aes = entry.getValue();
-        int slotIndex = entry.getIntKey();
-
-        if (Platform.isServer()) {
-            for (ICrafting crafter : this.crafters) {
-                final EntityPlayerMP emp = (EntityPlayerMP) crafter;
-                NetworkHandler.instance.sendTo(new PacketVirtualSlot(invName, slotIndex, aes), emp);
-            }
-        } else {
-            final GuiScreen gs = Minecraft.getMinecraft().currentScreen;
-            if (gs instanceof GuiPatternValueAmount gpva) {
-                gpva.update();
-            } else if (gs instanceof GuiPatternItemRenamer gpir) {
-                gpir.update();
-            }
-        }
-    }
-
     @Override
     public void updateVirtualSlot(StorageName invName, int slotId, IAEStack<?> aes) {
-        if (aes instanceof IAEItemStack ais) {
-            ItemStack newIs;
-            if (ais.getItem() instanceof ItemFluidPacket) {
-                newIs = ais.getItemStack();
-                newIs.stackSize = 1;
-                ItemFluidPacket.setFluidAmount(newIs, aes.getStackSize());
-            } else {
-                newIs = ais.getItemStack();
+        if (aes != null && aes.getStackSize() > Integer.MAX_VALUE) aes.setStackSize(Integer.MAX_VALUE);
+        switch (invName) {
+            case NONE -> {
+                this.configFluids.putAEStackInSlot(slotId, aes);
+                this.configFluidsSlots.markDirty();
+            }
+            case CONFIG -> {
+                this.configItems.putAEStackInSlot(slotId, aes);
+                this.configItemsSlots.markDirty();
             }
-            this.inventorySlots.get(slotId).putStack(newIs);
         }
     }
-
 }

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

@@ -1,6 +1,5 @@
 package com.glodblock.github.common.block;
 
-import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.world.World;
@@ -47,15 +46,6 @@ public class BlockSuperStockReplenisher extends FCBaseBlock {
         return false;
     }
 
-    @Override
-    public void breakBlock(World w, int x, int y, int z, Block a, int b) {
-        final TileSuperStockReplenisher tss = this.getTileEntity(w, x, y, z);
-        if (tss != null) {
-            tss.fullRefund();
-        }
-        super.breakBlock(w, x, y, z, a, b);
-    }
-
     @Override
     public BlockSuperStockReplenisher register() {
         GameRegistry.registerBlock(this, AEBaseItemBlock.class, NameConst.BLOCK_SUPER_STOCK_REPLENISHER);

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

@@ -15,12 +15,16 @@ import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.fluids.FluidTankInfo;
 import net.minecraftforge.fluids.IFluidHandler;
 
+import org.jetbrains.annotations.Nullable;
+
 import com.glodblock.github.common.item.FCBaseItemCell;
 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 com.gtnewhorizon.gtnhlib.item.ItemStackNBT;
 
+import appeng.api.AEApi;
 import appeng.api.config.Actionable;
 import appeng.api.config.PowerMultiplier;
 import appeng.api.implementations.IPowerChannelState;
@@ -36,8 +40,10 @@ import appeng.api.networking.ticking.TickRateModulation;
 import appeng.api.networking.ticking.TickingRequest;
 import appeng.api.storage.IMEMonitor;
 import appeng.api.storage.ITerminalHost;
+import appeng.api.storage.StorageName;
 import appeng.api.storage.data.IAEFluidStack;
 import appeng.api.storage.data.IAEItemStack;
+import appeng.api.storage.data.IAEStack;
 import appeng.api.util.AECableType;
 import appeng.api.util.DimensionalCoord;
 import appeng.api.util.IConfigManager;
@@ -47,28 +53,48 @@ import appeng.me.GridAccessException;
 import appeng.tile.TileEvent;
 import appeng.tile.events.TileEventType;
 import appeng.tile.grid.AENetworkInvTile;
-import appeng.tile.inventory.AppEngInternalAEInventory;
 import appeng.tile.inventory.AppEngInternalInventory;
 import appeng.tile.inventory.BiggerAppEngInventory;
+import appeng.tile.inventory.IAEStackInventory;
+import appeng.tile.inventory.IIAEStackInventory;
 import appeng.tile.inventory.InvOperation;
+import appeng.util.Platform;
 import appeng.util.item.AEFluidStack;
 import appeng.util.item.AEItemStack;
 import io.netty.buffer.ByteBuf;
 
-public class TileSuperStockReplenisher extends AENetworkInvTile
-        implements IAEFluidInventory, IFluidHandler, IPowerChannelState, IGridTickable, ITerminalHost {
+public class TileSuperStockReplenisher extends AENetworkInvTile implements IAEFluidInventory, IFluidHandler,
+        IPowerChannelState, IGridTickable, ITerminalHost, IIAEStackInventory {
 
     private final AppEngInternalInventory cell = new AppEngInternalInventory(this, 1);
     private final BiggerAppEngInventory invItems = new BiggerAppEngInventory(this, 63);
     private final AEFluidInventory invFluids = new AEFluidInventory(this, 9, Integer.MAX_VALUE);
-    private final AppEngInternalAEInventory configFluids = new AppEngInternalAEInventory(this, 9);
-    private final AppEngInternalAEInventory configItems = new AppEngInternalAEInventory(this, 63);
+    private final IAEStackInventory configFluids = new IAEStackInventory(this, 9, StorageName.NONE) {
+
+        @Override
+        public void readFromNBT(@Nullable NBTTagCompound data, String name) {
+            super.readFromNBT(data, name);
+
+            for (int i = 0; i < this.getSizeInventory(); i++) {
+                final IAEStack<?> aes = this.getAEStackInSlot(i);
+                if (aes instanceof IAEItemStack ais && ais.getItem() instanceof ItemFluidPacket) {
+                    final IAEFluidStack ifs = ItemFluidPacket.getFluidAEStack(ais);
+                    if (ifs != null && ifs.getStackSize() > Integer.MAX_VALUE) ifs.setStackSize(Integer.MAX_VALUE);
+                    this.putAEStackInSlot(i, ifs);
+                }
+            }
+        }
+    };
+    private final IAEStackInventory configItems = new IAEStackInventory(this, 63, StorageName.CONFIG);
     private final BaseActionSource source;
     private boolean isPowered;
     private long totalBytes;
     private long storedFluidCount;
     private long storedItemCount;
 
+    private boolean needReCountStoredFluids = true;
+    private boolean needReCountStoredItems = true;
+
     public TileSuperStockReplenisher() {
         super(false);
         getProxy().setIdlePowerUsage(4D);
@@ -78,18 +104,28 @@ public class TileSuperStockReplenisher extends AENetworkInvTile
     }
 
     private TickRateModulation doWork() {
+        this.fletchFluids();
+        this.fletchItems();
+
+        this.needReCountStoredFluids = true;
+        this.needReCountStoredItems = true;
+
+        return TickRateModulation.SAME;
+    }
+
+    private void fletchFluids() {
         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)) {
+            IAEStack<?> configFluid = configFluids.getAEStackInSlot(i);
+            if (configFluid instanceof IAEFluidStack fs) {
+                IAEFluidStack ifs = fs.copy();
+                if (invFluid == null) requestFluid(ifs, i);
+                else if (invFluid.equals(ifs)) {
                     long invSize = invFluid.getStackSize();
-                    long confSize = fs.getStackSize();
+                    long confSize = ifs.getStackSize();
                     if (invSize < confSize / 2f) {
-                        fs.setStackSize(confSize - invSize);
-                        requestFluid(fs, i);
+                        ifs.setStackSize(confSize - invSize);
+                        requestFluid(ifs, i);
                     } else if (invSize > confSize) {
                         returnFluid(i, invSize - confSize);
                     }
@@ -100,13 +136,14 @@ public class TileSuperStockReplenisher extends AENetworkInvTile
                 returnFluid(i, Long.MAX_VALUE);
             }
         }
+    }
 
+    private void fletchItems() {
         for (int i = 0; i < 63; i++) {
             ItemStack invItem = invItems.getStackInSlot(i);
-            IAEItemStack configItem = configItems.getAEStackInSlot(i);
-
-            if (configItem != null) {
-                IAEItemStack is = configItem.copy();
+            IAEStack<?> configItem = configItems.getAEStackInSlot(i);
+            if (configItem instanceof IAEItemStack ais) {
+                IAEItemStack is = ais.copy();
                 if (invItem == null) requestItem(is, i);
                 else if (is.equals(invItem)) {
                     int confSize = (int) is.getStackSize();
@@ -123,8 +160,28 @@ public class TileSuperStockReplenisher extends AENetworkInvTile
                 returnItem(i, Integer.MAX_VALUE);
             }
         }
+    }
 
-        return TickRateModulation.SAME;
+    private void countFluids() {
+        if (this.needReCountStoredFluids) {
+            this.needReCountStoredFluids = false;
+            this.storedFluidCount = 0;
+            for (int i = 0; i < this.invFluids.getSlots(); i++) {
+                final IAEFluidStack fs = this.invFluids.getFluidInSlot(i);
+                if (fs != null) this.storedFluidCount += fs.getStackSize();
+            }
+        }
+    }
+
+    private void countItems() {
+        if (this.needReCountStoredItems) {
+            this.needReCountStoredItems = false;
+            this.storedItemCount = 0;
+            for (int i = 0; i < this.invItems.getSizeInventory(); i++) {
+                final ItemStack is = this.invItems.getStackInSlot(i);
+                if (is != null) this.storedItemCount += is.stackSize;
+            }
+        }
     }
 
     private void returnFluid(int index, long amount) {
@@ -161,21 +218,23 @@ public class TileSuperStockReplenisher extends AENetworkInvTile
                 is.stackSize = is.stackSize - amount;
                 is = is.copy();
                 is.stackSize = amount;
-                storedItemCount -= is.stackSize;
             } else {
                 invItems.setInventorySlotContents(index, null);
             }
 
+            this.storedItemCount -= is.stackSize;
+
             IAEItemStack notInserted = this.getProxy().getStorage().getItemInventory()
                     .injectItems(AEItemStack.create(is), Actionable.MODULATE, this.source);
             if (notInserted != null) {
                 ItemStack tempStack = invItems.getStackInSlot(index);
                 if (tempStack != null) {
                     tempStack.stackSize = tempStack.stackSize + (int) notInserted.getStackSize();
-                    storedItemCount += notInserted.getStackSize();
 
                     saveChanges();
                 } else invItems.setInventorySlotContents(index, notInserted.getItemStack());
+
+                this.storedItemCount += notInserted.getStackSize();
             }
         } catch (final GridAccessException ignored) {}
     }
@@ -191,10 +250,11 @@ public class TileSuperStockReplenisher extends AENetworkInvTile
                 ItemStack tempStack = invItems.getStackInSlot(index);
                 if (tempStack != null) {
                     tempStack.stackSize = tempStack.stackSize + (int) extracted.getStackSize();
-                    storedItemCount += extracted.getStackSize();
 
                     saveChanges();
                 } else invItems.setInventorySlotContents(index, extracted.getItemStack());
+
+                this.storedItemCount += extracted.getStackSize();
             }
         } catch (final GridAccessException ignored) {}
     }
@@ -210,12 +270,12 @@ public class TileSuperStockReplenisher extends AENetworkInvTile
         return invItems;
     }
 
-    public AppEngInternalAEInventory getConfigFluid() {
-        return configFluids;
+    public IAEStackInventory getConfigFluids() {
+        return this.configFluids;
     }
 
-    public AppEngInternalAEInventory getConfigItems() {
-        return configItems;
+    public IAEStackInventory getConfigItems() {
+        return this.configItems;
     }
 
     public AppEngInternalInventory getCell() {
@@ -223,6 +283,9 @@ public class TileSuperStockReplenisher extends AENetworkInvTile
     }
 
     public long getFreeBytes() {
+        this.countFluids();
+        this.countItems();
+
         return totalBytes - (((storedItemCount + getUnusedItemCount()) / 8)
                 + ((storedFluidCount + getUnusedFluidCount()) / 2048));
     }
@@ -273,14 +336,6 @@ public class TileSuperStockReplenisher extends AENetworkInvTile
                         totalBytes = 0;
                         getProxy().setIdlePowerUsage(4d);
                     }
-                } else if (inv == invItems) {
-                    if (added != null) {
-                        storedItemCount += added.stackSize;
-                    }
-
-                    if (removed != null) {
-                        storedItemCount -= removed.stackSize;
-                    }
                 }
             }
             case decreaseStackSize -> {
@@ -288,10 +343,6 @@ public class TileSuperStockReplenisher extends AENetworkInvTile
                     totalBytes = 0;
                     getProxy().setIdlePowerUsage(4d);
                 }
-
-                if (inv == invItems) {
-                    storedItemCount -= removed.stackSize;
-                }
             }
             case markDirty -> markDirty();
         }
@@ -319,12 +370,26 @@ public class TileSuperStockReplenisher extends AENetworkInvTile
 
     @Override
     public void getDrops(World w, int x, int y, int z, List<ItemStack> drops) {
+        this.fullRefund();
+
         if (cell.getStackInSlot(0) != null) drops.add(cell.getStackInSlot(0));
+        final ItemStack container = AEApi.instance().definitions().items().itemMEStackPacket().maybeStack(1).get();
+
         for (int i = 0; i < 9; i++) {
-            ItemStack ifp = ItemFluidPacket.newStack(invFluids.getFluidStackInSlot(i));
-            if (ifp != null) drops.add(ifp);
+            final FluidStack fs = this.invFluids.getFluidStackInSlot(i);
+            if (fs == null) continue;
+            final ItemStack temp = container.copy();
+            Platform.writeStackNBT(AEFluidStack.create(fs), ItemStackNBT.get(temp));
+            drops.add(temp);
+        }
+
+        for (int i = 0; i < 63; i++) {
+            final ItemStack is = this.invItems.getStackInSlot(i);
+            if (is == null) continue;
+            final ItemStack temp = container.copy();
+            Platform.writeStackNBT(AEItemStack.create(is), ItemStackNBT.get(temp));
+            drops.add(temp);
         }
-        super.getDrops(w, x, y, z, drops);
     }
 
     @Override
@@ -339,16 +404,12 @@ public class TileSuperStockReplenisher extends AENetworkInvTile
 
     @Override
     public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) {
-        FluidStack fs = invFluids.drain(from, resource, doDrain);
-        if (doDrain && fs != null) storedFluidCount -= fs.amount;
-        return fs;
+        return invFluids.drain(from, resource, doDrain);
     }
 
     @Override
     public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) {
-        FluidStack fs = invFluids.drain(from, maxDrain, doDrain);
-        if (doDrain && fs != null) storedFluidCount -= fs.amount;
-        return fs;
+        return invFluids.drain(from, maxDrain, doDrain);
     }
 
     @Override
@@ -368,7 +429,7 @@ public class TileSuperStockReplenisher extends AENetworkInvTile
 
     @Override
     public void onFluidInventoryChanged(IAEFluidTank inv, int slot) {
-        saveChanges();
+        this.markDirty();
     }
 
     @Override
@@ -396,8 +457,6 @@ public class TileSuperStockReplenisher extends AENetworkInvTile
         configFluids.readFromNBT(data, "configFluids");
         cell.readFromNBT(data, "cellHolder");
         totalBytes = data.getLong("totalBytes");
-        storedFluidCount = data.getLong("storedFluidCount");
-        storedItemCount = data.getLong("storedItemCount");
         getProxy().setIdlePowerUsage(data.getDouble("powerDraw"));
     }
 
@@ -409,8 +468,6 @@ public class TileSuperStockReplenisher extends AENetworkInvTile
         configFluids.writeToNBT(data, "configFluids");
         cell.writeToNBT(data, "cellHolder");
         data.setLong("totalBytes", totalBytes);
-        data.setLong("storedFluidCount", storedFluidCount);
-        data.setLong("storedItemCount", storedItemCount);
         data.setDouble("powerDraw", getProxy().getIdlePowerUsage());
         return data;
     }
@@ -482,4 +539,18 @@ public class TileSuperStockReplenisher extends AENetworkInvTile
     public IConfigManager getConfigManager() {
         return null;
     }
+
+    @Override
+    public void saveAEStackInv() {
+        this.markDirty();
+    }
+
+    @Override
+    public IAEStackInventory getAEInventoryByName(StorageName name) {
+        return switch (name) {
+            case NONE -> this.configFluids;
+            case CONFIG -> this.configItems;
+            default -> null;
+        };
+    }
 }

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

@@ -432,7 +432,10 @@ public class AEFluidInventory implements IAEFluidTank {
             if (doFill) {
                 if (getFluid() == null) AEFluidInventory.this
                         .setFluidInSlot(this.slot, AEFluidStack.create(new FluidStack(resource.getFluid(), acc)));
-                else getFluid().amount += acc;
+                else {
+                    getFluid().amount += acc;
+                    AEFluidInventory.this.onContentChanged(this.slot);
+                }
             }
             return acc;
         }
@@ -446,7 +449,10 @@ public class AEFluidInventory implements IAEFluidTank {
             if (doDrain) {
                 if (amt == getFluid().amount) {
                     AEFluidInventory.this.setFluidInSlot(this.slot, null);
-                } else getFluid().amount -= amt;
+                } else {
+                    getFluid().amount -= amt;
+                    AEFluidInventory.this.onContentChanged(this.slot);
+                }
             }
             return remove;
         }