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>

4 files changed, 261 insertions, 130 deletions

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())))
+                                + EnumChatFormatting.GRAY,
+                            "" + EnumChatFormatting.BLUE
+                                + (int) (turbine.getLoosePlasmaEfficiency() * 100)
+                                + "%"
+                                + EnumChatFormatting.GRAY));
                 aList.add(
-                    tOffset + 13,
+                    tOffset + 11,
                     EnumChatFormatting.LIGHT_PURPLE + String.format(
                         transItem("502", "Overflow Efficiency Tier: %s"),
-                        "" + EnumChatFormatting.GOLD + overflowMultiplier + EnumChatFormatting.GRAY));
-
+                        "" + EnumChatFormatting.GOLD + turbine.getOverflowEfficiency() + EnumChatFormatting.GRAY));
             } else {
                 aList.add(
                     tOffset,
diff --git a/src/main/java/gregtech/api/util/GTLanguageManager.java b/src/main/java/gregtech/api/util/GTLanguageManager.java
index 73e503e75a..06ba98fe8d 100644
--- a/src/main/java/gregtech/api/util/GTLanguageManager.java
+++ b/src/main/java/gregtech/api/util/GTLanguageManager.java
@@ -561,11 +561,11 @@ public class GTLanguageManager {
 
         addStringLocalization("Item_DESCRIPTION_Index_000", "Stored Heat: %s");
         addStringLocalization("Item_DESCRIPTION_Index_001", "Durability: %s/%s");
-        addStringLocalization("Item_DESCRIPTION_Index_002", "%s lvl %s");
+        addStringLocalization("Item_DESCRIPTION_Index_002", "%s Tier %s");
         addStringLocalization("Item_DESCRIPTION_Index_003", "Attack Damage: %s");
         addStringLocalization("Item_DESCRIPTION_Index_004", "Mining Speed: %s");
-        addStringLocalization("Item_DESCRIPTION_Index_005", "Turbine Efficiency: %s");
-        addStringLocalization("Item_DESCRIPTION_Index_006", "Optimal Steam flow: %s L/t");
+        addStringLocalization("Item_DESCRIPTION_Index_005", "Base Efficiency: %s");
+        addStringLocalization("Item_DESCRIPTION_Index_006", "Fuel | Optimal Flow > EU/t Produced | Efficiency");
         addStringLocalization("Item_DESCRIPTION_Index_007", "Energy from Optimal Gas Flow: %s EU/t");
         addStringLocalization("Item_DESCRIPTION_Index_008", "Energy from Optimal Plasma Flow: %s EU/t");
         addStringLocalization("Item_DESCRIPTION_Index_009", "Contains %s EU   Tier: %s");
diff --git a/src/main/java/gregtech/api/util/TurbineStatCalculator.java b/src/main/java/gregtech/api/util/TurbineStatCalculator.java
new file mode 100644
index 0000000000..48c00dfe09
--- /dev/null
+++ b/src/main/java/gregtech/api/util/TurbineStatCalculator.java
@@ -0,0 +1,140 @@
+package gregtech.api.util;
+
+// import static gregtech.api.items.GT_MetaGenerated_Tool.getToolMaxDamage;
+// import static gregtech.api.items.GT_MetaGenerated_Tool.getPrimaryMaterial;
+// import gregtech.api.items.GT_MetaGenerated_Tool.getToolStats;
+import net.minecraft.item.ItemStack;
+
+import gregtech.api.enums.Materials;
+import gregtech.api.interfaces.IToolStats;
+import gregtech.api.items.MetaGeneratedTool;
+
+public class TurbineStatCalculator {
+
+    public MetaGeneratedTool turbine;
+    public ItemStack item;
+    public long tMaxDamage;
+    public Materials tMaterial;
+    public IToolStats tStats;
+
+    public TurbineStatCalculator(MetaGeneratedTool turbineItem, ItemStack aStack) {
+        turbine = turbineItem;
+        item = aStack;
+        tMaxDamage = turbine.getToolMaxDamage(aStack);
+        tMaterial = turbine.getPrimaryMaterial(aStack);
+        tStats = turbine.getToolStats(aStack);
+    }
+
+    // Base stats
+
+    public long getMaxDurability() {
+        return tMaxDamage;
+    }
+
+    public long getCurrentDurability() {
+        return getMaxDurability() - turbine.getToolDamage(item);
+    }
+
+    // Efficiency in percentages
+    public float getEfficiency() {
+        return 0.5F + (0.5F + turbine.getToolCombatDamage(item)) * 0.1F;
+    }
+
+    public float getSteamEfficiency() {
+        return getEfficiency();
+    }
+
+    public float getGasEfficiency() {
+        return getEfficiency();
+    }
+
+    public float getPlasmaEfficiency() {
+        return getEfficiency();
+    }
+
+    public float getLooseEfficiency() {
+        // 0.85x - 0.3, where x is the base efficiency
+        return (float) (-0.2f + Math.round(getEfficiency() * 85.0f) * 0.01);
+    }
+
+    public float getLooseSteamEfficiency() {
+        return getLooseEfficiency() * 0.9f;
+    }
+
+    public float getLooseGasEfficiency() {
+        return getLooseEfficiency() * 0.95f;
+    }
+
+    public float getLoosePlasmaEfficiency() {
+        return getLooseEfficiency();
+    }
+
+    // Base optimal flows
+
+    public float getOptimalFlow() {
+        return tStats.getSpeedMultiplier() * tMaterial.mToolSpeed * 50F;
+    }
+
+    // All values are in EU/t before efficiency
+    public float getOptimalSteamFlow() {
+        return getOptimalFlow() * tMaterial.mSteamMultiplier;
+    }
+
+    public float getOptimalGasFlow() {
+        return getOptimalFlow() * tMaterial.mGasMultiplier;
+    }
+
+    public float getOptimalPlasmaFlow() {
+        return getOptimalFlow() * tMaterial.mPlasmaMultiplier * 42;
+    }
+
+    // Loose optimal flows
+
+    public float getOptimalLooseSteamFlow() {
+        // 3 * 1.1^((Efficiency - 0.8) * 20)
+        return 3.0f * getOptimalSteamFlow() * (float) Math.pow(1.1f, ((getEfficiency() - 0.8f)) * 20f);
+    }
+
+    public float getOptimalLooseGasFlow() {
+        // 2 * 1.05^((Efficiency - 0.8) * 20)
+        return 2.0f * getOptimalGasFlow() * (float) Math.pow(1.05f, ((getEfficiency() - 0.8f)) * 20f);
+    }
+
+    public float getOptimalLoosePlasmaFlow() {
+        // 1 * 1.05^((Efficiency - 0.8) * 20)
+        return 2.0f * getOptimalPlasmaFlow() * (float) Math.pow(1.03f, ((getEfficiency() - 0.8f)) * 20f);
+    }
+
+    // Base EU/t from optimal flow
+
+    public float getOptimalSteamEUt() {
+        return getOptimalSteamFlow() * getSteamEfficiency() * 0.5f;
+    }
+
+    public float getOptimalGasEUt() {
+        return getOptimalGasFlow() * getGasEfficiency();
+    }
+
+    public float getOptimalPlasmaEUt() {
+        return getOptimalPlasmaFlow() * getPlasmaEfficiency();
+    }
+
+    // Loose EU/t from optimal flow
+
+    public float getOptimalLooseSteamEUt() {
+        return getOptimalLooseSteamFlow() * getLooseSteamEfficiency() * 0.5f;
+    }
+
+    public float getOptimalLooseGasEUt() {
+        return getOptimalLooseGasFlow() * getLooseGasEfficiency();
+    }
+
+    public float getOptimalLoosePlasmaEUt() {
+        return getOptimalLoosePlasmaFlow() * getLoosePlasmaEfficiency();
+    }
+
+    public int getOverflowEfficiency() {
+        return (int) (1 + Math.min(2.0, tMaterial.mToolQuality / 3));
+    }
+
+}