Implement a bunch of rhythm difficulty calculation fixes

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

@@ -2,6 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Osu.Objects;
@@ -10,21 +12,65 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
 {
     public static class RhythmEvaluator
     {
-        private const int history_time_max = 5000; // 5 seconds of calculatingRhythmBonus max.
+        private readonly struct Island : IEquatable<Island>
-        private const double rhythm_multiplier = 0.75;
+        {
+            public Island()
+            {
+            }
+
+            public Island(int firstDelta, double epsilon)
+            {
+                AddDelta(firstDelta, epsilon);
+            }
+
+            public List<int> Deltas { get; } = new List<int>();
+
+            public void AddDelta(int delta, double epsilon)
+            {
+                int existingDelta = Deltas.FirstOrDefault(x => Math.Abs(x - delta) >= epsilon);
+
+                Deltas.Add(existingDelta == default ? delta : existingDelta);
+            }
+
+            public double AverageDelta() => Math.Max(Deltas.Average(), OsuDifficultyHitObject.MIN_DELTA_TIME);
+
+            public override int GetHashCode()
+            {
+                // we need to compare all deltas and they must be in the exact same order we added them
+                string joinedDeltas = string.Join(string.Empty, Deltas);
+                return joinedDeltas.GetHashCode();
+            }
+
+            public bool Equals(Island other)
+            {
+                return other.GetHashCode() == GetHashCode();
+            }
+
+            public override bool Equals(object? obj)
+            {
+                return obj?.GetHashCode() == GetHashCode();
+            }
+        }
+
+        private const int history_time_max = 5 * 1000; // 5 seconds of calculatingRhythmBonus max.
+        private const double rhythm_multiplier = 1.14;
+        private const int max_island_size = 7;
 
         /// <summary>
         /// Calculates a rhythm multiplier for the difficulty of the tap associated with historic data of the current <see cref="OsuDifficultyHitObject"/>.
         /// </summary>
         public static double EvaluateDifficultyOf(DifficultyHitObject current)
         {
+            Dictionary<Island, int> islandCounts = new Dictionary<Island, int>();
+
             if (current.BaseObject is Spinner)
                 return 0;
 
-            int previousIslandSize = 0;
-
             double rhythmComplexitySum = 0;
-            int islandSize = 1;
+
+            var island = new Island();
+            var previousIsland = new Island();
+
             double startRatio = 0; // store the ratio of the current start of an island to buff for tighter rhythms
 
             bool firstDeltaSwitch = false;
@@ -50,6 +96,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
                 double currDelta = currObj.StrainTime;
                 double prevDelta = prevObj.StrainTime;
                 double lastDelta = lastObj.StrainTime;
+
                 double currRatio = 1.0 + 6.0 * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / (Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta))), 2)); // fancy function to calculate rhythmbonuses.
 
                 double windowPenalty = Math.Min(1, Math.Max(0, Math.Abs(prevDelta - currDelta) - currObj.HitWindowGreat * 0.3) / (currObj.HitWindowGreat * 0.3));
@@ -58,12 +105,17 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
 
                 double effectiveRatio = windowPenalty * currRatio;
 
+                double deltaDifferenceEpsilon = currObj.HitWindowGreat * 0.3;
+
                 if (firstDeltaSwitch)
                 {
-                    if (!(prevDelta > 1.25 * currDelta || prevDelta * 1.25 < currDelta))
+                    if (!(Math.Abs(prevDelta - currDelta) > deltaDifferenceEpsilon))
                     {
-                        if (islandSize < 7)
+                        if (island.Deltas.Count < max_island_size)
-                            islandSize++; // island is still progressing, count size.
+                        {
+                            // island is still progressing
+                            island.AddDelta((int)currDelta, deltaDifferenceEpsilon);
+                        }
                     }
                     else
                     {
@@ -73,33 +125,44 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
                         if (prevObj.BaseObject is Slider) // bpm change was from a slider, this is easier typically than circle -> circle
                             effectiveRatio *= 0.25;
 
-                        if (previousIslandSize == islandSize) // repeated island size (ex: triplet -> triplet)
+                        if (previousIsland.Deltas.Count % 2 == island.Deltas.Count % 2) // repeated island polartiy (2 -> 4, 3 -> 5)
-                            effectiveRatio *= 0.25;
-
-                        if (previousIslandSize % 2 == islandSize % 2) // repeated island polartiy (2 -> 4, 3 -> 5)
                             effectiveRatio *= 0.50;
 
-                        if (lastDelta > prevDelta + 10 && prevDelta > currDelta + 10) // previous increase happened a note ago, 1/1->1/2-1/4, dont want to buff this.
+                        if (lastDelta > prevDelta + deltaDifferenceEpsilon && prevDelta > currDelta + deltaDifferenceEpsilon) // previous increase happened a note ago, 1/1->1/2-1/4, dont want to buff this.
                             effectiveRatio *= 0.125;
 
-                        rhythmComplexitySum += Math.Sqrt(effectiveRatio * startRatio) * currHistoricalDecay * Math.Sqrt(4 + islandSize) / 2 * Math.Sqrt(4 + previousIslandSize) / 2;
+                        if (islandCounts.ContainsKey(island))
+                        {
+                            islandCounts[island]++;
+
+                            // repeated island (ex: triplet -> triplet)
+                            double power = Math.Max(0.75, logistic(island.AverageDelta(), 3, 0.15, 9));
+                            effectiveRatio *= Math.Pow(1.0 / islandCounts[island], power);
+                        }
+                        else
+                        {
+                            islandCounts.Add(island, 1);
+                        }
+
+                        rhythmComplexitySum += Math.Sqrt(effectiveRatio * startRatio) * currHistoricalDecay;
 
                         startRatio = effectiveRatio;
 
-                        previousIslandSize = islandSize; // log the last island size.
+                        previousIsland = island;
 
-                        if (prevDelta * 1.25 < currDelta) // we're slowing down, stop counting
+                        if (prevDelta + deltaDifferenceEpsilon < currDelta) // we're slowing down, stop counting
                             firstDeltaSwitch = false; // if we're speeding up, this stays true and  we keep counting island size.
 
-                        islandSize = 1;
+                        island = new Island((int)currDelta, deltaDifferenceEpsilon);
                     }
                 }
-                else if (prevDelta > 1.25 * currDelta) // we want to be speeding up.
+                else if (prevDelta > currDelta + deltaDifferenceEpsilon) // we want to be speeding up.
                 {
                     // Begin counting island until we change speed again.
                     firstDeltaSwitch = true;
                     startRatio = effectiveRatio;
-                    islandSize = 1;
+
+                    island = new Island((int)currDelta, deltaDifferenceEpsilon);
                 }
 
                 lastObj = prevObj;
@@ -108,5 +171,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
 
             return Math.Sqrt(4 + rhythmComplexitySum * rhythm_multiplier) / 2; //produces multiplier that can be applied to strain. range [1, infinity) (not really though)
         }
+
+        private static double logistic(double x, double maxValue, double multiplier, double offset) => (maxValue / (1 + Math.Pow(Math.E, offset - multiplier * x)));
     }
 }

osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs

@@ -20,7 +20,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
         /// </summary>
         public const int NORMALISED_RADIUS = 50; // Change radius to 50 to make 100 the diameter. Easier for mental maths.
 
-        private const int min_delta_time = 25;
+        public const int MIN_DELTA_TIME = 25;
+
         private const float maximum_slider_radius = NORMALISED_RADIUS * 2.4f;
         private const float assumed_slider_radius = NORMALISED_RADIUS * 1.8f;
 
@@ -93,7 +94,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
             this.lastObject = (OsuHitObject)lastObject;
 
             // Capped to 25ms to prevent difficulty calculation breaking from simultaneous objects.
-            StrainTime = Math.Max(DeltaTime, min_delta_time);
+            StrainTime = Math.Max(DeltaTime, MIN_DELTA_TIME);
 
             if (BaseObject is Slider sliderObject)
             {
@@ -143,7 +144,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
                 computeSliderCursorPosition(currentSlider);
                 // Bonus for repeat sliders until a better per nested object strain system can be achieved.
                 TravelDistance = currentSlider.LazyTravelDistance * (float)Math.Pow(1 + currentSlider.RepeatCount / 2.5, 1.0 / 2.5);
-                TravelTime = Math.Max(currentSlider.LazyTravelTime / clockRate, min_delta_time);
+                TravelTime = Math.Max(currentSlider.LazyTravelTime / clockRate, MIN_DELTA_TIME);
             }
 
             // We don't need to calculate either angle or distance when one of the last->curr objects is a spinner
@@ -167,8 +168,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
 
             if (lastObject is Slider lastSlider)
             {
-                double lastTravelTime = Math.Max(lastSlider.LazyTravelTime / clockRate, min_delta_time);
+                double lastTravelTime = Math.Max(lastSlider.LazyTravelTime / clockRate, MIN_DELTA_TIME);
-                MinimumJumpTime = Math.Max(StrainTime - lastTravelTime, min_delta_time);
+                MinimumJumpTime = Math.Max(StrainTime - lastTravelTime, MIN_DELTA_TIME);
 
                 //
                 // There are two types of slider-to-object patterns to consider in order to better approximate the real movement a player will take to jump between the hitobjects.