Refactor HitResult generation to make ruleset-specific behavior more explicit

PerformanceCalculator/Simulate/CatchSimulateCommand.cs

@@ -35,7 +35,9 @@ public class CatchSimulateCommand : SimulateCommand
 
         public override Ruleset Ruleset => new CatchRuleset();
 
-        protected override Dictionary<HitResult, int> GenerateHitResults(double accuracy, IBeatmap beatmap, int countMiss, int? countMeh, int? countGood)
+        protected override Dictionary<HitResult, int> GenerateHitResults(IBeatmap beatmap) => generateHitResults(beatmap, Accuracy / 100, Misses, Mehs, Goods);
+
+        private static Dictionary<HitResult, int> generateHitResults(IBeatmap beatmap, double accuracy, int countMiss, int? countMeh, int? countGood)
         {
             var maxCombo = beatmap.GetMaxCombo();
             int maxTinyDroplets = beatmap.HitObjects.OfType<JuiceStream>().Sum(s => s.NestedHitObjects.OfType<TinyDroplet>().Count());

PerformanceCalculator/Simulate/ManiaSimulateCommand.cs

@@ -35,21 +35,23 @@ public class ManiaSimulateCommand : SimulateCommand
 
         public override Ruleset Ruleset => new ManiaRuleset();
 
-        protected override Dictionary<HitResult, int> GenerateHitResults(double accuracy, IBeatmap beatmap, int countMiss, int? countMeh, int? countGood)
+        protected override Dictionary<HitResult, int> GenerateHitResults(IBeatmap beatmap) => generateHitResults(beatmap, Accuracy / 100, Misses, Mehs, oks, Goods, greats);
+
+        private static Dictionary<HitResult, int> generateHitResults(IBeatmap beatmap, double accuracy, int countMiss, int? countMeh, int? countOk, int? countGood, int? countGreat)
         {
             // One judgement per normal note. Two judgements per hold note (head + tail).
             var totalHits = beatmap.HitObjects.Count + beatmap.HitObjects.Count(ho => ho is HoldNote);
 
-            if (countMeh != null || oks != null || countGood != null || greats != null)
+            if (countMeh != null || countOk != null || countGood != null || countGreat != null)
             {
-                int countPerfect = totalHits - (countMiss + (countMeh ?? 0) + (oks ?? 0) + (countGood ?? 0) + (greats ?? 0));
+                int countPerfect = totalHits - (countMiss + (countMeh ?? 0) + (countOk ?? 0) + (countGood ?? 0) + (countGreat ?? 0));
 
                 return new Dictionary<HitResult, int>
                 {
                     [HitResult.Perfect] = countPerfect,
-                    [HitResult.Great] = greats ?? 0,
+                    [HitResult.Great] = countGreat ?? 0,
                     [HitResult.Good] = countGood ?? 0,
-                    [HitResult.Ok] = oks ?? 0,
+                    [HitResult.Ok] = countOk ?? 0,
                     [HitResult.Meh] = countMeh ?? 0,
                     [HitResult.Miss] = countMiss
                 };
@@ -66,28 +68,28 @@ protected override Dictionary<HitResult, int> GenerateHitResults(double accuracy
             // Each great and perfect increases total by 5 (great-meh=5)
             // There is no difference in accuracy between them, so just halve arbitrarily (favouring perfects for an odd number).
             int greatsAndPerfects = Math.Min(delta / 5, remainingHits);
-            int countGreat = greatsAndPerfects / 2;
-            int perfects = greatsAndPerfects - countGreat;
-            delta -= (countGreat + perfects) * 5;
-            remainingHits -= countGreat + perfects;
+            int greats = greatsAndPerfects / 2;
+            int perfects = greatsAndPerfects - greats;
+            delta -= (greats + perfects) * 5;
+            remainingHits -= greats + perfects;
 
             // Each good increases total by 3 (good-meh=3).
             countGood = Math.Min(delta / 3, remainingHits);
             delta -= countGood.Value * 3;
             remainingHits -= countGood.Value;
 
             // Each ok increases total by 1 (ok-meh=1).
-            int countOk = delta;
-            remainingHits -= countOk;
+            int oks = delta;
+            remainingHits -= oks;
 
             // Everything else is a meh, as initially assumed.
             countMeh = remainingHits;
 
             return new Dictionary<HitResult, int>
             {
                 { HitResult.Perfect, perfects },
-                { HitResult.Great, countGreat },
-                { HitResult.Ok, countOk },
+                { HitResult.Great, greats },
+                { HitResult.Ok, oks },
                 { HitResult.Good, countGood.Value },
                 { HitResult.Meh, countMeh.Value },
                 { HitResult.Miss, countMiss }

PerformanceCalculator/Simulate/OsuSimulateCommand.cs

@@ -43,7 +43,9 @@ public class OsuSimulateCommand : SimulateCommand
 
         public override Ruleset Ruleset => new OsuRuleset();
 
-        protected override Dictionary<HitResult, int> GenerateHitResults(double accuracy, IBeatmap beatmap, int countMiss, int? countMeh, int? countGood)
+        protected override Dictionary<HitResult, int> GenerateHitResults(IBeatmap beatmap) => generateHitResults(beatmap, Accuracy / 100, Misses, Mehs, Goods, largeTickMisses, sliderTailMisses);
+
+        private static Dictionary<HitResult, int> generateHitResults(IBeatmap beatmap, double accuracy, int countMiss, int? countMeh, int? countGood, int countLargeTickMisses, int countSliderTailMisses)
         {
             int countGreat;
 
@@ -124,8 +126,8 @@ protected override Dictionary<HitResult, int> GenerateHitResults(double accuracy
                 { HitResult.Great, countGreat },
                 { HitResult.Ok, countGood ?? 0 },
                 { HitResult.Meh, countMeh ?? 0 },
-                { HitResult.LargeTickMiss, largeTickMisses },
-                { HitResult.SliderTailHit, beatmap.HitObjects.Count(x => x is Slider) - sliderTailMisses },
+                { HitResult.LargeTickMiss, countLargeTickMisses },
+                { HitResult.SliderTailHit, beatmap.HitObjects.Count(x => x is Slider) - countSliderTailMisses },
                 { HitResult.Miss, countMiss }
             };
         }

PerformanceCalculator/Simulate/SimulateCommand.cs

@@ -66,7 +66,7 @@ public override void Execute()
             var beatmap = workingBeatmap.GetPlayableBeatmap(ruleset.RulesetInfo, mods);
 
             var beatmapMaxCombo = beatmap.GetMaxCombo();
-            var statistics = GenerateHitResults(Accuracy / 100, beatmap, Misses, Mehs, Goods);
+            var statistics = GenerateHitResults(beatmap);
             var scoreInfo = new ScoreInfo(beatmap.BeatmapInfo, ruleset.RulesetInfo)
             {
                 Accuracy = GetAccuracy(beatmap, statistics),
@@ -83,7 +83,7 @@ public override void Execute()
             OutputPerformance(scoreInfo, performanceAttributes, difficultyAttributes);
         }
 
-        protected abstract Dictionary<HitResult, int> GenerateHitResults(double accuracy, IBeatmap beatmap, int countMiss, int? countMeh, int? countGood);
+        protected abstract Dictionary<HitResult, int> GenerateHitResults(IBeatmap beatmap);
 
         protected virtual double GetAccuracy(IBeatmap beatmap, Dictionary<HitResult, int> statistics) => 0;
     }

PerformanceCalculator/Simulate/TaikoSimulateCommand.cs

@@ -29,7 +29,9 @@ public class TaikoSimulateCommand : SimulateCommand
 
         public override Ruleset Ruleset => new TaikoRuleset();
 
-        protected override Dictionary<HitResult, int> GenerateHitResults(double accuracy, IBeatmap beatmap, int countMiss, int? countMeh, int? countGood)
+        protected override Dictionary<HitResult, int> GenerateHitResults(IBeatmap beatmap) => generateHitResults(Accuracy / 100, beatmap, Misses, Goods);
+
+        private static Dictionary<HitResult, int> generateHitResults(double accuracy, IBeatmap beatmap, int countMiss, int? countGood)
         {
             var totalResultCount = beatmap.GetMaxCombo();