Refactor of osu!taiko difficulty calculation code

osu.Game.Rulesets.Taiko/Difficulty/Evaluators/ColourEvaluator.cs

@@ -10,32 +10,8 @@
 
 namespace osu.Game.Rulesets.Taiko.Difficulty.Evaluators
 {
-    public class ColourEvaluator
+    public static class ColourEvaluator
     {
-        /// <summary>
-        /// Evaluate the difficulty of the first note of a <see cref="MonoStreak"/>.
-        /// </summary>
-        public static double EvaluateDifficultyOf(MonoStreak monoStreak)
-        {
-            return DifficultyCalculationUtils.Logistic(exponent: Math.E * monoStreak.Index - 2 * Math.E) * EvaluateDifficultyOf(monoStreak.Parent) * 0.5;
-        }
-
-        /// <summary>
-        /// Evaluate the difficulty of the first note of a <see cref="AlternatingMonoPattern"/>.
-        /// </summary>
-        public static double EvaluateDifficultyOf(AlternatingMonoPattern alternatingMonoPattern)
-        {
-            return DifficultyCalculationUtils.Logistic(exponent: Math.E * alternatingMonoPattern.Index - 2 * Math.E) * EvaluateDifficultyOf(alternatingMonoPattern.Parent);
-        }
-
-        /// <summary>
-        /// Evaluate the difficulty of the first note of a <see cref="RepeatingHitPatterns"/>.
-        /// </summary>
-        public static double EvaluateDifficultyOf(RepeatingHitPatterns repeatingHitPattern)
-        {
-            return 2 * (1 - DifficultyCalculationUtils.Logistic(exponent: Math.E * repeatingHitPattern.RepetitionInterval - 2 * Math.E));
-        }
-
         /// <summary>
         /// Calculates a consistency penalty based on the number of consecutive consistent intervals,
         /// considering the delta time between each colour sequence.
@@ -89,18 +65,27 @@ public static double EvaluateDifficultyOf(DifficultyHitObject hitObject)
             double difficulty = 0.0d;
 
             if (colour.MonoStreak?.FirstHitObject == hitObject) // Difficulty for MonoStreak
-                difficulty += EvaluateDifficultyOf(colour.MonoStreak);
+                difficulty += evaluateMonoStreakDifficulty(colour.MonoStreak);
 
             if (colour.AlternatingMonoPattern?.FirstHitObject == hitObject) // Difficulty for AlternatingMonoPattern
-                difficulty += EvaluateDifficultyOf(colour.AlternatingMonoPattern);
+                difficulty += evaluateAlternatingMonoPatternDifficulty(colour.AlternatingMonoPattern);
 
             if (colour.RepeatingHitPattern?.FirstHitObject == hitObject) // Difficulty for RepeatingHitPattern
-                difficulty += EvaluateDifficultyOf(colour.RepeatingHitPattern);
+                difficulty += evaluateRepeatingHitPatternsDifficulty(colour.RepeatingHitPattern);
 
             double consistencyPenalty = consistentRatioPenalty(taikoObject);
             difficulty *= consistencyPenalty;
 
             return difficulty;
         }
+
+        private static double evaluateMonoStreakDifficulty(MonoStreak monoStreak) =>
+            DifficultyCalculationUtils.Logistic(exponent: Math.E * monoStreak.Index - 2 * Math.E) * evaluateAlternatingMonoPatternDifficulty(monoStreak.Parent) * 0.5;
+
+        private static double evaluateAlternatingMonoPatternDifficulty(AlternatingMonoPattern alternatingMonoPattern) =>
+            DifficultyCalculationUtils.Logistic(exponent: Math.E * alternatingMonoPattern.Index - 2 * Math.E) * evaluateRepeatingHitPatternsDifficulty(alternatingMonoPattern.Parent);
+
+        private static double evaluateRepeatingHitPatternsDifficulty(RepeatingHitPatterns repeatingHitPattern) =>
+            2 * (1 - DifficultyCalculationUtils.Logistic(exponent: Math.E * repeatingHitPattern.RepetitionInterval - 2 * Math.E));
     }
 }

osu.Game.Rulesets.Taiko/Difficulty/Evaluators/ReadingEvaluator.cs

@@ -47,8 +47,8 @@ public static double EvaluateDifficultyOf(TaikoDifficultyHitObject noteObject)
             // High density is penalised at high velocity as it is generally considered easier to read. See https://www.desmos.com/calculator/u63f3ntdsi
             double densityPenalty = DifficultyCalculationUtils.Logistic(objectDensity, 0.925, 15);
 
-            double highVelocityDifficulty = (1.0 - 0.33 * densityPenalty) * DifficultyCalculationUtils.Logistic
-                (effectiveBPM, highVelocity.Center + 8 * densityPenalty, (1.0 + 0.5 * densityPenalty) / (highVelocity.Range / 10));
+            double highVelocityDifficulty = (1.0 - 0.33 * densityPenalty)
+                                            * DifficultyCalculationUtils.Logistic(effectiveBPM, highVelocity.Center + 8 * densityPenalty, (1.0 + 0.5 * densityPenalty) / (highVelocity.Range / 10));
 
             return midVelocityDifficulty + highVelocityDifficulty;
         }

osu.Game.Rulesets.Taiko/Difficulty/Evaluators/RhythmEvaluator.cs

@@ -25,32 +25,32 @@ public static double EvaluateDifficultyOf(DifficultyHitObject hitObject, double
             double samePattern = 0;
             double intervalPenalty = 0;
 
-            if (rhythm.SameRhythmHitObjects?.FirstHitObject == hitObject) // Difficulty for SameRhythmHitObjects
+            if (rhythm.SameRhythmGroupedHitObjects?.FirstHitObject == hitObject) // Difficulty for SameRhythmGroupedHitObjects
             {
-                sameRhythm += 10.0 * evaluateDifficultyOf(rhythm.SameRhythmHitObjects, hitWindow);
-                intervalPenalty = repeatedIntervalPenalty(rhythm.SameRhythmHitObjects, hitWindow);
+                sameRhythm += 10.0 * evaluateDifficultyOf(rhythm.SameRhythmGroupedHitObjects, hitWindow);
+                intervalPenalty = repeatedIntervalPenalty(rhythm.SameRhythmGroupedHitObjects, hitWindow);
             }
 
-            if (rhythm.SamePatterns?.FirstHitObject == hitObject) // Difficulty for SamePatterns
-                samePattern += 1.15 * ratioDifficulty(rhythm.SamePatterns.IntervalRatio);
+            if (rhythm.SamePatternsGroupedHitObjects?.FirstHitObject == hitObject) // Difficulty for SamePatternsGroupedHitObjects
+                samePattern += 1.15 * ratioDifficulty(rhythm.SamePatternsGroupedHitObjects.IntervalRatio);
 
             difficulty += Math.Max(sameRhythm, samePattern) * intervalPenalty;
 
             return difficulty;
         }
 
-        private static double evaluateDifficultyOf(SameRhythmHitObjects sameRhythmHitObjects, double hitWindow)
+        private static double evaluateDifficultyOf(SameRhythmGroupedHitObjects sameRhythmGroupedHitObjects, double hitWindow)
         {
-            double intervalDifficulty = ratioDifficulty(sameRhythmHitObjects.HitObjectIntervalRatio);
-            double? previousInterval = sameRhythmHitObjects.Previous?.HitObjectInterval;
+            double intervalDifficulty = ratioDifficulty(sameRhythmGroupedHitObjects.HitObjectIntervalRatio);
+            double? previousInterval = sameRhythmGroupedHitObjects.Previous?.HitObjectInterval;
 
-            intervalDifficulty *= repeatedIntervalPenalty(sameRhythmHitObjects, hitWindow);
+            intervalDifficulty *= repeatedIntervalPenalty(sameRhythmGroupedHitObjects, hitWindow);
 
             // If a previous interval exists and there are multiple hit objects in the sequence:
-            if (previousInterval != null && sameRhythmHitObjects.Children.Count > 1)
+            if (previousInterval != null && sameRhythmGroupedHitObjects.Children.Count > 1)
             {
-                double expectedDurationFromPrevious = (double)previousInterval * sameRhythmHitObjects.Children.Count;
-                double durationDifference = sameRhythmHitObjects.Duration - expectedDurationFromPrevious;
+                double expectedDurationFromPrevious = (double)previousInterval * sameRhythmGroupedHitObjects.Children.Count;
+                double durationDifference = sameRhythmGroupedHitObjects.Duration - expectedDurationFromPrevious;
 
                 if (durationDifference > 0)
                 {
@@ -64,7 +64,7 @@ private static double evaluateDifficultyOf(SameRhythmHitObjects sameRhythmHitObj
 
             // Penalise patterns that can be hit within a single hit window.
             intervalDifficulty *= DifficultyCalculationUtils.Logistic(
-                sameRhythmHitObjects.Duration / hitWindow,
+                sameRhythmGroupedHitObjects.Duration / hitWindow,
                 midpointOffset: 0.6,
                 multiplier: 1,
                 maxValue: 1);
@@ -75,20 +75,20 @@ private static double evaluateDifficultyOf(SameRhythmHitObjects sameRhythmHitObj
         /// <summary>
         /// Determines if the changes in hit object intervals is consistent based on a given threshold.
         /// </summary>
-        private static double repeatedIntervalPenalty(SameRhythmHitObjects sameRhythmHitObjects, double hitWindow, double threshold = 0.1)
+        private static double repeatedIntervalPenalty(SameRhythmGroupedHitObjects sameRhythmGroupedHitObjects, double hitWindow, double threshold = 0.1)
         {
-            double longIntervalPenalty = sameInterval(sameRhythmHitObjects, 3);
+            double longIntervalPenalty = sameInterval(sameRhythmGroupedHitObjects, 3);
 
-            double shortIntervalPenalty = sameRhythmHitObjects.Children.Count < 6
-                ? sameInterval(sameRhythmHitObjects, 4)
+            double shortIntervalPenalty = sameRhythmGroupedHitObjects.Children.Count < 6
+                ? sameInterval(sameRhythmGroupedHitObjects, 4)
                 : 1.0; // Returns a non-penalty if there are 6 or more notes within an interval.
 
             // The duration penalty is based on hit object duration relative to hitWindow.
-            double durationPenalty = Math.Max(1 - sameRhythmHitObjects.Duration * 2 / hitWindow, 0.5);
+            double durationPenalty = Math.Max(1 - sameRhythmGroupedHitObjects.Duration * 2 / hitWindow, 0.5);
 
             return Math.Min(longIntervalPenalty, shortIntervalPenalty) * durationPenalty;
 
-            double sameInterval(SameRhythmHitObjects startObject, int intervalCount)
+            double sameInterval(SameRhythmGroupedHitObjects startObject, int intervalCount)
             {
                 List<double?> intervals = new List<double?>();
                 var currentObject = startObject;

osu.Game.Rulesets.Taiko/Difficulty/Evaluators/StaminaEvaluator.cs

@@ -8,8 +8,34 @@
 
 namespace osu.Game.Rulesets.Taiko.Difficulty.Evaluators
 {
-    public class StaminaEvaluator
+    public static class StaminaEvaluator
     {
+        /// <summary>
+        /// Evaluates the minimum mechanical stamina required to play the current object. This is calculated using the
+        /// maximum possible interval between two hits using the same key, by alternating available fingers for each colour.
+        /// </summary>
+        public static double EvaluateDifficultyOf(DifficultyHitObject current)
+        {
+            if (current.BaseObject is not Hit)
+            {
+                return 0.0;
+            }
+
+            // Find the previous hit object hit by the current finger, which is n notes prior, n being the number of
+            // available fingers.
+            TaikoDifficultyHitObject taikoCurrent = (TaikoDifficultyHitObject)current;
+            TaikoDifficultyHitObject? taikoPrevious = current.Previous(1) as TaikoDifficultyHitObject;
+            TaikoDifficultyHitObject? previousMono = taikoCurrent.PreviousMono(availableFingersFor(taikoCurrent) - 1);
+
+            double objectStrain = 0.5; // Add a base strain to all objects
+            if (taikoPrevious == null) return objectStrain;
+
+            if (previousMono != null)
+                objectStrain += speedBonus(taikoCurrent.StartTime - previousMono.StartTime) + 0.5 * speedBonus(taikoCurrent.StartTime - taikoPrevious.StartTime);
+
+            return objectStrain;
+        }
+
         /// <summary>
         /// Applies a speed bonus dependent on the time since the last hit performed using this finger.
         /// </summary>
@@ -44,31 +70,5 @@ private static int availableFingersFor(TaikoDifficultyHitObject hitObject)
 
             return 8;
         }
-
-        /// <summary>
-        /// Evaluates the minimum mechanical stamina required to play the current object. This is calculated using the
-        /// maximum possible interval between two hits using the same key, by alternating available fingers for each colour.
-        /// </summary>
-        public static double EvaluateDifficultyOf(DifficultyHitObject current)
-        {
-            if (current.BaseObject is not Hit)
-            {
-                return 0.0;
-            }
-
-            // Find the previous hit object hit by the current finger, which is n notes prior, n being the number of
-            // available fingers.
-            TaikoDifficultyHitObject taikoCurrent = (TaikoDifficultyHitObject)current;
-            TaikoDifficultyHitObject? taikoPrevious = current.Previous(1) as TaikoDifficultyHitObject;
-            TaikoDifficultyHitObject? previousMono = taikoCurrent.PreviousMono(availableFingersFor(taikoCurrent) - 1);
-
-            double objectStrain = 0.5; // Add a base strain to all objects
-            if (taikoPrevious == null) return objectStrain;
-
-            if (previousMono != null)
-                objectStrain += speedBonus(taikoCurrent.StartTime - previousMono.StartTime) + 0.5 * speedBonus(taikoCurrent.StartTime - taikoPrevious.StartTime);
-
-            return objectStrain;
-        }
     }
 }

osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Rhythm/Data/SamePatternsGroupedHitObjects.cs

@@ -0,0 +1,40 @@
+// Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Rhythm.Data
+{
+    /// <summary>
+    /// Represents <see cref="SameRhythmGroupedHitObjects"/> grouped by their <see cref="SameRhythmGroupedHitObjects.StartTime"/>'s interval.
+    /// </summary>
+    public class SamePatternsGroupedHitObjects
+    {
+        public IReadOnlyList<SameRhythmGroupedHitObjects> Children { get; }
+
+        public SamePatternsGroupedHitObjects? Previous { get; }
+
+        /// <summary>
+        /// The <see cref="SameRhythmGroupedHitObjects.Interval"/> between children <see cref="SameRhythmGroupedHitObjects"/> within this group.
+        /// If there is only one child, this will have the value of the first child's <see cref="SameRhythmGroupedHitObjects.Interval"/>.
+        /// </summary>
+        public double ChildrenInterval => Children.Count > 1 ? Children[1].Interval : Children[0].Interval;
+
+        /// <summary>
+        /// The ratio of <see cref="ChildrenInterval"/> between this and the previous <see cref="SamePatternsGroupedHitObjects"/>. In the
+        /// case where there is no previous <see cref="SamePatternsGroupedHitObjects"/>, this will have a value of 1.
+        /// </summary>
+        public double IntervalRatio => ChildrenInterval / Previous?.ChildrenInterval ?? 1.0d;
+
+        public TaikoDifficultyHitObject FirstHitObject => Children[0].FirstHitObject;
+
+        public IEnumerable<TaikoDifficultyHitObject> AllHitObjects => Children.SelectMany(child => child.Children);
+
+        public SamePatternsGroupedHitObjects(SamePatternsGroupedHitObjects? previous, List<SameRhythmGroupedHitObjects> children)
+        {
+            Previous = previous;
+            Children = children;
+        }
+    }
+}