Merge pull request #35029 from ppy/pp-dev

Q3 SR & PP release

.editorconfig

@@ -19,6 +19,11 @@ indent_style = space
 indent_size = 4
 trim_trailing_whitespace = true
 
+# temporary workaround for https://youtrack.jetbrains.com/issue/RIDER-130051/Cannot-resolve-symbol-inspections-incorrectly-firing-for-xmldoc-protected-member-references
+resharper_c_sharp_warnings_cs1574_cs1584_cs1581_cs1580_highlighting = hint
+# temporary workaround for https://youtrack.jetbrains.com/issue/RIDER-130381/Rider-does-not-respect-propagated-NoWarn-CS1591?backToIssues=false
+dotnet_diagnostic.CS1591.severity = none
+
 #license header
 file_header_template = Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.\nSee the LICENCE file in the repository root for full licence text.
 

osu.Android.props

@@ -10,7 +10,7 @@
     <EmbedAssembliesIntoApk>true</EmbedAssembliesIntoApk>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2025.908.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2025.930.0" />
   </ItemGroup>
   <PropertyGroup>
     <!-- Fody does not handle Android build well, and warns when unchanged.

osu.Game.Benchmarks/BenchmarkDifficultyCalculation.cs

@@ -0,0 +1,77 @@
+// 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.IO;
+using BenchmarkDotNet.Attributes;
+using osu.Framework.IO.Stores;
+using osu.Game.Beatmaps;
+using osu.Game.IO;
+using osu.Game.IO.Archives;
+using osu.Game.Rulesets.Catch;
+using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mania;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Taiko;
+using osu.Game.Tests.Resources;
+
+namespace osu.Game.Benchmarks
+{
+    public class BenchmarkDifficultyCalculation : BenchmarkTest
+    {
+        private DifficultyCalculator osuCalculator = null!;
+        private DifficultyCalculator taikoCalculator = null!;
+        private DifficultyCalculator catchCalculator = null!;
+        private DifficultyCalculator maniaCalculator = null!;
+
+        public override void SetUp()
+        {
+            using var resources = new DllResourceStore(typeof(TestResources).Assembly);
+
+            using var archive = resources.GetStream("Resources/Archives/241526 Soleily - Renatus.osz");
+            using var archiveReader = new ZipArchiveReader(archive);
+
+            var osuBeatmap = readBeatmap(archiveReader, "Soleily - Renatus (Gamu) [Insane].osu");
+            var taikoBeatmap = readBeatmap(archiveReader, "Soleily - Renatus (MMzz) [Oni].osu");
+            var catchBeatmap = readBeatmap(archiveReader, "Soleily - Renatus (Deif) [Salad].osu");
+            var maniaBeatmap = readBeatmap(archiveReader, "Soleily - Renatus (ExPew) [Another].osu");
+
+            osuCalculator = new OsuRuleset().CreateDifficultyCalculator(osuBeatmap);
+            taikoCalculator = new TaikoRuleset().CreateDifficultyCalculator(taikoBeatmap);
+            catchCalculator = new CatchRuleset().CreateDifficultyCalculator(catchBeatmap);
+            maniaCalculator = new ManiaRuleset().CreateDifficultyCalculator(maniaBeatmap);
+        }
+
+        private WorkingBeatmap readBeatmap(ZipArchiveReader archiveReader, string beatmapName)
+        {
+            using var beatmapStream = new MemoryStream();
+            archiveReader.GetStream(beatmapName).CopyTo(beatmapStream);
+
+            beatmapStream.Seek(0, SeekOrigin.Begin);
+            using var reader = new LineBufferedReader(beatmapStream);
+
+            var decoder = Beatmaps.Formats.Decoder.GetDecoder<Beatmap>(reader);
+            return new FlatWorkingBeatmap(decoder.Decode(reader));
+        }
+
+        [Benchmark]
+        public void CalculateDifficultyOsu() => osuCalculator.Calculate();
+
+        [Benchmark]
+        public void CalculateDifficultyTaiko() => taikoCalculator.Calculate();
+
+        [Benchmark]
+        public void CalculateDifficultyCatch() => catchCalculator.Calculate();
+
+        [Benchmark]
+        public void CalculateDifficultyMania() => maniaCalculator.Calculate();
+
+        [Benchmark]
+        public void CalculateDifficultyOsuHundredTimes()
+        {
+            for (int i = 0; i < 100; i++)
+            {
+                osuCalculator.Calculate();
+            }
+        }
+    }
+}

osu.Game.Rulesets.Catch.Tests/TestSceneCatcher.cs

@@ -157,7 +157,7 @@ namespace osu.Game.Rulesets.Catch.Tests
         }
 
         [Test]
-        public void TestTinyDropletMissPreservesCatcherState()
+        public void TestTinyDropletMissChangesCatcherState()
         {
             AddStep("catch hyper kiai fruit", () => attemptCatch(new TestKiaiFruit
             {
@@ -165,8 +165,8 @@ namespace osu.Game.Rulesets.Catch.Tests
             }));
             AddStep("catch tiny droplet", () => attemptCatch(new TinyDroplet()));
             AddStep("miss tiny droplet", () => attemptCatch(new TinyDroplet { X = 100 }));
-            // catcher state and hyper dash state is preserved
-            checkState(CatcherAnimationState.Kiai);
+            // catcher state is changed but hyper dash state is preserved
+            checkState(CatcherAnimationState.Fail);
             checkHyperDash(true);
         }
 

osu.Game.Rulesets.Catch/Difficulty/CatchPerformanceCalculator.cs

@@ -3,13 +3,13 @@
 
 using System;
 using System.Linq;
-using osu.Framework.Audio.Track;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
 using osu.Game.Scoring.Legacy;
+using osu.Game.Utils;
 
 namespace osu.Game.Rulesets.Catch.Difficulty
 {
@@ -51,15 +51,13 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
             // Combo scaling
             if (catchAttributes.MaxCombo > 0)
-                value *= Math.Min(Math.Pow(score.MaxCombo, 0.8) / Math.Pow(catchAttributes.MaxCombo, 0.8), 1.0);
+                value *= Math.Min(Math.Pow(score.MaxCombo, 0.35) / Math.Pow(catchAttributes.MaxCombo, 0.35), 1.0);
 
             var difficulty = score.BeatmapInfo!.Difficulty.Clone();
 
             score.Mods.OfType<IApplicableToDifficulty>().ForEach(m => m.ApplyToDifficulty(difficulty));
 
-            var track = new TrackVirtual(10000);
-            score.Mods.OfType<IApplicableToTrack>().ForEach(m => m.ApplyToTrack(track));
-            double clockRate = track.Rate;
+            double clockRate = ModUtils.CalculateRateWithMods(score.Mods);
 
             // this is the same as osu!, so there's potential to share the implementation... maybe
             double preempt = IBeatmapDifficultyInfo.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450) / clockRate;

osu.Game.Rulesets.Catch/Difficulty/Evaluators/MovementEvaluator.cs

@@ -0,0 +1,65 @@
+// 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.Catch.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+
+namespace osu.Game.Rulesets.Catch.Difficulty.Evaluators
+{
+    public static class MovementEvaluator
+    {
+        private const double direction_change_bonus = 21.0;
+
+        public static double EvaluateDifficultyOf(DifficultyHitObject current, double catcherSpeedMultiplier)
+        {
+            var catchCurrent = (CatchDifficultyHitObject)current;
+            var catchLast = (CatchDifficultyHitObject)current.Previous(0);
+            var catchLastLast = (CatchDifficultyHitObject)current.Previous(1);
+
+            double weightedStrainTime = catchCurrent.StrainTime + 13 + (3 / catcherSpeedMultiplier);
+
+            double distanceAddition = (Math.Pow(Math.Abs(catchCurrent.DistanceMoved), 1.3) / 510);
+            double sqrtStrain = Math.Sqrt(weightedStrainTime);
+
+            double edgeDashBonus = 0;
+
+            // Direction change bonus.
+            if (Math.Abs(catchCurrent.DistanceMoved) > 0.1)
+            {
+                if (current.Index >= 1 && Math.Abs(catchLast.DistanceMoved) > 0.1 && Math.Sign(catchCurrent.DistanceMoved) != Math.Sign(catchLast.DistanceMoved))
+                {
+                    double bonusFactor = Math.Min(50, Math.Abs(catchCurrent.DistanceMoved)) / 50;
+                    double antiflowFactor = Math.Max(Math.Min(70, Math.Abs(catchLast.DistanceMoved)) / 70, 0.38);
+
+                    distanceAddition += direction_change_bonus / Math.Sqrt(catchLast.StrainTime + 16) * bonusFactor * antiflowFactor * Math.Max(1 - Math.Pow(weightedStrainTime / 1000, 3), 0);
+                }
+
+                // Base bonus for every movement, giving some weight to streams.
+                distanceAddition += 12.5 * Math.Min(Math.Abs(catchCurrent.DistanceMoved), CatchDifficultyHitObject.NORMALIZED_HALF_CATCHER_WIDTH * 2)
+                                    / (CatchDifficultyHitObject.NORMALIZED_HALF_CATCHER_WIDTH * 6) / sqrtStrain;
+            }
+
+            // Bonus for edge dashes.
+            if (catchCurrent.LastObject.DistanceToHyperDash <= 20.0f)
+            {
+                if (!catchCurrent.LastObject.HyperDash)
+                    edgeDashBonus += 5.7;
+
+                distanceAddition *= 1.0 + edgeDashBonus * ((20 - catchCurrent.LastObject.DistanceToHyperDash) / 20)
+                                                        * Math.Pow((Math.Min(catchCurrent.StrainTime * catcherSpeedMultiplier, 265) / 265), 1.5); // Edge Dashes are easier at lower ms values
+            }
+
+            // There is an edge case where horizontal back and forth sliders create "buzz" patterns which are repeated "movements" with a distance lower than
+            // the platter's width but high enough to be considered a movement due to the absolute_player_positioning_error and NORMALIZED_HALF_CATCHER_WIDTH offsets
+            // We are detecting this exact scenario. The first back and forth is counted but all subsequent ones are nullified.
+            // To achieve that, we need to store the exact distances (distance ignoring absolute_player_positioning_error and NORMALIZED_HALF_CATCHER_WIDTH)
+            if (current.Index >= 2 && Math.Abs(catchCurrent.ExactDistanceMoved) <= CatchDifficultyHitObject.NORMALIZED_HALF_CATCHER_WIDTH * 2
+                                   && catchCurrent.ExactDistanceMoved == -catchLast.ExactDistanceMoved && catchLast.ExactDistanceMoved == -catchLastLast.ExactDistanceMoved
+                                   && catchCurrent.StrainTime == catchLast.StrainTime && catchLast.StrainTime == catchLastLast.StrainTime)
+                distanceAddition = 0;
+
+            return distanceAddition / weightedStrainTime;
+        }
+    }
+}

osu.Game.Rulesets.Catch/Difficulty/Preprocessing/CatchDifficultyHitObject.cs

@@ -11,15 +11,49 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Preprocessing
 {
     public class CatchDifficultyHitObject : DifficultyHitObject
     {
-        private const float normalized_hitobject_radius = 41.0f;
+        public const float NORMALIZED_HALF_CATCHER_WIDTH = 41.0f;
+        private const float absolute_player_positioning_error = 16.0f;
 
         public new PalpableCatchHitObject BaseObject => (PalpableCatchHitObject)base.BaseObject;
 
         public new PalpableCatchHitObject LastObject => (PalpableCatchHitObject)base.LastObject;
 
+        /// <summary>
+        /// Normalized position of <see cref="BaseObject"/>.
+        /// </summary>
         public readonly float NormalizedPosition;
+
+        /// <summary>
+        /// Normalized position of <see cref="LastObject"/>.
+        /// </summary>
         public readonly float LastNormalizedPosition;
 
+        /// <summary>
+        /// Normalized position of the player required to catch <see cref="BaseObject"/>, assuming the player moves as little as possible.
+        /// </summary>
+        public float PlayerPosition { get; private set; }
+
+        /// <summary>
+        /// Normalized position of the player after catching <see cref="LastObject"/>.
+        /// </summary>
+        public float LastPlayerPosition { get; private set; }
+
+        /// <summary>
+        /// Normalized distance between <see cref="LastPlayerPosition"/> and <see cref="PlayerPosition"/>.
+        /// </summary>
+        /// <remarks>
+        /// The sign of the value indicates the direction of the movement: negative is left and positive is right.
+        /// </remarks>
+        public float DistanceMoved { get; private set; }
+
+        /// <summary>
+        /// Normalized distance the player has to move from <see cref="LastPlayerPosition"/> in order to catch <see cref="BaseObject"/> at its <see cref="NormalizedPosition"/>.
+        /// </summary>
+        /// <remarks>
+        /// The sign of the value indicates the direction of the movement: negative is left and positive is right.
+        /// </remarks>
+        public float ExactDistanceMoved { get; private set; }
+
         /// <summary>
         /// Milliseconds elapsed since the start time of the previous <see cref="CatchDifficultyHitObject"/>, with a minimum of 40ms.
         /// </summary>
@@ -29,13 +63,35 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Preprocessing
             : base(hitObject, lastObject, clockRate, objects, index)
         {
             // We will scale everything by this factor, so we can assume a uniform CircleSize among beatmaps.
-            float scalingFactor = normalized_hitobject_radius / halfCatcherWidth;
+            float scalingFactor = NORMALIZED_HALF_CATCHER_WIDTH / halfCatcherWidth;
 
             NormalizedPosition = BaseObject.EffectiveX * scalingFactor;
             LastNormalizedPosition = LastObject.EffectiveX * scalingFactor;
 
             // Every strain interval is hard capped at the equivalent of 375 BPM streaming speed as a safety measure
             StrainTime = Math.Max(40, DeltaTime);
+
+            setMovementState();
+        }
+
+        private void setMovementState()
+        {
+            LastPlayerPosition = Index == 0 ? LastNormalizedPosition : ((CatchDifficultyHitObject)Previous(0)).PlayerPosition;
+
+            PlayerPosition = Math.Clamp(
+                LastPlayerPosition,
+                NormalizedPosition - (NORMALIZED_HALF_CATCHER_WIDTH - absolute_player_positioning_error),
+                NormalizedPosition + (NORMALIZED_HALF_CATCHER_WIDTH - absolute_player_positioning_error)
+            );
+
+            DistanceMoved = PlayerPosition - LastPlayerPosition;
+
+            // For the exact position we consider that the catcher is in the correct position for both objects
+            ExactDistanceMoved = NormalizedPosition - LastPlayerPosition;
+
+            // After a hyperdash we ARE in the correct position. Always!
+            if (LastObject.HyperDash)
+                PlayerPosition = NormalizedPosition;
         }
     }
 }

osu.Game.Rulesets.Catch/Difficulty/Skills/Movement.cs

@@ -1,8 +1,7 @@
 // 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.Catch.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Catch.Difficulty.Evaluators;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Skills;
 using osu.Game.Rulesets.Mods;
@@ -11,10 +10,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
 {
     public class Movement : StrainDecaySkill
     {
-        private const float absolute_player_positioning_error = 16f;
-        private const float normalized_hitobject_radius = 41.0f;
-        private const double direction_change_bonus = 21.0;
-
         protected override double SkillMultiplier => 1;
         protected override double StrainDecayBase => 0.2;
 
@@ -24,12 +19,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
 
         protected readonly float HalfCatcherWidth;
 
-        private float? lastPlayerPosition;
-        private float lastDistanceMoved;
-        private float lastExactDistanceMoved;
-        private double lastStrainTime;
-        private bool isInBuzzSection;
-
         /// <summary>
         /// The speed multiplier applied to the player's catcher.
         /// </summary>
@@ -49,80 +38,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
 
         protected override double StrainValueOf(DifficultyHitObject current)
         {
-            var catchCurrent = (CatchDifficultyHitObject)current;
-
-            lastPlayerPosition ??= catchCurrent.LastNormalizedPosition;
-
-            float playerPosition = Math.Clamp(
-                lastPlayerPosition.Value,
-                catchCurrent.NormalizedPosition - (normalized_hitobject_radius - absolute_player_positioning_error),
-                catchCurrent.NormalizedPosition + (normalized_hitobject_radius - absolute_player_positioning_error)
-            );
-
-            float distanceMoved = playerPosition - lastPlayerPosition.Value;
-
-            // For the exact position we consider that the catcher is in the correct position for both objects
-            float exactDistanceMoved = catchCurrent.NormalizedPosition - lastPlayerPosition.Value;
-
-            double weightedStrainTime = catchCurrent.StrainTime + 13 + (3 / catcherSpeedMultiplier);
-
-            double distanceAddition = (Math.Pow(Math.Abs(distanceMoved), 1.3) / 510);
-            double sqrtStrain = Math.Sqrt(weightedStrainTime);
-
-            double edgeDashBonus = 0;
-
-            // Direction change bonus.
-            if (Math.Abs(distanceMoved) > 0.1)
-            {
-                if (Math.Abs(lastDistanceMoved) > 0.1 && Math.Sign(distanceMoved) != Math.Sign(lastDistanceMoved))
-                {
-                    double bonusFactor = Math.Min(50, Math.Abs(distanceMoved)) / 50;
-                    double antiflowFactor = Math.Max(Math.Min(70, Math.Abs(lastDistanceMoved)) / 70, 0.38);
-
-                    distanceAddition += direction_change_bonus / Math.Sqrt(lastStrainTime + 16) * bonusFactor * antiflowFactor * Math.Max(1 - Math.Pow(weightedStrainTime / 1000, 3), 0);
-                }
-
-                // Base bonus for every movement, giving some weight to streams.
-                distanceAddition += 12.5 * Math.Min(Math.Abs(distanceMoved), normalized_hitobject_radius * 2) / (normalized_hitobject_radius * 6) / sqrtStrain;
-            }
-
-            // Bonus for edge dashes.
-            if (catchCurrent.LastObject.DistanceToHyperDash <= 20.0f)
-            {
-                if (!catchCurrent.LastObject.HyperDash)
-                    edgeDashBonus += 5.7;
-                else
-                {
-                    // After a hyperdash we ARE in the correct position. Always!
-                    playerPosition = catchCurrent.NormalizedPosition;
-                }
-
-                distanceAddition *= 1.0 + edgeDashBonus * ((20 - catchCurrent.LastObject.DistanceToHyperDash) / 20)
-                                                        * Math.Pow((Math.Min(catchCurrent.StrainTime * catcherSpeedMultiplier, 265) / 265), 1.5); // Edge Dashes are easier at lower ms values
-            }
-
-            // There is an edge case where horizontal back and forth sliders create "buzz" patterns which are repeated "movements" with a distance lower than
-            // the platter's width but high enough to be considered a movement due to the absolute_player_positioning_error and normalized_hitobject_radius offsets
-            // We are detecting this exact scenario. The first back and forth is counted but all subsequent ones are nullified.
-            // To achieve that, we need to store the exact distances (distance ignoring absolute_player_positioning_error and normalized_hitobject_radius)
-            if (Math.Abs(exactDistanceMoved) <= HalfCatcherWidth * 2 && exactDistanceMoved == -lastExactDistanceMoved && catchCurrent.StrainTime == lastStrainTime)
-            {
-                if (isInBuzzSection)
-                    distanceAddition = 0;
-                else
-                    isInBuzzSection = true;
-            }
-            else
-            {
-                isInBuzzSection = false;
-            }
-
-            lastPlayerPosition = playerPosition;
-            lastDistanceMoved = distanceMoved;
-            lastStrainTime = catchCurrent.StrainTime;
-            lastExactDistanceMoved = exactDistanceMoved;
-
-            return distanceAddition / weightedStrainTime;
+            return MovementEvaluator.EvaluateDifficultyOf(current, catcherSpeedMultiplier);
         }
     }
 }

osu.Game.Rulesets.Catch/UI/Catcher.cs

@@ -224,7 +224,20 @@ namespace osu.Game.Rulesets.Catch.UI
                     addLighting(result, drawableObject.AccentColour.Value, positionInStack.X);
             }
 
-            // droplet doesn't affect the catcher state
+            if (result.IsHit)
+                CurrentState = hitObject.Kiai ? CatcherAnimationState.Kiai : CatcherAnimationState.Idle;
+            else if (hitObject is not Banana)
+                CurrentState = CatcherAnimationState.Fail;
+
+            if (palpableObject.HitObject.LastInCombo)
+            {
+                if (result.Judgement is CatchJudgement catchJudgement && catchJudgement.ShouldExplodeFor(result))
+                    Explode();
+                else
+                    Drop();
+            }
+
+            // droplet doesn't affect hyperdash state
             if (hitObject is TinyDroplet) return;
 
             // if a hyper fruit was already handled this frame, just go where it says to go.
@@ -244,19 +257,6 @@ namespace osu.Game.Rulesets.Catch.UI
                 else
                     SetHyperDashState();
             }
-
-            if (result.IsHit)
-                CurrentState = hitObject.Kiai ? CatcherAnimationState.Kiai : CatcherAnimationState.Idle;
-            else if (!(hitObject is Banana))
-                CurrentState = CatcherAnimationState.Fail;
-
-            if (palpableObject.HitObject.LastInCombo)
-            {
-                if (result.Judgement is CatchJudgement catchJudgement && catchJudgement.ShouldExplodeFor(result))
-                    Explode();
-                else
-                    Drop();
-            }
         }
 
         public void OnRevertResult(JudgementResult result)

osu.Game.Rulesets.Mania/Difficulty/Evaluators/IndividualStrainEvaluator.cs

@@ -0,0 +1,37 @@
+// 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 osu.Framework.Utils;
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Mania.Difficulty.Preprocessing;
+
+namespace osu.Game.Rulesets.Mania.Difficulty.Evaluators
+{
+    public class IndividualStrainEvaluator
+    {
+        public static double EvaluateDifficultyOf(DifficultyHitObject current)
+        {
+            var maniaCurrent = (ManiaDifficultyHitObject)current;
+            double startTime = maniaCurrent.StartTime;
+            double endTime = maniaCurrent.EndTime;
+
+            double holdFactor = 1.0; // Factor to all additional strains in case something else is held
+
+            // We award a bonus if this note starts and ends before the end of another hold note.
+            foreach (var maniaPrevious in maniaCurrent.PreviousHitObjects)
+            {
+                if (maniaPrevious is null)
+                    continue;
+
+                if (Precision.DefinitelyBigger(maniaPrevious.EndTime, endTime, 1) &&
+                    Precision.DefinitelyBigger(startTime, maniaPrevious.StartTime, 1))
+                {
+                    holdFactor = 1.25;
+                    break;
+                }
+            }
+
+            return 2.0 * holdFactor;
+        }
+    }
+}

osu.Game.Rulesets.Mania/Difficulty/Evaluators/OverallStrainEvaluator.cs

@@ -0,0 +1,61 @@
+// 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.Framework.Utils;
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Difficulty.Utils;
+using osu.Game.Rulesets.Mania.Difficulty.Preprocessing;
+
+namespace osu.Game.Rulesets.Mania.Difficulty.Evaluators
+{
+    public class OverallStrainEvaluator
+    {
+        private const double release_threshold = 30;
+
+        public static double EvaluateDifficultyOf(DifficultyHitObject current)
+        {
+            var maniaCurrent = (ManiaDifficultyHitObject)current;
+            double startTime = maniaCurrent.StartTime;
+            double endTime = maniaCurrent.EndTime;
+            bool isOverlapping = false;
+
+            double closestEndTime = Math.Abs(endTime - startTime); // Lowest value we can assume with the current information
+            double holdFactor = 1.0; // Factor to all additional strains in case something else is held
+            double holdAddition = 0; // Addition to the current note in case it's a hold and has to be released awkwardly
+
+            foreach (var maniaPrevious in maniaCurrent.PreviousHitObjects)
+            {
+                if (maniaPrevious is null)
+                    continue;
+
+                // The current note is overlapped if a previous note or end is overlapping the current note body
+                isOverlapping |= Precision.DefinitelyBigger(maniaPrevious.EndTime, startTime, 1) &&
+                                 Precision.DefinitelyBigger(endTime, maniaPrevious.EndTime, 1) &&
+                                 Precision.DefinitelyBigger(startTime, maniaPrevious.StartTime, 1);
+
+                // We give a slight bonus to everything if something is held meanwhile
+                if (Precision.DefinitelyBigger(maniaPrevious.EndTime, endTime, 1) &&
+                    Precision.DefinitelyBigger(startTime, maniaPrevious.StartTime, 1))
+                    holdFactor = 1.25;
+
+                closestEndTime = Math.Min(closestEndTime, Math.Abs(endTime - maniaPrevious.EndTime));
+            }
+
+            // The hold addition is given if there was an overlap, however it is only valid if there are no other note with a similar ending.
+            // Releasing multiple notes is just as easy as releasing 1. Nerfs the hold addition by half if the closest release is release_threshold away.
+            // holdAddition
+            //     ^
+            // 1.0 + - - - - - -+-----------
+            //     |           /
+            // 0.5 + - - - - -/   Sigmoid Curve
+            //     |         /|
+            // 0.0 +--------+-+---------------> Release Difference / ms
+            //         release_threshold
+            if (isOverlapping)
+                holdAddition = DifficultyCalculationUtils.Logistic(x: closestEndTime, multiplier: 0.27, midpointOffset: release_threshold);
+
+            return (1 + holdAddition) * holdFactor;
+        }
+    }
+}

osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs

@@ -65,13 +65,22 @@ namespace osu.Game.Rulesets.Mania.Difficulty
         protected override IEnumerable<DifficultyHitObject> CreateDifficultyHitObjects(IBeatmap beatmap, double clockRate)
         {
             var sortedObjects = beatmap.HitObjects.ToArray();
+            int totalColumns = ((ManiaBeatmap)beatmap).TotalColumns;
 
             LegacySortHelper<HitObject>.Sort(sortedObjects, Comparer<HitObject>.Create((a, b) => (int)Math.Round(a.StartTime) - (int)Math.Round(b.StartTime)));
 
             List<DifficultyHitObject> objects = new List<DifficultyHitObject>();
+            List<DifficultyHitObject>[] perColumnObjects = new List<DifficultyHitObject>[totalColumns];
+
+            for (int column = 0; column < totalColumns; column++)
+                perColumnObjects[column] = new List<DifficultyHitObject>();
 
             for (int i = 1; i < sortedObjects.Length; i++)
-                objects.Add(new ManiaDifficultyHitObject(sortedObjects[i], sortedObjects[i - 1], clockRate, objects, objects.Count));
+            {
+                var currentObject = new ManiaDifficultyHitObject(sortedObjects[i], sortedObjects[i - 1], clockRate, objects, perColumnObjects, objects.Count);
+                objects.Add(currentObject);
+                perColumnObjects[currentObject.Column].Add(currentObject);
+            }
 
             return objects;
         }

osu.Game.Rulesets.Mania/Difficulty/Preprocessing/ManiaDifficultyHitObject.cs

@@ -12,9 +12,59 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Preprocessing
     {
         public new ManiaHitObject BaseObject => (ManiaHitObject)base.BaseObject;
 
-        public ManiaDifficultyHitObject(HitObject hitObject, HitObject lastObject, double clockRate, List<DifficultyHitObject> objects, int index)
+        private readonly List<DifficultyHitObject>[] perColumnObjects;
+
+        private readonly int columnIndex;
+
+        public readonly int Column;
+
+        // The hit object earlier in time than this note in each column
+        public readonly ManiaDifficultyHitObject?[] PreviousHitObjects;
+
+        public readonly double ColumnStrainTime;
+
+        public ManiaDifficultyHitObject(HitObject hitObject, HitObject lastObject, double clockRate, List<DifficultyHitObject> objects, List<DifficultyHitObject>[] perColumnObjects, int index)
             : base(hitObject, lastObject, clockRate, objects, index)
         {
+            int totalColumns = perColumnObjects.Length;
+            this.perColumnObjects = perColumnObjects;
+            Column = BaseObject.Column;
+            columnIndex = perColumnObjects[Column].Count;
+            PreviousHitObjects = new ManiaDifficultyHitObject[totalColumns];
+            ColumnStrainTime = StartTime - PrevInColumn(0)?.StartTime ?? StartTime;
+
+            if (index > 0)
+            {
+                ManiaDifficultyHitObject prevNote = (ManiaDifficultyHitObject)objects[index - 1];
+
+                for (int i = 0; i < prevNote.PreviousHitObjects.Length; i++)
+                    PreviousHitObjects[i] = prevNote.PreviousHitObjects[i];
+
+                // intentionally depends on processing order to match live.
+                PreviousHitObjects[prevNote.Column] = prevNote;
+            }
+        }
+
+        /// <summary>
+        /// The previous object in the same column as this <see cref="ManiaDifficultyHitObject"/>, exclusive of Long Note tails.
+        /// </summary>
+        /// <param name="backwardsIndex">The number of notes to go back.</param>
+        /// <returns>The object in this column <paramref name="backwardsIndex"/> notes back, or null if this is the first note in the column.</returns>
+        public ManiaDifficultyHitObject? PrevInColumn(int backwardsIndex)
+        {
+            int index = columnIndex - (backwardsIndex + 1);
+            return index >= 0 && index < perColumnObjects[Column].Count ? (ManiaDifficultyHitObject)perColumnObjects[Column][index] : null;
+        }
+
+        /// <summary>
+        /// The next object in the same column as this <see cref="ManiaDifficultyHitObject"/>, exclusive of Long Note tails.
+        /// </summary>
+        /// <param name="forwardsIndex">The number of notes to go forward.</param>
+        /// <returns>The object in this column <paramref name="forwardsIndex"/> notes forward, or null if this is the last note in the column.</returns>
+        public ManiaDifficultyHitObject? NextInColumn(int forwardsIndex)
+        {
+            int index = columnIndex + (forwardsIndex + 1);
+            return index >= 0 && index < perColumnObjects[Column].Count ? (ManiaDifficultyHitObject)perColumnObjects[Column][index] : null;
         }
     }
 }

osu.Game.Rulesets.Mania/Difficulty/Skills/Strain.cs

@@ -2,10 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using osu.Framework.Utils;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Skills;
-using osu.Game.Rulesets.Difficulty.Utils;
+using osu.Game.Rulesets.Mania.Difficulty.Evaluators;
 using osu.Game.Rulesets.Mania.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Mods;
 
@@ -15,23 +14,17 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Skills
     {
         private const double individual_decay_base = 0.125;
         private const double overall_decay_base = 0.30;
-        private const double release_threshold = 30;
 
         protected override double SkillMultiplier => 1;
         protected override double StrainDecayBase => 1;
 
-        private readonly double[] startTimes;
-        private readonly double[] endTimes;
         private readonly double[] individualStrains;
-
-        private double individualStrain;
+        private double highestIndividualStrain;
         private double overallStrain;
 
         public Strain(Mod[] mods, int totalColumns)
             : base(mods)
         {
-            startTimes = new double[totalColumns];
-            endTimes = new double[totalColumns];
             individualStrains = new double[totalColumns];
             overallStrain = 1;
         }
@@ -39,65 +32,24 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Skills
         protected override double StrainValueOf(DifficultyHitObject current)
         {
             var maniaCurrent = (ManiaDifficultyHitObject)current;
-            double startTime = maniaCurrent.StartTime;
-            double endTime = maniaCurrent.EndTime;
-            int column = maniaCurrent.BaseObject.Column;
-            bool isOverlapping = false;
 
-            double closestEndTime = Math.Abs(endTime - startTime); // Lowest value we can assume with the current information
-            double holdFactor = 1.0; // Factor to all additional strains in case something else is held
-            double holdAddition = 0; // Addition to the current note in case it's a hold and has to be released awkwardly
+            individualStrains[maniaCurrent.Column] = applyDecay(individualStrains[maniaCurrent.Column], maniaCurrent.ColumnStrainTime, individual_decay_base);
+            individualStrains[maniaCurrent.Column] += IndividualStrainEvaluator.EvaluateDifficultyOf(current);
 
-            for (int i = 0; i < endTimes.Length; ++i)
-            {
-                // The current note is overlapped if a previous note or end is overlapping the current note body
-                isOverlapping |= Precision.DefinitelyBigger(endTimes[i], startTime, 1) &&
-                                 Precision.DefinitelyBigger(endTime, endTimes[i], 1) &&
-                                 Precision.DefinitelyBigger(startTime, startTimes[i], 1);
+            // Take the hardest individualStrain for notes that happen at the same time (in a chord).
+            // This is to ensure the order in which the notes are processed does not affect the resultant total strain.
+            highestIndividualStrain = maniaCurrent.DeltaTime <= 1 ? Math.Max(highestIndividualStrain, individualStrains[maniaCurrent.Column]) : individualStrains[maniaCurrent.Column];
 
-                // We give a slight bonus to everything if something is held meanwhile
-                if (Precision.DefinitelyBigger(endTimes[i], endTime, 1) &&
-                    Precision.DefinitelyBigger(startTime, startTimes[i], 1))
-                    holdFactor = 1.25;
-
-                closestEndTime = Math.Min(closestEndTime, Math.Abs(endTime - endTimes[i]));
-            }
-
-            // The hold addition is given if there was an overlap, however it is only valid if there are no other note with a similar ending.
-            // Releasing multiple notes is just as easy as releasing 1. Nerfs the hold addition by half if the closest release is release_threshold away.
-            // holdAddition
-            //     ^
-            // 1.0 + - - - - - -+-----------
-            //     |           /
-            // 0.5 + - - - - -/   Sigmoid Curve
-            //     |         /|
-            // 0.0 +--------+-+---------------> Release Difference / ms
-            //         release_threshold
-            if (isOverlapping)
-                holdAddition = DifficultyCalculationUtils.Logistic(x: closestEndTime, multiplier: 0.27, midpointOffset: release_threshold);
-
-            // Decay and increase individualStrains in own column
-            individualStrains[column] = applyDecay(individualStrains[column], startTime - startTimes[column], individual_decay_base);
-            individualStrains[column] += 2.0 * holdFactor;
-
-            // For notes at the same time (in a chord), the individualStrain should be the hardest individualStrain out of those columns
-            individualStrain = maniaCurrent.DeltaTime <= 1 ? Math.Max(individualStrain, individualStrains[column]) : individualStrains[column];
-
-            // Decay and increase overallStrain
-            overallStrain = applyDecay(overallStrain, current.DeltaTime, overall_decay_base);
-            overallStrain += (1 + holdAddition) * holdFactor;
-
-            // Update startTimes and endTimes arrays
-            startTimes[column] = startTime;
-            endTimes[column] = endTime;
+            overallStrain = applyDecay(overallStrain, maniaCurrent.DeltaTime, overall_decay_base);
+            overallStrain += OverallStrainEvaluator.EvaluateDifficultyOf(current);
 
             // By subtracting CurrentStrain, this skill effectively only considers the maximum strain of any one hitobject within each strain section.
-            return individualStrain + overallStrain - CurrentStrain;
+            return highestIndividualStrain + overallStrain - CurrentStrain;
         }
 
-        protected override double CalculateInitialStrain(double offset, DifficultyHitObject current)
-            => applyDecay(individualStrain, offset - current.Previous(0).StartTime, individual_decay_base)
-               + applyDecay(overallStrain, offset - current.Previous(0).StartTime, overall_decay_base);
+        protected override double CalculateInitialStrain(double offset, DifficultyHitObject current) =>
+            applyDecay(highestIndividualStrain, offset - current.Previous(0).StartTime, individual_decay_base)
+            + applyDecay(overallStrain, offset - current.Previous(0).StartTime, overall_decay_base);
 
         private double applyDecay(double value, double deltaTime, double decayBase)
             => value * Math.Pow(decayBase, deltaTime / 1000);

osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyNotePiece.cs

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 
         private Drawable noteAnimation = null!;
 
-        private float? minimumColumnWidth;
+        private float? widthForNoteHeightScale;
 
         public LegacyNotePiece()
         {
@@ -33,7 +33,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
         [BackgroundDependencyLoader]
         private void load(ISkinSource skin, IScrollingInfo scrollingInfo)
         {
-            minimumColumnWidth = skin.GetConfig<ManiaSkinConfigurationLookup, float>(new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.MinimumColumnWidth))?.Value;
+            widthForNoteHeightScale = skin.GetConfig<ManiaSkinConfigurationLookup, float>(new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.WidthForNoteHeightScale))?.Value;
 
             InternalChild = directionContainer = new Container
             {
@@ -60,9 +60,8 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 
             if (texture != null)
             {
-                // The height is scaled to the minimum column width, if provided.
-                float minimumWidth = minimumColumnWidth ?? DrawWidth;
-                noteAnimation.Scale = Vector2.Divide(new Vector2(DrawWidth, minimumWidth), texture.DisplayWidth);
+                float noteHeight = widthForNoteHeightScale ?? DrawWidth;
+                noteAnimation.Scale = Vector2.Divide(new Vector2(DrawWidth, noteHeight), texture.DisplayWidth);
             }
         }
 

osu.Game.Rulesets.Osu.Tests/OsuDifficultyCalculatorTest.cs

@@ -15,22 +15,22 @@ namespace osu.Game.Rulesets.Osu.Tests
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Osu.Tests";
 
-        [TestCase(6.7331304290522747d, 239, "diffcalc-test")]
-        [TestCase(1.4602604078137214d, 54, "zero-length-sliders")]
-        [TestCase(0.43052813047866129d, 4, "very-fast-slider")]
-        [TestCase(0.14143808967817237d, 2, "nan-slider")]
+        [TestCase(6.6232533278125061d, 239, "diffcalc-test")]
+        [TestCase(1.5045783545699611d, 54, "zero-length-sliders")]
+        [TestCase(0.43333836671191595d, 4, "very-fast-slider")]
+        [TestCase(0.13841532030395723d, 2, "nan-slider")]
         public void Test(double expectedStarRating, int expectedMaxCombo, string name)
             => base.Test(expectedStarRating, expectedMaxCombo, name);
 
-        [TestCase(9.6779746353001634d, 239, "diffcalc-test")]
-        [TestCase(1.7691451263718989d, 54, "zero-length-sliders")]
-        [TestCase(0.55785578988249407d, 4, "very-fast-slider")]
+        [TestCase(9.6491691624112761d, 239, "diffcalc-test")]
+        [TestCase(1.756936832498702d, 54, "zero-length-sliders")]
+        [TestCase(0.57771197086735004d, 4, "very-fast-slider")]
         public void TestClockRateAdjusted(double expectedStarRating, int expectedMaxCombo, string name)
             => Test(expectedStarRating, expectedMaxCombo, name, new OsuModDoubleTime());
 
-        [TestCase(6.7331304290522747d, 239, "diffcalc-test")]
-        [TestCase(1.4602604078137214d, 54, "zero-length-sliders")]
-        [TestCase(0.43052813047866129d, 4, "very-fast-slider")]
+        [TestCase(6.6232533278125061d, 239, "diffcalc-test")]
+        [TestCase(1.5045783545699611d, 54, "zero-length-sliders")]
+        [TestCase(0.43333836671191595d, 4, "very-fast-slider")]
         public void TestClassicMod(double expectedStarRating, int expectedMaxCombo, string name)
             => Test(expectedStarRating, expectedMaxCombo, name, new OsuModClassic());
 

osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerInput.cs

@@ -191,6 +191,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         }
 
         [Test]
+        [FlakyTest]
         public void TestRewind()
         {
             AddStep("set manual clock", () => manualClock = new ManualClock

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

@@ -12,7 +12,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
     public static class AimEvaluator
     {
         private const double wide_angle_multiplier = 1.5;
-        private const double acute_angle_multiplier = 2.6;
+        private const double acute_angle_multiplier = 2.55;
         private const double slider_multiplier = 1.35;
         private const double velocity_change_multiplier = 0.75;
         private const double wiggle_multiplier = 1.02;
@@ -34,12 +34,13 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
             var osuCurrObj = (OsuDifficultyHitObject)current;
             var osuLastObj = (OsuDifficultyHitObject)current.Previous(0);
             var osuLastLastObj = (OsuDifficultyHitObject)current.Previous(1);
+            var osuLast2Obj = (OsuDifficultyHitObject)current.Previous(2);
 
             const int radius = OsuDifficultyHitObject.NORMALISED_RADIUS;
             const int diameter = OsuDifficultyHitObject.NORMALISED_DIAMETER;
 
             // Calculate the velocity to the current hitobject, which starts with a base distance / time assuming the last object is a hitcircle.
-            double currVelocity = osuCurrObj.LazyJumpDistance / osuCurrObj.StrainTime;
+            double currVelocity = osuCurrObj.LazyJumpDistance / osuCurrObj.AdjustedDeltaTime;
 
             // But if the last object is a slider, then we extend the travel velocity through the slider into the current object.
             if (osuLastObj.BaseObject is Slider && withSliderTravelDistance)
@@ -51,7 +52,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
             }
 
             // As above, do the same for the previous hitobject.
-            double prevVelocity = osuLastObj.LazyJumpDistance / osuLastObj.StrainTime;
+            double prevVelocity = osuLastObj.LazyJumpDistance / osuLastObj.AdjustedDeltaTime;
 
             if (osuLastLastObj.BaseObject is Slider && withSliderTravelDistance)
             {
@@ -69,59 +70,77 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
 
             double aimStrain = currVelocity; // Start strain with regular velocity.
 
-            if (Math.Max(osuCurrObj.StrainTime, osuLastObj.StrainTime) < 1.25 * Math.Min(osuCurrObj.StrainTime, osuLastObj.StrainTime)) // If rhythms are the same.
+            if (osuCurrObj.Angle != null && osuLastObj.Angle != null)
             {
-                if (osuCurrObj.Angle != null && osuLastObj.Angle != null)
+                double currAngle = osuCurrObj.Angle.Value;
+                double lastAngle = osuLastObj.Angle.Value;
+
+                // Rewarding angles, take the smaller velocity as base.
+                double angleBonus = Math.Min(currVelocity, prevVelocity);
+
+                if (Math.Max(osuCurrObj.AdjustedDeltaTime, osuLastObj.AdjustedDeltaTime) < 1.25 * Math.Min(osuCurrObj.AdjustedDeltaTime, osuLastObj.AdjustedDeltaTime)) // If rhythms are the same.
                 {
-                    double currAngle = osuCurrObj.Angle.Value;
-                    double lastAngle = osuLastObj.Angle.Value;
-
-                    // Rewarding angles, take the smaller velocity as base.
-                    double angleBonus = Math.Min(currVelocity, prevVelocity);
-
-                    wideAngleBonus = calcWideAngleBonus(currAngle);
                     acuteAngleBonus = calcAcuteAngleBonus(currAngle);
 
                     // Penalize angle repetition.
-                    wideAngleBonus *= 1 - Math.Min(wideAngleBonus, Math.Pow(calcWideAngleBonus(lastAngle), 3));
                     acuteAngleBonus *= 0.08 + 0.92 * (1 - Math.Min(acuteAngleBonus, Math.Pow(calcAcuteAngleBonus(lastAngle), 3)));
 
-                    // Apply full wide angle bonus for distance more than one diameter
-                    wideAngleBonus *= angleBonus * DifficultyCalculationUtils.Smootherstep(osuCurrObj.LazyJumpDistance, 0, diameter);
-
                     // Apply acute angle bonus for BPM above 300 1/2 and distance more than one diameter
                     acuteAngleBonus *= angleBonus *
-                                       DifficultyCalculationUtils.Smootherstep(DifficultyCalculationUtils.MillisecondsToBPM(osuCurrObj.StrainTime, 2), 300, 400) *
+                                       DifficultyCalculationUtils.Smootherstep(DifficultyCalculationUtils.MillisecondsToBPM(osuCurrObj.AdjustedDeltaTime, 2), 300, 400) *
                                        DifficultyCalculationUtils.Smootherstep(osuCurrObj.LazyJumpDistance, diameter, diameter * 2);
+                }
 
-                    // Apply wiggle bonus for jumps that are [radius, 3*diameter] in distance, with < 110 angle
-                    // https://www.desmos.com/calculator/dp0v0nvowc
-                    wiggleBonus = angleBonus
-                                  * DifficultyCalculationUtils.Smootherstep(osuCurrObj.LazyJumpDistance, radius, diameter)
-                                  * Math.Pow(DifficultyCalculationUtils.ReverseLerp(osuCurrObj.LazyJumpDistance, diameter * 3, diameter), 1.8)
-                                  * DifficultyCalculationUtils.Smootherstep(currAngle, double.DegreesToRadians(110), double.DegreesToRadians(60))
-                                  * DifficultyCalculationUtils.Smootherstep(osuLastObj.LazyJumpDistance, radius, diameter)
-                                  * Math.Pow(DifficultyCalculationUtils.ReverseLerp(osuLastObj.LazyJumpDistance, diameter * 3, diameter), 1.8)
-                                  * DifficultyCalculationUtils.Smootherstep(lastAngle, double.DegreesToRadians(110), double.DegreesToRadians(60));
+                wideAngleBonus = calcWideAngleBonus(currAngle);
+
+                // Penalize angle repetition.
+                wideAngleBonus *= 1 - Math.Min(wideAngleBonus, Math.Pow(calcWideAngleBonus(lastAngle), 3));
+
+                // Apply full wide angle bonus for distance more than one diameter
+                wideAngleBonus *= angleBonus * DifficultyCalculationUtils.Smootherstep(osuCurrObj.LazyJumpDistance, 0, diameter);
+
+                // Apply wiggle bonus for jumps that are [radius, 3*diameter] in distance, with < 110 angle
+                // https://www.desmos.com/calculator/dp0v0nvowc
+                wiggleBonus = angleBonus
+                              * DifficultyCalculationUtils.Smootherstep(osuCurrObj.LazyJumpDistance, radius, diameter)
+                              * Math.Pow(DifficultyCalculationUtils.ReverseLerp(osuCurrObj.LazyJumpDistance, diameter * 3, diameter), 1.8)
+                              * DifficultyCalculationUtils.Smootherstep(currAngle, double.DegreesToRadians(110), double.DegreesToRadians(60))
+                              * DifficultyCalculationUtils.Smootherstep(osuLastObj.LazyJumpDistance, radius, diameter)
+                              * Math.Pow(DifficultyCalculationUtils.ReverseLerp(osuLastObj.LazyJumpDistance, diameter * 3, diameter), 1.8)
+                              * DifficultyCalculationUtils.Smootherstep(lastAngle, double.DegreesToRadians(110), double.DegreesToRadians(60));
+
+                if (osuLast2Obj != null)
+                {
+                    // If objects just go back and forth through a middle point - don't give as much wide bonus
+                    // Use Previous(2) and Previous(0) because angles calculation is done prevprev-prev-curr, so any object's angle's center point is always the previous object
+                    var lastBaseObject = (OsuHitObject)osuLastObj.BaseObject;
+                    var last2BaseObject = (OsuHitObject)osuLast2Obj.BaseObject;
+
+                    float distance = (last2BaseObject.StackedPosition - lastBaseObject.StackedPosition).Length;
+
+                    if (distance < 1)
+                    {
+                        wideAngleBonus *= 1 - 0.35 * (1 - distance);
+                    }
                 }
             }
 
             if (Math.Max(prevVelocity, currVelocity) != 0)
             {
                 // We want to use the average velocity over the whole object when awarding differences, not the individual jump and slider path velocities.
-                prevVelocity = (osuLastObj.LazyJumpDistance + osuLastLastObj.TravelDistance) / osuLastObj.StrainTime;
-                currVelocity = (osuCurrObj.LazyJumpDistance + osuLastObj.TravelDistance) / osuCurrObj.StrainTime;
+                prevVelocity = (osuLastObj.LazyJumpDistance + osuLastLastObj.TravelDistance) / osuLastObj.AdjustedDeltaTime;
+                currVelocity = (osuCurrObj.LazyJumpDistance + osuLastObj.TravelDistance) / osuCurrObj.AdjustedDeltaTime;
 
                 // Scale with ratio of difference compared to 0.5 * max dist.
-                double distRatio = Math.Pow(Math.Sin(Math.PI / 2 * Math.Abs(prevVelocity - currVelocity) / Math.Max(prevVelocity, currVelocity)), 2);
+                double distRatio = DifficultyCalculationUtils.Smoothstep(Math.Abs(prevVelocity - currVelocity) / Math.Max(prevVelocity, currVelocity), 0, 1);
 
                 // Reward for % distance up to 125 / strainTime for overlaps where velocity is still changing.
-                double overlapVelocityBuff = Math.Min(diameter * 1.25 / Math.Min(osuCurrObj.StrainTime, osuLastObj.StrainTime), Math.Abs(prevVelocity - currVelocity));
+                double overlapVelocityBuff = Math.Min(diameter * 1.25 / Math.Min(osuCurrObj.AdjustedDeltaTime, osuLastObj.AdjustedDeltaTime), Math.Abs(prevVelocity - currVelocity));
 
                 velocityChangeBonus = overlapVelocityBuff * distRatio;
 
                 // Penalize for rhythm changes.
-                velocityChangeBonus *= Math.Pow(Math.Min(osuCurrObj.StrainTime, osuLastObj.StrainTime) / Math.Max(osuCurrObj.StrainTime, osuLastObj.StrainTime), 2);
+                velocityChangeBonus *= Math.Pow(Math.Min(osuCurrObj.AdjustedDeltaTime, osuLastObj.AdjustedDeltaTime) / Math.Max(osuCurrObj.AdjustedDeltaTime, osuLastObj.AdjustedDeltaTime), 2);
             }
 
             if (osuLastObj.BaseObject is Slider)
@@ -131,9 +150,13 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
             }
 
             aimStrain += wiggleBonus * wiggle_multiplier;
+            aimStrain += velocityChangeBonus * velocity_change_multiplier;
 
-            // Add in acute angle bonus or wide angle bonus + velocity change bonus, whichever is larger.
-            aimStrain += Math.Max(acuteAngleBonus * acute_angle_multiplier, wideAngleBonus * wide_angle_multiplier + velocityChangeBonus * velocity_change_multiplier);
+            // Add in acute angle bonus or wide angle bonus, whichever is larger.
+            aimStrain += Math.Max(acuteAngleBonus * acute_angle_multiplier, wideAngleBonus * wide_angle_multiplier);
+
+            // Apply high circle size bonus
+            aimStrain *= osuCurrObj.SmallCircleBonus;
 
             // Add in additional slider velocity bonus.
             if (withSliderTravelDistance)

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

@@ -52,7 +52,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
                 var currentObj = (OsuDifficultyHitObject)current.Previous(i);
                 var currentHitObject = (OsuHitObject)(currentObj.BaseObject);
 
-                cumulativeStrainTime += lastObj.StrainTime;
+                cumulativeStrainTime += lastObj.AdjustedDeltaTime;
 
                 if (!(currentObj.BaseObject is Spinner))
                 {
@@ -95,7 +95,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
             if (osuCurrent.BaseObject is Slider osuSlider)
             {
                 // Invert the scaling factor to determine the true travel distance independent of circle size.
-                double pixelTravelDistance = osuSlider.LazyTravelDistance / scalingFactor;
+                double pixelTravelDistance = osuCurrent.LazyTravelDistance / scalingFactor;
 
                 // Reward sliders based on velocity.
                 sliderBonus = Math.Pow(Math.Max(0.0, pixelTravelDistance / osuCurrent.TravelTime - min_velocity), 0.5);

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

@@ -15,8 +15,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
     {
         private const int history_time_max = 5 * 1000; // 5 seconds
         private const int history_objects_max = 32;
-        private const double rhythm_overall_multiplier = 0.95;
-        private const double rhythm_ratio_multiplier = 12.0;
+        private const double rhythm_overall_multiplier = 1.0;
+        private const double rhythm_ratio_multiplier = 15.0;
 
         /// <summary>
         /// Calculates a rhythm multiplier for the difficulty of the tap associated with historic data of the current <see cref="OsuDifficultyHitObject"/>.
@@ -26,6 +26,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
             if (current.BaseObject is Spinner)
                 return 0;
 
+            var currentOsuObject = (OsuDifficultyHitObject)current;
+
             double rhythmComplexitySum = 0;
 
             double deltaDifferenceEpsilon = ((OsuDifficultyHitObject)current).HitWindowGreat * 0.3;
@@ -62,22 +64,26 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
 
                 double currHistoricalDecay = Math.Min(noteDecay, timeDecay); // either we're limited by time or limited by object count.
 
-                double currDelta = currObj.StrainTime;
-                double prevDelta = prevObj.StrainTime;
-                double lastDelta = lastObj.StrainTime;
+                // Use custom cap value to ensure that that at this point delta time is actually zero
+                double currDelta = Math.Max(currObj.DeltaTime, 1e-7);
+                double prevDelta = Math.Max(prevObj.DeltaTime, 1e-7);
+                double lastDelta = Math.Max(lastObj.DeltaTime, 1e-7);
 
                 // calculate how much current delta difference deserves a rhythm bonus
                 // this function is meant to reduce rhythm bonus for deltas that are multiples of each other (i.e 100 and 200)
-                double deltaDifferenceRatio = Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta);
-                double currRatio = 1.0 + rhythm_ratio_multiplier * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / deltaDifferenceRatio), 2));
+                double deltaDifference = Math.Max(prevDelta, currDelta) / Math.Min(prevDelta, currDelta);
+
+                // Take only the fractional part of the value since we're only interested in punishing multiples
+                double deltaDifferenceFraction = deltaDifference - Math.Truncate(deltaDifference);
+
+                double currRatio = 1.0 + rhythm_ratio_multiplier * Math.Min(0.5, DifficultyCalculationUtils.SmoothstepBellCurve(deltaDifferenceFraction));
 
                 // reduce ratio bonus if delta difference is too big
-                double fraction = Math.Max(prevDelta / currDelta, currDelta / prevDelta);
-                double fractionMultiplier = Math.Clamp(2.0 - fraction / 8.0, 0.0, 1.0);
+                double differenceMultiplier = Math.Clamp(2.0 - deltaDifference / 8.0, 0.0, 1.0);
 
                 double windowPenalty = Math.Min(1, Math.Max(0, Math.Abs(prevDelta - currDelta) - deltaDifferenceEpsilon) / deltaDifferenceEpsilon);
 
-                double effectiveRatio = windowPenalty * currRatio * fractionMultiplier;
+                double effectiveRatio = windowPenalty * currRatio * differenceMultiplier;
 
                 if (firstDeltaSwitch)
                 {
@@ -170,7 +176,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
                 prevObj = currObj;
             }
 
-            return Math.Sqrt(4 + rhythmComplexitySum * rhythm_overall_multiplier) / 2.0; // produces multiplier that can be applied to strain. range [1, infinity) (not really though)
+            double rhythmDifficulty = Math.Sqrt(4 + rhythmComplexitySum * rhythm_overall_multiplier) / 2.0; // produces multiplier that can be applied to strain. range [1, infinity) (not really though)
+            rhythmDifficulty *= 1 - currentOsuObject.GetDoubletapness((OsuDifficultyHitObject)current.Next(0));
+
+            return rhythmDifficulty;
         }
 
         private class Island : IEquatable<Island>

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

@@ -18,7 +18,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
         private const double single_spacing_threshold = OsuDifficultyHitObject.NORMALISED_DIAMETER * 1.25; // 1.25 circles distance between centers
         private const double min_speed_bonus = 200; // 200 BPM 1/4th
         private const double speed_balancing_factor = 40;
-        private const double distance_multiplier = 0.9;
+        private const double distance_multiplier = 0.8;
 
         /// <summary>
         /// Evaluates the difficulty of tapping the current object, based on:
@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
             var osuCurrObj = (OsuDifficultyHitObject)current;
             var osuPrevObj = current.Index > 0 ? (OsuDifficultyHitObject)current.Previous(0) : null;
 
-            double strainTime = osuCurrObj.StrainTime;
+            double strainTime = osuCurrObj.AdjustedDeltaTime;
             double doubletapness = 1.0 - osuCurrObj.GetDoubletapness((OsuDifficultyHitObject?)osuCurrObj.Next(0));
 
             // Cap deltatime to the OD 300 hitwindow.
@@ -60,6 +60,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
             // Max distance bonus is 1 * `distance_multiplier` at single_spacing_threshold
             double distanceBonus = Math.Pow(distance / single_spacing_threshold, 3.95) * distance_multiplier;
 
+            // Apply reduced small circle bonus because flow aim difficulty on small circles doesn't scale as hard as jumps
+            distanceBonus *= Math.Sqrt(osuCurrObj.SmallCircleBonus);
+
             if (mods.OfType<OsuModAutopilot>().Any())
                 distanceBonus = 0;
 

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

@@ -53,12 +53,37 @@ namespace osu.Game.Rulesets.Osu.Difficulty
         [JsonProperty("slider_factor")]
         public double SliderFactor { get; set; }
 
+        /// <summary>
+        /// Describes how much of <see cref="AimDifficultStrainCount"/> is contributed to by hitcircles or sliders
+        /// A value closer to 0.0 indicates most of <see cref="AimDifficultStrainCount"/> is contributed by hitcircles
+        /// A value closer to Infinity indicates most of <see cref="AimDifficultStrainCount"/> is contributed by sliders
+        /// </summary>
+        [JsonProperty("aim_top_weighted_slider_factor")]
+        public double AimTopWeightedSliderFactor { get; set; }
+
+        /// <summary>
+        /// Describes how much of <see cref="SpeedDifficultStrainCount"/> is contributed to by hitcircles or sliders
+        /// A value closer to 0.0 indicates most of <see cref="SpeedDifficultStrainCount"/> is contributed by hitcircles
+        /// A value closer to Infinity indicates most of <see cref="SpeedDifficultStrainCount"/> is contributed by sliders
+        /// </summary>
+        [JsonProperty("speed_top_weighted_slider_factor")]
+        public double SpeedTopWeightedSliderFactor { get; set; }
+
         [JsonProperty("aim_difficult_strain_count")]
         public double AimDifficultStrainCount { get; set; }
 
         [JsonProperty("speed_difficult_strain_count")]
         public double SpeedDifficultStrainCount { get; set; }
 
+        [JsonProperty("nested_score_per_object")]
+        public double NestedScorePerObject { get; set; }
+
+        [JsonProperty("legacy_score_base_multiplier")]
+        public double LegacyScoreBaseMultiplier { get; set; }
+
+        [JsonProperty("maximum_legacy_combo_score")]
+        public double MaximumLegacyComboScore { get; set; }
+
         /// <summary>
         /// The beatmap's drain rate. This doesn't scale with rate-adjusting mods.
         /// </summary>
@@ -97,6 +122,11 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             yield return (ATTRIB_ID_SPEED_DIFFICULT_STRAIN_COUNT, SpeedDifficultStrainCount);
             yield return (ATTRIB_ID_SPEED_NOTE_COUNT, SpeedNoteCount);
             yield return (ATTRIB_ID_AIM_DIFFICULT_SLIDER_COUNT, AimDifficultSliderCount);
+            yield return (ATTRIB_ID_AIM_TOP_WEIGHTED_SLIDER_FACTOR, AimTopWeightedSliderFactor);
+            yield return (ATTRIB_ID_SPEED_TOP_WEIGHTED_SLIDER_FACTOR, SpeedTopWeightedSliderFactor);
+            yield return (ATTRIB_ID_NESTED_SCORE_PER_OBJECT, NestedScorePerObject);
+            yield return (ATTRIB_ID_LEGACY_SCORE_BASE_MULTIPLIER, LegacyScoreBaseMultiplier);
+            yield return (ATTRIB_ID_MAXIMUM_LEGACY_COMBO_SCORE, MaximumLegacyComboScore);
         }
 
         public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values, IBeatmapOnlineInfo onlineInfo)
@@ -112,6 +142,11 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             SpeedDifficultStrainCount = values[ATTRIB_ID_SPEED_DIFFICULT_STRAIN_COUNT];
             SpeedNoteCount = values[ATTRIB_ID_SPEED_NOTE_COUNT];
             AimDifficultSliderCount = values[ATTRIB_ID_AIM_DIFFICULT_SLIDER_COUNT];
+            AimTopWeightedSliderFactor = values[ATTRIB_ID_AIM_TOP_WEIGHTED_SLIDER_FACTOR];
+            SpeedTopWeightedSliderFactor = values[ATTRIB_ID_SPEED_TOP_WEIGHTED_SLIDER_FACTOR];
+            NestedScorePerObject = values[ATTRIB_ID_NESTED_SCORE_PER_OBJECT];
+            LegacyScoreBaseMultiplier = values[ATTRIB_ID_LEGACY_SCORE_BASE_MULTIPLIER];
+            MaximumLegacyComboScore = values[ATTRIB_ID_MAXIMUM_LEGACY_COMBO_SCORE];
             DrainRate = onlineInfo.DrainRate;
             HitCircleCount = onlineInfo.CircleCount;
             SliderCount = onlineInfo.SliderCount;

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

@@ -1,8 +1,6 @@
 // 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.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -13,14 +11,17 @@ using osu.Game.Rulesets.Difficulty.Skills;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Osu.Difficulty.Skills;
+using osu.Game.Rulesets.Osu.Difficulty.Utils;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Scoring;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Difficulty
 {
     public class OsuDifficultyCalculator : DifficultyCalculator
     {
-        private const double difficulty_multiplier = 0.0675;
+        private const double star_rating_multiplier = 0.0265;
 
         public override int Version => 20250306;
 
@@ -29,53 +30,84 @@ namespace osu.Game.Rulesets.Osu.Difficulty
         {
         }
 
+        public static double CalculateRateAdjustedApproachRate(double approachRate, double clockRate)
+        {
+            double preempt = IBeatmapDifficultyInfo.DifficultyRange(approachRate, OsuHitObject.PREEMPT_MAX, OsuHitObject.PREEMPT_MID, OsuHitObject.PREEMPT_MIN) / clockRate;
+            return IBeatmapDifficultyInfo.InverseDifficultyRange(preempt, OsuHitObject.PREEMPT_MAX, OsuHitObject.PREEMPT_MID, OsuHitObject.PREEMPT_MIN);
+        }
+
+        public static double CalculateRateAdjustedOverallDifficulty(double overallDifficulty, double clockRate)
+        {
+            HitWindows hitWindows = new OsuHitWindows();
+            hitWindows.SetDifficulty(overallDifficulty);
+
+            double hitWindowGreat = hitWindows.WindowFor(HitResult.Great) / clockRate;
+
+            return (79.5 - hitWindowGreat) / 6;
+        }
+
         protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
         {
             if (beatmap.HitObjects.Count == 0)
                 return new OsuDifficultyAttributes { Mods = mods };
 
             var aim = skills.OfType<Aim>().Single(a => a.IncludeSliders);
-            double aimRating = Math.Sqrt(aim.DifficultyValue()) * difficulty_multiplier;
-            double aimDifficultyStrainCount = aim.CountTopWeightedStrains();
+            var aimWithoutSliders = skills.OfType<Aim>().Single(a => !a.IncludeSliders);
+            var speed = skills.OfType<Speed>().Single();
+            var flashlight = skills.OfType<Flashlight>().SingleOrDefault();
+
+            double speedNotes = speed.RelevantNoteCount();
+
+            double aimDifficultStrainCount = aim.CountTopWeightedStrains();
+            double speedDifficultStrainCount = speed.CountTopWeightedStrains();
+
+            double aimNoSlidersTopWeightedSliderCount = aimWithoutSliders.CountTopWeightedSliders();
+            double aimNoSlidersDifficultStrainCount = aimWithoutSliders.CountTopWeightedStrains();
+
+            double aimTopWeightedSliderFactor = aimNoSlidersTopWeightedSliderCount / Math.Max(1, aimNoSlidersDifficultStrainCount - aimNoSlidersTopWeightedSliderCount);
+
+            double speedTopWeightedSliderCount = speed.CountTopWeightedSliders();
+            double speedTopWeightedSliderFactor = speedTopWeightedSliderCount / Math.Max(1, speedDifficultStrainCount - speedTopWeightedSliderCount);
+
             double difficultSliders = aim.GetDifficultSliders();
 
-            var aimWithoutSliders = skills.OfType<Aim>().Single(a => !a.IncludeSliders);
-            double aimRatingNoSliders = Math.Sqrt(aimWithoutSliders.DifficultyValue()) * difficulty_multiplier;
-            double sliderFactor = aimRating > 0 ? aimRatingNoSliders / aimRating : 1;
+            double approachRate = CalculateRateAdjustedApproachRate(beatmap.Difficulty.ApproachRate, clockRate);
+            double overallDifficulty = CalculateRateAdjustedOverallDifficulty(beatmap.Difficulty.OverallDifficulty, clockRate);
 
-            var speed = skills.OfType<Speed>().Single();
-            double speedRating = Math.Sqrt(speed.DifficultyValue()) * difficulty_multiplier;
-            double speedNotes = speed.RelevantNoteCount();
-            double speedDifficultyStrainCount = speed.CountTopWeightedStrains();
+            int hitCircleCount = 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);
 
-            var flashlight = skills.OfType<Flashlight>().SingleOrDefault();
-            double flashlightRating = flashlight == null ? 0.0 : Math.Sqrt(flashlight.DifficultyValue()) * difficulty_multiplier;
+            int totalHits = beatmap.HitObjects.Count;
 
-            if (mods.Any(m => m is OsuModTouchDevice))
-            {
-                aimRating = Math.Pow(aimRating, 0.8);
-                flashlightRating = Math.Pow(flashlightRating, 0.8);
-            }
+            double drainRate = beatmap.Difficulty.DrainRate;
 
-            if (mods.Any(h => h is OsuModRelax))
-            {
-                aimRating *= 0.9;
-                speedRating = 0.0;
-                flashlightRating *= 0.7;
-            }
-            else if (mods.Any(h => h is OsuModAutopilot))
-            {
-                speedRating *= 0.5;
-                aimRating = 0.0;
-                flashlightRating *= 0.4;
-            }
+            double aimDifficultyValue = aim.DifficultyValue();
+            double aimNoSlidersDifficultyValue = aimWithoutSliders.DifficultyValue();
+            double speedDifficultyValue = speed.DifficultyValue();
+
+            double mechanicalDifficultyRating = calculateMechanicalDifficultyRating(aimDifficultyValue, speedDifficultyValue);
+            double sliderFactor = aimDifficultyValue > 0 ? OsuRatingCalculator.CalculateDifficultyRating(aimNoSlidersDifficultyValue) / OsuRatingCalculator.CalculateDifficultyRating(aimDifficultyValue) : 1;
+
+            var osuRatingCalculator = new OsuRatingCalculator(mods, totalHits, approachRate, overallDifficulty, mechanicalDifficultyRating, sliderFactor);
+
+            double aimRating = osuRatingCalculator.ComputeAimRating(aimDifficultyValue);
+            double speedRating = osuRatingCalculator.ComputeSpeedRating(speedDifficultyValue);
+
+            double flashlightRating = 0.0;
+
+            if (flashlight is not null)
+                flashlightRating = osuRatingCalculator.ComputeFlashlightRating(flashlight.DifficultyValue());
+
+            double sliderNestedScorePerObject = LegacyScoreUtils.CalculateNestedScorePerObject(beatmap, totalHits);
+            double legacyScoreBaseMultiplier = LegacyScoreUtils.CalculateDifficultyPeppyStars(beatmap);
+
+            var simulator = new OsuLegacyScoreSimulator();
+            var scoreAttributes = simulator.Simulate(WorkingBeatmap, beatmap);
 
             double baseAimPerformance = OsuStrainSkill.DifficultyToPerformance(aimRating);
             double baseSpeedPerformance = OsuStrainSkill.DifficultyToPerformance(speedRating);
-            double baseFlashlightPerformance = 0.0;
-
-            if (mods.Any(h => h is OsuModFlashlight))
-                baseFlashlightPerformance = Flashlight.DifficultyToPerformance(flashlightRating);
+            double baseFlashlightPerformance = Flashlight.DifficultyToPerformance(flashlightRating);
 
             double basePerformance =
                 Math.Pow(
@@ -84,15 +116,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                     Math.Pow(baseFlashlightPerformance, 1.1), 1.0 / 1.1
                 );
 
-            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 drainRate = beatmap.Difficulty.DrainRate;
-
-            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 starRating = calculateStarRating(basePerformance);
 
             OsuDifficultyAttributes attributes = new OsuDifficultyAttributes
             {
@@ -104,18 +128,41 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                 SpeedNoteCount = speedNotes,
                 FlashlightDifficulty = flashlightRating,
                 SliderFactor = sliderFactor,
-                AimDifficultStrainCount = aimDifficultyStrainCount,
-                SpeedDifficultStrainCount = speedDifficultyStrainCount,
+                AimDifficultStrainCount = aimDifficultStrainCount,
+                SpeedDifficultStrainCount = speedDifficultStrainCount,
+                AimTopWeightedSliderFactor = aimTopWeightedSliderFactor,
+                SpeedTopWeightedSliderFactor = speedTopWeightedSliderFactor,
                 DrainRate = drainRate,
                 MaxCombo = beatmap.GetMaxCombo(),
-                HitCircleCount = hitCirclesCount,
+                HitCircleCount = hitCircleCount,
                 SliderCount = sliderCount,
                 SpinnerCount = spinnerCount,
+                NestedScorePerObject = sliderNestedScorePerObject,
+                LegacyScoreBaseMultiplier = legacyScoreBaseMultiplier,
+                MaximumLegacyComboScore = scoreAttributes.ComboScore
             };
 
             return attributes;
         }
 
+        private double calculateMechanicalDifficultyRating(double aimDifficultyValue, double speedDifficultyValue)
+        {
+            double aimValue = OsuStrainSkill.DifficultyToPerformance(OsuRatingCalculator.CalculateDifficultyRating(aimDifficultyValue));
+            double speedValue = OsuStrainSkill.DifficultyToPerformance(OsuRatingCalculator.CalculateDifficultyRating(speedDifficultyValue));
+
+            double totalValue = Math.Pow(Math.Pow(aimValue, 1.1) + Math.Pow(speedValue, 1.1), 1 / 1.1);
+
+            return calculateStarRating(totalValue);
+        }
+
+        private double calculateStarRating(double basePerformance)
+        {
+            if (basePerformance <= 0.00001)
+                return 0;
+
+            return Math.Cbrt(OsuPerformanceCalculator.PERFORMANCE_BASE_MULTIPLIER) * star_rating_multiplier * (Math.Cbrt(100000 / Math.Pow(2, 1 / 1.1) * basePerformance) + 4);
+        }
+
         protected override IEnumerable<DifficultyHitObject> CreateDifficultyHitObjects(IBeatmap beatmap, double clockRate)
         {
             List<DifficultyHitObject> objects = new List<DifficultyHitObject>();
@@ -124,8 +171,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             // If the map has less than two OsuHitObjects, the enumerator will not return anything.
             for (int i = 1; i < beatmap.HitObjects.Count; i++)
             {
-                var lastLast = i > 1 ? beatmap.HitObjects[i - 2] : null;
-                objects.Add(new OsuDifficultyHitObject(beatmap.HitObjects[i], beatmap.HitObjects[i - 1], lastLast, clockRate, objects, objects.Count));
+                objects.Add(new OsuDifficultyHitObject(beatmap.HitObjects[i], beatmap.HitObjects[i - 1], clockRate, objects, objects.Count));
             }
 
             return objects;
@@ -154,7 +200,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             new OsuModEasy(),
             new OsuModHardRock(),
             new OsuModFlashlight(),
-            new MultiMod(new OsuModFlashlight(), new OsuModHidden())
+            new OsuModHidden(),
         };
     }
 }

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

@@ -0,0 +1,200 @@
+// 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 System.Collections.Generic;
+using System.Linq;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+
+namespace osu.Game.Rulesets.Osu.Difficulty
+{
+    public class OsuLegacyScoreMissCalculator
+    {
+        private readonly ScoreInfo score;
+        private readonly OsuDifficultyAttributes attributes;
+
+        public OsuLegacyScoreMissCalculator(ScoreInfo scoreInfo, OsuDifficultyAttributes attributes)
+        {
+            score = scoreInfo;
+            this.attributes = attributes;
+        }
+
+        public double Calculate()
+        {
+            if (attributes.MaxCombo == 0 || score.LegacyTotalScore == null)
+                return 0;
+
+            double scoreV1Multiplier = attributes.LegacyScoreBaseMultiplier * getLegacyScoreMultiplier();
+            double relevantComboPerObject = calculateRelevantScoreComboPerObject();
+
+            double maximumMissCount = calculateMaximumComboBasedMissCount();
+
+            double scoreObtainedDuringMaxCombo = calculateScoreAtCombo(score.MaxCombo, relevantComboPerObject, scoreV1Multiplier);
+            double remainingScore = score.LegacyTotalScore.Value - scoreObtainedDuringMaxCombo;
+
+            if (remainingScore <= 0)
+                return maximumMissCount;
+
+            double remainingCombo = attributes.MaxCombo - score.MaxCombo;
+            double expectedRemainingScore = calculateScoreAtCombo(remainingCombo, relevantComboPerObject, scoreV1Multiplier);
+
+            double scoreBasedMissCount = expectedRemainingScore / remainingScore;
+
+            // If there's less then one miss detected - let combo-based miss count decide if this is FC or not
+            scoreBasedMissCount = Math.Max(scoreBasedMissCount, 1);
+
+            // Cap result by very harsh version of combo-based miss count
+            return Math.Min(scoreBasedMissCount, maximumMissCount);
+        }
+
+        /// <summary>
+        /// Calculates the amount of score that would be achieved at a given combo.
+        /// </summary>
+        private double calculateScoreAtCombo(double combo, double relevantComboPerObject, double scoreV1Multiplier)
+        {
+            int countGreat = score.Statistics.GetValueOrDefault(HitResult.Great);
+            int countOk = score.Statistics.GetValueOrDefault(HitResult.Ok);
+            int countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
+            int countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
+
+            int totalHits = countGreat + countOk + countMeh + countMiss;
+
+            double estimatedObjects = combo / relevantComboPerObject - 1;
+
+            // The combo portion of ScoreV1 follows arithmetic progression
+            // Therefore, we calculate the combo portion of score using the combo per object and our current combo.
+            double comboScore = relevantComboPerObject > 0 ? (2 * (relevantComboPerObject - 1) + (estimatedObjects - 1) * relevantComboPerObject) * estimatedObjects / 2 : 0;
+
+            // We then apply the accuracy and ScoreV1 multipliers to the resulting score.
+            comboScore *= score.Accuracy * 300 / 25 * scoreV1Multiplier;
+
+            double objectsHit = (totalHits - countMiss) * combo / attributes.MaxCombo;
+
+            // Score also has a non-combo portion we need to create the final score value.
+            double nonComboScore = (300 + attributes.NestedScorePerObject) * score.Accuracy * objectsHit;
+
+            return comboScore + nonComboScore;
+        }
+
+        /// <summary>
+        /// Calculates the relevant combo per object for legacy score.
+        /// This assumes a uniform distribution for circles and sliders.
+        /// This handles cases where objects (such as buzz sliders) do not fit a normal arithmetic progression model.
+        /// </summary>
+        private double calculateRelevantScoreComboPerObject()
+        {
+            double comboScore = attributes.MaximumLegacyComboScore;
+
+            // We then reverse apply the ScoreV1 multipliers to get the raw value.
+            comboScore /= 300.0 / 25.0 * attributes.LegacyScoreBaseMultiplier;
+
+            // Reverse the arithmetic progression to work out the amount of combo per object based on the score.
+            double result = (attributes.MaxCombo - 2) * attributes.MaxCombo;
+            result /= Math.Max(attributes.MaxCombo + 2 * (comboScore - 1), 1);
+
+            return result;
+        }
+
+        /// <summary>
+        /// This function is a harsher version of current combo-based miss count, used to provide reasonable value for cases where score-based miss count can't do this.
+        /// </summary>
+        private double calculateMaximumComboBasedMissCount()
+        {
+            int countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
+
+            if (attributes.SliderCount <= 0)
+                return countMiss;
+
+            int countOk = score.Statistics.GetValueOrDefault(HitResult.Ok);
+            int countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
+
+            int totalImperfectHits = countOk + countMeh + countMiss;
+
+            double missCount = 0;
+
+            // Consider that full combo is maximum combo minus dropped slider tails since they don't contribute to combo but also don't break it
+            // In classic scores we can't know the amount of dropped sliders so we estimate to 10% of all sliders on the map
+            double fullComboThreshold = attributes.MaxCombo - 0.1 * attributes.SliderCount;
+
+            if (score.MaxCombo < fullComboThreshold)
+                missCount = Math.Pow(fullComboThreshold / Math.Max(1.0, score.MaxCombo), 2.5);
+
+            // In classic scores there can't be more misses than a sum of all non-perfect judgements
+            missCount = Math.Min(missCount, totalImperfectHits);
+
+            // Every slider has *at least* 2 combo attributed in classic mechanics.
+            // If they broke on a slider with a tick, then this still works since they would have lost at least 2 combo (the tick and the end)
+            // Using this as a max means a score that loses 1 combo on a map can't possibly have been a slider break.
+            // It must have been a slider end.
+            int maxPossibleSliderBreaks = Math.Min(attributes.SliderCount, (attributes.MaxCombo - score.MaxCombo) / 2);
+
+            int scoreMissCount = score.Statistics.GetValueOrDefault(HitResult.Miss);
+
+            double sliderBreaks = missCount - scoreMissCount;
+
+            if (sliderBreaks > maxPossibleSliderBreaks)
+                missCount = scoreMissCount + maxPossibleSliderBreaks;
+
+            return missCount;
+        }
+
+        /// <remarks>
+        /// Logic copied from <see cref="OsuLegacyScoreSimulator.GetLegacyScoreMultiplier"/>.
+        /// </remarks>
+        private double getLegacyScoreMultiplier()
+        {
+            bool scoreV2 = score.Mods.Any(m => m is ModScoreV2);
+
+            double multiplier = 1.0;
+
+            foreach (var mod in score.Mods)
+            {
+                switch (mod)
+                {
+                    case OsuModNoFail:
+                        multiplier *= scoreV2 ? 1.0 : 0.5;
+                        break;
+
+                    case OsuModEasy:
+                        multiplier *= 0.5;
+                        break;
+
+                    case OsuModHalfTime:
+                    case OsuModDaycore:
+                        multiplier *= 0.3;
+                        break;
+
+                    case OsuModHidden:
+                        multiplier *= 1.06;
+                        break;
+
+                    case OsuModHardRock:
+                        multiplier *= scoreV2 ? 1.10 : 1.06;
+                        break;
+
+                    case OsuModDoubleTime:
+                    case OsuModNightcore:
+                        multiplier *= scoreV2 ? 1.20 : 1.12;
+                        break;
+
+                    case OsuModFlashlight:
+                        multiplier *= 1.12;
+                        break;
+
+                    case OsuModSpunOut:
+                        multiplier *= 0.9;
+                        break;
+
+                    case OsuModRelax:
+                    case OsuModAutopilot:
+                        return 0;
+                }
+            }
+
+            return multiplier;
+        }
+    }
+}

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

@@ -27,6 +27,18 @@ namespace osu.Game.Rulesets.Osu.Difficulty
         [JsonProperty("speed_deviation")]
         public double? SpeedDeviation { get; set; }
 
+        [JsonProperty("combo_based_estimated_miss_count")]
+        public double ComboBasedEstimatedMissCount { get; set; }
+
+        [JsonProperty("score_based_estimated_miss_count")]
+        public double? ScoreBasedEstimatedMissCount { get; set; }
+
+        [JsonProperty("aim_estimated_slider_breaks")]
+        public double AimEstimatedSliderBreaks { get; set; }
+
+        [JsonProperty("speed_estimated_slider_breaks")]
+        public double SpeedEstimatedSliderBreaks { get; set; }
+
         public override IEnumerable<PerformanceDisplayAttribute> GetAttributesForDisplay()
         {
             foreach (var attribute in base.GetAttributesForDisplay())

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

@@ -4,25 +4,25 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using osu.Framework.Audio.Track;
 using osu.Framework.Extensions.IEnumerableExtensions;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Difficulty.Utils;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Scoring;
+using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Osu.Difficulty.Skills;
 using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
+using osu.Game.Utils;
 
 namespace osu.Game.Rulesets.Osu.Difficulty
 {
     public class OsuPerformanceCalculator : PerformanceCalculator
     {
-        public const double PERFORMANCE_BASE_MULTIPLIER = 1.15; // This is being adjusted to keep the final pp value scaled around what it used to be when changing things.
+        public const double PERFORMANCE_BASE_MULTIPLIER = 1.14; // This is being adjusted to keep the final pp value scaled around what it used to be when changing things.
 
         private bool usingClassicSliderAccuracy;
+        private bool usingScoreV2;
 
         private double accuracy;
         private int scoreMaxCombo;
@@ -55,6 +55,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
         private double? speedDeviation;
 
+        private double aimEstimatedSliderBreaks;
+        private double speedEstimatedSliderBreaks;
+
         public OsuPerformanceCalculator()
             : base(new OsuRuleset())
         {
@@ -65,6 +68,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             var osuAttributes = (OsuDifficultyAttributes)attributes;
 
             usingClassicSliderAccuracy = score.Mods.OfType<OsuModClassic>().Any(m => m.NoSliderHeadAccuracy.Value);
+            usingScoreV2 = score.Mods.Any(m => m is ModScoreV2);
 
             accuracy = score.Accuracy;
             scoreMaxCombo = score.MaxCombo;
@@ -80,9 +84,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
             score.Mods.OfType<IApplicableToDifficulty>().ForEach(m => m.ApplyToDifficulty(difficulty));
 
-            var track = new TrackVirtual(10000);
-            score.Mods.OfType<IApplicableToTrack>().ForEach(m => m.ApplyToTrack(track));
-            clockRate = track.Rate;
+            clockRate = ModUtils.CalculateRateWithMods(score.Mods);
 
             HitWindows hitWindows = new OsuHitWindows();
             hitWindows.SetDifficulty(difficulty.OverallDifficulty);
@@ -91,35 +93,23 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             okHitWindow = hitWindows.WindowFor(HitResult.Ok) / clockRate;
             mehHitWindow = hitWindows.WindowFor(HitResult.Meh) / clockRate;
 
-            double preempt = IBeatmapDifficultyInfo.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
+            approachRate = OsuDifficultyCalculator.CalculateRateAdjustedApproachRate(difficulty.ApproachRate, clockRate);
+            overallDifficulty = OsuDifficultyCalculator.CalculateRateAdjustedOverallDifficulty(difficulty.OverallDifficulty, clockRate);
 
-            overallDifficulty = (79.5 - greatHitWindow) / 6;
-            approachRate = preempt > 1200 ? (1800 - preempt) / 120 : (1200 - preempt) / 150 + 5;
+            double comboBasedEstimatedMissCount = calculateComboBasedEstimatedMissCount(osuAttributes);
+            double? scoreBasedEstimatedMissCount = null;
 
-            if (osuAttributes.SliderCount > 0)
+            if (usingClassicSliderAccuracy && score.LegacyTotalScore != null)
             {
-                if (usingClassicSliderAccuracy)
-                {
-                    // Consider that full combo is maximum combo minus dropped slider tails since they don't contribute to combo but also don't break it
-                    // In classic scores we can't know the amount of dropped sliders so we estimate to 10% of all sliders on the map
-                    double fullComboThreshold = attributes.MaxCombo - 0.1 * osuAttributes.SliderCount;
+                var legacyScoreMissCalculator = new OsuLegacyScoreMissCalculator(score, osuAttributes);
+                scoreBasedEstimatedMissCount = legacyScoreMissCalculator.Calculate();
 
-                    if (scoreMaxCombo < fullComboThreshold)
-                        effectiveMissCount = fullComboThreshold / Math.Max(1.0, scoreMaxCombo);
-
-                    // In classic scores there can't be more misses than a sum of all non-perfect judgements
-                    effectiveMissCount = Math.Min(effectiveMissCount, totalImperfectHits);
-                }
-                else
-                {
-                    double fullComboThreshold = attributes.MaxCombo - countSliderEndsDropped;
-
-                    if (scoreMaxCombo < fullComboThreshold)
-                        effectiveMissCount = fullComboThreshold / Math.Max(1.0, scoreMaxCombo);
-
-                    // Combine regular misses with tick misses since tick misses break combo as well
-                    effectiveMissCount = Math.Min(effectiveMissCount, countSliderTickMiss + countMiss);
-                }
+                effectiveMissCount = scoreBasedEstimatedMissCount.Value;
+            }
+            else
+            {
+                // Use combo-based miss count if this isn't a legacy score
+                effectiveMissCount = comboBasedEstimatedMissCount;
             }
 
             effectiveMissCount = Math.Max(countMiss, effectiveMissCount);
@@ -135,10 +125,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
             if (score.Mods.Any(h => h is OsuModRelax))
             {
-                // https://www.desmos.com/calculator/bc9eybdthb
+                // https://www.desmos.com/calculator/vspzsop6td
                 // we use OD13.3 as maximum since it's the value at which great hitwidow becomes 0
                 // this is well beyond currently maximum achievable OD which is 12.17 (DTx2 + DA with OD11)
-                double okMultiplier = Math.Max(0.0, overallDifficulty > 0.0 ? 1 - Math.Pow(overallDifficulty / 13.33, 1.8) : 1.0);
+                double okMultiplier = 0.75 * Math.Max(0.0, overallDifficulty > 0.0 ? 1 - overallDifficulty / 13.33 : 1.0);
                 double mehMultiplier = Math.Max(0.0, overallDifficulty > 0.0 ? 1 - Math.Pow(overallDifficulty / 13.33, 5) : 1.0);
 
                 // As we're adding Oks and Mehs to an approximated number of combo breaks the result can be higher than total hits in specific scenarios (which breaks some calculations) so we need to clamp it.
@@ -167,6 +157,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                 Accuracy = accuracyValue,
                 Flashlight = flashlightValue,
                 EffectiveMissCount = effectiveMissCount,
+                ComboBasedEstimatedMissCount = comboBasedEstimatedMissCount,
+                ScoreBasedEstimatedMissCount = scoreBasedEstimatedMissCount,
+                AimEstimatedSliderBreaks = aimEstimatedSliderBreaks,
+                SpeedEstimatedSliderBreaks = speedEstimatedSliderBreaks,
                 SpeedDeviation = speedDeviation,
                 Total = totalValue
             };
@@ -207,30 +201,23 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             aimValue *= lengthBonus;
 
             if (effectiveMissCount > 0)
-                aimValue *= calculateMissPenalty(effectiveMissCount, attributes.AimDifficultStrainCount);
+            {
+                aimEstimatedSliderBreaks = calculateEstimatedSliderBreaks(attributes.AimTopWeightedSliderFactor, attributes);
 
-            double approachRateFactor = 0.0;
-            if (approachRate > 10.33)
-                approachRateFactor = 0.3 * (approachRate - 10.33);
-            else if (approachRate < 8.0)
-                approachRateFactor = 0.05 * (8.0 - approachRate);
+                double relevantMissCount = Math.Min(effectiveMissCount + aimEstimatedSliderBreaks, totalImperfectHits + countSliderTickMiss);
 
-            if (score.Mods.Any(h => h is OsuModRelax))
-                approachRateFactor = 0.0;
-
-            aimValue *= 1.0 + approachRateFactor * lengthBonus; // Buff for longer maps with high AR.
+                aimValue *= calculateMissPenalty(relevantMissCount, attributes.AimDifficultStrainCount);
+            }
 
+            // TC bonuses are excluded when blinds is present as the increased visual difficulty is unimportant when notes cannot be seen.
             if (score.Mods.Any(m => m is OsuModBlinds))
                 aimValue *= 1.3 + (totalHits * (0.0016 / (1 + 2 * effectiveMissCount)) * Math.Pow(accuracy, 16)) * (1 - 0.003 * attributes.DrainRate * attributes.DrainRate);
-            else if (score.Mods.Any(m => m is OsuModHidden || m is OsuModTraceable))
+            else if (score.Mods.Any(m => m is OsuModTraceable))
             {
-                // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
-                aimValue *= 1.0 + 0.04 * (12.0 - approachRate);
+                aimValue *= 1.0 + OsuRatingCalculator.CalculateVisibilityBonus(score.Mods, approachRate, attributes.SliderFactor);
             }
 
             aimValue *= accuracy;
-            // It is important to consider accuracy difficulty when scaling with accuracy.
-            aimValue *= 0.98 + Math.Pow(Math.Max(0, overallDifficulty), 2) / 2500;
 
             return aimValue;
         }
@@ -247,26 +234,23 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             speedValue *= lengthBonus;
 
             if (effectiveMissCount > 0)
-                speedValue *= calculateMissPenalty(effectiveMissCount, attributes.SpeedDifficultStrainCount);
+            {
+                speedEstimatedSliderBreaks = calculateEstimatedSliderBreaks(attributes.SpeedTopWeightedSliderFactor, attributes);
 
-            double approachRateFactor = 0.0;
-            if (approachRate > 10.33)
-                approachRateFactor = 0.3 * (approachRate - 10.33);
+                double relevantMissCount = Math.Min(effectiveMissCount + speedEstimatedSliderBreaks, totalImperfectHits + countSliderTickMiss);
 
-            if (score.Mods.Any(h => h is OsuModAutopilot))
-                approachRateFactor = 0.0;
-
-            speedValue *= 1.0 + approachRateFactor * lengthBonus; // Buff for longer maps with high AR.
+                speedValue *= calculateMissPenalty(relevantMissCount, attributes.SpeedDifficultStrainCount);
+            }
 
+            // TC bonuses are excluded when blinds is present as the increased visual difficulty is unimportant when notes cannot be seen.
             if (score.Mods.Any(m => m is OsuModBlinds))
             {
                 // Increasing the speed value by object count for Blinds isn't ideal, so the minimum buff is given.
                 speedValue *= 1.12;
             }
-            else if (score.Mods.Any(m => m is OsuModHidden || m is OsuModTraceable))
+            else if (score.Mods.Any(m => m is OsuModTraceable))
             {
-                // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
-                speedValue *= 1.0 + 0.04 * (12.0 - approachRate);
+                speedValue *= 1.0 + OsuRatingCalculator.CalculateVisibilityBonus(score.Mods, approachRate);
             }
 
             double speedHighDeviationMultiplier = calculateSpeedHighDeviationNerf(attributes);
@@ -280,7 +264,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             double relevantAccuracy = attributes.SpeedNoteCount == 0 ? 0 : (relevantCountGreat * 6.0 + relevantCountOk * 2.0 + relevantCountMeh) / (attributes.SpeedNoteCount * 6.0);
 
             // Scale the speed value with accuracy and OD.
-            speedValue *= (0.95 + Math.Pow(Math.Max(0, overallDifficulty), 2) / 750) * Math.Pow((accuracy + relevantAccuracy) / 2.0, (14.5 - overallDifficulty) / 2);
+            speedValue *= Math.Pow((accuracy + relevantAccuracy) / 2.0, (14.5 - overallDifficulty) / 2);
 
             return speedValue;
         }
@@ -293,7 +277,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             // This percentage only considers HitCircles of any value - in this part of the calculation we focus on hitting the timing hit window.
             double betterAccuracyPercentage;
             int amountHitObjectsWithAccuracy = attributes.HitCircleCount;
-            if (!usingClassicSliderAccuracy)
+            if (!usingClassicSliderAccuracy || usingScoreV2)
                 amountHitObjectsWithAccuracy += attributes.SliderCount;
 
             if (amountHitObjectsWithAccuracy > 0)
@@ -316,7 +300,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             if (score.Mods.Any(m => m is OsuModBlinds))
                 accuracyValue *= 1.14;
             else if (score.Mods.Any(m => m is OsuModHidden || m is OsuModTraceable))
-                accuracyValue *= 1.08;
+            {
+                // Decrease bonus for AR > 10
+                accuracyValue *= 1 + 0.08 * DifficultyCalculationUtils.ReverseLerp(approachRate, 11.5, 10);
+            }
 
             if (score.Mods.Any(m => m is OsuModFlashlight))
                 accuracyValue *= 1.02;
@@ -337,18 +324,73 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
             flashlightValue *= getComboScalingFactor(attributes);
 
-            // Account for shorter maps having a higher ratio of 0 combo/100 combo flashlight radius.
-            flashlightValue *= 0.7 + 0.1 * Math.Min(1.0, totalHits / 200.0) +
-                               (totalHits > 200 ? 0.2 * Math.Min(1.0, (totalHits - 200) / 200.0) : 0.0);
-
             // Scale the flashlight value with accuracy _slightly_.
             flashlightValue *= 0.5 + accuracy / 2.0;
-            // It is important to also consider accuracy difficulty when doing that.
-            flashlightValue *= 0.98 + Math.Pow(Math.Max(0, overallDifficulty), 2) / 2500;
 
             return flashlightValue;
         }
 
+        private double calculateComboBasedEstimatedMissCount(OsuDifficultyAttributes attributes)
+        {
+            if (attributes.SliderCount <= 0)
+                return countMiss;
+
+            double missCount = countMiss;
+
+            if (usingClassicSliderAccuracy)
+            {
+                // Consider that full combo is maximum combo minus dropped slider tails since they don't contribute to combo but also don't break it
+                // In classic scores we can't know the amount of dropped sliders so we estimate to 10% of all sliders on the map
+                double fullComboThreshold = attributes.MaxCombo - 0.1 * attributes.SliderCount;
+
+                if (scoreMaxCombo < fullComboThreshold)
+                    missCount = fullComboThreshold / Math.Max(1.0, scoreMaxCombo);
+
+                // In classic scores there can't be more misses than a sum of all non-perfect judgements
+                missCount = Math.Min(missCount, totalImperfectHits);
+
+                // Every slider has *at least* 2 combo attributed in classic mechanics.
+                // If they broke on a slider with a tick, then this still works since they would have lost at least 2 combo (the tick and the end)
+                // Using this as a max means a score that loses 1 combo on a map can't possibly have been a slider break.
+                // It must have been a slider end.
+                int maxPossibleSliderBreaks = Math.Min(attributes.SliderCount, (attributes.MaxCombo - scoreMaxCombo) / 2);
+
+                double sliderBreaks = missCount - countMiss;
+
+                if (sliderBreaks > maxPossibleSliderBreaks)
+                    missCount = countMiss + maxPossibleSliderBreaks;
+            }
+            else
+            {
+                double fullComboThreshold = attributes.MaxCombo - countSliderEndsDropped;
+
+                if (scoreMaxCombo < fullComboThreshold)
+                    missCount = fullComboThreshold / Math.Max(1.0, scoreMaxCombo);
+
+                // Combine regular misses with tick misses since tick misses break combo as well
+                missCount = Math.Min(missCount, countSliderTickMiss + countMiss);
+            }
+
+            return missCount;
+        }
+
+        private double calculateEstimatedSliderBreaks(double topWeightedSliderFactor, OsuDifficultyAttributes attributes)
+        {
+            if (!usingClassicSliderAccuracy || countOk == 0)
+                return 0;
+
+            double missedComboPercent = 1.0 - (double)scoreMaxCombo / attributes.MaxCombo;
+            double estimatedSliderBreaks = Math.Min(countOk, effectiveMissCount * topWeightedSliderFactor);
+
+            // Scores with more Oks are more likely to have slider breaks.
+            double okAdjustment = ((countOk - estimatedSliderBreaks) + 0.5) / countOk;
+
+            // There is a low probability of extra slider breaks on effective miss counts close to 1, as score based calculations are good at indicating if only a single break occurred.
+            estimatedSliderBreaks *= DifficultyCalculationUtils.Smoothstep(effectiveMissCount, 1, 2);
+
+            return estimatedSliderBreaks * okAdjustment * DifficultyCalculationUtils.Logistic(missedComboPercent, 0.33, 15);
+        }
+
         /// <summary>
         /// Estimates player's deviation on speed notes using <see cref="calculateDeviation"/>, assuming worst-case.
         /// Treats all speed notes as hit circles.
@@ -368,7 +410,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             double relevantCountOk = Math.Min(countOk, speedNoteCount - relevantCountMiss - relevantCountMeh);
             double relevantCountGreat = Math.Max(0, speedNoteCount - relevantCountMiss - relevantCountMeh - relevantCountOk);
 
-            return calculateDeviation(attributes, relevantCountGreat, relevantCountOk, relevantCountMeh, relevantCountMiss);
+            return calculateDeviation(relevantCountGreat, relevantCountOk, relevantCountMeh);
         }
 
         /// <summary>
@@ -377,45 +419,45 @@ namespace osu.Game.Rulesets.Osu.Difficulty
         /// will always return the same deviation. Misses are ignored because they are usually due to misaiming.
         /// Greats and oks are assumed to follow a normal distribution, whereas mehs are assumed to follow a uniform distribution.
         /// </summary>
-        private double? calculateDeviation(OsuDifficultyAttributes attributes, double relevantCountGreat, double relevantCountOk, double relevantCountMeh, double relevantCountMiss)
+        private double? calculateDeviation(double relevantCountGreat, double relevantCountOk, double relevantCountMeh)
         {
             if (relevantCountGreat + relevantCountOk + relevantCountMeh <= 0)
                 return null;
 
-            double objectCount = relevantCountGreat + relevantCountOk + relevantCountMeh + relevantCountMiss;
-
-            // The probability that a player hits a circle is unknown, but we can estimate it to be
-            // the number of greats on circles divided by the number of circles, and then add one
-            // to the number of circles as a bias correction.
-            double n = Math.Max(1, objectCount - relevantCountMiss - relevantCountMeh);
-            const double z = 2.32634787404; // 99% critical value for the normal distribution (one-tailed).
-
-            // Proportion of greats hit on circles, ignoring misses and 50s.
+            // The sample proportion of successful hits.
+            double n = Math.Max(1, relevantCountGreat + relevantCountOk);
             double p = relevantCountGreat / n;
 
-            // We can be 99% confident that p is at least this value.
-            double pLowerBound = (n * p + z * z / 2) / (n + z * z) - z / (n + z * z) * Math.Sqrt(n * p * (1 - p) + z * z / 4);
+            // 99% critical value for the normal distribution (one-tailed).
+            const double z = 2.32634787404;
 
-            // Compute the deviation assuming greats and oks are normally distributed, and mehs are uniformly distributed.
-            // Begin with greats and oks first. Ignoring mehs, we can be 99% confident that the deviation is not higher than:
-            double deviation = greatHitWindow / (Math.Sqrt(2) * DifficultyCalculationUtils.ErfInv(pLowerBound));
+            // We can be 99% confident that the population proportion is at least this value.
+            double pLowerBound = Math.Min(p, (n * p + z * z / 2) / (n + z * z) - z / (n + z * z) * Math.Sqrt(n * p * (1 - p) + z * z / 4));
 
-            double randomValue = Math.Sqrt(2 / Math.PI) * okHitWindow * Math.Exp(-0.5 * Math.Pow(okHitWindow / deviation, 2))
-                                 / (deviation * DifficultyCalculationUtils.Erf(okHitWindow / (Math.Sqrt(2) * deviation)));
+            double deviation;
 
-            deviation *= Math.Sqrt(1 - randomValue);
+            // Tested max precision for the deviation calculation.
+            if (pLowerBound > 0.01)
+            {
+                // Compute deviation assuming greats and oks are normally distributed.
+                deviation = greatHitWindow / (Math.Sqrt(2) * DifficultyCalculationUtils.ErfInv(pLowerBound));
 
-            // Value deviation approach as greatCount approaches 0
-            double limitValue = okHitWindow / Math.Sqrt(3);
+                // Subtract the deviation provided by tails that land outside the ok hit window from the deviation computed above.
+                // This is equivalent to calculating the deviation of a normal distribution truncated at +-okHitWindow.
+                double okHitWindowTailAmount = Math.Sqrt(2 / Math.PI) * okHitWindow * Math.Exp(-0.5 * Math.Pow(okHitWindow / deviation, 2))
+                                               / (deviation * DifficultyCalculationUtils.Erf(okHitWindow / (Math.Sqrt(2) * deviation)));
 
-            // If precision is not enough to compute true deviation - use limit value
-            if (pLowerBound == 0 || randomValue >= 1 || deviation > limitValue)
-                deviation = limitValue;
+                deviation *= Math.Sqrt(1 - okHitWindowTailAmount);
+            }
+            else
+            {
+                // A tested limit value for the case of a score only containing oks.
+                deviation = okHitWindow / Math.Sqrt(3);
+            }
 
-            // Then compute the variance for mehs.
+            // Compute and add the variance for mehs, assuming that they are uniformly distributed.
             double mehVariance = (mehHitWindow * mehHitWindow + okHitWindow * mehHitWindow + okHitWindow * okHitWindow) / 3;
 
-            // Find the total deviation.
             deviation = Math.Sqrt(((relevantCountGreat + relevantCountOk) * Math.Pow(deviation, 2) + relevantCountMeh * mehVariance) / (relevantCountGreat + relevantCountOk + relevantCountMeh));
 
             return deviation;

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

@@ -0,0 +1,210 @@
+// 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 System.Linq;
+using osu.Game.Rulesets.Difficulty.Utils;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
+
+namespace osu.Game.Rulesets.Osu.Difficulty
+{
+    public class OsuRatingCalculator
+    {
+        private const double difficulty_multiplier = 0.0675;
+
+        private readonly Mod[] mods;
+        private readonly int totalHits;
+        private readonly double approachRate;
+        private readonly double overallDifficulty;
+        private readonly double mechanicalDifficultyRating;
+        private readonly double sliderFactor;
+
+        public OsuRatingCalculator(Mod[] mods, int totalHits, double approachRate, double overallDifficulty, double mechanicalDifficultyRating, double sliderFactor)
+        {
+            this.mods = mods;
+            this.totalHits = totalHits;
+            this.approachRate = approachRate;
+            this.overallDifficulty = overallDifficulty;
+            this.mechanicalDifficultyRating = mechanicalDifficultyRating;
+            this.sliderFactor = sliderFactor;
+        }
+
+        public double ComputeAimRating(double aimDifficultyValue)
+        {
+            if (mods.Any(m => m is OsuModAutopilot))
+                return 0;
+
+            double aimRating = CalculateDifficultyRating(aimDifficultyValue);
+
+            if (mods.Any(m => m is OsuModTouchDevice))
+                aimRating = Math.Pow(aimRating, 0.8);
+
+            if (mods.Any(m => m is OsuModRelax))
+                aimRating *= 0.9;
+
+            if (mods.Any(m => m is OsuModMagnetised))
+            {
+                float magnetisedStrength = mods.OfType<OsuModMagnetised>().First().AttractionStrength.Value;
+                aimRating *= 1.0 - magnetisedStrength;
+            }
+
+            double ratingMultiplier = 1.0;
+
+            double approachRateLengthBonus = 0.95 + 0.4 * Math.Min(1.0, totalHits / 2000.0) +
+                                             (totalHits > 2000 ? Math.Log10(totalHits / 2000.0) * 0.5 : 0.0);
+
+            double approachRateFactor = 0.0;
+            if (approachRate > 10.33)
+                approachRateFactor = 0.3 * (approachRate - 10.33);
+            else if (approachRate < 8.0)
+                approachRateFactor = 0.05 * (8.0 - approachRate);
+
+            if (mods.Any(h => h is OsuModRelax))
+                approachRateFactor = 0.0;
+
+            ratingMultiplier += approachRateFactor * approachRateLengthBonus; // Buff for longer maps with high AR.
+
+            if (mods.Any(m => m is OsuModHidden))
+            {
+                double visibilityFactor = calculateAimVisibilityFactor(approachRate);
+                ratingMultiplier += CalculateVisibilityBonus(mods, approachRate, visibilityFactor, sliderFactor);
+            }
+
+            // It is important to consider accuracy difficulty when scaling with accuracy.
+            ratingMultiplier *= 0.98 + Math.Pow(Math.Max(0, overallDifficulty), 2) / 2500;
+
+            return aimRating * Math.Cbrt(ratingMultiplier);
+        }
+
+        public double ComputeSpeedRating(double speedDifficultyValue)
+        {
+            if (mods.Any(m => m is OsuModRelax))
+                return 0;
+
+            double speedRating = CalculateDifficultyRating(speedDifficultyValue);
+
+            if (mods.Any(m => m is OsuModAutopilot))
+                speedRating *= 0.5;
+
+            if (mods.Any(m => m is OsuModMagnetised))
+            {
+                // reduce speed rating because of the speed distance scaling, with maximum reduction being 0.7x
+                float magnetisedStrength = mods.OfType<OsuModMagnetised>().First().AttractionStrength.Value;
+                speedRating *= 1.0 - magnetisedStrength * 0.3;
+            }
+
+            double ratingMultiplier = 1.0;
+
+            double approachRateLengthBonus = 0.95 + 0.4 * Math.Min(1.0, totalHits / 2000.0) +
+                                             (totalHits > 2000 ? Math.Log10(totalHits / 2000.0) * 0.5 : 0.0);
+
+            double approachRateFactor = 0.0;
+            if (approachRate > 10.33)
+                approachRateFactor = 0.3 * (approachRate - 10.33);
+
+            if (mods.Any(m => m is OsuModAutopilot))
+                approachRateFactor = 0.0;
+
+            ratingMultiplier += approachRateFactor * approachRateLengthBonus; // Buff for longer maps with high AR.
+
+            if (mods.Any(m => m is OsuModHidden))
+            {
+                double visibilityFactor = calculateSpeedVisibilityFactor(approachRate);
+                ratingMultiplier += CalculateVisibilityBonus(mods, approachRate, visibilityFactor);
+            }
+
+            ratingMultiplier *= 0.95 + Math.Pow(Math.Max(0, overallDifficulty), 2) / 750;
+
+            return speedRating * Math.Cbrt(ratingMultiplier);
+        }
+
+        public double ComputeFlashlightRating(double flashlightDifficultyValue)
+        {
+            if (!mods.Any(m => m is OsuModFlashlight))
+                return 0;
+
+            double flashlightRating = CalculateDifficultyRating(flashlightDifficultyValue);
+
+            if (mods.Any(m => m is OsuModTouchDevice))
+                flashlightRating = Math.Pow(flashlightRating, 0.8);
+
+            if (mods.Any(m => m is OsuModRelax))
+                flashlightRating *= 0.7;
+            else if (mods.Any(m => m is OsuModAutopilot))
+                flashlightRating *= 0.4;
+
+            if (mods.Any(m => m is OsuModMagnetised))
+            {
+                float magnetisedStrength = mods.OfType<OsuModMagnetised>().First().AttractionStrength.Value;
+                flashlightRating *= 1.0 - magnetisedStrength;
+            }
+
+            if (mods.Any(m => m is OsuModDeflate))
+            {
+                float deflateInitialScale = mods.OfType<OsuModDeflate>().First().StartScale.Value;
+                flashlightRating *= Math.Clamp(DifficultyCalculationUtils.ReverseLerp(deflateInitialScale, 11, 1), 0.1, 1);
+            }
+
+            double ratingMultiplier = 1.0;
+
+            // Account for shorter maps having a higher ratio of 0 combo/100 combo flashlight radius.
+            ratingMultiplier *= 0.7 + 0.1 * Math.Min(1.0, totalHits / 200.0) +
+                                (totalHits > 200 ? 0.2 * Math.Min(1.0, (totalHits - 200) / 200.0) : 0.0);
+
+            // It is important to consider accuracy difficulty when scaling with accuracy.
+            ratingMultiplier *= 0.98 + Math.Pow(Math.Max(0, overallDifficulty), 2) / 2500;
+
+            return flashlightRating * Math.Sqrt(ratingMultiplier);
+        }
+
+        private double calculateAimVisibilityFactor(double approachRate)
+        {
+            const double ar_factor_end_point = 11.5;
+
+            double mechanicalDifficultyFactor = DifficultyCalculationUtils.ReverseLerp(mechanicalDifficultyRating, 5, 10);
+            double arFactorStartingPoint = double.Lerp(9, 10.33, mechanicalDifficultyFactor);
+
+            return DifficultyCalculationUtils.ReverseLerp(approachRate, ar_factor_end_point, arFactorStartingPoint);
+        }
+
+        private double calculateSpeedVisibilityFactor(double approachRate)
+        {
+            const double ar_factor_end_point = 11.5;
+
+            double mechanicalDifficultyFactor = DifficultyCalculationUtils.ReverseLerp(mechanicalDifficultyRating, 5, 10);
+            double arFactorStartingPoint = double.Lerp(10, 10.33, mechanicalDifficultyFactor);
+
+            return DifficultyCalculationUtils.ReverseLerp(approachRate, ar_factor_end_point, arFactorStartingPoint);
+        }
+
+        /// <summary>
+        /// Calculates a visibility bonus that is applicable to Hidden and Traceable.
+        /// </summary>
+        public static double CalculateVisibilityBonus(Mod[] mods, double approachRate, double visibilityFactor = 1, double sliderFactor = 1)
+        {
+            // NOTE: TC's effect is only noticeable in performance calculations until lazer mods are accounted for server-side.
+            bool isAlwaysPartiallyVisible = mods.OfType<OsuModHidden>().Any(m => m.OnlyFadeApproachCircles.Value) || mods.OfType<OsuModTraceable>().Any();
+
+            // Start from normal curve, rewarding lower AR up to AR7
+            double readingBonus = 0.04 * (12.0 - Math.Max(approachRate, 7));
+
+            readingBonus *= visibilityFactor;
+
+            // We want to reward slideraim on low AR less
+            double sliderVisibilityFactor = Math.Pow(sliderFactor, 3);
+
+            // For AR up to 0 - reduce reward for very low ARs when object is visible
+            if (approachRate < 7)
+                readingBonus += (isAlwaysPartiallyVisible ? 0.03 : 0.045) * (7.0 - Math.Max(approachRate, 0)) * sliderVisibilityFactor;
+
+            // Starting from AR0 - cap values so they won't grow to infinity
+            if (approachRate < 0)
+                readingBonus += (isAlwaysPartiallyVisible ? 0.075 : 0.1) * (1 - Math.Pow(1.5, approachRate)) * sliderVisibilityFactor;
+
+            return readingBonus;
+        }
+
+        public static double CalculateDifficultyRating(double difficultyValue) => Math.Sqrt(difficultyValue) * difficulty_multiplier;
+    }
+}

osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs

@@ -28,11 +28,12 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
         private const float assumed_slider_radius = NORMALISED_RADIUS * 1.8f;
 
         protected new OsuHitObject BaseObject => (OsuHitObject)base.BaseObject;
+        protected new OsuHitObject LastObject => (OsuHitObject)base.LastObject;
 
         /// <summary>
-        /// Milliseconds elapsed since the start time of the previous <see cref="OsuDifficultyHitObject"/>, with a minimum of 25ms.
+        /// <see cref="DifficultyHitObject.DeltaTime"/> capped to a minimum of <see cref="MIN_DELTA_TIME"/>ms.
         /// </summary>
-        public readonly double StrainTime;
+        public readonly double AdjustedDeltaTime;
 
         /// <summary>
         /// Normalised distance from the "lazy" end position of the previous <see cref="OsuDifficultyHitObject"/> to the start position of this <see cref="OsuDifficultyHitObject"/>.
@@ -75,6 +76,24 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
         /// </summary>
         public double TravelTime { get; private set; }
 
+        /// <summary>
+        /// The position of the cursor at the point of completion of this <see cref="OsuDifficultyHitObject"/> if it is a <see cref="Slider"/>
+        /// and was hit with as few movements as possible.
+        /// </summary>
+        public Vector2? LazyEndPosition { get; private set; }
+
+        /// <summary>
+        /// The distance travelled by the cursor upon completion of this <see cref="OsuDifficultyHitObject"/> if it is a <see cref="Slider"/>
+        /// and was hit with as few movements as possible.
+        /// </summary>
+        public double LazyTravelDistance { get; private set; }
+
+        /// <summary>
+        /// The time taken by the cursor upon completion of this <see cref="OsuDifficultyHitObject"/> if it is a <see cref="Slider"/>
+        /// and was hit with as few movements as possible.
+        /// </summary>
+        public double LazyTravelTime { get; private set; }
+
         /// <summary>
         /// Angle the player has to take to hit this <see cref="OsuDifficultyHitObject"/>.
         /// Calculated as the angle between the circles (current-2, current-1, current).
@@ -86,17 +105,24 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
         /// </summary>
         public double HitWindowGreat { get; private set; }
 
-        private readonly OsuHitObject? lastLastObject;
-        private readonly OsuHitObject lastObject;
+        /// <summary>
+        /// Selective bonus for maps with higher circle size.
+        /// </summary>
+        public double SmallCircleBonus { get; private set; }
 
-        public OsuDifficultyHitObject(HitObject hitObject, HitObject lastObject, HitObject? lastLastObject, double clockRate, List<DifficultyHitObject> objects, int index)
+        private readonly OsuDifficultyHitObject? lastLastDifficultyObject;
+        private readonly OsuDifficultyHitObject? lastDifficultyObject;
+
+        public OsuDifficultyHitObject(HitObject hitObject, HitObject lastObject, double clockRate, List<DifficultyHitObject> objects, int index)
             : base(hitObject, lastObject, clockRate, objects, index)
         {
-            this.lastLastObject = lastLastObject as OsuHitObject;
-            this.lastObject = (OsuHitObject)lastObject;
+            lastLastDifficultyObject = index > 1 ? (OsuDifficultyHitObject)objects[index - 2] : null;
+            lastDifficultyObject = index > 0 ? (OsuDifficultyHitObject)objects[index - 1] : null;
 
             // Capped to 25ms to prevent difficulty calculation breaking from simultaneous objects.
-            StrainTime = Math.Max(DeltaTime, MIN_DELTA_TIME);
+            AdjustedDeltaTime = Math.Max(DeltaTime, MIN_DELTA_TIME);
+
+            SmallCircleBonus = Math.Max(1.0, 1.0 + (30 - BaseObject.Radius) / 40);
 
             if (BaseObject is Slider sliderObject)
             {
@@ -107,6 +133,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
                 HitWindowGreat = 2 * BaseObject.HitWindows.WindowFor(HitResult.Great) / clockRate;
             }
 
+            computeSliderCursorPosition();
             setDistances(clockRate);
         }
 
@@ -161,35 +188,28 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
         {
             if (BaseObject is Slider currentSlider)
             {
-                computeSliderCursorPosition(currentSlider);
                 // Bonus for repeat sliders until a better per nested object strain system can be achieved.
-                TravelDistance = currentSlider.LazyTravelDistance * (float)Math.Pow(1 + currentSlider.RepeatCount / 2.5, 1.0 / 2.5);
-                TravelTime = Math.Max(currentSlider.LazyTravelTime / clockRate, MIN_DELTA_TIME);
+                TravelDistance = LazyTravelDistance * Math.Pow(1 + currentSlider.RepeatCount / 2.5, 1.0 / 2.5);
+                TravelTime = Math.Max(LazyTravelTime / clockRate, MIN_DELTA_TIME);
             }
 
             // We don't need to calculate either angle or distance when one of the last->curr objects is a spinner
-            if (BaseObject is Spinner || lastObject is Spinner)
+            if (BaseObject is Spinner || LastObject is Spinner)
                 return;
 
             // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
             float scalingFactor = NORMALISED_RADIUS / (float)BaseObject.Radius;
 
-            if (BaseObject.Radius < 30)
-            {
-                float smallCircleBonus = Math.Min(30 - (float)BaseObject.Radius, 5) / 50;
-                scalingFactor *= 1 + smallCircleBonus;
-            }
-
-            Vector2 lastCursorPosition = getEndCursorPosition(lastObject);
+            Vector2 lastCursorPosition = lastDifficultyObject != null ? getEndCursorPosition(lastDifficultyObject) : LastObject.StackedPosition;
 
             LazyJumpDistance = (BaseObject.StackedPosition * scalingFactor - lastCursorPosition * scalingFactor).Length;
-            MinimumJumpTime = StrainTime;
+            MinimumJumpTime = AdjustedDeltaTime;
             MinimumJumpDistance = LazyJumpDistance;
 
-            if (lastObject is Slider lastSlider)
+            if (LastObject is Slider lastSlider && lastDifficultyObject != null)
             {
-                double lastTravelTime = Math.Max(lastSlider.LazyTravelTime / clockRate, MIN_DELTA_TIME);
-                MinimumJumpTime = Math.Max(StrainTime - lastTravelTime, MIN_DELTA_TIME);
+                double lastTravelTime = Math.Max(lastDifficultyObject.LazyTravelTime / clockRate, MIN_DELTA_TIME);
+                MinimumJumpTime = Math.Max(AdjustedDeltaTime - lastTravelTime, MIN_DELTA_TIME);
 
                 //
                 // There are two types of slider-to-object patterns to consider in order to better approximate the real movement a player will take to jump between the hitobjects.
@@ -217,11 +237,11 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
                 MinimumJumpDistance = Math.Max(0, Math.Min(LazyJumpDistance - (maximum_slider_radius - assumed_slider_radius), tailJumpDistance - maximum_slider_radius));
             }
 
-            if (lastLastObject != null && !(lastLastObject is Spinner))
+            if (lastLastDifficultyObject != null && lastLastDifficultyObject.BaseObject is not Spinner)
             {
-                Vector2 lastLastCursorPosition = getEndCursorPosition(lastLastObject);
+                Vector2 lastLastCursorPosition = getEndCursorPosition(lastLastDifficultyObject);
 
-                Vector2 v1 = lastLastCursorPosition - lastObject.StackedPosition;
+                Vector2 v1 = lastLastCursorPosition - LastObject.StackedPosition;
                 Vector2 v2 = BaseObject.StackedPosition - lastCursorPosition;
 
                 float dot = Vector2.Dot(v1, v2);
@@ -231,9 +251,12 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
             }
         }
 
-        private void computeSliderCursorPosition(Slider slider)
+        private void computeSliderCursorPosition()
         {
-            if (slider.LazyEndPosition != null)
+            if (BaseObject is not Slider slider)
+                return;
+
+            if (LazyEndPosition != null)
                 return;
 
             // TODO: This commented version is actually correct by the new lazer implementation, but intentionally held back from
@@ -280,15 +303,15 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
                 nestedObjects = reordered;
             }
 
-            slider.LazyTravelTime = trackingEndTime - slider.StartTime;
+            LazyTravelTime = trackingEndTime - slider.StartTime;
 
-            double endTimeMin = slider.LazyTravelTime / slider.SpanDuration;
+            double endTimeMin = LazyTravelTime / slider.SpanDuration;
             if (endTimeMin % 2 >= 1)
                 endTimeMin = 1 - endTimeMin % 1;
             else
                 endTimeMin %= 1;
 
-            slider.LazyEndPosition = slider.StackedPosition + slider.Path.PositionAt(endTimeMin); // temporary lazy end position until a real result can be derived.
+            LazyEndPosition = slider.StackedPosition + slider.Path.PositionAt(endTimeMin); // temporary lazy end position until a real result can be derived.
 
             Vector2 currCursorPosition = slider.StackedPosition;
 
@@ -310,7 +333,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
                     // There is both a lazy end position as well as the actual end slider position. We assume the player takes the simpler movement.
                     // For sliders that are circular, the lazy end position may actually be farther away than the sliders true end.
                     // This code is designed to prevent buffing situations where lazy end is actually a less efficient movement.
-                    Vector2 lazyMovement = Vector2.Subtract((Vector2)slider.LazyEndPosition, currCursorPosition);
+                    Vector2 lazyMovement = Vector2.Subtract((Vector2)LazyEndPosition, currCursorPosition);
 
                     if (lazyMovement.Length < currMovement.Length)
                         currMovement = lazyMovement;
@@ -328,25 +351,17 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
                     // this finds the positional delta from the required radius and the current position, and updates the currCursorPosition accordingly, as well as rewarding distance.
                     currCursorPosition = Vector2.Add(currCursorPosition, Vector2.Multiply(currMovement, (float)((currMovementLength - requiredMovement) / currMovementLength)));
                     currMovementLength *= (currMovementLength - requiredMovement) / currMovementLength;
-                    slider.LazyTravelDistance += (float)currMovementLength;
+                    LazyTravelDistance += currMovementLength;
                 }
 
                 if (i == nestedObjects.Count - 1)
-                    slider.LazyEndPosition = currCursorPosition;
+                    LazyEndPosition = currCursorPosition;
             }
         }
 
-        private Vector2 getEndCursorPosition(OsuHitObject hitObject)
+        private Vector2 getEndCursorPosition(OsuDifficultyHitObject difficultyHitObject)
         {
-            Vector2 pos = hitObject.StackedPosition;
-
-            if (hitObject is Slider slider)
-            {
-                computeSliderCursorPosition(slider);
-                pos = slider.LazyEndPosition ?? pos;
-            }
-
-            return pos;
+            return difficultyHitObject.LazyEndPosition ?? difficultyHitObject.BaseObject.StackedPosition;
         }
     }
 }

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

@@ -7,6 +7,7 @@ using System.Linq;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Difficulty.Evaluators;
+using osu.Game.Rulesets.Osu.Difficulty.Utils;
 using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Difficulty.Skills
@@ -26,7 +27,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
 
         private double currentStrain;
 
-        private double skillMultiplier => 25.6;
+        private double skillMultiplier => 26;
         private double strainDecayBase => 0.15;
 
         private readonly List<double> sliderStrains = new List<double>();
@@ -41,9 +42,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
             currentStrain += AimEvaluator.EvaluateDifficultyOf(current, IncludeSliders) * skillMultiplier;
 
             if (current.BaseObject is Slider)
-            {
                 sliderStrains.Add(currentStrain);
-            }
 
             return currentStrain;
         }
@@ -54,10 +53,13 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
                 return 0;
 
             double maxSliderStrain = sliderStrains.Max();
+
             if (maxSliderStrain == 0)
                 return 0;
 
             return sliderStrains.Sum(strain => 1.0 / (1.0 + Math.Exp(-(strain / maxSliderStrain * 12.0 - 6.0))));
         }
+
+        public double CountTopWeightedSliders() => OsuStrainUtils.CountTopWeightedSliders(sliderStrains, DifficultyValue());
     }
 }

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

@@ -2,11 +2,14 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Difficulty.Evaluators;
 using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Osu.Objects;
 using System.Linq;
+using osu.Game.Rulesets.Osu.Difficulty.Utils;
 
 namespace osu.Game.Rulesets.Osu.Difficulty.Skills
 {
@@ -15,12 +18,14 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
     /// </summary>
     public class Speed : OsuStrainSkill
     {
-        private double skillMultiplier => 1.46;
+        private double skillMultiplier => 1.47;
         private double strainDecayBase => 0.3;
 
         private double currentStrain;
         private double currentRhythm;
 
+        private readonly List<double> sliderStrains = new List<double>();
+
         protected override int ReducedSectionCount => 5;
 
         public Speed(Mod[] mods)
@@ -34,13 +39,16 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
 
         protected override double StrainValueAt(DifficultyHitObject current)
         {
-            currentStrain *= strainDecay(((OsuDifficultyHitObject)current).StrainTime);
+            currentStrain *= strainDecay(((OsuDifficultyHitObject)current).AdjustedDeltaTime);
             currentStrain += SpeedEvaluator.EvaluateDifficultyOf(current, Mods) * skillMultiplier;
 
             currentRhythm = RhythmEvaluator.EvaluateDifficultyOf(current);
 
             double totalStrain = currentStrain * currentRhythm;
 
+            if (current.BaseObject is Slider)
+                sliderStrains.Add(totalStrain);
+
             return totalStrain;
         }
 
@@ -55,5 +63,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
 
             return ObjectStrains.Sum(strain => 1.0 / (1.0 + Math.Exp(-(strain / maxStrain * 12.0 - 6.0))));
         }
+
+        public double CountTopWeightedSliders() => OsuStrainUtils.CountTopWeightedSliders(sliderStrains, DifficultyValue());
     }
 }

osu.Game.Rulesets.Osu/Difficulty/Utils/LegacyScoreUtils.cs

@@ -0,0 +1,101 @@
+// 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 System.Linq;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Objects.Legacy;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Difficulty.Utils
+{
+    public static class LegacyScoreUtils
+    {
+        /// <summary>
+        /// Calculates the average amount of score per object that is caused by nested judgements such as slider-ticks and spinners.
+        /// </summary>
+        public static double CalculateNestedScorePerObject(IBeatmap beatmap, int objectCount)
+        {
+            const double big_tick_score = 30;
+            const double small_tick_score = 10;
+
+            var sliders = beatmap.HitObjects.OfType<Slider>().ToArray();
+
+            // 1 for head, 1 for tail
+            int amountOfBigTicks = sliders.Length * 2;
+
+            // Add slider repeats
+            amountOfBigTicks += sliders.Select(s => s.RepeatCount).Sum();
+
+            int amountOfSmallTicks = sliders.Select(s => s.NestedHitObjects.Count(nho => nho is SliderTick)).Sum();
+
+            double sliderScore = amountOfBigTicks * big_tick_score + amountOfSmallTicks * small_tick_score;
+
+            double spinnerScore = 0;
+
+            foreach (var spinner in beatmap.HitObjects.OfType<Spinner>())
+            {
+                spinnerScore += calculateSpinnerScore(spinner);
+            }
+
+            return (sliderScore + spinnerScore) / objectCount;
+        }
+
+        /// <remarks>
+        /// Logic borrowed from <see cref="OsuLegacyScoreSimulator.simulateHit"/> for basic score calculations.
+        /// </remarks>
+        private static double calculateSpinnerScore(Spinner spinner)
+        {
+            const int spin_score = 100;
+            const int bonus_spin_score = 1000;
+
+            // The spinner object applies a lenience because gameplay mechanics differ from osu-stable.
+            // We'll redo the calculations to match osu-stable here...
+            const double maximum_rotations_per_second = 477.0 / 60;
+
+            // Normally, this value depends on the final overall difficulty. For simplicity, we'll only consider the worst case that maximises bonus score.
+            // As we're primarily concerned with computing the maximum theoretical final score,
+            // this will have the final effect of slightly underestimating bonus score achieved on stable when converting from score V1.
+            const double minimum_rotations_per_second = 3;
+
+            double secondsDuration = spinner.Duration / 1000;
+
+            // The total amount of half spins possible for the entire spinner.
+            int totalHalfSpinsPossible = (int)(secondsDuration * maximum_rotations_per_second * 2);
+            // The amount of half spins that are required to successfully complete the spinner (i.e. get a 300).
+            int halfSpinsRequiredForCompletion = (int)(secondsDuration * minimum_rotations_per_second);
+            // To be able to receive bonus points, the spinner must be rotated another 1.5 times.
+            int halfSpinsRequiredBeforeBonus = halfSpinsRequiredForCompletion + 3;
+
+            long score = 0;
+
+            int fullSpins = (totalHalfSpinsPossible / 2);
+
+            // Normal spin score
+            score += spin_score * fullSpins;
+
+            int bonusSpins = (totalHalfSpinsPossible - halfSpinsRequiredBeforeBonus) / 2;
+
+            // Reduce amount of bonus spins because we want to represent the more average case, rather than the best one.
+            bonusSpins = Math.Max(0, bonusSpins - fullSpins / 2);
+
+            score += bonus_spin_score * bonusSpins;
+
+            return score;
+        }
+
+        public static int CalculateDifficultyPeppyStars(IBeatmap beatmap)
+        {
+            int objectCount = beatmap.HitObjects.Count;
+            int drainLength = 0;
+
+            if (objectCount > 0)
+            {
+                int breakLength = beatmap.Breaks.Select(b => (int)Math.Round(b.EndTime) - (int)Math.Round(b.StartTime)).Sum();
+                drainLength = ((int)Math.Round(beatmap.HitObjects[^1].StartTime) - (int)Math.Round(beatmap.HitObjects[0].StartTime) - breakLength) / 1000;
+            }
+
+            return LegacyRulesetExtensions.CalculateDifficultyPeppyStars(beatmap.Difficulty, objectCount, drainLength);
+        }
+    }
+}

osu.Game.Rulesets.Osu/Difficulty/Utils/OsuStrainUtils.cs

@@ -0,0 +1,26 @@
+// 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.Collections.Generic;
+using System.Linq;
+using osu.Game.Rulesets.Difficulty.Utils;
+
+namespace osu.Game.Rulesets.Osu.Difficulty.Utils
+{
+    public static class OsuStrainUtils
+    {
+        public static double CountTopWeightedSliders(IReadOnlyCollection<double> sliderStrains, double difficultyValue)
+        {
+            if (sliderStrains.Count == 0)
+                return 0;
+
+            double consistentTopStrain = difficultyValue / 10; // What would the top strain be if all strain values were identical
+
+            if (consistentTopStrain == 0)
+                return 0;
+
+            // Use a weighted sum of all strains. Constants are arbitrary and give nice values
+            return sliderStrains.Sum(s => DifficultyCalculationUtils.Logistic(s / consistentTopStrain, 0.88, 10, 1.1));
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs

@@ -469,9 +469,20 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
             }
             else
             {
-                SnapResult result = positionSnapProvider?.TrySnapToPositionGrid(Parent!.ToScreenSpace(e.MousePosition));
+                Vector2 newControlPointPosition = Parent!.ToScreenSpace(e.MousePosition);
 
-                Vector2 movementDelta = Parent!.ToLocalSpace(result?.ScreenSpacePosition ?? Parent!.ToScreenSpace(e.MousePosition)) - dragStartPositions[draggedControlPointIndex] - hitObject.Position;
+                // Snapping inherited B-spline control points to nearby objects would be unintuitive, because snapping them does not equate to snapping the interpolated slider path.
+                bool shouldSnapToNearbyObjects = dragPathTypes[draggedControlPointIndex] is not null ||
+                                                 dragPathTypes[..draggedControlPointIndex].LastOrDefault(t => t is not null)?.Type != SplineType.BSpline;
+
+                SnapResult result = null;
+                if (shouldSnapToNearbyObjects)
+                    result = positionSnapProvider?.TrySnapToNearbyObjects(newControlPointPosition, oldStartTime);
+                if (positionSnapProvider?.TrySnapToPositionGrid(result?.ScreenSpacePosition ?? newControlPointPosition, result?.Time ?? oldStartTime) is SnapResult gridSnapResult)
+                    result = gridSnapResult;
+                result ??= new SnapResult(newControlPointPosition, oldStartTime);
+
+                Vector2 movementDelta = Parent!.ToLocalSpace(result.ScreenSpacePosition) - dragStartPositions[draggedControlPointIndex] - hitObject.Position;
 
                 for (int i = 0; i < controlPoints.Count; ++i)
                 {

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs

@@ -626,10 +626,38 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
         public override Vector2 ScreenSpaceSelectionPoint => DrawableObject.SliderBody?.ToScreenSpace(DrawableObject.SliderBody.PathOffset)
                                                              ?? BodyPiece.ToScreenSpace(BodyPiece.PathStartLocation);
 
-        protected override Vector2[] ScreenSpaceAdditionalNodes => new[]
-        {
+        protected override Vector2[] ScreenSpaceAdditionalNodes => getScreenSpaceControlPointNodes().Prepend(
             DrawableObject.SliderBody?.ToScreenSpace(DrawableObject.SliderBody.PathEndOffset) ?? BodyPiece.ToScreenSpace(BodyPiece.PathEndLocation)
-        };
+        ).ToArray();
+
+        private IEnumerable<Vector2> getScreenSpaceControlPointNodes()
+        {
+            // Returns the positions of control points that produce visible kinks on the slider's path
+            // This excludes inherited control points from Bezier, B-Spline, Perfect, and Catmull curves
+            if (DrawableObject.SliderBody == null)
+                yield break;
+
+            PathType? currentPathType = null;
+
+            // Skip the last control point because its always either not on the slider path or exactly on the slider end
+            for (int i = 0; i < DrawableObject.HitObject.Path.ControlPoints.Count - 1; i++)
+            {
+                var controlPoint = DrawableObject.HitObject.Path.ControlPoints[i];
+
+                if (controlPoint.Type is not null)
+                    currentPathType = controlPoint.Type;
+
+                // Skip the first control point because it is already covered by the slider head
+                if (i == 0)
+                    continue;
+
+                if (controlPoint.Type is null && currentPathType != PathType.LINEAR)
+                    continue;
+
+                var screenSpacePosition = DrawableObject.SliderBody.ToScreenSpace(DrawableObject.SliderBody.PathOffset + controlPoint.Position);
+                yield return screenSpacePosition;
+            }
+        }
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos)
         {

osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs

@@ -253,7 +253,7 @@ namespace osu.Game.Rulesets.Osu.Edit
         {
             var hitObjects = selectedMovableObjects;
 
-            Quad quad = GeometryUtils.GetSurroundingQuad(hitObjects);
+            Quad quad = GeometryUtils.GetSurroundingQuad(hitObjects, true);
 
             Vector2 delta = Vector2.Zero;
 

osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs

@@ -81,12 +81,8 @@ namespace osu.Game.Rulesets.Osu.Edit
             changeHandler?.BeginChange();
 
             objectsInScale = selectedMovableObjects.ToDictionary(ho => ho, ho => new OriginalHitObjectState(ho));
-            OriginalSurroundingQuad = objectsInScale.Count == 1 && objectsInScale.First().Key is Slider slider
-                ? GeometryUtils.GetSurroundingQuad(slider.Path.ControlPoints.Select(p => slider.Position + p.Position))
-                : GeometryUtils.GetSurroundingQuad(objectsInScale.Keys);
-            originalConvexHull = objectsInScale.Count == 1 && objectsInScale.First().Key is Slider slider2
-                ? GeometryUtils.GetConvexHull(slider2.Path.ControlPoints.Select(p => slider2.Position + p.Position))
-                : GeometryUtils.GetConvexHull(objectsInScale.Keys);
+            OriginalSurroundingQuad = GeometryUtils.GetSurroundingQuad(objectsInScale.Keys);
+            originalConvexHull = GeometryUtils.GetConvexHull(objectsInScale.Keys);
             defaultOrigin = GeometryUtils.MinimumEnclosingCircle(originalConvexHull).Item1;
         }
 
@@ -312,7 +308,7 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         private void moveSelectionInBounds()
         {
-            Quad quad = GeometryUtils.GetSurroundingQuad(objectsInScale!.Keys);
+            Quad quad = GeometryUtils.GetSurroundingQuad(objectsInScale!.Keys, true);
 
             Vector2 delta = Vector2.Zero;
 

osu.Game.Rulesets.Osu/Objects/Slider.cs

@@ -68,24 +68,6 @@ namespace osu.Game.Rulesets.Osu.Objects
             }
         }
 
-        /// <summary>
-        /// The position of the cursor at the point of completion of this <see cref="Slider"/> if it was hit
-        /// with as few movements as possible. This is set and used by difficulty calculation.
-        /// </summary>
-        internal Vector2? LazyEndPosition;
-
-        /// <summary>
-        /// The distance travelled by the cursor upon completion of this <see cref="Slider"/> if it was hit
-        /// with as few movements as possible. This is set and used by difficulty calculation.
-        /// </summary>
-        internal float LazyTravelDistance;
-
-        /// <summary>
-        /// The time taken by the cursor upon completion of this <see cref="Slider"/> if it was hit
-        /// with as few movements as possible. This is set and used by difficulty calculation.
-        /// </summary>
-        internal double LazyTravelTime;
-
         public IList<IList<HitSampleInfo>> NodeSamples { get; set; } = new List<IList<HitSampleInfo>>();
 
         [JsonIgnore]

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

@@ -14,13 +14,13 @@ namespace osu.Game.Rulesets.Taiko.Tests
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Taiko";
 
-        [TestCase(3.305554470092722d, 200, "diffcalc-test")]
-        [TestCase(3.305554470092722d, 200, "diffcalc-test-strong")]
+        [TestCase(3.3190848563395079d, 200, "diffcalc-test")]
+        [TestCase(3.3190848563395079d, 200, "diffcalc-test-strong")]
         public void Test(double expectedStarRating, int expectedMaxCombo, string name)
             => base.Test(expectedStarRating, expectedMaxCombo, name);
 
-        [TestCase(4.4472572672057815d, 200, "diffcalc-test")]
-        [TestCase(4.4472572672057815d, 200, "diffcalc-test-strong")]
+        [TestCase(4.4551414906554987d, 200, "diffcalc-test")]
+        [TestCase(4.4551414906554987d, 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

@@ -2,6 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Utils;
 using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing;
@@ -24,7 +26,9 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Evaluators
             int consistentRatioCount = 0;
             double totalRatioCount = 0.0;
 
+            List<double> recentRatios = new List<double>();
             TaikoDifficultyHitObject current = hitObject;
+            var previousHitObject = (TaikoDifficultyHitObject)current.Previous(1);
 
             for (int i = 0; i < maxObjectsToCheck; i++)
             {
@@ -32,11 +36,11 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Evaluators
                 if (current.Index <= 1)
                     break;
 
-                var previousHitObject = (TaikoDifficultyHitObject)current.Previous(1);
-
                 double currentRatio = current.RhythmData.Ratio;
                 double previousRatio = previousHitObject.RhythmData.Ratio;
 
+                recentRatios.Add(currentRatio);
+
                 // A consistent interval is defined as the percentage difference between the two rhythmic ratios with the margin of error.
                 if (Math.Abs(1 - currentRatio / previousRatio) <= threshold)
                 {
@@ -45,14 +49,21 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Evaluators
                     break;
                 }
 
-                // Move to the previous object
                 current = previousHitObject;
             }
 
             // Ensure no division by zero
-            double ratioPenalty = 1 - totalRatioCount / (consistentRatioCount + 1) * 0.80;
+            if (consistentRatioCount > 0)
+                return 1 - totalRatioCount / (consistentRatioCount + 1) * 0.80;
 
-            return ratioPenalty;
+            if (recentRatios.Count <= 1) return 1.0;
+
+            // As a fallback, calculate the maximum deviation from the average of the recent ratios to ensure slightly off-snapped objects don't bypass the penalty.
+            double maxRatioDeviation = recentRatios.Max(r => Math.Abs(r - recentRatios.Average()));
+
+            double consistentRatioPenalty = 0.7 + 0.3 * DifficultyCalculationUtils.Smootherstep(maxRatioDeviation, 0.0, 1.0);
+
+            return consistentRatioPenalty;
         }
 
         /// <summary>

osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Rhythm/Data/SameRhythmHitObjectGrouping.cs

@@ -1,7 +1,9 @@
 // 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 System.Collections.Generic;
+using System.Linq;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Taiko.Difficulty.Utils;
 
@@ -18,6 +20,8 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Rhythm.Data
 
         public readonly SameRhythmHitObjectGrouping? Previous;
 
+        private const double snap_tolerance = IntervalGroupingUtils.MARGIN_OF_ERROR;
+
         /// <summary>
         /// <see cref="DifficultyHitObject.StartTime"/> of the first hit object.
         /// </summary>
@@ -29,35 +33,60 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Rhythm.Data
         public double Duration => HitObjects[^1].StartTime - HitObjects[0].StartTime;
 
         /// <summary>
-        /// The interval in ms of each hit object in this <see cref="SameRhythmHitObjectGrouping"/>. This is only defined if there is
+        /// The normalised interval in ms of each hit object in this <see cref="SameRhythmHitObjectGrouping"/>. This is only defined if there is
         /// more than two hit objects in this <see cref="SameRhythmHitObjectGrouping"/>.
         /// </summary>
         public readonly double? HitObjectInterval;
 
         /// <summary>
-        /// The ratio of <see cref="HitObjectInterval"/> between this and the previous <see cref="SameRhythmHitObjectGrouping"/>. In the
+        /// The normalised ratio of <see cref="HitObjectInterval"/> between this and the previous <see cref="SameRhythmHitObjectGrouping"/>. In the
         /// case where one or both of the <see cref="HitObjectInterval"/> is undefined, this will have a value of 1.
         /// </summary>
         public readonly double HitObjectIntervalRatio;
 
         /// <inheritdoc/>
-        public double Interval { get; }
+        public double Interval { get; } = double.PositiveInfinity;
 
         public SameRhythmHitObjectGrouping(SameRhythmHitObjectGrouping? previous, List<TaikoDifficultyHitObject> hitObjects)
         {
             Previous = previous;
             HitObjects = hitObjects;
 
-            // Calculate the average interval between hitobjects, or null if there are fewer than two
-            HitObjectInterval = HitObjects.Count < 2 ? null : Duration / (HitObjects.Count - 1);
+            // Cluster and normalise each hitobjects delta-time.
+            var normaliseHitObjects = DeltaTimeNormaliser.Normalise(hitObjects, snap_tolerance);
+
+            var normalisedHitObjectDeltaTime = hitObjects
+                                               .Skip(1)
+                                               .Select(hitObject => normaliseHitObjects[hitObject])
+                                               .ToList();
+
+            // Secondary check to ensure there isn't any 'noise' or outliers by taking the modal delta time.
+            double modalDelta = normalisedHitObjectDeltaTime.Count > 0
+                ? Math.Round(normalisedHitObjectDeltaTime[0])
+                : 0;
+
+            // Calculate the average interval between hitobjects.
+            if (normalisedHitObjectDeltaTime.Count > 0)
+            {
+                if (previous?.HitObjectInterval is double previousDelta && Math.Abs(modalDelta - previousDelta) <= snap_tolerance)
+                    HitObjectInterval = previousDelta;
+                else
+                    HitObjectInterval = modalDelta;
+            }
 
             // Calculate the ratio between this group's interval and the previous group's interval
-            HitObjectIntervalRatio = Previous?.HitObjectInterval != null && HitObjectInterval != null
-                ? HitObjectInterval.Value / Previous.HitObjectInterval.Value
-                : 1;
+            HitObjectIntervalRatio = previous?.HitObjectInterval is double previousInterval && HitObjectInterval is double currentInterval
+                ? currentInterval / previousInterval
+                : 1.0;
 
             // Calculate the interval from the previous group's start time
-            Interval = Previous != null ? StartTime - Previous.StartTime : double.PositiveInfinity;
+            if (previous != null)
+            {
+                if (Math.Abs(StartTime - previous.StartTime) <= snap_tolerance)
+                    Interval = 0;
+                else
+                    Interval = StartTime - previous.StartTime;
+            }
         }
     }
 }

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

@@ -42,20 +42,28 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
         protected override double StrainValueAt(DifficultyHitObject current)
         {
             currentStrain *= strainDecay(current.DeltaTime);
-            currentStrain += StaminaEvaluator.EvaluateDifficultyOf(current) * skillMultiplier;
+            double staminaDifficulty = StaminaEvaluator.EvaluateDifficultyOf(current) * skillMultiplier;
 
             // Safely prevents previous strains from shifting as new notes are added.
             var currentObject = current as TaikoDifficultyHitObject;
             int index = currentObject?.ColourData.MonoStreak?.HitObjects.IndexOf(currentObject) ?? 0;
 
-            double monolengthBonus = isConvert ? 1 : 1 + Math.Min(Math.Max((index - 5) / 50.0, 0), 0.30);
+            double monoLengthBonus = isConvert ? 1.0 : 1.0 + 0.5 * DifficultyCalculationUtils.ReverseLerp(index, 5, 20);
 
-            if (SingleColourStamina)
-                return DifficultyCalculationUtils.Logistic(-(index - 10) / 2.0, currentStrain);
+            // Mono-streak bonus is only applied to colour-based stamina to reward longer sequences of same-colour hits within patterns.
+            if (!SingleColourStamina)
+                staminaDifficulty *= monoLengthBonus;
 
-            return currentStrain * monolengthBonus;
+            currentStrain += staminaDifficulty;
+
+            // For converted maps, difficulty often comes entirely from long mono streams with no colour variation.
+            // To avoid over-rewarding these maps based purely on stamina strain, we dampen the strain value once the index exceeds 10.
+            return SingleColourStamina ? DifficultyCalculationUtils.Logistic(-(index - 10) / 2.0, currentStrain) : currentStrain;
         }
 
-        protected override double CalculateInitialStrain(double time, DifficultyHitObject current) => SingleColourStamina ? 0 : currentStrain * strainDecay(time - current.Previous(0).StartTime);
+        protected override double CalculateInitialStrain(double time, DifficultyHitObject current) =>
+            SingleColourStamina
+                ? 0
+                : currentStrain * strainDecay(time - current.Previous(0).StartTime);
     }
 }

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

@@ -10,9 +10,16 @@ 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>
+        public double MechanicalDifficulty { get; set; }
+
         /// <summary>
         /// The difficulty corresponding to the rhythm skill.
         /// </summary>
+        [JsonProperty("rhythm_difficulty")]
         public double RhythmDifficulty { get; set; }
 
         /// <summary>
@@ -36,9 +43,11 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
         [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,7 +57,9 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
                 yield return v;
 
             yield return (ATTRIB_ID_DIFFICULTY, StarRating);
+            yield return (ATTRIB_ID_RHYTHM_DIFFICULTY, RhythmDifficulty);
             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)
@@ -56,7 +67,9 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
             base.FromDatabaseAttributes(values, onlineInfo);
 
             StarRating = values[ATTRIB_ID_DIFFICULTY];
+            RhythmDifficulty = values[ATTRIB_ID_RHYTHM_DIFFICULTY];
             MonoStaminaFactor = values[ATTRIB_ID_MONO_STAMINA_FACTOR];
+            ConsistencyFactor = values[ATTRIB_ID_CONSISTENCY_FACTOR];
         }
     }
 }

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

@@ -23,7 +23,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
     public class TaikoDifficultyCalculator : DifficultyCalculator
     {
         private const double difficulty_multiplier = 0.084375;
-        private const double rhythm_skill_multiplier = 0.65 * difficulty_multiplier;
+        private const double rhythm_skill_multiplier = 0.750 * difficulty_multiplier;
         private const double reading_skill_multiplier = 0.100 * difficulty_multiplier;
         private const double colour_skill_multiplier = 0.375 * difficulty_multiplier;
         private const double stamina_skill_multiplier = 0.445 * difficulty_multiplier;
@@ -31,6 +31,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
         private double strainLengthBonus;
         private double patternMultiplier;
 
+        private bool isRelax;
         private bool isConvert;
 
         public override int Version => 20250306;
@@ -46,6 +47,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
             hitWindows.SetDifficulty(beatmap.Difficulty.OverallDifficulty);
 
             isConvert = beatmap.BeatmapInfo.Ruleset.OnlineID == 0;
+            isRelax = mods.Any(h => h is TaikoModRelax);
 
             return new Skill[]
             {
@@ -100,47 +102,50 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
             if (beatmap.HitObjects.Count == 0)
                 return new TaikoDifficultyAttributes { Mods = mods };
 
-            bool isRelax = mods.Any(h => h is TaikoModRelax);
-
             var rhythm = skills.OfType<Rhythm>().Single();
             var reading = skills.OfType<Reading>().Single();
             var colour = skills.OfType<Colour>().Single();
             var stamina = skills.OfType<Stamina>().Single(s => !s.SingleColourStamina);
             var singleColourStamina = skills.OfType<Stamina>().Single(s => s.SingleColourStamina);
 
-            double rhythmRating = rhythm.DifficultyValue() * rhythm_skill_multiplier;
-            double readingRating = reading.DifficultyValue() * reading_skill_multiplier;
-            double colourRating = colour.DifficultyValue() * colour_skill_multiplier;
-            double staminaRating = stamina.DifficultyValue() * stamina_skill_multiplier;
-            double monoStaminaRating = singleColourStamina.DifficultyValue() * stamina_skill_multiplier;
-            double monoStaminaFactor = staminaRating == 0 ? 1 : Math.Pow(monoStaminaRating / staminaRating, 5);
+            double rhythmSkill = rhythm.DifficultyValue() * rhythm_skill_multiplier;
+            double readingSkill = reading.DifficultyValue() * reading_skill_multiplier;
+            double colourSkill = colour.DifficultyValue() * colour_skill_multiplier;
+            double staminaSkill = stamina.DifficultyValue() * stamina_skill_multiplier;
+            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.
-            patternMultiplier = Math.Pow(staminaRating * colourRating, 0.10);
+            patternMultiplier = Math.Pow(staminaSkill * colourSkill, 0.10);
 
-            strainLengthBonus = 1
-                                + Math.Min(Math.Max((staminaDifficultStrains - 1000) / 3700, 0), 0.15)
-                                + Math.Min(Math.Max((staminaRating - 7.0) / 1.0, 0), 0.05);
+            strainLengthBonus = 1 + 0.15 * DifficultyCalculationUtils.ReverseLerp(staminaDifficultStrains, 1000, 1555);
 
-            double combinedRating = combinedDifficultyValue(rhythm, reading, colour, stamina, isRelax, isConvert);
+            double combinedRating = combinedDifficultyValue(rhythm, reading, colour, stamina, out double consistencyFactor);
             double starRating = rescale(combinedRating * 1.4);
 
+            // Calculate proportional contribution of each skill to the combinedRating.
+            double skillRating = starRating / (rhythmSkill + readingSkill + colourSkill + staminaSkill);
+
+            double rhythmDifficulty = rhythmSkill * skillRating;
+            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,
-                RhythmDifficulty = rhythmRating,
-                ReadingDifficulty = readingRating,
-                ColourDifficulty = colourRating,
-                StaminaDifficulty = staminaRating,
+                MechanicalDifficulty = mechanicalDifficulty,
+                RhythmDifficulty = rhythmDifficulty,
+                ReadingDifficulty = readingDifficulty,
+                ColourDifficulty = colourDifficulty,
+                StaminaDifficulty = staminaDifficulty,
                 MonoStaminaFactor = monoStaminaFactor,
-                RhythmTopStrains = rhythmDifficultStrains,
-                ColourTopStrains = colourDifficultStrains,
                 StaminaTopStrains = staminaDifficultStrains,
+                ConsistencyFactor = consistencyFactor,
                 MaxCombo = beatmap.GetMaxCombo(),
             };
 
@@ -154,14 +159,59 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
         /// 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, out double consistencyFactor)
         {
-            List<double> peaks = new List<double>();
+            List<double> peaks = combinePeaks(
+                rhythm.GetCurrentStrainPeaks().ToList(),
+                reading.GetCurrentStrainPeaks().ToList(),
+                colour.GetCurrentStrainPeaks().ToList(),
+                stamina.GetCurrentStrainPeaks().ToList()
+            );
 
-            var rhythmPeaks = rhythm.GetCurrentStrainPeaks().ToList();
-            var readingPeaks = reading.GetCurrentStrainPeaks().ToList();
-            var colourPeaks = colour.GetCurrentStrainPeaks().ToList();
-            var staminaPeaks = stamina.GetCurrentStrainPeaks().ToList();
+            if (peaks.Count == 0)
+            {
+                consistencyFactor = 0;
+                return 0;
+            }
+
+            double difficulty = 0;
+            double weight = 1;
+
+            foreach (double strain in peaks.OrderDescending())
+            {
+                difficulty += strain * weight;
+                weight *= 0.9;
+            }
+
+            List<double> hitObjectStrainPeaks = combinePeaks(
+                rhythm.GetObjectStrains().ToList(),
+                reading.GetObjectStrains().ToList(),
+                colour.GetObjectStrains().ToList(),
+                stamina.GetObjectStrains().ToList()
+            );
+
+            if (hitObjectStrainPeaks.Count == 0)
+            {
+                consistencyFactor = 0;
+                return 0;
+            }
+
+            // The average of the top 5% of strain peaks from hit objects.
+            double topAverageHitObjectStrain = hitObjectStrainPeaks.OrderDescending().Take(1 + hitObjectStrainPeaks.Count / 20).Average();
+
+            // Calculates a consistency factor as the sum of difficulty from hit objects compared to if every object were as hard as the hardest.
+            // The top average strain is used instead of the very hardest to prevent exceptionally hard objects lowering the factor.
+            consistencyFactor = hitObjectStrainPeaks.Sum() / (topAverageHitObjectStrain * hitObjectStrainPeaks.Count);
+
+            return difficulty;
+        }
+
+        /// <summary>
+        /// Combines lists of peak strains from multiple skills into a list of single peak strains for each section.
+        /// </summary>
+        private List<double> combinePeaks(List<double> rhythmPeaks, List<double> readingPeaks, List<double> colourPeaks, List<double> staminaPeaks)
+        {
+            var combinedPeaks = new List<double>();
 
             for (int i = 0; i < colourPeaks.Count; i++)
             {
@@ -176,19 +226,10 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
                 // Sections with 0 strain are excluded to avoid worst-case time complexity of the following sort (e.g. /b/2351871).
                 // These sections will not contribute to the difficulty.
                 if (peak > 0)
-                    peaks.Add(peak);
+                    combinedPeaks.Add(peak);
             }
 
-            double difficulty = 0;
-            double weight = 1;
-
-            foreach (double strain in peaks.OrderDescending())
-            {
-                difficulty += strain * weight;
-                weight *= 0.9;
-            }
-
-            return difficulty;
+            return combinedPeaks;
         }
 
         /// <summary>

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

@@ -15,9 +15,6 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
         [JsonProperty("accuracy")]
         public double Accuracy { get; set; }
 
-        [JsonProperty("effective_miss_count")]
-        public double EffectiveMissCount { get; set; }
-
         [JsonProperty("estimated_unstable_rate")]
         public double? EstimatedUnstableRate { get; set; }
 

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

@@ -4,7 +4,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using osu.Framework.Audio.Track;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Difficulty.Utils;
@@ -13,6 +12,7 @@ using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Rulesets.Taiko.Scoring;
 using osu.Game.Scoring;
+using osu.Game.Utils;
 
 namespace osu.Game.Rulesets.Taiko.Difficulty
 {
@@ -27,7 +27,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
         private double clockRate;
         private double greatHitWindow;
 
-        private double effectiveMissCount;
+        private double totalDifficultHits;
 
         public TaikoPerformanceCalculator()
             : base(new TaikoRuleset())
@@ -43,9 +43,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
             countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
             countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
 
-            var track = new TrackVirtual(10000);
-            score.Mods.OfType<IApplicableToTrack>().ForEach(m => m.ApplyToTrack(track));
-            clockRate = track.Rate;
+            clockRate = ModUtils.CalculateRateWithMods(score.Mods);
 
             var difficulty = score.BeatmapInfo!.Difficulty.Clone();
 
@@ -56,70 +54,92 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
 
             greatHitWindow = hitWindows.WindowFor(HitResult.Great) / clockRate;
 
-            estimatedUnstableRate = computeDeviationUpperBound() * 10;
+            estimatedUnstableRate = (countGreat == 0 || greatHitWindow <= 0)
+                ? null
+                : computeDeviationUpperBound(countGreat / (double)totalHits) * 10;
 
-            // 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)
-                effectiveMissCount = Math.Max(1.0, 1000.0 / totalSuccessfulHits) * countMiss;
+            // Total difficult hits measures the total difficulty of a map based on its consistency factor.
+            totalDifficultHits = totalHits * taikoAttributes.ConsistencyFactor;
 
-            // Converts are detected and omitted from mod-specific bonuses due to the scope of current difficulty calculation.
+            // Converts and the classic mod are detected and omitted from mod-specific bonuses due to the scope of current difficulty calculation.
             bool isConvert = score.BeatmapInfo!.Ruleset.OnlineID != 1;
+            bool isClassic = score.Mods.Any(m => m is ModClassic);
 
-            double multiplier = 1.13;
-
-            if (score.Mods.Any(m => m is ModHidden) && !isConvert)
-                multiplier *= 1.075;
-
-            if (score.Mods.Any(m => m is ModEasy))
-                multiplier *= 0.950;
-
-            double difficultyValue = computeDifficultyValue(score, taikoAttributes);
-            double accuracyValue = computeAccuracyValue(score, taikoAttributes, isConvert);
-            double totalValue =
-                Math.Pow(
-                    Math.Pow(difficultyValue, 1.1) +
-                    Math.Pow(accuracyValue, 1.1), 1.0 / 1.1
-                ) * multiplier;
+            double difficultyValue = computeDifficultyValue(score, taikoAttributes, isConvert, isClassic) * 1.08;
+            double accuracyValue = computeAccuracyValue(score, taikoAttributes, isConvert) * 1.1;
 
             return new TaikoPerformanceAttributes
             {
                 Difficulty = difficultyValue,
                 Accuracy = accuracyValue,
-                EffectiveMissCount = effectiveMissCount,
                 EstimatedUnstableRate = estimatedUnstableRate,
-                Total = totalValue
+                Total = difficultyValue + accuracyValue
             };
         }
 
-        private double computeDifficultyValue(ScoreInfo score, TaikoDifficultyAttributes attributes)
+        private double computeDifficultyValue(ScoreInfo score, TaikoDifficultyAttributes attributes, bool isConvert, bool isClassic)
         {
-            double baseDifficulty = 5 * Math.Max(1.0, attributes.StarRating / 0.110) - 4.0;
+            if (estimatedUnstableRate == null || totalDifficultHits == 0)
+                return 0;
+
+            // The estimated unstable rate for 100% accuracy, at which all rhythm difficulty has been played successfully.
+            double rhythmExpectedUnstableRate = computeDeviationUpperBound(1.0) * 10;
+
+            // The unstable rate at which it can be assumed all rhythm difficulty has been ignored.
+            // 0.8 represents 80% of total hits being greats, or 90% accuracy in-game
+            double rhythmMaximumUnstableRate = computeDeviationUpperBound(0.8) * 10;
+
+            // The fraction of star rating made up by rhythm difficulty, normalised to represent rhythm's perceived contribution to star rating.
+            double rhythmFactor = DifficultyCalculationUtils.ReverseLerp(attributes.RhythmDifficulty / attributes.StarRating, 0.15, 0.4);
+
+            // A penalty removing improperly played rhythm difficulty from star rating based on estimated unstable rate.
+            double rhythmPenalty = 1 - DifficultyCalculationUtils.Logistic(
+                estimatedUnstableRate.Value,
+                midpointOffset: (rhythmExpectedUnstableRate + rhythmMaximumUnstableRate) / 2,
+                multiplier: 10 / (rhythmMaximumUnstableRate - rhythmExpectedUnstableRate),
+                maxValue: 0.25 * Math.Pow(rhythmFactor, 3)
+            );
+
+            double baseDifficulty = 5 * Math.Max(1.0, attributes.StarRating * rhythmPenalty / 0.110) - 4.0;
             double difficultyValue = Math.Min(Math.Pow(baseDifficulty, 3) / 69052.51, Math.Pow(baseDifficulty, 2.25) / 1250.0);
 
             difficultyValue *= 1 + 0.10 * Math.Max(0, attributes.StarRating - 10);
 
-            double lengthBonus = 1 + 0.1 * Math.Min(1.0, totalHits / 1500.0);
+            // Applies a bonus to maps with more total difficulty.
+            double lengthBonus = 1 + 0.25 * totalDifficultHits / (totalDifficultHits + 4000);
             difficultyValue *= lengthBonus;
 
-            difficultyValue *= Math.Pow(0.986, effectiveMissCount);
-
-            if (score.Mods.Any(m => m is ModEasy))
-                difficultyValue *= 0.90;
+            // Scales miss penalty by the total difficult hits of a map, making misses more punishing on maps with less total difficulty.
+            double missPenalty = 0.97 + 0.03 * totalDifficultHits / (totalDifficultHits + 1500);
+            difficultyValue *= Math.Pow(missPenalty, countMiss);
 
             if (score.Mods.Any(m => m is ModHidden))
-                difficultyValue *= 1.025;
+            {
+                double hiddenBonus = isConvert ? 0.025 : 0.1;
+
+                // Hidden+flashlight plays are excluded from reading-based penalties to hidden.
+                if (!score.Mods.Any(m => m is ModFlashlight))
+                {
+                    // A penalty is applied to the bonus for hidden on non-classic scores, as the playfield can be made wider to make fast reading easier.
+                    if (!isClassic)
+                        hiddenBonus *= 0.2;
+
+                    // A penalty is applied to classic easy+hidden scores, as notes disappear later making fast reading easier.
+                    if (score.Mods.Any(m => m is ModEasy) && isClassic)
+                        hiddenBonus *= 0.5;
+                }
+
+                difficultyValue *= 1 + hiddenBonus;
+            }
 
             if (score.Mods.Any(m => m is ModFlashlight<TaikoHitObject>))
                 difficultyValue *= Math.Max(1, 1.050 - Math.Min(attributes.MonoStaminaFactor / 50, 1) * lengthBonus);
 
-            if (estimatedUnstableRate == null)
-                return 0;
-
             // Scale accuracy more harshly on nearly-completely mono (single coloured) speed maps.
-            double accScalingExponent = 2 + attributes.MonoStaminaFactor;
-            double accScalingShift = 500 - 100 * (attributes.MonoStaminaFactor * 3);
+            double monoAccScalingExponent = 2 + attributes.MonoStaminaFactor;
+            double monoAccScalingShift = 500 - 100 * (attributes.MonoStaminaFactor * 3);
 
-            return difficultyValue * Math.Pow(DifficultyCalculationUtils.Erf(accScalingShift / (Math.Sqrt(2) * estimatedUnstableRate.Value)), accScalingExponent);
+            return difficultyValue * Math.Pow(DifficultyCalculationUtils.Erf(monoAccScalingShift / (Math.Sqrt(2) * estimatedUnstableRate.Value)), monoAccScalingExponent);
         }
 
         private double computeAccuracyValue(ScoreInfo score, TaikoDifficultyAttributes attributes, bool isConvert)
@@ -127,13 +147,22 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
             if (greatHitWindow <= 0 || estimatedUnstableRate == null)
                 return 0;
 
-            double accuracyValue = Math.Pow(70 / estimatedUnstableRate.Value, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 100.0;
+            double accuracyValue = 470 * Math.Pow(0.9885, estimatedUnstableRate.Value);
 
-            double lengthBonus = Math.Min(1.15, Math.Pow(totalHits / 1500.0, 0.3));
+            // Scales up the bonus for lower unstable rate as star rating increases.
+            accuracyValue *= 1 + Math.Pow(50 / estimatedUnstableRate.Value, 2) * Math.Pow(attributes.StarRating, 2.8) / 600;
+
+            if (score.Mods.Any(m => m is ModHidden) && !isConvert)
+                accuracyValue *= 1.075;
+
+            // Applies a bonus to maps with more total difficulty, calculating this with a map's total hits and consistency factor.
+            accuracyValue *= 1 + 0.3 * totalDifficultHits / (totalDifficultHits + 4000);
+
+            // Applies a bonus to maps with more total memory required with HDFL.
+            double memoryLengthBonus = Math.Min(1.15, Math.Pow(totalHits / 1500.0, 0.3));
 
-            // 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.05 * lengthBonus);
+                accuracyValue *= Math.Max(1.0, 1.05 * memoryLengthBonus);
 
             return accuracyValue;
         }
@@ -143,17 +172,14 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
         /// and the hit judgements, assuming the player's mean hit error is 0. The estimation is consistent in that
         /// two SS scores on the same map with the same settings will always return the same deviation.
         /// </summary>
-        private double? computeDeviationUpperBound()
+        private double computeDeviationUpperBound(double accuracy)
         {
-            if (countGreat == 0 || greatHitWindow <= 0)
-                return null;
-
             const double z = 2.32634787404; // 99% critical value for the normal distribution (one-tailed).
 
             double n = totalHits;
 
             // Proportion of greats hit.
-            double p = countGreat / n;
+            double p = accuracy;
 
             // We can be 99% confident that p is at least this value.
             double pLowerBound = (n * p + z * z / 2) / (n + z * z) - z / (n + z * z) * Math.Sqrt(n * p * (1 - p) + z * z / 4);

osu.Game.Rulesets.Taiko/Difficulty/Utils/DeltaTimeNormaliser.cs

@@ -0,0 +1,66 @@
+// 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 System.Collections.Generic;
+using System.Linq;
+using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Utils
+{
+    /// <summary>
+    /// Normalises deltaTime values for TaikoDifficultyHitObjects.
+    /// </summary>
+    public static class DeltaTimeNormaliser
+    {
+        /// <summary>
+        /// Combines deltaTime values that differ by at most <paramref name="marginOfError"/>
+        /// and replaces each value with the median of its range. This is used to reduce timing noise
+        /// and improve rhythm grouping consistency, especially for maps with inconsistent or 'off-snapped' timing.
+        /// </summary>
+        public static Dictionary<TaikoDifficultyHitObject, double> Normalise(
+            IReadOnlyList<TaikoDifficultyHitObject> hitObjects,
+            double marginOfError)
+        {
+            var deltaTimes = hitObjects.Select(h => h.DeltaTime).Distinct().OrderBy(d => d).ToList();
+
+            var sets = new List<List<double>>();
+            List<double>? current = null;
+
+            foreach (double value in deltaTimes)
+            {
+                // Add to the current group if within margin of error
+                if (current != null && Math.Abs(value - current[0]) <= marginOfError)
+                {
+                    current.Add(value);
+                    continue;
+                }
+
+                // Otherwise begin a new group
+                current = new List<double> { value };
+                sets.Add(current);
+            }
+
+            // Compute median for each group
+            var medianLookup = new Dictionary<double, double>();
+
+            foreach (var set in sets)
+            {
+                set.Sort();
+                int mid = set.Count / 2;
+                double median = set.Count % 2 == 1
+                    ? set[mid]
+                    : (set[mid - 1] + set[mid]) / 2;
+
+                foreach (double v in set)
+                    medianLookup[v] = median;
+            }
+
+            // Assign each hitobjects deltaTime the corresponding median value
+            return hitObjects.ToDictionary(
+                h => h,
+                h => medianLookup.TryGetValue(h.DeltaTime, out double median) ? median : h.DeltaTime
+            );
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Difficulty/Utils/IntervalGroupingUtils.cs

@@ -8,6 +8,9 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Utils
 {
     public static class IntervalGroupingUtils
     {
+        // The margin of error when comparing intervals for grouping, or snapping intervals to a common value.
+        public const double MARGIN_OF_ERROR = 5.0;
+
         public static List<List<T>> GroupByInterval<T>(IReadOnlyList<T> objects) where T : IHasInterval
         {
             var groups = new List<List<T>>();
@@ -21,8 +24,6 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Utils
 
         private static List<T> createNextGroup<T>(IReadOnlyList<T> objects, ref int i) where T : IHasInterval
         {
-            const double margin_of_error = 5;
-
             // This never compares the first two elements in the group.
             // This sounds wrong but is apparently "as intended" (https://github.com/ppy/osu/pull/31636#discussion_r1942673329)
             var groupedObjects = new List<T> { objects[i] };
@@ -30,11 +31,11 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Utils
 
             for (; i < objects.Count - 1; i++)
             {
-                if (!Precision.AlmostEquals(objects[i].Interval, objects[i + 1].Interval, margin_of_error))
+                if (!Precision.AlmostEquals(objects[i].Interval, objects[i + 1].Interval, MARGIN_OF_ERROR))
                 {
                     // When an interval change occurs, include the object with the differing interval in the case it increased
                     // See https://github.com/ppy/osu/pull/31636#discussion_r1942368372 for rationale.
-                    if (objects[i + 1].Interval > objects[i].Interval + margin_of_error)
+                    if (objects[i + 1].Interval > objects[i].Interval + MARGIN_OF_ERROR)
                     {
                         groupedObjects.Add(objects[i]);
                         i++;
@@ -49,7 +50,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Utils
 
             // Check if the last two objects in the object form a "flat" rhythm pattern within the specified margin of error.
             // If true, add the current object to the group and increment the index to process the next object.
-            if (objects.Count > 2 && i < objects.Count && Precision.AlmostEquals(objects[^1].Interval, objects[^2].Interval, margin_of_error))
+            if (objects.Count > 2 && i < objects.Count && Precision.AlmostEquals(objects[^1].Interval, objects[^2].Interval, MARGIN_OF_ERROR))
             {
                 groupedObjects.Add(objects[i]);
                 i++;

osu.Game.Tests/Extensions/NumberFormattingExtensionsTest.cs

@@ -46,9 +46,12 @@ namespace osu.Game.Tests.Extensions
 
         [Test]
         [SetCulture("fr-FR")]
-        public void TestCultureInsensitivity()
+        [TestCase(0.4, true, 2, ExpectedResult = "40%")]
+        [TestCase(1e-6, false, 6, ExpectedResult = "0.000001")]
+        [TestCase(0.48333, true, 4, ExpectedResult = "48.33%")]
+        public string TestCultureInsensitivity(double input, bool percent, int decimalDigits)
         {
-            Assert.That(0.4.ToStandardFormattedString(maxDecimalDigits: 2, asPercentage: true), Is.EqualTo("40%"));
+            return input.ToStandardFormattedString(decimalDigits, percent);
         }
     }
 }

osu.Game.Tests/Visual/Editing/TestSceneSubmissionStageProgress.cs

@@ -68,6 +68,25 @@ namespace osu.Game.Tests.Visual.Editing
                         progress.SetInProgress(incrementingProgress += RNG.NextSingle(0.08f));
                 }, 0, true);
             });
+            AddStep("increase progress slowly then fail", () =>
+            {
+                incrementingProgress = 0;
+
+                ScheduledDelegate? task = null;
+
+                task = Scheduler.AddDelayed(() =>
+                {
+                    if (incrementingProgress >= 1)
+                    {
+                        progress.SetFailed("nope");
+                        // ReSharper disable once AccessToModifiedClosure
+                        task?.Cancel();
+                        return;
+                    }
+
+                    progress.SetInProgress(incrementingProgress += RNG.NextSingle(0.001f));
+                }, 0, true);
+            });
 
             AddUntilStep("wait for completed", () => incrementingProgress >= 1);
             AddStep("completed", () => progress.SetCompleted());

osu.Game.Tests/Visual/Gameplay/TestSceneArgonJudgementCounter.cs

@@ -183,6 +183,9 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("Show all judgements", () => counterDisplay.Mode.Value = ArgonJudgementCounterDisplay.DisplayMode.All);
             AddWaitStep("wait some", 2);
             AddAssert("Check all visible", () => counterDisplay.CounterFlow.ChildrenOfType<ArgonJudgementCounter>().Last().Alpha == 1);
+            AddToggleStep("toggle wireframe display", t => counterDisplay.WireframeOpacity.Value = t ? 0.3f : 0);
+            AddStep("Set direction vertical", () => counterDisplay.FlowDirection.Value = Direction.Vertical);
+            AddStep("Set direction horizontal", () => counterDisplay.FlowDirection.Value = Direction.Horizontal);
         }
 
         private int hiddenCount()

osu.Game.Tests/Visual/Gameplay/TestScenePlayerScoreSubmission.cs

@@ -316,6 +316,26 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("ensure no submission", () => Player.SubmittedScore == null);
         }
 
+        [Test]
+        public void TestNoSubmissionOnLocallyModifiedBeatmapWithOnlineId()
+        {
+            prepareTestAPI(true);
+
+            createPlayerTest(false, r =>
+            {
+                var beatmap = createTestBeatmap(r);
+                beatmap.BeatmapInfo.Status = BeatmapOnlineStatus.LocallyModified;
+                return beatmap;
+            });
+
+            AddUntilStep("wait for token request", () => Player.TokenCreationRequested);
+
+            addFakeHit();
+
+            AddStep("exit", () => Player.Exit());
+            AddAssert("ensure no submission", () => Player.SubmittedScore == null);
+        }
+
         [TestCase(null)]
         [TestCase(10)]
         public void TestNoSubmissionOnCustomRuleset(int? rulesetId)

osu.Game.Tests/Visual/Matchmaking/TestSceneBeatmapSelectGrid.cs

@@ -0,0 +1,210 @@
+// 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 System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match.BeatmapSelect;
+using osu.Game.Tests.Visual.OnlinePlay;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneBeatmapSelectGrid : OnlinePlayTestScene
+    {
+        private MultiplayerPlaylistItem[] items = null!;
+
+        private BeatmapSelectGrid grid = null!;
+
+        [Resolved]
+        private BeatmapManager beatmapManager { get; set; } = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            var beatmaps = beatmapManager.GetAllUsableBeatmapSets()
+                                         .SelectMany(it => it.Beatmaps)
+                                         .Take(50)
+                                         .ToArray();
+
+            if (beatmaps.Length > 0)
+            {
+                items = Enumerable.Range(1, 50).Select(i => new MultiplayerPlaylistItem
+                {
+                    ID = i,
+                    BeatmapID = beatmaps[i % beatmaps.Length].OnlineID,
+                    StarRating = i / 10.0,
+                }).ToArray();
+            }
+            else
+            {
+                items = Enumerable.Range(1, 50).Select(i => new MultiplayerPlaylistItem
+                {
+                    ID = i,
+                    BeatmapID = i,
+                    StarRating = i / 10.0,
+                }).ToArray();
+            }
+        }
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("add grid", () => Child = grid = new BeatmapSelectGrid
+            {
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Scale = new Vector2(0.8f),
+            });
+
+            AddStep("add items", () =>
+            {
+                foreach (var item in items)
+                    grid.AddItem(item);
+            });
+
+            AddWaitStep("wait for panels", 3);
+        }
+
+        [Test]
+        public void TestBasic()
+        {
+            AddStep("do nothing", () =>
+            {
+                // test scene is weird.
+            });
+
+            AddStep("add selection 1", () => grid.ChildrenOfType<BeatmapSelectPanel>().First().AddUser(new APIUser
+            {
+                Id = 6411631,
+                Username = "Maarvin",
+            }, isOwnUser: true));
+            AddStep("add selection 2", () => grid.ChildrenOfType<BeatmapSelectPanel>().Skip(5).First().AddUser(new APIUser
+            {
+                Id = 2,
+                Username = "peppy",
+            }));
+            AddStep("add selection 3", () => grid.ChildrenOfType<BeatmapSelectPanel>().Skip(10).First().AddUser(new APIUser
+            {
+                Id = 1040328,
+                Username = "smoogipoo",
+            }));
+        }
+
+        [Test]
+        public void TestCompleteRollAnimation()
+        {
+            AddStep("play animation", () =>
+            {
+                var (candidateItems, finalItem) = pickRandomItems(5);
+
+                grid.RollAndDisplayFinalBeatmap(candidateItems, finalItem);
+            });
+        }
+
+        [Test]
+        public void TestRollAnimation()
+        {
+            AddStep("play animation", () =>
+            {
+                var (candidateItems, finalItem) = pickRandomItems(5);
+
+                grid.TransferCandidatePanelsToRollContainer(candidateItems, duration: 0);
+                grid.ArrangeItemsForRollAnimation(duration: 0, stagger: 0);
+
+                Scheduler.AddDelayed(() => grid.PlayRollAnimation(finalItem), 500);
+            });
+        }
+
+        [Test]
+        public void TestPresentRolledBeatmap()
+        {
+            AddStep("present beatmap", () =>
+            {
+                var (candidateItems, finalItem) = pickRandomItems(5);
+
+                grid.TransferCandidatePanelsToRollContainer(candidateItems, duration: 0);
+                grid.ArrangeItemsForRollAnimation(duration: 0, stagger: 0);
+                grid.PlayRollAnimation(finalItem, duration: 0);
+
+                Scheduler.AddDelayed(() => grid.PresentRolledBeatmap(finalItem), 500);
+            });
+        }
+
+        [Test]
+        public void TestPresentUnanimouslyChosenBeatmap()
+        {
+            AddStep("present beatmap", () =>
+            {
+                var (candidateItems, finalItem) = pickRandomItems(5);
+
+                grid.TransferCandidatePanelsToRollContainer(candidateItems, duration: 0);
+                grid.ArrangeItemsForRollAnimation(duration: 0, stagger: 0);
+                grid.PlayRollAnimation(finalItem, duration: 0);
+
+                Scheduler.AddDelayed(() => grid.PresentUnanimouslyChosenBeatmap(finalItem), 500);
+            });
+        }
+
+        [TestCase(1)]
+        [TestCase(2)]
+        [TestCase(3)]
+        [TestCase(4)]
+        [TestCase(5)]
+        [TestCase(6)]
+        [TestCase(7)]
+        [TestCase(8)]
+        public void TestPanelArrangement(int count)
+        {
+            AddStep("arrange panels", () =>
+            {
+                var (candidateItems, _) = pickRandomItems(count);
+
+                grid.TransferCandidatePanelsToRollContainer(candidateItems);
+                grid.Delay(BeatmapSelectGrid.ARRANGE_DELAY)
+                    .Schedule(() => grid.ArrangeItemsForRollAnimation());
+            });
+
+            AddWaitStep("wait for movement", 5);
+
+            AddStep("display roll order", () =>
+            {
+                var panels = grid.ChildrenOfType<BeatmapSelectPanel>().ToArray();
+
+                for (int i = 0; i < panels.Length; i++)
+                {
+                    var panel = panels[i];
+
+                    panel.Add(new OsuSpriteText
+                    {
+                        Text = (i + 1).ToString(),
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Font = OsuFont.Default.With(size: 50, weight: FontWeight.SemiBold),
+                    });
+                }
+            });
+        }
+
+        private (long[] candidateItems, long finalItem) pickRandomItems(int count)
+        {
+            long[] candidateItems = items.Select(it => it.ID).ToArray();
+            Random.Shared.Shuffle(candidateItems);
+            candidateItems = candidateItems.Take(count).ToArray();
+
+            long finalItem = candidateItems[Random.Shared.Next(candidateItems.Length)];
+
+            return (candidateItems, finalItem);
+        }
+    }
+}

osu.Game.Tests/Visual/Matchmaking/TestSceneBeatmapSelectPanel.cs

@@ -0,0 +1,57 @@
+// 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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Rooms;
+using osu.Game.Overlays;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match.BeatmapSelect;
+using osu.Game.Tests.Visual.Multiplayer;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneBeatmapSelectPanel : MultiplayerTestScene
+    {
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Purple);
+
+        [Test]
+        public void TestBeatmapPanel()
+        {
+            BeatmapSelectPanel? panel = null;
+
+            AddStep("add panel", () => Child = panel = new BeatmapSelectPanel(new MultiplayerPlaylistItem())
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+            });
+
+            AddStep("add maarvin", () => panel!.AddUser(new APIUser
+            {
+                Id = 6411631,
+                Username = "Maarvin",
+            }, isOwnUser: true));
+            AddStep("add peppy", () => panel!.AddUser(new APIUser
+            {
+                Id = 2,
+                Username = "peppy",
+            }));
+            AddStep("add smogipoo", () => panel!.AddUser(new APIUser
+            {
+                Id = 1040328,
+                Username = "smoogipoo",
+            }));
+            AddStep("remove smogipoo", () => panel!.RemoveUser(new APIUser { Id = 1040328 }));
+            AddStep("remove peppy", () => panel!.RemoveUser(new APIUser { Id = 2 }));
+            AddStep("remove maarvin", () => panel!.RemoveUser(new APIUser { Id = 6411631 }));
+
+            AddToggleStep("allow selection", value =>
+            {
+                if (panel != null)
+                    panel.AllowSelection = value;
+            });
+        }
+    }
+}

osu.Game.Tests/Visual/Matchmaking/TestSceneIdleScreen.cs

@@ -0,0 +1,90 @@
+// 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 System.Linq;
+using NUnit.Framework;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Screens;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match.RoundWarmup;
+using osu.Game.Tests.Visual.Multiplayer;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneIdleScreen : MultiplayerTestScene
+    {
+        private const int user_count = 8;
+
+        private (MultiplayerRoomUser user, int score)[] userScores = null!;
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom(MatchType.Matchmaking)));
+            WaitForJoined();
+
+            AddStep("add list", () =>
+            {
+                userScores = Enumerable.Range(1, user_count).Select(i =>
+                {
+                    var user = new MultiplayerRoomUser(i)
+                    {
+                        User = new APIUser
+                        {
+                            Username = $"Player {i}"
+                        }
+                    };
+
+                    return (user, 0);
+                }).ToArray();
+
+                Child = new ScreenStack(new SubScreenRoundWarmup())
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(0.8f)
+                };
+            });
+
+            AddStep("join users", () =>
+            {
+                foreach (var (user, _) in userScores)
+                    MultiplayerClient.AddUser(user);
+            });
+        }
+
+        [Test]
+        public void TestRandomChanges()
+        {
+            AddStep("apply random changes", () =>
+            {
+                int[] deltas = Enumerable.Range(1, userScores.Length).ToArray();
+                new Random().Shuffle(deltas);
+
+                for (int i = 0; i < userScores.Length; i++)
+                    userScores[i] = (userScores[i].user, userScores[i].score + deltas[i]);
+                userScores = userScores.OrderByDescending(u => u.score).ToArray();
+
+                MultiplayerClient.ChangeMatchRoomState(new MatchmakingRoomState
+                {
+                    Users =
+                    {
+                        UserDictionary = userScores.Select((tuple, i) => new MatchmakingUser
+                        {
+                            UserId = tuple.user.UserID,
+                            Points = tuple.score,
+                            Placement = i + 1
+                        }).ToDictionary(s => s.UserId)
+                    }
+                }).WaitSafely();
+            });
+        }
+    }
+}

osu.Game.Tests/Visual/Matchmaking/TestSceneMatchmakingCloud.cs

@@ -0,0 +1,44 @@
+// 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.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Utils;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Queue;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneMatchmakingCloud : OsuTestScene
+    {
+        private CloudVisualisation cloud = null!;
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Child = cloud = new CloudVisualisation
+            {
+                RelativeSizeAxes = Axes.Both,
+            };
+        }
+
+        [Test]
+        public void TestBasic()
+        {
+            AddStep("refresh users", () =>
+            {
+                var testUsers = Enumerable.Range(0, 50).Select(_ => new APIUser
+                {
+                    Username = "peppy",
+                    Statistics = new UserStatistics { GlobalRank = 1234 },
+                    Id = RNG.Next(2, 30000000),
+                }).ToArray();
+
+                cloud.Users = testUsers;
+            });
+        }
+    }
+}

osu.Game.Tests/Visual/Matchmaking/TestSceneMatchmakingPoolSelector.cs

@@ -0,0 +1,35 @@
+// 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 osu.Framework.Graphics;
+using osu.Game.Online.Matchmaking;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Queue;
+using osu.Game.Tests.Visual.Multiplayer;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneMatchmakingPoolSelector : MultiplayerTestScene
+    {
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("add selector", () => Child = new PoolSelector
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                AvailablePools =
+                {
+                    Value =
+                    [
+                        new MatchmakingPool { Id = 0, RulesetId = 0 },
+                        new MatchmakingPool { Id = 1, RulesetId = 1 },
+                        new MatchmakingPool { Id = 2, RulesetId = 2 },
+                        new MatchmakingPool { Id = 3, RulesetId = 3, Variant = 4 },
+                        new MatchmakingPool { Id = 4, RulesetId = 3, Variant = 7 },
+                    ]
+                }
+            });
+        }
+    }
+}

osu.Game.Tests/Visual/Matchmaking/TestSceneMatchmakingQueueScreen.cs

@@ -0,0 +1,58 @@
+// 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.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Intro;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Queue;
+using osu.Game.Tests.Visual.Multiplayer;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneMatchmakingQueueScreen : MultiplayerTestScene
+    {
+        [Cached]
+        private readonly QueueController controller = new QueueController();
+
+        private ScreenQueue? queueScreen => Stack.CurrentScreen as ScreenQueue;
+
+        [SetUpSteps]
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("load screen", () => LoadScreen(new IntroScreen()));
+        }
+
+        [Test]
+        public void TestBasic()
+        {
+            AddUntilStep("wait for queue screen", () => queueScreen?.IsLoaded == true);
+
+            AddStep("set users", () =>
+            {
+                queueScreen!.Users = Enumerable.Range(0, 10).Select(_ => new APIUser
+                {
+                    Username = "peppy",
+                    Statistics = new UserStatistics { GlobalRank = 1234 },
+                    Id = RNG.Next(2, 30000000),
+                }).ToArray();
+            });
+
+            AddStep("change state to idle", () => queueScreen!.SetState(ScreenQueue.MatchmakingScreenState.Idle));
+
+            AddStep("change state to queueing", () => queueScreen!.SetState(ScreenQueue.MatchmakingScreenState.Queueing));
+
+            AddStep("change state to found match", () => queueScreen!.SetState(ScreenQueue.MatchmakingScreenState.PendingAccept));
+
+            AddStep("change state to waiting for room", () => queueScreen!.SetState(ScreenQueue.MatchmakingScreenState.AcceptedWaitingForRoom));
+
+            AddStep("change state to in room", () => queueScreen!.SetState(ScreenQueue.MatchmakingScreenState.InRoom));
+        }
+    }
+}

osu.Game.Tests/Visual/Matchmaking/TestSceneMatchmakingScreen.cs

@@ -0,0 +1,196 @@
+// 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 System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Extensions;
+using osu.Framework.Screens;
+using osu.Framework.Utils;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Online.Rooms;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match;
+using osu.Game.Tests.Visual.Multiplayer;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneMatchmakingScreen : MultiplayerTestScene
+    {
+        private const int user_count = 8;
+        private const int beatmap_count = 50;
+
+        private MultiplayerRoomUser[] users = null!;
+        private ScreenMatchmaking screen = null!;
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () =>
+            {
+                var room = CreateDefaultRoom(MatchType.Matchmaking);
+                room.Playlist = Enumerable.Range(1, 50).Select(i => new PlaylistItem(new MultiplayerPlaylistItem
+                {
+                    ID = i,
+                    BeatmapID = i,
+                    StarRating = i / 10.0,
+                })).ToArray();
+
+                JoinRoom(room);
+            });
+
+            WaitForJoined();
+
+            AddStep("join users", () =>
+            {
+                for (int i = 0; i < 7; i++)
+                {
+                    MultiplayerClient.AddUser(new MultiplayerRoomUser(i)
+                    {
+                        User = new APIUser
+                        {
+                            Username = $"User {i}"
+                        }
+                    });
+                }
+            });
+
+            setupRequestHandler();
+
+            AddStep("load match", () =>
+            {
+                users = Enumerable.Range(1, user_count).Select(i => new MultiplayerRoomUser(i)
+                {
+                    User = new APIUser
+                    {
+                        Username = $"Player {i}"
+                    }
+                }).ToArray();
+
+                var beatmaps = Enumerable.Range(1, beatmap_count).Select(i => new MultiplayerPlaylistItem
+                {
+                    BeatmapID = i,
+                    StarRating = i / 10.0
+                }).ToArray();
+
+                LoadScreen(screen = new ScreenMatchmaking(new MultiplayerRoom(0)
+                {
+                    Users = users,
+                    Playlist = beatmaps
+                }));
+            });
+            AddUntilStep("wait for load", () => screen.IsCurrentScreen());
+        }
+
+        [Test]
+        public void TestGameplayFlow()
+        {
+            for (int round = 1; round <= 3; round++)
+            {
+                AddLabel($"Round {round}");
+
+                int r = round;
+                changeStage(MatchmakingStage.RoundWarmupTime, state => state.CurrentRound = r);
+                changeStage(MatchmakingStage.UserBeatmapSelect);
+                changeStage(MatchmakingStage.ServerBeatmapFinalised, state =>
+                {
+                    MultiplayerPlaylistItem[] beatmaps = Enumerable.Range(1, 8).Select(i => new MultiplayerPlaylistItem
+                    {
+                        ID = i,
+                        BeatmapID = i,
+                        StarRating = i / 10.0,
+                    }).ToArray();
+
+                    state.CandidateItems = beatmaps.Select(b => b.ID).ToArray();
+                    state.CandidateItem = beatmaps[0].ID;
+                }, waitTime: 35);
+
+                changeStage(MatchmakingStage.WaitingForClientsBeatmapDownload);
+                changeStage(MatchmakingStage.GameplayWarmupTime);
+                changeStage(MatchmakingStage.Gameplay);
+                changeStage(MatchmakingStage.ResultsDisplaying);
+            }
+
+            changeStage(MatchmakingStage.Ended, state =>
+            {
+                int localUserId = API.LocalUser.Value.OnlineID;
+
+                state.Users[localUserId].Placement = 1;
+                state.Users[localUserId].Rounds[1].Placement = 1;
+                state.Users[localUserId].Rounds[1].TotalScore = 1;
+                state.Users[localUserId].Rounds[1].Statistics[HitResult.LargeBonus] = 1;
+            });
+        }
+
+        private void changeStage(MatchmakingStage stage, Action<MatchmakingRoomState>? prepare = null, int waitTime = 5)
+        {
+            AddStep($"stage: {stage}", () => MultiplayerClient.MatchmakingChangeStage(stage, prepare).WaitSafely());
+            AddWaitStep("wait", waitTime);
+        }
+
+        private void setupRequestHandler()
+        {
+            AddStep("setup request handler", () =>
+            {
+                Func<APIRequest, bool>? defaultRequestHandler = null;
+
+                ((DummyAPIAccess)API).HandleRequest = request =>
+                {
+                    switch (request)
+                    {
+                        case GetBeatmapsRequest getBeatmaps:
+                            getBeatmaps.TriggerSuccess(new GetBeatmapsResponse
+                            {
+                                Beatmaps = getBeatmaps.BeatmapIds.Select(id => new APIBeatmap
+                                {
+                                    OnlineID = id,
+                                    StarRating = id,
+                                    DifficultyName = $"Beatmap {id}",
+                                    BeatmapSet = new APIBeatmapSet
+                                    {
+                                        Title = $"Title {id}",
+                                        Artist = $"Artist {id}",
+                                        AuthorString = $"Author {id}"
+                                    }
+                                }).ToList()
+                            });
+                            return true;
+
+                        case IndexPlaylistScoresRequest index:
+                            var result = new IndexedMultiplayerScores();
+
+                            for (int i = 0; i < 8; ++i)
+                            {
+                                result.Scores.Add(new MultiplayerScore
+                                {
+                                    ID = i,
+                                    Accuracy = 1 - (float)i / 16,
+                                    Position = i + 1,
+                                    EndedAt = DateTimeOffset.Now,
+                                    Passed = true,
+                                    Rank = (ScoreRank)RNG.Next((int)ScoreRank.D, (int)ScoreRank.XH),
+                                    MaxCombo = 1000 - i,
+                                    TotalScore = (long)(1_000_000 * (1 - (float)i / 16)),
+                                    User = new APIUser { Username = $"user {i}" },
+                                    Statistics = new Dictionary<HitResult, int>()
+                                });
+                            }
+
+                            index.TriggerSuccess(result);
+                            return true;
+
+                        default:
+                            return defaultRequestHandler?.Invoke(request) ?? false;
+                    }
+                };
+            });
+        }
+    }
+}

osu.Game.Tests/Visual/Matchmaking/TestScenePanelRoomAward.cs

@@ -0,0 +1,23 @@
+// 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 osu.Framework.Graphics;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match.Results;
+using osu.Game.Tests.Visual.Multiplayer;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestScenePanelRoomAward : MultiplayerTestScene
+    {
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("add statistic", () => Child = new PanelRoomAward("Statistic description", 1)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre
+            });
+        }
+    }
+}

osu.Game.Tests/Visual/Matchmaking/TestScenePickScreen.cs

@@ -0,0 +1,111 @@
+// 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 System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Screens;
+using osu.Framework.Utils;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match.BeatmapSelect;
+using osu.Game.Tests.Visual.Multiplayer;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestScenePickScreen : MultiplayerTestScene
+    {
+        private readonly IReadOnlyList<APIUser> users = new[]
+        {
+            new APIUser
+            {
+                Id = 2,
+                Username = "peppy",
+            },
+            new APIUser
+            {
+                Id = 1040328,
+                Username = "smoogipoo",
+            },
+            new APIUser
+            {
+                Id = 6573093,
+                Username = "OliBomby",
+            },
+            new APIUser
+            {
+                Id = 7782553,
+                Username = "aesth",
+            },
+            new APIUser
+            {
+                Id = 6411631,
+                Username = "Maarvin",
+            }
+        };
+
+        private readonly PlaylistItem[] items = Enumerable.Range(1, 50).Select(i => new PlaylistItem(new MultiplayerPlaylistItem
+        {
+            ID = i,
+            BeatmapID = i,
+            StarRating = i / 10.0,
+        })).ToArray();
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () =>
+            {
+                var room = CreateDefaultRoom(MatchType.Matchmaking);
+                room.Playlist = items;
+
+                JoinRoom(room);
+            });
+
+            WaitForJoined();
+
+            AddStep("add users", () =>
+            {
+                foreach (var user in users)
+                    MultiplayerClient.AddUser(user);
+            });
+        }
+
+        [Test]
+        public void TestScreen()
+        {
+            var selectedItems = new List<long>();
+
+            SubScreenBeatmapSelect screen = null!;
+
+            AddStep("add screen", () => Child = new ScreenStack(screen = new SubScreenBeatmapSelect()));
+
+            AddStep("select maps", () =>
+            {
+                selectedItems.Clear();
+
+                foreach (var user in users)
+                {
+                    var item = items[Random.Shared.Next(items.Length)];
+                    selectedItems.Add(item.ID);
+
+                    Scheduler.AddDelayed(() =>
+                    {
+                        MultiplayerClient.MatchmakingToggleUserSelection(user.Id, item.ID).FireAndForget();
+                    }, RNG.NextDouble(10, 1000));
+                }
+            });
+
+            AddStep("show final map", () =>
+            {
+                long[] candidateItems = selectedItems.ToArray();
+                long finalItem = candidateItems[Random.Shared.Next(candidateItems.Length)];
+
+                screen.RollFinalBeatmap(candidateItems, finalItem);
+            });
+        }
+    }
+}

osu.Game.Tests/Visual/Matchmaking/TestScenePlayerPanel.cs

@@ -0,0 +1,102 @@
+// 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 NUnit.Framework;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Matchmaking.Events;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match;
+using osu.Game.Tests.Visual.Multiplayer;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestScenePlayerPanel : MultiplayerTestScene
+    {
+        private PlayerPanel panel = null!;
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom(MatchType.Matchmaking)));
+            WaitForJoined();
+
+            AddStep("add panel", () => Child = panel = new PlayerPanel(new MultiplayerRoomUser(1)
+            {
+                User = new APIUser
+                {
+                    Username = @"peppy",
+                    Id = 2,
+                    Colour = "99EB47",
+                    CountryCode = CountryCode.AU,
+                    CoverUrl = @"https://assets.ppy.sh/user-profile-covers/8195163/4a8e2ad5a02a2642b631438cfa6c6bd7e2f9db289be881cb27df18331f64144c.jpeg",
+                    Statistics = new UserStatistics { GlobalRank = null, CountryRank = null }
+                }
+            })
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre
+            });
+        }
+
+        [Test]
+        public void TestIncreasePlacement()
+        {
+            int rank = 0;
+
+            AddStep("increase placement", () => MultiplayerClient.ChangeMatchRoomState(new MatchmakingRoomState
+            {
+                Users =
+                {
+                    UserDictionary =
+                    {
+                        {
+                            2, new MatchmakingUser
+                            {
+                                UserId = 2,
+                                Placement = ++rank
+                            }
+                        }
+                    }
+                }
+            }).WaitSafely());
+
+            AddToggleStep("toggle horizontal", h => panel.Horizontal = h);
+        }
+
+        [Test]
+        public void TestIncreasePoints()
+        {
+            int points = 0;
+
+            AddStep("increase points", () => MultiplayerClient.ChangeMatchRoomState(new MatchmakingRoomState
+            {
+                Users =
+                {
+                    UserDictionary =
+                    {
+                        {
+                            1, new MatchmakingUser
+                            {
+                                UserId = 1,
+                                Placement = 1,
+                                Points = ++points
+                            }
+                        }
+                    }
+                }
+            }).WaitSafely());
+        }
+
+        [Test]
+        public void TestJump()
+        {
+            AddStep("jump", () => MultiplayerClient.SendUserMatchRequest(1, new MatchmakingAvatarActionRequest { Action = MatchmakingAvatarAction.Jump }).WaitSafely());
+        }
+    }
+}

osu.Game.Tests/Visual/Matchmaking/TestSceneResultsScreen.cs

@@ -0,0 +1,99 @@
+// 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 NUnit.Framework;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Screens;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Online.Rooms;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match.Results;
+using osu.Game.Tests.Visual.Multiplayer;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneResultsScreen : MultiplayerTestScene
+    {
+        private const int invalid_user_id = 1;
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom(MatchType.Matchmaking)));
+            WaitForJoined();
+
+            AddStep("add results screen", () =>
+            {
+                Child = new ScreenStack(new SubScreenResults())
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(0.8f)
+                };
+            });
+
+            AddStep("join another user", () => MultiplayerClient.AddUser(new MultiplayerRoomUser(invalid_user_id)
+            {
+                User = new APIUser
+                {
+                    Id = invalid_user_id,
+                    Username = "Invalid user"
+                }
+            }));
+        }
+
+        [Test]
+        public void TestResults()
+        {
+            AddStep("set results stage", () =>
+            {
+                var state = new MatchmakingRoomState
+                {
+                    CurrentRound = 6,
+                    Stage = MatchmakingStage.Ended
+                };
+
+                int localUserId = API.LocalUser.Value.OnlineID;
+
+                // Overall state.
+                state.Users[localUserId].Placement = 1;
+                state.Users[localUserId].Points = 8;
+                state.Users[invalid_user_id].Placement = 2;
+                state.Users[invalid_user_id].Points = 7;
+                for (int round = 1; round <= state.CurrentRound; round++)
+                    state.Users[localUserId].Rounds[round].Placement = round;
+
+                // Highest score.
+                state.Users[localUserId].Rounds[1].TotalScore = 1000;
+                state.Users[invalid_user_id].Rounds[1].TotalScore = 990;
+
+                // Highest accuracy.
+                state.Users[localUserId].Rounds[2].Accuracy = 0.9995;
+                state.Users[invalid_user_id].Rounds[2].Accuracy = 0.5;
+
+                // Highest combo.
+                state.Users[localUserId].Rounds[3].MaxCombo = 100;
+                state.Users[invalid_user_id].Rounds[3].MaxCombo = 10;
+
+                // Most bonus score.
+                state.Users[localUserId].Rounds[4].Statistics[HitResult.LargeBonus] = 50;
+                state.Users[invalid_user_id].Rounds[4].Statistics[HitResult.LargeBonus] = 25;
+
+                // Smallest score difference.
+                state.Users[localUserId].Rounds[5].TotalScore = 1000;
+                state.Users[invalid_user_id].Rounds[5].TotalScore = 999;
+
+                // Largest score difference.
+                state.Users[localUserId].Rounds[6].TotalScore = 1000;
+                state.Users[invalid_user_id].Rounds[6].TotalScore = 0;
+
+                MultiplayerClient.ChangeMatchRoomState(state).WaitSafely();
+            });
+        }
+    }
+}

osu.Game.Tests/Visual/Matchmaking/TestSceneRoundResultsScreen.cs

@@ -0,0 +1,102 @@
+// 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 System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Graphics;
+using osu.Framework.Screens;
+using osu.Framework.Utils;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Rooms;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match.RoundResults;
+using osu.Game.Tests.Visual.Multiplayer;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneRoundResultsScreen : MultiplayerTestScene
+    {
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom(MatchType.Matchmaking)));
+            WaitForJoined();
+
+            setupRequestHandler();
+
+            AddStep("load screen", () =>
+            {
+                Child = new ScreenStack(new SubScreenRoundResults())
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(0.8f)
+                };
+            });
+        }
+
+        private void setupRequestHandler()
+        {
+            AddStep("setup request handler", () =>
+            {
+                Func<APIRequest, bool>? defaultRequestHandler = null;
+
+                ((DummyAPIAccess)API).HandleRequest = request =>
+                {
+                    switch (request)
+                    {
+                        case GetBeatmapsRequest getBeatmaps:
+                            getBeatmaps.TriggerSuccess(new GetBeatmapsResponse
+                            {
+                                Beatmaps = getBeatmaps.BeatmapIds.Select(id => new APIBeatmap
+                                {
+                                    OnlineID = id,
+                                    StarRating = id,
+                                    DifficultyName = $"Beatmap {id}",
+                                    BeatmapSet = new APIBeatmapSet
+                                    {
+                                        Title = $"Title {id}",
+                                        Artist = $"Artist {id}",
+                                        AuthorString = $"Author {id}"
+                                    }
+                                }).ToList()
+                            });
+                            return true;
+
+                        case IndexPlaylistScoresRequest index:
+                            var result = new IndexedMultiplayerScores();
+
+                            for (int i = 0; i < 8; ++i)
+                            {
+                                result.Scores.Add(new MultiplayerScore
+                                {
+                                    ID = i,
+                                    Accuracy = 1 - (float)i / 16,
+                                    Position = i + 1,
+                                    EndedAt = DateTimeOffset.Now,
+                                    Passed = true,
+                                    Rank = (ScoreRank)RNG.Next((int)ScoreRank.D, (int)ScoreRank.XH),
+                                    MaxCombo = 1000 - i,
+                                    TotalScore = (long)(1_000_000 * (1 - (float)i / 16)),
+                                    User = new APIUser { Username = $"user {i}" },
+                                    Statistics = new Dictionary<HitResult, int>()
+                                });
+                            }
+
+                            index.TriggerSuccess(result);
+                            return true;
+
+                        default:
+                            return defaultRequestHandler?.Invoke(request) ?? false;
+                    }
+                };
+            });
+        }
+    }
+}

osu.Game.Tests/Visual/Matchmaking/TestSceneStageDisplay.cs

@@ -0,0 +1,61 @@
+// 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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Online.Rooms;
+using osu.Game.Overlays;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match;
+using osu.Game.Tests.Visual.Multiplayer;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneStageDisplay : MultiplayerTestScene
+    {
+        [Cached]
+        protected readonly OverlayColourProvider ColourProvider = new OverlayColourProvider(OverlayColourScheme.Plum);
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom(MatchType.Matchmaking)));
+            WaitForJoined();
+
+            AddStep("add display", () => Child = new StageDisplay
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.X,
+            });
+        }
+
+        [Test]
+        public void TestChangeStage()
+        {
+            addStage(MatchmakingStage.WaitingForClientsJoin);
+
+            for (int i = 1; i <= 5; i++)
+            {
+                addStage(MatchmakingStage.RoundWarmupTime);
+                addStage(MatchmakingStage.UserBeatmapSelect);
+                addStage(MatchmakingStage.ServerBeatmapFinalised);
+                addStage(MatchmakingStage.WaitingForClientsBeatmapDownload);
+                addStage(MatchmakingStage.GameplayWarmupTime);
+                addStage(MatchmakingStage.Gameplay);
+                addStage(MatchmakingStage.ResultsDisplaying);
+            }
+
+            addStage(MatchmakingStage.Ended);
+        }
+
+        private void addStage(MatchmakingStage stage)
+        {
+            AddStep($"{stage}", () => MultiplayerClient.MatchmakingChangeStage(stage).WaitSafely());
+            AddWaitStep("wait a bit", 10);
+        }
+    }
+}

osu.Game.Tests/Visual/Matchmaking/TestSceneStageSegment.cs

@@ -0,0 +1,49 @@
+// 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 NUnit.Framework;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Game.Online.Matchmaking;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match;
+using osu.Game.Tests.Visual.Multiplayer;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneStageSegment : MultiplayerTestScene
+    {
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom(MatchType.Matchmaking)));
+            WaitForJoined();
+
+            AddStep("add bubble", () => Child = new StageDisplay.StageSegment(null, MatchmakingStage.RoundWarmupTime, "Next Round")
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+            });
+        }
+
+        [Test]
+        public void TestStartStopCountdown()
+        {
+            MultiplayerCountdown countdown = null!;
+
+            AddStep("start countdown", () => MultiplayerClient.StartCountdown(countdown = new MatchmakingStageCountdown
+            {
+                Stage = MatchmakingStage.RoundWarmupTime,
+                TimeRemaining = TimeSpan.FromSeconds(5)
+            }).WaitSafely());
+
+            AddWaitStep("wait a bit", 10);
+
+            AddStep("stop countdown", () => MultiplayerClient.StopCountdown(countdown).WaitSafely());
+        }
+    }
+}

osu.Game.Tests/Visual/Matchmaking/TestSceneStatusText.cs

@@ -0,0 +1,41 @@
+// 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 NUnit.Framework;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match;
+using osu.Game.Tests.Visual.Multiplayer;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneStatusText : MultiplayerTestScene
+    {
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom(MatchType.Matchmaking)));
+            WaitForJoined();
+
+            AddStep("create display", () => Child = new StageDisplay.StatusText
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre
+            });
+        }
+
+        [Test]
+        public void TestChangeStage()
+        {
+            foreach (var stage in Enum.GetValues<MatchmakingStage>())
+            {
+                AddStep($"{stage}", () => MultiplayerClient.MatchmakingChangeStage(stage).WaitSafely());
+                AddWaitStep("wait a bit", 10);
+            }
+        }
+    }
+}

osu.Game.Tests/Visual/Matchmaking/TestSceneUserPanelOverlay.cs

@@ -0,0 +1,160 @@
+// 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 System.Linq;
+using NUnit.Framework;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match;
+using osu.Game.Tests.Visual.Multiplayer;
+using osu.Game.Users;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneUserPanelOverlay : MultiplayerTestScene
+    {
+        private PlayerPanelOverlay list = null!;
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom(MatchType.Matchmaking)));
+            WaitForJoined();
+
+            AddStep("add list", () => Child = new Container
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Both,
+                Size = new Vector2(0.8f),
+                Child = list = new PlayerPanelOverlay()
+            });
+        }
+
+        [Test]
+        public void TestChangeDisplayMode()
+        {
+            AddStep("join users", () =>
+            {
+                for (int i = 0; i < 7; i++)
+                {
+                    MultiplayerClient.AddUser(new MultiplayerRoomUser(i)
+                    {
+                        User = new APIUser
+                        {
+                            Username = $"User {i}"
+                        }
+                    });
+                }
+            });
+
+            AddStep("change to split mode", () => list.DisplayStyle = PanelDisplayStyle.Split);
+            AddStep("change to grid mode", () => list.DisplayStyle = PanelDisplayStyle.Grid);
+            AddStep("change to hidden mode", () => list.DisplayStyle = PanelDisplayStyle.Hidden);
+        }
+
+        [Test]
+        public void AddPanelsGrid()
+        {
+            AddStep("change to grid mode", () => list.DisplayStyle = PanelDisplayStyle.Grid);
+
+            int userId = 0;
+
+            AddRepeatStep("join user", () =>
+            {
+                MultiplayerClient.AddUser(new MultiplayerRoomUser(userId)
+                {
+                    User = new APIUser
+                    {
+                        Username = $"User {userId}"
+                    }
+                });
+
+                userId++;
+            }, 8);
+        }
+
+        [Test]
+        public void AddPanelsSplit()
+        {
+            AddStep("change to split mode", () => list.DisplayStyle = PanelDisplayStyle.Split);
+
+            int userId = 0;
+
+            AddRepeatStep("join user", () =>
+            {
+                MultiplayerClient.AddUser(new MultiplayerRoomUser(userId)
+                {
+                    User = new APIUser
+                    {
+                        Username = $"User {userId}"
+                    }
+                });
+
+                userId++;
+            }, 8);
+        }
+
+        [Test]
+        public void RemovePanels()
+        {
+            AddStep("join another user", () =>
+            {
+                MultiplayerClient.AddUser(new MultiplayerRoomUser(1)
+                {
+                    User = new APIUser
+                    {
+                        Username = "User 1"
+                    }
+                });
+            });
+
+            AddUntilStep("two panels displayed", () => this.ChildrenOfType<UserPanel>().Count(), () => Is.EqualTo(2));
+
+            AddStep("remove a user", () => MultiplayerClient.RemoveUser(new APIUser { Id = 1 }));
+            AddUntilStep("one panel displayed", () => this.ChildrenOfType<UserPanel>().Count(), () => Is.EqualTo(1));
+        }
+
+        [Test]
+        public void ChangeRankings()
+        {
+            AddStep("join users", () =>
+            {
+                for (int i = 0; i < 7; i++)
+                {
+                    MultiplayerClient.AddUser(new MultiplayerRoomUser(i)
+                    {
+                        User = new APIUser
+                        {
+                            Username = $"User {i}"
+                        }
+                    });
+                }
+            });
+
+            AddStep("set random placements", () =>
+            {
+                MultiplayerRoom room = MultiplayerClient.ServerRoom!;
+
+                int[] placements = Enumerable.Range(1, room.Users.Count).ToArray();
+                Random.Shared.Shuffle(placements);
+
+                MatchmakingRoomState state = new MatchmakingRoomState();
+
+                for (int i = 0; i < room.Users.Count; i++)
+                    state.Users[room.Users[i].UserID].Placement = placements[i];
+
+                MultiplayerClient.ChangeMatchRoomState(state).WaitSafely();
+            });
+        }
+    }
+}

osu.Game.Tests/Visual/Menus/TestSceneLoginOverlay.cs

@@ -1,6 +1,7 @@
 // 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 System.Linq;
 using System.Net;
 using NUnit.Framework;
@@ -9,10 +10,12 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
 using osu.Game.Configuration;
+using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Login;
 using osu.Game.Overlays.Settings;
@@ -54,7 +57,7 @@ namespace osu.Game.Tests.Visual.Menus
         }
 
         [Test]
-        public void TestLoginSuccess()
+        public void TestLoginSuccess_EmailVerification()
         {
             AddStep("logout", () => API.Logout());
             assertAPIState(APIState.Offline);
@@ -94,6 +97,152 @@ namespace osu.Game.Tests.Visual.Menus
             assertDropdownState(UserAction.DoNotDisturb);
         }
 
+        [Test]
+        public void TestLoginSuccess_TOTPVerification()
+        {
+            AddStep("logout", () => API.Logout());
+            assertAPIState(APIState.Offline);
+            AddStep("expect totp verification", () => dummyAPI.SessionVerificationMethod = SessionVerificationMethod.TimedOneTimePassword);
+
+            AddStep("enter password", () => loginOverlay.ChildrenOfType<OsuPasswordTextBox>().First().Text = "password");
+            AddStep("submit", () => loginOverlay.ChildrenOfType<OsuButton>().First(b => b.Text.ToString() == "Sign in").TriggerClick());
+
+            assertAPIState(APIState.RequiresSecondFactorAuth);
+            AddUntilStep("wait for second factor auth form", () => loginOverlay.ChildrenOfType<SecondFactorAuthForm>().SingleOrDefault(), () => Is.Not.Null);
+
+            AddStep("set up verification handling", () => dummyAPI.HandleRequest = req =>
+            {
+                switch (req)
+                {
+                    case VerifySessionRequest verifySessionRequest:
+                        if (verifySessionRequest.VerificationKey == "012345")
+                            verifySessionRequest.TriggerSuccess();
+                        else
+                            verifySessionRequest.TriggerFailure(new WebException());
+                        return true;
+                }
+
+                return false;
+            });
+
+            AddStep("enter code", () => loginOverlay.ChildrenOfType<OsuTextBox>().First().Text = "012345");
+            assertAPIState(APIState.Online);
+            assertDropdownState(UserAction.Online);
+
+            AddStep("set failing", () => { dummyAPI.SetState(APIState.Failing); });
+            AddStep("return to online", () => { dummyAPI.SetState(APIState.Online); });
+
+            AddStep("clear handler", () => dummyAPI.HandleRequest = null);
+
+            assertDropdownState(UserAction.Online);
+            AddStep("change user state", () => localConfig.SetValue(OsuSetting.UserOnlineStatus, UserStatus.DoNotDisturb));
+            assertDropdownState(UserAction.DoNotDisturb);
+        }
+
+        [Test]
+        public void TestLoginSuccess_TOTPVerification_FallbackToEmail()
+        {
+            AddStep("logout", () => API.Logout());
+            assertAPIState(APIState.Offline);
+            AddStep("expect totp verification", () => dummyAPI.SessionVerificationMethod = SessionVerificationMethod.TimedOneTimePassword);
+
+            AddStep("enter password", () => loginOverlay.ChildrenOfType<OsuPasswordTextBox>().First().Text = "password");
+            AddStep("submit", () => loginOverlay.ChildrenOfType<OsuButton>().First(b => b.Text.ToString() == "Sign in").TriggerClick());
+
+            assertAPIState(APIState.RequiresSecondFactorAuth);
+            AddUntilStep("wait for second factor auth form", () => loginOverlay.ChildrenOfType<SecondFactorAuthForm>().SingleOrDefault(), () => Is.Not.Null);
+
+            AddStep("set up verification handling", () => dummyAPI.HandleRequest = req =>
+            {
+                switch (req)
+                {
+                    case VerifySessionRequest verifySessionRequest:
+                        if (verifySessionRequest.VerificationKey == "deadbeef")
+                            verifySessionRequest.TriggerSuccess();
+                        else
+                            verifySessionRequest.TriggerFailure(new WebException());
+                        return true;
+
+                    case VerificationMailFallbackRequest verificationMailFallbackRequest:
+                        verificationMailFallbackRequest.TriggerSuccess();
+                        return true;
+                }
+
+                return false;
+            });
+
+            AddStep("request fallback to email", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<OsuSpriteText>().Single(t => t.Text.ToString().Contains("email", StringComparison.InvariantCultureIgnoreCase)));
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddStep("enter code", () => loginOverlay.ChildrenOfType<OsuTextBox>().First().Text = "deadbeef");
+            assertAPIState(APIState.Online);
+            assertDropdownState(UserAction.Online);
+
+            AddStep("set failing", () => { dummyAPI.SetState(APIState.Failing); });
+            AddStep("return to online", () => { dummyAPI.SetState(APIState.Online); });
+
+            AddStep("clear handler", () => dummyAPI.HandleRequest = null);
+
+            assertDropdownState(UserAction.Online);
+            AddStep("change user state", () => localConfig.SetValue(OsuSetting.UserOnlineStatus, UserStatus.DoNotDisturb));
+            assertDropdownState(UserAction.DoNotDisturb);
+        }
+
+        [Test]
+        public void TestLoginSuccess_TOTPVerification_TurnedOffMidwayThrough()
+        {
+            bool firstAttemptHandled = false;
+
+            AddStep("logout", () => API.Logout());
+            assertAPIState(APIState.Offline);
+            AddStep("expect totp verification", () => dummyAPI.SessionVerificationMethod = SessionVerificationMethod.TimedOneTimePassword);
+
+            AddStep("enter password", () => loginOverlay.ChildrenOfType<OsuPasswordTextBox>().First().Text = "password");
+            AddStep("submit", () => loginOverlay.ChildrenOfType<OsuButton>().First(b => b.Text.ToString() == "Sign in").TriggerClick());
+
+            assertAPIState(APIState.RequiresSecondFactorAuth);
+            AddUntilStep("wait for second factor auth form", () => loginOverlay.ChildrenOfType<SecondFactorAuthForm>().SingleOrDefault(), () => Is.Not.Null);
+
+            AddStep("set up verification handling", () => dummyAPI.HandleRequest = req =>
+            {
+                switch (req)
+                {
+                    case VerifySessionRequest verifySessionRequest:
+                        verifySessionRequest.RequiredVerificationMethod = SessionVerificationMethod.EmailMessage;
+                        verifySessionRequest.TriggerFailure(new WebException());
+                        firstAttemptHandled = true;
+                        return true;
+                }
+
+                return false;
+            });
+
+            AddStep("enter code", () => loginOverlay.ChildrenOfType<OsuTextBox>().First().Text = "123456");
+            AddUntilStep("first verification attempt handled", () => firstAttemptHandled);
+            assertAPIState(APIState.RequiresSecondFactorAuth);
+
+            AddStep("set up verification handling", () => dummyAPI.HandleRequest = req =>
+            {
+                switch (req)
+                {
+                    case VerifySessionRequest verifySessionRequest:
+                        if (verifySessionRequest.VerificationKey == "deadbeef")
+                            verifySessionRequest.TriggerSuccess();
+                        else
+                            verifySessionRequest.TriggerFailure(new WebException());
+                        return true;
+                }
+
+                return false;
+            });
+            AddStep("enter code", () => loginOverlay.ChildrenOfType<OsuTextBox>().First().Text = "deadbeef");
+            assertAPIState(APIState.Online);
+            assertDropdownState(UserAction.Online);
+        }
+
         private void assertDropdownState(UserAction state)
         {
             AddAssert($"dropdown state is {state}", () => loginOverlay.ChildrenOfType<UserDropdown>().First().Current.Value, () => Is.EqualTo(state));

osu.Game.Tests/Visual/Navigation/TestSceneSkinEditorNavigation.cs

@@ -278,6 +278,8 @@ namespace osu.Game.Tests.Visual.Navigation
         {
             advanceToSongSelect();
             openSkinEditor();
+            AddUntilStep("skin editor visible", () => skinEditor.State.Value == Visibility.Visible);
+
             AddStep("select autoplay", () => Game.SelectedMods.Value = new Mod[] { new OsuModAutoplay() });
             AddStep("import beatmap", () => BeatmapImportHelper.LoadQuickOszIntoOsu(Game).WaitSafely());
             AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
@@ -290,8 +292,9 @@ namespace osu.Game.Tests.Visual.Navigation
             AddAssert("settings not visible", () => getPlayerSettingsOverlay().DrawWidth, () => Is.EqualTo(0));
 
             toggleSkinEditor();
+            AddUntilStep("skin editor hidden", () => skinEditor.State.Value == Visibility.Hidden);
 
-            AddStep("move cursor slightly", () => InputManager.MoveMouseTo(InputManager.ScreenSpaceDrawQuad.TopRight + new Vector2(1)));
+            AddStep("move cursor slightly", () => InputManager.MoveMouseTo(InputManager.ScreenSpaceDrawQuad.TopRight + new Vector2(2)));
             AddUntilStep("settings visible", () => getPlayerSettingsOverlay().DrawWidth, () => Is.GreaterThan(0));
 
             AddStep("move cursor to right of screen too far", () => InputManager.MoveMouseTo(InputManager.ScreenSpaceDrawQuad.TopRight + new Vector2(10240, 0)));

osu.Game.Tests/Visual/Navigation/TestSceneSongSelectNavigation.cs

@@ -9,6 +9,8 @@ using osu.Framework.Extensions;
 using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.Leaderboards;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
@@ -17,6 +19,7 @@ using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Footer;
+using osu.Game.Screens.Menu;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Ranking;
 using osu.Game.Screens.SelectV2;
@@ -217,6 +220,57 @@ namespace osu.Game.Tests.Visual.Navigation
             AddAssert("leaderboard matches gameplay beatmap", () => Game.ChildrenOfType<LeaderboardManager>().Single().CurrentCriteria?.Beatmap, () => Is.EqualTo(beatmap().BeatmapInfo));
         }
 
+        [Test]
+        public void TestEnterKeyProgressesToGameplayEvenIfCarouselFilteredOut()
+        {
+            PushAndConfirm(() => new SoloSongSelect());
+
+            AddStep("import beatmap", () => BeatmapImportHelper.LoadOszIntoOsu(Game, virtualTrack: true).WaitSafely());
+            AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
+
+            AddStep("filter out active beatmap", () => this.ChildrenOfType<SearchTextBox>().First().Text = "abacadabadaeba");
+            AddUntilStep("wait for filter", () => this.ChildrenOfType<BeatmapCarousel>().Single().IsFiltering, () => Is.False);
+
+            AddStep("press enter", () => InputManager.Key(Key.Enter));
+
+            AddUntilStep("player entered", () =>
+            {
+                DismissAnyNotifications();
+                return Game.ScreenStack.CurrentScreen is Player;
+            });
+        }
+
+        [Test]
+        public void TestSelectionNotLostWithConvertedBeatmapsShown()
+        {
+            BeatmapSetInfo beatmapSet = null!;
+            BeatmapInfo selectedBeatmap = null!;
+
+            AddStep("import beatmap", () => beatmapSet = BeatmapImportHelper.LoadOszIntoOsu(Game).GetResultSafely());
+            PushAndConfirm(() => new SoloSongSelect());
+
+            AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
+
+            AddStep("change ruleset to taiko", () =>
+            {
+                InputManager.PressKey(Key.ControlLeft);
+                InputManager.Key(Key.Number2);
+                InputManager.ReleaseKey(Key.ControlLeft);
+            });
+            AddStep("show converts", () => Game.LocalConfig.SetValue(OsuSetting.ShowConvertedBeatmaps, true));
+            AddStep("select osu! beatmap", () =>
+            {
+                selectedBeatmap = beatmapSet.Beatmaps.First(b => b.Ruleset.OnlineID == 0);
+                Game.Beatmap.Value = Game.BeatmapManager.GetWorkingBeatmap(selectedBeatmap);
+            });
+
+            pushEscape();
+            AddUntilStep("went back to main menu", () => Game.ScreenStack.CurrentScreen is MainMenu);
+            PushAndConfirm(() => new SoloSongSelect());
+
+            AddUntilStep("selected beatmap is still osu! ruleset", () => Game.Beatmap.Value.BeatmapInfo, () => Is.EqualTo(selectedBeatmap));
+        }
+
         private Func<Player> playToResults()
         {
             var player = playToCompletion();

osu.Game.Tests/Visual/Ranking/TestSceneUserTagControl.cs

@@ -71,9 +71,9 @@ namespace osu.Game.Tests.Visual.Ranking
                             var beatmapSet = CreateAPIBeatmapSet(Beatmap.Value.BeatmapInfo);
                             beatmapSet.Beatmaps.Single().TopTags =
                             [
-                                new APIBeatmapTag { TagId = 3, VoteCount = 9 },
-                                new APIBeatmapTag { TagId = 2, VoteCount = 8 },
-                                new APIBeatmapTag { TagId = 0, VoteCount = 7 },
+                                new APIBeatmapTag { TagId = 3, VoteCount = 4 },
+                                new APIBeatmapTag { TagId = 2, VoteCount = 3 },
+                                new APIBeatmapTag { TagId = 0, VoteCount = 2 },
                             ];
                             Scheduler.AddDelayed(() => getBeatmapSetRequest.TriggerSuccess(beatmapSet), 500);
                             return true;
@@ -155,14 +155,14 @@ namespace osu.Game.Tests.Visual.Ranking
                 InputManager.MoveMouseTo(getDrawableTagById(2));
                 InputManager.Click(MouseButton.Left);
             });
-            AddUntilStep("tag 2 voted for", () => getDrawableTagById(2).UserTag.VoteCount.Value, () => Is.EqualTo(9));
+            AddUntilStep("tag 2 voted for", () => getDrawableTagById(2).UserTag.VoteCount.Value, () => Is.EqualTo(4));
 
             AddStep("remove vote for tag 2", () =>
             {
                 InputManager.MoveMouseTo(getDrawableTagById(2));
                 InputManager.Click(MouseButton.Left);
             });
-            AddUntilStep("tag 2 not voted for", () => getDrawableTagById(2).UserTag.VoteCount.Value, () => Is.EqualTo(8));
+            AddUntilStep("tag 2 not voted for", () => getDrawableTagById(2).UserTag.VoteCount.Value, () => Is.EqualTo(3));
             AddAssert("tag 2 is still second", () => getTagFlow().GetLayoutPosition(getDrawableTagById(2)), () => Is.EqualTo(1));
 
             AddStep("vote for tag 2", () =>
@@ -170,7 +170,7 @@ namespace osu.Game.Tests.Visual.Ranking
                 InputManager.MoveMouseTo(getDrawableTagById(2));
                 InputManager.Click(MouseButton.Left);
             });
-            AddUntilStep("tag 2 voted for", () => getDrawableTagById(2).UserTag.VoteCount.Value, () => Is.EqualTo(9));
+            AddUntilStep("tag 2 voted for", () => getDrawableTagById(2).UserTag.VoteCount.Value, () => Is.EqualTo(4));
             AddStep("move mouse away", () => InputManager.MoveMouseTo(Vector2.Zero));
             AddAssert("tag 2 reordered to first", () => getTagFlow().GetLayoutPosition(getDrawableTagById(2)), () => Is.EqualTo(0));
 

osu.Game.Tests/Visual/SongSelect/TestSceneCollectionDropdown.cs

@@ -86,11 +86,11 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "2"))));
             AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "3"))));
 
-            AddAssert("check count 5", () => dropdown.ChildrenOfType<CollectionDropdown>().Single().ChildrenOfType<Menu.DrawableMenuItem>().Count(), () => Is.EqualTo(5));
+            AddUntilStep("check count 5", () => dropdown.ChildrenOfType<CollectionDropdown>().Single().ChildrenOfType<Menu.DrawableMenuItem>().Count(), () => Is.EqualTo(5));
 
             AddStep("delete all collections", () => writeAndRefresh(r => r.RemoveAll<BeatmapCollection>()));
 
-            AddAssert("check count 2", () => dropdown.ChildrenOfType<CollectionDropdown>().Single().ChildrenOfType<Menu.DrawableMenuItem>().Count(), () => Is.EqualTo(2));
+            AddUntilStep("check count 2", () => dropdown.ChildrenOfType<CollectionDropdown>().Single().ChildrenOfType<Menu.DrawableMenuItem>().Count(), () => Is.EqualTo(2));
         }
 
         [Test]
@@ -185,11 +185,11 @@ namespace osu.Game.Tests.Visual.SongSelect
             assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
 
             addClickAddOrRemoveButtonStep(1);
-            AddAssert("collection contains beatmap", () => getFirstCollection().BeatmapMD5Hashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
+            AddUntilStep("collection contains beatmap", () => getFirstCollection().BeatmapMD5Hashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
             assertFirstButtonIs(FontAwesome.Solid.MinusSquare);
 
             addClickAddOrRemoveButtonStep(1);
-            AddAssert("collection does not contain beatmap", () => !getFirstCollection().BeatmapMD5Hashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
+            AddUntilStep("collection does not contain beatmap", () => !getFirstCollection().BeatmapMD5Hashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
             assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
         }
 

osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselFilterGroupingTest.cs

@@ -390,7 +390,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             var groupModel = (GroupDefinition)groupItem.Model;
 
-            Assert.That(groupModel.Title, Is.EqualTo(expectedTitle));
+            Assert.That(groupModel.Title.ToString(), Is.EqualTo(expectedTitle));
             Assert.That(itemsInGroup.Select(i => i.Model).OfType<GroupedBeatmap>().Select(gb => gb.Beatmap), Is.EquivalentTo(expectedBeatmaps));
 
             totalItems += itemsInGroup.Count() + 1;

osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselArtistGrouping.cs

@@ -249,5 +249,39 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             CheckDisplayedBeatmapSetsCount(10);
             CheckDisplayedBeatmapsCount(30);
         }
+
+        [Test]
+        public void TestGroupDoesNotExpandAgainOnRefilterIfManuallyCollapsed()
+        {
+            ApplyToFilterAndWaitForFilter("filter", c => c.SearchText = BeatmapSets[2].Metadata.Title);
+
+            CheckDisplayedGroupsCount(1);
+            CheckDisplayedBeatmapSetsCount(1);
+            CheckDisplayedBeatmapsCount(3);
+
+            CheckHasSelection();
+
+            ApplyToFilterAndWaitForFilter("remove filter", c => c.SearchText = string.Empty);
+
+            CheckDisplayedGroupsCount(5);
+            CheckDisplayedBeatmapSetsCount(10);
+            CheckDisplayedBeatmapsCount(30);
+
+            ToggleGroupCollapse();
+
+            ApplyToFilterAndWaitForFilter("apply no-op filter", c => c.AllowConvertedBeatmaps = !c.AllowConvertedBeatmaps);
+            AddAssert("group didn't re-expand", () => Carousel.ExpandedGroup, () => Is.Null);
+
+            ToggleGroupCollapse();
+            AddAssert("beatmap set re-expanded correctly", () => Carousel.ExpandedBeatmapSet?.BeatmapSet, () => Is.EqualTo(BeatmapSets[2]));
+
+            ApplyToFilterAndWaitForFilter("filter", c => c.SearchText = BeatmapSets[1].Metadata.Title);
+
+            CheckDisplayedGroupsCount(1);
+            CheckDisplayedBeatmapSetsCount(1);
+            CheckDisplayedBeatmapsCount(3);
+
+            CheckHasSelection();
+        }
     }
 }

osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselDifficultyGrouping.cs

@@ -337,5 +337,31 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             AddAssert("expanded group is still first", () => (Carousel.ExpandedGroup as StarDifficultyGroupDefinition)?.Difficulty.Stars, () => Is.EqualTo(0));
         }
+
+        [Test]
+        public void TestExpandedGroupDoesNotExpandAgainOnRefilterIfManuallyCollapsed()
+        {
+            SelectPrevSet();
+
+            WaitForBeatmapSelection(2, 9);
+            AddAssert("expanded group is last", () => (Carousel.ExpandedGroup as StarDifficultyGroupDefinition)?.Difficulty.Stars, () => Is.EqualTo(6));
+
+            SelectNextPanel();
+            Select();
+
+            WaitForBeatmapSelection(2, 9);
+            AddAssert("expanded group is first", () => (Carousel.ExpandedGroup as StarDifficultyGroupDefinition)?.Difficulty.Stars, () => Is.EqualTo(0));
+
+            ToggleGroupCollapse();
+
+            // doesn't actually filter anything away, but triggers a filter.
+            ApplyToFilterAndWaitForFilter("filter", c => c.SearchText = "Some");
+            AddAssert("group didn't re-expand", () => (Carousel.ExpandedGroup as StarDifficultyGroupDefinition)?.Difficulty.Stars, () => Is.Null);
+
+            ToggleGroupCollapse();
+
+            ApplyToFilterAndWaitForFilter("filter", c => c.SearchText = "Som");
+            AddAssert("expanded group is first", () => (Carousel.ExpandedGroup as StarDifficultyGroupDefinition)?.Difficulty.Stars, () => Is.EqualTo(0));
+        }
     }
 }

osu.Game.Tests/Visual/SongSelectV2/TestSceneCollectionDropdown.cs

@@ -87,11 +87,11 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "2"))));
             AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "3"))));
 
-            AddAssert("check count 5", () => dropdown.ChildrenOfType<CollectionDropdown>().Single().ChildrenOfType<Menu.DrawableMenuItem>().Count(), () => Is.EqualTo(5));
+            AddUntilStep("check count 5", () => dropdown.ChildrenOfType<CollectionDropdown>().Single().ChildrenOfType<Menu.DrawableMenuItem>().Count(), () => Is.EqualTo(5));
 
             AddStep("delete all collections", () => writeAndRefresh(r => r.RemoveAll<BeatmapCollection>()));
 
-            AddAssert("check count 2", () => dropdown.ChildrenOfType<CollectionDropdown>().Single().ChildrenOfType<Menu.DrawableMenuItem>().Count(), () => Is.EqualTo(2));
+            AddUntilStep("check count 2", () => dropdown.ChildrenOfType<CollectionDropdown>().Single().ChildrenOfType<Menu.DrawableMenuItem>().Count(), () => Is.EqualTo(2));
         }
 
         [Test]
@@ -186,11 +186,11 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
 
             addClickAddOrRemoveButtonStep(1);
-            AddAssert("collection contains beatmap", () => getFirstCollection().BeatmapMD5Hashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
+            AddUntilStep("collection contains beatmap", () => getFirstCollection().BeatmapMD5Hashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
             assertFirstButtonIs(FontAwesome.Solid.MinusSquare);
 
             addClickAddOrRemoveButtonStep(1);
-            AddAssert("collection does not contain beatmap", () => !getFirstCollection().BeatmapMD5Hashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
+            AddUntilStep("collection does not contain beatmap", () => !getFirstCollection().BeatmapMD5Hashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
             assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
         }
 

osu.Game.Tests/Visual/SongSelectV2/TestScenePanelGroup.cs

@@ -9,6 +9,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Overlays;
 using osu.Game.Graphics.Carousel;
 using osu.Game.Graphics.Cursor;
+using osu.Game.Scoring;
 using osu.Game.Screens.SelectV2;
 using osu.Game.Tests.Visual.UserInterface;
 using osuTK;
@@ -86,6 +87,64 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             }
         }
 
+        [Test]
+        public void TestRanks()
+        {
+            for (int i = -1; i <= 7; i++)
+            {
+                ScoreRank rank = (ScoreRank)i;
+
+                AddStep($"display rank {rank}", () =>
+                {
+                    ContentContainer.Child = new DependencyProvidingContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        CachedDependencies = new (Type, object)[]
+                        {
+                            (typeof(OverlayColourProvider), new OverlayColourProvider(OverlayColourScheme.Aquamarine))
+                        },
+                        Child = new OsuContextMenuContainer
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Child = new FillFlowContainer
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Width = 0.5f,
+                                RelativeSizeAxes = Axes.X,
+                                AutoSizeAxes = Axes.Y,
+                                Direction = FillDirection.Vertical,
+                                Spacing = new Vector2(0f, 5f),
+                                Children = new[]
+                                {
+                                    new PanelGroupRankDisplay
+                                    {
+                                        Item = new CarouselItem(new RankDisplayGroupDefinition(rank))
+                                    },
+                                    new PanelGroupRankDisplay
+                                    {
+                                        Item = new CarouselItem(new RankDisplayGroupDefinition(rank)),
+                                        KeyboardSelected = { Value = true },
+                                    },
+                                    new PanelGroupRankDisplay
+                                    {
+                                        Item = new CarouselItem(new RankDisplayGroupDefinition(rank)),
+                                        Expanded = { Value = true },
+                                    },
+                                    new PanelGroupRankDisplay
+                                    {
+                                        Item = new CarouselItem(new RankDisplayGroupDefinition(rank)),
+                                        Expanded = { Value = true },
+                                        KeyboardSelected = { Value = true },
+                                    },
+                                },
+                            }
+                        }
+                    };
+                });
+            }
+        }
+
         protected override Drawable CreateContent()
         {
             return new OsuContextMenuContainer

osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs

@@ -22,6 +22,7 @@ using osu.Game.Screens.Menu;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Ranking;
 using osu.Game.Screens.Select;
+using osu.Game.Screens.Select.Filter;
 using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Screens.SelectV2;
 using osu.Game.Tests.Resources;
@@ -143,6 +144,41 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             void onScreenPushed(IScreen lastScreen, IScreen newScreen) => screensPushed.Add(lastScreen);
         }
 
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestHoveringLeftSideReexpandsGroupSelectionIsIn(bool mouseOverPanel)
+        {
+            ImportBeatmapForRuleset(0);
+
+            LoadSongSelect();
+            SortAndGroupBy(SortMode.Difficulty, GroupMode.Difficulty);
+
+            AddStep("move mouse to carousel", () => InputManager.MoveMouseTo(Carousel));
+
+            AddUntilStep("expanded group is below 1 star",
+                () => (Carousel.ChildrenOfType<PanelGroupStarDifficulty>().SingleOrDefault(p => p.Expanded.Value)?.Item?.Model as StarDifficultyGroupDefinition)?.Difficulty.Stars,
+                () => Is.EqualTo(0));
+
+            AddStep("select next group", () =>
+            {
+                InputManager.PressKey(Key.ShiftLeft);
+                InputManager.Key(Key.Right);
+                InputManager.ReleaseKey(Key.ShiftLeft);
+            });
+            AddUntilStep("expanded group is 3 star",
+                () => (Carousel.ChildrenOfType<PanelGroupStarDifficulty>().SingleOrDefault(p => p.Expanded.Value)?.Item?.Model as StarDifficultyGroupDefinition)?.Difficulty.Stars,
+                () => Is.EqualTo(3));
+
+            if (mouseOverPanel)
+                AddStep("move mouse over left panel", () => InputManager.MoveMouseTo(this.ChildrenOfType<BeatmapTitleWedge>().Single()));
+            else
+                AddStep("move mouse to left side container", () => InputManager.MoveMouseTo(this.ChildrenOfType<Screens.Select.SongSelect.LeftSideInteractionContainer>().Single()));
+
+            AddUntilStep("expanded group is below 1 star",
+                () => (Carousel.ChildrenOfType<PanelGroupStarDifficulty>().Single(p => p.Expanded.Value).Item?.Model as StarDifficultyGroupDefinition)?.Difficulty.Stars,
+                () => Is.EqualTo(0));
+        }
+
         #region Hotkeys
 
         [Test]

osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectCurrentSelectionInvalidated.cs

@@ -55,22 +55,26 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             waitForFiltering(6);
 
             BeatmapInfo? initiallySelected = null;
-            AddAssert("selected is taiko", () => (initiallySelected = selectedBeatmap)?.Ruleset.OnlineID, () => Is.EqualTo(1));
+            AddAssert("carousel beatmap is taiko", () => (initiallySelected = selectedBeatmap)?.Ruleset.OnlineID, () => Is.EqualTo(1));
+            AddUntilStep("global beatmap is taiko", () => Beatmap.Value.BeatmapInfo.Ruleset.OnlineID, () => Is.EqualTo(1));
 
             ChangeRuleset(0);
             waitForFiltering(7);
-            AddAssert("selected is osu", () => selectedBeatmap?.Ruleset.OnlineID, () => Is.EqualTo(0));
-            AddAssert("selected is same set as original", () => selectedBeatmap?.BeatmapSet, () => Is.EqualTo(initiallySelected!.BeatmapSet));
+            AddAssert("carousel beatmap is osu", () => selectedBeatmap?.Ruleset.OnlineID, () => Is.EqualTo(0));
+            AddUntilStep("global beatmap is osu", () => Beatmap.Value.BeatmapInfo.Ruleset.OnlineID, () => Is.EqualTo(0));
+            AddAssert("carousel beatmap is same set as original", () => selectedBeatmap?.BeatmapSet, () => Is.EqualTo(initiallySelected!.BeatmapSet));
 
             ChangeRuleset(1);
             waitForFiltering(8);
-            AddAssert("selected is taiko", () => selectedBeatmap?.Ruleset.OnlineID, () => Is.EqualTo(1));
-            AddAssert("selected is same set as original", () => selectedBeatmap?.BeatmapSet, () => Is.EqualTo(initiallySelected!.BeatmapSet));
+            AddAssert("carousel beatmap is taiko", () => selectedBeatmap?.Ruleset.OnlineID, () => Is.EqualTo(1));
+            AddUntilStep("global beatmap is taiko", () => Beatmap.Value.BeatmapInfo.Ruleset.OnlineID, () => Is.EqualTo(1));
+            AddAssert("carousel beatmap is same set as original", () => selectedBeatmap?.BeatmapSet, () => Is.EqualTo(initiallySelected!.BeatmapSet));
 
             ChangeRuleset(2);
             waitForFiltering(9);
-            AddAssert("selected is catch", () => selectedBeatmap?.Ruleset.OnlineID, () => Is.EqualTo(2));
-            AddAssert("selected is different set", () => selectedBeatmap?.BeatmapSet, () => Is.Not.EqualTo(initiallySelected!.BeatmapSet));
+            AddAssert("carousel beatmap is catch", () => selectedBeatmap?.Ruleset.OnlineID, () => Is.EqualTo(2));
+            AddUntilStep("global beatmap is catch", () => Beatmap.Value.BeatmapInfo.Ruleset.OnlineID, () => Is.EqualTo(2));
+            AddAssert("carousel beatmap is different set", () => selectedBeatmap?.BeatmapSet, () => Is.Not.EqualTo(initiallySelected!.BeatmapSet));
         }
 
         /// <summary>

osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectGrouping.cs

@@ -245,7 +245,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             GroupBy(GroupMode.RankAchieved);
             WaitForFiltering();
 
-            assertGroupPresent("S+", () => new[] { beatmapSets[0] });
+            assertGroupPresent("Silver S", () => new[] { beatmapSets[0] });
             assertGroupPresent("A", () => new[] { beatmapSets[1] });
             assertGroupPresent("C", () => new[] { beatmapSets[2] });
             assertGroupPresent("Unplayed", () => new[] { beatmapSets[3], beatmapSets[4] });
@@ -316,7 +316,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         {
             AddAssert($"\"{name}\" present", () =>
             {
-                var group = grouping.GroupItems.Single(g => g.Key.Title == name);
+                var group = grouping.GroupItems.Single(g => g.Key.Title.ToString() == name);
                 var actualBeatmaps = group.Value.Select(i => i.Model).OfType<GroupedBeatmap>().Select(gb => gb.Beatmap).OrderBy(b => b.ID);
                 var expectedBeatmaps = getBeatmaps().SelectMany(s => s.Beatmaps).OrderBy(b => b.ID);
                 return actualBeatmaps.SequenceEqual(expectedBeatmaps);

osu.Game.Tests/Visual/UserInterface/TestSceneButtonSystem.cs

@@ -68,14 +68,15 @@ namespace osu.Game.Tests.Visual.UserInterface
         }
 
         [TestCase(Key.P, Key.P)]
-        [TestCase(Key.M, Key.P)]
-        [TestCase(Key.L, Key.P)]
-        [TestCase(Key.B, Key.E)]
-        [TestCase(Key.S, Key.E)]
-        [TestCase(Key.D, null)]
-        [TestCase(Key.Q, null)]
-        [TestCase(Key.O, null)]
-        public void TestShortcutKeys(Key key, Key? subMenuEnterKey)
+        [TestCase(Key.M, Key.M, Key.L)]
+        [TestCase(Key.M, Key.M, Key.M)]
+        [TestCase(Key.L, Key.L)]
+        [TestCase(Key.B, Key.E, Key.B)]
+        [TestCase(Key.S, Key.E, Key.S)]
+        [TestCase(Key.D)]
+        [TestCase(Key.Q)]
+        [TestCase(Key.O)]
+        public void TestShortcutKeys(params Key[] keys)
         {
             int activationCount = -1;
             AddStep("set up action", () =>
@@ -83,7 +84,7 @@ namespace osu.Game.Tests.Visual.UserInterface
                 activationCount = 0;
                 void action() => activationCount++;
 
-                switch (key)
+                switch (keys.First())
                 {
                     case Key.P:
                         buttons.OnSolo = action;
@@ -119,16 +120,19 @@ namespace osu.Game.Tests.Visual.UserInterface
                 }
             });
 
-            AddStep($"press {key}", () => InputManager.Key(key));
+            // trigger out of idle state
+            AddStep($"press {keys.First()}", () => InputManager.Key(keys.First()));
             AddAssert("state is top level", () => buttons.State == ButtonSystemState.TopLevel);
 
-            if (subMenuEnterKey != null)
+            for (int i = 0; i < keys.Length; i++)
             {
-                AddStep($"press {subMenuEnterKey}", () => InputManager.Key(subMenuEnterKey.Value));
-                AddAssert("state is not top menu", () => buttons.State != ButtonSystemState.TopLevel);
+                var key = keys[i];
+                AddStep($"press {key}", () => InputManager.Key(key));
+
+                if (i > 0)
+                    AddAssert("state is not top menu", () => buttons.State != ButtonSystemState.TopLevel);
             }
 
-            AddStep($"press {key}", () => InputManager.Key(key));
             AddAssert("action triggered", () => activationCount == 1);
         }
 

osu.Game.Tests/Visual/UserInterface/TestSceneMainMenuButton.cs

@@ -13,8 +13,8 @@ using osu.Game.Online.Metadata;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
 using osu.Game.Screens.Menu;
+using osuTK.Graphics;
 using osuTK.Input;
-using Color4 = osuTK.Graphics.Color4;
 
 namespace osu.Game.Tests.Visual.UserInterface
 {

osu.Game/Beatmaps/Drawables/Cards/BeatmapCard.cs

@@ -24,7 +24,7 @@ namespace osu.Game.Beatmaps.Drawables.Cards
         public const float TRANSITION_DURATION = 340;
         public const float CORNER_RADIUS = 8;
 
-        protected const float WIDTH = 345;
+        public const float WIDTH = 345;
 
         public IBindable<bool> Expanded { get; }
 
@@ -77,25 +77,27 @@ namespace osu.Game.Beatmaps.Drawables.Cards
 
             containingInputManager = GetContainingInputManager();
 
-            Action = () =>
-            {
-                if (containingInputManager?.CurrentState.Keyboard.ShiftPressed == true)
-                {
-                    switch (DownloadTracker.State.Value)
-                    {
-                        case DownloadState.NotDownloaded:
-                            if (!BeatmapSet.Availability.DownloadDisabled)
-                                beatmaps?.Download(BeatmapSet, preferNoVideo.Value);
-                            break;
+            if (Action == null)
+                throw new InvalidOperationException($"An action should be assigned to this {nameof(BeatmapCard)}. To use the default, assign {nameof(DefaultAction)}.");
+        }
 
-                        case DownloadState.LocallyAvailable:
-                            game?.PresentBeatmap(BeatmapSet);
-                            break;
-                    }
+        protected void DefaultAction()
+        {
+            if (containingInputManager?.CurrentState.Keyboard.ShiftPressed == true)
+            {
+                switch (DownloadTracker.State.Value)
+                {
+                    case DownloadState.NotDownloaded:
+                        if (!BeatmapSet.Availability.DownloadDisabled) beatmaps?.Download(BeatmapSet, preferNoVideo.Value);
+                        break;
+
+                    case DownloadState.LocallyAvailable:
+                        game?.PresentBeatmap(BeatmapSet);
+                        break;
                 }
-                else
-                    beatmapSetOverlay?.FetchAndShowBeatmapSet(BeatmapSet.OnlineID);
-            };
+            }
+            else
+                beatmapSetOverlay?.FetchAndShowBeatmapSet(BeatmapSet.OnlineID);
         }
 
         protected override bool OnHover(HoverEvent e)

osu.Game/Beatmaps/Drawables/Cards/BeatmapCardContentBackground.cs

@@ -21,7 +21,7 @@ namespace osu.Game.Beatmaps.Drawables.Cards
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; } = null!;
 
-        public BeatmapCardContentBackground(IBeatmapSetOnlineInfo onlineInfo)
+        public BeatmapCardContentBackground(IBeatmapSetOnlineInfo onlineInfo, bool keepLoaded = false)
         {
             InternalChildren = new Drawable[]
             {
@@ -29,7 +29,7 @@ namespace osu.Game.Beatmaps.Drawables.Cards
                 {
                     RelativeSizeAxes = Axes.Both,
                 },
-                cover = new DelayedLoadUnloadWrapper(() => createCover(onlineInfo), 500, 500)
+                cover = new DelayedLoadUnloadWrapper(() => createCover(onlineInfo), keepLoaded ? 0 : 500, keepLoaded ? double.MaxValue : 1000)
                 {
                     RelativeSizeAxes = Axes.Both,
                     Colour = Colour4.Transparent

osu.Game/Beatmaps/Drawables/Cards/BeatmapCardExtra.cs

@@ -46,6 +46,8 @@ namespace osu.Game.Beatmaps.Drawables.Cards
             : base(beatmapSet, allowExpansion)
         {
             content = new BeatmapCardContent(height);
+
+            Action = DefaultAction;
         }
 
         [BackgroundDependencyLoader(true)]

osu.Game/Beatmaps/Drawables/Cards/BeatmapCardNano.cs

@@ -54,6 +54,8 @@ namespace osu.Game.Beatmaps.Drawables.Cards
             : base(beatmapSet, false)
         {
             content = new BeatmapCardContent(height);
+
+            Action = DefaultAction;
         }
 
         [BackgroundDependencyLoader]

osu.Game/Beatmaps/Drawables/Cards/BeatmapCardNormal.cs

@@ -47,6 +47,8 @@ namespace osu.Game.Beatmaps.Drawables.Cards
             : base(beatmapSet, allowExpansion)
         {
             content = new BeatmapCardContent(HEIGHT);
+
+            Action = DefaultAction;
         }
 
         [BackgroundDependencyLoader]

osu.Game/Beatmaps/Drawables/Cards/BeatmapCardThumbnail.cs

@@ -35,11 +35,11 @@ namespace osu.Game.Beatmaps.Drawables.Cards
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; } = null!;
 
-        public BeatmapCardThumbnail(IBeatmapSetInfo beatmapSetInfo, IBeatmapSetOnlineInfo onlineInfo)
+        public BeatmapCardThumbnail(IBeatmapSetInfo beatmapSetInfo, IBeatmapSetOnlineInfo onlineInfo, bool keepLoaded = false)
         {
             InternalChildren = new Drawable[]
             {
-                new UpdateableOnlineBeatmapSetCover(BeatmapSetCoverType.List)
+                new UpdateableOnlineBeatmapSetCover(BeatmapSetCoverType.List, keepLoaded ? 0 : 500, keepLoaded ? double.MaxValue : 1000)
                 {
                     RelativeSizeAxes = Axes.Both,
                     OnlineInfo = onlineInfo

osu.Game/Beatmaps/Drawables/Cards/Buttons/GoToBeatmapButton.cs

@@ -16,10 +16,12 @@ namespace osu.Game.Beatmaps.Drawables.Cards.Buttons
         private readonly Bindable<DownloadState> state = new Bindable<DownloadState>();
 
         private readonly APIBeatmapSet beatmapSet;
+        private readonly bool allowNavigationToBeatmap;
 
-        public GoToBeatmapButton(APIBeatmapSet beatmapSet)
+        public GoToBeatmapButton(APIBeatmapSet beatmapSet, bool allowNavigationToBeatmap)
         {
             this.beatmapSet = beatmapSet;
+            this.allowNavigationToBeatmap = allowNavigationToBeatmap;
         }
 
         [BackgroundDependencyLoader(true)]
@@ -27,7 +29,6 @@ namespace osu.Game.Beatmaps.Drawables.Cards.Buttons
         {
             Action = () => game?.PresentBeatmap(beatmapSet);
             Icon.Icon = FontAwesome.Solid.AngleDoubleRight;
-            TooltipText = "Go to beatmap";
         }
 
         protected override void LoadComplete()
@@ -40,8 +41,31 @@ namespace osu.Game.Beatmaps.Drawables.Cards.Buttons
 
         private void updateState()
         {
-            Enabled.Value = state.Value == DownloadState.LocallyAvailable;
-            this.FadeTo(Enabled.Value ? 1 : 0, BeatmapCard.TRANSITION_DURATION, Easing.OutQuint);
+            bool available = state.Value == DownloadState.LocallyAvailable;
+            Enabled.Value = allowNavigationToBeatmap && available;
+
+            float alpha;
+
+            if (available && allowNavigationToBeatmap)
+            {
+                TooltipText = "Go to beatmap";
+                Enabled.Value = true;
+                alpha = 1f;
+            }
+            else if (available)
+            {
+                TooltipText = string.Empty;
+                Enabled.Value = false;
+                alpha = 0.3f;
+            }
+            else
+            {
+                TooltipText = string.Empty;
+                Enabled.Value = false;
+                alpha = 0;
+            }
+
+            this.FadeTo(alpha, BeatmapCard.TRANSITION_DURATION, Easing.OutQuint);
         }
     }
 }

osu.Game/Beatmaps/Drawables/Cards/CollapsibleButtonContainer.cs

@@ -30,7 +30,6 @@ namespace osu.Game.Beatmaps.Drawables.Cards
             set
             {
                 buttonsExpandedWidth = value;
-                buttonArea.Width = value;
                 if (IsLoaded)
                     updateState();
             }
@@ -67,7 +66,7 @@ namespace osu.Game.Beatmaps.Drawables.Cards
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; } = null!;
 
-        public CollapsibleButtonContainer(APIBeatmapSet beatmapSet)
+        public CollapsibleButtonContainer(APIBeatmapSet beatmapSet, bool allowNavigationToBeatmap = true, bool keepBackgroundLoaded = false)
         {
             downloadTracker = new BeatmapDownloadTracker(beatmapSet);
 
@@ -116,14 +115,6 @@ namespace osu.Game.Beatmaps.Drawables.Cards
                                 RelativeSizeAxes = Axes.Both,
                                 Height = 0.5f,
                             },
-                            new GoToBeatmapButton(beatmapSet)
-                            {
-                                Anchor = Anchor.BottomCentre,
-                                Origin = Anchor.BottomCentre,
-                                State = { BindTarget = downloadTracker.State },
-                                RelativeSizeAxes = Axes.Both,
-                                Height = 0.5f,
-                            }
                         }
                     }
                 },
@@ -135,7 +126,7 @@ namespace osu.Game.Beatmaps.Drawables.Cards
                     Masking = true,
                     Children = new Drawable[]
                     {
-                        new BeatmapCardContentBackground(beatmapSet)
+                        new BeatmapCardContentBackground(beatmapSet, keepBackgroundLoaded)
                         {
                             RelativeSizeAxes = Axes.Both,
                             Dimmed = { BindTarget = ShowDetails }
@@ -152,6 +143,15 @@ namespace osu.Game.Beatmaps.Drawables.Cards
                     }
                 }
             };
+
+            buttons.Add(new GoToBeatmapButton(beatmapSet, allowNavigationToBeatmap)
+            {
+                Anchor = Anchor.BottomCentre,
+                Origin = Anchor.BottomCentre,
+                State = { BindTarget = downloadTracker.State },
+                RelativeSizeAxes = Axes.Both,
+                Height = 0.5f,
+            });
         }
 
         protected override void LoadComplete()
@@ -165,6 +165,8 @@ namespace osu.Game.Beatmaps.Drawables.Cards
 
         private void updateState()
         {
+            buttonArea.Width = buttonsExpandedWidth;
+
             float buttonAreaWidth = ShowDetails.Value ? ButtonsExpandedWidth : ButtonsCollapsedWidth;
             float mainAreaWidth = Width - buttonAreaWidth;
 

osu.Game/Extensions/NumberFormattingExtensions.cs

@@ -36,7 +36,7 @@ namespace osu.Game.Extensions
 
             string negativeSign = Math.Round(floatValue, significantDigits) < 0 ? "-" : string.Empty;
 
-            return FormattableString.Invariant($"{negativeSign}{Math.Abs(floatValue).ToString($"N{significantDigits}")}");
+            return $"{negativeSign}{Math.Abs(floatValue).ToString($"N{significantDigits}", CultureInfo.InvariantCulture)}";
         }
 
         /// <summary>

osu.Game/Graphics/Carousel/Carousel.cs

@@ -453,8 +453,7 @@ namespace osu.Game.Graphics.Carousel
                 // matching with exact modifier consideration (so Ctrl+Enter would be ignored).
                 case Key.Enter:
                 case Key.KeypadEnter:
-                    activateSelection();
-                    return true;
+                    return activateSelection();
             }
 
             return base.OnKeyDown(e);
@@ -465,8 +464,7 @@ namespace osu.Game.Graphics.Carousel
             switch (e.Action)
             {
                 case GlobalAction.Select:
-                    activateSelection();
-                    return true;
+                    return activateSelection();
 
                 // the selection traversal handlers below are scheduled to avoid an issue
                 // wherein if the update frame rate is low, keeping one of the actions below pressed leads to selection moving back to the start / end.
@@ -560,10 +558,15 @@ namespace osu.Game.Graphics.Carousel
         {
         }
 
-        private void activateSelection()
+        private bool activateSelection()
         {
             if (currentKeyboardSelection.CarouselItem != null)
+            {
                 Activate(currentKeyboardSelection.CarouselItem);
+                return true;
+            }
+
+            return false;
         }
 
         private void traverseKeyboardSelection(int direction)
@@ -761,10 +764,10 @@ namespace osu.Game.Graphics.Carousel
                 updateItemYPosition(item, ref lastVisible, ref yPos);
 
                 if (CheckModelEquality(item.Model, currentKeyboardSelection.Model!))
-                    currentKeyboardSelection = new Selection(currentKeyboardSelection.Model, item, item.CarouselYPosition, i);
+                    currentKeyboardSelection = new Selection(currentKeyboardSelection.Model, item, item.CarouselYPosition + item.DrawHeight / 2, i);
 
                 if (CheckModelEquality(item.Model, currentSelection.Model!))
-                    currentSelection = new Selection(currentSelection.Model, item, item.CarouselYPosition, i);
+                    currentSelection = new Selection(currentSelection.Model, item, item.CarouselYPosition + item.DrawHeight / 2, i);
             }
 
             // Update the total height of all items (to make the scroll container scrollable through the full height even though
@@ -873,13 +876,18 @@ namespace osu.Game.Graphics.Carousel
 
             if (!scrollToSelection.IsValid)
             {
-                if (currentKeyboardSelection.YPosition != null)
-                    Scroll.ScrollTo(currentKeyboardSelection.YPosition.Value - visibleHalfHeight + BleedTop);
+                if (GetScrollTarget() is double scrollTarget)
+                    Scroll.ScrollTo(scrollTarget - visibleHalfHeight + BleedTop);
 
                 scrollToSelection.Validate();
             }
         }
 
+        /// <summary>
+        /// Returns the Y position to scroll to in order to show the most relevant carousel item(s).
+        /// </summary>
+        protected virtual double? GetScrollTarget() => currentKeyboardSelection.YPosition;
+
         protected virtual float GetPanelXOffset(Drawable panel)
         {
             Vector2 posInScroll = Scroll.ToLocalSpace(panel.ScreenSpaceDrawQuad.Centre);

osu.Game/Graphics/Containers/OsuClickableContainer.cs

@@ -18,6 +18,8 @@ namespace osu.Game.Graphics.Containers
 
         private readonly Container content = new Container { RelativeSizeAxes = Axes.Both };
 
+        private HoverSounds samples = null!;
+
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) =>
             // base call is checked for cases when `OsuClickableContainer` has masking applied to it directly (ie. externally in object initialisation).
             base.ReceivePositionalInputAt(screenSpacePos)
@@ -33,6 +35,14 @@ namespace osu.Game.Graphics.Containers
             this.sampleSet = sampleSet;
         }
 
+        public void TriggerClickWithSound()
+        {
+            TriggerClick();
+
+            // TriggerClick doesn't recursively fire the event so we need to manually do this.
+            (samples as HoverClickSounds)?.PlayClickSample();
+        }
+
         public virtual LocalisableString TooltipText { get; set; }
 
         [BackgroundDependencyLoader]
@@ -46,7 +56,7 @@ namespace osu.Game.Graphics.Containers
 
             AddRangeInternal(new Drawable[]
             {
-                CreateHoverSounds(sampleSet),
+                samples = CreateHoverSounds(sampleSet),
                 content,
             });
         }

osu.Game/Graphics/OsuIcon.cs

@@ -16,77 +16,19 @@ namespace osu.Game.Graphics
 {
     public static class OsuIcon
     {
-        #region Legacy spritesheet-based icons
-
-        private static IconUsage get(int icon) => new IconUsage((char)icon, @"osuFont");
-
-        // ruleset icons in circles
-        public static IconUsage RulesetOsu => get(0xe000);
-        public static IconUsage RulesetMania => get(0xe001);
-        public static IconUsage RulesetCatch => get(0xe002);
-        public static IconUsage RulesetTaiko => get(0xe003);
-
-        // ruleset icons without circles
-        public static IconUsage FilledCircle => get(0xe004);
-        public static IconUsage Logo => get(0xe006);
-        public static IconUsage ChevronDownCircle => get(0xe007);
-        public static IconUsage EditCircle => get(0xe033);
-        public static IconUsage LeftCircle => get(0xe034);
-        public static IconUsage RightCircle => get(0xe035);
-        public static IconUsage Charts => get(0xe036);
-        public static IconUsage Solo => get(0xe037);
-        public static IconUsage Multi => get(0xe038);
-        public static IconUsage Gear => get(0xe039);
-
-        // misc icons
-        public static IconUsage Bat => get(0xe008);
-        public static IconUsage Bubble => get(0xe009);
-        public static IconUsage BubblePop => get(0xe02e);
-        public static IconUsage Dice => get(0xe011);
-        public static IconUsage HeartBreak => get(0xe030);
-        public static IconUsage Hot => get(0xe031);
-        public static IconUsage ListSearch => get(0xe032);
-
-        //osu! playstyles
-        public static IconUsage PlayStyleTablet => get(0xe02a);
-        public static IconUsage PlayStyleMouse => get(0xe029);
-        public static IconUsage PlayStyleKeyboard => get(0xe02b);
-        public static IconUsage PlayStyleTouch => get(0xe02c);
-
-        // osu! difficulties
-        public static IconUsage EasyOsu => get(0xe015);
-        public static IconUsage NormalOsu => get(0xe016);
-        public static IconUsage HardOsu => get(0xe017);
-        public static IconUsage InsaneOsu => get(0xe018);
-        public static IconUsage ExpertOsu => get(0xe019);
-
-        // taiko difficulties
-        public static IconUsage EasyTaiko => get(0xe01a);
-        public static IconUsage NormalTaiko => get(0xe01b);
-        public static IconUsage HardTaiko => get(0xe01c);
-        public static IconUsage InsaneTaiko => get(0xe01d);
-        public static IconUsage ExpertTaiko => get(0xe01e);
-
-        // fruits difficulties
-        public static IconUsage EasyFruits => get(0xe01f);
-        public static IconUsage NormalFruits => get(0xe020);
-        public static IconUsage HardFruits => get(0xe021);
-        public static IconUsage InsaneFruits => get(0xe022);
-        public static IconUsage ExpertFruits => get(0xe023);
-
-        // mania difficulties
-        public static IconUsage EasyMania => get(0xe024);
-        public static IconUsage NormalMania => get(0xe025);
-        public static IconUsage HardMania => get(0xe026);
-        public static IconUsage InsaneMania => get(0xe027);
-        public static IconUsage ExpertMania => get(0xe028);
-
-        #endregion
-
-        #region New single-file-based icons
-
         public const string FONT_NAME = @"Icons";
 
+        // ruleset icons
+        public static IconUsage RulesetOsu => get(OsuIconMapping.RulesetOsu);
+        public static IconUsage RulesetMania => get(OsuIconMapping.RulesetMania);
+        public static IconUsage RulesetCatch => get(OsuIconMapping.RulesetCatch);
+        public static IconUsage RulesetTaiko => get(OsuIconMapping.RulesetTaiko);
+
+        public static IconUsage Logo => get(OsuIconMapping.Logo);
+        public static IconUsage EditCircle => get(OsuIconMapping.EditCircle);
+        public static IconUsage LeftCircle => get(OsuIconMapping.LeftCircle);
+        public static IconUsage RightCircle => get(OsuIconMapping.RightCircle);
+
         public static IconUsage Audio => get(OsuIconMapping.Audio);
         public static IconUsage Beatmap => get(OsuIconMapping.Beatmap);
         public static IconUsage Calendar => get(OsuIconMapping.Calendar);
@@ -246,6 +188,30 @@ namespace osu.Game.Graphics
 
         private enum OsuIconMapping
         {
+            [Description(@"Logo")]
+            Logo,
+
+            [Description(@"RulesetOsu")]
+            RulesetOsu,
+
+            [Description(@"RulesetMania")]
+            RulesetMania,
+
+            [Description(@"RulesetCatch")]
+            RulesetCatch,
+
+            [Description(@"RulesetTaiko")]
+            RulesetTaiko,
+
+            [Description(@"EditCircle")]
+            EditCircle,
+
+            [Description(@"LeftCircle")]
+            LeftCircle,
+
+            [Description(@"RightCircle")]
+            RightCircle,
+
             [Description(@"audio")]
             Audio,
 
@@ -737,7 +703,5 @@ namespace osu.Game.Graphics
                 textures.Dispose();
             }
         }
-
-        #endregion
     }
 }

osu.Game/Graphics/UserInterface/HoverClickSounds.cs

@@ -42,18 +42,20 @@ namespace osu.Game.Graphics.UserInterface
             this.buttons = buttons ?? new[] { MouseButton.Left };
         }
 
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio)
+        {
+            sampleClick = audio.Samples.Get($@"UI/{SampleSet.GetDescription()}-select")
+                          ?? audio.Samples.Get($@"UI/{HoverSampleSet.Default.GetDescription()}-select");
+
+            sampleClickDisabled = audio.Samples.Get($@"UI/{SampleSet.GetDescription()}-select-disabled")
+                                  ?? audio.Samples.Get($@"UI/{HoverSampleSet.Default.GetDescription()}-select-disabled");
+        }
+
         protected override bool OnClick(ClickEvent e)
         {
             if (buttons.Contains(e.Button))
-            {
-                var channel = Enabled.Value ? sampleClick?.GetChannel() : sampleClickDisabled?.GetChannel();
-
-                if (channel != null)
-                {
-                    channel.Frequency.Value = 0.99 + RNG.NextDouble(0.02);
-                    channel.Play();
-                }
-            }
+                PlayClickSample();
 
             return base.OnClick(e);
         }
@@ -66,14 +68,15 @@ namespace osu.Game.Graphics.UserInterface
             base.PlayHoverSample();
         }
 
-        [BackgroundDependencyLoader]
-        private void load(AudioManager audio)
+        public void PlayClickSample()
         {
-            sampleClick = audio.Samples.Get($@"UI/{SampleSet.GetDescription()}-select")
-                          ?? audio.Samples.Get($@"UI/{HoverSampleSet.Default.GetDescription()}-select");
+            var channel = Enabled.Value ? sampleClick?.GetChannel() : sampleClickDisabled?.GetChannel();
 
-            sampleClickDisabled = audio.Samples.Get($@"UI/{SampleSet.GetDescription()}-select-disabled")
-                                  ?? audio.Samples.Get($@"UI/{HoverSampleSet.Default.GetDescription()}-select-disabled");
+            if (channel != null)
+            {
+                channel.Frequency.Value = 0.99 + RNG.NextDouble(0.02);
+                channel.Play();
+            }
         }
     }
 }

osu.Game/Online/API/APIAccess.cs

@@ -15,6 +15,7 @@ using System.Threading.Tasks;
 using Newtonsoft.Json.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Development;
+using osu.Framework.Extensions;
 using osu.Framework.Extensions.ExceptionExtensions;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
@@ -52,6 +53,8 @@ namespace osu.Game.Online.API
 
         public string ProvidedUsername { get; private set; }
 
+        public SessionVerificationMethod? SessionVerificationMethod { get; set; }
+
         public string SecondFactorCode { get; private set; }
 
         private string password;
@@ -292,7 +295,17 @@ namespace osu.Game.Online.API
                     verificationRequest.Failure += ex =>
                     {
                         state.Value = APIState.RequiresSecondFactorAuth;
-                        LastLoginError = ex;
+
+                        if (verificationRequest.RequiredVerificationMethod != null)
+                        {
+                            SessionVerificationMethod = verificationRequest.RequiredVerificationMethod;
+                            LastLoginError = new APIException($"Must use {SessionVerificationMethod.GetDescription().ToLowerInvariant()} to complete verification.", ex);
+                        }
+                        else
+                        {
+                            LastLoginError = ex;
+                        }
+
                         SecondFactorCode = null;
                     };
 
@@ -337,7 +350,8 @@ namespace osu.Game.Online.API
 
                         localUser.Value = me;
                         configSupporter.Value = me.IsSupporter;
-                        state.Value = me.SessionVerified ? APIState.Online : APIState.RequiresSecondFactorAuth;
+                        SessionVerificationMethod = me.SessionVerificationMethod;
+                        state.Value = SessionVerificationMethod == null ? APIState.Online : APIState.RequiresSecondFactorAuth;
                         failureCount = 0;
                     };
 

osu.Game/Online/API/DummyAPIAccess.cs

@@ -5,6 +5,7 @@ using System;
 using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Game.Localisation;
 using osu.Game.Online.API.Requests;
@@ -62,7 +63,8 @@ namespace osu.Game.Online.API
 
         private bool shouldFailNextLogin;
         private bool stayConnectingNextLogin;
-        private bool requiredSecondFactorAuth = true;
+
+        public SessionVerificationMethod? SessionVerificationMethod { get; set; } = Requests.Responses.SessionVerificationMethod.EmailMessage;
 
         /// <summary>
         /// The current connectivity state of the API.
@@ -130,14 +132,14 @@ namespace osu.Game.Online.API
                 Id = DUMMY_USER_ID,
             };
 
-            if (requiredSecondFactorAuth)
+            if (SessionVerificationMethod != null)
             {
                 state.Value = APIState.RequiresSecondFactorAuth;
             }
             else
             {
                 onSuccessfulLogin();
-                requiredSecondFactorAuth = true;
+                SessionVerificationMethod = null;
             }
         }
 
@@ -147,7 +149,16 @@ namespace osu.Game.Online.API
             request.Failure += e =>
             {
                 state.Value = APIState.RequiresSecondFactorAuth;
-                LastLoginError = e;
+
+                if (request.RequiredVerificationMethod != null)
+                {
+                    SessionVerificationMethod = request.RequiredVerificationMethod;
+                    LastLoginError = new APIException($"Must use {SessionVerificationMethod.GetDescription().ToLowerInvariant()} to complete verification.", e);
+                }
+                else
+                {
+                    LastLoginError = e;
+                }
             };
 
             state.Value = APIState.Connecting;
@@ -204,7 +215,7 @@ namespace osu.Game.Online.API
         /// <summary>
         /// Skip 2FA requirement for next login.
         /// </summary>
-        public void SkipSecondFactor() => requiredSecondFactorAuth = false;
+        public void SkipSecondFactor() => SessionVerificationMethod = null;
 
         /// <summary>
         /// During the next simulated login, the process will fail immediately.

osu.Game/Online/API/IAPIProvider.cs

@@ -107,10 +107,15 @@ namespace osu.Game.Online.API
         /// <param name="password">The user's password.</param>
         void Login(string username, string password);
 
+        /// <summary>
+        /// The <see cref="SessionVerificationMethod"/> requested by the server to complete verification.
+        /// </summary>
+        SessionVerificationMethod? SessionVerificationMethod { get; }
+
         /// <summary>
         /// Provide a second-factor authentication code for authentication.
         /// </summary>
-        /// <param name="code">The 2FA code.</param>
+        /// <paramref name="code">The 2FA code.</paramref>
         void AuthenticateSecondFactor(string code);
 
         /// <summary>