Add a consistency factor to osu!taiko diffcalc (#33233)

* add consistency attribute

* write attributes to json for serialisation

* comment change

* fix json, add mechanical difficulty

* write new attributes to database

---------

Co-authored-by: James Wilson <[email protected]>

Author: Lawtrohux

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

@@ -10,14 +10,23 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
 {
     public class TaikoDifficultyAttributes : DifficultyAttributes
     {
+        /// <summary>
+        /// The difficulty corresponding to the mechanical skills in osu!taiko.
+        /// This includes colour and stamina combined.
+        /// </summary>
+        [JsonProperty("mechanical_difficulty")]
+        public double MechanicalDifficulty { get; set; }
+
         /// <summary>
         /// The difficulty corresponding to the rhythm skill.
         /// </summary>
+        [JsonProperty("rhythm_difficulty")]
         public double RhythmDifficulty { get; set; }
 
         /// <summary>
         /// The difficulty corresponding to the reading skill.
         /// </summary>
+        [JsonProperty("reading_difficulty")]
         public double ReadingDifficulty { get; set; }
 
         /// <summary>
@@ -36,9 +45,11 @@ public class TaikoDifficultyAttributes : DifficultyAttributes
         [JsonProperty("mono_stamina_factor")]
         public double MonoStaminaFactor { get; set; }
 
-        public double RhythmTopStrains { get; set; }
-
-        public double ColourTopStrains { get; set; }
+        /// <summary>
+        /// The factor corresponding to the consistency of a map.
+        /// </summary>
+        [JsonProperty("consistency_factor")]
+        public double ConsistencyFactor { get; set; }
 
         public double StaminaTopStrains { get; set; }
 
@@ -48,15 +59,23 @@ public class TaikoDifficultyAttributes : DifficultyAttributes
                 yield return v;
 
             yield return (ATTRIB_ID_DIFFICULTY, StarRating);
+            yield return (ATTRIB_ID_MECHANICAL_DIFFICULTY, MechanicalDifficulty);
+            yield return (ATTRIB_ID_RHYTHM_DIFFICULTY, RhythmDifficulty);
+            yield return (ATTRIB_ID_READING_DIFFICULTY, ReadingDifficulty);
             yield return (ATTRIB_ID_MONO_STAMINA_FACTOR, MonoStaminaFactor);
+            yield return (ATTRIB_ID_CONSISTENCY_FACTOR, ConsistencyFactor);
         }
 
         public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values, IBeatmapOnlineInfo onlineInfo)
         {
             base.FromDatabaseAttributes(values, onlineInfo);
 
             StarRating = values[ATTRIB_ID_DIFFICULTY];
+            MechanicalDifficulty = values[ATTRIB_ID_MECHANICAL_DIFFICULTY];
+            RhythmDifficulty = values[ATTRIB_ID_RHYTHM_DIFFICULTY];
+            ReadingDifficulty = values[ATTRIB_ID_READING_DIFFICULTY];
             MonoStaminaFactor = values[ATTRIB_ID_MONO_STAMINA_FACTOR];
+            ConsistencyFactor = values[ATTRIB_ID_CONSISTENCY_FACTOR];
         }
     }
 }

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

@@ -115,8 +115,6 @@ protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beat
             double monoStaminaSkill = singleColourStamina.DifficultyValue() * stamina_skill_multiplier;
             double monoStaminaFactor = staminaSkill == 0 ? 1 : Math.Pow(monoStaminaSkill / staminaSkill, 5);
 
-            double colourDifficultStrains = colour.CountTopWeightedStrains();
-            double rhythmDifficultStrains = rhythm.CountTopWeightedStrains();
             double staminaDifficultStrains = stamina.CountTopWeightedStrains();
 
             // As we don't have pattern integration in osu!taiko, we apply the other two skills relative to rhythm.
@@ -126,7 +124,7 @@ protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beat
                                 + Math.Min(Math.Max((staminaDifficultStrains - 1000) / 3700, 0), 0.15)
                                 + Math.Min(Math.Max((staminaSkill - 7.0) / 1.0, 0), 0.05);
 
-            double combinedRating = combinedDifficultyValue(rhythm, reading, colour, stamina, isRelax, isConvert);
+            double combinedRating = combinedDifficultyValue(rhythm, reading, colour, stamina, isRelax, isConvert, out double consistencyFactor);
             double starRating = rescale(combinedRating * 1.4);
 
             // Calculate proportional contribution of each skill to the combinedRating.
@@ -136,19 +134,20 @@ protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beat
             double readingDifficulty = readingSkill * skillRating;
             double colourDifficulty = colourSkill * skillRating;
             double staminaDifficulty = staminaSkill * skillRating;
+            double mechanicalDifficulty = colourDifficulty + staminaDifficulty; // Mechanical difficulty is the sum of colour and stamina difficulties.
 
             TaikoDifficultyAttributes attributes = new TaikoDifficultyAttributes
             {
                 StarRating = starRating,
                 Mods = mods,
+                MechanicalDifficulty = mechanicalDifficulty,
                 RhythmDifficulty = rhythmDifficulty,
                 ReadingDifficulty = readingDifficulty,
                 ColourDifficulty = colourDifficulty,
                 StaminaDifficulty = staminaDifficulty,
                 MonoStaminaFactor = monoStaminaFactor,
-                RhythmTopStrains = rhythmDifficultStrains,
-                ColourTopStrains = colourDifficultStrains,
                 StaminaTopStrains = staminaDifficultStrains,
+                ConsistencyFactor = consistencyFactor,
                 MaxCombo = beatmap.GetMaxCombo(),
             };
 
@@ -162,7 +161,7 @@ protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beat
         /// For each section, the peak strains of all separate skills are combined into a single peak strain for the section.
         /// The resulting partial rating of the beatmap is a weighted sum of the combined peaks (higher peaks are weighted more).
         /// </remarks>
-        private double combinedDifficultyValue(Rhythm rhythm, Reading reading, Colour colour, Stamina stamina, bool isRelax, bool isConvert)
+        private double combinedDifficultyValue(Rhythm rhythm, Reading reading, Colour colour, Stamina stamina, bool isRelax, bool isConvert, out double consistencyFactor)
         {
             List<double> peaks = new List<double>();
 
@@ -196,9 +195,35 @@ private double combinedDifficultyValue(Rhythm rhythm, Reading reading, Colour co
                 weight *= 0.9;
             }
 
+            consistencyFactor = calculateConsistencyFactor(peaks);
+
             return difficulty;
         }
 
+        /// <summary>
+        /// Calculates a consistency factor based on how 'spiked' the strain peaks are.
+        /// Higher values indicate more consistent difficulty, lower values indicate diff-spike heavy maps.
+        /// </summary>
+        private double calculateConsistencyFactor(List<double> peaks)
+        {
+            // If there are too few sections in a map, assume it is consistent.
+            if (peaks.Count < 3)
+                return 1.0;
+
+            List<double> sorted = peaks.OrderDescending().ToList();
+
+            double topPeak = sorted[0];
+            double secondTopPeak = sorted.Count > 1 ? sorted[1] : topPeak;
+
+            // Compute the average of the middle 50% of strain values.
+            double midAvg = sorted.Skip(sorted.Count / 4).Take(sorted.Count / 2).Average();
+
+            // A higher ratio means the top sections are much harder than the average, indicating inconsistency.
+            double spikeSeverity = (topPeak + secondTopPeak) / 2.0 / midAvg;
+
+            return 1.0 / spikeSeverity;
+        }
+
         /// <summary>
         /// Applies a final re-scaling of the star rating.
         /// </summary>

osu.Game/Rulesets/Difficulty/DifficultyAttributes.cs

@@ -31,6 +31,10 @@ public class DifficultyAttributes
         protected const int ATTRIB_ID_NESTED_SCORE_PER_OBJECT = 37;
         protected const int ATTRIB_ID_LEGACY_SCORE_BASE_MULTIPLIER = 39;
         protected const int ATTRIB_ID_MAXIMUM_LEGACY_COMBO_SCORE = 41;
+        protected const int ATTRIB_ID_MECHANICAL_DIFFICULTY = 43;
+        protected const int ATTRIB_ID_RHYTHM_DIFFICULTY = 45;
+        protected const int ATTRIB_ID_READING_DIFFICULTY = 47;
+        protected const int ATTRIB_ID_CONSISTENCY_FACTOR = 49;
 
         /// <summary>
         /// The mods which were applied to the beatmap.