optimize parallel algorithm

Former-commit-id: b4d3eeaa77c61c2597326a3e659c008c07087779

4 files changed, 197 insertions, 8 deletions

diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/common/tileentities/multis/mega/GT_TileEntity_MegaBlastFurnace.java b/src/main/java/com/github/bartimaeusnek/bartworks/common/tileentities/multis/mega/GT_TileEntity_MegaBlastFurnace.java
index 7213e7de25..8a018d9c2a 100644
--- a/src/main/java/com/github/bartimaeusnek/bartworks/common/tileentities/multis/mega/GT_TileEntity_MegaBlastFurnace.java
+++ b/src/main/java/com/github/bartimaeusnek/bartworks/common/tileentities/multis/mega/GT_TileEntity_MegaBlastFurnace.java
@@ -59,6 +59,7 @@ import net.minecraftforge.fluids.FluidStack;
 import java.util.*;
 import java.util.stream.Collectors;
 
+import static com.github.bartimaeusnek.bartworks.util.RecipeFinderForParallel.handleParallelRecipe;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlockAdder;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
 import static gregtech.api.enums.GT_Values.V;
@@ -390,7 +391,39 @@ public class GT_TileEntity_MegaBlastFurnace extends GT_MetaTileEntity_ElectricBl
         int tHeatCapacityDivTiers = (this.mHeatingCapacity - tRecipe.mSpecialValue) / 900;
         long precutRecipeVoltage = (long) (tRecipe.mEUt * Math.pow(0.95, tHeatCapacityDivTiers));
 
-        while (this.getStoredInputs().size() > 0 && processed < ConfigHandler.megaMachinesMax) {
+        long tMaxPara = Math.min(ConfigHandler.megaMachinesMax, nominalV / precutRecipeVoltage);
+
+        if (this.mHeatingCapacity >= tRecipe.mSpecialValue) {
+            int tCurrentPara = handleParallelRecipe(tRecipe, tFluids, tInputs, (int) tMaxPara);
+            processed = tCurrentPara;
+            found_Recipe = true;
+            if (tRecipe.mOutputs != null) {
+                for (int i = 0; i < tRecipe.mOutputs.length; i++) {
+                    tCurrentPara = processed;
+                    while (tCurrentPara > 0 && tRecipe.getOutput(i) != null) {
+                        int maxSize = tRecipe.getOutput(i).getMaxStackSize();
+                        if (tCurrentPara <= maxSize) {
+                            outputItems.add(GT_Utility.copyAmount(maxSize, tRecipe.getOutput(i)));
+                            tCurrentPara -= maxSize;
+                        }
+                        else {
+                            outputItems.add(GT_Utility.copyAmount(tCurrentPara, tRecipe.getOutput(i)));
+                            tCurrentPara = 0;
+                        }
+                    }
+                }
+            }
+            if (tRecipe.mFluidOutputs != null) {
+                for (int i = 0; i < tRecipe.mFluidOutputs.length; i++) {
+                    while (tRecipe.getFluidOutput(i) != null) {
+                        FluidStack tOutputFluid = new FluidStack(tRecipe.getFluidOutput(i).getFluid(), tRecipe.getFluidOutput(i).amount * processed);
+                        outputFluids.add(tOutputFluid);
+                    }
+                }
+            }
+        }
+
+       /* while (this.getStoredInputs().size() > 0 && processed < ConfigHandler.megaMachinesMax) {
             if (this.mHeatingCapacity >= tRecipe.mSpecialValue && (precutRecipeVoltage * (processed + 1)) < nominalV && tRecipe.isRecipeInputEqual(true, tFluids, tInputs)) {
                 found_Recipe = true;
                 for (int i = 0; i < tRecipe.mOutputs.length; i++) {
@@ -402,7 +435,7 @@ public class GT_TileEntity_MegaBlastFurnace extends GT_MetaTileEntity_ElectricBl
                 ++processed;
             } else
                 break;
-        }
+        }*/
 
         if (found_Recipe) {
             this.mEfficiency = (10000 - (this.getIdealStatus() - this.getRepairStatus()) * 1000);
diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/common/tileentities/multis/mega/GT_TileEntity_MegaDistillTower.java b/src/main/java/com/github/bartimaeusnek/bartworks/common/tileentities/multis/mega/GT_TileEntity_MegaDistillTower.java
index 15105babf0..d365a75bd1 100644
--- a/src/main/java/com/github/bartimaeusnek/bartworks/common/tileentities/multis/mega/GT_TileEntity_MegaDistillTower.java
+++ b/src/main/java/com/github/bartimaeusnek/bartworks/common/tileentities/multis/mega/GT_TileEntity_MegaDistillTower.java
@@ -44,6 +44,7 @@ import net.minecraftforge.fluids.FluidStack;
 import java.util.ArrayList;
 import java.util.List;
 
+import static com.github.bartimaeusnek.bartworks.util.RecipeFinderForParallel.handleParallelRecipe;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
 import static gregtech.api.enums.GT_Values.V;
 import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
@@ -231,7 +232,24 @@ public class GT_TileEntity_MegaDistillTower extends GT_MetaTileEntity_Distillati
                 boolean found_Recipe = false;
                 FluidStack[] output;
                 GT_Recipe tRecipe = GT_Recipe.GT_Recipe_Map.sDistillationRecipes.findRecipe(this.getBaseMetaTileEntity(), false, GT_Values.V[tTier], new FluidStack[]{tFluid});
-                while (this.getStoredFluids().size() > 0 && processed < ConfigHandler.megaMachinesMax) {
+
+                if (tRecipe != null) {
+                    found_Recipe = true;
+                    long tMaxPara = Math.min(ConfigHandler.megaMachinesMax, nominalV / tRecipe.mEUt);
+                    int tCurrentPara = handleParallelRecipe(tRecipe, new FluidStack[]{tFluid}, null, (int) tMaxPara);
+                    processed = tCurrentPara;
+                    if (tRecipe.mFluidOutputs != null) {
+                        output = new FluidStack[tRecipe.mFluidOutputs.length];
+                        for (int i = 0; i < tRecipe.mFluidOutputs.length; i++) {
+                            if (tRecipe.getFluidOutput(i) != null) {
+                                output[i] = new FluidStack(tRecipe.getFluidOutput(i).getFluid(), tRecipe.getFluidOutput(i).amount * tCurrentPara);
+                            }
+                        }
+                        outputFluids.add(output);
+                    }
+                }
+
+               /* while (this.getStoredFluids().size() > 0 && processed < ConfigHandler.megaMachinesMax) {
                     if (tRecipe != null && (tRecipe.mEUt * (processed + 1)) < nominalV && tRecipe.isRecipeInputEqual(true, tFluids)) {
                         found_Recipe = true;
                         if (tRecipe.mFluidOutputs.length == 1 && tRecipe.mFluidOutputs[0].amount == 0)
@@ -244,14 +262,14 @@ public class GT_TileEntity_MegaDistillTower extends GT_MetaTileEntity_Distillati
                         ++processed;
                     } else
                         break;
-                }
+                }*/
                 if (!found_Recipe)
                     continue;
-                for (int j = 1; j < outputFluids.size(); j++) {
+                /*for (int j = 1; j < outputFluids.size(); j++) {
                     for (int k = 0; k < outputFluids.get(j).length; k++) {
                         outputFluids.get(0)[k].amount += outputFluids.get(j)[k].amount;
                     }
-                }
+                }*/
                 this.mEfficiency = (10000 - (this.getIdealStatus() - this.getRepairStatus()) * 1000);
                 this.mEfficiencyIncrease = 10000;
                 long actualEUT = (long) (tRecipe.mEUt) * processed;
diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/common/tileentities/multis/mega/GT_TileEntity_MegaVacuumFreezer.java b/src/main/java/com/github/bartimaeusnek/bartworks/common/tileentities/multis/mega/GT_TileEntity_MegaVacuumFreezer.java
index 2fdaa545dc..c9febd1fa8 100644
--- a/src/main/java/com/github/bartimaeusnek/bartworks/common/tileentities/multis/mega/GT_TileEntity_MegaVacuumFreezer.java
+++ b/src/main/java/com/github/bartimaeusnek/bartworks/common/tileentities/multis/mega/GT_TileEntity_MegaVacuumFreezer.java
@@ -45,6 +45,7 @@ import net.minecraftforge.fluids.FluidStack;
 import java.util.ArrayList;
 import java.util.List;
 
+import static com.github.bartimaeusnek.bartworks.util.RecipeFinderForParallel.handleParallelRecipe;
 import static gregtech.api.enums.GT_Values.V;
 
 @Optional.Interface(iface = "com.github.bartimaeusnek.crossmod.tectech.TecTechEnabledMulti", modid = "tectech", striprefs = true)
@@ -108,7 +109,38 @@ public class GT_TileEntity_MegaVacuumFreezer extends GT_MetaTileEntity_VacuumFre
         boolean found_Recipe = false;
         int processed = 0;
 
-        while ((this.getStoredInputs().size() > 0 || this.getStoredFluids().size() > 0) && processed < ConfigHandler.megaMachinesMax) {
+        if (tRecipe != null) {
+            found_Recipe = true;
+            long tMaxPara = Math.min(ConfigHandler.megaMachinesMax, nominalV / tRecipe.mEUt);
+            int tCurrentPara = handleParallelRecipe(tRecipe, tInputFluids, tInputs, (int) tMaxPara);
+            processed = tCurrentPara;
+            if (tRecipe.mOutputs != null) {
+                for (int i = 0; i < tRecipe.mOutputs.length; i++) {
+                    tCurrentPara = processed;
+                    while (tCurrentPara > 0 && tRecipe.getOutput(i) != null) {
+                        int maxSize = tRecipe.getOutput(i).getMaxStackSize();
+                        if (tCurrentPara <= maxSize) {
+                            outputItems.add(GT_Utility.copyAmount(maxSize, tRecipe.getOutput(i)));
+                            tCurrentPara -= maxSize;
+                        }
+                        else {
+                            outputItems.add(GT_Utility.copyAmount(tCurrentPara, tRecipe.getOutput(i)));
+                            tCurrentPara = 0;
+                        }
+                    }
+                }
+            }
+            if (tRecipe.mFluidOutputs != null) {
+                for (int i = 0; i < tRecipe.mFluidOutputs.length; i++) {
+                    while (tRecipe.getFluidOutput(i) != null) {
+                        FluidStack tOutputFluid = new FluidStack(tRecipe.getFluidOutput(i).getFluid(), tRecipe.getFluidOutput(i).amount * processed);
+                        outputFluids.add(tOutputFluid);
+                    }
+                }
+            }
+        }
+
+        /*while ((this.getStoredInputs().size() > 0 || this.getStoredFluids().size() > 0) && processed < ConfigHandler.megaMachinesMax) {
             if (tRecipe != null && ((long) tRecipe.mEUt * (processed + 1)) < nominalV && tRecipe.isRecipeInputEqual(true, tInputFluids, tInputs)) {
                 found_Recipe = true;
                 if (tRecipe.mOutputs != null) {
@@ -124,7 +156,7 @@ public class GT_TileEntity_MegaVacuumFreezer extends GT_MetaTileEntity_VacuumFre
                 ++processed;
             } else
                 break;
-        }
+        }*/
 
         if (found_Recipe) {
             this.mEfficiency = (10000 - (this.getIdealStatus() - this.getRepairStatus()) * 1000);
diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/util/RecipeFinderForParallel.java b/src/main/java/com/github/bartimaeusnek/bartworks/util/RecipeFinderForParallel.java
new file mode 100644
index 0000000000..a0061564a6
--- /dev/null
+++ b/src/main/java/com/github/bartimaeusnek/bartworks/util/RecipeFinderForParallel.java
@@ -0,0 +1,106 @@
+package com.github.bartimaeusnek.bartworks.util;
+
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+import java.util.HashMap;
+
+public class RecipeFinderForParallel {
+
+    /**
+        This method is used for mega multis which have extremely high parallel.<BR>
+        Never use it for non parallel machines, it will have worse performance.<BR>
+     */
+
+    public static int handleParallelRecipe(GT_Recipe aRecipe, FluidStack[] aFluidInputs, ItemStack[] aItemStacks, int aMaxParallel) {
+        HashMap<Integer, Integer> tCompressedFluidInput = compressFluid(aFluidInputs);
+        HashMap<Integer, Integer> tCompressedItemInput = compressItem(aItemStacks);
+        HashMap<Integer, Integer> tCompressedFluidRecipe = compressFluid(aRecipe.mFluidInputs);
+        HashMap<Integer, Integer> tCompressedItemRecipe = compressItem(aRecipe.mInputs);
+        int tCurrentPara = aMaxParallel;
+        for (int tFluid : tCompressedFluidRecipe.keySet()) {
+            if (tCompressedFluidInput.containsKey(tFluid) && tCompressedFluidRecipe.get(tFluid) != 0) {
+                tCurrentPara = Math.min(tCurrentPara, tCompressedFluidInput.get(tFluid) / tCompressedFluidRecipe.get(tFluid));
+            }
+        }
+        for (int tItem : tCompressedItemRecipe.keySet()) {
+            if (tCompressedItemInput.containsKey(tItem) && tCompressedItemRecipe.get(tItem) != 0) {
+                tCurrentPara = Math.min(tCurrentPara, tCompressedItemInput.get(tItem) / tCompressedItemRecipe.get(tItem));
+            }
+        }
+
+        for (int tFluid : tCompressedFluidRecipe.keySet()) {
+            int tOldSize = tCompressedFluidRecipe.get(tFluid);
+            tCompressedFluidRecipe.put(tFluid, tOldSize * tCurrentPara);
+        }
+        for (int tItem : tCompressedItemRecipe.keySet()) {
+            int tOldSize = tCompressedItemRecipe.get(tItem);
+            tCompressedItemRecipe.put(tItem, tOldSize * tCurrentPara);
+        }
+
+        for (FluidStack tFluid : aFluidInputs) {
+            if (tFluid != null && tCompressedFluidRecipe.containsKey(tFluid.getFluidID())) {
+                if (tFluid.amount >= tCompressedFluidRecipe.get(tFluid.getFluidID())) {
+                    tFluid.amount -= tCompressedFluidRecipe.get(tFluid.getFluidID());
+                    tCompressedItemRecipe.remove(tFluid.getFluidID());
+                }
+                else {
+                    tCompressedFluidRecipe.put(tFluid.getFluidID(), tCompressedFluidRecipe.get(tFluid.getFluidID()) - tFluid.amount);
+                    tFluid.amount = 0;
+                }
+            }
+        }
+
+        for (ItemStack tItem : aItemStacks) {
+            if (tItem != null && tCompressedItemRecipe.containsKey(GT_Utility.stackToInt(tItem))) {
+                if (tItem.stackSize >= tCompressedItemRecipe.get(GT_Utility.stackToInt(tItem))) {
+                    tItem.stackSize -= tCompressedItemRecipe.get(GT_Utility.stackToInt(tItem));
+                    tCompressedItemRecipe.remove(GT_Utility.stackToInt(tItem));
+                }
+                else {
+                    tCompressedItemRecipe.put(GT_Utility.stackToInt(tItem), tCompressedItemRecipe.get(GT_Utility.stackToInt(tItem)) - tItem.stackSize);
+                    tItem.stackSize = 0;
+                }
+            }
+        }
+        return tCurrentPara;
+    }
+
+    public static HashMap<Integer, Integer> compressItem(ItemStack[] aItemStacks) {
+        HashMap<Integer, Integer> tCompressed = new HashMap<>();
+        for (ItemStack tItem : aItemStacks) {
+            if (tItem != null) {
+                int tItemID = GT_Utility.stackToInt(tItem);
+                int tItemSize = tItem.stackSize;
+                if (tCompressed.containsKey(tItemID)) {
+                    int tOldSize = tCompressed.get(tItemID);
+                    tCompressed.put(tItemID, tOldSize + tItemSize);
+                }
+                else {
+                    tCompressed.put(tItemID, tItemSize);
+                }
+            }
+        }
+        return tCompressed;
+    }
+
+    public static HashMap<Integer, Integer> compressFluid(FluidStack[] aFluidStack) {
+        HashMap<Integer, Integer> tCompressed = new HashMap<>();
+        for (FluidStack tFluid : aFluidStack) {
+            if (tFluid != null) {
+                int tFluidID = tFluid.getFluidID();
+                int tFluidSize = tFluid.amount;
+                if (tCompressed.containsKey(tFluidID)) {
+                    int tOldSize = tCompressed.get(tFluidID);
+                    tCompressed.put(tFluidID, tOldSize + tFluidSize);
+                }
+                else {
+                    tCompressed.put(tFluidID, tFluidSize);
+                }
+            }
+        }
+        return tCompressed;
+    }
+}