Statistical accuracy PP and difficulty scaling for the osu!taiko ruleset

osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyAttributes.cs

@@ -43,13 +43,23 @@ public class TaikoDifficultyAttributes : DifficultyAttributes
         [JsonProperty("great_hit_window")]
         public double GreatHitWindow { get; set; }
 
+        /// <summary>
+        /// The perceived hit window for an OK hit inclusive of rate-adjusting mods (DT/HT/etc).
+        /// </summary>
+        /// <remarks>
+        /// Rate-adjusting mods don't directly affect the hit window, but have a perceived effect as a result of adjusting audio timing.
+        /// </remarks>
+        [JsonProperty("ok_hit_window")]
+        public double OkHitWindow { get; set; }
+
         public override IEnumerable<(int attributeId, object value)> ToDatabaseAttributes()
         {
             foreach (var v in base.ToDatabaseAttributes())
                 yield return v;
 
             yield return (ATTRIB_ID_DIFFICULTY, StarRating);
             yield return (ATTRIB_ID_GREAT_HIT_WINDOW, GreatHitWindow);
+            yield return (ATTRIB_ID_OK_HIT_WINDOW, OkHitWindow);
         }
 
         public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values, IBeatmapOnlineInfo onlineInfo)
@@ -58,6 +68,7 @@ public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> val
 
             StarRating = values[ATTRIB_ID_DIFFICULTY];
             GreatHitWindow = values[ATTRIB_ID_GREAT_HIT_WINDOW];
+            OkHitWindow = values[ATTRIB_ID_OK_HIT_WINDOW];
         }
     }
 }

osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs

@@ -96,6 +96,7 @@ protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beat
                 ColourDifficulty = colourRating,
                 PeakDifficulty = combinedRating,
                 GreatHitWindow = hitWindows.WindowFor(HitResult.Great) / clockRate,
+                OkHitWindow = hitWindows.WindowFor(HitResult.Ok) / clockRate,
                 MaxCombo = beatmap.HitObjects.Count(h => h is Hit),
             };
 

osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs

@@ -18,6 +18,9 @@ public class TaikoPerformanceAttributes : PerformanceAttributes
         [JsonProperty("effective_miss_count")]
         public double EffectiveMissCount { get; set; }
 
+        [JsonProperty("estimated_ur")]
+        public double? EstimatedUr { get; set; }
+
         public override IEnumerable<PerformanceDisplayAttribute> GetAttributesForDisplay()
         {
             foreach (var attribute in base.GetAttributesForDisplay())

osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs

@@ -9,6 +9,7 @@
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Scoring;
+using MathNet.Numerics;
 
 namespace osu.Game.Rulesets.Taiko.Difficulty
 {
@@ -18,7 +19,7 @@ public class TaikoPerformanceCalculator : PerformanceCalculator
         private int countOk;
         private int countMeh;
         private int countMiss;
-        private double accuracy;
+        private double? estimatedUr;
 
         private double effectiveMissCount;
 
@@ -35,7 +36,7 @@ protected override PerformanceAttributes CreatePerformanceAttributes(ScoreInfo s
             countOk = score.Statistics.GetValueOrDefault(HitResult.Ok);
             countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
             countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
-            accuracy = customAccuracy;
+            estimatedUr = computeEstimatedUr(score, taikoAttributes);
 
             // The effectiveMissCount is calculated by gaining a ratio for totalSuccessfulHits and increasing the miss penalty for shorter object counts lower than 1000.
             if (totalSuccessfulHits > 0)
@@ -65,6 +66,7 @@ protected override PerformanceAttributes CreatePerformanceAttributes(ScoreInfo s
                 Difficulty = difficultyValue,
                 Accuracy = accuracyValue,
                 EffectiveMissCount = effectiveMissCount,
+                EstimatedUr = estimatedUr,
                 Total = totalValue
             };
         }
@@ -85,35 +87,92 @@ private double computeDifficultyValue(ScoreInfo score, TaikoDifficultyAttributes
                 difficultyValue *= 1.025;
 
             if (score.Mods.Any(m => m is ModHardRock))
-                difficultyValue *= 1.050;
+                difficultyValue *= 1.10;
 
             if (score.Mods.Any(m => m is ModFlashlight<TaikoHitObject>))
                 difficultyValue *= 1.050 * lengthBonus;
 
-            return difficultyValue * Math.Pow(accuracy, 2.0);
+            if (estimatedUr == null)
+                return 0;
+
+            return difficultyValue * Math.Pow(SpecialFunctions.Erf(400 / (Math.Sqrt(2) * estimatedUr.Value)), 2.0);
         }
 
         private double computeAccuracyValue(ScoreInfo score, TaikoDifficultyAttributes attributes, bool isConvert)
         {
-            if (attributes.GreatHitWindow <= 0)
+            if (attributes.GreatHitWindow <= 0 || estimatedUr == null)
                 return 0;
 
-            double accuracyValue = Math.Pow(60.0 / attributes.GreatHitWindow, 1.1) * Math.Pow(accuracy, 8.0) * Math.Pow(attributes.StarRating, 0.4) * 27.0;
+            double accuracyValue = Math.Pow(65 / estimatedUr.Value, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 100.0;
 
             double lengthBonus = Math.Min(1.15, Math.Pow(totalHits / 1500.0, 0.3));
-            accuracyValue *= lengthBonus;
 
             // Slight HDFL Bonus for accuracy. A clamp is used to prevent against negative values.
             if (score.Mods.Any(m => m is ModFlashlight<TaikoHitObject>) && score.Mods.Any(m => m is ModHidden) && !isConvert)
-                accuracyValue *= Math.Max(1.0, 1.1 * lengthBonus);
+                accuracyValue *= Math.Max(1.0, 1.05 * lengthBonus);
 
             return accuracyValue;
         }
 
+        /// <summary>
+        /// Calculates the tap deviation for a player using the OD, object count, and scores of 300s, 100s, and misses, with an assumed mean hit error of 0.
+        /// Consistency is ensured as identical SS scores on the same map and settings yield the same deviation.
+        /// </summary>
+        private double? computeEstimatedUr(ScoreInfo score, TaikoDifficultyAttributes attributes)
+        {
+            if (totalSuccessfulHits == 0 || attributes.GreatHitWindow <= 0)
+                return null;
+
+            double h300 = attributes.GreatHitWindow;
+            double h100 = attributes.OkHitWindow;
+
+            // Determines the probability of a deviation leading to the score's hit evaluations. The curve's apex represents the most probable deviation.
+            double likelihoodGradient(double d)
+            {
+                if (d <= 0)
+                    return 0;
+
+                double p300 = logDiff(0, logPcHit(h300, d));
+                double p100 = logDiff(logPcHit(h300, d), logPcHit(h100, d));
+                double p0 = logPcHit(h100, d);
+
+                double gradient = Math.Exp(
+                    (countGreat * p300
+                     + (countOk + 0.5) * p100
+                     + countMiss * p0) / totalHits
+                );
+
+                return -gradient;
+            }
+
+            double deviation = FindMinimum.OfScalarFunction(likelihoodGradient, 30);
+
+            return deviation * 10;
+        }
+
         private int totalHits => countGreat + countOk + countMeh + countMiss;
 
         private int totalSuccessfulHits => countGreat + countOk + countMeh;
 
-        private double customAccuracy => totalHits > 0 ? (countGreat * 300 + countOk * 150) / (totalHits * 300.0) : 0;
+        private double logPcHit(double x, double deviation) => logErfcApprox(x / (deviation * Math.Sqrt(2)));
+
+        // Utilises a numerical approximation to extend the computation range of ln(erfc(x)).
+        private double logErfcApprox(double x) => x <= 5
+            ? Math.Log(SpecialFunctions.Erfc(x))
+            : -Math.Pow(x, 2) - Math.Log(x * Math.Sqrt(Math.PI)); // https://www.desmos.com/calculator/kdbxwxgf01
+
+        // Subtracts the base value of two logs, circumventing log rules that typically complicate subtraction of non-logarithmic values.
+        private double logDiff(double firstLog, double secondLog)
+        {
+            double maxVal = Math.Max(firstLog, secondLog);
+
+            // To avoid a NaN result, a check is performed to prevent subtraction of two negative infinity values.
+            if (double.IsNegativeInfinity(maxVal))
+            {
+                return maxVal;
+            }
+
+            return firstLog + SpecialFunctions.Log1p(-Math.Exp(-(firstLog - secondLog)));
+        }
     }
 }

osu.Game.Rulesets.Taiko/osu.Game.Rulesets.Taiko.csproj

@@ -15,4 +15,8 @@
   <ItemGroup Label="Project References">
     <ProjectReference Include="..\osu.Game\osu.Game.csproj" />
   </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="MathNet.Numerics" Version="5.0.0" />
+  </ItemGroup>
 </Project>

osu.Game/Rulesets/Difficulty/DifficultyAttributes.cs

@@ -30,6 +30,7 @@ public class DifficultyAttributes
         protected const int ATTRIB_ID_LEGACY_ACCURACY_SCORE = 23;
         protected const int ATTRIB_ID_LEGACY_COMBO_SCORE = 25;
         protected const int ATTRIB_ID_LEGACY_BONUS_SCORE_RATIO = 27;
+        protected const int ATTRIB_ID_OK_HIT_WINDOW = 29;
 
         /// <summary>
         /// The mods which were applied to the beatmap.