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>

7 files changed, 267 insertions, 254 deletions

diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargeTurbineGas.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargeTurbineGas.java
index e57a7d7e77..31450cc303 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargeTurbineGas.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargeTurbineGas.java
@@ -25,6 +25,7 @@ import gregtech.api.recipe.check.SimpleCheckRecipeResult;
 import gregtech.api.recipe.maps.FuelBackend;
 import gregtech.api.util.GTRecipe;
 import gregtech.api.util.GTUtility;
+import gregtech.api.util.TurbineStatCalculator;
 import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
 
 @SuppressWarnings("deprecation")
@@ -111,7 +112,7 @@ public class MTELargeTurbineGas extends MTELargerTurbineBase {
     }
 
     @Override
-    long fluidIntoPower(ArrayList<FluidStack> aFluids, long aOptFlow, int aBaseEff, float[] flowMultipliers) {
+    long fluidIntoPower(ArrayList<FluidStack> aFluids, TurbineStatCalculator turbine) {
         if (aFluids.size() >= 1) {
             int tEU = 0;
             int actualOptimalFlow = 0;
@@ -119,17 +120,19 @@ public class MTELargeTurbineGas extends MTELargerTurbineBase {
                                                                           // Doesn't matter which one. Ignore the rest!
             int fuelValue = getFuelValue(firstFuelType);
             // log("Fuel Value of "+aFluids.get(0).getLocalizedName()+" is "+fuelValue+"eu");
-            if (aOptFlow < fuelValue) {
+            if (turbine.getOptimalGasEUt() < fuelValue) {
                 // turbine too weak and/or fuel too powerful
                 // at least consume 1L
                 this.realOptFlow = 1;
                 // wastes the extra fuel and generate aOptFlow directly
                 depleteInput(new FluidStack(firstFuelType, 1));
                 this.storedFluid += 1;
-                return GTUtility.safeInt((long) aOptFlow * (long) aBaseEff / 10000L);
+                return GTUtility.safeInt((long) (turbine.getOptimalGasEUt()));
             }
 
-            actualOptimalFlow = GTUtility.safeInt((long) (aOptFlow * (double) flowMultipliers[1] / fuelValue));
+            actualOptimalFlow = GTUtility.safeInt(
+                (long) (getSpeedMultiplier()
+                    * ((isLooseMode() ? turbine.getOptimalLooseGasFlow() : turbine.getOptimalGasFlow()) / fuelValue)));
             this.realOptFlow = actualOptimalFlow;
 
             int remainingFlow = GTUtility.safeInt((long) (actualOptimalFlow * 1.25f)); // Allowed to use up to 125% of
@@ -154,11 +157,13 @@ public class MTELargeTurbineGas extends MTELargerTurbineBase {
             tEU = GTUtility.safeInt((long) totalFlow * fuelValue);
 
             if (totalFlow == actualOptimalFlow) {
-                tEU = GTUtility.safeInt((long) tEU * (long) aBaseEff / 10000L);
+                tEU = GTUtility.safeInt(
+                    (long) (tEU * (isLooseMode() ? turbine.getLooseGasEfficiency() : turbine.getGasEfficiency())));
             } else {
                 float efficiency = 1.0f - Math.abs((totalFlow - actualOptimalFlow) / (float) actualOptimalFlow);
                 tEU *= efficiency;
-                tEU = GTUtility.safeInt((long) tEU * (long) aBaseEff / 10000L);
+                tEU = GTUtility.safeInt(
+                    (long) (tEU * (isLooseMode() ? turbine.getLooseGasEfficiency() : turbine.getGasEfficiency())));
             }
 
             return tEU;
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargeTurbineSCSteam.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargeTurbineSCSteam.java
index 0ef3ef0256..a608cbfc07 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargeTurbineSCSteam.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargeTurbineSCSteam.java
@@ -6,17 +6,23 @@ import net.minecraft.item.ItemStack;
 import net.minecraftforge.fluids.FluidRegistry;
 import net.minecraftforge.fluids.FluidStack;
 
+import gregtech.api.enums.Materials;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.render.TextureFactory;
 import gregtech.api.util.GTModHandler;
 import gregtech.api.util.GTUtility;
+import gregtech.api.util.TurbineStatCalculator;
+import gtPlusPlus.core.lib.GTPPCore;
 import gtPlusPlus.core.util.math.MathUtils;
 import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
 
 public class MTELargeTurbineSCSteam extends MTELargerTurbineBase {
 
+    private boolean hasConsumedSteam;
+    private boolean isUsingDenseSteam;
+
     public MTELargeTurbineSCSteam(int aID, String aName, String aNameRegional) {
         super(aID, aName, aNameRegional);
     }
@@ -56,47 +62,88 @@ public class MTELargeTurbineSCSteam extends MTELargerTurbineBase {
     }
 
     @Override
-    long fluidIntoPower(ArrayList<FluidStack> aFluids, long aOptFlow, int aBaseEff, float[] flowMultipliers) {
+    long fluidIntoPower(ArrayList<FluidStack> aFluids, TurbineStatCalculator turbine) {
+
         int tEU = 0;
         int totalFlow = 0; // Byproducts are based on actual flow
         int flow = 0;
+        float denseFlow = 0;
+        float steamFlowForNextSteam = 0;
+        int steamInHatch = 0;
         // Variable required outside of loop for
         // multi-hatch scenarios.
-        this.realOptFlow = aOptFlow;
+        this.realOptFlow = getSpeedMultiplier()
+            * (looseFit ? turbine.getOptimalLooseSteamFlow() : turbine.getOptimalSteamFlow());
         // this.realOptFlow = (double) aOptFlow * (double) flowMultipliers[0];
         // Will there be an multiplier for SC?
         int remainingFlow = MathUtils.safeInt((long) (realOptFlow * 1.25f)); // Allowed to use up to
         // 125% of optimal flow.
+        float remainingDenseFlow = 0;
 
         storedFluid = 0;
         FluidStack tSCSteam = FluidRegistry.getFluidStack("supercriticalsteam", 1);
         for (int i = 0; i < aFluids.size() && remainingFlow > 0; i++) {
+            String fluidName = aFluids.get(i)
+                .getFluid()
+                .getUnlocalizedName(aFluids.get(i));
             if (GTUtility.areFluidsEqual(aFluids.get(i), tSCSteam, true)) {
+                if (!hasConsumedSteam) {
+                    hasConsumedSteam = true;
+                    isUsingDenseSteam = false;
+                } else if (isUsingDenseSteam) {
+                    continue;
+                }
                 flow = Math.min(aFluids.get(i).amount, remainingFlow); // try to use up w/o exceeding remainingFlow
                 depleteInput(new FluidStack(aFluids.get(i), flow)); // deplete that amount
                 this.storedFluid += aFluids.get(i).amount;
                 remainingFlow -= flow; // track amount we're allowed to continue depleting from hatches
                 totalFlow += flow; // track total input used
+            } else if (fluidName.equals("fluid.densesupercriticalsteam")) {
+                if (!hasConsumedSteam) {
+                    hasConsumedSteam = true;
+                    isUsingDenseSteam = true;
+                } else if (!isUsingDenseSteam) {
+                    continue;
+                }
+                steamInHatch = aFluids.get(i).amount;
+                remainingDenseFlow = (float) remainingFlow / 1000; // Dense Steam is 1000x the EU value
+                denseFlow = Math.min(steamInHatch, remainingDenseFlow); // try to use up w/o exceeding
+                                                                        // remainingDenseFlow
+                depleteInput(new FluidStack(aFluids.get(i), (int) denseFlow)); // deplete that amount
+                this.storedFluid += aFluids.get(i).amount;
+                remainingFlow -= denseFlow * 1000; // track amount we're allowed to continue depleting from hatches
+                totalFlow += denseFlow * 1000; // track total input used
+                steamFlowForNextSteam += denseFlow;
             }
         }
         if (totalFlow <= 0) return 0;
-        tEU = totalFlow;
-        addOutput(GTModHandler.getSteam(totalFlow * 100));
+        tEU = totalFlow; // SC Steam has 1 EU per litre so the flow equals base EU produced
+        if (isUsingDenseSteam) {
+            addOutput(Materials.DenseSuperheatedSteam.getGas((long) steamFlowForNextSteam));
+        } else {
+            addOutput(GTModHandler.getSteam(totalFlow * 100));
+        }
         if (totalFlow != realOptFlow) {
             float efficiency = 1.0f - Math.abs((totalFlow - (float) realOptFlow) / (float) realOptFlow);
             // if(totalFlow>aOptFlow){efficiency = 1.0f;}
             tEU *= efficiency;
-            tEU = Math.max(1, MathUtils.safeInt((long) tEU * (long) aBaseEff / 10000L));
+            tEU = Math.max(
+                1,
+                MathUtils.safeInt(
+                    (long) (tEU * (looseFit ? turbine.getLooseSteamEfficiency() : turbine.getSteamEfficiency()))));
         } else {
-            tEU = MathUtils.safeInt((long) tEU * (long) aBaseEff / 10000L);
+            tEU = MathUtils
+                .safeInt((long) (tEU * (looseFit ? turbine.getLooseSteamEfficiency() : turbine.getSteamEfficiency())));
+        }
+        if (isUsingDenseSteam) {
+            return tEU;
         }
-
         return tEU * 100L;
     }
 
     @Override
     public int getDamageToComponent(ItemStack aStack) {
-        return 8;
+        return (looseFit && GTPPCore.RANDOM.nextInt(4) == 0) ? 0 : 1;
     }
 
     @Override
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargeTurbineSHSteam.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargeTurbineSHSteam.java
index 7fdc36450d..afa13de0be 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargeTurbineSHSteam.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargeTurbineSHSteam.java
@@ -2,29 +2,26 @@ package gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.production.t
 
 import java.util.ArrayList;
 
-import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.fluids.FluidStack;
 
 import gregtech.GTMod;
+import gregtech.api.enums.Materials;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.objects.GTRenderedTexture;
 import gregtech.api.util.GTModHandler;
-import gregtech.api.util.GTUtility;
+import gregtech.api.util.TurbineStatCalculator;
 import gtPlusPlus.core.lib.GTPPCore;
 import gtPlusPlus.core.util.math.MathUtils;
-import gtPlusPlus.core.util.minecraft.PlayerUtils;
 import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
 
 @SuppressWarnings("deprecation")
 public class MTELargeTurbineSHSteam extends MTELargerTurbineBase {
 
     public boolean achievement = false;
-    private boolean looseFit = false;
+    private boolean isUsingDenseSteam;
 
     public MTELargeTurbineSHSteam(int aID, String aName, String aNameRegional) {
         super(aID, aName, aNameRegional);
@@ -65,119 +62,107 @@ public class MTELargeTurbineSHSteam extends MTELargerTurbineBase {
     }
 
     @Override
-    long fluidIntoPower(ArrayList<FluidStack> aFluids, long aOptFlow, int aBaseEff, float[] flowMultipliers) {
-        if (looseFit) {
-            aOptFlow *= 4;
-            if (aBaseEff > 10000) {
-                aOptFlow *= Math.pow(1.1f, ((aBaseEff - 7500) / 10000F) * 20f);
-                aBaseEff = 7500;
-            } else if (aBaseEff > 7500) {
-                aOptFlow *= Math.pow(1.1f, ((aBaseEff - 7500) / 10000F) * 20f);
-                aBaseEff *= 0.75f;
-            } else {
-                aBaseEff *= 0.75f;
-            }
-        }
-        // prevent overflow like that in SC Steam
+    long fluidIntoPower(ArrayList<FluidStack> aFluids, TurbineStatCalculator turbine) {
+
         long tEU = 0;
         int totalFlow = 0; // Byproducts are based on actual flow
         int flow = 0;
+        float denseFlow = 0;
+        float steamFlowForNextSteam = 0;
+        int steamInHatch = 0;
 
         // Variable required outside of loop for
         // multi-hatch scenarios.
-        this.realOptFlow = aOptFlow * flowMultipliers[0];
+        this.realOptFlow = getSpeedMultiplier()
+            * (looseFit ? turbine.getOptimalLooseSteamFlow() : turbine.getOptimalSteamFlow());
 
         int remainingFlow = MathUtils.safeInt((long) (realOptFlow * 1.25f)); // Allowed to use up to
         // 125% of optimal flow.
+        float remainingDenseFlow = 0;
+
+        boolean hasConsumedSteam = false;
 
         storedFluid = 0;
         for (int i = 0; i < aFluids.size() && remainingFlow > 0; i++) {
             String fluidName = aFluids.get(i)
                 .getFluid()
                 .getUnlocalizedName(aFluids.get(i));
-            if (fluidName.equals("ic2.fluidSuperheatedSteam")) {
-                flow = Math.min(aFluids.get(i).amount, remainingFlow); // try to use up w/o exceeding remainingFlow
-                depleteInput(new FluidStack(aFluids.get(i), flow)); // deplete that amount
-                this.storedFluid += aFluids.get(i).amount;
-                remainingFlow -= flow; // track amount we're allowed to continue depleting from hatches
-                totalFlow += flow; // track total input used
-                if (!achievement) {
-                    try {
-                        GTMod.achievements.issueAchievement(
-                            this.getBaseMetaTileEntity()
-                                .getWorld()
-                                .getPlayerEntityByName(
-                                    this.getBaseMetaTileEntity()
-                                        .getOwnerName()),
-                            "efficientsteam");
-                    } catch (Exception e) {}
-                    achievement = true;
+            switch (fluidName) {
+                case "ic2.fluidSuperheatedSteam" -> {
+                    if (!hasConsumedSteam) {
+                        hasConsumedSteam = true;
+                        isUsingDenseSteam = false;
+                    } else if (isUsingDenseSteam) {
+                        continue;
+                    }
+                    flow = Math.min(aFluids.get(i).amount, remainingFlow); // try to use up w/o exceeding remainingFlow
+                    depleteInput(new FluidStack(aFluids.get(i), flow)); // deplete that amount
+                    this.storedFluid += aFluids.get(i).amount;
+                    remainingFlow -= flow; // track amount we're allowed to continue depleting from hatches
+                    totalFlow += flow; // track total input used
+                    if (!achievement) {
+                        try {
+                            GTMod.achievements.issueAchievement(
+                                this.getBaseMetaTileEntity()
+                                    .getWorld()
+                                    .getPlayerEntityByName(
+                                        this.getBaseMetaTileEntity()
+                                            .getOwnerName()),
+                                "efficientsteam");
+                        } catch (Exception e) {}
+                        achievement = true;
+                    }
                 }
-            } else if (fluidName.equals("fluid.steam") || fluidName.equals("ic2.fluidSteam")
-                || fluidName.equals("fluid.mfr.steam.still.name")) {
-                    depleteInput(new FluidStack(aFluids.get(i), aFluids.get(i).amount));
+                case "fluid.densesuperheatedsteam" -> {
+                    if (!hasConsumedSteam) {
+                        hasConsumedSteam = true;
+                        isUsingDenseSteam = true;
+                    } else if (!isUsingDenseSteam) {
+                        continue;
+                    }
+                    steamInHatch = aFluids.get(i).amount;
+                    remainingDenseFlow = (float) remainingFlow / 1000; // Dense Steam is 1000x the EU value
+                    denseFlow = Math.min(steamInHatch, remainingDenseFlow); // try to use up w/o exceeding
+                                                                            // remainingDenseFlow
+                    depleteInput(new FluidStack(aFluids.get(i), (int) denseFlow)); // deplete that amount
+                    this.storedFluid += aFluids.get(i).amount;
+                    remainingFlow -= denseFlow * 1000; // track amount we're allowed to continue depleting from hatches
+                    totalFlow += denseFlow * 1000; // track total input used
+                    steamFlowForNextSteam += denseFlow;
                 }
+                case "fluid.steam", "ic2.fluidSteam", "fluid.mfr.steam.still.name" -> depleteInput(
+                    new FluidStack(aFluids.get(i), aFluids.get(i).amount));
+            }
         }
         if (totalFlow <= 0) return 0;
-        tEU = totalFlow;
-        addOutput(GTModHandler.getSteam(totalFlow));
+        tEU = totalFlow; // SH Steam has 1 EU per litre so the flow equals base EU produced
+        if (isUsingDenseSteam) {
+            addOutput(Materials.DenseSteam.getGas((long) steamFlowForNextSteam));
+        } else {
+            addOutput(GTModHandler.getSteam(totalFlow));
+        }
         if (totalFlow != realOptFlow) {
             float efficiency = 1.0f - Math.abs((totalFlow - (float) realOptFlow) / (float) realOptFlow);
             // if(totalFlow>aOptFlow){efficiency = 1.0f;}
             tEU *= efficiency;
-            tEU = Math.max(1L, tEU * aBaseEff / 10000L);
+            tEU = Math.max(
+                1,
+                MathUtils.safeInt(
+                    (long) (tEU * (looseFit ? turbine.getLooseSteamEfficiency() : turbine.getSteamEfficiency()))));
         } else {
-            tEU = tEU * aBaseEff / 10000L;
+            tEU = MathUtils
+                .safeInt((long) (tEU * (looseFit ? turbine.getLooseSteamEfficiency() : turbine.getSteamEfficiency())));
         }
 
         return tEU;
     }
 
     @Override
-    public void onModeChangeByScrewdriver(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) {
-        // Using a screwdriver to change modes should allow for any combination of Slow/Fast and Tight/Loose Mode
-        // Whenever there's a mode switch, there will be two messages on the player chat
-        // The two messages specify which two modes the turbine is on after the change
-        // (Tight/Loose changes on every action, Slow/Fast changes every other action, all pairs are cycled this way)
-        if (side == getBaseMetaTileEntity().getFrontFacing()) {
-            looseFit ^= true;
-            GTUtility.sendChatToPlayer(
-                aPlayer,
-                looseFit ? "Fitting is Loose (Higher Flow)" : "Fitting is Tight (Higher Efficiency)");
-        }
-
-        if (looseFit) {
-            super.onModeChangeByScrewdriver(side, aPlayer, aX, aY, aZ);
-        } else if (mFastMode) {
-            PlayerUtils.messagePlayer(aPlayer, "Running in Fast (48x) Mode.");
-        } else {
-            PlayerUtils.messagePlayer(aPlayer, "Running in Slow (16x) Mode.");
-        }
-    }
-
-    @Override
     public int getDamageToComponent(ItemStack aStack) {
         return (looseFit && GTPPCore.RANDOM.nextInt(4) == 0) ? 0 : 1;
     }
 
     @Override
-    public boolean isLooseMode() {
-        return looseFit;
-    }
-
-    @Override
-    public void saveNBTData(NBTTagCompound aNBT) {
-        super.saveNBTData(aNBT);
-        aNBT.setBoolean("turbineFitting", looseFit);
-    }
-
-    @Override
-    public void loadNBTData(NBTTagCompound aNBT) {
-        super.loadNBTData(aNBT);
-        looseFit = aNBT.getBoolean("turbineFitting");
-    }
-
-    @Override
     public String getMachineType() {
         return "Large Super-heated Steam Turbine";
     }
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargeTurbineSteam.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargeTurbineSteam.java
index 68cfc8cd1e..72a50cacf3 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargeTurbineSteam.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargeTurbineSteam.java
@@ -4,10 +4,7 @@ import static gtPlusPlus.core.lib.GTPPCore.RANDOM;
 
 import java.util.ArrayList;
 
-import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.fluids.FluidStack;
 
 import gregtech.GTMod;
@@ -16,9 +13,8 @@ import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.objects.GTRenderedTexture;
 import gregtech.api.util.GTModHandler;
-import gregtech.api.util.GTUtility;
+import gregtech.api.util.TurbineStatCalculator;
 import gtPlusPlus.core.util.math.MathUtils;
-import gtPlusPlus.core.util.minecraft.PlayerUtils;
 import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
 
 @SuppressWarnings("deprecation")
@@ -26,7 +22,7 @@ public class MTELargeTurbineSteam extends MTELargerTurbineBase {
 
     private float water;
     private boolean achievement = false;
-    private boolean looseFit = false;
+    private boolean isUsingDenseSteam;
 
     public MTELargeTurbineSteam(int aID, String aName, String aNameRegional) {
         super(aID, aName, aNameRegional);
@@ -74,32 +70,27 @@ public class MTELargeTurbineSteam extends MTELargerTurbineBase {
     }
 
     @Override
-    long fluidIntoPower(ArrayList<FluidStack> aFluids, long aOptFlow, int aBaseEff, float[] flowMultipliers) {
-        if (looseFit) {
-            aOptFlow *= 4;
-            if (aBaseEff > 10000) {
-                aOptFlow *= Math.pow(1.1f, ((aBaseEff - 7500) / 10000F) * 20f);
-                aBaseEff = 7500;
-            } else if (aBaseEff > 7500) {
-                aOptFlow *= Math.pow(1.1f, ((aBaseEff - 7500) / 10000F) * 20f);
-                aBaseEff *= 0.75f;
-            } else {
-                aBaseEff *= 0.75f;
-            }
-        }
-        // prevent overflow like that in SC Steam
+    long fluidIntoPower(ArrayList<FluidStack> aFluids, TurbineStatCalculator turbine) {
+
         long tEU = 0;
         int totalFlow = 0; // Byproducts are based on actual flow
         int flow = 0;
+        float denseFlow = 0;
+        float steamFlowForWater = 0;
+        int steamInHatch = 0;
 
         // Variable required outside of loop for
         // multi-hatch scenarios.
-        this.realOptFlow = aOptFlow * flowMultipliers[0];
+        this.realOptFlow = getSpeedMultiplier()
+            * (looseFit ? turbine.getOptimalLooseSteamFlow() : turbine.getOptimalSteamFlow());
 
         int remainingFlow = MathUtils.safeInt((long) (realOptFlow * 1.25f)); // Allowed to
         // use up to
         // 125% of
         // optimal flow.
+        float remainingDenseFlow = 0;
+
+        boolean hasConsumedSteam = false;
 
         storedFluid = 0;
         for (int i = 0; i < aFluids.size() && remainingFlow > 0; i++) { // loop through each hatch; extract inputs and
@@ -107,88 +98,82 @@ public class MTELargeTurbineSteam extends MTELargerTurbineBase {
             String fluidName = aFluids.get(i)
                 .getFluid()
                 .getUnlocalizedName(aFluids.get(i));
-            if (fluidName.equals("fluid.steam") || fluidName.equals("ic2.fluidSteam")
-                || fluidName.equals("fluid.mfr.steam.still.name")) {
-                flow = Math.min(aFluids.get(i).amount, remainingFlow); // try to use up w/o exceeding remainingFlow
-                depleteInput(new FluidStack(aFluids.get(i), flow)); // deplete that amount
-                this.storedFluid += aFluids.get(i).amount;
-                remainingFlow -= flow; // track amount we're allowed to continue depleting from hatches
-                totalFlow += flow; // track total input used
-                if (!achievement) {
-                    GTMod.achievements.issueAchievement(
-                        this.getBaseMetaTileEntity()
-                            .getWorld()
-                            .getPlayerEntityByName(
-                                this.getBaseMetaTileEntity()
-                                    .getOwnerName()),
-                        "muchsteam");
-                    achievement = true;
+            switch (fluidName) {
+                case "fluid.steam", "ic2.fluidSteam", "fluid.mfr.steam.still.name" -> {
+                    if (!hasConsumedSteam) {
+                        hasConsumedSteam = true;
+                        isUsingDenseSteam = false;
+                    } else if (isUsingDenseSteam) {
+                        continue;
+                    }
+                    flow = Math.min(aFluids.get(i).amount, remainingFlow); // try to use up w/o exceeding remainingFlow
+                    depleteInput(new FluidStack(aFluids.get(i), flow)); // deplete that amount
+                    this.storedFluid += aFluids.get(i).amount;
+                    remainingFlow -= flow; // track amount we're allowed to continue depleting from hatches
+                    totalFlow += flow; // track total input used
+                    if (!achievement) {
+                        GTMod.achievements.issueAchievement(
+                            this.getBaseMetaTileEntity()
+                                .getWorld()
+                                .getPlayerEntityByName(
+                                    this.getBaseMetaTileEntity()
+                                        .getOwnerName()),
+                            "muchsteam");
+                        achievement = true;
+                    }
+                }
+                case "fluid.densesteam" -> {
+                    if (!hasConsumedSteam) {
+                        hasConsumedSteam = true;
+                        isUsingDenseSteam = true;
+                    } else if (!isUsingDenseSteam) {
+                        continue;
+                    }
+                    steamInHatch = aFluids.get(i).amount;
+                    remainingDenseFlow = (float) remainingFlow / 1000; // Dense Steam is 1000x the EU value
+                    denseFlow = Math.min(steamInHatch, remainingDenseFlow); // try to use up w/o exceeding
+                                                                            // remainingDenseFlow
+                    depleteInput(new FluidStack(aFluids.get(i), (int) denseFlow)); // deplete that amount
+                    this.storedFluid += aFluids.get(i).amount;
+                    remainingFlow -= denseFlow * 1000; // track amount we're allowed to continue depleting from hatches
+                    totalFlow += denseFlow * 1000; // track total input used
+                    steamFlowForWater += denseFlow * 1000;
                 }
-            } else if (fluidName.equals("ic2.fluidSuperheatedSteam")) {
-                depleteInput(new FluidStack(aFluids.get(i), aFluids.get(i).amount));
+                case "ic2.fluidSuperheatedSteam" -> depleteInput(new FluidStack(aFluids.get(i), aFluids.get(i).amount));
             }
         }
         if (totalFlow <= 0) return 0;
-        tEU = totalFlow;
-        int waterToOutput = useWater(totalFlow / 160.0f);
+        tEU = (long) (totalFlow * 0.5f);
+        int waterToOutput;
+        if (isUsingDenseSteam) {
+            // Water return is lower to counteract water generation from rounding errors
+            waterToOutput = useWater(steamFlowForWater / 160.1f);
+        } else {
+            waterToOutput = useWater(totalFlow / 160.0f);
+        }
         addOutput(GTModHandler.getDistilledWater(waterToOutput));
         if (totalFlow != realOptFlow) {
             float efficiency = 1.0f - Math.abs((totalFlow - (float) realOptFlow) / (float) realOptFlow);
             // if(totalFlow>aOptFlow){efficiency = 1.0f;}
             tEU *= efficiency;
-            tEU = Math.max(1L, tEU * aBaseEff / 20000L);
+            tEU = Math.max(
+                1,
+                MathUtils.safeInt(
+                    (long) (tEU * (looseFit ? turbine.getLooseSteamEfficiency() : turbine.getSteamEfficiency()))));
         } else {
-            tEU = tEU * aBaseEff / 20000L;
+            tEU = MathUtils
+                .safeInt((long) (tEU * (looseFit ? turbine.getLooseSteamEfficiency() : turbine.getSteamEfficiency())));
         }
 
         return tEU;
     }
 
     @Override
-    public void onModeChangeByScrewdriver(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) {
-        // Using a screwdriver to change modes should allow for any combination of Slow/Fast and Tight/Loose Mode
-        // Whenever there's a mode switch, there will be two messages on the player chat
-        // The two messages specify which two modes the turbine is on after the change
-        // (Tight/Loose changes on every action, Slow/Fast changes every other action, all pairs are cycled this way)
-        if (side == getBaseMetaTileEntity().getFrontFacing()) {
-            looseFit ^= true;
-            GTUtility.sendChatToPlayer(
-                aPlayer,
-                looseFit ? "Fitting: Loose - More Flow" : "Fitting: Tight - More Efficiency");
-        }
-
-        if (looseFit) {
-            super.onModeChangeByScrewdriver(side, aPlayer, aX, aY, aZ);
-        } else if (mFastMode) {
-            PlayerUtils.messagePlayer(aPlayer, "Running in Fast (48x) Mode.");
-        } else {
-            PlayerUtils.messagePlayer(aPlayer, "Running in Slow (16x) Mode.");
-        }
-    }
-
-    @Override
     public int getDamageToComponent(ItemStack aStack) {
         return (looseFit && RANDOM.nextInt(4) == 0) ? 0 : 1;
     }
 
     @Override
-    public boolean isLooseMode() {
-        return looseFit;
-    }
-
-    @Override
-    public void saveNBTData(NBTTagCompound aNBT) {
-        super.saveNBTData(aNBT);
-        aNBT.setBoolean("turbineFitting", looseFit);
-    }
-
-    @Override
-    public void loadNBTData(NBTTagCompound aNBT) {
-        super.loadNBTData(aNBT);
-        looseFit = aNBT.getBoolean("turbineFitting");
-    }
-
-    @Override
     public String getMachineType() {
         return "Large Steam Turbine";
     }
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargerTurbineBase.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargerTurbineBase.java
index 0bd1397137..079983e337 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargerTurbineBase.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargerTurbineBase.java
@@ -45,6 +45,7 @@ import gregtech.api.recipe.check.CheckRecipeResult;
 import gregtech.api.recipe.check.CheckRecipeResultRegistry;
 import gregtech.api.util.GTUtility;
 import gregtech.api.util.MultiblockTooltipBuilder;
+import gregtech.api.util.TurbineStatCalculator;
 import gregtech.api.util.shutdown.ShutDownReason;
 import gregtech.api.util.shutdown.ShutDownReasonRegistry;
 import gtPlusPlus.api.objects.Logger;
@@ -53,7 +54,6 @@ import gtPlusPlus.api.objects.minecraft.BlockPos;
 import gtPlusPlus.core.block.ModBlocks;
 import gtPlusPlus.core.lib.GTPPCore;
 import gtPlusPlus.core.util.math.MathUtils;
-import gtPlusPlus.core.util.minecraft.PlayerUtils;
 import gtPlusPlus.core.util.minecraft.gregtech.PollutionUtils;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.MTEHatchTurbine;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GTPPMultiBlockBase;
@@ -67,7 +67,7 @@ public abstract class MTELargerTurbineBase extends GTPPMultiBlockBase<MTELargerT
     protected double realOptFlow = 0;
     protected int storedFluid = 0;
     protected int counter = 0;
-    protected boolean mFastMode = false;
+    protected boolean looseFit = false;
     protected double mufflerReduction = 1;
     protected float[] flowMultipliers = new float[] { 1, 1, 1 };
 
@@ -104,10 +104,9 @@ public abstract class MTELargerTurbineBase extends GTPPMultiBlockBase<MTELargerT
         tt.addMachineType(getMachineType())
             .addInfo("Controller Block for the XL " + getTurbineType() + " Turbine")
             .addInfo("Runs as fast as 16 Large Turbines of the same type, takes the space of 12")
-            .addInfo("Right-click with screwdriver to enable Fast Mode, to run it even faster")
-            .addInfo("Optimal flow will increase or decrease accordingly on mode switch")
-            .addInfo("Fast Mode increases speed to 48x instead of 16x, with some penalties")
-            .addInfo("Maintenance problems and turbine damage happen 12x as often in Fast Mode");
+            .addInfo("Right-click with screwdriver to enable loose fit")
+            .addInfo("Optimal flow will increase or decrease depending on fitting")
+            .addInfo("Loose fit increases flow in exchange for efficiency");
         if (getTurbineType().contains("Steam")) {
             tt.addInfo("XL Steam Turbines can use Loose Mode with either Slow or Fast Mode");
         }
@@ -116,7 +115,6 @@ public abstract class MTELargerTurbineBase extends GTPPMultiBlockBase<MTELargerT
                 .addInfo("Efficiency = ((FuelValue / 200,000)^2) / (EU per Turbine)");
         }
         tt.addPollutionAmount(getPollutionPerSecond(null))
-            .addInfo("Pollution is 3x higher in Fast Mode")
             .addSeparator()
             .beginStructureBlock(7, 9, 7, false)
             .addController("Top Middle")
@@ -450,6 +448,11 @@ public abstract class MTELargerTurbineBase extends GTPPMultiBlockBase<MTELargerT
 
             ArrayList<FluidStack> tFluids = getStoredFluids();
 
+            ItemStack aStack = getFullTurbineAssemblies().get(0)
+                .getTurbine();
+
+            TurbineStatCalculator turbine = new TurbineStatCalculator((MetaGeneratedTool) aStack.getItem(), aStack);
+
             if (tFluids.size() > 0) {
                 if (baseEff == 0 || optFlow == 0
                     || counter >= 512
@@ -461,25 +464,15 @@ public abstract class MTELargerTurbineBase extends GTPPMultiBlockBase<MTELargerT
                     float aTotalBaseEff = 0;
                     float aTotalOptimalFlow = 0;
 
-                    ItemStack aStack = getFullTurbineAssemblies().get(0)
-                        .getTurbine();
-                    aTotalBaseEff += GTUtility.safeInt(
-                        (long) ((5F + ((MetaGeneratedTool) aStack.getItem()).getToolCombatDamage(aStack)) * 1000F));
-                    aTotalOptimalFlow += GTUtility.safeInt(
-                        (long) Math.max(
-                            Float.MIN_NORMAL,
-                            ((MetaGeneratedTool) aStack.getItem()).getToolStats(aStack)
-                                .getSpeedMultiplier() * MetaGeneratedTool.getPrimaryMaterial(aStack).mToolSpeed * 50)
-                            * getSpeedMultiplier());
+                    aTotalBaseEff += turbine.getEfficiency() * 100;
+                    aTotalOptimalFlow += GTUtility
+                        .safeInt((long) Math.max(Float.MIN_NORMAL, getSpeedMultiplier() * turbine.getOptimalFlow()));
+                    baseEff = MathUtils.roundToClosestInt(aTotalBaseEff);
+                    optFlow = MathUtils.roundToClosestInt(aTotalOptimalFlow);
                     if (aTotalOptimalFlow < 0) {
                         aTotalOptimalFlow = 100;
                     }
 
-                    flowMultipliers[0] = MetaGeneratedTool.getPrimaryMaterial(aStack).mSteamMultiplier;
-                    flowMultipliers[1] = MetaGeneratedTool.getPrimaryMaterial(aStack).mGasMultiplier;
-                    flowMultipliers[2] = MetaGeneratedTool.getPrimaryMaterial(aStack).mPlasmaMultiplier;
-                    baseEff = MathUtils.roundToClosestInt(aTotalBaseEff);
-                    optFlow = MathUtils.roundToClosestInt(aTotalOptimalFlow);
                     if (optFlow <= 0 || baseEff <= 0) {
                         stopMachine(ShutDownReasonRegistry.NONE); // in case the turbine got removed
                         return CheckRecipeResultRegistry.NO_FUEL_FOUND;
@@ -490,7 +483,7 @@ public abstract class MTELargerTurbineBase extends GTPPMultiBlockBase<MTELargerT
             }
 
             // How much the turbine should be producing with this flow
-            long newPower = fluidIntoPower(tFluids, optFlow, baseEff, flowMultipliers);
+            long newPower = fluidIntoPower(tFluids, turbine);
             long difference = newPower - this.lEUt; // 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
@@ -554,7 +547,7 @@ public abstract class MTELargerTurbineBase extends GTPPMultiBlockBase<MTELargerT
         return (getFullTurbineAssemblies().size());
     }
 
-    abstract long fluidIntoPower(ArrayList<FluidStack> aFluids, long aOptFlow, int aBaseEff, float[] flowMultipliers);
+    abstract long fluidIntoPower(ArrayList<FluidStack> aFluids, TurbineStatCalculator turbine);
 
     @Override
     public int getDamageToComponent(ItemStack aStack) {
@@ -572,7 +565,7 @@ public abstract class MTELargerTurbineBase extends GTPPMultiBlockBase<MTELargerT
     }
 
     public boolean isLooseMode() {
-        return false;
+        return looseFit;
     }
 
     @Override
@@ -694,33 +687,28 @@ public abstract class MTELargerTurbineBase extends GTPPMultiBlockBase<MTELargerT
 
     @Override
     public long maxAmperesOut() {
-        // This should not be a hard limit, due to TecTech dynamos
-        if (mFastMode) {
-            return 64;
-        } else {
-            return 16;
-        }
+        return 16;
     }
 
     @Override
     public void saveNBTData(NBTTagCompound aNBT) {
-        aNBT.setBoolean("mFastMode", mFastMode);
         super.saveNBTData(aNBT);
+        aNBT.setBoolean("turbineFitting", looseFit);
     }
 
     @Override
     public void loadNBTData(NBTTagCompound aNBT) {
-        mFastMode = aNBT.getBoolean("mFastMode");
         super.loadNBTData(aNBT);
+        looseFit = aNBT.getBoolean("turbineFitting");
     }
 
     @Override
     public void onModeChangeByScrewdriver(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) {
-        mFastMode = !mFastMode;
-        if (mFastMode) {
-            PlayerUtils.messagePlayer(aPlayer, "Running in Fast (48x) Mode.");
-        } else {
-            PlayerUtils.messagePlayer(aPlayer, "Running in Slow (16x) Mode.");
+        if (side == getBaseMetaTileEntity().getFrontFacing()) {
+            looseFit ^= true;
+            GTUtility.sendChatToPlayer(
+                aPlayer,
+                looseFit ? "Fitting: Loose - More Flow" : "Fitting: Tight - More Efficiency");
         }
     }
 
@@ -862,19 +850,19 @@ public abstract class MTELargerTurbineBase extends GTPPMultiBlockBase<MTELargerT
     }
 
     public int getSpeedMultiplier() {
-        return mFastMode ? 48 : 16;
+        return 16;
     }
 
     public int getMaintenanceThreshold() {
-        return mFastMode ? 12 : 1;
+        return 1;
     }
 
     public int getPollutionMultiplier() {
-        return mFastMode ? 3 : 1;
+        return 1;
     }
 
     public int getTurbineDamageMultiplier() {
-        return mFastMode ? 3 : 1;
+        return 1;
     }
 
     @Override
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargeTurbinePlasma.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargerTurbinePlasma.java
index 310463e0d5..9947cc6350 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargeTurbinePlasma.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/turbines/MTELargerTurbinePlasma.java
@@ -23,27 +23,28 @@ import gregtech.api.recipe.check.SimpleCheckRecipeResult;
 import gregtech.api.recipe.maps.FuelBackend;
 import gregtech.api.util.GTRecipe;
 import gregtech.api.util.GTUtility;
+import gregtech.api.util.TurbineStatCalculator;
 import gregtech.api.util.shutdown.ShutDownReasonRegistry;
 import gtPlusPlus.core.util.math.MathUtils;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.MTEHatchTurbine;
 import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
 
 @SuppressWarnings("deprecation")
-public class MTELargeTurbinePlasma extends MTELargerTurbineBase {
+public class MTELargerTurbinePlasma extends MTELargerTurbineBase {
 
     private static final HashSet<Fluid> BLACKLIST = new HashSet<>();
 
-    public MTELargeTurbinePlasma(int aID, String aName, String aNameRegional) {
+    public MTELargerTurbinePlasma(int aID, String aName, String aNameRegional) {
         super(aID, aName, aNameRegional);
     }
 
-    public MTELargeTurbinePlasma(String aName) {
+    public MTELargerTurbinePlasma(String aName) {
         super(aName);
     }
 
     @Override
     public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
-        return new MTELargeTurbinePlasma(mName);
+        return new MTELargerTurbinePlasma(mName);
     }
 
     @Override
@@ -119,6 +120,14 @@ public class MTELargeTurbinePlasma extends MTELargerTurbineBase {
                 return CheckRecipeResultRegistry.NO_TURBINE_FOUND;
             }
 
+            // At this point all turbines are equivalent in all hatches, use the stats of the first turbine for
+            // calculations
+            ItemStack turbineItem = mTurbineRotorHatches.get(0)
+                .getTurbine();
+            TurbineStatCalculator turbine = new TurbineStatCalculator(
+                (MetaGeneratedTool) turbineItem.getItem(),
+                turbineItem);
+
             ArrayList<FluidStack> tFluids = getStoredFluids();
 
             if (tFluids.size() > 0) {
@@ -140,21 +149,11 @@ public class MTELargeTurbinePlasma extends MTELargerTurbineBase {
 
                     ItemStack aStack = getFullTurbineAssemblies().get(0)
                         .getTurbine();
-                    aTotalBaseEff += GTUtility.safeInt(
-                        (long) ((5F + ((MetaGeneratedTool) aStack.getItem()).getToolCombatDamage(aStack)) * 1000F));
-                    aTotalOptimalFlow += GTUtility
-                        .safeInt(
-                            (long) Math.max(
-                                Float.MIN_NORMAL,
-                                ((MetaGeneratedTool) aStack.getItem()).getToolStats(aStack)
-                                    .getSpeedMultiplier() * MetaGeneratedTool.getPrimaryMaterial(aStack).mToolSpeed
-                                    * 50));
+                    aTotalBaseEff += turbine.getPlasmaEfficiency() * 10000;
+                    aTotalOptimalFlow += turbine.getOptimalPlasmaFlow();
 
                     // Calculate total EU/t (as shown on turbine tooltip (Fast mode doesn't affect))
-                    double aEUPerTurbine = aTotalOptimalFlow * 40
-                        * 0.0105
-                        * MetaGeneratedTool.getPrimaryMaterial(aStack).mPlasmaMultiplier
-                        * (50.0f + (10.0f * ((MetaGeneratedTool) aStack.getItem()).getToolCombatDamage(aStack)));
+                    double aEUPerTurbine = turbine.getOptimalPlasmaEUt();
                     aTotalOptimalFlow *= getSpeedMultiplier();
 
                     if (aTotalOptimalFlow < 0) {
@@ -177,7 +176,7 @@ public class MTELargeTurbinePlasma extends MTELargerTurbineBase {
             }
 
             // How much the turbine should be producing with this flow
-            long newPower = fluidIntoPower(tFluids, optFlow, baseEff, flowMultipliers);
+            long newPower = fluidIntoPower(tFluids, turbine);
 
             // Reduce produced power depending on the ratio between fuel value and turbine EU/t with the following
             // formula:
@@ -198,7 +197,7 @@ public class MTELargeTurbinePlasma extends MTELargerTurbineBase {
             int maxChangeAllowed = Math.max(10, GTUtility.safeInt((long) Math.abs(difference) / 100));
 
             if (Math.abs(difference) > maxChangeAllowed) { // If this difference is too big, use the maximum allowed
-                                                           // change
+                // change
                 int change = maxChangeAllowed * (difference > 0 ? 1 : -1); // Make the change positive or negative.
                 this.lEUt += change; // Apply the change
             } else {
@@ -210,7 +209,7 @@ public class MTELargeTurbinePlasma extends MTELargerTurbineBase {
                 return CheckRecipeResultRegistry.NO_FUEL_FOUND;
             } else {
                 this.mMaxProgresstime = 20;
-                this.mEfficiencyIncrease = 10;
+                this.mEfficiencyIncrease = 200;
                 // Overvoltage is handled inside the MultiBlockBase when pushing out to dynamos. no need to do it here.
                 // Play sounds (GT++ addition - GT multiblocks play no sounds)
                 enableAllTurbineHatches();
@@ -222,24 +221,24 @@ public class MTELargeTurbinePlasma extends MTELargerTurbineBase {
         return CheckRecipeResultRegistry.NO_FUEL_FOUND;
     }
 
-    @Override
-    long fluidIntoPower(ArrayList<FluidStack> aFluids, long aOptFlow, int aBaseEff, float[] flowMultipliers) {
+    long fluidIntoPower(ArrayList<FluidStack> aFluids, TurbineStatCalculator turbine) {
         if (aFluids.size() >= 1) {
-            aOptFlow *= 800; // CHANGED THINGS HERE, check recipe runs once per 20 ticks
             int tEU = 0;
 
             int actualOptimalFlow = 0;
 
             FluidStack firstFuelType = new FluidStack(aFluids.get(0), 0); // Identify a SINGLE type of fluid to process.
-                                                                          // Doesn't matter which one. Ignore the rest!
+            // Doesn't matter which one. Ignore the rest!
             int fuelValue = getFuelValue(firstFuelType);
-            actualOptimalFlow = GTUtility
-                .safeInt((long) Math.ceil((double) aOptFlow * (double) flowMultipliers[2] / (double) fuelValue));
+            actualOptimalFlow = GTUtility.safeInt(
+                (long) ((getSpeedMultiplier()
+                    * (isLooseMode() ? turbine.getOptimalLoosePlasmaFlow() : turbine.getOptimalPlasmaFlow())
+                    * 20) / (double) fuelValue)); // Check recipe runs once every 20 ticks
             this.realOptFlow = actualOptimalFlow; // For scanner info
 
             int remainingFlow = GTUtility.safeInt((long) (actualOptimalFlow * 1.25f)); // Allowed to use up to 125% of
-                                                                                       // optimal flow. Variable
-                                                                                       // required outside of loop for
+            // optimal flow. Variable
+            // required outside of loop for
             // multi-hatch scenarios.
             int flow = 0;
             int totalFlow = 0;
@@ -270,12 +269,16 @@ public class MTELargeTurbinePlasma extends MTELargerTurbineBase {
             tEU = GTUtility.safeInt((long) ((fuelValue / 20D) * (double) totalFlow));
 
             if (totalFlow == actualOptimalFlow) {
-                tEU = GTUtility.safeInt((long) (aBaseEff / 10000D * tEU));
+                tEU = GTUtility.safeInt(
+                    (long) ((isLooseMode() ? turbine.getLoosePlasmaEfficiency() : turbine.getPlasmaEfficiency())
+                        * tEU));
             } else {
                 double efficiency = 1.0D - Math.abs((totalFlow - actualOptimalFlow) / (float) actualOptimalFlow);
 
                 tEU = (int) (tEU * efficiency);
-                tEU = GTUtility.safeInt((long) (aBaseEff / 10000D * tEU));
+                tEU = GTUtility.safeInt(
+                    (long) ((isLooseMode() ? turbine.getLoosePlasmaEfficiency() : turbine.getPlasmaEfficiency())
+                        * tEU));
             }
 
             return tEU;
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechLargeTurbinesAndHeatExchanger.java b/src/main/java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechLargeTurbinesAndHeatExchanger.java
index 580be58352..67d75fe68c 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechLargeTurbinesAndHeatExchanger.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechLargeTurbinesAndHeatExchanger.java
@@ -13,10 +13,10 @@ import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.MTEHatchTurbine;
 import gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.processing.advanced.MTEAdvHeatExchanger;
 import gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.production.turbines.MTELargeTurbineGas;
-import gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.production.turbines.MTELargeTurbinePlasma;
 import gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.production.turbines.MTELargeTurbineSCSteam;
 import gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.production.turbines.MTELargeTurbineSHSteam;
 import gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.production.turbines.MTELargeTurbineSteam;
+import gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.production.turbines.MTELargerTurbinePlasma;
 
 public class GregtechLargeTurbinesAndHeatExchanger {
 
@@ -38,7 +38,7 @@ public class GregtechLargeTurbinesAndHeatExchanger {
             new MTELargeTurbineGas(Large_Gas_Turbine.ID, "multimachine.largergasturbine", "XL Turbo Gas Turbine")
                 .getStackForm(1L));
         GregtechItemList.Large_Plasma_Turbine.set(
-            new MTELargeTurbinePlasma(
+            new MTELargerTurbinePlasma(
                 Large_Plasma_Turbine.ID,
                 "multimachine.largerplasmaturbine",
                 "XL Turbo Plasma Turbine").getStackForm(1L));