Dual hatches

src/main/java/gregtech/api/capability/DualHandler.java

@@ -1,21 +1,26 @@
 package gregtech.api.capability;
 
 import gregtech.api.capability.impl.FluidTankList;
+import gregtech.api.capability.impl.ItemHandlerList;
 import gregtech.api.metatileentity.MetaTileEntity;
 import gregtech.api.util.ItemStackHashStrategy;
 
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.fluids.IFluidTank;
 import net.minecraftforge.fluids.capability.IFluidTankProperties;
+import net.minecraftforge.items.IItemHandler;
 import net.minecraftforge.items.IItemHandlerModifiable;
 
+import com.google.common.collect.ImmutableList;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 
-public class DualHandler implements IItemHandlerModifiable, IMultipleTankHandler, INotifiableHandler {
+public class DualHandler implements IItemHandlerModifiable, IMultipleTankHandler, INotifiableHandler,
+                         IMultipleNotifiableHandler {
 
     @NotNull
     private static final ItemStackHashStrategy strategy = ItemStackHashStrategy.comparingAll();
@@ -158,11 +163,39 @@ public void addNotifiableMetaTileEntity(MetaTileEntity metaTileEntity) {
         if (metaTileEntity == null || this.notifiableEntities.contains(metaTileEntity))
             return;
         this.notifiableEntities.add(metaTileEntity);
+        if (getItemDelegate() instanceof INotifiableHandler handler) {
+            handler.addNotifiableMetaTileEntity(metaTileEntity);
+        } else if (getItemDelegate() instanceof ItemHandlerList list) {
+            for (IItemHandler handler : list.getBackingHandlers()) {
+                if (handler instanceof INotifiableHandler notifiableHandler) {
+                    notifiableHandler.addNotifiableMetaTileEntity(metaTileEntity);
+                }
+            }
+        }
+        for (ITankEntry entry : getFluidDelegate()) {
+            if (entry.getDelegate() instanceof INotifiableHandler handler) {
+                handler.addNotifiableMetaTileEntity(metaTileEntity);
+            }
+        }
     }
 
     @Override
     public void removeNotifiableMetaTileEntity(MetaTileEntity metaTileEntity) {
         this.notifiableEntities.remove(metaTileEntity);
+        if (getItemDelegate() instanceof INotifiableHandler handler) {
+            handler.removeNotifiableMetaTileEntity(metaTileEntity);
+        } else if (getItemDelegate() instanceof ItemHandlerList list) {
+            for (IItemHandler handler : list.getBackingHandlers()) {
+                if (handler instanceof INotifiableHandler notifiableHandler) {
+                    notifiableHandler.removeNotifiableMetaTileEntity(metaTileEntity);
+                }
+            }
+        }
+        for (ITankEntry entry : getFluidDelegate()) {
+            if (entry.getDelegate() instanceof INotifiableHandler handler) {
+                handler.removeNotifiableMetaTileEntity(metaTileEntity);
+            }
+        }
     }
 
     public @NotNull IItemHandlerModifiable getItemDelegate() {
@@ -173,6 +206,27 @@ public void removeNotifiableMetaTileEntity(MetaTileEntity metaTileEntity) {
         return fluidDelegate;
     }
 
+    @Override
+    public @NotNull Collection<INotifiableHandler> getBackingNotifiers() {
+        ImmutableList.Builder<INotifiableHandler> handlerList = ImmutableList.builder();
+
+        if (itemDelegate instanceof IMultipleNotifiableHandler multipleNotifiableHandler) {
+            handlerList.addAll(multipleNotifiableHandler.getBackingNotifiers());
+        } else if (itemDelegate instanceof INotifiableHandler notifiableHandler) {
+            handlerList.add(notifiableHandler);
+        }
+
+        for (var tank : fluidDelegate) {
+            if (tank instanceof INotifiableHandler notifiableHandler) {
+                handlerList.add(notifiableHandler);
+            } else if (tank.getDelegate() instanceof INotifiableHandler notifiableHandler) {
+                handlerList.add(notifiableHandler);
+            }
+        }
+
+        return handlerList.build();
+    }
+
     public static class DualEntry implements ITankEntry, INotifiableHandler {
 
         @NotNull

src/main/java/gregtech/api/capability/IMultipleNotifiableHandler.java

@@ -0,0 +1,11 @@
+package gregtech.api.capability;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+
+public interface IMultipleNotifiableHandler {
+
+    @NotNull
+    Collection<INotifiableHandler> getBackingNotifiers();
+}

src/main/java/gregtech/api/capability/impl/ItemHandlerList.java

@@ -1,9 +1,13 @@
 package gregtech.api.capability.impl;
 
+import gregtech.api.capability.IMultipleNotifiableHandler;
+import gregtech.api.capability.INotifiableHandler;
+
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.items.IItemHandler;
 import net.minecraftforge.items.IItemHandlerModifiable;
 
+import com.google.common.collect.ImmutableList;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 import it.unimi.dsi.fastutil.objects.Object2IntArrayMap;
@@ -15,7 +19,7 @@
 /**
  * Efficiently delegates calls into multiple item handlers
  */
-public class ItemHandlerList implements IItemHandlerModifiable {
+public class ItemHandlerList implements IItemHandlerModifiable, IMultipleNotifiableHandler {
 
     private final Int2ObjectMap<IItemHandler> handlerBySlotIndex = new Int2ObjectOpenHashMap<>();
     private final Object2IntMap<IItemHandler> baseIndexOffset = new Object2IntArrayMap<>();
@@ -93,6 +97,19 @@ public Collection<IItemHandler> getBackingHandlers() {
         return Collections.unmodifiableCollection(baseIndexOffset.keySet());
     }
 
+    @Override
+    public @NotNull Collection<INotifiableHandler> getBackingNotifiers() {
+        ImmutableList.Builder<INotifiableHandler> notifiableHandlers = ImmutableList.builder();
+
+        for (var handler : getBackingHandlers()) {
+            if (handler instanceof INotifiableHandler notifiableHandler) {
+                notifiableHandlers.add(notifiableHandler);
+            }
+        }
+
+        return notifiableHandlers.build();
+    }
+
     private boolean invalidSlot(int slot) {
         return slot < 0 && slot >= this.getSlots();
     }

src/main/java/gregtech/api/capability/impl/MultiblockRecipeLogic.java

@@ -4,6 +4,7 @@
 import gregtech.api.capability.DualHandler;
 import gregtech.api.capability.IEnergyContainer;
 import gregtech.api.capability.IMultiblockController;
+import gregtech.api.capability.IMultipleNotifiableHandler;
 import gregtech.api.capability.IMultipleRecipeMaps;
 import gregtech.api.capability.IMultipleTankHandler;
 import gregtech.api.metatileentity.multiblock.MultiblockAbility;
@@ -146,9 +147,9 @@ protected boolean canWorkWithInputs() {
                         Iterator<IItemHandlerModifiable> invalidatedIter = invalidatedInputList.iterator();
                         while (invalidatedIter.hasNext()) {
                             IItemHandler invalidatedHandler = invalidatedIter.next();
-                            if (invalidatedHandler instanceof ItemHandlerList) {
-                                for (IItemHandler ih : ((ItemHandlerList) invalidatedHandler).getBackingHandlers()) {
-                                    if (ih == bus) {
+                            if (invalidatedHandler instanceof IMultipleNotifiableHandler multipleNotifiableHandler) {
+                                for (var notifiableHandler : multipleNotifiableHandler.getBackingNotifiers()) {
+                                    if (notifiableHandler == bus) {
                                         canWork = true;
                                         invalidatedIter.remove();
                                         break;

src/main/java/gregtech/api/util/GTUtility.java

@@ -56,6 +56,7 @@
 import net.minecraftforge.items.IItemHandlerModifiable;
 
 import com.google.common.util.concurrent.AtomicDouble;
+import it.unimi.dsi.fastutil.objects.Object2IntMap;
 import it.unimi.dsi.fastutil.objects.ObjectOpenCustomHashSet;
 import org.apache.commons.lang3.ArrayUtils;
 import org.apache.commons.lang3.tuple.Pair;
@@ -1029,4 +1030,42 @@ public static boolean areFluidStacksEqual(@Nullable FluidStack a, @Nullable Flui
         if (a == null) return false;
         return a.isFluidEqual(b);
     }
+
+    public static void collapseInventorySlotContents(IItemHandlerModifiable inventory) {
+        // Gather a snapshot of the provided inventory
+        Object2IntMap<ItemStack> inventoryContents = GTHashMaps.fromItemHandler(inventory, true);
+
+        List<ItemStack> inventoryItemContents = new ArrayList<>();
+
+        // Populate the list of item stacks in the inventory with apportioned item stacks, for easy replacement
+        for (Object2IntMap.Entry<ItemStack> e : inventoryContents.object2IntEntrySet()) {
+            ItemStack stack = e.getKey();
+            int count = e.getIntValue();
+            int maxStackSize = stack.getMaxStackSize();
+            while (count >= maxStackSize) {
+                ItemStack copy = stack.copy();
+                copy.setCount(maxStackSize);
+                inventoryItemContents.add(copy);
+                count -= maxStackSize;
+            }
+            if (count > 0) {
+                ItemStack copy = stack.copy();
+                copy.setCount(count);
+                inventoryItemContents.add(copy);
+            }
+        }
+
+        for (int i = 0; i < inventory.getSlots(); i++) {
+            ItemStack stackToMove;
+            // Ensure that we are not exceeding the List size when attempting to populate items
+            if (i >= inventoryItemContents.size()) {
+                stackToMove = ItemStack.EMPTY;
+            } else {
+                stackToMove = inventoryItemContents.get(i);
+            }
+
+            // Populate the slots
+            inventory.setStackInSlot(i, stackToMove);
+        }
+    }
 }

src/main/java/gregtech/client/renderer/texture/Textures.java

@@ -348,6 +348,10 @@ public class Textures {
             "overlay/machine/overlay_item_hatch_input");
     public static final SimpleOverlayRenderer WATER_OVERLAY = new SimpleOverlayRenderer(
             "overlay/machine/overlay_water");
+    public static final SimpleOverlayRenderer DUAL_HATCH_OUTPUT_OVERLAY = new SimpleOverlayRenderer(
+            "overlay/machine/overlay_dual_hatch_output");
+    public static final SimpleOverlayRenderer DUAL_HATCH_INPUT_OVERLAY = new SimpleOverlayRenderer(
+            "overlay/machine/overlay_dual_hatch_input");
 
     public static final ICubeRenderer BRONZE_FIREBOX = new SidedCubeRenderer("casings/firebox/overlay/bronze");
     public static final ICubeRenderer BRONZE_FIREBOX_ACTIVE = new FireboxActiveRenderer(

src/main/java/gregtech/common/metatileentities/MetaTileEntities.java

@@ -65,6 +65,7 @@
 import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityCleaningMaintenanceHatch;
 import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityComputationHatch;
 import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityDataAccessHatch;
+import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityDualHatch;
 import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityEnergyHatch;
 import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityFluidHatch;
 import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityItemBus;
@@ -246,6 +247,8 @@ private MetaTileEntities() {}
     public static MetaTileEntityHPCACooler HPCA_HEAT_SINK_COMPONENT;
     public static MetaTileEntityHPCACooler HPCA_ACTIVE_COOLER_COMPONENT;
     public static MetaTileEntityHPCABridge HPCA_BRIDGE_COMPONENT;
+    public static MetaTileEntityDualHatch[] DUAL_INPUT_HATCH = new MetaTileEntityDualHatch[GTValues.V.length - 1];
+    public static MetaTileEntityDualHatch[] DUAL_OUTPUT_HATCH = new MetaTileEntityDualHatch[GTValues.V.length - 1];
 
     // Used for addons if they wish to disable certain tiers of machines
     private static final Map<String, Boolean> MID_TIER = new HashMap<>();

src/main/java/gregtech/common/metatileentities/MetaTileEntityRegistration.java

@@ -69,6 +69,7 @@
 import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityCleaningMaintenanceHatch;
 import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityComputationHatch;
 import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityDataAccessHatch;
+import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityDualHatch;
 import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityEnergyHatch;
 import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityFluidHatch;
 import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityItemBus;
@@ -1098,5 +1099,21 @@ private static void multiblockParts() {
             MetaTileEntities.FLUID_EXPORT_HATCH_ME = MetaTileEntities.registerMetaTileEntity(11533,
                     new MetaTileEntityMEOutputHatch(gregtechId("me_export_fluid_hatch")));
         }
+
+        // Dual Input Hatches
+        for (int tier = GTValues.ULV; tier <= (GregTechAPI.isHighTier() ? GTValues.OpV : GTValues.UHV); tier++) {
+            String voltageName = GTValues.VN[tier].toLowerCase();
+            MetaTileEntities.DUAL_INPUT_HATCH[tier] = MetaTileEntities.registerMetaTileEntity(11591 + tier,
+                    new MetaTileEntityDualHatch(
+                            gregtechId(String.format("%s.%s", "dual_input_hatch", voltageName)), tier, false));
+        }
+
+        // Dual Output Hatches
+        for (int tier = GTValues.ULV; tier <= (GregTechAPI.isHighTier() ? GTValues.OpV : GTValues.UHV); tier++) {
+            String voltageName = GTValues.VN[tier].toLowerCase();
+            MetaTileEntities.DUAL_INPUT_HATCH[tier] = MetaTileEntities.registerMetaTileEntity(11605 + tier,
+                    new MetaTileEntityDualHatch(
+                            gregtechId(String.format("%s.%s", "dual_output_hatch", voltageName)), tier, true));
+        }
     }
 }