From 50877adf4583874381fb11f998e4f53abe8f6b4b Mon Sep 17 00:00:00 2001
From: Pinapelz <yukais@pinapelz.com>
Date: Sun, 1 Sep 2024 00:03:32 -0700
Subject: refactor: condense remaining series xp calculation

---
 Malmstone/Plugin.cs                      |   2 +-
 Malmstone/Utils/MalmstoneXPCalculator.cs | 113 ++++++++++++++-----------------
 2 files changed, 53 insertions(+), 62 deletions(-)

diff --git a/Malmstone/Plugin.cs b/Malmstone/Plugin.cs
index d4f4cfd..6f5e50c 100644
--- a/Malmstone/Plugin.cs
+++ b/Malmstone/Plugin.cs
@@ -28,7 +28,7 @@ public sealed class Plugin : IDalamudPlugin
     public readonly WindowSystem WindowSystem = new("Malmstone");
     private ConfigWindow ConfigWindow { get; init; }
     private MainWindow MainWindow { get; init; }
-    private PvPService PvPService;
+    internal readonly PvPService PvPService;
 
     public Plugin()
     {
diff --git a/Malmstone/Utils/MalmstoneXPCalculator.cs b/Malmstone/Utils/MalmstoneXPCalculator.cs
index 85ecadf..ab6fcf9 100644
--- a/Malmstone/Utils/MalmstoneXPCalculator.cs
+++ b/Malmstone/Utils/MalmstoneXPCalculator.cs
@@ -40,28 +40,15 @@ namespace Malmstone.Utils
 
         public static XpCalculationResult CalculateXp(int currentLevel, int goalLevel, int currentProgress)
         {
-            if (currentLevel < 1 || goalLevel < 1)
-            {
-                throw new ArgumentOutOfRangeException(nameof(currentLevel), "Levels must be greater than 0.");
-            }
 
-            int remainingXp = 0;
-
-            if (currentLevel <= PvpLevels.Length && goalLevel <= PvpLevels.Length)
-            {
-                remainingXp = CalculateRemainingXp(currentLevel, goalLevel, currentProgress);
-            }
-            else
-            {
-                remainingXp = CalculateRemainingXpBeyondChart(currentLevel, goalLevel, currentProgress);
-            }
+            int remainingXp = CalculateRemainingXpForLevels(currentLevel, goalLevel, currentProgress);
 
             if (remainingXp <= 0)
             {
                 return new XpCalculationResult { RemainingXp = 0, TargetLevel = goalLevel };
             }
 
-            var result = new XpCalculationResult
+            return new XpCalculationResult
             {
                 RemainingXp = remainingXp,
                 TargetLevel = goalLevel,
@@ -72,86 +59,89 @@ namespace Malmstone.Utils
                 FrontlineLose3rd = CalculateActivityCount(remainingXp, FrontlineLoseExp),
                 FrontlineDailyWin = CalculateActivityCount(remainingXp, FrontlineDailyWinExp),
                 FrontlineDailyLose2nd = CalculateActivityCount(remainingXp, FrontlineDailyLose2Exp),
-                FrontlineDailyLose3rd = CalculateActivityCount(remainingXp, FrontlineDailyLoseExp),
+                FrontlineDailyLose3rd = CalculateActivityCount(remainingXp, FrontlineLoseExp),
                 RivalWingsWin = CalculateActivityCount(remainingXp, RivalWingsWinExp),
                 RivalWingsLose = CalculateActivityCount(remainingXp, RivalWingsLoseExp)
             };
-
-            return result;
         }
 
         public static XpCalculationResult CalculateCrystallineConflictMatches(int currentLevel, int goalLevel, int currentProgress)
         {
-            var baseResult = CalculateXp(currentLevel, goalLevel, currentProgress);
-            var result = new XpCalculationResult
+            int remainingXp = CalculateRemainingXpForLevels(currentLevel, goalLevel, currentProgress);
+
+            return new XpCalculationResult
             {
-                RemainingXp = baseResult.RemainingXp,
-                TargetLevel = baseResult.TargetLevel,
-                CrystallineConflictWin = CalculateActivityCount(baseResult.RemainingXp, CrystallineWinExp),
-                CrystallineConflictLose = CalculateActivityCount(baseResult.RemainingXp, CrystallineLoseExp)
+                RemainingXp = remainingXp,
+                TargetLevel = goalLevel,
+                CrystallineConflictWin = CalculateActivityCount(remainingXp, CrystallineWinExp),
+                CrystallineConflictLose = CalculateActivityCount(remainingXp, CrystallineLoseExp)
             };
-
-            return result;
         }
 
         public static XpCalculationResult CalculateFrontlineMatches(int currentLevel, int goalLevel, int currentProgress)
         {
-            var baseResult = CalculateXp(currentLevel, goalLevel, currentProgress);
-            var result = new XpCalculationResult
+            int remainingXp = CalculateRemainingXpForLevels(currentLevel, goalLevel, currentProgress);
+
+            return new XpCalculationResult
             {
-                RemainingXp = baseResult.RemainingXp,
-                TargetLevel = baseResult.TargetLevel,
-                FrontlineWin = CalculateActivityCount(baseResult.RemainingXp, FrontlineWinExp),
-                FrontlineLose2nd = CalculateActivityCount(baseResult.RemainingXp, FrontlineLose2Exp),
-                FrontlineLose3rd = CalculateActivityCount(baseResult.RemainingXp, FrontlineLoseExp),
-                FrontlineDailyWin = CalculateActivityCount(baseResult.RemainingXp, FrontlineDailyWinExp),
-                FrontlineDailyLose2nd = CalculateActivityCount(baseResult.RemainingXp, FrontlineDailyLose2Exp),
-                FrontlineDailyLose3rd = CalculateActivityCount(baseResult.RemainingXp, FrontlineDailyLoseExp)
+                RemainingXp = remainingXp,
+                TargetLevel = goalLevel,
+                FrontlineWin = CalculateActivityCount(remainingXp, FrontlineWinExp),
+                FrontlineLose2nd = CalculateActivityCount(remainingXp, FrontlineLose2Exp),
+                FrontlineLose3rd = CalculateActivityCount(remainingXp, FrontlineLoseExp),
+                FrontlineDailyWin = CalculateActivityCount(remainingXp, FrontlineDailyWinExp),
+                FrontlineDailyLose2nd = CalculateActivityCount(remainingXp, FrontlineDailyLose2Exp),
+                FrontlineDailyLose3rd = CalculateActivityCount(remainingXp, FrontlineLoseExp)
             };
-
-            return result;
         }
 
         public static XpCalculationResult CalculateRivalWingsMatches(int currentLevel, int goalLevel, int currentProgress)
         {
-            var baseResult = CalculateXp(currentLevel, goalLevel, currentProgress);
-            var result = new XpCalculationResult
+            int remainingXp = CalculateRemainingXpForLevels(currentLevel, goalLevel, currentProgress);
+
+            return new XpCalculationResult
             {
-                RemainingXp = baseResult.RemainingXp,
-                TargetLevel = baseResult.TargetLevel,
-                RivalWingsWin = CalculateActivityCount(baseResult.RemainingXp, RivalWingsWinExp),
-                RivalWingsLose = CalculateActivityCount(baseResult.RemainingXp, RivalWingsLoseExp)
+                RemainingXp = remainingXp,
+                TargetLevel = goalLevel,
+                RivalWingsWin = CalculateActivityCount(remainingXp, RivalWingsWinExp),
+                RivalWingsLose = CalculateActivityCount(remainingXp, RivalWingsLoseExp)
             };
-
-            return result;
         }
 
-
-        private static int CalculateRemainingXp(int currentLevel, int goalLevel, int currentProgress)
+        private static int CalculateRemainingXpForLevels(int currentLevel, int goalLevel, int currentProgress)
         {
             int remainingXp = 0;
-
-            for (int level = currentLevel; level < goalLevel; level++)
+            if (currentLevel <= PvpLevels.Length)
             {
-                remainingXp += PvpLevels[level];
+                int upperBoundLevel = Math.Min(goalLevel, PvpLevels.Length);
+                remainingXp = CalculateRemainingXpWithinChart(currentLevel, upperBoundLevel, currentProgress);
+
+                if (goalLevel > PvpLevels.Length)
+                {
+                    currentLevel = PvpLevels.Length;
+                    currentProgress = 0;
+                }
             }
-
-            return remainingXp - currentProgress;
+            if (goalLevel > PvpLevels.Length)
+            {
+                remainingXp += CalculateRemainingXpBeyondChart(currentLevel, goalLevel);
+            }
+            return remainingXp;
         }
 
-        private static int CalculateRemainingXpBeyondChart(int currentLevel, int goalLevel, int currentProgress)
+        private static int CalculateRemainingXpWithinChart(int currentLevel, int goalLevel, int currentProgress)
         {
             int remainingXp = 0;
-
-            if (currentLevel <= PvpLevels.Length)
+            for (int level = currentLevel; level < goalLevel; level++)
             {
-                remainingXp = CalculateRemainingXp(currentLevel, PvpLevels.Length, currentProgress);
-                currentLevel = PvpLevels.Length;
+                remainingXp += PvpLevels[level];
             }
+            return remainingXp - currentProgress;
+        }
 
-            remainingXp += (goalLevel - currentLevel) * InfinityLevelExp;
-
-            return remainingXp;
+        private static int CalculateRemainingXpBeyondChart(int currentLevel, int goalLevel)
+        {
+            return (goalLevel - currentLevel) * InfinityLevelExp;
         }
 
         private static int CalculateActivityCount(int remainingXp, int activityXp)
@@ -159,5 +149,6 @@ namespace Malmstone.Utils
             // Should always be greater than 0
             return Math.Max(1, (int)Math.Ceiling((double)remainingXp / activityXp));
         }
+
     }
 }
-- 
cgit v1.2.3