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,8 +12,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
 {
     public static class RhythmEvaluator
     {
-        private const int history_time_max = 5000; // 5 seconds of calculatingRhythmBonus max.
-        private const double rhythm_multiplier = 0.75;
+        private const int history_time_max = 4 * 1000; // 4 seconds
+        private const int history_objects_max = 24;
+        private const double rhythm_overall_multiplier = 0.95;
+        private const double rhythm_ratio_multiplier = 14.0;
 
         /// <summary>
         /// Calculates a rhythm multiplier for the difficulty of the tap associated with historic data of the current <see cref="OsuDifficultyHitObject"/>.
@@ -21,15 +25,22 @@ public static double EvaluateDifficultyOf(DifficultyHitObject current)
             if (current.BaseObject is Spinner)
                 return 0;
 
-            int previousIslandSize = 0;
-
             double rhythmComplexitySum = 0;
-            int islandSize = 1;
+
+            double deltaDifferenceEpsilon = ((OsuDifficultyHitObject)current).HitWindowGreat * 0.3;
+
+            var island = new Island(deltaDifferenceEpsilon);
+            var previousIsland = new Island(deltaDifferenceEpsilon);
+
+            // we can't use dictionary here because we need to compare island with a tolerance
+            // which is impossible to pass into the hash comparer
+            var islandCounts = new List<(Island Island, int Count)>();
+
             double startRatio = 0; // store the ratio of the current start of an island to buff for tighter rhythms
 
             bool firstDeltaSwitch = false;
 
-            int historicalNoteCount = Math.Min(current.Index, 32);
+            int historicalNoteCount = Math.Min(current.Index, history_objects_max);
 
             int rhythmStart = 0;
 
@@ -39,74 +50,172 @@ public static double EvaluateDifficultyOf(DifficultyHitObject current)
             OsuDifficultyHitObject prevObj = (OsuDifficultyHitObject)current.Previous(rhythmStart);
             OsuDifficultyHitObject lastObj = (OsuDifficultyHitObject)current.Previous(rhythmStart + 1);
 
+            // we go from the furthest object back to the current one
             for (int i = rhythmStart; i > 0; i--)
             {
                 OsuDifficultyHitObject currObj = (OsuDifficultyHitObject)current.Previous(i - 1);
 
-                double currHistoricalDecay = (history_time_max - (current.StartTime - currObj.StartTime)) / history_time_max; // scales note 0 to 1 from history to now
+                // scales note 0 to 1 from history to now
+                double timeDecay = (history_time_max - (current.StartTime - currObj.StartTime)) / history_time_max;
+                double noteDecay = (double)(historicalNoteCount - i) / historicalNoteCount;
 
-                currHistoricalDecay = Math.Min((double)(historicalNoteCount - i) / historicalNoteCount, currHistoricalDecay); // either we're limited by time or limited by object count.
+                double currHistoricalDecay = Math.Min(noteDecay, timeDecay); // either we're limited by time or limited by object count.
 
                 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));
+                // calculate how much current delta difference deserves a rhythm bonus
+                // this function is meant to reduce rhythm bonus for deltas that are multiples of each other (i.e 100 and 200)
+                double deltaDifferenceRatio = Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta);
+                double currRatio = 1.0 + rhythm_ratio_multiplier * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / deltaDifferenceRatio), 2));
+
+                // reduce ratio bonus if delta difference is too big
+                double fraction = Math.Max(prevDelta / currDelta, currDelta / prevDelta);
+                double fractionMultiplier = Math.Clamp(2.0 - fraction / 8.0, 0.0, 1.0);
 
-                windowPenalty = Math.Min(1, windowPenalty);
+                double windowPenalty = Math.Min(1, Math.Max(0, Math.Abs(prevDelta - currDelta) - deltaDifferenceEpsilon) / deltaDifferenceEpsilon);
 
-                double effectiveRatio = windowPenalty * currRatio;
+                double effectiveRatio = windowPenalty * currRatio * fractionMultiplier;
+
+                // bpm change is into slider, this is easy acc window
+                if (currObj.BaseObject is Slider)
+                    effectiveRatio *= 0.125;
+
+                // bpm change was from a slider, this is easier typically than circle -> circle
+                // unintentional side effect is that bursts with kicksliders at the ends might have lower difficulty than bursts without sliders
+                if (prevObj.BaseObject is Slider)
+                    effectiveRatio *= 0.2;
 
                 if (firstDeltaSwitch)
                 {
-                    if (!(prevDelta > 1.25 * currDelta || prevDelta * 1.25 < currDelta))
+                    if (Math.Abs(prevDelta - currDelta) < deltaDifferenceEpsilon)
                     {
-                        if (islandSize < 7)
-                            islandSize++; // island is still progressing, count size.
+                        // island is still progressing
+                        island.AddDelta((int)currDelta);
                     }
                     else
                     {
-                        if (currObj.BaseObject is Slider) // bpm change is into slider, this is easy acc window
+                        // repeated island polarity (2 -> 4, 3 -> 5)
+                        if (island.IsSimilarPolarity(previousIsland))
+                            effectiveRatio *= 0.3;
+
+                        // previous increase happened a note ago, 1/1->1/2-1/4, dont want to buff this.
+                        if (lastDelta > prevDelta + deltaDifferenceEpsilon && prevDelta > currDelta + deltaDifferenceEpsilon)
                             effectiveRatio *= 0.125;
 
-                        if (prevObj.BaseObject is Slider) // bpm change was from a slider, this is easier typically than circle -> circle
-                            effectiveRatio *= 0.25;
+                        // singletaps are easier to control
+                        if (island.DeltaCount == 1)
+                            effectiveRatio *= 0.7;
 
-                        if (previousIslandSize == islandSize) // repeated island size (ex: triplet -> triplet)
-                            effectiveRatio *= 0.25;
+                        var islandCount = islandCounts.FirstOrDefault(x => x.Island.Equals(island));
 
-                        if (previousIslandSize % 2 == islandSize % 2) // repeated island polartiy (2 -> 4, 3 -> 5)
-                            effectiveRatio *= 0.50;
+                        if (islandCount != default)
+                        {
+                            int countIndex = islandCounts.IndexOf(islandCount);
 
-                        if (lastDelta > prevDelta + 10 && prevDelta > currDelta + 10) // previous increase happened a note ago, 1/1->1/2-1/4, dont want to buff this.
-                            effectiveRatio *= 0.125;
+                            // only add island to island counts if they're going one after another
+                            if (previousIsland.Equals(island))
+                                islandCount.Count++;
+
+                            // repeated island (ex: triplet -> triplet)
+                            double power = logistic(island.Delta, 4, 0.165, 10);
+                            effectiveRatio *= Math.Min(3.0 / islandCount.Count, Math.Pow(1.0 / islandCount.Count, power));
 
-                        rhythmComplexitySum += Math.Sqrt(effectiveRatio * startRatio) * currHistoricalDecay * Math.Sqrt(4 + islandSize) / 2 * Math.Sqrt(4 + previousIslandSize) / 2;
+                            islandCounts[countIndex] = (islandCount.Island, islandCount.Count);
+                        }
+                        else
+                        {
+                            islandCounts.Add((island, 1));
+                        }
+
+                        // scale down the difficulty if the object is doubletappable
+                        double doubletapness = prevObj.GetDoubletapness((OsuDifficultyHitObject?)prevObj.Next(0));
+                        effectiveRatio *= 1 - doubletapness * 0.75;
+
+                        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
-                            firstDeltaSwitch = false; // if we're speeding up, this stays true and  we keep counting island size.
+                        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're speeding up
                 {
                     // Begin counting island until we change speed again.
                     firstDeltaSwitch = true;
+
                     startRatio = effectiveRatio;
-                    islandSize = 1;
+
+                    island = new Island((int)currDelta, deltaDifferenceEpsilon);
                 }
 
                 lastObj = prevObj;
                 prevObj = currObj;
             }
 
-            return Math.Sqrt(4 + rhythmComplexitySum * rhythm_multiplier) / 2; //produces multiplier that can be applied to strain. range [1, infinity) (not really though)
+            return Math.Sqrt(4 + rhythmComplexitySum * rhythm_overall_multiplier) / 2.0; // 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))));
+
+        private class Island : IEquatable<Island>
+        {
+            private readonly double deltaDifferenceEpsilon;
+
+            public Island(double epsilon)
+            {
+                deltaDifferenceEpsilon = epsilon;
+            }
+
+            public Island(int delta, double epsilon)
+            {
+                deltaDifferenceEpsilon = epsilon;
+                Delta = Math.Max(delta, OsuDifficultyHitObject.MIN_DELTA_TIME);
+                DeltaCount++;
+            }
+
+            public int Delta { get; private set; }
+            public int DeltaCount { get; private set; }
+
+            public void AddDelta(int delta)
+            {
+                if (Delta == default)
+                    Delta = Math.Max(delta, OsuDifficultyHitObject.MIN_DELTA_TIME);
+
+                DeltaCount++;
+            }
+
+            public bool IsSimilarPolarity(Island other)
+            {
+                // consider islands to be of similar polarity only if they're having the same average delta (we don't want to consider 3 singletaps similar to a triple)
+                return DeltaCount % 2 == other.DeltaCount % 2 &&
+                       Math.Abs(Delta - other.Delta) < deltaDifferenceEpsilon;
+            }
+
+            public override int GetHashCode()
+            {
+                return HashCode.Combine(Delta, DeltaCount);
+            }
+
+            public bool Equals(Island? other)
+            {
+                if (other == null)
+                    return false;
+
+                return Math.Abs(Delta - other.Delta) < deltaDifferenceEpsilon &&
+                       DeltaCount == other.DeltaCount;
+            }
+
+            public override string ToString()
+            {
+                return $"{Delta}x{DeltaCount}";
+            }
         }
     }
 }

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

@@ -30,21 +30,9 @@ public static double EvaluateDifficultyOf(DifficultyHitObject current)
             // derive strainTime for calculation
             var osuCurrObj = (OsuDifficultyHitObject)current;
             var osuPrevObj = current.Index > 0 ? (OsuDifficultyHitObject)current.Previous(0) : null;
-            var osuNextObj = (OsuDifficultyHitObject?)current.Next(0);
 
             double strainTime = osuCurrObj.StrainTime;
-            double doubletapness = 1;
-
-            // Nerf doubletappable doubles.
-            if (osuNextObj != null)
-            {
-                double currDeltaTime = Math.Max(1, osuCurrObj.DeltaTime);
-                double nextDeltaTime = Math.Max(1, osuNextObj.DeltaTime);
-                double deltaDifference = Math.Abs(nextDeltaTime - currDeltaTime);
-                double speedRatio = currDeltaTime / Math.Max(currDeltaTime, deltaDifference);
-                double windowRatio = Math.Pow(Math.Min(1, currDeltaTime / osuCurrObj.HitWindowGreat), 2);
-                doubletapness = Math.Pow(speedRatio, 1 - windowRatio);
-            }
+            double doubletapness = 1.0 - osuCurrObj.GetDoubletapness((OsuDifficultyHitObject?)osuCurrObj.Next(0));
 
             // Cap deltatime to the OD 300 hitwindow.
             // 0.93 is derived from making sure 260bpm OD8 streams aren't nerfed harshly, whilst 0.92 limits the effect of the cap.

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

@@ -20,7 +20,8 @@ public class OsuDifficultyHitObject : DifficultyHitObject
         /// </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 @@ public OsuDifficultyHitObject(HitObject hitObject, HitObject lastObject, HitObje
             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)
             {
@@ -136,14 +137,32 @@ public double OpacityAt(double time, bool hidden)
             return Math.Clamp((time - fadeInStartTime) / fadeInDuration, 0.0, 1.0);
         }
 
+        /// <summary>
+        /// Returns how possible is it to doubletap this object together with the next one and get perfect judgement in range from 0 to 1
+        /// </summary>
+        public double GetDoubletapness(OsuDifficultyHitObject? osuNextObj)
+        {
+            if (osuNextObj != null)
+            {
+                double currDeltaTime = Math.Max(1, DeltaTime);
+                double nextDeltaTime = Math.Max(1, osuNextObj.DeltaTime);
+                double deltaDifference = Math.Abs(nextDeltaTime - currDeltaTime);
+                double speedRatio = currDeltaTime / Math.Max(currDeltaTime, deltaDifference);
+                double windowRatio = Math.Pow(Math.Min(1, currDeltaTime / HitWindowGreat), 2);
+                return 1.0 - Math.Pow(speedRatio, 1 - windowRatio);
+            }
+
+            return 0;
+        }
+
         private void setDistances(double clockRate)
         {
             if (BaseObject is Slider currentSlider)
             {
                 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 +186,8 @@ private void setDistances(double clockRate)
 
             if (lastObject is Slider lastSlider)
             {
-                double lastTravelTime = Math.Max(lastSlider.LazyTravelTime / clockRate, min_delta_time);
-                MinimumJumpTime = Math.Max(StrainTime - lastTravelTime, min_delta_time);
+                double lastTravelTime = Math.Max(lastSlider.LazyTravelTime / clockRate, 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.

osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs

@@ -23,7 +23,7 @@ public Aim(Mod[] mods, bool withSliders)
 
         private double currentStrain;
 
-        private double skillMultiplier => 23.55;
+        private double skillMultiplier => 23.65;
         private double strainDecayBase => 0.15;
 
         private double strainDecay(double ms) => Math.Pow(strainDecayBase, ms / 1000);