Remove combo scaling from Aim and Speed from osu! performance calculation

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

@@ -24,6 +24,12 @@ public class OsuDifficultyAttributes : DifficultyAttributes
         [JsonProperty("slider_factor")]
         public double SliderFactor { get; set; }
 
+        [JsonProperty("aim_difficult_strain_count")]
+        public double AimDifficultStrainCount { get; set; }
+
+        [JsonProperty("speed_difficult_strain_count")]
+        public double SpeedDifficultStrainCount { get; set; }
+
         [JsonProperty("approach_rate")]
         public double ApproachRate { get; set; }
 
@@ -54,6 +60,8 @@ public class OsuDifficultyAttributes : DifficultyAttributes
                 yield return (ATTRIB_ID_FLASHLIGHT, FlashlightDifficulty);
 
             yield return (ATTRIB_ID_SLIDER_FACTOR, SliderFactor);
+            yield return (ATTRIB_ID_AIM_DIFFICULT_STRAIN_COUNT, AimDifficultStrainCount);
+            yield return (ATTRIB_ID_SPEED_DIFFICULT_STRAIN_COUNT, SpeedDifficultStrainCount);
         }
 
         public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values)
@@ -68,6 +76,8 @@ public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> val
             StarRating = values[ATTRIB_ID_DIFFICULTY];
             FlashlightDifficulty = values.GetValueOrDefault(ATTRIB_ID_FLASHLIGHT);
             SliderFactor = values[ATTRIB_ID_SLIDER_FACTOR];
+            AimDifficultStrainCount = values[ATTRIB_ID_AIM_DIFFICULT_STRAIN_COUNT];
+            SpeedDifficultStrainCount = values[ATTRIB_ID_SPEED_DIFFICULT_STRAIN_COUNT];
         }
 
         #region Newtonsoft.Json implicit ShouldSerialize() methods

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

@@ -40,6 +40,9 @@ protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beat
 
             double sliderFactor = aimRating > 0 ? aimRatingNoSliders / aimRating : 1;
 
+            double aimDifficultyStrainCount = ((OsuStrainSkill)skills[0]).CountDifficultStrains(clockRate);
+            double speedDifficultyStrainCount = ((OsuStrainSkill)skills[2]).CountDifficultStrains(clockRate);
+
             if (mods.Any(h => h is OsuModRelax))
                 speedRating = 0.0;
 
@@ -78,6 +81,8 @@ protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beat
                 SpeedDifficulty = speedRating,
                 FlashlightDifficulty = flashlightRating,
                 SliderFactor = sliderFactor,
+                AimDifficultStrainCount = aimDifficultyStrainCount,
+                SpeedDifficultStrainCount = speedDifficultyStrainCount,
                 ApproachRate = preempt > 1200 ? (1800 - preempt) / 120 : (1200 - preempt) / 150 + 5,
                 OverallDifficulty = (80 - hitWindowGreat) / 6,
                 DrainRate = drainRate,

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

@@ -95,11 +95,8 @@ private double computeAimValue()
                                  (totalHits > 2000 ? Math.Log10(totalHits / 2000.0) * 0.5 : 0.0);
             aimValue *= lengthBonus;
 
-            // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
             if (effectiveMissCount > 0)
-                aimValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), effectiveMissCount);
-
-            aimValue *= getComboScalingFactor();
+                aimValue *= calculateMissPenalty(effectiveMissCount, Attributes.AimDifficultStrainCount);
 
             double approachRateFactor = 0.0;
             if (Attributes.ApproachRate > 10.33)
@@ -142,11 +139,8 @@ private double computeSpeedValue()
                                  (totalHits > 2000 ? Math.Log10(totalHits / 2000.0) * 0.5 : 0.0);
             speedValue *= lengthBonus;
 
-            // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
             if (effectiveMissCount > 0)
-                speedValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), Math.Pow(effectiveMissCount, .875));
-
-            speedValue *= getComboScalingFactor();
+                speedValue *= calculateMissPenalty(effectiveMissCount, Attributes.SpeedDifficultStrainCount);
 
             double approachRateFactor = 0.0;
             if (Attributes.ApproachRate > 10.33)
@@ -262,6 +256,10 @@ private int calculateEffectiveMissCount()
             return Math.Max(countMiss, (int)Math.Floor(comboBasedMissCount));
         }
 
+        // Miss penalty assumes that a player will miss on the hardest parts of a map,
+        // so we use the amount of relatively difficult sections to adjust miss penalty
+        // to make it more punishing on maps with lower amount of hard sections.
+        private double calculateMissPenalty(double missCount, double difficultStrainCount) => 0.95 / ((missCount / (3 * Math.Sqrt(difficultStrainCount))) + 1);
         private double getComboScalingFactor() => Attributes.MaxCombo <= 0 ? 1.0 : Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(Attributes.MaxCombo, 0.8), 1.0);
         private int totalHits => countGreat + countOk + countMeh + countMiss;
         private int totalSuccessfulHits => countGreat + countOk + countMeh;

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

@@ -57,5 +57,18 @@ public override double DifficultyValue()
 
             return difficulty * DifficultyMultiplier;
         }
+
+        /// <summary>
+        /// Returns the number of strains weighted against the top strain.
+        /// The result is scaled by clock rate as it affects the total number of strains.
+        /// </summary>
+        public double CountDifficultStrains(double clockRate)
+        {
+            List<double> strains = GetCurrentStrainPeaks().ToList();
+            double topStrain = strains.Max();
+
+            double realtimeCount = strains.Sum(s => Math.Pow(s / topStrain, 4));
+            return clockRate * realtimeCount;
+        }
     }
 }

osu.Game/Rulesets/Difficulty/DifficultyAttributes.cs

@@ -24,6 +24,8 @@ public class DifficultyAttributes
         protected const int ATTRIB_ID_SCORE_MULTIPLIER = 15;
         protected const int ATTRIB_ID_FLASHLIGHT = 17;
         protected const int ATTRIB_ID_SLIDER_FACTOR = 19;
+        protected const int ATTRIB_ID_AIM_DIFFICULT_STRAIN_COUNT = 21;
+        protected const int ATTRIB_ID_SPEED_DIFFICULT_STRAIN_COUNT = 23;
 
         /// <summary>
         /// The mods which were applied to the beatmap.