Cognition difficulty calculation rework: High AR part

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

@@ -0,0 +1,142 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
+{
+    // Main class with some util functions
+    public static class ReadingEvaluator
+    {
+        // Returns value from 0 to 1, where 0 is very predictable and 1 is very unpredictable
+        public static double EvaluateInpredictabilityOf(DifficultyHitObject current)
+        {
+            // make the sum equal to 1
+            const double velocity_change_part = 0.8;
+            const double angle_change_part = 0.1;
+            const double rhythm_change_part = 0.1;
+
+            if (current.BaseObject is Spinner || current.Index == 0 || current.Previous(0).BaseObject is Spinner)
+                return 0;
+
+            var osuCurrObj = (OsuDifficultyHitObject)current;
+            var osuLastObj = (OsuDifficultyHitObject)current.Previous(0);
+
+            // Rhythm difference punishment for velocity and angle bonuses
+            double rhythmSimilarity = 1 - getRhythmDifference(osuCurrObj.StrainTime, osuLastObj.StrainTime);
+
+            // Make differentiation going from 1/4 to 1/2 and bigger difference
+            // To 1/3 to 1/2 and smaller difference
+            rhythmSimilarity = Math.Clamp(rhythmSimilarity, 0.5, 0.75);
+            rhythmSimilarity = 4 * (rhythmSimilarity - 0.5);
+
+            double velocityChangeBonus = getVelocityChangeFactor(osuCurrObj, osuLastObj) * rhythmSimilarity;
+
+            double currVelocity = osuCurrObj.LazyJumpDistance / osuCurrObj.StrainTime;
+            double prevVelocity = osuLastObj.LazyJumpDistance / osuLastObj.StrainTime;
+
+            double angleChangeBonus = 0;
+
+            if (osuCurrObj.Angle != null && osuLastObj.Angle != null && currVelocity > 0 && prevVelocity > 0)
+            {
+                angleChangeBonus = 1 - osuCurrObj.AnglePredictability;
+                angleChangeBonus *= Math.Min(currVelocity, prevVelocity) / Math.Max(currVelocity, prevVelocity); // Prevent cheesing
+            }
+
+            angleChangeBonus *= rhythmSimilarity;
+
+            // This bonus only awards rhythm changes if they're not filled with sliderends
+            double rhythmChangeBonus = 0;
+
+            if (current.Index > 1)
+            {
+                var osuLastLastObj = (OsuDifficultyHitObject)current.Previous(1);
+
+                double currDelta = osuCurrObj.StrainTime;
+                double lastDelta = osuLastObj.StrainTime;
+
+                if (osuLastObj.BaseObject is Slider sliderCurr)
+                {
+                    currDelta -= sliderCurr.Duration / osuCurrObj.ClockRate;
+                    currDelta = Math.Max(0, currDelta);
+                }
+
+                if (osuLastLastObj.BaseObject is Slider sliderLast)
+                {
+                    lastDelta -= sliderLast.Duration / osuLastObj.ClockRate;
+                    lastDelta = Math.Max(0, lastDelta);
+                }
+
+                rhythmChangeBonus = getRhythmDifference(currDelta, lastDelta);
+            }
+
+            double result = velocity_change_part * velocityChangeBonus + angle_change_part * angleChangeBonus + rhythm_change_part * rhythmChangeBonus;
+            return result;
+        }
+
+        private static double getVelocityChangeFactor(OsuDifficultyHitObject osuCurrObj, OsuDifficultyHitObject osuLastObj)
+        {
+            double currVelocity = osuCurrObj.LazyJumpDistance / osuCurrObj.StrainTime;
+            double prevVelocity = osuLastObj.LazyJumpDistance / osuLastObj.StrainTime;
+
+            double velocityChangeFactor = 0;
+
+            // https://www.desmos.com/calculator/kqxmqc8pkg
+            if (currVelocity > 0 || prevVelocity > 0)
+            {
+                double velocityChange = Math.Max(0,
+                Math.Min(
+                    Math.Abs(prevVelocity - currVelocity) - 0.5 * Math.Min(currVelocity, prevVelocity),
+                    Math.Max(((OsuHitObject)osuCurrObj.BaseObject).Radius / Math.Max(osuCurrObj.StrainTime, osuLastObj.StrainTime), Math.Min(currVelocity, prevVelocity))
+                    )); // Stealed from xexxar
+                velocityChangeFactor = velocityChange / Math.Max(currVelocity, prevVelocity); // maxiumum is 0.4
+                velocityChangeFactor /= 0.4;
+            }
+
+            return velocityChangeFactor;
+        }
+
+        private static double getRhythmDifference(double t1, double t2) => 1 - Math.Min(t1, t2) / Math.Max(t1, t2);
+    }
+    public static class ReadingHighAREvaluator
+    {
+        public static double EvaluateDifficultyOf(DifficultyHitObject current, bool applyAdjust = false)
+        {
+            var currObj = (OsuDifficultyHitObject)current;
+
+            double result = GetDifficulty(currObj.Preempt);
+
+            if (applyAdjust)
+            {
+                double inpredictability = ReadingEvaluator.EvaluateInpredictabilityOf(current);
+
+                // follow lines make high AR easier, so apply nerf if object isn't new combo
+                inpredictability *= 1 + 0.1 * (800 - currObj.FollowLineTime) / 800;
+
+                result *= 0.98 + 0.6 * inpredictability;
+            }
+
+            return result;
+        }
+
+        // High AR curve (this curve is without Math.Pow(value, 2))
+        // https://www.desmos.com/calculator/xuuwd77cbq
+        public static double GetDifficulty(double preempt)
+        {
+            // Get preempt in seconds
+            preempt /= 1000;
+            double value;
+
+            if (preempt < 0.375) // We have stop in the point of AR10.5, the value here = 0.396875, derivative = -10.5833, 
+                value = 0.63 * Math.Pow(8 - 20 * preempt, 2.0 / 3); // This function is matching live high AR bonus
+            else
+                value = Math.Exp(9.07583 - 80.0 * preempt / 3);
+
+            // The power is 2 times higher to compensate sqrt in high AR skill
+            return Math.Pow(value, 2);
+        }
+    }
+}

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

@@ -32,12 +32,24 @@ public class OsuDifficultyAttributes : DifficultyAttributes
         [JsonProperty("speed_note_count")]
         public double SpeedNoteCount { get; set; }
 
+        /// <summary>
+        /// The difficulty corresponding to the reading skill. High AR branch.
+        /// </summary>
+        [JsonProperty("reading_high_ar_difficulty")]
+        public double ReadingDifficultyHighAR { get; set; }
+
         /// <summary>
         /// The difficulty corresponding to the flashlight skill.
         /// </summary>
         [JsonProperty("flashlight_difficulty")]
         public double FlashlightDifficulty { get; set; }
 
+        /// <summary>
+        /// The difficulty corresponding to the flashlight skill with HD (used in capping cognition performance).
+        /// </summary>
+        [JsonProperty("hidden_flashlight_difficulty")]
+        public double HiddenFlashlightDifficulty { get; set; }
+
         /// <summary>
         /// Describes how much of <see cref="AimDifficulty"/> is contributed to by hitcircles or sliders.
         /// A value closer to 1.0 indicates most of <see cref="AimDifficulty"/> is contributed by hitcircles.

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

@@ -22,8 +22,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 {
     public class OsuDifficultyCalculator : DifficultyCalculator
     {
-        private const double difficulty_multiplier = 0.0675;
-
+        public const double DIFFICULTY_MULTIPLIER = 0.0675;
+        public const double SUM_POWER = 1.1;
+        public const double FL_SUM_POWER = 1.5;
         public override int Version => 20220902;
 
         public OsuDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
@@ -36,57 +37,72 @@ protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beat
             if (beatmap.HitObjects.Count == 0)
                 return new OsuDifficultyAttributes { Mods = mods };
 
-            double aimRating = Math.Sqrt(skills[0].DifficultyValue()) * difficulty_multiplier;
-            double aimRatingNoSliders = Math.Sqrt(skills[1].DifficultyValue()) * difficulty_multiplier;
-            double speedRating = Math.Sqrt(skills[2].DifficultyValue()) * difficulty_multiplier;
+            double aimRating = Math.Sqrt(skills[0].DifficultyValue()) * DIFFICULTY_MULTIPLIER;
+            double aimRatingNoSliders = Math.Sqrt(skills[1].DifficultyValue()) * DIFFICULTY_MULTIPLIER;
+            double speedRating = Math.Sqrt(skills[2].DifficultyValue()) * DIFFICULTY_MULTIPLIER;
             double speedNotes = ((Speed)skills[2]).RelevantNoteCount();
 
-            double flashlightRating = 0.0;
+            double hiddenFlashlightRating = Math.Sqrt(skills[3].DifficultyValue()) * DIFFICULTY_MULTIPLIER;
 
-            if (mods.Any(h => h is OsuModFlashlight))
-                flashlightRating = Math.Sqrt(skills[3].DifficultyValue()) * difficulty_multiplier;
+            double readingHighARRating = Math.Sqrt(skills[4].DifficultyValue()) * DIFFICULTY_MULTIPLIER;
+
+            double flashlightRating = 0;
 
             double sliderFactor = aimRating > 0 ? aimRatingNoSliders / aimRating : 1;
 
+            double baseFlashlightPerformance = 0.0;
+            if (mods.Any(h => h is OsuModFlashlight))
+            {
+                flashlightRating = Math.Sqrt(skills[5].DifficultyValue()) * DIFFICULTY_MULTIPLIER;
+                baseFlashlightPerformance = Flashlight.DifficultyToPerformance(flashlightRating);
+            }
+
             if (mods.Any(m => m is OsuModTouchDevice))
             {
                 aimRating = Math.Pow(aimRating, 0.8);
+                readingHighARRating = Math.Pow(readingHighARRating, 0.9);
                 flashlightRating = Math.Pow(flashlightRating, 0.8);
             }
 
             if (mods.Any(h => h is OsuModRelax))
             {
                 aimRating *= 0.9;
                 speedRating = 0.0;
+                readingHighARRating *= 0.7;
                 flashlightRating *= 0.7;
             }
 
-            double baseAimPerformance = Math.Pow(5 * Math.Max(1, aimRating / 0.0675) - 4, 3) / 100000;
-            double baseSpeedPerformance = Math.Pow(5 * Math.Max(1, speedRating / 0.0675) - 4, 3) / 100000;
-            double baseFlashlightPerformance = 0.0;
-
-            if (mods.Any(h => h is OsuModFlashlight))
-                baseFlashlightPerformance = Math.Pow(flashlightRating, 2.0) * 25.0;
+            double baseAimPerformance = OsuStrainSkill.DifficultyToPerformance(aimRating);
+            double baseSpeedPerformance = OsuStrainSkill.DifficultyToPerformance(speedRating);
 
-            double basePerformance =
-                Math.Pow(
-                    Math.Pow(baseAimPerformance, 1.1) +
-                    Math.Pow(baseSpeedPerformance, 1.1) +
-                    Math.Pow(baseFlashlightPerformance, 1.1), 1.0 / 1.1
-                );
+            // Cognition
+            double baseReadingHighARPerformance = OsuStrainSkill.DifficultyToPerformance(readingHighARRating);
+            double baseReadingARPerformance = baseReadingHighARPerformance;
 
-            double starRating = basePerformance > 0.00001
-                ? Math.Cbrt(OsuPerformanceCalculator.PERFORMANCE_BASE_MULTIPLIER) * 0.027 * (Math.Cbrt(100000 / Math.Pow(2, 1 / 1.1) * basePerformance) + 4)
-                : 0;
+            double baseFlashlightARPerformance = Math.Pow(Math.Pow(baseFlashlightPerformance, FL_SUM_POWER) + Math.Pow(baseReadingARPerformance, FL_SUM_POWER), 1.0 / FL_SUM_POWER);
 
             double preempt = IBeatmapDifficultyInfo.DifficultyRange(beatmap.Difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
+
             double drainRate = beatmap.Difficulty.DrainRate;
             int maxCombo = beatmap.GetMaxCombo();
 
             int hitCirclesCount = beatmap.HitObjects.Count(h => h is HitCircle);
             int sliderCount = beatmap.HitObjects.Count(h => h is Slider);
             int spinnerCount = beatmap.HitObjects.Count(h => h is Spinner);
 
+            double cognitionPerformance = baseFlashlightARPerformance;
+            double mechanicalPerformance = Math.Pow(Math.Pow(baseAimPerformance, SUM_POWER) + Math.Pow(baseSpeedPerformance, SUM_POWER), 1.0 / SUM_POWER);
+
+            // Limit cognition by full memorisation difficulty, what is assumed to be mechanicalPerformance + hiddenFlashlightPerformance
+            double hiddenFlashlightPerformance = OsuPerformanceCalculator.ComputePerfectFlashlightValue(hiddenFlashlightRating, hitCirclesCount + sliderCount);
+            cognitionPerformance = OsuPerformanceCalculator.AdjustCognitionPerformance(cognitionPerformance, mechanicalPerformance, hiddenFlashlightPerformance);
+
+            double basePerformance = mechanicalPerformance + cognitionPerformance;
+
+            double starRating = basePerformance > 0.00001
+                ? Math.Cbrt(OsuPerformanceCalculator.PERFORMANCE_BASE_MULTIPLIER) * 0.027 * (Math.Cbrt(100000 / Math.Pow(2, 1 / 1.1) * basePerformance) + 4)
+                : 0;
+
             HitWindows hitWindows = new OsuHitWindows();
             hitWindows.SetDifficulty(beatmap.Difficulty.OverallDifficulty);
 
@@ -99,9 +115,11 @@ protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beat
                 AimDifficulty = aimRating,
                 SpeedDifficulty = speedRating,
                 SpeedNoteCount = speedNotes,
+                ReadingDifficultyHighAR = readingHighARRating,
                 FlashlightDifficulty = flashlightRating,
+                HiddenFlashlightDifficulty = hiddenFlashlightRating,
                 SliderFactor = sliderFactor,
-                ApproachRate = preempt > 1200 ? (1800 - preempt) / 120 : (1200 - preempt) / 150 + 5,
+                ApproachRate = IBeatmapDifficultyInfo.InverseDifficultyRange(preempt, 1800, 1200, 450),
                 OverallDifficulty = (80 - hitWindowGreat) / 6,
                 DrainRate = drainRate,
                 MaxCombo = maxCombo,
@@ -134,7 +152,9 @@ protected override Skill[] CreateSkills(IBeatmap beatmap, Mod[] mods, double clo
             {
                 new Aim(mods, true),
                 new Aim(mods, false),
-                new Speed(mods)
+                new Speed(mods),
+                new HiddenFlashlight(mods),
+                new ReadingHighAR(mods),
             };
 
             if (mods.Any(h => h is OsuModFlashlight))

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

@@ -18,8 +18,8 @@ public class OsuPerformanceAttributes : PerformanceAttributes
         [JsonProperty("accuracy")]
         public double Accuracy { get; set; }
 
-        [JsonProperty("flashlight")]
-        public double Flashlight { get; set; }
+        [JsonProperty("cognition")]
+        public double Cognition { get; set; }
 
         [JsonProperty("effective_miss_count")]
         public double EffectiveMissCount { get; set; }
@@ -32,7 +32,7 @@ public override IEnumerable<PerformanceDisplayAttribute> GetAttributesForDisplay
             yield return new PerformanceDisplayAttribute(nameof(Aim), "Aim", Aim);
             yield return new PerformanceDisplayAttribute(nameof(Speed), "Speed", Speed);
             yield return new PerformanceDisplayAttribute(nameof(Accuracy), "Accuracy", Accuracy);
-            yield return new PerformanceDisplayAttribute(nameof(Flashlight), "Flashlight Bonus", Flashlight);
+            yield return new PerformanceDisplayAttribute(nameof(Cognition), "Cognition", Cognition);
         }
     }
 }