update

dependencies.gradle

@@ -35,27 +35,27 @@
  */
 dependencies {
     api('com.github.GTNewHorizons:NotEnoughItems:2.6.26-GTNH:dev')
-    api('com.github.GTNewHorizons:Applied-Energistics-2-Unofficial:rv3-beta-435-GTNH:dev')
+    api('com.github.GTNewHorizons:Applied-Energistics-2-Unofficial:rv3-beta-437-GTNH-pre:dev')
     api('curse.maven:cofh-core-69162:2388751')
     api('com.github.GTNewHorizons:waila:1.8.1:dev')
 
     implementation("com.github.GTNewHorizons:WirelessCraftingTerminal:1.11.6:dev")
 
-    compileOnly("com.github.GTNewHorizons:GTNHLib:0.4.7:dev") { transitive = false }
+    compileOnly("com.github.GTNewHorizons:GTNHLib:0.4.8:dev") { transitive = false }
     compileOnly('com.github.GTNewHorizons:Baubles:1.0.4:dev')
     compileOnly('com.github.GTNewHorizons:ExtraCells2:2.5.35:dev') { transitive = false }
     compileOnly('com.github.GTNewHorizons:ForestryMC:4.9.7:dev')
     compileOnly('com.github.GTNewHorizons:EnderIO:2.8.17:dev')
-    compileOnly('com.github.GTNewHorizons:GT5-Unofficial:5.09.49.22:dev') {
+    compileOnly('com.github.GTNewHorizons:GT5-Unofficial:5.09.49.25:dev') {
         exclude group: 'com.github.GTNewHorizons', module: 'AE2FluidCraft-Rework'
     }
 
     compileOnly('thaumcraft:Thaumcraft:1.7.10-4.2.3.5:dev')
     compileOnly('com.gregoriust.gregtech:gregtech_1.7.10:6.14.23:dev') { transitive = false }
-    compileOnly('com.github.GTNewHorizons:OpenComputers:1.10.20-GTNH:dev') { transitive = false }
+    compileOnly('com.github.GTNewHorizons:OpenComputers:1.10.21-GTNH:dev') { transitive = false }
     compileOnly('com.github.GTNewHorizons:ThaumicEnergistics:1.6.22-GTNH:dev') { transitive = false }
-    compileOnly("com.github.GTNewHorizons:Hodgepodge:2.5.48:dev") { transitive = false }
+    compileOnly("com.github.GTNewHorizons:Hodgepodge:2.5.49:dev") { transitive = false }
 
     runtimeOnlyNonPublishable("com.github.GTNewHorizons:DuraDisplay:1.3.2:dev")
-	runtimeOnlyNonPublishable("com.github.GTNewHorizons:GTNHLib:0.4.7:dev")
+	runtimeOnlyNonPublishable("com.github.GTNewHorizons:GTNHLib:0.4.8:dev")
 }

src/main/java/com/glodblock/github/common/parts/PartFluidStorageBus.java

@@ -4,6 +4,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
+import java.util.function.Predicate;
 
 import javax.annotation.Nullable;
 
@@ -91,7 +92,7 @@ public class PartFluidStorageBus extends PartUpgradeable
     private boolean wasActive = false;
     private byte resetCacheLogic = 0;
     /**
-     * used when changing access settings to read the changes once
+     * used to read changes once when the list of extractable items was changed
      */
     private boolean readOncePass = false;
 
@@ -136,14 +137,6 @@ public class PartFluidStorageBus extends PartUpgradeable
 
     @Override
     public void updateSetting(final IConfigManager manager, final Enum settingName, final Enum newValue) {
-        if (settingName == Settings.ACCESS && this.handler != null) {
-            AccessRestriction currentAccess = this.handler.getAccess();
-            if (newValue != currentAccess && currentAccess.hasPermission(AccessRestriction.READ)) {
-                if (newValue == AccessRestriction.WRITE || newValue == AccessRestriction.READ) {
-                    this.readOncePass = true;
-                }
-            }
-        }
         this.resetCache(true);
         this.getHost().markForSave();
     }
@@ -273,8 +266,9 @@ public class PartFluidStorageBus extends PartUpgradeable
         if (this.handler != null && this.handler.isExtractFilterActive()
                 && !this.handler.getExtractPartitionList().isEmpty()) {
             List<IAEFluidStack> filteredChanges = new ArrayList<>();
+            Predicate<IAEFluidStack> extractFilterCondition = this.handler.getExtractFilterCondition();
             for (final IAEFluidStack changedFluid : change) {
-                if (this.handler.getExtractPartitionList().isListed(changedFluid)) {
+                if (extractFilterCondition.test(changedFluid)) {
                     filteredChanges.add(changedFluid);
                 }
             }
@@ -381,6 +375,7 @@ public class PartFluidStorageBus extends PartUpgradeable
         this.handlerHash = newHandlerHash;
         this.handler = null;
         this.monitor = null;
+        this.readOncePass = true;
         if (target != null) {
             final IExternalStorageHandler esh = AEApi.instance().registries().externalStorage()
                     .getHandler(target, this.getSide().getOpposite(), StorageChannel.FLUIDS, this.source);

src/main/java/com/glodblock/github/coremod/FCClassTransformer.java

@@ -7,6 +7,7 @@ import org.objectweb.asm.ClassVisitor;
 import org.objectweb.asm.ClassWriter;
 
 import com.glodblock.github.coremod.transform.CraftingCpuTransformer;
+import com.glodblock.github.coremod.transform.CraftingGridCacheTransformer;
 import com.glodblock.github.coremod.transform.CraftingTreeNodeTransformer;
 import com.glodblock.github.coremod.transform.DualityInterfaceTransformer;
 import com.glodblock.github.coremod.transform.ExternalStorageRegistryTransformer;
@@ -20,6 +21,7 @@ public class FCClassTransformer implements IClassTransformer {
         Transform tform;
         switch (transformedName) {
             case "appeng.crafting.CraftingTreeNode" -> tform = CraftingTreeNodeTransformer.INSTANCE;
+            case "appeng.me.cache.CraftingGridCache" -> tform = CraftingGridCacheTransformer.INSTANCE;
             case "appeng.me.cluster.implementations.CraftingCPUCluster" -> tform = CraftingCpuTransformer.INSTANCE;
             case "appeng.helpers.DualityInterface" -> tform = DualityInterfaceTransformer.INSTANCE;
             case "appeng.client.gui.implementations.GuiCraftingCPU", "appeng.client.gui.implementations.GuiCraftConfirm", "net.p455w0rd.wirelesscraftingterminal.client.gui.GuiCraftConfirm", "appeng.client.gui.widgets.GuiCraftingTree" -> tform = GuiCraftingTransformer.INSTANCE;

src/main/java/com/glodblock/github/coremod/hooker/CoreModHooks.java

@@ -1,7 +1,7 @@
 package com.glodblock.github.coremod.hooker;
 
-import java.util.HashSet;
-import java.util.Set;
+import java.util.Arrays;
+import java.util.List;
 
 import javax.annotation.Nullable;
 
@@ -15,30 +15,24 @@ import net.minecraftforge.fluids.FluidStack;
 import com.glodblock.github.client.gui.GuiFluidCraftConfirm;
 import com.glodblock.github.common.item.ItemFluidDrop;
 import com.glodblock.github.common.item.ItemFluidPacket;
-import com.glodblock.github.common.parts.PartFluidInterface;
-import com.glodblock.github.common.tile.TileFluidInterface;
+import com.glodblock.github.inventory.CraftingGridCacheFluidInventoryProxyCell;
 import com.glodblock.github.inventory.FluidConvertingInventoryAdaptor;
 import com.glodblock.github.inventory.FluidConvertingInventoryCrafting;
 import com.glodblock.github.loader.ItemAndBlockHolder;
 import com.glodblock.github.util.Ae2Reflect;
-import com.glodblock.github.util.SetBackedMachineSet;
-import com.google.common.collect.Sets;
 
 import appeng.api.config.Actionable;
 import appeng.api.networking.IGrid;
-import appeng.api.networking.IGridHost;
-import appeng.api.networking.IGridNode;
-import appeng.api.networking.IMachineSet;
 import appeng.api.networking.storage.IStorageGrid;
 import appeng.api.storage.IMEInventory;
+import appeng.api.storage.IMEInventoryHandler;
+import appeng.api.storage.StorageChannel;
 import appeng.api.storage.data.IAEFluidStack;
 import appeng.api.storage.data.IAEItemStack;
 import appeng.client.gui.IGuiTooltipHandler;
 import appeng.crafting.MECraftingInventory;
-import appeng.me.MachineSet;
+import appeng.me.cache.CraftingGridCache;
 import appeng.me.cluster.implementations.CraftingCPUCluster;
-import appeng.parts.misc.PartInterface;
-import appeng.tile.misc.TileInterface;
 import appeng.util.InventoryAdaptor;
 
 public class CoreModHooks {
@@ -87,40 +81,6 @@ public class CoreModHooks {
         return originByte + totalBytes;
     }
 
-    public static IAEItemStack[] flattenFluidPackets(IAEItemStack[] stacks) {
-        for (int i = 0; i < stacks.length; i++) {
-            if (stacks[i].getItem() instanceof ItemFluidPacket) {
-                stacks[i] = ItemFluidDrop.newAeStack(ItemFluidPacket.getFluidStack(stacks[i]));
-            }
-        }
-        return stacks;
-    }
-
-    public static IMachineSet getMachines(IGrid grid, Class<? extends IGridHost> c) {
-        if (c == TileInterface.class) {
-            return unionMachineSets(grid.getMachines(c), grid.getMachines(TileFluidInterface.class));
-        } else if (c == PartInterface.class) {
-            return unionMachineSets(grid.getMachines(c), grid.getMachines(PartFluidInterface.class));
-        } else {
-            return grid.getMachines(c);
-        }
-    }
-
-    private static IMachineSet unionMachineSets(IMachineSet a, IMachineSet b) {
-        if (a.isEmpty()) {
-            return b;
-        } else if (b.isEmpty()) {
-            return a;
-        } else if (a instanceof MachineSet && b instanceof MachineSet) {
-            return new SetBackedMachineSet(TileInterface.class, Sets.union((MachineSet) a, (MachineSet) b));
-        } else {
-            Set<IGridNode> union = new HashSet<>();
-            a.forEach(union::add);
-            b.forEach(union::add);
-            return new SetBackedMachineSet(TileInterface.class, union);
-        }
-    }
-
     public static ItemStack displayFluid(IAEItemStack aeStack) {
         if (aeStack.getItemStack() != null && aeStack.getItemStack().getItem() instanceof ItemFluidDrop) {
             FluidStack fluid = ItemFluidDrop.getFluidStack(aeStack.getItemStack());
@@ -134,6 +94,13 @@ public class CoreModHooks {
         } else return aeStack.getStackSize();
     }
 
+    public static List<IMEInventoryHandler> craftingGridCacheGetCellArray(final CraftingGridCache instance,
+            final StorageChannel channel) {
+        // Equivalent to original function, but using the proxy for fluid channel
+        return channel == StorageChannel.ITEMS ? Arrays.asList(instance)
+                : Arrays.asList(new CraftingGridCacheFluidInventoryProxyCell(instance));
+    }
+
     public static void storeFluidItem(CraftingCPUCluster instance) {
         final IGrid g = Ae2Reflect.getGrid(instance);
 

src/main/java/com/glodblock/github/coremod/transform/CraftingGridCacheTransformer.java

@@ -0,0 +1,67 @@
+package com.glodblock.github.coremod.transform;
+
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import com.glodblock.github.coremod.FCClassTransformer;
+
+public class CraftingGridCacheTransformer extends FCClassTransformer.ClassMapper {
+
+    public static final CraftingGridCacheTransformer INSTANCE = new CraftingGridCacheTransformer();
+
+    private CraftingGridCacheTransformer() {
+        // NO-OP
+    }
+
+    @Override
+    protected ClassVisitor getClassMapper(ClassVisitor downstream) {
+        return new CraftingGridCacheTransformer.TransformCraftingGridCache(Opcodes.ASM5, downstream);
+    }
+
+    private static class TransformCraftingGridCache extends ClassVisitor {
+
+        TransformCraftingGridCache(int api, ClassVisitor cv) {
+            super(api, cv);
+        }
+
+        @Override
+        public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
+            if (name.equals("getCellArray")) {
+                return new CraftingGridCacheTransformer.ReplaceGetCellArray(
+                        api,
+                        super.visitMethod(access, name, desc, signature, exceptions));
+            }
+            return super.visitMethod(access, name, desc, signature, exceptions);
+        }
+    }
+
+    private static class ReplaceGetCellArray extends MethodVisitor {
+
+        private final MethodVisitor target;
+
+        ReplaceGetCellArray(int api, MethodVisitor mv) {
+            // Original method is replaced
+            super(api, null);
+            target = mv;
+        }
+
+        @Override
+        public void visitCode() {
+            target.visitCode();
+            // Equivalent to
+            // return CoreModHooks::craftingGridCacheGetCellArray(this, channel);
+            target.visitVarInsn(Opcodes.ALOAD, 0);
+            target.visitVarInsn(Opcodes.ALOAD, 1);
+            target.visitMethodInsn(
+                    Opcodes.INVOKESTATIC,
+                    "com/glodblock/github/coremod/hooker/CoreModHooks",
+                    "craftingGridCacheGetCellArray",
+                    "(Lappeng/me/cache/CraftingGridCache;Lappeng/api/storage/StorageChannel;)Ljava/util/List;",
+                    false);
+            target.visitInsn(Opcodes.ARETURN);
+            target.visitMaxs(2, 3);
+            target.visitEnd();
+        }
+    }
+}

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

@@ -0,0 +1,80 @@
+package com.glodblock.github.inventory;
+
+import org.jetbrains.annotations.NotNull;
+
+import com.glodblock.github.common.item.ItemFluidDrop;
+
+import appeng.api.config.AccessRestriction;
+import appeng.api.config.Actionable;
+import appeng.api.networking.security.BaseActionSource;
+import appeng.api.storage.IMEInventoryHandler;
+import appeng.api.storage.StorageChannel;
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.api.storage.data.IItemList;
+import appeng.me.cache.CraftingGridCache;
+
+public class CraftingGridCacheFluidInventoryProxyCell implements IMEInventoryHandler<IAEFluidStack> {
+
+    private final CraftingGridCache inner;
+
+    public CraftingGridCacheFluidInventoryProxyCell(final CraftingGridCache craftingGridCache) {
+        inner = craftingGridCache;
+    }
+
+    @Override
+    public IAEFluidStack injectItems(IAEFluidStack input, Actionable type, BaseActionSource src) {
+        return ItemFluidDrop
+                .getAeFluidStack((IAEItemStack) inner.injectItems(ItemFluidDrop.newAeStack(input), type, src));
+    }
+
+    @Override
+    public IAEFluidStack extractItems(IAEFluidStack request, Actionable mode, BaseActionSource src) {
+        return null;
+    }
+
+    @Override
+    public IItemList<IAEFluidStack> getAvailableItems(IItemList<IAEFluidStack> out, int iteration) {
+        return out;
+    }
+
+    @Override
+    public IAEFluidStack getAvailableItem(@NotNull IAEFluidStack request, int iteration) {
+        return null;
+    }
+
+    @Override
+    public StorageChannel getChannel() {
+        return StorageChannel.FLUIDS;
+    }
+
+    @Override
+    public AccessRestriction getAccess() {
+        return inner.getAccess();
+    }
+
+    @Override
+    public boolean isPrioritized(IAEFluidStack input) {
+        return inner.isPrioritized(input);
+    }
+
+    @Override
+    public boolean canAccept(IAEFluidStack input) {
+        return inner.canAccept(ItemFluidDrop.newAeStack(input));
+    }
+
+    @Override
+    public int getPriority() {
+        return inner.getPriority();
+    }
+
+    @Override
+    public int getSlot() {
+        return inner.getSlot();
+    }
+
+    @Override
+    public boolean validForPass(int i) {
+        return inner.validForPass(i);
+    }
+}