Add support for VoidProtection of Items to MultiSmelter

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

@@ -1,10 +1,6 @@
 package gregtech.api.util;
 
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.PriorityQueue;
+import java.util.*;
 import java.util.function.Function;
 
 import net.minecraft.item.ItemStack;
@@ -64,6 +60,10 @@ public class VoidProtectionHelper {
      * The fluid output inventory
      */
     private FluidInventoryLogic fluidOutputInventory;
+    /**
+     * The item outputs to take in account as already in output buses
+     */
+    private ItemStack[] virtualItemOutputsInBus;
     /**
      * Has this helper been built?
      */
@@ -150,6 +150,11 @@ public VoidProtectionHelper setChangeGetter(Function<Integer, Integer> getter) {
         return this;
     }
 
+    public VoidProtectionHelper setVirtualItemOutputsInBus(ItemStack[] itemOutputs) {
+        this.virtualItemOutputsInBus = itemOutputs;
+        return this;
+    }
+
     /**
      * Finishes the VoidProtectionHelper. Anything changed after this will not affect anything
      */
@@ -403,6 +408,11 @@ private int calculateMaxItemParallels() {
         } else {
             busStacks = machine.getItemOutputSlots(itemOutputs);
         }
+
+        if (virtualItemOutputsInBus != null && virtualItemOutputsInBus.length > 0) {
+            Collections.addAll(busStacks, virtualItemOutputsInBus);
+        }
+
         // A map to hold the items we will be 'inputting' into the output buses. These itemstacks are actually the
         // recipe outputs.
         Map<ItemStack, Integer> tItemOutputMap = new ItemStackMap<>();

src/main/java/gregtech/common/tileentities/machines/multi/MTEMultiFurnace.java

@@ -48,6 +48,7 @@
 import gregtech.api.util.GTUtility;
 import gregtech.api.util.MultiblockTooltipBuilder;
 import gregtech.api.util.OverclockCalculator;
+import gregtech.api.util.VoidProtectionHelper;
 
 public class MTEMultiFurnace extends MTEAbstractMultiFurnace<MTEMultiFurnace> implements ISurvivalConstructable {
 
@@ -206,19 +207,50 @@ public CheckRecipeResult checkProcessing() {
         for (ItemStack item : tInputList) {
             ItemStack smeltedOutput = GTModHandler.getSmeltingOutput(item, false, null);
             if (smeltedOutput != null) {
-                if (remainingCost >= item.stackSize) {
+                int maxParallelForOutput = remainingCost;
+
+                // Initialize void protection for the current output
+                if (protectsExcessItem()) {
+                    VoidProtectionHelper voidProtectionHelper = new VoidProtectionHelper();
+                    voidProtectionHelper.setMachine(this)
+                        .setMaxParallel(remainingCost)
+                        .setVirtualItemOutputsInBus(smeltedOutputs.toArray(new ItemStack[0]))
+                        .setItemOutputs(new ItemStack[] { smeltedOutput })
+                        .build();
+
+                    maxParallelForOutput = Math.min(voidProtectionHelper.getMaxParallel(), remainingCost);
+
+                    if (maxParallelForOutput == 0) {
+                        continue;
+                    }
+                }
+
+                if (maxParallelForOutput >= item.stackSize) {
                     remainingCost -= item.stackSize;
                     smeltedOutput.stackSize *= item.stackSize;
                     item.stackSize = 0;
                     smeltedOutputs.add(smeltedOutput);
                 } else {
-                    smeltedOutput.stackSize *= remainingCost;
-                    item.stackSize -= remainingCost;
+                    remainingCost -= maxParallelForOutput;
+                    smeltedOutput.stackSize *= maxParallelForOutput;
+                    item.stackSize -= maxParallelForOutput;
                     smeltedOutputs.add(smeltedOutput);
+                }
+
+                if (remainingCost <= 0) {
                     break;
                 }
             }
         }
+
+        if (protectsExcessItem() && smeltedOutputs.isEmpty()) {
+            return CheckRecipeResultRegistry.ITEM_OUTPUT_FULL;
+        }
+
+        if (isBatchModeEnabled()) {
+            batchMultiplierMax = Math.max(1, batchMultiplierMax * (finalParallel - remainingCost) / finalParallel);
+        }
+
         this.mOutputItems = smeltedOutputs.toArray(new ItemStack[0]);
 
         this.mEfficiency = 10000 - (getIdealStatus() - getRepairStatus()) * 1000;
@@ -376,4 +408,9 @@ public boolean onWireCutterRightClick(ForgeDirection side, ForgeDirection wrench
         }
         return true;
     }
+
+    @Override
+    public boolean supportsVoidProtection() {
+        return true;
+    }
 }