From 1253a9002d6f13ce3397dae77d4fef6565a9b83f Mon Sep 17 00:00:00 2001 From: GlodBlock <1356392126@qq.com> Date: Wed, 18 May 2022 01:16:20 +0800 Subject: [PATCH] fix block mode crash --- README.md | 3 + .../ContainerFluidPatternTerminal.java | 2 +- .../github/coremod/CoreModHooks.java | 20 ++-- .../DualityInterfaceTransformer.java | 23 +++++ .../BlockingFluidInventoryAdaptor.java | 96 +++++++++++++++++++ 5 files changed, 130 insertions(+), 14 deletions(-) create mode 100644 src/main/java/com/glodblock/github/inventory/BlockingFluidInventoryAdaptor.java diff --git a/README.md b/README.md index 433fb322..3ca8388e 100644 --- a/README.md +++ b/README.md @@ -25,6 +25,7 @@ This is a rework and ported version of [ae2-fluid-crafting](https://github.com/p - [1.12.2] Fix the fluid amount display error when removing fluid. - [1.12.2] Upgrade cards can be inserted in Dual Interface. - [1.12.2] Fluid pattern is searchable in interface terminal. + - [1.12.2] Fix crash when using block mode, fluid will also be considered as blockable. ## Installation @@ -36,6 +37,8 @@ Any version of AE2(Both Official AE2 and GTNH edition AE2 works). ### 1.12.2 Unofficial AE2([PAE2](https://www.curseforge.com/minecraft/mc-mods/ae2-extended-life)). +You can directly upgrade origin AE2FC2 in your old save. + Official AE2 isn't supported, you can use origin [AE2FC](https://github.com/phantamanta44/ae2-fluid-crafting) if you are playing with Official AE2. ## Basic Devices diff --git a/src/main/java/com/glodblock/github/client/container/ContainerFluidPatternTerminal.java b/src/main/java/com/glodblock/github/client/container/ContainerFluidPatternTerminal.java index 917f756a..ed5a9b15 100644 --- a/src/main/java/com/glodblock/github/client/container/ContainerFluidPatternTerminal.java +++ b/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); } } } diff --git a/src/main/java/com/glodblock/github/coremod/CoreModHooks.java b/src/main/java/com/glodblock/github/coremod/CoreModHooks.java index 010539fc..c4e83a68 100644 --- a/src/main/java/com/glodblock/github/coremod/CoreModHooks.java +++ b/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); - } - } - } \ No newline at end of file diff --git a/src/main/java/com/glodblock/github/coremod/transform/DualityInterfaceTransformer.java b/src/main/java/com/glodblock/github/coremod/transform/DualityInterfaceTransformer.java index 7db0adab..e64db388 100644 --- a/src/main/java/com/glodblock/github/coremod/transform/DualityInterfaceTransformer.java +++ b/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); + } + } + + } + } \ No newline at end of file diff --git a/src/main/java/com/glodblock/github/inventory/BlockingFluidInventoryAdaptor.java b/src/main/java/com/glodblock/github/inventory/BlockingFluidInventoryAdaptor.java new file mode 100644 index 00000000..e1d46b62 --- /dev/null +++ b/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 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; + } + } +}