Basic tl-tapping consideration for stamina

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

@@ -16,13 +16,13 @@ public class TaikoDifficultyCalculatorTest : DifficultyCalculatorTest
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Taiko";
 
-        [TestCase(3.1098944660126882d, 200, "diffcalc-test")]
-        [TestCase(3.1098944660126882d, 200, "diffcalc-test-strong")]
+        [TestCase(3.0920212594351191d, 200, "diffcalc-test")]
+        [TestCase(3.0920212594351191d, 200, "diffcalc-test-strong")]
         public void Test(double expectedStarRating, int expectedMaxCombo, string name)
             => base.Test(expectedStarRating, expectedMaxCombo, name);
 
-        [TestCase(4.0974106752474251d, 200, "diffcalc-test")]
-        [TestCase(4.0974106752474251d, 200, "diffcalc-test-strong")]
+        [TestCase(4.0789820318081444d, 200, "diffcalc-test")]
+        [TestCase(4.0789820318081444d, 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

@@ -54,12 +54,12 @@ public static double EvaluateDifficultyOf(DifficultyHitObject hitObject)
             TaikoDifficultyHitObjectColour colour = ((TaikoDifficultyHitObject)hitObject).Colour;
             double difficulty = 0.0d;
 
-            if (colour.MonoStreak != null) // Difficulty for MonoStreak
-                difficulty += EvaluateDifficultyOf(colour.MonoStreak);
-            if (colour.AlternatingMonoPattern != null) // Difficulty for AlternatingMonoPattern
-                difficulty += EvaluateDifficultyOf(colour.AlternatingMonoPattern);
-            if (colour.RepeatingHitPattern != null) // Difficulty for RepeatingHitPattern
-                difficulty += EvaluateDifficultyOf(colour.RepeatingHitPattern);
+            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!);
 
             return difficulty;
         }

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

@@ -11,22 +11,43 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Evaluators
     public class StaminaEvaluator
     {
         /// <summary>
-        /// Applies a speed bonus dependent on the time since the last hit performed using this key.
+        /// Applies a speed bonus dependent on the time since the last hit performed using this finger.
         /// </summary>
-        /// <param name="interval">The interval between the current and previous note hit using the same key.</param>
+        /// <param name="interval">The interval between the current and previous note hit using the same finger.</param>
         private static double speedBonus(double interval)
         {
-            // Cap to 600bpm 1/4, 25ms note interval, 50ms key interval
-            // Interval will be capped at a very small value to avoid infinite/negative speed bonuses.
-            // TODO - This is a temporary measure as we need to implement methods of detecting playstyle-abuse of SpeedBonus.
-            interval = Math.Max(interval, 50);
+            // Interval is capped at a very small value to prevent infinite values.
+            interval = Math.Max(interval, 1);
 
             return 30 / interval;
         }
 
+        /// <summary>
+        /// Determines the number of fingers available to hit the current <see cref="TaikoDifficultyHitObject"/>.
+        /// Any mono notes that is more than 300ms apart from a colour change will be considered to have more than 2
+        /// fingers available, since players can hit the same key with multiple fingers.
+        /// </summary>
+        private static int availableFingersFor(TaikoDifficultyHitObject hitObject)
+        {
+            DifficultyHitObject? previousColourChange = hitObject.Colour.PreviousColourChange;
+            DifficultyHitObject? nextColourChange = hitObject.Colour.NextColourChange;
+
+            if (previousColourChange != null && hitObject.StartTime - previousColourChange.StartTime < 300)
+            {
+                return 2;
+            }
+
+            if (nextColourChange != null && nextColourChange.StartTime - hitObject.StartTime < 300)
+            {
+                return 2;
+            }
+
+            return 4;
+        }
+
         /// <summary>
         /// Evaluates the minimum mechanical stamina required to play the current object. This is calculated using the
-        /// maximum possible interval between two hits using the same key, by alternating 2 keys for each colour.
+        /// maximum possible interval between two hits using the same key, by alternating available fingers for each colour.
         /// </summary>
         public static double EvaluateDifficultyOf(DifficultyHitObject current)
         {
@@ -35,13 +56,14 @@ public static double EvaluateDifficultyOf(DifficultyHitObject current)
                 return 0.0;
             }
 
-            // Find the previous hit object hit by the current key, which is two notes of the same colour prior.
+            // Find the previous hit object hit by the current finger, which is n notes prior, n being the number of
+            // available fingers.
             TaikoDifficultyHitObject taikoCurrent = (TaikoDifficultyHitObject)current;
-            TaikoDifficultyHitObject? keyPrevious = taikoCurrent.PreviousMono(1);
+            TaikoDifficultyHitObject? keyPrevious = taikoCurrent.PreviousMono(availableFingersFor(taikoCurrent) - 1);
 
             if (keyPrevious == null)
             {
-                // There is no previous hit object hit by the current key
+                // There is no previous hit object hit by the current finger
                 return 0.0;
             }
 

osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/Data/AlternatingMonoPattern.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Linq;
 
 namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Colour.Data
 {
@@ -31,6 +32,11 @@ public class AlternatingMonoPattern
         /// </summary>
         public TaikoDifficultyHitObject FirstHitObject => MonoStreaks[0].FirstHitObject;
 
+        /// <summary>
+        /// All <see cref="TaikoDifficultyHitObject"/>s in this <see cref="AlternatingMonoPattern"/>.
+        /// </summary>
+        public IEnumerable<TaikoDifficultyHitObject> AllHitObjects => MonoStreaks.SelectMany(streak => streak.HitObjects);
+
         /// <summary>
         /// Determine if this <see cref="AlternatingMonoPattern"/> is a repetition of another <see cref="AlternatingMonoPattern"/>. This
         /// is a strict comparison and is true if and only if the colour sequence is exactly the same.

osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/Data/MonoStreak.cs

@@ -33,6 +33,11 @@ public class MonoStreak
         /// </summary>
         public TaikoDifficultyHitObject FirstHitObject => HitObjects[0];
 
+        /// <summary>
+        /// The last <see cref="TaikoDifficultyHitObject"/> in this <see cref="MonoStreak"/>.
+        /// </summary>
+        public TaikoDifficultyHitObject LastHitObject => HitObjects[^1];
+
         /// <summary>
         /// The hit type of all objects encoded within this <see cref="MonoStreak"/>
         /// </summary>

osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/Data/RepeatingHitPatterns.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Linq;
 using System.Collections.Generic;
 
 namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Colour.Data
@@ -23,10 +24,15 @@ public class RepeatingHitPatterns
         public readonly List<AlternatingMonoPattern> AlternatingMonoPatterns = new List<AlternatingMonoPattern>();
 
         /// <summary>
-        /// The parent <see cref="TaikoDifficultyHitObject"/> in this <see cref="RepeatingHitPatterns"/>
+        /// The first <see cref="TaikoDifficultyHitObject"/> in this <see cref="RepeatingHitPatterns"/>
         /// </summary>
         public TaikoDifficultyHitObject FirstHitObject => AlternatingMonoPatterns[0].FirstHitObject;
 
+        /// <summary>
+        /// All <see cref="TaikoDifficultyHitObject"/>s in this <see cref="RepeatingHitPatterns"/>.
+        /// </summary>
+        public IEnumerable<TaikoDifficultyHitObject> AllHitObjects => AlternatingMonoPatterns.SelectMany(pattern => pattern.AllHitObjects);
+
         /// <summary>
         /// The previous <see cref="RepeatingHitPatterns"/>. This is used to determine the repetition interval.
         /// </summary>

osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/TaikoColourDifficultyPreprocessor.cs

@@ -15,18 +15,19 @@ public static class TaikoColourDifficultyPreprocessor
     {
         /// <summary>
         /// Processes and encodes a list of <see cref="TaikoDifficultyHitObject"/>s into a list of <see cref="TaikoDifficultyHitObjectColour"/>s,
-        /// assigning the appropriate <see cref="TaikoDifficultyHitObjectColour"/>s to each <see cref="TaikoDifficultyHitObject"/>,
-        /// and pre-evaluating colour difficulty of each <see cref="TaikoDifficultyHitObject"/>.
+        /// assigning the appropriate <see cref="TaikoDifficultyHitObjectColour"/>s to each <see cref="TaikoDifficultyHitObject"/>.
         /// </summary>
         public static void ProcessAndAssign(List<DifficultyHitObject> hitObjects)
         {
             List<RepeatingHitPatterns> hitPatterns = encode(hitObjects);
 
-            // Assign indexing and encoding data to all relevant objects. Only the first note of each encoding type is
-            // assigned with the relevant encodings.
+            // Assign indexing and encoding data to all relevant objects.
             foreach (var repeatingHitPattern in hitPatterns)
             {
-                repeatingHitPattern.FirstHitObject.Colour.RepeatingHitPattern = repeatingHitPattern;
+                foreach (var hitObject in repeatingHitPattern.AllHitObjects)
+                {
+                    hitObject.Colour.RepeatingHitPattern = repeatingHitPattern;
+                }
 
                 // The outermost loop is kept a ForEach loop since it doesn't need index information, and we want to
                 // keep i and j for AlternatingMonoPattern's and MonoStreak's index respectively, to keep it in line with
@@ -36,14 +37,22 @@ public static void ProcessAndAssign(List<DifficultyHitObject> hitObjects)
                     AlternatingMonoPattern monoPattern = repeatingHitPattern.AlternatingMonoPatterns[i];
                     monoPattern.Parent = repeatingHitPattern;
                     monoPattern.Index = i;
-                    monoPattern.FirstHitObject.Colour.AlternatingMonoPattern = monoPattern;
+
+                    foreach (var hitObject in monoPattern.AllHitObjects)
+                    {
+                        hitObject.Colour.AlternatingMonoPattern = monoPattern;
+                    }
 
                     for (int j = 0; j < monoPattern.MonoStreaks.Count; ++j)
                     {
                         MonoStreak monoStreak = monoPattern.MonoStreaks[j];
                         monoStreak.Parent = monoPattern;
                         monoStreak.Index = j;
-                        monoStreak.FirstHitObject.Colour.MonoStreak = monoStreak;
+
+                        foreach (var hitObject in monoStreak.HitObjects)
+                        {
+                            hitObject.Colour.MonoStreak = monoStreak;
+                        }
                     }
                 }
             }

osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/TaikoDifficultyHitObjectColour.cs

@@ -11,18 +11,28 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Colour
     public class TaikoDifficultyHitObjectColour
     {
         /// <summary>
-        /// The <see cref="MonoStreak"/> that encodes this note, only present if this is the first note within a <see cref="MonoStreak"/>
+        /// The <see cref="MonoStreak"/> that encodes this note.
         /// </summary>
         public MonoStreak? MonoStreak;
 
         /// <summary>
-        /// The <see cref="AlternatingMonoPattern"/> that encodes this note, only present if this is the first note within a <see cref="AlternatingMonoPattern"/>
+        /// The <see cref="AlternatingMonoPattern"/> that encodes this note.
         /// </summary>
         public AlternatingMonoPattern? AlternatingMonoPattern;
 
         /// <summary>
-        /// The <see cref="RepeatingHitPattern"/> that encodes this note, only present if this is the first note within a <see cref="RepeatingHitPattern"/>
+        /// The <see cref="RepeatingHitPattern"/> that encodes this note.
         /// </summary>
         public RepeatingHitPatterns? RepeatingHitPattern;
+
+        /// <summary>
+        /// The closest past <see cref="TaikoDifficultyHitObject"/> that's not the same colour.
+        /// </summary>
+        public TaikoDifficultyHitObject? PreviousColourChange => MonoStreak?.FirstHitObject.PreviousNote(0);
+
+        /// <summary>
+        /// The closest future <see cref="TaikoDifficultyHitObject"/> that's not the same colour.
+        /// </summary>
+        public TaikoDifficultyHitObject? NextColourChange => MonoStreak?.LastHitObject.NextNote(0);
     }
 }

osu.Game.Rulesets.Taiko/Difficulty/Skills/Stamina.cs

@@ -13,9 +13,6 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
     /// <summary>
     /// Calculates the stamina coefficient of taiko difficulty.
     /// </summary>
-    /// <remarks>
-    /// The reference play style chosen uses two hands, with full alternating (the hand changes after every hit).
-    /// </remarks>
     public class Stamina : StrainDecaySkill
     {
         protected override double SkillMultiplier => 1.1;

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

@@ -83,15 +83,6 @@ protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beat
             double combinedRating = combined.DifficultyValue() * difficulty_multiplier;
             double starRating = rescale(combinedRating * 1.4);
 
-            // TODO: This is temporary measure as we don't detect abuse of multiple-input playstyles of converts within the current system.
-            if (beatmap.BeatmapInfo.Ruleset.OnlineID == 0)
-            {
-                starRating *= 0.925;
-                // For maps with low colour variance and high stamina requirement, multiple inputs are more likely to be abused.
-                if (colourRating < 2 && staminaRating > 8)
-                    starRating *= 0.80;
-            }
-
             HitWindows hitWindows = new TaikoHitWindows();
             hitWindows.SetDifficulty(beatmap.Difficulty.OverallDifficulty);
 

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

@@ -41,6 +41,9 @@ protected override PerformanceAttributes CreatePerformanceAttributes(ScoreInfo s
             if (totalSuccessfulHits > 0)
                 effectiveMissCount = Math.Max(1.0, 1000.0 / totalSuccessfulHits) * countMiss;
 
+            // TODO: The detection of rulesets is temporary until the leftover old skills have been reworked.
+            bool rulesetTaiko = score.BeatmapInfo.Ruleset.OnlineID == 1;
+
             double multiplier = 1.13;
 
             if (score.Mods.Any(m => m is ModHidden))
@@ -49,8 +52,8 @@ protected override PerformanceAttributes CreatePerformanceAttributes(ScoreInfo s
             if (score.Mods.Any(m => m is ModEasy))
                 multiplier *= 0.975;
 
-            double difficultyValue = computeDifficultyValue(score, taikoAttributes);
-            double accuracyValue = computeAccuracyValue(score, taikoAttributes);
+            double difficultyValue = computeDifficultyValue(score, taikoAttributes, rulesetTaiko);
+            double accuracyValue = computeAccuracyValue(score, taikoAttributes, rulesetTaiko);
             double totalValue =
                 Math.Pow(
                     Math.Pow(difficultyValue, 1.1) +
@@ -66,7 +69,7 @@ protected override PerformanceAttributes CreatePerformanceAttributes(ScoreInfo s
             };
         }
 
-        private double computeDifficultyValue(ScoreInfo score, TaikoDifficultyAttributes attributes)
+        private double computeDifficultyValue(ScoreInfo score, TaikoDifficultyAttributes attributes, bool rulesetTaiko)
         {
             double difficultyValue = Math.Pow(5 * Math.Max(1.0, attributes.StarRating / 0.115) - 4.0, 2.25) / 1150.0;
 
@@ -78,7 +81,7 @@ private double computeDifficultyValue(ScoreInfo score, TaikoDifficultyAttributes
             if (score.Mods.Any(m => m is ModEasy))
                 difficultyValue *= 0.985;
 
-            if (score.Mods.Any(m => m is ModHidden))
+            if (score.Mods.Any(m => m is ModHidden) && rulesetTaiko)
                 difficultyValue *= 1.025;
 
             if (score.Mods.Any(m => m is ModHardRock))
@@ -90,7 +93,7 @@ private double computeDifficultyValue(ScoreInfo score, TaikoDifficultyAttributes
             return difficultyValue * Math.Pow(score.Accuracy, 2.0);
         }
 
-        private double computeAccuracyValue(ScoreInfo score, TaikoDifficultyAttributes attributes)
+        private double computeAccuracyValue(ScoreInfo score, TaikoDifficultyAttributes attributes, bool rulesetTaiko)
         {
             if (attributes.GreatHitWindow <= 0)
                 return 0;
@@ -100,9 +103,9 @@ private double computeAccuracyValue(ScoreInfo score, TaikoDifficultyAttributes a
             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))
-                accuracyValue *= Math.Max(1.050, 1.075 * 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) && rulesetTaiko)
+                accuracyValue *= Math.Max(1.0, 1.1 * lengthBonus);
 
             return accuracyValue;
         }