Large Large & Larger Turbine Rework (#3075)

Co-authored-by: Daniel Mendes <steelux7@gmail.com>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: NotAPenguin <michiel.vandeginste@gmail.com>
Co-authored-by: Martin Robertz <dream-master@gmx.net>

21 files changed, 674 insertions, 651 deletions

diff --git a/src/main/java/goodgenerator/blocks/tileEntity/MTEExtremeHeatExchanger.java b/src/main/java/goodgenerator/blocks/tileEntity/MTEExtremeHeatExchanger.java
index c37a2026d4..582b9d04aa 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/MTEExtremeHeatExchanger.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/MTEExtremeHeatExchanger.java
@@ -210,10 +210,10 @@ public class MTEExtremeHeatExchanger extends MTETooltipMultiBlockBaseEM
             .addInfo(BLUE_PRINT_INFO)
             .addSeparator()
             .addController("Front bottom")
-            .addOtherStructurePart("Input Hatch", "Distilled water. Any bottom left/right side casing", 1)
-            .addOtherStructurePart("Output Hatch", "SC Steam/SH Steam/Steam. Any top layer casing", 2)
-            .addOtherStructurePart("Input Hatch", "Hot fluid or plasma. Front middle on 4th layer", 3)
-            .addOtherStructurePart("Output Hatch", "Cold fluid. Back middle on 4th layer", 4)
+            .addOtherStructurePart("Input Hatch", "distilled water", 1)
+            .addOtherStructurePart("Output Hatch", "SC Steam/SH Steam/Steam", 2)
+            .addOtherStructurePart("Input Hatch", "Hot fluid or plasma", 3)
+            .addOtherStructurePart("Output Hatch", "Cold fluid", 4)
             .addMaintenanceHatch("Any Casing", 1, 2, 5)
             .addCasingInfoMin("Robust Tungstensteel Machine Casings", 25, false)
             .toolTipFinisher("Good Generator");
@@ -268,8 +268,15 @@ public class MTEExtremeHeatExchanger extends MTETooltipMultiBlockBaseEM
             Fluid tReadySteam = transformed ? tRunningRecipe.getHeatedSteam() : tRunningRecipe.getNormalSteam();
             int waterAmount = (int) (this.mEUt / getUnitSteamPower(tReadySteam.getName())) / 160;
             if (waterAmount < 0) return false;
+            int steamToOutput;
             if (depleteInput(GTModHandler.getDistilledWater(waterAmount))) {
-                addOutput(new FluidStack(tReadySteam, waterAmount * 160));
+                if (tRunningRecipe.mFluidInputs[0].getUnlocalizedName()
+                    .contains("plasma")) {
+                    steamToOutput = waterAmount * 160 / 1000;
+                } else {
+                    steamToOutput = waterAmount * 160;
+                }
+                addOutput(new FluidStack(tReadySteam, steamToOutput));
             } else {
                 GTLog.exp.println(this.mName + " had no more Distilled water!");
                 mHotFluidHatch.getBaseMetaTileEntity()
@@ -281,16 +288,13 @@ public class MTEExtremeHeatExchanger extends MTETooltipMultiBlockBaseEM
     }
 
     public double getUnitSteamPower(String steam) {
-        switch (steam) {
-            case "steam":
-                return 0.5;
-            case "ic2superheatedsteam":
-                return 1;
-            case "supercriticalsteam":
-                return 100;
-            default:
-                return -1;
-        }
+        return switch (steam) {
+            case "steam" -> 0.5;
+            case "ic2superheatedsteam" -> 1;
+            case "supercriticalsteam" -> 100;
+            case "densesupercriticalsteam" -> 1;
+            default -> -1;
+        };
     }
 
     @Override
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/MTESupercriticalFluidTurbine.java b/src/main/java/goodgenerator/blocks/tileEntity/MTESupercriticalFluidTurbine.java
index a78046909a..e7ea94f3c8 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/MTESupercriticalFluidTurbine.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/MTESupercriticalFluidTurbine.java
@@ -24,6 +24,7 @@ import gregtech.api.render.TextureFactory;
 import gregtech.api.util.GTModHandler;
 import gregtech.api.util.GTUtility;
 import gregtech.api.util.MultiblockTooltipBuilder;
+import gregtech.api.util.TurbineStatCalculator;
 
 public class MTESupercriticalFluidTurbine extends MTELargeTurbineBase {
 
@@ -42,27 +43,14 @@ public class MTESupercriticalFluidTurbine extends MTELargeTurbineBase {
     }
 
     @Override
-    public int fluidIntoPower(ArrayList<FluidStack> aFluids, int aOptFlow, int aBaseEff) {
-        if (looseFit) {
-            aOptFlow *= 4;
-            double pow = Math.pow(1.1f, ((aBaseEff - 7500) / 10000F) * 20f);
-            if (aBaseEff > 10000) {
-                aOptFlow *= pow;
-                aBaseEff = 7500;
-            } else if (aBaseEff > 7500) {
-                aOptFlow *= pow;
-                aBaseEff *= 0.75f;
-            } else {
-                aBaseEff *= 0.75f;
-            }
-        }
+    public int fluidIntoPower(ArrayList<FluidStack> aFluids, TurbineStatCalculator turbine) {
+
         int tEU = 0;
         int totalFlow = 0; // Byproducts are based on actual flow
         int flow = 0;
-        int remainingFlow = GTUtility.safeInt((long) (aOptFlow * 1.25f)); // Allowed to use up to 125% of optimal flow.
-                                                                          // Variable required outside of loop for
-        // multi-hatch scenarios.
-        this.realOptFlow = aOptFlow;
+        this.realOptFlow = looseFit ? turbine.getOptimalLooseSteamFlow() : turbine.getOptimalSteamFlow();
+        int remainingFlow = GTUtility.safeInt((long) (realOptFlow * 1.25f)); // Allowed to use up to 125% of optimal
+                                                                             // flow.
 
         storedFluid = 0;
         FluidStack tSCSteam = FluidRegistry.getFluidStack("supercriticalsteam", 1);
@@ -80,20 +68,24 @@ public class MTESupercriticalFluidTurbine extends MTELargeTurbineBase {
         }
         if (totalFlow <= 0) return 0;
         tEU = totalFlow;
-        addOutput(GTModHandler.getSteam(totalFlow * 100));
-        if (totalFlow == aOptFlow) {
-            tEU = GTUtility.safeInt((long) tEU * (long) aBaseEff / 10000L);
+        addOutput(GTModHandler.getSteam(totalFlow));
+        if (totalFlow == realOptFlow) {
+            tEU = GTUtility
+                .safeInt((long) (tEU * (looseFit ? turbine.getLooseSteamEfficiency() : turbine.getSteamEfficiency())));
         } else {
-            float efficiency = 1.0f - Math.abs((totalFlow - aOptFlow) / (float) aOptFlow);
+            float efficiency = 1.0f - (float) Math.abs((totalFlow - realOptFlow) / (float) realOptFlow);
             tEU *= efficiency;
-            tEU = Math.max(1, GTUtility.safeInt((long) tEU * (long) aBaseEff / 10000L));
+            tEU = Math.max(
+                1,
+                GTUtility.safeInt(
+                    (long) (tEU * (looseFit ? turbine.getLooseSteamEfficiency() : turbine.getSteamEfficiency()))));
         }
 
         if (tEU > maxPower) {
             tEU = GTUtility.safeInt(maxPower);
         }
 
-        return tEU * 100;
+        return tEU;
     }
 
     @Override
@@ -153,8 +145,7 @@ public class MTESupercriticalFluidTurbine extends MTELargeTurbineBase {
             .addInfo("Controller block for Supercritical Fluid Turbine")
             .addInfo("Needs a Turbine, place inside controller")
             .addInfo("Use Supercritical Steam to generate power.")
-            .addInfo("Outputs 100L of Steam per 1L of SC Steam as well as producing power")
-            .addInfo("1L Supercritical Steam = 100 EU")
+            .addInfo("Outputs 1L of Steam per 1L of SC Steam as well as producing power")
             .addInfo("Extreme Heated Steam will cause more damage to the turbine.")
             .addInfo("Power output depends on turbine and fitting")
             .addInfo("Use screwdriver to adjust fitting of turbine")
@@ -165,6 +156,7 @@ public class MTESupercriticalFluidTurbine extends MTELargeTurbineBase {
             .addDynamoHatch("Back center", 1)
             .addMaintenanceHatch("Side centered", 2)
             .addInputHatch("Supercritical Fluid, Side centered", 2)
+            .addOutputHatch("Superheated Steam, Side centered", 3)
             .toolTipFinisher("Good Generator");
         return tt;
     }
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/base/MTELargeTurbineBase.java b/src/main/java/goodgenerator/blocks/tileEntity/base/MTELargeTurbineBase.java
index 1c298d2b9a..086aa28528 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/base/MTELargeTurbineBase.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/base/MTELargeTurbineBase.java
@@ -35,6 +35,8 @@ import gregtech.api.metatileentity.implementations.MTEHatchMuffler;
 import gregtech.api.recipe.check.CheckRecipeResult;
 import gregtech.api.recipe.check.CheckRecipeResultRegistry;
 import gregtech.api.util.GTUtility;
+import gregtech.api.util.TurbineStatCalculator;
+import gregtech.api.util.shutdown.ShutDownReasonRegistry;
 import gregtech.common.items.MetaGeneratedTool01;
 
 public abstract class MTELargeTurbineBase extends MTEEnhancedMultiBlockBase<MTELargeTurbineBase>
@@ -79,6 +81,7 @@ public abstract class MTELargeTurbineBase extends MTEEnhancedMultiBlockBase<MTEL
     protected int storedFluid = 0;
     protected int counter = 0;
     protected boolean looseFit = false;
+    protected int overflowMultiplier = 0;
     protected long maxPower = 0;
 
     public MTELargeTurbineBase(int aID, String aName, String aNameRegional) {
@@ -140,11 +143,17 @@ public abstract class MTELargeTurbineBase extends MTEEnhancedMultiBlockBase<MTEL
         if ((counter & 7) == 0 && (controllerSlot == null || !(controllerSlot.getItem() instanceof MetaGeneratedTool)
             || controllerSlot.getItemDamage() < 170
             || controllerSlot.getItemDamage() > 179)) {
-            stopMachine();
+            stopMachine(ShutDownReasonRegistry.NO_TURBINE);
             return CheckRecipeResultRegistry.NO_TURBINE_FOUND;
         }
+
+        TurbineStatCalculator turbine = new TurbineStatCalculator(
+            (MetaGeneratedTool) controllerSlot.getItem(),
+            controllerSlot);
+
         ArrayList<FluidStack> tFluids = getStoredFluids();
-        if (tFluids.size() > 0) {
+        if (!tFluids.isEmpty()) {
+
             if (baseEff == 0 || optFlow == 0
                 || counter >= 512
                 || this.getBaseMetaTileEntity()
@@ -152,17 +161,13 @@ public abstract class MTELargeTurbineBase extends MTEEnhancedMultiBlockBase<MTEL
                 || this.getBaseMetaTileEntity()
                     .hasInventoryBeenModified()) {
                 counter = 0;
-                baseEff = GTUtility.safeInt(
-                    (long) ((5F + ((MetaGeneratedTool) controllerSlot.getItem()).getToolCombatDamage(controllerSlot))
-                        * 1000F));
-                optFlow = GTUtility.safeInt(
-                    (long) Math.max(
-                        Float.MIN_NORMAL,
-                        ((MetaGeneratedTool) controllerSlot.getItem()).getToolStats(controllerSlot)
-                            .getSpeedMultiplier() * MetaGeneratedTool.getPrimaryMaterial(controllerSlot).mToolSpeed
-                            * 50));
+                baseEff = (int) turbine.getEfficiency();
+                optFlow = (int) turbine.getOptimalFlow();
+
+                overflowMultiplier = turbine.getOverflowEfficiency();
+
                 if (optFlow <= 0 || baseEff <= 0) {
-                    stopMachine(); // in case the turbine got removed
+                    stopMachine(ShutDownReasonRegistry.NONE); // in case the turbine got removed
                     return CheckRecipeResultRegistry.NO_FUEL_FOUND;
                 }
             } else {
@@ -170,8 +175,8 @@ public abstract class MTELargeTurbineBase extends MTEEnhancedMultiBlockBase<MTEL
             }
         }
 
-        int newPower = fluidIntoPower(tFluids, optFlow, baseEff); // How much the turbine should be producing with this
-                                                                  // flow
+        int newPower = fluidIntoPower(tFluids, turbine); // How much the turbine should be producing with this
+                                                         // flow
         int difference = newPower - this.mEUt; // difference between current output and new output
 
         // Magic numbers: can always change by at least 10 eu/t, but otherwise by at most 1 percent of the difference in
@@ -197,7 +202,7 @@ public abstract class MTELargeTurbineBase extends MTEEnhancedMultiBlockBase<MTEL
         }
     }
 
-    public abstract int fluidIntoPower(ArrayList<FluidStack> aFluids, int aOptFlow, int aBaseEff);
+    public abstract int fluidIntoPower(ArrayList<FluidStack> aFluids, TurbineStatCalculator turbine);
 
     @Override
     public int getDamageToComponent(ItemStack aStack) {
diff --git a/src/main/java/goodgenerator/loader/RecipeLoader2.java b/src/main/java/goodgenerator/loader/RecipeLoader2.java
index a66b9360d6..1c4c05948d 100644
--- a/src/main/java/goodgenerator/loader/RecipeLoader2.java
+++ b/src/main/java/goodgenerator/loader/RecipeLoader2.java
@@ -1843,7 +1843,7 @@ public class RecipeLoader2 {
             .addTo(plasmaForgeRecipes);
     }
 
-    public static float EHEEfficiencyMultiplier = 1.2f;
+    public static float EHEEfficiencyMultiplier = 0.9f;
 
     public static void FinishLoadRecipe() {
         for (GTRecipe plasmaFuel : RecipeMaps.plasmaFuels.getAllRecipes()) {
@@ -1872,13 +1872,13 @@ public class RecipeLoader2 {
                 if (output == null) output = FluidRegistry.getFluidStack("molten." + tOutName, tPlasma.amount);
                 if (output != null) {
                     long waterAmount = (long) (tUnit * EHEEfficiencyMultiplier * tPlasma.amount / 160);
-                    long criticalSteamAmount = (long) (tUnit * EHEEfficiencyMultiplier * tPlasma.amount / 100);
+                    long criticalSteamAmount = (long) (tUnit * EHEEfficiencyMultiplier * tPlasma.amount / 1000);
                     MyRecipeAdder.instance.addExtremeHeatExchangerRecipe(
                         tPlasma,
                         output,
                         FluidRegistry.getFluidStack("ic2distilledwater", (int) waterAmount),
                         FluidRegistry.getFluidStack("ic2superheatedsteam", 0), // Plasma always outputs SC steam.
-                        FluidRegistry.getFluidStack("supercriticalsteam", (int) criticalSteamAmount),
+                        Materials.DenseSupercriticalSteam.getGas(criticalSteamAmount),
                         1);
                 }
             }
diff --git a/src/main/java/gregtech/api/enums/Materials.java b/src/main/java/gregtech/api/enums/Materials.java
index 177dc4f589..5aa02b8094 100644
--- a/src/main/java/gregtech/api/enums/Materials.java
+++ b/src/main/java/gregtech/api/enums/Materials.java
@@ -948,6 +948,18 @@ public class Materials implements IColorModulationContainer, ISubTagContainer {
     public static Materials TengamAttuned;
     public static Materials TengamRaw;
 
+    public static Materials DenseSteam = makeDenseSteam();
+    private static Materials makeDenseSteam() {
+        return new MaterialBuilder(232, TextureSet.SET_FLUID , "Dense Steam").addCell().addGas().setRGB(255, 255, 255).setColor(Dyes.dyeWhite).constructMaterial();
+    }
+    public static Materials DenseSuperheatedSteam = makeDenseSuperheatedSteam();
+    private static Materials makeDenseSuperheatedSteam() {
+        return new MaterialBuilder(233, TextureSet.SET_FLUID , "Dense Superheated Steam").addCell().addGas().setRGB(255, 255, 255).setColor(Dyes.dyeWhite).constructMaterial();
+    }
+    public static Materials DenseSupercriticalSteam = makeDenseSupercriticalSteam();
+    private static Materials makeDenseSupercriticalSteam() {
+        return new MaterialBuilder(234, TextureSet.SET_FLUID , "Dense Supercritical Steam").addCell().addGas().setRGB(255, 255, 255).setColor(Dyes.dyeWhite).constructMaterial();
+    }
     // Activated Carbon Line and waterline chemicals
     public static Materials ActivatedCarbon;
     public static Materials PreActivatedCarbon;
diff --git a/src/main/java/gregtech/api/items/MetaGeneratedTool.java b/src/main/java/gregtech/api/items/MetaGeneratedTool.java
index 6487a67a6b..dd3d50b739 100644
--- a/src/main/java/gregtech/api/items/MetaGeneratedTool.java
+++ b/src/main/java/gregtech/api/items/MetaGeneratedTool.java
@@ -1,7 +1,6 @@
 package gregtech.api.items;
 
 import static gregtech.api.util.GTUtility.formatNumbers;
-import static gregtech.common.tileentities.machines.multi.MTELargeTurbineSteam.calculateLooseFlow;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -55,6 +54,7 @@ import gregtech.api.util.GTLanguageManager;
 import gregtech.api.util.GTModHandler;
 import gregtech.api.util.GTOreDictUnificator;
 import gregtech.api.util.GTUtility;
+import gregtech.api.util.TurbineStatCalculator;
 import gregtech.common.tools.ToolTurbine;
 import mods.railcraft.api.core.items.IToolCrowbar;
 import mrtjp.projectred.api.IScrewdriver;
@@ -428,165 +428,144 @@ public abstract class MetaGeneratedTool extends MetaBaseItem
                 // EU/t -> toolCombatDamage, toolSpeed
                 // Overflow Tier -> toolQuality
                 float aBaseEff = (5f + getToolCombatDamage(aStack)) * 1000f;
-
+                TurbineStatCalculator turbine = new TurbineStatCalculator((MetaGeneratedTool) aStack.getItem(), aStack);
                 // It was noted by IntelliJ that replacing ((GT_MetaGenerated_Tool) aStack.getItem()) with
                 // GT_MetaGenerated_Tool can have side effects. This refactoring will need tests.
                 @SuppressWarnings("AccessStaticViaInstance")
-                float aOptFlow = (Math.max(
-                    Float.MIN_NORMAL,
-                    ((MetaGeneratedTool) aStack.getItem()).getToolStats(aStack)
-                        .getSpeedMultiplier()
-                        * ((MetaGeneratedTool) aStack.getItem()).getPrimaryMaterial(aStack).mToolSpeed
-                        * 50F));
+                float aOptFlow = (Math.max(Float.MIN_NORMAL, turbine.getOptimalFlow()));
                 aList.add(
                     tOffset + 0,
                     EnumChatFormatting.GRAY + String.format(
                         transItem("001", "Durability: %s/%s"),
-                        "" + EnumChatFormatting.GREEN + formatNumbers(tMaxDamage - getToolDamage(aStack)) + " ",
-                        " " + formatNumbers(tMaxDamage)) + EnumChatFormatting.GRAY);
+                        "" + EnumChatFormatting.GREEN + formatNumbers(turbine.getCurrentDurability()) + " ",
+                        " " + formatNumbers(turbine.getMaxDurability())) + EnumChatFormatting.GRAY);
                 aList.add(
                     tOffset + 1,
                     EnumChatFormatting.GRAY + String.format(
-                        transItem("002", "%s lvl %s"),
-                        tMaterial.mLocalizedName + EnumChatFormatting.YELLOW,
+                        transItem("002", "%s Tier %s"),
+                        tMaterial.mLocalizedName + ":" + EnumChatFormatting.YELLOW,
                         "" + getHarvestLevel(aStack, "")) + EnumChatFormatting.GRAY);
                 aList.add(
                     tOffset + 2,
                     EnumChatFormatting.WHITE
                         + String.format(
-                            transItem("005", "Turbine Efficiency: %s"),
-                            "" + EnumChatFormatting.BLUE + (50.0F + (10.0F * getToolCombatDamage(aStack))))
+                            transItem("005", "Base Efficiency: %s"),
+                            "" + EnumChatFormatting.BLUE + (int) Math.ceil(turbine.getEfficiency() * 100))
                         + "%"
                         + EnumChatFormatting.GRAY);
                 aList.add(
                     tOffset + 3,
-                    EnumChatFormatting.WHITE + String.format(
-                        transItem("006", "Optimal Steam flow: %s L/t"),
-                        "" + EnumChatFormatting.GOLD
-                            + formatNumbers(
-                                GTUtility.safeInt(
-                                    (long) (Math.max(
-                                        Float.MIN_NORMAL,
-                                        tStats.getSpeedMultiplier() * getPrimaryMaterial(aStack).mToolSpeed
-                                            * (1000 * getPrimaryMaterial(aStack).mSteamMultiplier / 20)))))
-                            + EnumChatFormatting.GRAY));
+                    EnumChatFormatting.GRAY + transItem("006", "Fuel | Optimal Flow > EU/t Produced | Efficiency"));
                 aList.add(
                     tOffset + 4,
-                    EnumChatFormatting.WHITE + String.format(
-                        transItem("900", "Energy from Optimal Steam Flow: %s EU/t"),
-                        "" + EnumChatFormatting.GOLD
-                            + formatNumbers(
-                                GTUtility.safeInt(
-                                    (long) (Math.max(
-                                        Float.MIN_NORMAL,
-                                        tStats.getSpeedMultiplier() * getPrimaryMaterial(aStack).mToolSpeed
-                                            * (1000 * getPrimaryMaterial(aStack).mSteamMultiplier / 20))
-                                        * (50.0F + (10.0F * getToolCombatDamage(aStack)))
-                                        / 200)))
-                            + EnumChatFormatting.GRAY));
-                {
-                    float[] calculatedFlow = calculateLooseFlow(aOptFlow, aBaseEff);
-                    float aOptFlowLoose = calculatedFlow[0];
-                    float aBaseEffLoose = calculatedFlow[1];
-
-                    aList.add(
-                        tOffset + 5,
-                        EnumChatFormatting.AQUA + String.format(
-                            transItem("500", "Turbine Efficiency (Loose): %s"),
-                            "" + EnumChatFormatting.BLUE + (long) aBaseEffLoose / 100 + "%" + EnumChatFormatting.GRAY));
-                    aList.add(
-                        tOffset + 6,
-                        EnumChatFormatting.AQUA + String.format(
-                            transItem("501", "Optimal Steam flow (Loose): %s L/t"),
+                    EnumChatFormatting.WHITE + "  Steam "
+                        + EnumChatFormatting.GRAY
+                        + " | "
+                        + String.format(
+                            "%s L/t > %s EU/t | %s",
                             "" + EnumChatFormatting.GOLD
-                                + formatNumbers(((long) aOptFlowLoose * getPrimaryMaterial(aStack).mSteamMultiplier))
+                                + formatNumbers(GTUtility.safeInt((long) (turbine.getOptimalSteamFlow())))
+                                + EnumChatFormatting.GRAY,
+                            "" + EnumChatFormatting.DARK_GREEN
+                                + formatNumbers(GTUtility.safeInt((long) (turbine.getOptimalSteamEUt())))
+                                + EnumChatFormatting.GRAY,
+                            "" + EnumChatFormatting.BLUE
+                                + (int) (turbine.getSteamEfficiency() * 100)
+                                + "%"
                                 + EnumChatFormatting.GRAY));
-                    aList.add(
-                        tOffset + 7,
-                        EnumChatFormatting.AQUA + String.format(
-                            transItem("901", "Energy from Optimal Steam Flow (Loose): %s EU/t"),
+                aList.add(
+                    tOffset + 5,
+                    EnumChatFormatting.WHITE + "  Loose "
+                        + EnumChatFormatting.GRAY
+                        + " | "
+                        + String.format(
+                            "%s L/t > %s EU/t | %s",
                             "" + EnumChatFormatting.GOLD
-                                + formatNumbers(
-                                    ((long) aOptFlowLoose * getPrimaryMaterial(aStack).mSteamMultiplier / 10000)
-                                        * ((long) aBaseEffLoose / 2))
+                                + formatNumbers(GTUtility.safeInt((long) (turbine.getOptimalLooseSteamFlow())))
+                                + EnumChatFormatting.GRAY,
+                            "" + EnumChatFormatting.DARK_GREEN
+                                + formatNumbers(GTUtility.safeInt((long) (turbine.getOptimalLooseSteamEUt())))
+                                + EnumChatFormatting.GRAY,
+                            "" + EnumChatFormatting.BLUE
+                                + (int) (turbine.getLooseSteamEfficiency() * 100)
+                                + "%"
                                 + EnumChatFormatting.GRAY));
-                    aList.add(
-                        tOffset + 8,
-                        EnumChatFormatting.GRAY + "(Superheated Steam EU values are 2x those of Steam)");
-                }
                 aList.add(
-                    tOffset + 9,
-                    EnumChatFormatting.WHITE + String.format(
-                        transItem("902", "Optimal SC Steam flow: %s L/t"),
-                        "" + EnumChatFormatting.GOLD
-                            + formatNumbers(
-                                GTUtility.safeInt(
-                                    (long) (Math.max(
-                                        Float.MIN_NORMAL,
-                                        tStats.getSpeedMultiplier() * getPrimaryMaterial(aStack).mToolSpeed
-                                            * (1000f / 20f)))))
-                            + EnumChatFormatting.GRAY));
+                    tOffset + 6,
+                    EnumChatFormatting.DARK_GRAY + "  Supercritical and Superheated EU values are 2x");
                 aList.add(
-                    tOffset + 10,
-                    EnumChatFormatting.WHITE + String.format(
-                        transItem("903", "Energy from Optimal SC Steam Flow: %s EU/t"),
-                        "" + EnumChatFormatting.GOLD
-                            + formatNumbers(
-                                GTUtility.safeInt(
-                                    (long) (Math.max(
-                                        Float.MIN_NORMAL,
-                                        tStats.getSpeedMultiplier() * getPrimaryMaterial(aStack).mToolSpeed
-                                            * (1000f / 20f))
-                                        * (50.0F + (10.0F * getToolCombatDamage(aStack))))))
-                            + EnumChatFormatting.GRAY));
+                    tOffset + 7,
+                    EnumChatFormatting.AQUA + "  Gas "
+                        + EnumChatFormatting.GRAY
+                        + " | "
+                        + String.format(
+                            "%s EU/t > %s EU/t | %s",
+                            "" + EnumChatFormatting.GOLD
+                                + formatNumbers(GTUtility.safeInt((long) (turbine.getOptimalGasFlow())))
+                                + EnumChatFormatting.GRAY,
+                            "" + EnumChatFormatting.DARK_GREEN
+                                + formatNumbers(GTUtility.safeInt((long) (turbine.getOptimalGasEUt())))
+                                + EnumChatFormatting.GRAY,
+                            "" + EnumChatFormatting.BLUE
+                                + (int) (turbine.getGasEfficiency() * 100)
+                                + "%"
+                                + EnumChatFormatting.GRAY));
                 aList.add(
-                    tOffset + 11,
-                    EnumChatFormatting.LIGHT_PURPLE + String.format(
-                        transItem("007", "Energy from Optimal Gas Flow: %s EU/t"),
-                        "" + EnumChatFormatting.GOLD
-                            + formatNumbers(
-                                GTUtility.safeInt(
-                                    (long) (Math.max(
-                                        Float.MIN_NORMAL,
-                                        tStats.getSpeedMultiplier() * getPrimaryMaterial(aStack).mToolSpeed
-                                            * 50
-                                            * getPrimaryMaterial(aStack).mGasMultiplier)
-                                        * (50.0F + (10.0F * getToolCombatDamage(aStack)))
-                                        / 100)))
-                            + EnumChatFormatting.GRAY));
+                    tOffset + 8,
+                    EnumChatFormatting.AQUA + "  Loose "
+                        + EnumChatFormatting.GRAY
+                        + " | "
+                        + String.format(
+                            "%s EU/t > %s EU/t | %s",
+                            "" + EnumChatFormatting.GOLD
+                                + formatNumbers(GTUtility.safeInt((long) (turbine.getOptimalLooseGasFlow())))
+                                + EnumChatFormatting.GRAY,
+                            "" + EnumChatFormatting.DARK_GREEN
+                                + formatNumbers(GTUtility.safeInt((long) (turbine.getOptimalLooseGasEUt())))
+                                + EnumChatFormatting.GRAY,
+                            "" + EnumChatFormatting.BLUE
+                                + (int) (turbine.getLooseGasEfficiency() * 100)
+                                + "%"
+                                + EnumChatFormatting.GRAY));
                 aList.add(
-                    tOffset + 12,
-                    EnumChatFormatting.LIGHT_PURPLE + String.format(
-                        transItem("008", "Energy from Optimal Plasma Flow: %s EU/t"),
-                        "" + EnumChatFormatting.GOLD
-                            + formatNumbers(
-                                GTUtility.safeInt(
-                                    (long) (Math.max(
-                                        Float.MIN_NORMAL,
-                                        tStats.getSpeedMultiplier() * getPrimaryMaterial(aStack).mToolSpeed
-                                            * 2000
-                                            * getPrimaryMaterial(aStack).mPlasmaMultiplier)
-                                        * (50.0F + (10.0F * getToolCombatDamage(aStack)))
-                                        * (1.05 / 100))))
-                            + EnumChatFormatting.GRAY));
+                    tOffset + 9,
+                    EnumChatFormatting.LIGHT_PURPLE + "  Plasma"
+                        + EnumChatFormatting.GRAY
+                        + " | "
+                        + String.format(
+                            "%s EU/t > %s EU/t | %s",
+                            "" + EnumChatFormatting.GOLD
+                                + formatNumbers(GTUtility.safeInt((long) (turbine.getOptimalPlasmaFlow())))
+                                + EnumChatFormatting.GRAY,
+                            "" + EnumChatFormatting.DARK_GREEN
+                                + formatNumbers(GTUtility.safeInt((long) (turbine.getOptimalPlasmaEUt())))
+                                + EnumChatFormatting.GRAY,
+                            "" + EnumChatFormatting.BLUE
+                                + (int) (turbine.getPlasmaEfficiency() * 100)
+                                + "%"
+                                + EnumChatFormatting.GRAY));
                 aList.add(
-                    tOffset + 14,
-                    EnumChatFormatting.GRAY + "(EU/t values include efficiency and are not 100% accurate)");
-                int toolQualityLevel = MetaGeneratedTool.getPrimaryMaterial(aStack).mToolQuality;
-                int overflowMultiplier = 0;
-                if (toolQualityLevel >= 6) {
-                    overflowMultiplier = 3;
-                } else if (toolQualityLevel >= 3) {
-                    overflowMultiplier = 2;
-                } else {
-                    overflowMultiplier = 1;
-                }
+                    tOffset + 10,
+                    EnumChatFormatting.LIGHT_PURPLE + "  Loose"
+                        + EnumChatFormatting.GRAY
+                        + " | "
+                        + String.format(
+                            "%s EU/t > %s EU/t | %s",
+                            "" + EnumChatFormatting.GOLD
+                                + formatNumbers(GTUtility.safeInt((long) (turbine.getOptimalLoosePlasmaFlow())))
+                                + EnumChatFormatting.GRAY,
+                            "" + EnumChatFormatting.DARK_GREEN
+                                + formatNumbers(GTUtility.safeInt((long) (turbine.getOptimalLoosePlasmaEUt())))