Migrate fusion reactor to proper generic processing logic (#2145)

* Migrate fusion to generic processing logic

* Adjusted OC calculator to allow max number of OCs

* Fixed typo

* Fix buffer consumption logic

* Fix oversight

* Addressed reviews

3 files changed, 92 insertions, 2 deletions

diff --git a/src/main/java/gregtech/api/recipe/check/CheckRecipeResultRegistry.java b/src/main/java/gregtech/api/recipe/check/CheckRecipeResultRegistry.java
index 26f9dedd7d..7a2d8661dd 100644
--- a/src/main/java/gregtech/api/recipe/check/CheckRecipeResultRegistry.java
+++ b/src/main/java/gregtech/api/recipe/check/CheckRecipeResultRegistry.java
@@ -102,10 +102,18 @@ public final class CheckRecipeResultRegistry {
         return new ResultInsufficientMachineTier(required);
     }
 
+    /**
+     * Cannot process recipe because the machine doesn't have enough startup power.
+     */
+    public static CheckRecipeResult insufficientStartupPower(int required) {
+        return new ResultInsufficientStartupPower(required);
+    }
+
     static {
         register(new SimpleCheckRecipeResult(false, ""));
         register(new ResultInsufficientPower(0));
         register(new ResultInsufficientHeat(0));
         register(new ResultInsufficientMachineTier(0));
+        register(new ResultInsufficientStartupPower(0));
     }
 }
diff --git a/src/main/java/gregtech/api/recipe/check/ResultInsufficientStartupPower.java b/src/main/java/gregtech/api/recipe/check/ResultInsufficientStartupPower.java
new file mode 100644
index 0000000000..42b352563d
--- /dev/null
+++ b/src/main/java/gregtech/api/recipe/check/ResultInsufficientStartupPower.java
@@ -0,0 +1,54 @@
+package gregtech.api.recipe.check;
+
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.util.StatCollector;
+
+import gregtech.api.util.GT_Utility;
+
+public class ResultInsufficientStartupPower implements CheckRecipeResult {
+
+    private int required;
+
+    ResultInsufficientStartupPower(int required) {
+        this.required = required;
+    }
+
+    @Override
+    public String getID() {
+        return "insufficient_startup_power";
+    }
+
+    @Override
+    public boolean wasSuccessful() {
+        return false;
+    }
+
+    @Override
+    public String getDisplayString() {
+        return StatCollector
+            .translateToLocalFormatted("GT5U.gui.text.insufficient_startup_power", GT_Utility.formatNumbers(required));
+    }
+
+    @Override
+    public CheckRecipeResult newInstance() {
+        return new ResultInsufficientStartupPower(0);
+    }
+
+    @Override
+    public void encode(PacketBuffer buffer) {
+        buffer.writeVarIntToBuffer(required);
+    }
+
+    @Override
+    public void decode(PacketBuffer buffer) {
+        required = buffer.readVarIntFromBuffer();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ResultInsufficientStartupPower that = (ResultInsufficientStartupPower) o;
+        return required == that.required;
+    }
+}
diff --git a/src/main/java/gregtech/api/util/GT_OverclockCalculator.java b/src/main/java/gregtech/api/util/GT_OverclockCalculator.java
index 026f5e3fc9..d8948fc265 100644
--- a/src/main/java/gregtech/api/util/GT_OverclockCalculator.java
+++ b/src/main/java/gregtech/api/util/GT_OverclockCalculator.java
@@ -40,6 +40,13 @@ public class GT_OverclockCalculator {
      */
     private boolean mHeatOC, mOneTickDiscount, calculated, mHeatDiscount;
 
+    /** If the OC calculator should only do a given amount of overclocks. Mainly used in fusion reactors */
+    private boolean limitOverclocks;
+    /** Maximum amount of overclocks to perform, when limitOverclocks = true */
+    private int maxOverclocks;
+    /** How many overclocks have been performed */
+    private int overclockCount;
+
     private static final int HEAT_DISCOUNT_THRESHOLD = 900;
     private static final int HEAT_PERFECT_OVERCLOCK_THRESHOLD = 1800;
 
@@ -213,6 +220,16 @@ public class GT_OverclockCalculator {
     }
 
     /**
+     * Limit the amount of overclocks that can be performed, regardless of how much power is available. Mainly used for
+     * fusion reactors.
+     */
+    public GT_OverclockCalculator limitOverclockCount(int maxOverclocks) {
+        this.limitOverclocks = true;
+        this.maxOverclocks = maxOverclocks;
+        return this;
+    }
+
+    /**
      * Call this when all values have been put it.
      */
     public GT_OverclockCalculator calculate() {
@@ -250,7 +267,8 @@ public class GT_OverclockCalculator {
             long tNextConsumption = ((long) Math
                 .ceil(mRecipeEUt * mParallel * mRecipeAmps * mEUtDiscount * heatDiscountMultiplier))
                 << mEUtIncreasePerOC;
-            while (tTierDifference > 0 && tNextConsumption < mEUt * mAmps) {
+            while (tTierDifference > 0 && tNextConsumption < mEUt * mAmps
+                && (!limitOverclocks || overclockCount++ < maxOverclocks)) {
                 if (mDuration <= 1) {
                     break;
                 }
@@ -263,7 +281,7 @@ public class GT_OverclockCalculator {
             long tNextConsumption = ((long) Math
                 .ceil(mRecipeEUt * mParallel * mRecipeAmps * mEUtDiscount * heatDiscountMultiplier))
                 << mEUtIncreasePerOC;
-            while (tNextConsumption < mEUt * mAmps) {
+            while (tNextConsumption < mEUt * mAmps && (!limitOverclocks || overclockCount++ < maxOverclocks)) {
                 if (mDuration <= 1) {
                     break;
                 }
@@ -307,4 +325,14 @@ public class GT_OverclockCalculator {
         }
         return mDuration;
     }
+
+    /**
+     * @return Number of performed overclocks
+     */
+    public int getPerformedOverclocks() {
+        if (!calculated) {
+            calculate();
+        }
+        return overclockCount;
+    }
 }