fix block mode crash

src/main/java/com/glodblock/github/client/container/ContainerFluidPatternTerminal.java

@@ -315,7 +315,7 @@ public class ContainerFluidPatternTerminal extends ContainerPatternTerm implemen
             }
             else if (!slot.getStack().isEmpty()) {
                 ItemStack stack = slot.getStack();
-                stack.setCount(stack.getCount() * divide);
+                stack.setCount(stack.getCount() / divide);
             }
         }
     }

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

@@ -10,6 +10,7 @@ import appeng.me.MachineSet;
 import appeng.parts.misc.PartInterface;
 import appeng.tile.misc.TileInterface;
 import appeng.util.InventoryAdaptor;
+import appeng.util.inv.BlockingInventoryAdaptor;
 import appeng.util.inv.filter.IAEItemFilter;
 import com.glodblock.github.common.item.ItemFluidDrop;
 import com.glodblock.github.common.item.ItemFluidEncodedPattern;
@@ -17,6 +18,7 @@ import com.glodblock.github.common.item.ItemFluidPacket;
 import com.glodblock.github.common.part.PartDualInterface;
 import com.glodblock.github.common.tile.TileDualInterface;
 import com.glodblock.github.handler.FluidConvertingItemHandler;
+import com.glodblock.github.inventory.BlockingFluidInventoryAdaptor;
 import com.glodblock.github.inventory.FluidConvertingInventoryAdaptor;
 import com.glodblock.github.inventory.FluidConvertingInventoryCrafting;
 import com.glodblock.github.loader.FCItems;
@@ -58,6 +60,11 @@ public class CoreModHooks {
         return tile != null ? FluidConvertingInventoryAdaptor.wrap(tile, face) : null;
     }
 
+    @Nullable
+    public static BlockingInventoryAdaptor wrapBlockInventory(@Nullable TileEntity tile, EnumFacing face) {
+        return tile != null ? BlockingFluidInventoryAdaptor.getAdaptor(tile, face) : null;
+    }
+
     public static long getCraftingByteCost(IAEItemStack stack) {
         return stack.getItem() instanceof ItemFluidDrop
                 ? (long)Math.ceil(stack.getStackSize() / 1000D) : stack.getStackSize();
@@ -106,17 +113,4 @@ public class CoreModHooks {
         }
     }
 
-    public static class FluidPatternSlotFilter implements IAEItemFilter {
-        public FluidPatternSlotFilter() {
-        }
-
-        public boolean allowExtract(IItemHandler inv, int slot, int amount) {
-            return true;
-        }
-
-        public boolean allowInsert(IItemHandler inv, int slot, ItemStack stack) {
-            return !stack.isEmpty() && (stack.getItem() instanceof ItemEncodedPattern || stack.getItem() instanceof ItemFluidEncodedPattern);
-        }
-    }
-
 }

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

@@ -31,6 +31,8 @@ public class DualityInterfaceTransformer extends FCClassTransformer.ClassMapper
                 case "pushPattern":
                 case "isBusy":
                     return new TransformInvAdaptorCalls(api, super.visitMethod(access, name, desc, signature, exceptions));
+                case "isCustomInvBlocking":
+                    return new TransformBlockAdaptorCalls(api, super.visitMethod(access, name, desc, signature, exceptions));
                 default:
                     return super.visitMethod(access, name, desc, signature, exceptions);
             }
@@ -59,4 +61,25 @@ public class DualityInterfaceTransformer extends FCClassTransformer.ClassMapper
 
     }
 
+    private static class TransformBlockAdaptorCalls extends MethodVisitor {
+
+        TransformBlockAdaptorCalls(int api, MethodVisitor mv) {
+            super(api, mv);
+        }
+
+        @Override
+        public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
+            if (opcode == Opcodes.INVOKESTATIC && owner.equals("appeng/util/inv/BlockingInventoryAdaptor") && name.equals("getAdaptor")) {
+                super.visitMethodInsn(Opcodes.INVOKESTATIC,
+                        "com/glodblock/github/coremod/CoreModHooks",
+                        "wrapBlockInventory",
+                        "(Lnet/minecraft/tileentity/TileEntity;Lnet/minecraft/util/EnumFacing;)Lappeng/util/inv/BlockingInventoryAdaptor;",
+                        false);
+            } else {
+                super.visitMethodInsn(opcode, owner, name, desc, itf);
+            }
+        }
+
+    }
+
 }

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

@@ -0,0 +1,96 @@
+package com.glodblock.github.inventory;
+
+import appeng.helpers.NonBlockingItems;
+import appeng.util.inv.BlockingInventoryAdaptor;
+import appeng.util.inv.ItemHandlerIterator;
+import appeng.util.inv.ItemSlot;
+import it.unimi.dsi.fastutil.ints.IntSet;
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumFacing;
+import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
+import net.minecraftforge.fluids.capability.IFluidHandler;
+import net.minecraftforge.fluids.capability.IFluidTankProperties;
+import net.minecraftforge.items.CapabilityItemHandler;
+import net.minecraftforge.items.IItemHandler;
+
+import javax.annotation.Nullable;
+import java.util.Iterator;
+import java.util.Objects;
+
+public class BlockingFluidInventoryAdaptor extends BlockingInventoryAdaptor {
+
+    @Nullable
+    private final IItemHandler invItems;
+    @Nullable
+    private final IFluidHandler invFluids;
+    @Nullable
+    private final String domain;
+
+    public BlockingFluidInventoryAdaptor(@Nullable IItemHandler invItems, @Nullable IFluidHandler invFluids, @Nullable String domain) {
+        this.invItems = invItems;
+        this.invFluids = invFluids;
+        this.domain = domain;
+    }
+
+    public static BlockingInventoryAdaptor getAdaptor(TileEntity te, EnumFacing d) {
+        IItemHandler itemHandler = null;
+        IFluidHandler fluidHandler = null;
+        String domain = null;
+        if (te != null && te.hasCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, d)) {
+            itemHandler = te.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, d);
+            if (itemHandler != null) {
+                domain =  Objects.requireNonNull(te.getBlockType().getRegistryName()).getNamespace();
+            }
+        }
+        if (te != null && te.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, d)) {
+            fluidHandler = te.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, d);
+            if (fluidHandler != null) {
+                domain =  Objects.requireNonNull(te.getBlockType().getRegistryName()).getNamespace();
+            }
+        }
+        return new BlockingFluidInventoryAdaptor(itemHandler, fluidHandler, domain);
+    }
+
+    @Override
+    public boolean containsBlockingItems() {
+
+        boolean itemPass = true;
+        boolean fluidPass = true;
+
+        if (invItems != null) {
+            int slots = this.invItems.getSlots();
+            for(int slot = 0; slot < slots; ++slot) {
+                ItemStack is = this.invItems.getStackInSlot(slot);
+                if (!is.isEmpty() && this.isBlockableItem(is)) {
+                    itemPass = false;
+                }
+            }
+        }
+
+        if (invFluids != null) {
+            for (IFluidTankProperties tank : invFluids.getTankProperties()) {
+                if (tank != null && tank.getContents() != null && (tank.canFill() || tank.canDrain())) {
+                    fluidPass = false;
+                }
+            }
+        }
+
+        return !(fluidPass && itemPass);
+    }
+
+    @Override
+    public Iterator<ItemSlot> iterator() {
+        return new ItemHandlerIterator(this.invItems);
+    }
+
+    boolean isBlockableItem(ItemStack stack) {
+        Object2ObjectOpenHashMap map = NonBlockingItems.INSTANCE.getMap().get(this.domain);
+        if (map.get(stack.getItem()) != null) {
+            return !((IntSet)map.get(stack.getItem())).contains(stack.getItemDamage());
+        } else {
+            return true;
+        }
+    }
+}