Merge branch 'pp-dev' into fix-odho-minjumpdist

osu.Game.Rulesets.Osu.Tests/OsuDifficultyCalculatorTest.cs

@@ -15,22 +15,22 @@ public class OsuDifficultyCalculatorTest : DifficultyCalculatorTest
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Osu.Tests";
 
-        [TestCase(6.718709884850683d, 239, "diffcalc-test")]
-        [TestCase(1.4485749025771304d, 54, "zero-length-sliders")]
-        [TestCase(0.42630400627180914d, 4, "very-fast-slider")]
+        [TestCase(6.6860329680488437d, 239, "diffcalc-test")]
+        [TestCase(1.4485740324170036d, 54, "zero-length-sliders")]
+        [TestCase(0.43052813047866129d, 4, "very-fast-slider")]
         [TestCase(0.14143808967817237d, 2, "nan-slider")]
         public void Test(double expectedStarRating, int expectedMaxCombo, string name)
             => base.Test(expectedStarRating, expectedMaxCombo, name);
 
-        [TestCase(9.6343245007055653d, 239, "diffcalc-test")]
-        [TestCase(1.7550169162648608d, 54, "zero-length-sliders")]
-        [TestCase(0.55231632896800109d, 4, "very-fast-slider")]
+        [TestCase(9.6300773538770041d, 239, "diffcalc-test")]
+        [TestCase(1.7550155729445993d, 54, "zero-length-sliders")]
+        [TestCase(0.55785578988249407d, 4, "very-fast-slider")]
         public void TestClockRateAdjusted(double expectedStarRating, int expectedMaxCombo, string name)
             => Test(expectedStarRating, expectedMaxCombo, name, new OsuModDoubleTime());
 
-        [TestCase(6.718709884850683d, 239, "diffcalc-test")]
-        [TestCase(1.4485749025771304d, 54, "zero-length-sliders")]
-        [TestCase(0.42630400627180914d, 4, "very-fast-slider")]
+        [TestCase(6.6860329680488437d, 239, "diffcalc-test")]
+        [TestCase(1.4485740324170036d, 54, "zero-length-sliders")]
+        [TestCase(0.43052813047866129d, 4, "very-fast-slider")]
         public void TestClassicMod(double expectedStarRating, int expectedMaxCombo, string name)
             => Test(expectedStarRating, expectedMaxCombo, name, new OsuModClassic());
 

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

@@ -12,7 +12,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
     public static class AimEvaluator
     {
         private const double wide_angle_multiplier = 1.5;
-        private const double acute_angle_multiplier = 2.7;
+        private const double acute_angle_multiplier = 2.6;
         private const double slider_multiplier = 1.35;
         private const double velocity_change_multiplier = 0.75;
         private const double wiggle_multiplier = 1.02;
@@ -80,17 +80,19 @@ public static double EvaluateDifficultyOf(DifficultyHitObject current, bool with
                     double angleBonus = Math.Min(currVelocity, prevVelocity);
 
                     wideAngleBonus = calcWideAngleBonus(currAngle);
+                    acuteAngleBonus = calcAcuteAngleBonus(currAngle);
 
-                    // Apply acute angle bonus for BPM above 300 1/2 and distance more than one diameter
-                    acuteAngleBonus = calcAcuteAngleBonus(currAngle) *
-                                      angleBonus *
-                                      DifficultyCalculationUtils.Smootherstep(DifficultyCalculationUtils.MillisecondsToBPM(osuCurrObj.StrainTime, 2), 300, 400) *
-                                      DifficultyCalculationUtils.Smootherstep(osuCurrObj.LazyJumpDistance, diameter, diameter * 2);
+                    // Penalize angle repetition.
+                    wideAngleBonus *= 1 - Math.Min(wideAngleBonus, Math.Pow(calcWideAngleBonus(lastAngle), 3));
+                    acuteAngleBonus *= 0.1 + 0.9 * (1 - Math.Min(acuteAngleBonus, Math.Pow(calcAcuteAngleBonus(lastAngle), 3)));
+
+                    // Apply full wide angle bonus for distance more than one diameter
+                    wideAngleBonus *= angleBonus * DifficultyCalculationUtils.Smootherstep(osuCurrObj.LazyJumpDistance, 0, diameter);
 
-                    // Penalize wide angles if they're repeated, reducing the penalty as the lastAngle gets more acute.
-                    wideAngleBonus *= angleBonus * (1 - Math.Min(wideAngleBonus, Math.Pow(calcWideAngleBonus(lastAngle), 3)));
-                    // Penalize acute angles if they're repeated, reducing the penalty as the lastAngle gets more obtuse.
-                    acuteAngleBonus *= 0.03 + 0.97 * (1 - Math.Min(acuteAngleBonus, Math.Pow(calcAcuteAngleBonus(lastAngle), 3)));
+                    // Apply acute angle bonus for BPM above 300 1/2 and distance more than one diameter
+                    acuteAngleBonus *= angleBonus *
+                                       DifficultyCalculationUtils.Smootherstep(DifficultyCalculationUtils.MillisecondsToBPM(osuCurrObj.StrainTime, 2), 300, 400) *
+                                       DifficultyCalculationUtils.Smootherstep(osuCurrObj.LazyJumpDistance, diameter, diameter * 2);
 
                     // Apply wiggle bonus for jumps that are [radius, 3*diameter] in distance, with < 110 angle
                     // https://www.desmos.com/calculator/dp0v0nvowc
@@ -140,8 +142,8 @@ public static double EvaluateDifficultyOf(DifficultyHitObject current, bool with
             return aimStrain;
         }
 
-        private static double calcWideAngleBonus(double angle) => Math.Pow(Math.Sin(3.0 / 4 * (Math.Min(5.0 / 6 * Math.PI, Math.Max(Math.PI / 6, angle)) - Math.PI / 6)), 2);
+        private static double calcWideAngleBonus(double angle) => DifficultyCalculationUtils.Smoothstep(angle, double.DegreesToRadians(40), double.DegreesToRadians(140));
 
-        private static double calcAcuteAngleBonus(double angle) => 1 - calcWideAngleBonus(angle);
+        private static double calcAcuteAngleBonus(double angle) => DifficultyCalculationUtils.Smoothstep(angle, double.DegreesToRadians(140), double.DegreesToRadians(40));
     }
 }

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

@@ -2,9 +2,13 @@
 // 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.Difficulty.Utils;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
@@ -14,7 +18,7 @@ public static class SpeedEvaluator
         private const double single_spacing_threshold = OsuDifficultyHitObject.NORMALISED_DIAMETER * 1.25; // 1.25 circles distance between centers
         private const double min_speed_bonus = 200; // 200 BPM 1/4th
         private const double speed_balancing_factor = 40;
-        private const double distance_multiplier = 0.94;
+        private const double distance_multiplier = 0.9;
 
         /// <summary>
         /// Evaluates the difficulty of tapping the current object, based on:
@@ -24,7 +28,7 @@ public static class SpeedEvaluator
         /// <item><description>and how easily they can be cheesed.</description></item>
         /// </list>
         /// </summary>
-        public static double EvaluateDifficultyOf(DifficultyHitObject current)
+        public static double EvaluateDifficultyOf(DifficultyHitObject current, IReadOnlyList<Mod> mods)
         {
             if (current.BaseObject is Spinner)
                 return 0;
@@ -56,6 +60,9 @@ public static double EvaluateDifficultyOf(DifficultyHitObject current)
             // Max distance bonus is 1 * `distance_multiplier` at single_spacing_threshold
             double distanceBonus = Math.Pow(distance / single_spacing_threshold, 3.95) * distance_multiplier;
 
+            if (mods.OfType<OsuModAutopilot>().Any())
+                distanceBonus = 0;
+
             // Base difficulty with all bonuses
             double difficulty = (1 + speedBonus + distanceBonus) * 1000 / strainTime;
 

osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs

@@ -63,6 +63,12 @@ protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beat
                 speedRating = 0.0;
                 flashlightRating *= 0.7;
             }
+            else if (mods.Any(h => h is OsuModAutopilot))
+            {
+                speedRating *= 0.5;
+                aimRating = 0.0;
+                flashlightRating *= 0.4;
+            }
 
             double baseAimPerformance = OsuStrainSkill.DifficultyToPerformance(aimRating);
             double baseSpeedPerformance = OsuStrainSkill.DifficultyToPerformance(speedRating);

osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs

@@ -135,6 +135,9 @@ protected override PerformanceAttributes CreatePerformanceAttributes(ScoreInfo s
 
         private double computeAimValue(ScoreInfo score, OsuDifficultyAttributes attributes)
         {
+            if (score.Mods.Any(h => h is OsuModAutopilot))
+                return 0.0;
+
             double aimDifficulty = attributes.AimDifficulty;
 
             if (attributes.SliderCount > 0 && attributes.AimDifficultSliderCount > 0)
@@ -188,7 +191,7 @@ private double computeAimValue(ScoreInfo score, OsuDifficultyAttributes attribut
 
             aimValue *= accuracy;
             // It is important to consider accuracy difficulty when scaling with accuracy.
-            aimValue *= 0.98 + Math.Pow(attributes.OverallDifficulty, 2) / 2500;
+            aimValue *= 0.98 + Math.Pow(Math.Max(0, attributes.OverallDifficulty), 2) / 2500;
 
             return aimValue;
         }
@@ -211,6 +214,9 @@ private double computeSpeedValue(ScoreInfo score, OsuDifficultyAttributes attrib
             if (attributes.ApproachRate > 10.33)
                 approachRateFactor = 0.3 * (attributes.ApproachRate - 10.33);
 
+            if (score.Mods.Any(h => h is OsuModAutopilot))
+                approachRateFactor = 0.0;
+
             speedValue *= 1.0 + approachRateFactor * lengthBonus; // Buff for longer maps with high AR.
 
             if (score.Mods.Any(m => m is OsuModBlinds))
@@ -232,7 +238,7 @@ private double computeSpeedValue(ScoreInfo score, OsuDifficultyAttributes attrib
             double relevantAccuracy = attributes.SpeedNoteCount == 0 ? 0 : (relevantCountGreat * 6.0 + relevantCountOk * 2.0 + relevantCountMeh) / (attributes.SpeedNoteCount * 6.0);
 
             // Scale the speed value with accuracy and OD.
-            speedValue *= (0.95 + Math.Pow(attributes.OverallDifficulty, 2) / 750) * Math.Pow((accuracy + relevantAccuracy) / 2.0, (14.5 - attributes.OverallDifficulty) / 2);
+            speedValue *= (0.95 + Math.Pow(Math.Max(0, attributes.OverallDifficulty), 2) / 750) * Math.Pow((accuracy + relevantAccuracy) / 2.0, (14.5 - attributes.OverallDifficulty) / 2);
 
             // Scale the speed value with # of 50s to punish doubletapping.
             speedValue *= Math.Pow(0.99, countMeh < totalHits / 500.0 ? 0 : countMeh - totalHits / 500.0);
@@ -299,7 +305,7 @@ private double computeFlashlightValue(ScoreInfo score, OsuDifficultyAttributes a
             // Scale the flashlight value with accuracy _slightly_.
             flashlightValue *= 0.5 + accuracy / 2.0;
             // It is important to also consider accuracy difficulty when doing that.
-            flashlightValue *= 0.98 + Math.Pow(attributes.OverallDifficulty, 2) / 2500;
+            flashlightValue *= 0.98 + Math.Pow(Math.Max(0, attributes.OverallDifficulty), 2) / 2500;
 
             return flashlightValue;
         }

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

@@ -15,7 +15,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
     /// </summary>
     public class Speed : OsuStrainSkill
     {
-        private double skillMultiplier => 1.430;
+        private double skillMultiplier => 1.46;
         private double strainDecayBase => 0.3;
 
         private double currentStrain;
@@ -35,7 +35,7 @@ public Speed(Mod[] mods)
         protected override double StrainValueAt(DifficultyHitObject current)
         {
             currentStrain *= strainDecay(((OsuDifficultyHitObject)current).StrainTime);
-            currentStrain += SpeedEvaluator.EvaluateDifficultyOf(current) * skillMultiplier;
+            currentStrain += SpeedEvaluator.EvaluateDifficultyOf(current, Mods) * skillMultiplier;
 
             currentRhythm = RhythmEvaluator.EvaluateDifficultyOf(current);
 

osu.Game.Rulesets.Taiko.Tests/TaikoDifficultyCalculatorTest.cs

@@ -14,13 +14,13 @@ public class TaikoDifficultyCalculatorTest : DifficultyCalculatorTest
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Taiko";
 
-        [TestCase(3.0920212594351191d, 200, "diffcalc-test")]
-        [TestCase(3.0920212594351191d, 200, "diffcalc-test-strong")]
+        [TestCase(2.837609165845338d, 200, "diffcalc-test")]
+        [TestCase(2.837609165845338d, 200, "diffcalc-test-strong")]
         public void Test(double expectedStarRating, int expectedMaxCombo, string name)
             => base.Test(expectedStarRating, expectedMaxCombo, name);
 
-        [TestCase(4.0789820318081444d, 200, "diffcalc-test")]
-        [TestCase(4.0789820318081444d, 200, "diffcalc-test-strong")]
+        [TestCase(3.8005218640444949, 200, "diffcalc-test")]
+        [TestCase(3.8005218640444949, 200, "diffcalc-test-strong")]
         public void TestClockRateAdjusted(double expectedStarRating, int expectedMaxCombo, string name)
             => Test(expectedStarRating, expectedMaxCombo, name, new TaikoModDoubleTime());
 

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

@@ -36,18 +36,70 @@ public static double EvaluateDifficultyOf(RepeatingHitPatterns repeatingHitPatte
             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.
+        /// </summary>
+        /// <param name="hitObject">The current hitObject to consider.</param>
+        /// <param name="threshold"> The allowable margin of error for determining whether ratios are consistent.</param>
+        /// <param name="maxObjectsToCheck">The maximum objects to check per count of consistent ratio.</param>
+        private static double consistentRatioPenalty(TaikoDifficultyHitObject hitObject, double threshold = 0.01, int maxObjectsToCheck = 64)
+        {
+            int consistentRatioCount = 0;
+            double totalRatioCount = 0.0;
+
+            TaikoDifficultyHitObject current = hitObject;
+
+            for (int i = 0; i < maxObjectsToCheck; i++)
+            {
+                // Break if there is no valid previous object
+                if (current.Index <= 1)
+                    break;
+
+                var previousHitObject = (TaikoDifficultyHitObject)current.Previous(1);
+
+                double currentRatio = current.Rhythm.Ratio;
+                double previousRatio = previousHitObject.Rhythm.Ratio;
+
+                // A consistent interval is defined as the percentage difference between the two rhythmic ratios with the margin of error.
+                if (Math.Abs(1 - currentRatio / previousRatio) <= threshold)
+                {
+                    consistentRatioCount++;
+                    totalRatioCount += currentRatio;
+                    break;
+                }
+
+                // Move to the previous object
+                current = previousHitObject;
+            }
+
+            // Ensure no division by zero
+            double ratioPenalty = 1 - totalRatioCount / (consistentRatioCount + 1) * 0.80;
+
+            return ratioPenalty;
+        }
+
+        /// <summary>
+        /// Evaluate the difficulty of the first hitobject within a colour streak.
+        /// </summary>
         public static double EvaluateDifficultyOf(DifficultyHitObject hitObject)
         {
-            TaikoDifficultyHitObjectColour colour = ((TaikoDifficultyHitObject)hitObject).Colour;
+            var taikoObject = (TaikoDifficultyHitObject)hitObject;
+            TaikoDifficultyHitObjectColour colour = taikoObject.Colour;
             double difficulty = 0.0d;
 
             if (colour.MonoStreak?.FirstHitObject == hitObject) // Difficulty for MonoStreak
                 difficulty += EvaluateDifficultyOf(colour.MonoStreak);
+
             if (colour.AlternatingMonoPattern?.FirstHitObject == hitObject) // Difficulty for AlternatingMonoPattern
                 difficulty += EvaluateDifficultyOf(colour.AlternatingMonoPattern);
+
             if (colour.RepeatingHitPattern?.FirstHitObject == hitObject) // Difficulty for RepeatingHitPattern
                 difficulty += EvaluateDifficultyOf(colour.RepeatingHitPattern);
 
+            double consistencyPenalty = consistentRatioPenalty(taikoObject);
+            difficulty *= consistencyPenalty;
+
             return difficulty;
         }
     }