Fix steam macerator generating byproducts And use new API from GT5u (#708)

* fix steam macerator generating byproducts

* spotless

* update dep

(cherry picked from commit 0659b1bd8c4a29b571e9f6f71f74ed55cb20ecd1)

* make QFT use new API

* override correct createOverclockCalculator

* spotless

* fix fishing pond causing an NPE

* make tree growth simulator only use void protection

* update dep

---------

Co-authored-by: Martin Robertz <dream-master@gmx.net>

9 files changed, 142 insertions, 94 deletions

diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialAlloySmelter.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialAlloySmelter.java
index 0a8df0f104..44d154f757 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialAlloySmelter.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialAlloySmelter.java
@@ -29,7 +29,6 @@ import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.logic.ProcessingLogic;
 import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
 import gregtech.api.util.GT_OverclockCalculator;
-import gregtech.api.util.GT_ParallelHelper;
 import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Utility;
 import gtPlusPlus.core.block.ModBlocks;
@@ -186,10 +185,9 @@ public class GregtechMetaTileEntity_IndustrialAlloySmelter extends
 
             @NotNull
             @Override
-            protected GT_OverclockCalculator createOverclockCalculator(@NotNull GT_Recipe recipe,
-                    @NotNull GT_ParallelHelper helper) {
-                return super.createOverclockCalculator(recipe, helper).setSpeedBoost(100F / (100F + 5F * mLevel))
-                        .enableHeatOC().setRecipeHeat(0)
+            protected GT_OverclockCalculator createOverclockCalculator(@NotNull GT_Recipe recipe) {
+                return super.createOverclockCalculator(recipe).setSpeedBoost(100F / (100F + 5F * mLevel))
+                        .setHeatOC(true).setRecipeHeat(0)
                         // Need to multiply by 2 because heat OC is done only once every 1800 and this one does it once
                         // every
                         // 900
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialDehydrator.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialDehydrator.java
index c435e87938..61782003ce 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialDehydrator.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialDehydrator.java
@@ -36,7 +36,6 @@ import gregtech.api.recipe.check.CheckRecipeResultRegistry;
 import gregtech.api.util.GTPP_Recipe;
 import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
 import gregtech.api.util.GT_OverclockCalculator;
-import gregtech.api.util.GT_ParallelHelper;
 import gregtech.api.util.GT_Recipe;
 import gtPlusPlus.core.block.ModBlocks;
 import gtPlusPlus.core.lib.CORE;
@@ -189,9 +188,8 @@ public class GregtechMetaTileEntity_IndustrialDehydrator extends
 
             @NotNull
             @Override
-            protected GT_OverclockCalculator createOverclockCalculator(@NotNull GT_Recipe recipe,
-                    @NotNull GT_ParallelHelper helper) {
-                return super.createOverclockCalculator(recipe, helper).enableHeatOC().enableHeatDiscount()
+            protected GT_OverclockCalculator createOverclockCalculator(@NotNull GT_Recipe recipe) {
+                return super.createOverclockCalculator(recipe).setHeatOC(true).setHeatDiscount(true)
                         .setRecipeHeat(recipe.mSpecialValue).setMultiHeat((int) getCoilLevel().getHeat());
             }
         }.setSpeedBonus(1F / 2.2F).setEuModifier(0.5F).setMaxParallelSupplier(this::getMaxParallelRecipes);
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/advanced/GregtechMetaTileEntity_Adv_EBF.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/advanced/GregtechMetaTileEntity_Adv_EBF.java
index 42e117cce9..001c3624f9 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/advanced/GregtechMetaTileEntity_Adv_EBF.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/advanced/GregtechMetaTileEntity_Adv_EBF.java
@@ -42,7 +42,6 @@ import gregtech.api.recipe.check.CheckRecipeResult;
 import gregtech.api.recipe.check.CheckRecipeResultRegistry;
 import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
 import gregtech.api.util.GT_OverclockCalculator;
-import gregtech.api.util.GT_ParallelHelper;
 import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Utility;
 import gtPlusPlus.core.block.ModBlocks;
@@ -240,9 +239,8 @@ public class GregtechMetaTileEntity_Adv_EBF extends GregtechMeta_MultiBlockBase<
 
             @NotNull
             @Override
-            protected GT_OverclockCalculator createOverclockCalculator(@NotNull GT_Recipe recipe,
-                    @NotNull GT_ParallelHelper helper) {
-                return super.createOverclockCalculator(recipe, helper).enableHeatOC().enableHeatDiscount()
+            protected GT_OverclockCalculator createOverclockCalculator(@NotNull GT_Recipe recipe) {
+                return super.createOverclockCalculator(recipe).setHeatOC(true).setHeatDiscount(true)
                         .setRecipeHeat(recipe.mSpecialValue).setMultiHeat((int) getCoilLevel().getHeat());
             }
         }.setSpeedBonus(1F / 2.2F).setEuModifier(0.9F).setMaxParallelSupplier(this::getMaxParallelRecipes);
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/steam/GregtechMetaTileEntity_SteamMacerator.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/steam/GregtechMetaTileEntity_SteamMacerator.java
index 0efa2d1220..eccdc64f70 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/steam/GregtechMetaTileEntity_SteamMacerator.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/steam/GregtechMetaTileEntity_SteamMacerator.java
@@ -7,6 +7,10 @@ import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose
 import static gregtech.api.GregTech_API.sBlockCasings1;
 import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
 
+import java.util.ArrayList;
+
+import javax.annotation.Nonnull;
+
 import net.minecraft.item.ItemStack;
 
 import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
@@ -18,8 +22,10 @@ import gregtech.api.enums.ItemList;
 import gregtech.api.enums.Textures;
 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.logic.ProcessingLogic;
 import gregtech.api.objects.GT_RenderedTexture;
 import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_ParallelHelper;
 import gregtech.api.util.GT_Recipe;
 import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_SteamMultiBase;
@@ -123,4 +129,24 @@ public class GregtechMetaTileEntity_SteamMacerator
         return GT_Recipe.GT_Recipe_Map.sMaceratorRecipes;
     }
 
+    @Override
+    protected ProcessingLogic createProcessingLogic() {
+        return new ProcessingLogic() {
+
+            @Override
+            @Nonnull
+            public GT_ParallelHelper createParallelHelper(@Nonnull GT_Recipe recipe) {
+                return super.createParallelHelper(recipe).setCustomItemOutputCalculation(parallel -> {
+                    ArrayList<ItemStack> items = new ArrayList<>();
+                    ItemStack output = recipe.getOutput(0);
+                    if (output != null) {
+                        output = output.copy();
+                        output.stackSize *= parallel;
+                        items.add(output);
+                    }
+                    return items.toArray(new ItemStack[0]);
+                });
+            }
+        };
+    }
 }
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMTE_NuclearReactor.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMTE_NuclearReactor.java
index cf5b088542..9f91316621 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMTE_NuclearReactor.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMTE_NuclearReactor.java
@@ -44,7 +44,6 @@ import gregtech.api.render.TextureFactory;
 import gregtech.api.util.GTPP_Recipe.GTPP_Recipe_Map;
 import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
 import gregtech.api.util.GT_OverclockCalculator;
-import gregtech.api.util.GT_ParallelHelper;
 import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Recipe.GT_Recipe_Map;
 import gtPlusPlus.core.block.ModBlocks;
@@ -356,8 +355,7 @@ public class GregtechMTE_NuclearReactor extends GregtechMeta_MultiBlockBase<Greg
 
             @NotNull
             @Override
-            protected GT_OverclockCalculator createOverclockCalculator(@NotNull GT_Recipe recipe,
-                    @NotNull GT_ParallelHelper helper) {
+            protected GT_OverclockCalculator createOverclockCalculator(@NotNull GT_Recipe recipe) {
                 return GT_OverclockCalculator.ofNoOverclock(recipe.mSpecialValue * 4L, recipe.mDuration);
             }
 
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntityTreeFarm.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntityTreeFarm.java
index 087338fe95..fb4a210d84 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntityTreeFarm.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntityTreeFarm.java
@@ -59,9 +59,8 @@ import gregtech.api.recipe.check.SimpleCheckRecipeResult;
 import gregtech.api.util.GTPP_Recipe.GTPP_Recipe_Map;
 import gregtech.api.util.GT_ModHandler;
 import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
-import gregtech.api.util.GT_ParallelHelper;
-import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Utility;
+import gregtech.api.util.VoidProtectionHelper;
 import gtPlusPlus.api.objects.Logger;
 import gtPlusPlus.core.block.ModBlocks;
 import gtPlusPlus.core.item.ModItems;
@@ -205,17 +204,10 @@ public class GregtechMetaTileEntityTreeFarm extends GregtechMeta_MultiBlockBase<
             toOutput = new ItemStack[] { ItemUtils.getSimpleStack(mWood, amplifiedOutputAmount) };
         }
 
-        GT_Recipe tRecipe = new GT_Recipe(null, toOutput, null, null, null, null, 0, 0, 0);
+        VoidProtectionHelper voidProtection = new VoidProtectionHelper().setMachine(this).setItemOutputs(toOutput)
+                .build();
 
-        GT_ParallelHelper helper = new GT_ParallelHelper().setRecipe(tRecipe).setAvailableEUt(tVoltage)
-                .setMachine(this);
-
-        if (batchMode) {
-            helper.enableBatchMode(128);
-        }
-
-        helper.build();
-        if (helper.getCurrentParallel() == 0) {
+        if (voidProtection.getMaxParallel() == 0) {
             return CheckRecipeResultRegistry.OUTPUT_FULL;
         }
 
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntity_IndustrialFishingPond.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntity_IndustrialFishingPond.java
index f0ac233b3c..c992e90947 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntity_IndustrialFishingPond.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntity_IndustrialFishingPond.java
@@ -216,13 +216,12 @@ public class GregtechMetaTileEntity_IndustrialFishingPond extends
                     200,
                     16,
                     0);
+            GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(g.mEUt).setEUt(tEnergy)
+                    .setDuration(g.mDuration);
             GT_ParallelHelper helper = new GT_ParallelHelper().setRecipe(g).setItemInputs(tItemInputs)
                     .setFluidInputs(tFluidInputs).setAvailableEUt(tEnergy).setMaxParallel(getMaxParallelRecipes())
-                    .enableConsumption().enableOutputCalculation().setMachine(this);
-
-            if (batchMode) {
-                helper.enableBatchMode(128);
-            }
+                    .setConsumption(true).setOutputCalculation(true).setMachine(this)
+                    .enableBatchMode(batchMode ? 128 : 1).setCalculator(calculator);
 
             helper.build();
 
@@ -233,10 +232,6 @@ public class GregtechMetaTileEntity_IndustrialFishingPond extends
             this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000);
             this.mEfficiencyIncrease = 10000;
 
-            GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(g.mEUt).setEUt(tEnergy)
-                    .setDuration(g.mDuration)
-                    .setParallel((int) Math.floor(helper.getCurrentParallel() / helper.getDurationMultiplierDouble()))
-                    .calculate();
             lEUt = -calculator.getConsumption();
             mMaxProgresstime = (int) Math.ceil(calculator.getDuration() * helper.getDurationMultiplierDouble());
 
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntity_QuantumForceTransformer.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntity_QuantumForceTransformer.java
index f7f43644bb..e1ca56c953 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntity_QuantumForceTransformer.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntity_QuantumForceTransformer.java
@@ -12,12 +12,16 @@ import static gregtech.api.enums.GT_HatchElement.Maintenance;
 import static gregtech.api.enums.GT_HatchElement.OutputBus;
 import static gregtech.api.enums.GT_HatchElement.OutputHatch;
 import static gregtech.api.util.GT_OreDictUnificator.getAssociation;
+import static gregtech.api.util.GT_RecipeBuilder.BUCKETS;
+import static gregtech.api.util.GT_RecipeBuilder.INGOTS;
 import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
+import javax.annotation.Nonnull;
+
 import net.minecraft.block.Block;
 import net.minecraft.client.renderer.RenderBlocks;
 import net.minecraft.client.renderer.Tessellator;
@@ -64,6 +68,7 @@ import gregtech.api.recipe.check.SimpleCheckRecipeResult;
 import gregtech.api.render.TextureFactory;
 import gregtech.api.util.GTPP_Recipe;
 import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_ParallelHelper;
 import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Utility;
 import gtPlusPlus.core.block.ModBlocks;
@@ -502,68 +507,108 @@ public class GregtechMetaTileEntity_QuantumForceTransformer
 
             @NotNull
             @Override
-            public CheckRecipeResult process() {
-                CheckRecipeResult result = super.process();
-                if (result.wasSuccessful()) {
-                    List<ItemStack> generatedItems = new ArrayList<>();
-                    List<FluidStack> generatedFluids = new ArrayList<>();
+            public GT_ParallelHelper createParallelHelper(@Nonnull GT_Recipe recipe) {
+                return super.createParallelHelper(recipe).setCustomItemOutputCalculation(parallel -> {
+                    ArrayList<ItemStack> items = new ArrayList<>();
                     if (mFluidMode) {
-                        for (int i = 0; i < chances.length; i++) {
-                            if (getBaseMetaTileEntity().getRandomNumber(10000) < chances[i]) {
-                                ItemData data = getAssociation(lastRecipe.getOutput(i));
-                                Materials mat = data == null ? null : data.mMaterial.mMaterial;
-                                if (i < lastRecipe.mOutputs.length) {
-                                    if (mat != null) {
-                                        if (mat.getMolten(0) != null) {
-                                            generatedFluids.add(
-                                                    mat.getMolten(
-                                                            lastRecipe.getOutput(i).stackSize * 144L
-                                                                    * calculatedParallels));
-                                        } else if (mat.getFluid(0) != null) {
-                                            generatedFluids.add(
-                                                    mat.getFluid(
-                                                            lastRecipe.getOutput(i).stackSize * 1000L
-                                                                    * calculatedParallels));
-                                        } else {
-                                            ItemStack aItem = lastRecipe.getOutput(i);
-                                            generatedItems.add(
-                                                    GT_Utility.copyAmountUnsafe(
-                                                            (long) aItem.stackSize * calculatedParallels,
-                                                            aItem));
-                                        }
-                                    } else {
-                                        ItemStack aItem = lastRecipe.getOutput(i);
-                                        generatedItems.add(
-                                                GT_Utility.copyAmountUnsafe(
-                                                        (long) aItem.stackSize * calculatedParallels,
-                                                        aItem));
-                                    }
-                                } else {
-                                    FluidStack aFluid = lastRecipe.getFluidOutput(i - lastRecipe.mOutputs.length);
-                                    generatedFluids.add(new FluidStack(aFluid, aFluid.amount * calculatedParallels));
+                        for (int i = 0; i < recipe.mOutputs.length; i++) {
+                            ItemStack item = recipe.getOutput(i);
+                            if (item == null) continue;
+                            ItemData data = getAssociation(item);
+                            Materials mat = data == null ? null : data.mMaterial.mMaterial;
+                            if (mat != null) {
+                                if (mat.getMolten(0) != null) {
+                                    continue;
+                                } else if (mat.getFluid(0) != null) {
+                                    continue;
+                                }
+                            }
+                            ItemStack itemToAdd = item.copy();
+                            itemToAdd.stackSize = 0;
+                            for (int j = 0; j < parallel; j++) {
+                                if (getBaseMetaTileEntity().getRandomNumber(10000) < chances[i]) {
+                                    itemToAdd.stackSize += item.stackSize;
                                 }
                             }
+                            if (itemToAdd.stackSize == 0) {
+                                continue;
+                            }
+                            items.add(itemToAdd);
                         }
                     } else {
-                        for (int i = 0; i < chances.length; i++) {
-                            if (getBaseMetaTileEntity().getRandomNumber(10000) < chances[i]) {
-                                if (i < lastRecipe.mOutputs.length) {
-                                    ItemStack aItem = lastRecipe.getOutput(i).copy();
-                                    aItem.stackSize *= calculatedParallels;
-                                    generatedItems.add(aItem);
-                                } else {
-                                    FluidStack aFluid = lastRecipe.getFluidOutput(i - lastRecipe.mOutputs.length)
-                                            .copy();
-                                    aFluid.amount *= calculatedParallels;
-                                    generatedFluids.add(aFluid);
+                        for (int i = 0; i < recipe.mOutputs.length; i++) {
+                            ItemStack item = recipe.getOutput(i);
+                            if (item == null) continue;
+                            ItemStack itemToAdd = item.copy();
+                            itemToAdd.stackSize = 0;
+                            for (int j = 0; j < parallel; j++) {
+                                if (getBaseMetaTileEntity().getRandomNumber(10000) < chances[i]) {
+                                    itemToAdd.stackSize += item.stackSize;
                                 }
                             }
+                            if (itemToAdd.stackSize == 0) {
+                                continue;
+                            }
+                            items.add(itemToAdd);
                         }
                     }
-                    setOutputItems(generatedItems.toArray(new ItemStack[0]));
-                    setOutputFluids(generatedFluids.toArray(new FluidStack[0]));
-                }
-                return result;
+
+                    return items.toArray(new ItemStack[0]);
+                }).setCustomFluidOutputCalculation(parallel -> {
+                    ArrayList<FluidStack> fluids = new ArrayList<>();
+                    if (mFluidMode) {
+                        for (int i = 0; i < recipe.mOutputs.length; i++) {
+                            ItemStack item = recipe.getOutput(i);
+                            if (item == null) continue;
+                            ItemData data = getAssociation(item);
+                            Materials mat = data == null ? null : data.mMaterial.mMaterial;
+                            if (mat == null) {
+                                continue;
+                            }
+                            if (mat.getMolten(0) != null) {
+                                FluidStack fluid = mat.getMolten(0);
+                                for (int j = 0; j < parallel; j++) {
+                                    if (getBaseMetaTileEntity().getRandomNumber(10000) < chances[i]) {
+                                        fluid.amount += item.stackSize * INGOTS;
+                                    }
+                                }
+                                if (fluid.amount == 0) {
+                                    continue;
+                                }
+                                fluids.add(fluid);
+                            } else if (mat.getFluid(0) != null) {
+                                FluidStack fluid = mat.getFluid(0);
+                                for (int j = 0; j < parallel; j++) {
+                                    if (getBaseMetaTileEntity().getRandomNumber(10000) < chances[i]) {
+                                        fluid.amount += item.stackSize * BUCKETS;
+                                    }
+                                }
+                                if (fluid.amount == 0) {
+                                    continue;
+                                }
+                                fluids.add(fluid);
+                            }
+                        }
+                    }
+
+                    for (int i = 0; i < recipe.mFluidOutputs.length; i++) {
+                        FluidStack fluid = recipe.getFluidOutput(i);
+                        if (fluid == null) continue;
+                        FluidStack fluidToAdd = fluid.copy();
+                        fluidToAdd.amount = 0;
+                        for (int j = 0; j < parallel; j++) {
+                            if (getBaseMetaTileEntity().getRandomNumber(10000) < chances[i + recipe.mOutputs.length]) {
+                                fluidToAdd.amount += fluid.amount;
+                            }
+                        }
+                        if (fluidToAdd.amount == 0) {
+                            continue;
+                        }
+                        fluids.add(fluidToAdd);
+                    }
+
+                    return fluids.toArray(new FluidStack[0]);
+                });
             }
         };
     }
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/mega/GregTechMetaTileEntity_MegaAlloyBlastSmelter.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/mega/GregTechMetaTileEntity_MegaAlloyBlastSmelter.java
index 039937ea7f..edf3adf40b 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/mega/GregTechMetaTileEntity_MegaAlloyBlastSmelter.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/mega/GregTechMetaTileEntity_MegaAlloyBlastSmelter.java
@@ -49,7 +49,6 @@ import gregtech.api.render.TextureFactory;
 import gregtech.api.util.GTPP_Recipe;
 import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
 import gregtech.api.util.GT_OverclockCalculator;
-import gregtech.api.util.GT_ParallelHelper;
 import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Utility;
 import gtPlusPlus.core.block.ModBlocks;
@@ -175,9 +174,8 @@ public class GregTechMetaTileEntity_MegaAlloyBlastSmelter
 
             @NotNull
             @Override
-            protected GT_OverclockCalculator createOverclockCalculator(@NotNull GT_Recipe recipe,
-                    @NotNull GT_ParallelHelper helper) {
-                return super.createOverclockCalculator(recipe, helper)
+            protected GT_OverclockCalculator createOverclockCalculator(@NotNull GT_Recipe recipe) {
+                return super.createOverclockCalculator(recipe)
                         .setSpeedBoost((float) (1.0 - getCoilDiscount(coilLevel)));
             }
         }.setMaxParallel(MAX_PARALLELS);