Fix tablet settings adjusting with too much precision

Closes https://github.com/ppy/osu/issues/32920.

I don't know if there's going to be other cases of breakage, but from
what I can tell these settings *not* showing infinite precision
representations was a bug with the previous implementation of number
formatting.

.github/workflows/ci.yml

@@ -82,8 +82,18 @@ jobs:
         run: dotnet build -c Debug -warnaserror osu.Desktop.slnf
 
       - name: Test
-        run: dotnet test $pwd/**/*.Tests/bin/Debug/*/*.Tests.dll --logger "trx;LogFileName=TestResults-${{matrix.os.prettyname}}-${{matrix.threadingMode}}.trx" -- NUnit.ConsoleOut=0
-        shell: pwsh
+        run: >
+          dotnet test
+          osu.Game.Tests/bin/Debug/**/osu.Game.Tests.dll
+          osu.Game.Rulesets.Osu.Tests/bin/Debug/**/osu.Game.Rulesets.Osu.Tests.dll
+          osu.Game.Rulesets.Taiko.Tests/bin/Debug/**/osu.Game.Rulesets.Taiko.Tests.dll
+          osu.Game.Rulesets.Catch.Tests/bin/Debug/**/osu.Game.Rulesets.Catch.Tests.dll
+          osu.Game.Rulesets.Mania.Tests/bin/Debug/**/osu.Game.Rulesets.Mania.Tests.dll
+          osu.Game.Tournament.Tests/bin/Debug/**/osu.Game.Tournament.Tests.dll
+          Templates/**/*.Tests/bin/Debug/**/*.Tests.dll
+          --logger "trx;LogFileName=TestResults-${{matrix.os.prettyname}}-${{matrix.threadingMode}}.trx"
+          --
+          NUnit.ConsoleOut=0
 
       # Attempt to upload results even if test fails.
       # https://docs.github.com/en/actions/reference/context-and-expression-syntax-for-github-actions#always
@@ -136,4 +146,4 @@ jobs:
         run: dotnet workload install ios --from-rollback-file https://raw.githubusercontent.com/ppy/osu-framework/refs/heads/master/workloads.json
 
       - name: Build
-        run: dotnet build -c Debug osu.iOS
+        run: dotnet build -c Debug osu.iOS.slnf

osu.Android.props

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

osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmap.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.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
@@ -16,26 +17,30 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
             int fruits = HitObjects.Count(s => s is Fruit);
             int juiceStreams = HitObjects.Count(s => s is JuiceStream);
             int bananaShowers = HitObjects.Count(s => s is BananaShower);
+            int sum = Math.Max(1, fruits + juiceStreams);
 
             return new[]
             {
                 new BeatmapStatistic
                 {
-                    Name = @"Fruit Count",
+                    Name = @"Fruits",
                     Content = fruits.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
+                    BarDisplayLength = fruits / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Juice Stream Count",
+                    Name = @"Juice Streams",
                     Content = juiceStreams.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
+                    BarDisplayLength = juiceStreams / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Banana Shower Count",
+                    Name = @"Banana Showers",
                     Content = bananaShowers.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Spinners),
+                    BarDisplayLength = Math.Min(bananaShowers / 10f, 1),
                 }
             };
         }

osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapConverter.cs

@@ -45,7 +45,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                         LegacyConvertedY = yPositionData?.Y ?? CatchHitObject.DEFAULT_LEGACY_CONVERT_Y,
                         // prior to v8, speed multipliers don't adjust for how many ticks are generated over the same distance.
                         // this results in more (or less) ticks being generated in <v8 maps for the same time duration.
-                        TickDistanceMultiplier = beatmap.BeatmapInfo.BeatmapVersion < 8 ? 1f / ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(obj.StartTime).SliderVelocity : 1,
+                        TickDistanceMultiplier = beatmap.BeatmapVersion < 8 ? 1f / ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(obj.StartTime).SliderVelocity : 1,
                         SliderVelocityMultiplier = sliderVelocityData?.SliderVelocityMultiplier ?? 1
                     }.Yield();
 

osu.Game.Rulesets.Catch/Edit/Setup/CatchDifficultySection.cs

@@ -75,6 +75,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Setup
                 {
                     Caption = EditorSetupStrings.BaseVelocity,
                     HintText = EditorSetupStrings.BaseVelocityDescription,
+                    KeyboardStep = 0.1f,
                     Current = new BindableDouble(Beatmap.Difficulty.SliderMultiplier)
                     {
                         Default = 1.4,
@@ -89,6 +90,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Setup
                 {
                     Caption = EditorSetupStrings.TickRate,
                     HintText = EditorSetupStrings.TickRateDescription,
+                    KeyboardStep = 1,
                     Current = new BindableDouble(Beatmap.Difficulty.SliderTickRate)
                     {
                         Default = 1,

osu.Game.Rulesets.Catch/Mods/CatchModDifficultyAdjust.cs

@@ -1,8 +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.Linq;
+using System.Collections.Generic;
 using osu.Framework.Bindables;
+using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Catch.Beatmaps;
@@ -35,21 +36,21 @@ namespace osu.Game.Rulesets.Catch.Mods
         [SettingSource("Spicy Patterns", "Adjust the patterns as if Hard Rock is enabled.")]
         public BindableBool HardRockOffsets { get; } = new BindableBool();
 
-        public override string SettingDescription
+        public override IEnumerable<(LocalisableString setting, LocalisableString value)> SettingDescription
         {
             get
             {
-                string circleSize = CircleSize.IsDefault ? string.Empty : $"CS {CircleSize.Value:N1}";
-                string approachRate = ApproachRate.IsDefault ? string.Empty : $"AR {ApproachRate.Value:N1}";
-                string spicyPatterns = HardRockOffsets.IsDefault ? string.Empty : "Spicy patterns";
+                if (!CircleSize.IsDefault)
+                    yield return ("Circle size", $"{CircleSize.Value:N1}");
 
-                return string.Join(", ", new[]
-                {
-                    circleSize,
-                    base.SettingDescription,
-                    approachRate,
-                    spicyPatterns,
-                }.Where(s => !string.IsNullOrEmpty(s)));
+                foreach (var setting in base.SettingDescription)
+                    yield return setting;
+
+                if (!ApproachRate.IsDefault)
+                    yield return ("Approach rate", $"{ApproachRate.Value:N1}");
+
+                if (!HardRockOffsets.IsDefault)
+                    yield return ("Spicy patterns", "On");
             }
         }
 

osu.Game.Rulesets.Catch/Mods/CatchModEasy.cs

@@ -8,6 +8,6 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
     public class CatchModEasy : ModEasyWithExtraLives
     {
-        public override LocalisableString Description => @"Larger fruits, more forgiving HP drain, less accuracy required, and three lives!";
+        public override LocalisableString Description => @"Larger fruits, more forgiving HP drain, less accuracy required, and extra lives!";
     }
 }

osu.Game.Rulesets.Mania.Tests/ManiaFilterCriteriaTest.cs

@@ -0,0 +1,187 @@
+// 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.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Mods;
+using osu.Game.Screens.Select;
+using osu.Game.Screens.Select.Filter;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [TestFixture]
+    public class ManiaFilterCriteriaTest
+    {
+        [TestCase]
+        public void TestKeysEqualSingleValue()
+        {
+            var criteria = new ManiaFilterCriteria();
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.Equal, "1");
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 4 }),
+                new FilterCriteria
+                {
+                    Mods = [new ManiaModKey1()]
+                }));
+        }
+
+        [TestCase]
+        public void TestKeysEqualMultipleValues()
+        {
+            var criteria = new ManiaFilterCriteria();
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.Equal, "1,3,5,7");
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 4 }),
+                new FilterCriteria
+                {
+                    Mods = [new ManiaModKey1()]
+                }));
+        }
+
+        [TestCase]
+        public void TestKeysNotEqualSingleValue()
+        {
+            var criteria = new ManiaFilterCriteria();
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "1");
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 4 }),
+                new FilterCriteria
+                {
+                    Mods = [new ManiaModKey1()]
+                }));
+        }
+
+        [TestCase]
+        public void TestKeysNotEqualMultipleValues()
+        {
+            var criteria = new ManiaFilterCriteria();
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "1,3,5,7");
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 4 }),
+                new FilterCriteria
+                {
+                    Mods = [new ManiaModKey1()]
+                }));
+        }
+
+        [TestCase]
+        public void TestKeysGreaterOrEqualThan()
+        {
+            var criteria = new ManiaFilterCriteria();
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.GreaterOrEqual, "4");
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 4 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 5 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 3 }),
+                new FilterCriteria
+                {
+                    Mods = [new ManiaModKey7()]
+                }));
+        }
+
+        [TestCase]
+        public void TestFilterIntersection()
+        {
+            var criteria = new ManiaFilterCriteria();
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.Greater, "4");
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "7");
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 4 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 5 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 7 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 9 }),
+                new FilterCriteria()));
+        }
+
+        [TestCase]
+        public void TestInvalidFilters()
+        {
+            var criteria = new ManiaFilterCriteria();
+
+            Assert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.Equal, "some text"));
+            Assert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "4,some text"));
+            Assert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.GreaterOrEqual, "4,5,6"));
+        }
+    }
+}

osu.Game.Rulesets.Mania.Tests/TestSceneLegacyReplayPlayback.cs

@@ -0,0 +1,470 @@
+// 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.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Mods;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Replays;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
+    public partial class TestSceneLegacyReplayPlayback : LegacyReplayPlaybackTestScene
+    {
+        protected override Ruleset CreateRuleset() => new ManiaRuleset();
+
+        protected override string? ExportLocation => null;
+
+        private static readonly object[][] score_v2_test_cases =
+        {
+            // With respect to notation,
+            // square brackets `[]` represent *closed* or *inclusive* bounds,
+            // while round brackets `()` represent *open* or *exclusive* bounds.
+
+            // Note that mania hitwindows are heavily idiosyncratic,
+            // and if you *think* a number here is wrong, probably double check.
+
+            // Known issues / complexities:
+            // - There is a disparate set of hitwindow ranges for: score V1 non-converts, score V1 converts, and score V2 (regardless of convert)
+            // - It is NEVER POSSIBLE to get a MEH result when late; exceeding the OK hit windows will result in a MISS.
+            //   Additionally, the OK hit window when late is EXCLUSIVE / OPEN rather than INCLUSIVE / CLOSED.
+            //   Relevant stable source: https://github.com/peppy/osu-stable-reference/blob/996648fba06baf4e7d2e0b248959399444017895/osu!/GameplayElements/HitObjectManagerMania.cs#L737-L751
+            // - There is also a seemingly mania-specific issue wherein key inputs registered before time instant 0 get truncated to time 0,
+            //   which is why the beatmaps used below make sure not to cross that boundary (the note starts at t=300ms).
+            //   This is not an issue in osu! or taiko.
+            //   The source of this behaviour has not been investigated in detail.
+
+            // OD = 5 test cases.
+            // PERFECT hit window is [ -19ms,  19ms]
+            // GREAT   hit window is [ -49ms,  49ms]
+            // GOOD    hit window is [ -82ms,  82ms]
+            // OK      hit window is [-112ms, 112ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-136ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 5f, -18d, HitResult.Perfect },
+            new object[] { 5f, -19d, HitResult.Perfect },
+            new object[] { 5f, -20d, HitResult.Great },
+            new object[] { 5f, -21d, HitResult.Great },
+            new object[] { 5f, -48d, HitResult.Great },
+            new object[] { 5f, -49d, HitResult.Great },
+            new object[] { 5f, -50d, HitResult.Good },
+            new object[] { 5f, -51d, HitResult.Good },
+            new object[] { 5f, -81d, HitResult.Good },
+            new object[] { 5f, -82d, HitResult.Good },
+            new object[] { 5f, -83d, HitResult.Ok },
+            new object[] { 5f, -84d, HitResult.Ok },
+            new object[] { 5f, -111d, HitResult.Ok },
+            new object[] { 5f, -112d, HitResult.Ok },
+            new object[] { 5f, -113d, HitResult.Meh },
+            new object[] { 5f, -114d, HitResult.Meh },
+            new object[] { 5f, -135d, HitResult.Meh },
+            new object[] { 5f, -136d, HitResult.Meh },
+            new object[] { 5f, -137d, HitResult.Miss },
+            new object[] { 5f, -138d, HitResult.Miss },
+            new object[] { 5f, 111d, HitResult.Ok },
+            new object[] { 5f, 112d, HitResult.Miss },
+            new object[] { 5f, 113d, HitResult.Miss },
+            new object[] { 5f, 114d, HitResult.Miss },
+            new object[] { 5f, 135d, HitResult.Miss },
+            new object[] { 5f, 136d, HitResult.Miss },
+            new object[] { 5f, 137d, HitResult.Miss },
+            new object[] { 5f, 138d, HitResult.Miss },
+
+            // OD = 9.3 test cases.
+            // PERFECT hit window is [ -14ms,  14ms]
+            // GREAT   hit window is [ -36ms,  36ms]
+            // GOOD    hit window is [ -69ms,  69ms]
+            // OK      hit window is [ -99ms,  99ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-123ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 9.3f, 13d, HitResult.Perfect },
+            new object[] { 9.3f, 14d, HitResult.Perfect },
+            new object[] { 9.3f, 15d, HitResult.Great },
+            new object[] { 9.3f, 16d, HitResult.Great },
+            new object[] { 9.3f, 35d, HitResult.Great },
+            new object[] { 9.3f, 36d, HitResult.Great },
+            new object[] { 9.3f, 37d, HitResult.Good },
+            new object[] { 9.3f, 38d, HitResult.Good },
+            new object[] { 9.3f, 68d, HitResult.Good },
+            new object[] { 9.3f, 69d, HitResult.Good },
+            new object[] { 9.3f, 70d, HitResult.Ok },
+            new object[] { 9.3f, 71d, HitResult.Ok },
+            new object[] { 9.3f, 98d, HitResult.Ok },
+            new object[] { 9.3f, 99d, HitResult.Miss },
+            new object[] { 9.3f, 100d, HitResult.Miss },
+            new object[] { 9.3f, 101d, HitResult.Miss },
+            new object[] { 9.3f, 122d, HitResult.Miss },
+            new object[] { 9.3f, 123d, HitResult.Miss },
+            new object[] { 9.3f, 124d, HitResult.Miss },
+            new object[] { 9.3f, 125d, HitResult.Miss },
+            new object[] { 9.3f, -98d, HitResult.Ok },
+            new object[] { 9.3f, -99d, HitResult.Ok },
+            new object[] { 9.3f, -100d, HitResult.Meh },
+            new object[] { 9.3f, -101d, HitResult.Meh },
+            new object[] { 9.3f, -122d, HitResult.Meh },
+            new object[] { 9.3f, -123d, HitResult.Meh },
+            new object[] { 9.3f, -124d, HitResult.Miss },
+            new object[] { 9.3f, -125d, HitResult.Miss },
+        };
+
+        private static readonly object[][] score_v1_non_convert_test_cases =
+        {
+            // OD = 5 test cases.
+            // PERFECT hit window is [ -16ms,  16ms]
+            // GREAT   hit window is [ -49ms,  49ms]
+            // GOOD    hit window is [ -82ms,  82ms]
+            // OK      hit window is [-112ms, 112ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-136ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 5f, -15d, HitResult.Perfect },
+            new object[] { 5f, -16d, HitResult.Perfect },
+            new object[] { 5f, -17d, HitResult.Great },
+            new object[] { 5f, -18d, HitResult.Great },
+            new object[] { 5f, -48d, HitResult.Great },
+            new object[] { 5f, -49d, HitResult.Great },
+            new object[] { 5f, -50d, HitResult.Good },
+            new object[] { 5f, -51d, HitResult.Good },
+            new object[] { 5f, -81d, HitResult.Good },
+            new object[] { 5f, -82d, HitResult.Good },
+            new object[] { 5f, -83d, HitResult.Ok },
+            new object[] { 5f, -84d, HitResult.Ok },
+            new object[] { 5f, -111d, HitResult.Ok },
+            new object[] { 5f, -112d, HitResult.Ok },
+            new object[] { 5f, -113d, HitResult.Meh },
+            new object[] { 5f, -114d, HitResult.Meh },
+            new object[] { 5f, -135d, HitResult.Meh },
+            new object[] { 5f, -136d, HitResult.Meh },
+            new object[] { 5f, -137d, HitResult.Miss },
+            new object[] { 5f, -138d, HitResult.Miss },
+            new object[] { 5f, 111d, HitResult.Ok },
+            new object[] { 5f, 112d, HitResult.Miss },
+            new object[] { 5f, 113d, HitResult.Miss },
+            new object[] { 5f, 114d, HitResult.Miss },
+            new object[] { 5f, 135d, HitResult.Miss },
+            new object[] { 5f, 136d, HitResult.Miss },
+            new object[] { 5f, 137d, HitResult.Miss },
+            new object[] { 5f, 138d, HitResult.Miss },
+
+            // OD = 9.3 test cases.
+            // PERFECT hit window is [ -16ms,  16ms]
+            // GREAT   hit window is [ -36ms,  36ms]
+            // GOOD    hit window is [ -69ms,  69ms]
+            // OK      hit window is [ -99ms,  99ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-123ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 9.3f, 15d, HitResult.Perfect },
+            new object[] { 9.3f, 16d, HitResult.Perfect },
+            new object[] { 9.3f, 17d, HitResult.Great },
+            new object[] { 9.3f, 18d, HitResult.Great },
+            new object[] { 9.3f, 35d, HitResult.Great },
+            new object[] { 9.3f, 36d, HitResult.Great },
+            new object[] { 9.3f, 37d, HitResult.Good },
+            new object[] { 9.3f, 38d, HitResult.Good },
+            new object[] { 9.3f, 68d, HitResult.Good },
+            new object[] { 9.3f, 69d, HitResult.Good },
+            new object[] { 9.3f, 70d, HitResult.Ok },
+            new object[] { 9.3f, 71d, HitResult.Ok },
+            new object[] { 9.3f, 98d, HitResult.Ok },
+            new object[] { 9.3f, 99d, HitResult.Miss },
+            new object[] { 9.3f, 100d, HitResult.Miss },
+            new object[] { 9.3f, 101d, HitResult.Miss },
+            new object[] { 9.3f, 122d, HitResult.Miss },
+            new object[] { 9.3f, 123d, HitResult.Miss },
+            new object[] { 9.3f, 124d, HitResult.Miss },
+            new object[] { 9.3f, 125d, HitResult.Miss },
+            new object[] { 9.3f, -98d, HitResult.Ok },
+            new object[] { 9.3f, -99d, HitResult.Ok },
+            new object[] { 9.3f, -100d, HitResult.Meh },
+            new object[] { 9.3f, -101d, HitResult.Meh },
+            new object[] { 9.3f, -122d, HitResult.Meh },
+            new object[] { 9.3f, -123d, HitResult.Meh },
+            new object[] { 9.3f, -124d, HitResult.Miss },
+            new object[] { 9.3f, -125d, HitResult.Miss },
+
+            // OD = 3.1 test cases.
+            // PERFECT hit window is [ -16ms,  16ms]
+            // GREAT   hit window is [ -54ms,  54ms]
+            // GOOD    hit window is [ -87ms,  87ms]
+            // OK      hit window is [-117ms, 117ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-141ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 3.1f, 15d, HitResult.Perfect },
+            new object[] { 3.1f, 16d, HitResult.Perfect },
+            new object[] { 3.1f, 17d, HitResult.Great },
+            new object[] { 3.1f, 18d, HitResult.Great },
+            new object[] { 3.1f, 53d, HitResult.Great },
+            new object[] { 3.1f, 54d, HitResult.Great },
+            new object[] { 3.1f, 55d, HitResult.Good },
+            new object[] { 3.1f, 56d, HitResult.Good },
+            new object[] { 3.1f, 86d, HitResult.Good },
+            new object[] { 3.1f, 87d, HitResult.Good },
+            new object[] { 3.1f, 88d, HitResult.Ok },
+            new object[] { 3.1f, 89d, HitResult.Ok },
+            new object[] { 3.1f, 116d, HitResult.Ok },
+            new object[] { 3.1f, 117d, HitResult.Miss },
+            new object[] { 3.1f, 118d, HitResult.Miss },
+            new object[] { 3.1f, 119d, HitResult.Miss },
+            new object[] { 3.1f, 140d, HitResult.Miss },
+            new object[] { 3.1f, 141d, HitResult.Miss },
+            new object[] { 3.1f, 142d, HitResult.Miss },
+            new object[] { 3.1f, 143d, HitResult.Miss },
+            new object[] { 3.1f, -116d, HitResult.Ok },
+            new object[] { 3.1f, -117d, HitResult.Ok },
+            new object[] { 3.1f, -118d, HitResult.Meh },
+            new object[] { 3.1f, -119d, HitResult.Meh },
+            new object[] { 3.1f, -140d, HitResult.Meh },
+            new object[] { 3.1f, -141d, HitResult.Meh },
+            new object[] { 3.1f, -142d, HitResult.Miss },
+            new object[] { 3.1f, -143d, HitResult.Miss },
+        };
+
+        private static readonly object[][] score_v1_convert_test_cases =
+        {
+            // OD = 5 test cases.
+            // PERFECT hit window is [ -16ms,  16ms]
+            // GREAT   hit window is [ -34ms,  34ms]
+            // GOOD    hit window is [ -67ms,  67ms]
+            // OK      hit window is [ -97ms,  97ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-121ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 5f, -15d, HitResult.Perfect },
+            new object[] { 5f, -16d, HitResult.Perfect },
+            new object[] { 5f, -17d, HitResult.Great },
+            new object[] { 5f, -18d, HitResult.Great },
+            new object[] { 5f, -33d, HitResult.Great },
+            new object[] { 5f, -34d, HitResult.Great },
+            new object[] { 5f, -35d, HitResult.Good },
+            new object[] { 5f, -36d, HitResult.Good },
+            new object[] { 5f, -66d, HitResult.Good },
+            new object[] { 5f, -67d, HitResult.Good },
+            new object[] { 5f, -68d, HitResult.Ok },
+            new object[] { 5f, -69d, HitResult.Ok },
+            new object[] { 5f, -96d, HitResult.Ok },
+            new object[] { 5f, -97d, HitResult.Ok },
+            new object[] { 5f, -98d, HitResult.Meh },
+            new object[] { 5f, -99d, HitResult.Meh },
+            new object[] { 5f, -120d, HitResult.Meh },
+            new object[] { 5f, -121d, HitResult.Meh },
+            new object[] { 5f, -122d, HitResult.Miss },
+            new object[] { 5f, -123d, HitResult.Miss },
+            new object[] { 5f, 96d, HitResult.Ok },
+            new object[] { 5f, 97d, HitResult.Miss },
+            new object[] { 5f, 98d, HitResult.Miss },
+            new object[] { 5f, 99d, HitResult.Miss },
+            new object[] { 5f, 120d, HitResult.Miss },
+            new object[] { 5f, 121d, HitResult.Miss },
+            new object[] { 5f, 122d, HitResult.Miss },
+            new object[] { 5f, 123d, HitResult.Miss },
+
+            // OD = 3.1 test cases.
+            // PERFECT hit window is [ -16ms,  16ms]
+            // GREAT   hit window is [ -47ms,  47ms]
+            // GOOD    hit window is [ -77ms,  77ms]
+            // OK      hit window is [ -97ms,  97ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-121ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 3.1f, 15d, HitResult.Perfect },
+            new object[] { 3.1f, 16d, HitResult.Perfect },
+            new object[] { 3.1f, 17d, HitResult.Great },
+            new object[] { 3.1f, 18d, HitResult.Great },
+            new object[] { 3.1f, 46d, HitResult.Great },
+            new object[] { 3.1f, 47d, HitResult.Great },
+            new object[] { 3.1f, 48d, HitResult.Good },
+            new object[] { 3.1f, 49d, HitResult.Good },
+            new object[] { 3.1f, 76d, HitResult.Good },
+            new object[] { 3.1f, 77d, HitResult.Good },
+            new object[] { 3.1f, 78d, HitResult.Ok },
+            new object[] { 3.1f, 79d, HitResult.Ok },
+            new object[] { 3.1f, 96d, HitResult.Ok },
+            new object[] { 3.1f, 97d, HitResult.Miss },
+            new object[] { 3.1f, 98d, HitResult.Miss },
+            new object[] { 3.1f, 99d, HitResult.Miss },
+            new object[] { 3.1f, 120d, HitResult.Miss },
+            new object[] { 3.1f, 121d, HitResult.Miss },
+            new object[] { 3.1f, 122d, HitResult.Miss },
+            new object[] { 3.1f, 123d, HitResult.Miss },
+            new object[] { 3.1f, -96d, HitResult.Ok },
+            new object[] { 3.1f, -97d, HitResult.Ok },
+            new object[] { 3.1f, -98d, HitResult.Meh },
+            new object[] { 3.1f, -99d, HitResult.Meh },
+            new object[] { 3.1f, -120d, HitResult.Meh },
+            new object[] { 3.1f, -121d, HitResult.Meh },
+            new object[] { 3.1f, -122d, HitResult.Miss },
+            new object[] { 3.1f, -123d, HitResult.Miss },
+        };
+
+        [TestCaseSource(nameof(score_v2_test_cases))]
+        public void TestHitWindowTreatmentWithScoreV2(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            const double note_time = 300;
+
+            var cpi = new ControlPointInfo();
+            cpi.Add(0, new TimingControlPoint { BeatLength = 1000 });
+            var beatmap = new ManiaBeatmap(new StageDefinition(1))
+            {
+                HitObjects =
+                {
+                    new Note
+                    {
+                        StartTime = note_time,
+                        Column = 0,
+                    }
+                },
+                Difficulty = new BeatmapDifficulty
+                {
+                    OverallDifficulty = overallDifficulty,
+                    CircleSize = 1,
+                },
+                BeatmapInfo =
+                {
+                    Ruleset = new ManiaRuleset().RulesetInfo,
+                },
+                ControlPointInfo = cpi,
+            };
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new ManiaReplayFrame(0),
+                    new ManiaReplayFrame(note_time + hitOffset, ManiaAction.Key1),
+                    new ManiaReplayFrame(note_time + hitOffset + 20),
+                }
+            };
+
+            var score = new Score
+            {
+                Replay = replay,
+                ScoreInfo = new ScoreInfo
+                {
+                    Ruleset = CreateRuleset().RulesetInfo,
+                    Mods = [new ModScoreV2()]
+                }
+            };
+
+            RunTest($@"SV2 single note @ OD{overallDifficulty}", beatmap, $@"SV2 {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        [TestCaseSource(nameof(score_v1_non_convert_test_cases))]
+        public void TestHitWindowTreatmentWithScoreV1NonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            const double note_time = 300;
+
+            var cpi = new ControlPointInfo();
+            cpi.Add(0, new TimingControlPoint { BeatLength = 1000 });
+            var beatmap = new ManiaBeatmap(new StageDefinition(1))
+            {
+                HitObjects =
+                {
+                    new Note
+                    {
+                        StartTime = note_time,
+                        Column = 0,
+                    }
+                },
+                Difficulty = new BeatmapDifficulty
+                {
+                    OverallDifficulty = overallDifficulty,
+                    CircleSize = 1,
+                },
+                BeatmapInfo =
+                {
+                    Ruleset = new ManiaRuleset().RulesetInfo,
+                },
+                ControlPointInfo = cpi,
+            };
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new ManiaReplayFrame(0),
+                    new ManiaReplayFrame(note_time + hitOffset, ManiaAction.Key1),
+                    new ManiaReplayFrame(note_time + hitOffset + 20),
+                }
+            };
+
+            var score = new Score
+            {
+                Replay = replay,
+                ScoreInfo = new ScoreInfo
+                {
+                    Ruleset = CreateRuleset().RulesetInfo,
+                }
+            };
+
+            RunTest($@"SV1 single note @ OD{overallDifficulty}", beatmap, $@"SV1 {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        [TestCaseSource(nameof(score_v1_convert_test_cases))]
+        public void TestHitWindowTreatmentWithScoreV1Convert(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            const double note_time = 300;
+
+            var cpi = new ControlPointInfo();
+            cpi.Add(0, new TimingControlPoint { BeatLength = 1000 });
+            var beatmap = new Beatmap
+            {
+                HitObjects =
+                {
+                    new FakeCircle
+                    {
+                        StartTime = note_time,
+                    }
+                },
+                Difficulty = new BeatmapDifficulty
+                {
+                    OverallDifficulty = overallDifficulty,
+                },
+                BeatmapInfo =
+                {
+                    Ruleset = new RulesetInfo { OnlineID = 0 }
+                },
+                ControlPointInfo = cpi,
+            };
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new ManiaReplayFrame(0),
+                    new ManiaReplayFrame(note_time + hitOffset, ManiaAction.Key1),
+                    new ManiaReplayFrame(note_time + hitOffset + 20),
+                }
+            };
+
+            var score = new Score
+            {
+                Replay = replay,
+                ScoreInfo = new ScoreInfo
+                {
+                    Ruleset = CreateRuleset().RulesetInfo,
+                    Mods = [new ManiaModKey1()],
+                }
+            };
+
+            RunTest($@"SV1 convert single note @ OD{overallDifficulty}", beatmap, $@"SV1 convert {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        private class FakeCircle : HitObject, IHasPosition
+        {
+            public float X
+            {
+                get => Position.X;
+                set => Position = new Vector2(value, Position.Y);
+            }
+
+            public float Y
+            {
+                get => Position.Y;
+                set => Position = new Vector2(Position.X, value);
+            }
+
+            public Vector2 Position { get; set; }
+        }
+    }
+}

osu.Game.Rulesets.Mania.Tests/TestSceneReplayStability.cs

@@ -0,0 +1,149 @@
+// 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.Game.Beatmaps;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
+    public partial class TestSceneReplayStability : ReplayStabilityTestScene
+    {
+        private static readonly object[][] test_cases =
+        {
+            // With respect to notation,
+            // square brackets `[]` represent *closed* or *inclusive* bounds,
+            // while round brackets `()` represent *open* or *exclusive* bounds.
+
+            // OD = 5 test cases.
+            // PERFECT hit window is [ -19.4ms,  19.4ms]
+            // GREAT   hit window is [ -49.0ms,  49.0ms]
+            // GOOD    hit window is [ -82.0ms,  82.0ms]
+            // OK      hit window is [-112.0ms, 112.0ms]
+            // MEH     hit window is [-136.0ms, 136.0ms]
+            // MISS    hit window is [-173.0ms, 173.0ms]
+            new object[] { 5f, -19d, HitResult.Perfect },
+            new object[] { 5f, -19.2d, HitResult.Perfect },
+            new object[] { 5f, -19.38d, HitResult.Perfect },
+            // new object[] { 5f, -19.4d, HitResult.Perfect }, <- in theory this should work, in practice it does not (fails even before encode & rounding due to floating point precision issues)
+            new object[] { 5f, -19.44d, HitResult.Great },
+            new object[] { 5f, -19.7d, HitResult.Great },
+            new object[] { 5f, -20d, HitResult.Great },
+            new object[] { 5f, -48d, HitResult.Great },
+            new object[] { 5f, -48.4d, HitResult.Great },
+            new object[] { 5f, -48.7d, HitResult.Great },
+            new object[] { 5f, -49d, HitResult.Great },
+            new object[] { 5f, -49.2d, HitResult.Good },
+            new object[] { 5f, -49.7d, HitResult.Good },
+            new object[] { 5f, -50d, HitResult.Good },
+            new object[] { 5f, -81d, HitResult.Good },
+            new object[] { 5f, -81.2d, HitResult.Good },
+            new object[] { 5f, -81.7d, HitResult.Good },
+            new object[] { 5f, -82d, HitResult.Good },
+            new object[] { 5f, -82.2d, HitResult.Ok },
+            new object[] { 5f, -82.7d, HitResult.Ok },
+            new object[] { 5f, -83d, HitResult.Ok },
+            new object[] { 5f, -111d, HitResult.Ok },
+            new object[] { 5f, -111.2d, HitResult.Ok },
+            new object[] { 5f, -111.7d, HitResult.Ok },
+            new object[] { 5f, -112d, HitResult.Ok },
+            new object[] { 5f, -112.2d, HitResult.Meh },
+            new object[] { 5f, -112.7d, HitResult.Meh },
+            new object[] { 5f, -113d, HitResult.Meh },
+            new object[] { 5f, -135d, HitResult.Meh },
+            new object[] { 5f, -135.2d, HitResult.Meh },
+            new object[] { 5f, -135.8d, HitResult.Meh },
+            new object[] { 5f, -136d, HitResult.Meh },
+            new object[] { 5f, -136.2d, HitResult.Miss },
+            new object[] { 5f, -136.7d, HitResult.Miss },
+            new object[] { 5f, -137d, HitResult.Miss },
+
+            // OD = 9.3 test cases.
+            // PERFECT hit window is [ -14.67ms,  14.67ms]
+            // GREAT   hit window is [ -36.10ms,  36.10ms]
+            // GOOD    hit window is [ -69.10ms,  69.10ms]
+            // OK      hit window is [ -99.10ms,  99.10ms]
+            // MEH     hit window is [-123.10ms, 123.10ms]
+            // MISS    hit window is [-160.10ms, 160.10ms]
+            new object[] { 9.3f, 14d, HitResult.Perfect },
+            new object[] { 9.3f, 14.2d, HitResult.Perfect },
+            new object[] { 9.3f, 14.6d, HitResult.Perfect },
+            // new object[] { 9.3f, 14.67d, HitResult.Perfect }, <- in theory this should work, in practice it does not (fails even before encode & rounding due to floating point precision issues)
+            new object[] { 9.3f, 14.7d, HitResult.Great },
+            new object[] { 9.3f, 15d, HitResult.Great },
+            new object[] { 9.3f, 35d, HitResult.Great },
+            new object[] { 9.3f, 35.3d, HitResult.Great },
+            new object[] { 9.3f, 35.8d, HitResult.Great },
+            new object[] { 9.3f, 36.05d, HitResult.Great },
+            new object[] { 9.3f, 36.3d, HitResult.Good },
+            new object[] { 9.3f, 36.7d, HitResult.Good },
+            new object[] { 9.3f, 37d, HitResult.Good },
+            new object[] { 9.3f, 68d, HitResult.Good },
+            new object[] { 9.3f, 68.4d, HitResult.Good },
+            new object[] { 9.3f, 68.9d, HitResult.Good },
+            new object[] { 9.3f, 69.07d, HitResult.Good },
+            new object[] { 9.3f, 69.25d, HitResult.Ok },
+            new object[] { 9.3f, 69.85d, HitResult.Ok },
+            new object[] { 9.3f, 70d, HitResult.Ok },
+            new object[] { 9.3f, 98d, HitResult.Ok },
+            new object[] { 9.3f, 98.3d, HitResult.Ok },
+            new object[] { 9.3f, 98.6d, HitResult.Ok },
+            new object[] { 9.3f, 99d, HitResult.Ok },
+            new object[] { 9.3f, 99.3d, HitResult.Meh },
+            new object[] { 9.3f, 99.7d, HitResult.Meh },
+            new object[] { 9.3f, 100d, HitResult.Meh },
+            new object[] { 9.3f, 122d, HitResult.Meh },
+            new object[] { 9.3f, 122.34d, HitResult.Meh },
+            new object[] { 9.3f, 122.57d, HitResult.Meh },
+            new object[] { 9.3f, 123.04d, HitResult.Meh },
+            new object[] { 9.3f, 123.45d, HitResult.Miss },
+            new object[] { 9.3f, 123.95d, HitResult.Miss },
+            new object[] { 9.3f, 124d, HitResult.Miss },
+        };
+
+        [TestCaseSource(nameof(test_cases))]
+        public void TestHitWindowStability(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            const double note_time = 100;
+
+            var beatmap = new ManiaBeatmap(new StageDefinition(1))
+            {
+                HitObjects =
+                {
+                    new Note
+                    {
+                        StartTime = note_time,
+                        Column = 0,
+                    }
+                },
+                Difficulty = new BeatmapDifficulty
+                {
+                    OverallDifficulty = overallDifficulty,
+                    CircleSize = 1,
+                },
+                BeatmapInfo =
+                {
+                    Ruleset = new ManiaRuleset().RulesetInfo,
+                },
+            };
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new ManiaReplayFrame(0),
+                    new ManiaReplayFrame(note_time + hitOffset, ManiaAction.Key1),
+                    new ManiaReplayFrame(note_time + hitOffset + 20),
+                }
+            };
+
+            RunTest(beatmap, replay, [expectedResult]);
+        }
+    }
+}

osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmap.cs

@@ -36,20 +36,23 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         {
             int notes = HitObjects.Count(s => s is Note);
             int holdNotes = HitObjects.Count(s => s is HoldNote);
+            int sum = Math.Max(1, notes + holdNotes);
 
             return new[]
             {
                 new BeatmapStatistic
                 {
-                    Name = @"Note Count",
+                    Name = @"Notes",
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
                     Content = notes.ToString(),
+                    BarDisplayLength = notes / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Hold Note Count",
+                    Name = @"Hold Notes",
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
                     Content = holdNotes.ToString(),
+                    BarDisplayLength = holdNotes / (float)sum,
                 },
             };
         }

osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs

@@ -1,7 +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.
 
-using System;
 using osu.Framework.Configuration.Tracking;
 using osu.Game.Configuration;
 using osu.Game.Localisation;
@@ -25,17 +24,6 @@ namespace osu.Game.Rulesets.Mania.Configuration
             SetDefault(ManiaRulesetSetting.ScrollDirection, ManiaScrollingDirection.Down);
             SetDefault(ManiaRulesetSetting.TimingBasedNoteColouring, false);
             SetDefault(ManiaRulesetSetting.MobileLayout, ManiaMobileLayout.Portrait);
-
-#pragma warning disable CS0618
-            // Although obsolete, this is still required to populate the bindable from the database in case migration is required.
-            SetDefault<double?>(ManiaRulesetSetting.ScrollTime, null);
-
-            if (Get<double?>(ManiaRulesetSetting.ScrollTime) is double scrollTime)
-            {
-                SetValue(ManiaRulesetSetting.ScrollSpeed, Math.Round(DrawableManiaRuleset.MAX_TIME_RANGE / scrollTime));
-                SetValue<double?>(ManiaRulesetSetting.ScrollTime, null);
-            }
-#pragma warning restore CS0618
         }
 
         public override TrackedSettings CreateTrackedSettings() => new TrackedSettings
@@ -52,8 +40,6 @@ namespace osu.Game.Rulesets.Mania.Configuration
 
     public enum ManiaRulesetSetting
     {
-        [Obsolete("Use ScrollSpeed instead.")] // Can be removed 2023-11-30
-        ScrollTime,
         ScrollSpeed,
         ScrollDirection,
         TimingBasedNoteColouring,

osu.Game.Rulesets.Mania/Edit/Setup/ManiaDifficultySection.cs

@@ -89,6 +89,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Setup
                 {
                     Caption = EditorSetupStrings.BaseVelocity,
                     HintText = EditorSetupStrings.BaseVelocityDescription,
+                    KeyboardStep = 0.1f,
                     Current = new BindableDouble(Beatmap.Difficulty.SliderMultiplier)
                     {
                         Default = 1.4,
@@ -103,6 +104,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Setup
                 {
                     Caption = EditorSetupStrings.TickRate,
                     HintText = EditorSetupStrings.TickRateDescription,
+                    KeyboardStep = 1,
                     Current = new BindableDouble(Beatmap.Difficulty.SliderTickRate)
                     {
                         Default = 1,

osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs

@@ -5,6 +5,7 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Bindables;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Formats;
 using osu.Game.Rulesets.Filter;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Mods;
@@ -17,20 +18,72 @@ namespace osu.Game.Rulesets.Mania
 {
     public class ManiaFilterCriteria : IRulesetFilterCriteria
     {
-        private FilterCriteria.OptionalRange<float> keys;
+        private readonly HashSet<int> includedKeyCounts = Enumerable.Range(1, LegacyBeatmapDecoder.MAX_MANIA_KEY_COUNT).ToHashSet();
 
         public bool Matches(BeatmapInfo beatmapInfo, FilterCriteria criteria)
         {
-            return !keys.HasFilter || keys.IsInRange(ManiaBeatmapConverter.GetColumnCount(LegacyBeatmapConversionDifficultyInfo.FromBeatmapInfo(beatmapInfo), criteria.Mods));
+            int keyCount = ManiaBeatmapConverter.GetColumnCount(LegacyBeatmapConversionDifficultyInfo.FromBeatmapInfo(beatmapInfo), criteria.Mods);
+
+            return includedKeyCounts.Contains(keyCount);
         }
 
-        public bool TryParseCustomKeywordCriteria(string key, Operator op, string value)
+        public bool TryParseCustomKeywordCriteria(string key, Operator op, string strValues)
         {
             switch (key)
             {
                 case "key":
                 case "keys":
-                    return FilterQueryParser.TryUpdateCriteriaRange(ref keys, op, value);
+                {
+                    var keyCounts = new HashSet<int>();
+
+                    foreach (string strValue in strValues.Split(','))
+                    {
+                        if (!int.TryParse(strValue, out int keyCount))
+                            return false;
+
+                        keyCounts.Add(keyCount);
+                    }
+
+                    int? singleKeyCount = keyCounts.Count == 1 ? keyCounts.Single() : null;
+
+                    switch (op)
+                    {
+                        case Operator.Equal:
+                            includedKeyCounts.IntersectWith(keyCounts);
+                            return true;
+
+                        case Operator.NotEqual:
+                            includedKeyCounts.ExceptWith(keyCounts);
+                            return true;
+
+                        case Operator.Less:
+                            if (singleKeyCount == null) return false;
+
+                            includedKeyCounts.RemoveWhere(k => k >= singleKeyCount.Value);
+                            return true;
+
+                        case Operator.LessOrEqual:
+                            if (singleKeyCount == null) return false;
+
+                            includedKeyCounts.RemoveWhere(k => k > singleKeyCount.Value);
+                            return true;
+
+                        case Operator.Greater:
+                            if (singleKeyCount == null) return false;
+
+                            includedKeyCounts.RemoveWhere(k => k <= singleKeyCount.Value);
+                            return true;
+
+                        case Operator.GreaterOrEqual:
+                            if (singleKeyCount == null) return false;
+
+                            includedKeyCounts.RemoveWhere(k => k < singleKeyCount.Value);
+                            return true;
+
+                        default:
+                            return false;
+                    }
+                }
             }
 
             return false;
@@ -38,7 +91,7 @@ namespace osu.Game.Rulesets.Mania
 
         public bool FilterMayChangeFromMods(ValueChangedEvent<IReadOnlyList<Mod>> mods)
         {
-            if (keys.HasFilter)
+            if (includedKeyCounts.Count != LegacyBeatmapDecoder.MAX_MANIA_KEY_COUNT)
             {
                 // Interpreting as the Mod type is required for equality comparison.
                 HashSet<Mod> oldSet = mods.OldValue.OfType<ManiaKeyMod>().AsEnumerable<Mod>().ToHashSet();

osu.Game.Rulesets.Mania/Mods/ManiaModEasy.cs

@@ -8,6 +8,6 @@ namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModEasy : ModEasyWithExtraLives
     {
-        public override LocalisableString Description => @"More forgiving HP drain, less accuracy required, and three lives!";
+        public override LocalisableString Description => @"More forgiving HP drain, less accuracy required, and extra lives!";
     }
 }

osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs

@@ -60,8 +60,9 @@ namespace osu.Game.Rulesets.Mania.UI
         private readonly BindableDouble configScrollSpeed = new BindableDouble();
         private readonly Bindable<ManiaMobileLayout> mobileLayout = new Bindable<ManiaMobileLayout>();
 
+        public double TargetTimeRange { get; protected set; }
+
         private double currentTimeRange;
-        protected double TargetTimeRange;
 
         // Stores the current speed adjustment active in gameplay.
         private readonly Track speedAdjustmentTrack = new TrackVirtual(0);
@@ -109,7 +110,13 @@ namespace osu.Game.Rulesets.Mania.UI
             configDirection.BindValueChanged(direction => Direction.Value = (ScrollingDirection)direction.NewValue, true);
 
             Config.BindWith(ManiaRulesetSetting.ScrollSpeed, configScrollSpeed);
-            configScrollSpeed.BindValueChanged(speed => TargetTimeRange = ComputeScrollTime(speed.NewValue));
+            configScrollSpeed.BindValueChanged(speed =>
+            {
+                if (!AllowScrollSpeedAdjustment)
+                    return;
+
+                TargetTimeRange = ComputeScrollTime(speed.NewValue);
+            });
 
             TimeRange.Value = TargetTimeRange = currentTimeRange = ComputeScrollTime(configScrollSpeed.Value);
 

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

@@ -759,9 +759,9 @@ namespace osu.Game.Rulesets.Osu.Tests
                     BeatmapInfo =
                     {
                         Ruleset = new OsuRuleset().RulesetInfo,
-                        BeatmapVersion = LegacyBeatmapEncoder.FIRST_LAZER_VERSION // for correct offset treatment by score encoder
                     },
-                    ControlPointInfo = cpi
+                    ControlPointInfo = cpi,
+                    BeatmapVersion = LegacyBeatmapEncoder.FIRST_LAZER_VERSION // for correct offset treatment by score encoder
                 });
                 playableBeatmap = Beatmap.Value.GetPlayableBeatmap(new OsuRuleset().RulesetInfo);
             });

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

@@ -0,0 +1,118 @@
+// 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.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
+    public partial class TestSceneLegacyReplayPlayback : LegacyReplayPlaybackTestScene
+    {
+        protected override Ruleset CreateRuleset() => new OsuRuleset();
+
+        protected override string? ExportLocation => null;
+
+        private static readonly object[][] test_cases =
+        {
+            // With respect to notation,
+            // square brackets `[]` represent *closed* or *inclusive* bounds,
+            // while round brackets `()` represent *open* or *exclusive* bounds.
+            // Additionally, note that offsets provided in double will be rounded to the nearest integer.
+
+            // OD = 5 test cases.
+            // GREAT hit window is ( -50ms,  50ms)
+            // OK    hit window is (-100ms, 100ms)
+            // MEH   hit window is (-150ms, 150ms)
+            new object[] { 5f, 48d, HitResult.Great },
+            new object[] { 5f, 49d, HitResult.Great },
+            new object[] { 5f, 50d, HitResult.Ok },
+            new object[] { 5f, 51d, HitResult.Ok },
+            new object[] { 5f, 98d, HitResult.Ok },
+            new object[] { 5f, 99d, HitResult.Ok },
+            new object[] { 5f, 100d, HitResult.Meh },
+            new object[] { 5f, 101d, HitResult.Meh },
+            new object[] { 5f, 148d, HitResult.Meh },
+            new object[] { 5f, 149d, HitResult.Meh },
+            new object[] { 5f, 150d, HitResult.Miss },
+            new object[] { 5f, 151d, HitResult.Miss },
+
+            // OD = 5.7 test cases.
+            // GREAT hit window is ( -45ms,  45ms)
+            // OK    hit window is ( -94ms,  94ms)
+            // MEH   hit window is (-143ms, 143ms)
+            new object[] { 5.7f, 43d, HitResult.Great },
+            new object[] { 5.7f, 44d, HitResult.Great },
+            new object[] { 5.7f, 45d, HitResult.Ok },
+            new object[] { 5.7f, 46d, HitResult.Ok },
+            new object[] { 5.7f, 92d, HitResult.Ok },
+            new object[] { 5.7f, 93d, HitResult.Ok },
+            new object[] { 5.7f, 94d, HitResult.Meh },
+            new object[] { 5.7f, 95d, HitResult.Meh },
+            new object[] { 5.7f, 141d, HitResult.Meh },
+            new object[] { 5.7f, 142d, HitResult.Meh },
+            new object[] { 5.7f, 143d, HitResult.Miss },
+            new object[] { 5.7f, 144d, HitResult.Miss },
+        };
+
+        [TestCaseSource(nameof(test_cases))]
+        public void TestHitWindowTreatment(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            const double hit_circle_time = 100;
+
+            var cpi = new ControlPointInfo();
+            cpi.Add(0, new TimingControlPoint { BeatLength = 1000 });
+            var beatmap = new OsuBeatmap
+            {
+                HitObjects =
+                {
+                    new HitCircle
+                    {
+                        StartTime = hit_circle_time,
+                        Position = OsuPlayfield.BASE_SIZE / 2
+                    }
+                },
+                Difficulty = new BeatmapDifficulty { OverallDifficulty = overallDifficulty },
+                BeatmapInfo =
+                {
+                    Ruleset = new OsuRuleset().RulesetInfo,
+                },
+                ControlPointInfo = cpi,
+            };
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    // required for correct playback in stable
+                    new OsuReplayFrame(0, new Vector2(256, -500)),
+                    new OsuReplayFrame(0, new Vector2(256, -500)),
+                    new OsuReplayFrame(0, OsuPlayfield.BASE_SIZE / 2),
+                    new OsuReplayFrame(hit_circle_time + hitOffset, OsuPlayfield.BASE_SIZE / 2, OsuAction.LeftButton),
+                    new OsuReplayFrame(hit_circle_time + hitOffset + 20, OsuPlayfield.BASE_SIZE / 2),
+                }
+            };
+
+            var score = new Score
+            {
+                Replay = replay,
+                ScoreInfo = new ScoreInfo
+                {
+                    Ruleset = CreateRuleset().RulesetInfo,
+                }
+            };
+
+            RunTest($@"single circle @ OD{overallDifficulty}", beatmap, $@"{hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+    }
+}

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

@@ -0,0 +1,113 @@
+// 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.Game.Beatmaps;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
+    public partial class TestSceneReplayStability : ReplayStabilityTestScene
+    {
+        private static readonly object[][] test_cases =
+        {
+            // With respect to notation,
+            // square brackets `[]` represent *closed* or *inclusive* bounds,
+            // while round brackets `()` represent *open* or *exclusive* bounds.
+
+            // OD = 5 test cases.
+            // GREAT hit window is [ -50ms,  50ms]
+            // OK    hit window is [-100ms, 100ms]
+            // MEH   hit window is [-150ms, 150ms]
+            // MISS  hit window is [-400ms, 400ms]
+            new object[] { 5f, 49d, HitResult.Great },
+            new object[] { 5f, 49.2d, HitResult.Great },
+            new object[] { 5f, 49.7d, HitResult.Great },
+            new object[] { 5f, 50d, HitResult.Great },
+            new object[] { 5f, 50.4d, HitResult.Ok },
+            new object[] { 5f, 50.9d, HitResult.Ok },
+            new object[] { 5f, 51d, HitResult.Ok },
+            new object[] { 5f, 99d, HitResult.Ok },
+            new object[] { 5f, 99.2d, HitResult.Ok },
+            new object[] { 5f, 99.7d, HitResult.Ok },
+            new object[] { 5f, 100d, HitResult.Ok },
+            new object[] { 5f, 100.4d, HitResult.Meh },
+            new object[] { 5f, 100.9d, HitResult.Meh },
+            new object[] { 5f, 101d, HitResult.Meh },
+            new object[] { 5f, 149d, HitResult.Meh },
+            new object[] { 5f, 149.2d, HitResult.Meh },
+            new object[] { 5f, 149.7d, HitResult.Meh },
+            new object[] { 5f, 150d, HitResult.Meh },
+            new object[] { 5f, 150.4d, HitResult.Miss },
+            new object[] { 5f, 150.9d, HitResult.Miss },
+            new object[] { 5f, 151d, HitResult.Miss },
+
+            // OD = 5.7 test cases.
+            // GREAT hit window is [ -45.8ms,  45.8ms]
+            // OK    hit window is [ -94.4ms,  94.4ms]
+            // MEH   hit window is [-143.0ms, 143.0ms]
+            // MISS  hit window is [-400.0ms, 400.0ms]
+            new object[] { 5.7f, 45d, HitResult.Great },
+            new object[] { 5.7f, 45.2d, HitResult.Great },
+            new object[] { 5.7f, 45.8d, HitResult.Great },
+            new object[] { 5.7f, 45.9d, HitResult.Ok },
+            new object[] { 5.7f, 46d, HitResult.Ok },
+            new object[] { 5.7f, 46.4d, HitResult.Ok },
+            new object[] { 5.7f, 94d, HitResult.Ok },
+            new object[] { 5.7f, 94.2d, HitResult.Ok },
+            new object[] { 5.7f, 94.4d, HitResult.Ok },
+            new object[] { 5.7f, 94.48d, HitResult.Ok },
+            new object[] { 5.7f, 94.9d, HitResult.Meh },
+            new object[] { 5.7f, 95d, HitResult.Meh },
+            new object[] { 5.7f, 95.4d, HitResult.Meh },
+            new object[] { 5.7f, 142d, HitResult.Meh },
+            new object[] { 5.7f, 142.7d, HitResult.Meh },
+            new object[] { 5.7f, 143d, HitResult.Meh },
+            new object[] { 5.7f, 143.4d, HitResult.Miss },
+            new object[] { 5.7f, 143.9d, HitResult.Miss },
+            new object[] { 5.7f, 144d, HitResult.Miss },
+        };
+
+        [TestCaseSource(nameof(test_cases))]
+        public void TestHitWindowStability(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            const double hit_circle_time = 100;
+
+            var beatmap = new OsuBeatmap
+            {
+                HitObjects =
+                {
+                    new HitCircle
+                    {
+                        StartTime = hit_circle_time,
+                        Position = OsuPlayfield.BASE_SIZE / 2
+                    }
+                },
+                Difficulty = new BeatmapDifficulty { OverallDifficulty = overallDifficulty },
+                BeatmapInfo =
+                {
+                    Ruleset = new OsuRuleset().RulesetInfo,
+                },
+            };
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new OsuReplayFrame(0, OsuPlayfield.BASE_SIZE / 2),
+                    new OsuReplayFrame(hit_circle_time + hitOffset, OsuPlayfield.BASE_SIZE / 2, OsuAction.LeftButton),
+                    new OsuReplayFrame(hit_circle_time + hitOffset + 20, OsuPlayfield.BASE_SIZE / 2),
+                }
+            };
+
+            RunTest(beatmap, replay, [expectedResult]);
+        }
+    }
+}

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

@@ -86,9 +86,12 @@ namespace osu.Game.Rulesets.Osu.Tests
         [Test]
         public void TestSpinningSamplePitchShift()
         {
+            PausableSkinnableSound spinSample = null;
+
             AddStep("Add spinner", () => SetContents(_ => testSingle(5, true, 4000)));
-            AddUntilStep("Pitch starts low", () => getSpinningSample().Frequency.Value < 0.8);
-            AddUntilStep("Pitch increases", () => getSpinningSample().Frequency.Value > 0.8);
+            AddUntilStep("wait for spin sample", () => (spinSample = getSpinningSample()) != null);
+            AddUntilStep("Pitch starts low", () => spinSample.Frequency.Value < 0.8);
+            AddUntilStep("Pitch increases", () => spinSample.Frequency.Value > 0.8);
 
             PausableSkinnableSound getSpinningSample() =>
                 drawableSpinner.ChildrenOfType<PausableSkinnableSound>().FirstOrDefault(s => s.Samples.Any(i => i.LookupNames.Any(l => l.Contains("spinnerspin"))));

osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmap.cs

@@ -1,10 +1,10 @@
 // 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.Beatmaps;
-using osu.Game.Resources.Localisation.Web;
 using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Beatmaps
@@ -16,26 +16,30 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
             int circles = HitObjects.Count(c => c is HitCircle);
             int sliders = HitObjects.Count(s => s is Slider);
             int spinners = HitObjects.Count(s => s is Spinner);
+            int sum = Math.Max(1, circles + sliders);
 
             return new[]
             {
                 new BeatmapStatistic
                 {
-                    Name = BeatmapsetsStrings.ShowStatsCountCircles,
+                    Name = "Circles",
                     Content = circles.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
+                    BarDisplayLength = circles / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = BeatmapsetsStrings.ShowStatsCountSliders,
+                    Name = "Sliders",
                     Content = sliders.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
+                    BarDisplayLength = sliders / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Spinner Count",
+                    Name = @"Spinners",
                     Content = spinners.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Spinners),
+                    BarDisplayLength = Math.Min(spinners / 10f, 1),
                 }
             };
         }

osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapConverter.cs

@@ -46,7 +46,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                         ComboOffset = comboData?.ComboOffset ?? 0,
                         // prior to v8, speed multipliers don't adjust for how many ticks are generated over the same distance.
                         // this results in more (or less) ticks being generated in <v8 maps for the same time duration.
-                        TickDistanceMultiplier = beatmap.BeatmapInfo.BeatmapVersion < 8 ? 1f / ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(original.StartTime).SliderVelocity : 1,
+                        TickDistanceMultiplier = beatmap.BeatmapVersion < 8 ? 1f / ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(original.StartTime).SliderVelocity : 1,
                         GenerateTicks = generateTicksData?.GenerateTicks ?? true,
                         SliderVelocityMultiplier = sliderVelocityData?.SliderVelocityMultiplier ?? 1,
                     }.Yield();

osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapProcessor.cs

@@ -55,7 +55,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                 foreach (var h in hitObjects)
                     h.StackHeight = 0;
 
-                if (beatmap.BeatmapInfo.BeatmapVersion >= 6)
+                if (beatmap.BeatmapVersion >= 6)
                     applyStacking(beatmap, hitObjects, 0, hitObjects.Count - 1);
                 else
                     applyStackingOld(beatmap, hitObjects);

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

@@ -103,7 +103,7 @@ namespace osu.Game.Rulesets.Osu.Edit
                         Current = new BindableNumber<int>(3)
                         {
                             MinValue = 3,
-                            MaxValue = 10,
+                            MaxValue = 32,
                             Precision = 1,
                         },
                         Instantaneous = true

osu.Game.Rulesets.Osu/Edit/Setup/OsuDifficultySection.cs

@@ -91,6 +91,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Setup
                 {
                     Caption = EditorSetupStrings.BaseVelocity,
                     HintText = EditorSetupStrings.BaseVelocityDescription,
+                    KeyboardStep = 0.1f,
                     Current = new BindableDouble(Beatmap.Difficulty.SliderMultiplier)
                     {
                         Default = 1.4,
@@ -105,6 +106,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Setup
                 {
                     Caption = EditorSetupStrings.TickRate,
                     HintText = EditorSetupStrings.TickRateDescription,
+                    KeyboardStep = 1,
                     Current = new BindableDouble(Beatmap.Difficulty.SliderTickRate)
                     {
                         Default = 1,
@@ -119,6 +121,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Setup
                 {
                     Caption = "Stack Leniency",
                     HintText = "In play mode, osu! automatically stacks notes which occur at the same location. Increasing this value means it is more likely to snap notes of further time-distance.",
+                    KeyboardStep = 0.1f,
                     Current = new BindableFloat(Beatmap.StackLeniency)
                     {
                         Default = 0.7f,

osu.Game.Rulesets.Osu/Mods/OsuModDifficultyAdjust.cs

@@ -1,7 +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.Linq;
+using System.Collections.Generic;
 using osu.Framework.Bindables;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
@@ -36,19 +36,18 @@ namespace osu.Game.Rulesets.Osu.Mods
             ReadCurrentFromDifficulty = diff => diff.ApproachRate,
         };
 
-        public override string SettingDescription
+        public override IEnumerable<(LocalisableString setting, LocalisableString value)> SettingDescription
         {
             get
             {
-                string circleSize = CircleSize.IsDefault ? string.Empty : $"CS {CircleSize.Value:N1}";
-                string approachRate = ApproachRate.IsDefault ? string.Empty : $"AR {ApproachRate.Value:N1}";
+                if (!CircleSize.IsDefault)
+                    yield return ("Circle size", $"{CircleSize.Value:N1}");
 
-                return string.Join(", ", new[]
-                {
-                    circleSize,
-                    base.SettingDescription,
-                    approachRate
-                }.Where(s => !string.IsNullOrEmpty(s)));
+                foreach (var setting in base.SettingDescription)
+                    yield return setting;
+
+                if (!ApproachRate.IsDefault)
+                    yield return ("Approach rate", $"{ApproachRate.Value:N1}");
             }
         }
 

osu.Game.Rulesets.Osu/Mods/OsuModEasy.cs

@@ -8,6 +8,6 @@ namespace osu.Game.Rulesets.Osu.Mods
 {
     public class OsuModEasy : ModEasyWithExtraLives
     {
-        public override LocalisableString Description => @"Larger circles, more forgiving HP drain, less accuracy required, and three lives!";
+        public override LocalisableString Description => @"Larger circles, more forgiving HP drain, less accuracy required, and extra lives!";
     }
 }

osu.Game.Rulesets.Osu/Mods/OsuModSpunOut.cs

@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         {
             var spinner = (DrawableSpinner)drawable;
 
-            spinner.RotationTracker.Tracking = true;
+            spinner.RotationTracker.Tracking = spinner.RotationTracker.IsSpinnableTime;
 
             // early-return if we were paused to avoid division-by-zero in the subsequent calculations.
             if (Precision.AlmostEquals(spinner.Clock.Rate, 0))

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs

@@ -5,6 +5,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -149,5 +150,24 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         protected float CalculateDrawableRelativePosition(Drawable drawable) => (drawable.ScreenSpaceDrawQuad.Centre.X - parentScreenSpaceRectangle.X) / parentScreenSpaceRectangle.Width;
 
         protected override JudgementResult CreateResult(Judgement judgement) => new OsuJudgementResult(HitObject, judgement);
+
+        protected void ApplyRepeatFadeIn(Drawable target, double fadeTime)
+        {
+            DrawableSlider slider = (DrawableSlider)ParentHitObject;
+            int repeatIndex = ((SliderEndCircle)HitObject).RepeatIndex;
+
+            Debug.Assert(slider != null);
+
+            // When snaking in is enabled, the first end circle needs to be delayed until the snaking completes.
+            bool delayFadeIn = slider.SliderBody?.SnakingIn.Value == true && repeatIndex == 0;
+
+            if (repeatIndex > 0)
+                fadeTime = Math.Min(slider.HitObject.SpanDuration, fadeTime);
+
+            target
+                .FadeOut()
+                .Delay(delayFadeIn ? (slider.HitObject.TimePreempt) / 3 : 0)
+                .FadeIn(fadeTime);
+        }
     }
 }

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderRepeat.cs

@@ -27,8 +27,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         public DrawableSlider DrawableSlider => (DrawableSlider)ParentHitObject;
 
-        private double animDuration;
-
         public SkinnableDrawable CirclePiece { get; private set; }
 
         public SkinnableDrawable Arrow { get; private set; }
@@ -87,21 +85,18 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         protected override void UpdateInitialTransforms()
         {
-            // When snaking in is enabled, the first end circle needs to be delayed until the snaking completes.
-            bool delayFadeIn = DrawableSlider.SliderBody?.SnakingIn.Value == true && HitObject.RepeatIndex == 0;
+            base.UpdateInitialTransforms();
 
-            animDuration = Math.Min(300, HitObject.SpanDuration);
-
-            this
-                .FadeOut()
-                .Delay(delayFadeIn ? (Slider?.TimePreempt ?? 0) / 3 : 0)
-                .FadeIn(HitObject.RepeatIndex == 0 ? HitObject.TimeFadeIn : animDuration);
+            ApplyRepeatFadeIn(CirclePiece, HitObject.TimeFadeIn);
+            ApplyRepeatFadeIn(Arrow, 150);
         }
 
         protected override void UpdateHitStateTransforms(ArmedState state)
         {
             base.UpdateHitStateTransforms(state);
 
+            double animDuration = Math.Min(300, HitObject.SpanDuration);
+
             switch (state)
             {
                 case ArmedState.Idle:
@@ -181,10 +176,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 // More or less matches stable (see https://github.com/peppy/osu-stable-reference/blob/bb57924c1552adbed11ee3d96cdcde47cf96f2b6/osu!/GameplayElements/HitObjects/Osu/HitCircleOsu.cs#L336-L338)
                 AccentColour.Value = Color4.White;
                 Alpha = Interpolation.ValueAt(Time.Current, 1f, 0f, HitStateUpdateTime, HitStateUpdateTime + 700);
+                Arrow.Alpha = 0;
             }
 
-            Arrow.Alpha = hit ? 0 : 1;
-
             LifetimeEnd = HitStateUpdateTime + 700;
         }
 

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTail.cs

@@ -86,13 +86,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
             base.UpdateInitialTransforms();
 
-            // When snaking in is enabled, the first end circle needs to be delayed until the snaking completes.
-            bool delayFadeIn = DrawableSlider.SliderBody?.SnakingIn.Value == true && HitObject.RepeatIndex == 0;
-
-            CirclePiece
-                .FadeOut()
-                .Delay(delayFadeIn ? (Slider?.TimePreempt ?? 0) / 3 : 0)
-                .FadeIn(HitObject.TimeFadeIn);
+            ApplyRepeatFadeIn(CirclePiece, HitObject.TimeFadeIn);
         }
 
         protected override void UpdateHitStateTransforms(ArmedState state)

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs

@@ -277,13 +277,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             base.Update();
 
             if (HandleUserInput)
-            {
-                bool isValidSpinningTime = Time.Current >= HitObject.StartTime && Time.Current <= HitObject.EndTime;
-
-                RotationTracker.Tracking = !Result.HasResult
-                                           && correctButtonPressed()
-                                           && isValidSpinningTime;
-            }
+                RotationTracker.Tracking = RotationTracker.IsSpinnableTime && !Result.HasResult && correctButtonPressed();
 
             if (spinningSample != null && spinnerFrequencyModulate)
                 spinningSample.Frequency.Value = spinning_sample_modulated_base_frequency + Progress;

osu.Game.Rulesets.Osu/Skinning/Argon/ArgonReverseArrow.cs

@@ -85,9 +85,12 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
             {
                 double animDuration = Math.Min(300, drawableRepeat.HitObject.SpanDuration);
                 Scale = new Vector2(Interpolation.ValueAt(Time.Current, 1, 1.5f, drawableRepeat.HitStateUpdateTime, drawableRepeat.HitStateUpdateTime + animDuration, Easing.Out));
+
+                // When hit, don't animate further. This avoids a scale being applied on a scale and looking very weird.
+                return;
             }
-            else
-                Scale = Vector2.One;
+
+            Scale = Vector2.One;
 
             const float move_distance = -12;
             const float scale_amount = 1.3f;

osu.Game.Rulesets.Osu/Skinning/Default/SpinnerRotationTracker.cs

@@ -52,7 +52,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
         /// <summary>
         /// Whether currently in the correct time range to allow spinning.
         /// </summary>
-        private bool isSpinnableTime => drawableSpinner.HitObject.StartTime <= Time.Current && drawableSpinner.HitObject.EndTime > Time.Current;
+        public bool IsSpinnableTime => drawableSpinner.HitObject.StartTime <= Time.Current && drawableSpinner.HitObject.EndTime > Time.Current;
 
         protected override bool OnMouseMove(MouseMoveEvent e)
         {
@@ -79,7 +79,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
                 lastAngle = thisAngle;
             }
 
-            IsSpinning.Value = isSpinnableTime && Math.Abs(currentRotation - Rotation) > 10f;
+            IsSpinning.Value = IsSpinnableTime && Math.Abs(currentRotation - Rotation) > 10f;
             Rotation = (float)Interpolation.Damp(Rotation, currentRotation, 0.99, Math.Abs(Time.Elapsed));
         }
 
@@ -92,7 +92,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
         /// <param name="delta">The delta angle.</param>
         public void AddRotation(float delta)
         {
-            if (!isSpinnableTime)
+            if (!IsSpinnableTime)
                 return;
 
             if (!rotationTransferred)

osu.Game.Rulesets.Taiko.Tests/TestSceneLegacyReplayPlayback.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.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Beatmaps;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Replays;
+using osu.Game.Scoring;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Taiko.Tests
+{
+    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
+    public partial class TestSceneLegacyReplayPlayback : LegacyReplayPlaybackTestScene
+    {
+        protected override string? ExportLocation => null;
+
+        protected override Ruleset CreateRuleset() => new TaikoRuleset();
+
+        private static readonly object[][] test_cases =
+        {
+            // With respect to notation,
+            // square brackets `[]` represent *closed* or *inclusive* bounds,
+            // while round brackets `()` represent *open* or *exclusive* bounds.
+
+            // OD = 5 test cases.
+            // GREAT hit window is (-35ms, 35ms)
+            // OK    hit window is (-80ms, 80ms)
+            new object[] { 5f, -33d, HitResult.Great },
+            new object[] { 5f, -34d, HitResult.Great },
+            new object[] { 5f, -35d, HitResult.Ok },
+            new object[] { 5f, -36d, HitResult.Ok },
+            new object[] { 5f, -78d, HitResult.Ok },
+            new object[] { 5f, -79d, HitResult.Ok },
+            new object[] { 5f, -80d, HitResult.Miss },
+            new object[] { 5f, -81d, HitResult.Miss },
+
+            // OD = 7.8 test cases.
+            // GREAT hit window is (-26ms, 26ms)
+            // OK    hit window is (-63ms, 63ms)
+            new object[] { 7.8f, -24d, HitResult.Great },
+            new object[] { 7.8f, -25d, HitResult.Great },
+            new object[] { 7.8f, -26d, HitResult.Ok },
+            new object[] { 7.8f, -27d, HitResult.Ok },
+            new object[] { 7.8f, -61d, HitResult.Ok },
+            new object[] { 7.8f, -62d, HitResult.Ok },
+            new object[] { 7.8f, -63d, HitResult.Miss },
+            new object[] { 7.8f, -64d, HitResult.Miss },
+        };
+
+        [TestCaseSource(nameof(test_cases))]
+        public void TestHitWindowTreatment(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            const double hit_time = 100;
+
+            var cpi = new ControlPointInfo();
+            cpi.Add(0, new TimingControlPoint { BeatLength = 1000 });
+            var beatmap = new TaikoBeatmap
+            {
+                HitObjects =
+                {
+                    new Hit
+                    {
+                        StartTime = hit_time,
+                        Type = HitType.Centre,
+                    }
+                },
+                Difficulty = new BeatmapDifficulty { OverallDifficulty = overallDifficulty },
+                BeatmapInfo =
+                {
+                    Ruleset = new TaikoRuleset().RulesetInfo,
+                },
+                ControlPointInfo = cpi,
+            };
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new TaikoReplayFrame(0),
+                    new TaikoReplayFrame(hit_time + hitOffset, TaikoAction.LeftCentre),
+                    new TaikoReplayFrame(hit_time + hitOffset + 20),
+                }
+            };
+
+            var score = new Score
+            {
+                Replay = replay,
+                ScoreInfo = new ScoreInfo
+                {
+                    Ruleset = CreateRuleset().RulesetInfo,
+                }
+            };
+
+            RunTest($@"single hit @ OD{overallDifficulty}", beatmap, $@"{hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+    }
+}

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

@@ -0,0 +1,96 @@
+// 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.Game.Beatmaps;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Beatmaps;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Replays;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Taiko.Tests
+{
+    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
+    public partial class TestSceneReplayStability : ReplayStabilityTestScene
+    {
+        private static readonly object[][] test_cases =
+        {
+            // With respect to notation,
+            // square brackets `[]` represent *closed* or *inclusive* bounds,
+            // while round brackets `()` represent *open* or *exclusive* bounds.
+
+            // OD = 5 test cases.
+            // GREAT hit window is [-35ms, 35ms]
+            // OK    hit window is [-80ms, 80ms]
+            // MISS  hit window is [-95ms, 95ms]
+            new object[] { 5f, -34d, HitResult.Great },
+            new object[] { 5f, -34.2d, HitResult.Great },
+            new object[] { 5f, -34.7d, HitResult.Great },
+            new object[] { 5f, -35d, HitResult.Great },
+            new object[] { 5f, -35.2d, HitResult.Ok },
+            new object[] { 5f, -35.8d, HitResult.Ok },
+            new object[] { 5f, -36d, HitResult.Ok },
+            new object[] { 5f, -79d, HitResult.Ok },
+            new object[] { 5f, -79.3d, HitResult.Ok },
+            new object[] { 5f, -79.7d, HitResult.Ok },
+            new object[] { 5f, -80d, HitResult.Ok },
+            new object[] { 5f, -80.2d, HitResult.Miss },
+            new object[] { 5f, -80.8d, HitResult.Miss },
+            new object[] { 5f, -81d, HitResult.Miss },
+
+            // OD = 7.8 test cases.
+            // GREAT hit window is [-26.6ms, 26.6ms]
+            // OK    hit window is [-63.2ms, 63.2ms]
+            // MISS  hit window is [-81.0ms, 81.0ms]
+            new object[] { 7.8f, -26d, HitResult.Great },
+            new object[] { 7.8f, -26.4d, HitResult.Great },
+            new object[] { 7.8f, -26.59d, HitResult.Great },
+            new object[] { 7.8f, -26.8d, HitResult.Ok },
+            new object[] { 7.8f, -27d, HitResult.Ok },
+            new object[] { 7.8f, -27.1d, HitResult.Ok },
+            new object[] { 7.8f, -63d, HitResult.Ok },
+            new object[] { 7.8f, -63.18d, HitResult.Ok },
+            new object[] { 7.8f, -63.4d, HitResult.Ok },
+            new object[] { 7.8f, -63.7d, HitResult.Miss },
+            new object[] { 7.8f, -64d, HitResult.Miss },
+            new object[] { 7.8f, -64.2d, HitResult.Miss },
+        };
+
+        [TestCaseSource(nameof(test_cases))]
+        public void TestHitWindowStability(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            const double hit_time = 100;
+
+            var beatmap = new TaikoBeatmap
+            {
+                HitObjects =
+                {
+                    new Hit
+                    {
+                        StartTime = hit_time,
+                        Type = HitType.Centre,
+                    }
+                },
+                Difficulty = new BeatmapDifficulty { OverallDifficulty = overallDifficulty },
+                BeatmapInfo =
+                {
+                    Ruleset = new TaikoRuleset().RulesetInfo,
+                },
+            };
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new TaikoReplayFrame(0),
+                    new TaikoReplayFrame(hit_time + hitOffset, TaikoAction.LeftCentre),
+                    new TaikoReplayFrame(hit_time + hitOffset + 20),
+                }
+            };
+
+            RunTest(beatmap, replay, [expectedResult]);
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmap.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.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
@@ -15,26 +16,30 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
             int hits = HitObjects.Count(s => s is Hit);
             int drumRolls = HitObjects.Count(s => s is DrumRoll);
             int swells = HitObjects.Count(s => s is Swell);
+            int sum = Math.Max(1, hits + drumRolls);
 
             return new[]
             {
                 new BeatmapStatistic
                 {
-                    Name = @"Hit Count",
+                    Name = @"Hits",
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
                     Content = hits.ToString(),
+                    BarDisplayLength = hits / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Drumroll Count",
+                    Name = @"Drumrolls",
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
                     Content = drumRolls.ToString(),
+                    BarDisplayLength = drumRolls / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Swell Count",
+                    Name = @"Swells",
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Spinners),
                     Content = swells.ToString(),
+                    BarDisplayLength = Math.Min(swells / 10f, 1),
                 }
             };
         }

osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs

@@ -210,7 +210,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
             double osuVelocity = taikoVelocity * (1000f / beatLength);
 
             // osu-stable always uses the speed-adjusted beatlength to determine the osu! velocity, but only uses it for conversion if beatmap version < 8
-            if (beatmap.BeatmapInfo.BeatmapVersion >= 8)
+            if (beatmap.BeatmapVersion >= 8)
                 beatLength = timingPoint.BeatLength;
 
             // If the drum roll is to be split into hit circles, assume the ticks are 1/8 spaced within the duration of one beat

osu.Game.Rulesets.Taiko/Edit/Setup/TaikoDifficultySection.cs

@@ -60,6 +60,7 @@ namespace osu.Game.Rulesets.Taiko.Edit.Setup
                 {
                     Caption = EditorSetupStrings.BaseVelocity,
                     HintText = EditorSetupStrings.BaseVelocityDescription,
+                    KeyboardStep = 0.1f,
                     Current = new BindableDouble(Beatmap.Difficulty.SliderMultiplier)
                     {
                         Default = 1.4,
@@ -74,6 +75,7 @@ namespace osu.Game.Rulesets.Taiko.Edit.Setup
                 {
                     Caption = EditorSetupStrings.TickRate,
                     HintText = EditorSetupStrings.TickRateDescription,
+                    KeyboardStep = 1,
                     Current = new BindableDouble(Beatmap.Difficulty.SliderTickRate)
                     {
                         Default = 1,

osu.Game.Rulesets.Taiko/Mods/TaikoModDifficultyAdjust.cs

@@ -1,7 +1,8 @@
 // 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 System.Collections.Generic;
+using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Mods;
@@ -19,17 +20,15 @@ namespace osu.Game.Rulesets.Taiko.Mods
             ReadCurrentFromDifficulty = _ => 1,
         };
 
-        public override string SettingDescription
+        public override IEnumerable<(LocalisableString setting, LocalisableString value)> SettingDescription
         {
             get
             {
-                string scrollSpeed = ScrollSpeed.IsDefault ? string.Empty : $"Scroll x{ScrollSpeed.Value:N2}";
+                foreach (var setting in base.SettingDescription)
+                    yield return setting;
 
-                return string.Join(", ", new[]
-                {
-                    base.SettingDescription,
-                    scrollSpeed
-                }.Where(s => !string.IsNullOrEmpty(s)));
+                if (!ScrollSpeed.IsDefault)
+                    yield return ("Scroll speed", $"x{ScrollSpeed.Value:N2}");
             }
         }
 

osu.Game.Rulesets.Taiko/Skinning/Argon/ArgonCirclePiece.cs

@@ -3,6 +3,7 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Audio.Track;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Shapes;
@@ -112,5 +113,13 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Argon
                     .FadeOut(timingPoint.BeatLength * 0.75, Easing.OutSine);
             }
         }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (drawableHitObject.IsNotNull())
+                drawableHitObject.ApplyCustomUpdateState -= updateStateTransforms;
+        }
     }
 }

osu.Game.Rulesets.Taiko/Skinning/Default/CirclePiece.cs

@@ -4,6 +4,7 @@
 using osu.Framework.Allocation;
 using osu.Framework.Audio.Track;
 using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
@@ -202,5 +203,13 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Default
                 .Then()
                 .FadeEdgeEffectTo(edge_alpha_kiai, duration, Easing.OutQuint);
         }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (drawableHitObject.IsNotNull())
+                drawableHitObject.ApplyCustomUpdateState -= updateStateTransforms;
+        }
     }
 }

osu.Game.Rulesets.Taiko/Skinning/Legacy/LegacyHitExplosion.cs

@@ -60,11 +60,17 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
         {
             const double animation_time = 120;
 
-            (sprite as IFramedAnimation)?.GotoFrame(0);
+            var animation = sprite as IFramedAnimation;
+
+            animation?.GotoFrame(0);
             (strongSprite as IFramedAnimation)?.GotoFrame(0);
 
             this.FadeInFromZero(animation_time).Then().FadeOut(animation_time * 1.5);
 
+            // legacy judgements don't play any transforms if they are an animation.
+            if (animation?.FrameCount > 1)
+                return;
+
             this.ScaleTo(0.6f)
                 .Then().ScaleTo(1.1f, animation_time * 0.8)
                 .Then().ScaleTo(0.9f, animation_time * 0.4)

osu.Game.Rulesets.Taiko/Skinning/Legacy/LegacyKiaiGlow.cs

@@ -17,12 +17,14 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
 {
     internal partial class LegacyKiaiGlow : BeatSyncedContainer
     {
-        private bool isKiaiActive;
+        [Resolved]
+        private HealthProcessor? healthProcessor { get; set; }
 
+        private bool isKiaiActive;
         private Sprite sprite = null!;
 
-        [BackgroundDependencyLoader(true)]
-        private void load(ISkinSource skin, HealthProcessor? healthProcessor)
+        [BackgroundDependencyLoader]
+        private void load(ISkinSource skin)
         {
             Child = sprite = new Sprite
             {
@@ -33,6 +35,11 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
                 Scale = new Vector2(TaikoLegacyHitTarget.SCALE),
                 Colour = new Colour4(255, 228, 0, 255),
             };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
 
             if (healthProcessor != null)
                 healthProcessor.NewJudgement += onNewJudgement;
@@ -61,5 +68,13 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
             sprite.ScaleTo(TaikoLegacyHitTarget.SCALE + 0.15f).Then()
                   .ScaleTo(TaikoLegacyHitTarget.SCALE, 80, Easing.OutQuad);
         }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (healthProcessor != null)
+                healthProcessor.NewJudgement -= onNewJudgement;
+        }
     }
 }

osu.Game.Tests.Android/osu.Game.Tests.Android.csproj

@@ -28,6 +28,7 @@
     <ProjectReference Include="..\osu.Game\osu.Game.csproj" />
   </ItemGroup>
   <ItemGroup Label="Package References">
+    <PackageReference Include="Bogus" Version="35.6.2" />
     <PackageReference Include="DeepEqual" Version="2.0.0" />
     <PackageReference Include="Moq" Version="4.17.2" />
   </ItemGroup>

osu.Game.Tests.iOS/osu.Game.Tests.iOS.csproj

@@ -1,4 +1,5 @@
 <Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="..\osu.iOS.props" />
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net8.0-ios</TargetFramework>
@@ -6,11 +7,19 @@
     <RootNamespace>osu.Game.Tests</RootNamespace>
     <AssemblyName>osu.Game.Tests.iOS</AssemblyName>
   </PropertyGroup>
-  <Import Project="..\osu.iOS.props" />
+  <PropertyGroup>
+    <NoWarn>$(NoWarn);CA2007</NoWarn>
+  </PropertyGroup>
   <ItemGroup>
     <Compile Include="..\osu.Game.Tests\**\*.cs" Exclude="**\obj\**">
       <Link>%(RecursiveDir)%(Filename)%(Extension)</Link>
     </Compile>
+    <!-- TargetPath is relative to RootNamespace,
+         and DllResourceStore is relative to AssemblyName. -->
+    <EmbeddedResource Include="..\osu.Game.Tests\**\Resources\**\*">
+      <Link>%(RecursiveDir)%(Filename)%(Extension)</Link>
+      <TargetPath>iOS\%(RecursiveDir)%(Filename)%(Extension)</TargetPath>
+    </EmbeddedResource>
   </ItemGroup>
   <ItemGroup Label="Project References">
     <ProjectReference Include="..\osu.Game\osu.Game.csproj" />
@@ -20,6 +29,7 @@
     <ProjectReference Include="..\osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj" />
   </ItemGroup>
   <ItemGroup Label="Package References">
+    <PackageReference Include="Bogus" Version="35.6.2" />
     <PackageReference Include="DeepEqual" Version="2.0.0" />
     <PackageReference Include="Moq" Version="4.17.2" />
   </ItemGroup>

osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapDecoderTest.cs

@@ -42,9 +42,9 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var decoder = Decoder.GetDecoder<Beatmap>(stream);
                 var working = new TestWorkingBeatmap(decoder.Decode(stream));
 
-                Assert.AreEqual(6, working.BeatmapInfo.BeatmapVersion);
-                Assert.AreEqual(6, working.Beatmap.BeatmapInfo.BeatmapVersion);
-                Assert.AreEqual(6, working.GetPlayableBeatmap(new OsuRuleset().RulesetInfo, Array.Empty<Mod>()).BeatmapInfo.BeatmapVersion);
+                Assert.AreEqual(6, working.Beatmap.BeatmapVersion);
+                Assert.That(working.Beatmap.BeatmapInfo.Ruleset.Name, Is.Not.EqualTo("null placeholder ruleset"));
+                Assert.AreEqual(6, working.GetPlayableBeatmap(new OsuRuleset().RulesetInfo, Array.Empty<Mod>()).BeatmapVersion);
             }
         }
 
@@ -59,9 +59,8 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 ((LegacyBeatmapDecoder)decoder).ApplyOffsets = applyOffsets;
                 var working = new TestWorkingBeatmap(decoder.Decode(stream));
 
-                Assert.AreEqual(4, working.BeatmapInfo.BeatmapVersion);
-                Assert.AreEqual(4, working.Beatmap.BeatmapInfo.BeatmapVersion);
-                Assert.AreEqual(4, working.GetPlayableBeatmap(new OsuRuleset().RulesetInfo, Array.Empty<Mod>()).BeatmapInfo.BeatmapVersion);
+                Assert.AreEqual(4, working.Beatmap.BeatmapVersion);
+                Assert.AreEqual(4, working.GetPlayableBeatmap(new OsuRuleset().RulesetInfo, Array.Empty<Mod>()).BeatmapVersion);
 
                 Assert.AreEqual(-1, working.BeatmapInfo.Metadata.PreviewTime);
             }

osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs

@@ -155,10 +155,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var scoreInfo = TestResources.CreateTestScoreInfo(ruleset);
             var beatmap = new TestBeatmap(ruleset)
             {
-                BeatmapInfo =
-                {
-                    BeatmapVersion = beatmapVersion
-                }
+                BeatmapVersion = beatmapVersion
             };
 
             var score = new Score
@@ -633,14 +630,14 @@ namespace osu.Game.Tests.Beatmaps.Formats
                     MD5Hash = md5Hash,
                     Ruleset = new OsuRuleset().RulesetInfo,
                     Difficulty = new BeatmapDifficulty(),
-                    BeatmapVersion = beatmapVersion,
                 },
-                // needs to have at least one objects so that `StandardisedScoreMigrationTools` doesn't die
+                // needs to have at least one object so that `StandardisedScoreMigrationTools` doesn't die
                 // when trying to recompute total score.
                 HitObjects =
                 {
                     new HitCircle()
-                }
+                },
+                BeatmapVersion = beatmapVersion,
             });
         }
     }

osu.Game.Tests/Beatmaps/Formats/LegacyStoryboardDecoderTest.cs

@@ -135,6 +135,24 @@ namespace osu.Game.Tests.Beatmaps.Formats
             }
         }
 
+        [Test]
+        public void TestNoopFadeTransformIsIgnoredForLifetime()
+        {
+            var decoder = new LegacyStoryboardDecoder();
+
+            using (var resStream = TestResources.OpenResource("noop-fade-transform-is-ignored-for-lifetime.osb"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                var storyboard = decoder.Decode(stream);
+
+                StoryboardLayer background = storyboard.Layers.Single(l => l.Depth == 3);
+                Assert.AreEqual(2, background.Elements.Count);
+
+                Assert.AreEqual(1500, background.Elements[0].StartTime);
+                Assert.AreEqual(1500, background.Elements[1].StartTime);
+            }
+        }
+
         [Test]
         public void TestOutOfOrderStartTimes()
         {
@@ -288,6 +306,29 @@ namespace osu.Game.Tests.Beatmaps.Formats
             }
         }
 
+        [Test]
+        public void TestVideoWithCustomFadeIn()
+        {
+            var decoder = new LegacyStoryboardDecoder();
+
+            using var resStream = TestResources.OpenResource("video-custom-alpha-transform.osb");
+            using var stream = new LineBufferedReader(resStream);
+
+            var storyboard = decoder.Decode(stream);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(storyboard.GetLayer(@"Video").Elements, Has.Count.EqualTo(1));
+                Assert.That(storyboard.GetLayer(@"Video").Elements.Single(), Is.InstanceOf<StoryboardVideo>());
+                Assert.That(storyboard.GetLayer(@"Video").Elements.Single().StartTime, Is.EqualTo(-5678));
+                Assert.That(((StoryboardVideo)storyboard.GetLayer(@"Video").Elements.Single()).Commands.Alpha.Single().StartTime, Is.EqualTo(1500));
+                Assert.That(((StoryboardVideo)storyboard.GetLayer(@"Video").Elements.Single()).Commands.Alpha.Single().EndTime, Is.EqualTo(1600));
+
+                Assert.That(storyboard.EarliestEventTime, Is.Null);
+                Assert.That(storyboard.LatestEventTime, Is.Null);
+            });
+        }
+
         [Test]
         public void TestVideoAndBackgroundEventsDoNotAffectStoryboardBounds()
         {

osu.Game.Tests/Database/BackgroundDataStoreProcessorTests.cs

@@ -62,12 +62,11 @@ namespace osu.Game.Tests.Database
                 });
             });
 
-            AddStep("Run background processor", () =>
-            {
-                Add(new TestBackgroundDataStoreProcessor());
-            });
+            TestBackgroundDataStoreProcessor processor = null!;
+            AddStep("Run background processor", () => Add(processor = new TestBackgroundDataStoreProcessor()));
+            AddUntilStep("Wait for completion", () => processor.Completed);
 
-            AddUntilStep("wait for difficulties repopulated", () =>
+            AddAssert("Difficulties repopulated", () =>
             {
                 return Realm.Run(r =>
                 {
@@ -101,13 +100,10 @@ namespace osu.Game.Tests.Database
                 });
             });
 
-            AddStep("Run background processor", () =>
-            {
-                Add(new TestBackgroundDataStoreProcessor());
-            });
+            TestBackgroundDataStoreProcessor processor = null!;
+            AddStep("Run background processor", () => Add(processor = new TestBackgroundDataStoreProcessor()));
 
             AddWaitStep("wait some", 500);
-
             AddAssert("Difficulty still not populated", () =>
             {
                 return Realm.Run(r =>
@@ -118,8 +114,9 @@ namespace osu.Game.Tests.Database
             });
 
             AddStep("Set not playing", () => isPlaying.Value = LocalUserPlayingState.NotPlaying);
+            AddUntilStep("Wait for completion", () => processor.Completed);
 
-            AddUntilStep("wait for difficulties repopulated", () =>
+            AddAssert("Difficulties repopulated", () =>
             {
                 return Realm.Run(r =>
                 {
@@ -151,9 +148,11 @@ namespace osu.Game.Tests.Database
                 });
             });
 
-            AddStep("Run background processor", () => Add(new TestBackgroundDataStoreProcessor()));
+            TestBackgroundDataStoreProcessor processor = null!;
+            AddStep("Run background processor", () => Add(processor = new TestBackgroundDataStoreProcessor()));
+            AddUntilStep("Wait for completion", () => processor.Completed);
 
-            AddUntilStep("Score version upgraded", () => Realm.Run(r => r.Find<ScoreInfo>(scoreInfo.ID)!.TotalScoreVersion), () => Is.EqualTo(LegacyScoreEncoder.LATEST_VERSION));
+            AddAssert("Score version upgraded", () => Realm.Run(r => r.Find<ScoreInfo>(scoreInfo.ID)!.TotalScoreVersion), () => Is.EqualTo(LegacyScoreEncoder.LATEST_VERSION));
             AddAssert("Score not marked as failed", () => Realm.Run(r => r.Find<ScoreInfo>(scoreInfo.ID)!.BackgroundReprocessingFailed), () => Is.False);
         }
 
@@ -183,7 +182,7 @@ namespace osu.Game.Tests.Database
             AddStep("Run background processor", () => Add(processor = new TestBackgroundDataStoreProcessor()));
             AddUntilStep("Wait for completion", () => processor.Completed);
 
-            AddUntilStep("Score marked as failed", () => Realm.Run(r => r.Find<ScoreInfo>(scoreInfo.ID)!.BackgroundReprocessingFailed), () => Is.True);
+            AddAssert("Score marked as failed", () => Realm.Run(r => r.Find<ScoreInfo>(scoreInfo.ID)!.BackgroundReprocessingFailed), () => Is.True);
             AddAssert("Score version not upgraded", () => Realm.Run(r => r.Find<ScoreInfo>(scoreInfo.ID)!.TotalScoreVersion), () => Is.EqualTo(scoreVersion));
         }
 

osu.Game.Tests/Extensions/NumberFormattingExtensionsTest.cs

@@ -0,0 +1,54 @@
+// 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.Game.Extensions;
+
+namespace osu.Game.Tests.Extensions
+{
+    [TestFixture]
+    public class NumberFormattingExtensionsTest
+    {
+        [TestCase(-1, false, 0, ExpectedResult = "-1")]
+        [TestCase(0, false, 0, ExpectedResult = "0")]
+        [TestCase(1, false, 0, ExpectedResult = "1")]
+        [TestCase(500, false, 10, ExpectedResult = "500")]
+        [TestCase(-1, true, 0, ExpectedResult = "-1%")]
+        [TestCase(0, true, 0, ExpectedResult = "0%")]
+        [TestCase(1, true, 0, ExpectedResult = "1%")]
+        [TestCase(50, true, 0, ExpectedResult = "50%")]
+        public string TestInteger(int input, bool percent, int decimalDigits)
+        {
+            return input.ToStandardFormattedString(decimalDigits, percent);
+        }
+
+        [TestCase(-1, false, 0, ExpectedResult = "-1")]
+        [TestCase(-1e-6, false, 0, ExpectedResult = "0")]
+        [TestCase(-1e-6, false, 6, ExpectedResult = "-0.000001")]
+        [TestCase(0, false, 10, ExpectedResult = "0")]
+        [TestCase(0, false, 0, ExpectedResult = "0")]
+        [TestCase(double.NegativeZero, false, 0, ExpectedResult = "0")]
+        [TestCase(1e-6, false, 0, ExpectedResult = "0")]
+        [TestCase(1e-6, false, 6, ExpectedResult = "0.000001")]
+        [TestCase(1, false, 0, ExpectedResult = "1")]
+        [TestCase(1.528, false, 2, ExpectedResult = "1.53")]
+        [TestCase(500, false, 10, ExpectedResult = "500")]
+        [TestCase(-0.1, true, 0, ExpectedResult = "-10%")]
+        [TestCase(0, true, 0, ExpectedResult = "0%")]
+        [TestCase(0.4, true, 0, ExpectedResult = "40%")]
+        [TestCase(0.48333, true, 2, ExpectedResult = "48%")]
+        [TestCase(0.48333, true, 4, ExpectedResult = "48.33%")]
+        [TestCase(1, true, 0, ExpectedResult = "100%")]
+        public string TestDouble(double input, bool percent, int decimalDigits)
+        {
+            return input.ToStandardFormattedString(decimalDigits, percent);
+        }
+
+        [Test]
+        [SetCulture("fr-FR")]
+        public void TestCultureInsensitivity()
+        {
+            Assert.That(0.4.ToStandardFormattedString(maxDecimalDigits: 2, asPercentage: true), Is.EqualTo("40%"));
+        }
+    }
+}

osu.Game.Tests/Online/TestSceneMultiplayerBeatmapAvailabilityTracker.cs

@@ -0,0 +1,185 @@
+// 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.Allocation;
+using osu.Framework.Extensions;
+using osu.Framework.Platform;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+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.Online.Multiplayer;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay.Multiplayer;
+using osu.Game.Tests.Resources;
+using osu.Game.Tests.Visual.Multiplayer;
+using osu.Game.Utils;
+
+namespace osu.Game.Tests.Online
+{
+    [HeadlessTest]
+    public partial class TestSceneMultiplayerBeatmapAvailabilityTracker : MultiplayerTestScene
+    {
+        private BeatmapManager beatmapManager = null!;
+        private BeatmapInfo availableBeatmap = null!;
+        private BeatmapInfo unavailableBeatmap = null!;
+
+        private MultiplayerBeatmapAvailabilityTracker tracker = null!;
+
+        [BackgroundDependencyLoader]
+        private void load(GameHost host)
+        {
+            Dependencies.Cache(beatmapManager = new BeatmapManager(LocalStorage, Realm, null, Audio, Resources, host, Beatmap.Default));
+            Dependencies.Cache(Realm);
+
+            beatmapManager.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
+
+            var importedSet = beatmapManager.GetAllUsableBeatmapSets().First();
+            availableBeatmap = importedSet.Beatmaps[0];
+            unavailableBeatmap = importedSet.Beatmaps[1];
+
+            Realm.Write(r => r.Remove(r.Find<BeatmapInfo>(unavailableBeatmap.ID)!));
+        }
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("setup tracker", () =>
+            {
+                DummyAPIAccess api = (DummyAPIAccess)API;
+                Func<APIRequest, bool>? defaultRequestHandler = api.HandleRequest;
+
+                api.HandleRequest = req =>
+                {
+                    switch (req)
+                    {
+                        case GetBeatmapsRequest beatmapsReq:
+                            var availableApiBeatmap = CreateAPIBeatmap();
+                            availableApiBeatmap.OnlineID = availableBeatmap.OnlineID;
+                            availableApiBeatmap.OnlineBeatmapSetID = availableBeatmap.BeatmapSet!.OnlineID;
+                            availableApiBeatmap.Checksum = availableBeatmap.MD5Hash;
+                            availableApiBeatmap.BeatmapSet!.OnlineID = availableBeatmap.BeatmapSet!.OnlineID;
+
+                            var unavailableApiBeatmap = CreateAPIBeatmap();
+                            unavailableApiBeatmap.OnlineID = unavailableBeatmap.OnlineID;
+                            unavailableApiBeatmap.OnlineBeatmapSetID = unavailableBeatmap.BeatmapSet!.OnlineID;
+                            unavailableApiBeatmap.Checksum = unavailableBeatmap.MD5Hash;
+                            unavailableApiBeatmap.BeatmapSet!.OnlineID = unavailableBeatmap.BeatmapSet!.OnlineID;
+
+                            beatmapsReq.TriggerSuccess(new GetBeatmapsResponse
+                            {
+                                Beatmaps = new List<APIBeatmap>
+                                {
+                                    availableApiBeatmap,
+                                    unavailableApiBeatmap
+                                }
+                            });
+                            return true;
+
+                        default:
+                            return defaultRequestHandler?.Invoke(req) ?? false;
+                    }
+                };
+
+                Child = tracker = new MultiplayerBeatmapAvailabilityTracker();
+            });
+        }
+
+        [Test]
+        public void TestEnterRoomWithNotDownloadedBeatmap()
+        {
+            AddStep("join room", () =>
+            {
+                var room = CreateDefaultRoom();
+                room.Playlist = [new PlaylistItem(unavailableBeatmap)];
+                JoinRoom(room);
+            });
+
+            WaitForJoined();
+
+            AddUntilStep("beatmap is not available", () => tracker.Availability.Value.State, () => Is.EqualTo(DownloadState.NotDownloaded));
+        }
+
+        [Test]
+        public void TestEnterRoomWithLocallyAvailableBeatmap()
+        {
+            AddStep("join room", () =>
+            {
+                var room = CreateDefaultRoom();
+                room.Playlist = [new PlaylistItem(availableBeatmap)];
+                JoinRoom(room);
+            });
+
+            WaitForJoined();
+
+            AddUntilStep("beatmap is available", () => tracker.Availability.Value.State, () => Is.EqualTo(DownloadState.LocallyAvailable));
+        }
+
+        [Test]
+        public void TestAvailabilityUpdatesOnItemEdit()
+        {
+            AddStep("join room", () =>
+            {
+                var room = CreateDefaultRoom();
+                room.Playlist = [new PlaylistItem(availableBeatmap)];
+                JoinRoom(room);
+            });
+
+            WaitForJoined();
+
+            AddUntilStep("beatmap is available", () => tracker.Availability.Value.State, () => Is.EqualTo(DownloadState.LocallyAvailable));
+
+            AddStep("change item to not downloaded beatmap", () =>
+            {
+                PlaylistItem newItem = new PlaylistItem(MultiplayerClient.ClientRoom!.CurrentPlaylistItem).With(beatmap: new Optional<IBeatmapInfo>(unavailableBeatmap));
+                MultiplayerClient.EditPlaylistItem(new MultiplayerPlaylistItem(newItem)).WaitSafely();
+            });
+
+            AddUntilStep("beatmap is not available", () => tracker.Availability.Value.State, () => Is.EqualTo(DownloadState.NotDownloaded));
+
+            AddStep("change item to downloaded beatmap", () =>
+            {
+                PlaylistItem newItem = new PlaylistItem(MultiplayerClient.ClientRoom!.CurrentPlaylistItem).With(beatmap: new Optional<IBeatmapInfo>(availableBeatmap));
+                MultiplayerClient.EditPlaylistItem(new MultiplayerPlaylistItem(newItem)).WaitSafely();
+            });
+
+            AddUntilStep("beatmap is available", () => tracker.Availability.Value.State, () => Is.EqualTo(DownloadState.LocallyAvailable));
+        }
+
+        [Test]
+        public void TestAvailabilityUpdatesOnSettingsChange()
+        {
+            AddStep("join room", () =>
+            {
+                var room = CreateDefaultRoom();
+                room.Playlist = [new PlaylistItem(availableBeatmap), new PlaylistItem(unavailableBeatmap)];
+                JoinRoom(room);
+            });
+
+            WaitForJoined();
+
+            AddUntilStep("beatmap is available", () => tracker.Availability.Value.State, () => Is.EqualTo(DownloadState.LocallyAvailable));
+
+            AddStep("change settings to not downloaded beatmap", () => MultiplayerClient.ChangeServerRoomSettings(new MultiplayerRoomSettings(MultiplayerClient.ClientAPIRoom!)
+            {
+                PlaylistItemId = MultiplayerClient.ServerRoom!.Playlist[1].ID
+            }).WaitSafely());
+
+            AddUntilStep("beatmap is not available", () => tracker.Availability.Value.State, () => Is.EqualTo(DownloadState.NotDownloaded));
+
+            AddStep("change settings to downloaded beatmap", () => MultiplayerClient.ChangeServerRoomSettings(new MultiplayerRoomSettings(MultiplayerClient.ClientAPIRoom!)
+            {
+                PlaylistItemId = MultiplayerClient.ServerRoom!.Playlist[0].ID
+            }).WaitSafely());
+
+            AddUntilStep("beatmap is available", () => tracker.Availability.Value.State, () => Is.EqualTo(DownloadState.LocallyAvailable));
+        }
+    }
+}

osu.Game.Tests/Online/TestScenePlaylistsBeatmapAvailabilityTracker.cs

@@ -1,18 +1,14 @@
 // 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.Diagnostics;
 using System.IO;
 using System.Threading;
-using JetBrains.Annotations;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
-using osu.Framework.Bindables;
 using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.IO.Stores;
@@ -27,31 +23,29 @@ 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;
+using osu.Game.Screens.OnlinePlay;
+using osu.Game.Screens.OnlinePlay.Playlists;
 using osu.Game.Tests.Resources;
 using osu.Game.Tests.Visual;
 
 namespace osu.Game.Tests.Online
 {
     [HeadlessTest]
-    public partial class TestSceneOnlinePlayBeatmapAvailabilityTracker : OsuTestScene
+    public partial class TestScenePlaylistsBeatmapAvailabilityTracker : OsuTestScene
     {
-        private RulesetStore rulesets;
-        private TestBeatmapManager beatmaps;
-        private TestBeatmapModelDownloader beatmapDownloader;
+        private TestBeatmapManager beatmaps = null!;
+        private TestBeatmapModelDownloader beatmapDownloader = null!;
 
-        private string testBeatmapFile;
-        private BeatmapInfo testBeatmapInfo;
-        private BeatmapSetInfo testBeatmapSet;
+        private string testBeatmapFile = null!;
+        private BeatmapInfo testBeatmapInfo = null!;
+        private BeatmapSetInfo testBeatmapSet = null!;
 
-        private readonly Bindable<PlaylistItem> selectedItem = new Bindable<PlaylistItem>();
-        private OnlinePlayBeatmapAvailabilityTracker availabilityTracker;
+        private OnlinePlayBeatmapAvailabilityTracker availabilityTracker = null!;
 
         [BackgroundDependencyLoader]
         private void load(AudioManager audio, GameHost host)
         {
-            Dependencies.Cache(rulesets = new RealmRulesetStore(Realm));
-            Dependencies.CacheAs<BeatmapManager>(beatmaps = new TestBeatmapManager(LocalStorage, Realm, rulesets, API, audio, Resources, host, Beatmap.Default));
+            Dependencies.CacheAs<BeatmapManager>(beatmaps = new TestBeatmapManager(LocalStorage, Realm, API, audio, Resources, host, Beatmap.Default));
             Dependencies.CacheAs<BeatmapModelDownloader>(beatmapDownloader = new TestBeatmapModelDownloader(beatmaps, API));
         }
 
@@ -82,16 +76,11 @@ namespace osu.Game.Tests.Online
             testBeatmapFile = TestResources.GetQuickTestBeatmapForImport();
 
             testBeatmapInfo = getTestBeatmapInfo(testBeatmapFile);
-            testBeatmapSet = testBeatmapInfo.BeatmapSet;
+            testBeatmapSet = testBeatmapInfo.BeatmapSet!;
 
             Realm.Write(r => r.RemoveAll<BeatmapSetInfo>());
             Realm.Write(r => r.RemoveAll<BeatmapInfo>());
 
-            selectedItem.Value = new PlaylistItem(testBeatmapInfo)
-            {
-                RulesetID = testBeatmapInfo.Ruleset.OnlineID,
-            };
-
             recreateChildren();
         });
 
@@ -108,9 +97,15 @@ namespace osu.Game.Tests.Online
                 Children = new Drawable[]
                 {
                     beatmapLookupCache,
-                    availabilityTracker = new OnlinePlayBeatmapAvailabilityTracker
+                    availabilityTracker = new PlaylistsBeatmapAvailabilityTracker
                     {
-                        SelectedItem = { BindTarget = selectedItem, }
+                        PlaylistItem =
+                        {
+                            Value = new PlaylistItem(testBeatmapInfo)
+                            {
+                                RulesetID = testBeatmapInfo.Ruleset.OnlineID,
+                            },
+                        }
                     }
                 }
             };
@@ -125,10 +120,10 @@ namespace osu.Game.Tests.Online
             AddStep("start downloading", () => beatmapDownloader.Download(testBeatmapSet));
             addAvailabilityCheckStep("state downloading 0%", () => BeatmapAvailability.Downloading(0.0f));
 
-            AddStep("set progress 40%", () => ((TestDownloadRequest)beatmapDownloader.GetExistingDownload(testBeatmapSet))!.SetProgress(0.4f));
+            AddStep("set progress 40%", () => ((TestDownloadRequest)beatmapDownloader.GetExistingDownload(testBeatmapSet)!).SetProgress(0.4f));
             addAvailabilityCheckStep("state downloading 40%", () => BeatmapAvailability.Downloading(0.4f));
 
-            AddStep("finish download", () => ((TestDownloadRequest)beatmapDownloader.GetExistingDownload(testBeatmapSet))!.TriggerSuccess(testBeatmapFile));
+            AddStep("finish download", () => ((TestDownloadRequest)beatmapDownloader.GetExistingDownload(testBeatmapSet)!).TriggerSuccess(testBeatmapFile));
             addAvailabilityCheckStep("state importing", BeatmapAvailability.Importing);
 
             AddStep("allow importing", () => beatmaps.AllowImport.Set());
@@ -203,10 +198,10 @@ namespace osu.Game.Tests.Online
         {
             public readonly ManualResetEventSlim AllowImport = new ManualResetEventSlim();
 
-            public Live<BeatmapSetInfo> CurrentImport { get; private set; }
+            public Live<BeatmapSetInfo>? CurrentImport { get; private set; }
 
-            public TestBeatmapManager(Storage storage, RealmAccess realm, RulesetStore rulesets, IAPIProvider api, [NotNull] AudioManager audioManager, IResourceStore<byte[]> resources,
-                                      GameHost host = null, WorkingBeatmap defaultBeatmap = null)
+            public TestBeatmapManager(Storage storage, RealmAccess realm, IAPIProvider api, AudioManager audioManager, IResourceStore<byte[]> resources,
+                                      GameHost? host = null, WorkingBeatmap? defaultBeatmap = null)
                 : base(storage, realm, api, audioManager, resources, host, defaultBeatmap)
             {
             }
@@ -226,12 +221,13 @@ namespace osu.Game.Tests.Online
                     this.testBeatmapManager = testBeatmapManager;
                 }
 
-                public override Live<BeatmapSetInfo> ImportModel(BeatmapSetInfo item, ArchiveReader archive = null, ImportParameters parameters = default, CancellationToken cancellationToken = default)
+                public override Live<BeatmapSetInfo>? ImportModel(BeatmapSetInfo item, ArchiveReader? archive = null, ImportParameters parameters = default,
+                                                                  CancellationToken cancellationToken = default)
                 {
                     if (!testBeatmapManager.AllowImport.Wait(TimeSpan.FromSeconds(10), cancellationToken))
                         throw new TimeoutException("Timeout waiting for import to be allowed.");
 
-                    return (testBeatmapManager.CurrentImport = base.ImportModel(item, archive, parameters, cancellationToken));
+                    return testBeatmapManager.CurrentImport = base.ImportModel(item, archive, parameters, cancellationToken);
                 }
             }
         }

osu.Game.Tests/OnlinePlay/MultiplayerPlaylistItemTest.cs

@@ -0,0 +1,73 @@
+// 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 Bogus;
+using MessagePack;
+using NUnit.Framework;
+using osu.Game.Online.API;
+using osu.Game.Online.Rooms;
+
+namespace osu.Game.Tests.OnlinePlay
+{
+    [TestFixture]
+    public class MultiplayerPlaylistItemTest
+    {
+        [SetUp]
+        public void Setup()
+        {
+            Randomizer.Seed = new Random(1337);
+        }
+
+        [Test]
+        public void TestCloneMultiplayerPlaylistItem()
+        {
+            var faker = new Faker<MultiplayerPlaylistItem>()
+                        .StrictMode(true)
+                        .RuleFor(o => o.ID, f => f.Random.Long())
+                        .RuleFor(o => o.OwnerID, f => f.Random.Int())
+                        .RuleFor(o => o.BeatmapID, f => f.Random.Int())
+                        .RuleFor(o => o.BeatmapChecksum, f => f.Random.Hash())
+                        .RuleFor(o => o.RulesetID, f => f.Random.Int())
+                        .RuleFor(o => o.RequiredMods, f => f.Make(5, _ => new APIMod { Acronym = f.Random.String2(3) }))
+                        .RuleFor(o => o.AllowedMods, f => f.Make(5, _ => new APIMod { Acronym = f.Random.String2(3) }))
+                        .RuleFor(o => o.Expired, f => f.Random.Bool())
+                        .RuleFor(o => o.PlaylistOrder, f => f.Random.UShort())
+                        .RuleFor(o => o.PlayedAt, f => f.Date.RecentOffset())
+                        .RuleFor(o => o.StarRating, f => f.Random.Double())
+                        .RuleFor(o => o.Freestyle, f => f.Random.Bool());
+
+            for (int i = 0; i < 100; i++)
+            {
+                MultiplayerPlaylistItem item = faker.Generate();
+                Assert.That(MessagePackSerializer.SerializeToJson(item.Clone()), Is.EqualTo(MessagePackSerializer.SerializeToJson(item)));
+            }
+        }
+
+        [Test]
+        public void TestConstructFromAPIModel()
+        {
+            var faker = new Faker<MultiplayerPlaylistItem>()
+                        .StrictMode(true)
+                        .RuleFor(o => o.ID, f => f.Random.Long())
+                        .RuleFor(o => o.OwnerID, f => f.Random.Int())
+                        .RuleFor(o => o.BeatmapID, f => f.Random.Int())
+                        .RuleFor(o => o.BeatmapChecksum, f => f.Random.Hash())
+                        .RuleFor(o => o.RulesetID, f => f.Random.Int())
+                        .RuleFor(o => o.RequiredMods, f => f.Make(5, _ => new APIMod { Acronym = f.Random.String2(3) }))
+                        .RuleFor(o => o.AllowedMods, f => f.Make(5, _ => new APIMod { Acronym = f.Random.String2(3) }))
+                        .RuleFor(o => o.Expired, f => f.Random.Bool())
+                        .RuleFor(o => o.PlaylistOrder, f => f.Random.UShort())
+                        .RuleFor(o => o.PlayedAt, f => f.Date.RecentOffset())
+                        .RuleFor(o => o.StarRating, f => f.Random.Double())
+                        .RuleFor(o => o.Freestyle, f => f.Random.Bool());
+
+            for (int i = 0; i < 100; i++)
+            {
+                MultiplayerPlaylistItem initialItem = faker.Generate();
+                MultiplayerPlaylistItem copiedItem = new MultiplayerPlaylistItem(new PlaylistItem(initialItem));
+                Assert.That(MessagePackSerializer.SerializeToJson(copiedItem), Is.EqualTo(MessagePackSerializer.SerializeToJson(initialItem)));
+            }
+        }
+    }
+}

osu.Game.Tests/Resources/noop-fade-transform-is-ignored-for-lifetime.osb

@@ -0,0 +1,8 @@
+[Events]
+//Storyboard Layer 0 (Background)
+Sprite,Background,TopCentre,"img.jpg",320,240
+ F,0,1000,1000,0,0 // should be ignored
+ F,0,1500,1600,0,1
+Sprite,Background,TopCentre,"img.jpg",320,240
+ F,0,1000,1000,0,0 // should be ignored
+ F,0,1500,1600,1,1

osu.Game.Tests/Resources/video-custom-alpha-transform.osb

@@ -0,0 +1,5 @@
+osu file format v14
+
+[Events]
+Video,-5678,"Video.avi",0,0
+ F,0,1500,1600,0,1

osu.Game.Tests/Scores/IO/ImportScoreTest.cs

@@ -215,6 +215,35 @@ namespace osu.Game.Tests.Scores.IO
             }
         }
 
+        [Test]
+        public void TestScoreWithInvalidModCombinationsWillNotImport()
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host, true);
+
+                    var beatmap = BeatmapImportHelper.LoadOszIntoOsu(osu, TestResources.GetQuickTestBeatmapForImport()).GetResultSafely();
+
+                    var toImport = new ScoreInfo
+                    {
+                        User = new APIUser { Username = "Test user" },
+                        BeatmapInfo = beatmap.Beatmaps.First(),
+                        Ruleset = new OsuRuleset().RulesetInfo,
+                        ClientVersion = "12345",
+                        Mods = new Mod[] { new OsuModHalfTime(), new OsuModDoubleTime() },
+                    };
+
+                    Assert.Throws<InvalidOperationException>(() => LoadScoreIntoOsu(osu, toImport));
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
         [Test]
         public void TestImportStatistics()
         {

osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapCardFavouriteButton.cs

@@ -91,6 +91,6 @@ namespace osu.Game.Tests.Visual.Beatmaps
         }
 
         private void assertCorrectIcon(bool favourited) => AddAssert("icon correct",
-            () => this.ChildrenOfType<SpriteIcon>().Single().Icon.Equals(favourited ? FontAwesome.Solid.Heart : FontAwesome.Regular.Heart));
+            () => this.ChildrenOfType<SpriteIcon>().First().Icon.Equals(favourited ? FontAwesome.Solid.Heart : FontAwesome.Regular.Heart));
     }
 }

osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapSetOnlineStatusPill.cs

@@ -19,6 +19,8 @@ namespace osu.Game.Tests.Visual.Beatmaps
 {
     public partial class TestSceneBeatmapSetOnlineStatusPill : ThemeComparisonTestScene
     {
+        private bool showUnknownStatus;
+
         protected override Drawable CreateContent() => new FillFlowContainer
         {
             AutoSizeAxes = Axes.Both,
@@ -26,12 +28,20 @@ namespace osu.Game.Tests.Visual.Beatmaps
             Origin = Anchor.Centre,
             Direction = FillDirection.Vertical,
             Spacing = new Vector2(0, 10),
-            ChildrenEnumerable = Enum.GetValues(typeof(BeatmapOnlineStatus)).Cast<BeatmapOnlineStatus>().Select(status => new BeatmapSetOnlineStatusPill
+            ChildrenEnumerable = Enum.GetValues(typeof(BeatmapOnlineStatus)).Cast<BeatmapOnlineStatus>().Select(status => new Container
             {
-                AutoSizeAxes = Axes.Both,
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                Status = status
+                RelativeSizeAxes = Axes.X,
+                Height = 20,
+                Children = new Drawable[]
+                {
+                    new BeatmapSetOnlineStatusPill
+                    {
+                        ShowUnknownStatus = showUnknownStatus,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Status = status
+                    }
+                }
             })
         };
 
@@ -48,6 +58,12 @@ namespace osu.Game.Tests.Visual.Beatmaps
                 pill.Width = 90;
             }));
 
+            AddStep("toggle show unknown", () =>
+            {
+                showUnknownStatus = !showUnknownStatus;
+                CreateThemedContent(OverlayColourScheme.Red);
+            });
+
             AddStep("unset fixed width", () => statusPills.ForEach(pill => pill.AutoSizeAxes = Axes.Both));
         }
 
@@ -65,11 +81,6 @@ namespace osu.Game.Tests.Visual.Beatmaps
                             pill.Status = BeatmapOnlineStatus.LocallyModified;
                             break;
 
-                        // skip none
-                        case BeatmapOnlineStatus.LocallyModified:
-                            pill.Status = BeatmapOnlineStatus.Graveyard;
-                            break;
-
                         default:
                             pill.Status = (pill.Status + 1);
                             break;

osu.Game.Tests/Visual/Beatmaps/TestSceneDifficultySpectrumDisplay.cs

@@ -1,12 +1,10 @@
 // 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.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
-using osu.Game.Beatmaps;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps.Drawables;
 using osu.Game.Online.API.Requests.Responses;
 using osuTK;
@@ -15,16 +13,18 @@ namespace osu.Game.Tests.Visual.Beatmaps
 {
     public partial class TestSceneDifficultySpectrumDisplay : OsuTestScene
     {
-        private DifficultySpectrumDisplay display;
+        private DifficultySpectrumDisplay display = null!;
 
-        private static APIBeatmapSet createBeatmapSetWith(params (int rulesetId, double stars)[] difficulties) => new APIBeatmapSet
+        [SetUpSteps]
+        public void SetUpSteps()
         {
-            Beatmaps = difficulties.Select(difficulty => new APIBeatmap
+            AddStep("create spectrum display", () => Child = display = new DifficultySpectrumDisplay
             {
-                RulesetID = difficulty.rulesetId,
-                StarRating = difficulty.stars
-            }).ToArray()
-        };
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Scale = new Vector2(3)
+            });
+        }
 
         [Test]
         public void TestSingleRuleset()
@@ -34,7 +34,7 @@ namespace osu.Game.Tests.Visual.Beatmaps
                 (rulesetId: 0, stars: 3.2),
                 (rulesetId: 0, stars: 5.6));
 
-            createDisplay(beatmapSet);
+            AddStep("set beatmap to display", () => display.BeatmapSet = beatmapSet);
         }
 
         [Test]
@@ -47,7 +47,7 @@ namespace osu.Game.Tests.Visual.Beatmaps
                 (rulesetId: 1, stars: 4.3),
                 (rulesetId: 0, stars: 5.6));
 
-            createDisplay(beatmapSet);
+            AddStep("set beatmap to display", () => display.BeatmapSet = beatmapSet);
         }
 
         [Test]
@@ -61,52 +61,30 @@ namespace osu.Game.Tests.Visual.Beatmaps
                 (rulesetId: 0, stars: 5.6),
                 (rulesetId: 15, stars: 7.8));
 
-            createDisplay(beatmapSet);
+            AddStep("set beatmap to display", () => display.BeatmapSet = beatmapSet);
         }
 
         [Test]
         public void TestMaximumUncollapsed()
         {
             var beatmapSet = createBeatmapSetWith(Enumerable.Range(0, 12).Select(i => (rulesetId: i % 4, stars: 2.5 + i * 0.25)).ToArray());
-            createDisplay(beatmapSet);
+            AddStep("set beatmap to display", () => display.BeatmapSet = beatmapSet);
         }
 
         [Test]
         public void TestMinimumCollapsed()
         {
             var beatmapSet = createBeatmapSetWith(Enumerable.Range(0, 13).Select(i => (rulesetId: i % 4, stars: 2.5 + i * 0.25)).ToArray());
-            createDisplay(beatmapSet);
+            AddStep("set beatmap to display", () => display.BeatmapSet = beatmapSet);
         }
 
-        [Test]
-        public void TestAdjustableDotSize()
+        private static APIBeatmapSet createBeatmapSetWith(params (int rulesetId, double stars)[] difficulties) => new APIBeatmapSet
         {
-            var beatmapSet = createBeatmapSetWith(
-                (rulesetId: 0, stars: 2.0),
-                (rulesetId: 3, stars: 2.3),
-                (rulesetId: 0, stars: 3.2),
-                (rulesetId: 1, stars: 4.3),
-                (rulesetId: 0, stars: 5.6));
-
-            createDisplay(beatmapSet);
-
-            AddStep("change dot dimensions", () =>
+            Beatmaps = difficulties.Select(difficulty => new APIBeatmap
             {
-                display.DotSize = new Vector2(8, 12);
-                display.DotSpacing = 2;
-            });
-            AddStep("change dot dimensions back", () =>
-            {
-                display.DotSize = new Vector2(4, 8);
-                display.DotSpacing = 1;
-            });
-        }
-
-        private void createDisplay(IBeatmapSetInfo beatmapSetInfo) => AddStep("create spectrum display", () => Child = display = new DifficultySpectrumDisplay(beatmapSetInfo)
-        {
-            Anchor = Anchor.Centre,
-            Origin = Anchor.Centre,
-            Scale = new Vector2(3)
-        });
+                RulesetID = difficulty.rulesetId,
+                StarRating = difficulty.stars
+            }).ToArray()
+        };
     }
 }

osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallenge.cs

@@ -15,7 +15,7 @@ using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Screens.SelectV2.Leaderboards;
+using osu.Game.Screens.SelectV2;
 using osu.Game.Tests.Resources;
 using osu.Game.Tests.Visual.Metadata;
 using osu.Game.Tests.Visual.OnlinePlay;
@@ -43,7 +43,6 @@ namespace osu.Game.Tests.Visual.DailyChallenge
         {
             var room = new Room
             {
-                RoomID = 1234,
                 Name = "Daily Challenge: June 4, 2024",
                 Playlist =
                 [
@@ -66,7 +65,6 @@ namespace osu.Game.Tests.Visual.DailyChallenge
         {
             var room = new Room
             {
-                RoomID = 1234,
                 Name = "Daily Challenge: June 4, 2024",
                 Playlist =
                 [
@@ -87,7 +85,7 @@ namespace osu.Game.Tests.Visual.DailyChallenge
             AddStep("force transforms to finish", () => FinishTransforms(true));
             AddStep("right click second score", () =>
             {
-                InputManager.MoveMouseTo(this.ChildrenOfType<LeaderboardScoreV2>().ElementAt(1));
+                InputManager.MoveMouseTo(this.ChildrenOfType<BeatmapLeaderboardScore>().ElementAt(1));
                 InputManager.Click(MouseButton.Right);
             });
             AddAssert("use these mods not present",
@@ -99,7 +97,6 @@ namespace osu.Game.Tests.Visual.DailyChallenge
         {
             var room = new Room
             {
-                RoomID = 1234,
                 Name = "Daily Challenge: June 4, 2024",
                 Playlist =
                 [
@@ -114,7 +111,7 @@ namespace osu.Game.Tests.Visual.DailyChallenge
             };
 
             AddStep("add room", () => API.Perform(new CreateRoomRequest(room)));
-            AddStep("set daily challenge info", () => metadataClient.DailyChallengeInfo.Value = new DailyChallengeInfo { RoomID = 1234 });
+            AddStep("set daily challenge info", () => metadataClient.DailyChallengeInfo.Value = new DailyChallengeInfo { RoomID = room.RoomID!.Value });
 
             Screens.OnlinePlay.DailyChallenge.DailyChallenge screen = null!;
             AddStep("push screen", () => LoadScreen(screen = new Screens.OnlinePlay.DailyChallenge.DailyChallenge(room)));
@@ -128,7 +125,6 @@ namespace osu.Game.Tests.Visual.DailyChallenge
         {
             var room = new Room
             {
-                RoomID = 1234,
                 Name = "Daily Challenge: June 4, 2024",
                 Playlist =
                 [
@@ -143,7 +139,7 @@ namespace osu.Game.Tests.Visual.DailyChallenge
             };
 
             AddStep("add room", () => API.Perform(new CreateRoomRequest(room)));
-            AddStep("set daily challenge info", () => metadataClient.DailyChallengeInfo.Value = new DailyChallengeInfo { RoomID = 1234 });
+            AddStep("set daily challenge info", () => metadataClient.DailyChallengeInfo.Value = new DailyChallengeInfo { RoomID = room.RoomID!.Value });
 
             Screens.OnlinePlay.DailyChallenge.DailyChallenge screen = null!;
             AddStep("push screen", () => LoadScreen(screen = new Screens.OnlinePlay.DailyChallenge.DailyChallenge(room)));

osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeIntro.cs

@@ -44,17 +44,17 @@ namespace osu.Game.Tests.Visual.DailyChallenge
         [Test]
         public void TestDailyChallenge()
         {
-            startChallenge(1234);
+            startChallenge();
             AddStep("push screen", () => LoadScreen(new DailyChallengeIntro(room)));
         }
 
         [Test]
         public void TestPlayIntroOnceFlag()
         {
-            startChallenge(1234);
+            startChallenge();
             AddStep("set intro played flag", () => Dependencies.Get<SessionStatics>().SetValue(Static.DailyChallengeIntroPlayed, true));
 
-            startChallenge(1235);
+            startChallenge();
 
             AddAssert("intro played flag reset", () => Dependencies.Get<SessionStatics>().Get<bool>(Static.DailyChallengeIntroPlayed), () => Is.False);
 
@@ -62,13 +62,12 @@ namespace osu.Game.Tests.Visual.DailyChallenge
             AddUntilStep("intro played flag set", () => Dependencies.Get<SessionStatics>().Get<bool>(Static.DailyChallengeIntroPlayed), () => Is.True);
         }
 
-        private void startChallenge(int roomId)
+        private void startChallenge()
         {
             AddStep("add room", () =>
             {
                 API.Perform(new CreateRoomRequest(room = new Room
                 {
-                    RoomID = roomId,
                     Name = "Daily Challenge: June 4, 2024",
                     Playlist =
                     [
@@ -83,7 +82,7 @@ namespace osu.Game.Tests.Visual.DailyChallenge
                     Category = RoomCategory.DailyChallenge
                 }));
             });
-            AddStep("signal client", () => metadataClient.DailyChallengeUpdated(new DailyChallengeInfo { RoomID = roomId }));
+            AddStep("signal client", () => metadataClient.DailyChallengeUpdated(new DailyChallengeInfo { RoomID = room.RoomID!.Value }));
         }
     }
 }

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

@@ -24,12 +24,7 @@ namespace osu.Game.Tests.Visual.Editing
             PoolableSkinnableSample[] loopingSamples = null;
             PoolableSkinnableSample[] onceOffSamples = null;
 
-            AddStep("get first slider", () =>
-            {
-                slider = Editor.ChildrenOfType<DrawableSlider>().OrderBy(s => s.HitObject.StartTime).First();
-                onceOffSamples = slider.ChildrenOfType<PoolableSkinnableSample>().Where(s => !s.Looping).ToArray();
-                loopingSamples = slider.ChildrenOfType<PoolableSkinnableSample>().Where(s => s.Looping).ToArray();
-            });
+            AddStep("get first slider", () => slider = Editor.ChildrenOfType<DrawableSlider>().OrderBy(s => s.HitObject.StartTime).First());
 
             AddStep("start playback", () => EditorClock.Start());
 
@@ -38,6 +33,9 @@ namespace osu.Game.Tests.Visual.Editing
                 if (!slider.Tracking.Value)
                     return false;
 
+                onceOffSamples = slider.ChildrenOfType<PoolableSkinnableSample>().Where(s => !s.Looping).ToArray();
+                loopingSamples = slider.ChildrenOfType<PoolableSkinnableSample>().Where(s => s.Looping).ToArray();
+
                 if (!loopingSamples.Any(s => s.Playing))
                     return false;
 

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

@@ -208,5 +208,11 @@ namespace osu.Game.Tests.Visual.Editing
             AddAssert("Beatmap still has correct beat divisor", () => EditorBeatmap.BeatmapInfo.BeatDivisor, () => Is.EqualTo(7));
             AddAssert("Correct beat divisor actually active", () => Editor.BeatDivisor, () => Is.EqualTo(7));
         }
+
+        [Test]
+        public void TestBeatmapVersionPopulatedCorrectly()
+        {
+            AddAssert("beatmap version is populated", () => EditorBeatmap.BeatmapVersion > 0);
+        }
     }
 }

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

@@ -65,10 +65,10 @@ namespace osu.Game.Tests.Visual.Editing
                 InputManager.Keys(PlatformAction.Paste);
             });
 
-            assertArtistMetadata("Example Artist");
+            assertArtistMetadata("Example ArtistExample Artist");
 
             // It's important values are committed immediately on focus loss so the editor exit sequence detects them.
-            AddAssert("value immediately changed on focus loss", () =>
+            AddAssert("value still changed after focus loss", () =>
             {
                 ((IFocusManager)InputManager).TriggerFocusContention(metadataSection);
                 return editorBeatmap.Metadata.Artist;
@@ -104,7 +104,7 @@ namespace osu.Game.Tests.Visual.Editing
                 InputManager.Keys(PlatformAction.Paste);
             });
 
-            assertArtistMetadata("Example Artist");
+            assertArtistMetadata("Example ArtistExample Artist");
 
             AddStep("commit", () => InputManager.Key(Key.Enter));
 

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

@@ -50,21 +50,17 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddStep("Set short reference score", () =>
             {
+                // 50 events total. one of them (head circle) being timed / having hitwindows, rest having no hitwindows
                 List<HitEvent> hitEvents =
                 [
-                    // 10 events total. one of them (head circle) being timed / having hitwindows, rest having no hitwindows
                     new HitEvent(30, 1, HitResult.LargeTickHit, new SliderHeadCircle { ClassicSliderBehaviour = true }, null, null),
-                    new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null),
-                    new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null),
-                    new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null),
-                    new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null),
-                    new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null),
-                    new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null),
-                    new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null),
-                    new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null),
-                    new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null),
                 ];
 
+                for (int i = 0; i < 49; i++)
+                {
+                    hitEvents.Add(new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null));
+                }
+
                 foreach (var ev in hitEvents)
                     ev.HitObject.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
 

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

@@ -15,6 +15,7 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input;
 using osu.Framework.Testing;
 using osu.Game.Database;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Settings;
 using osu.Game.Overlays.SkinEditor;
@@ -458,6 +459,62 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("combo placed in ruleset target", () => rulesetHUDTarget.Components.OfType<LegacyDefaultComboCounter>().Count() == 1);
         }
 
+        [Test]
+        public void TestAnchorRadioButtonBehavior()
+        {
+            ISerialisableDrawable? selectedComponent = null;
+
+            AddStep("Select first component", () =>
+            {
+                var blueprint = skinEditor.ChildrenOfType<SkinBlueprint>().First();
+                skinEditor.SelectedComponents.Clear();
+                skinEditor.SelectedComponents.Add(blueprint.Item);
+                selectedComponent = blueprint.Item;
+            });
+
+            AddStep("Right-click to open context menu", () =>
+            {
+                if (selectedComponent != null)
+                    InputManager.MoveMouseTo(((Drawable)selectedComponent).ScreenSpaceDrawQuad.Centre);
+                InputManager.Click(MouseButton.Right);
+            });
+
+            AddStep("Click on Anchor menu", () =>
+            {
+                InputManager.MoveMouseTo(getMenuItemByText("Anchor"));
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddStep("Right-click TopLeft anchor", () =>
+            {
+                InputManager.MoveMouseTo(getMenuItemByText("TopLeft"));
+                InputManager.Click(MouseButton.Right);
+            });
+
+            AddAssert("TopLeft item checked", () => (getMenuItemByText("TopLeft").Item as TernaryStateRadioMenuItem)?.State.Value == TernaryState.True);
+
+            AddStep("Right-click Centre anchor", () =>
+            {
+                InputManager.MoveMouseTo(getMenuItemByText("Centre"));
+                InputManager.Click(MouseButton.Right);
+            });
+
+            AddAssert("Centre item checked", () => (getMenuItemByText("Centre").Item as TernaryStateRadioMenuItem)?.State.Value == TernaryState.True);
+            AddAssert("TopLeft item unchecked", () => (getMenuItemByText("TopLeft").Item as TernaryStateRadioMenuItem)?.State.Value == TernaryState.False);
+
+            AddStep("Right-click Closest anchor", () =>
+            {
+                InputManager.MoveMouseTo(getMenuItemByText("Closest"));
+                InputManager.Click(MouseButton.Right);
+            });
+
+            AddAssert("Closest item checked", () => (getMenuItemByText("Closest").Item as TernaryStateRadioMenuItem)?.State.Value == TernaryState.True);
+            AddAssert("Centre item unchecked", () => (getMenuItemByText("Centre").Item as TernaryStateRadioMenuItem)?.State.Value == TernaryState.False);
+
+            Menu.DrawableMenuItem getMenuItemByText(string text)
+                => this.ChildrenOfType<Menu.DrawableMenuItem>().First(m => m.Item.Text.ToString() == text);
+        }
+
         private Skin importSkinFromArchives(string filename)
         {
             var imported = skins.Import(new ImportTask(TestResources.OpenResource($@"Archives/{filename}"), filename)).GetResultSafely();

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

@@ -57,7 +57,6 @@ namespace osu.Game.Tests.Visual.Gameplay
                     Scores = { BindTarget = scores },
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    AlwaysVisible = { Value = false },
                     Expanded = { Value = true },
                 };
             });
@@ -101,12 +100,6 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddStep("set config visible false", () => configVisibility.Value = false);
             AddUntilStep("leaderboard not visible", () => leaderboard.Alpha == 0);
-
-            AddStep("set always visible", () => leaderboard.AlwaysVisible.Value = true);
-            AddUntilStep("leaderboard visible", () => leaderboard.Alpha == 1);
-
-            AddStep("set config visible true", () => configVisibility.Value = true);
-            AddAssert("leaderboard still visible", () => leaderboard.Alpha == 1);
         }
 
         private static List<ScoreInfo> createSampleScores()

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

@@ -2,12 +2,14 @@
 // 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.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Testing;
 using osu.Framework.Timing;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
@@ -48,7 +50,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         }
 
         [Test]
-        public void TestVideoSize()
+        public void TestVideo()
         {
             AddStep("load storyboard with only video", () =>
             {
@@ -56,6 +58,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                 loadStoryboard("storyboard_only_video.osu", s => s.Beatmap.WidescreenStoryboard = false);
             });
 
+            AddAssert("storyboard video present in hierarchy", () => this.ChildrenOfType<DrawableStoryboardVideo>().Any());
             AddAssert("storyboard is correct width", () => Precision.AlmostEquals(storyboard?.Width ?? 0f, 480 * 16 / 9f));
         }
 

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

@@ -185,8 +185,12 @@ namespace osu.Game.Tests.Visual.Menus
             AddUntilStep("track changed", () => trackChangeQueue.Count == 1);
 
             AddStep("press previous", () => globalActionContainer.TriggerPressed(GlobalAction.MusicPrev));
-            AddUntilStep("track changed", () =>
+            AddUntilStep("new track selected", () =>
                 trackChangeQueue.Count == 2 && !trackChangeQueue.First().working.BeatmapInfo.Equals(trackChangeQueue.Last().working.BeatmapInfo));
+
+            AddStep("press next", () => globalActionContainer.TriggerPressed(GlobalAction.MusicNext));
+            AddUntilStep("first track selected",
+                () => trackChangeQueue.Count == 3 && trackChangeQueue.First().working.BeatmapInfo.Equals(trackChangeQueue.Last().working.BeatmapInfo));
         }
     }
 }

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

@@ -50,30 +50,17 @@ namespace osu.Game.Tests.Visual.Menus
         [Test]
         public void TestGameplay()
         {
+            KiaiGameplayFountains fountains = null!;
+
             AddStep("make fountains", () =>
             {
                 Children = new[]
                 {
-                    new KiaiGameplayFountains.GameplayStarFountain
-                    {
-                        Anchor = Anchor.BottomLeft,
-                        Origin = Anchor.BottomLeft,
-                        X = 75,
-                    },
-                    new KiaiGameplayFountains.GameplayStarFountain
-                    {
-                        Anchor = Anchor.BottomRight,
-                        Origin = Anchor.BottomRight,
-                        X = -75,
-                    },
+                    fountains = new KiaiGameplayFountains(),
                 };
             });
 
-            AddStep("activate fountains", () =>
-            {
-                ((StarFountain)Children[0]).Shoot(1);
-                ((StarFountain)Children[1]).Shoot(-1);
-            });
+            AddStep("activate fountains", () => fountains.Shoot());
         }
 
         [Test]

osu.Game.Tests/Visual/Multiplayer/QueueModeTestScene.cs

@@ -61,6 +61,11 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("import beatmap", () =>
             {
                 beatmaps.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
+                Realm.Write(r =>
+                {
+                    foreach (var beatmapInfo in r.All<BeatmapInfo>())
+                        beatmapInfo.OnlineMD5Hash = beatmapInfo.MD5Hash;
+                });
                 importedSet = beatmaps.GetAllUsableBeatmapSets().First();
                 InitialBeatmap = importedSet.Beatmaps.First(b => b.Ruleset.OnlineID == 0);
                 OtherBeatmap = importedSet.Beatmaps.Last(b => b.Ruleset.OnlineID == 0);

osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableLoungeRoom.cs

@@ -13,6 +13,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Testing;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
 using osu.Game.Screens.OnlinePlay.Lounge;
@@ -30,7 +31,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Cached]
         protected readonly OverlayColourProvider ColourProvider = new OverlayColourProvider(OverlayColourScheme.Pink);
 
-        private DrawableLoungeRoom drawableRoom = null!;
+        private LoungeRoomPanel panel = null!;
         private SearchTextBox searchTextBox = null!;
 
         private readonly ManualResetEventSlim allowResponseCallback = new ManualResetEventSlim();
@@ -40,14 +41,14 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             var mockLounge = new Mock<IOnlinePlayLounge>();
             mockLounge
-                .Setup(l => l.Join(It.IsAny<Room>(), It.IsAny<string>(), It.IsAny<Action<Room>>(), It.IsAny<Action<string>>()))
-                .Callback<Room, string, Action<Room>, Action<string>>((_, _, _, d) =>
+                .Setup(l => l.Join(It.IsAny<Room>(), It.IsAny<string>(), It.IsAny<Action<Room>>(), It.IsAny<Action<string, Exception?>>()))
+                .Callback<Room, string, Action<Room>, Action<string, Exception?>>((_, _, _, d) =>
                 {
                     Task.Run(() =>
                     {
                         allowResponseCallback.Wait(10000);
                         allowResponseCallback.Reset();
-                        Schedule(() => d?.Invoke("Incorrect password"));
+                        Schedule(() => d?.Invoke("Incorrect password", new InvalidPasswordException()));
                     });
                 });
 
@@ -73,7 +74,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                             Width = 500,
                             Depth = float.MaxValue
                         },
-                        drawableRoom = new DrawableLoungeRoom(room)
+                        panel = new LoungeRoomPanel(room)
                         {
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,
@@ -87,16 +88,16 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestFocusViaKeyboardCommit()
         {
-            DrawableLoungeRoom.PasswordEntryPopover? popover = null;
+            LoungeRoomPanel.PasswordEntryPopover? popover = null;
 
             AddAssert("search textbox has focus", () => checkFocus(searchTextBox));
             AddStep("click room twice", () =>
             {
-                InputManager.MoveMouseTo(drawableRoom);
+                InputManager.MoveMouseTo(panel);
                 InputManager.Click(MouseButton.Left);
                 InputManager.Click(MouseButton.Left);
             });
-            AddUntilStep("wait for popover", () => (popover = InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().SingleOrDefault()) != null);
+            AddUntilStep("wait for popover", () => (popover = InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().SingleOrDefault()) != null);
 
             AddAssert("textbox has focus", () => checkFocus(popover.ChildrenOfType<OsuPasswordTextBox>().Single()));
 
@@ -122,16 +123,16 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestFocusViaMouseCommit()
         {
-            DrawableLoungeRoom.PasswordEntryPopover? popover = null;
+            LoungeRoomPanel.PasswordEntryPopover? popover = null;
 
             AddAssert("search textbox has focus", () => checkFocus(searchTextBox));
             AddStep("click room twice", () =>
             {
-                InputManager.MoveMouseTo(drawableRoom);
+                InputManager.MoveMouseTo(panel);
                 InputManager.Click(MouseButton.Left);
                 InputManager.Click(MouseButton.Left);
             });
-            AddUntilStep("wait for popover", () => (popover = InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().SingleOrDefault()) != null);
+            AddUntilStep("wait for popover", () => (popover = InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().SingleOrDefault()) != null);
 
             AddAssert("textbox has focus", () => checkFocus(popover.ChildrenOfType<OsuPasswordTextBox>().Single()));
 

osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoomPlaylist.cs

@@ -105,6 +105,19 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("no item selected", () => playlist.SelectedItem.Value == null);
         }
 
+        [Test]
+        public void TestMarkCompleted()
+        {
+            createPlaylist();
+            AddStep("mark some items as complete", () =>
+            {
+                playlist.Items[0].MarkCompleted();
+                playlist.Items[2].MarkCompleted();
+                playlist.Items[3].MarkCompleted();
+                playlist.Items[5].MarkCompleted();
+            });
+        }
+
         [Test]
         public void TestSelectable()
         {

osu.Game.Tests/Visual/Multiplayer/TestSceneHostOnlyQueueMode.cs

@@ -105,7 +105,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("select other beatmap", () => ((Screens.Select.SongSelect)CurrentSubScreen).FinaliseSelection(otherBeatmap = beatmap()));
 
             AddUntilStep("wait for return to match", () => CurrentSubScreen is MultiplayerMatchSubScreen);
-            AddUntilStep("selected item is new beatmap", () => (CurrentSubScreen as MultiplayerMatchSubScreen)?.SelectedItem.Value?.Beatmap.OnlineID == otherBeatmap.OnlineID);
+            AddUntilStep("selected item is new beatmap", () => Beatmap.Value.BeatmapInfo.OnlineID == otherBeatmap.OnlineID);
         }
 
         private void addItem(Func<BeatmapInfo> beatmap)

osu.Game.Tests/Visual/Multiplayer/TestSceneMatchStartControl.cs

@@ -101,15 +101,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [SetUpSteps]
         public void SetUpSteps()
         {
-            PlaylistItem item = null!;
-
             AddStep("reset state", () =>
             {
                 multiplayerClient.Invocations.Clear();
 
                 beatmapAvailability.Value = BeatmapAvailability.LocallyAvailable();
 
-                item = new PlaylistItem(Beatmap.Value.BeatmapInfo)
+                PlaylistItem item = new PlaylistItem(Beatmap.Value.BeatmapInfo)
                 {
                     RulesetID = Beatmap.Value.BeatmapInfo.Ruleset.OnlineID
                 };
@@ -127,7 +125,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
                 multiplayerRoom = new MultiplayerRoom(0)
                 {
-                    Playlist = { TestMultiplayerClient.CreateMultiplayerPlaylistItem(item) },
+                    Playlist = { new MultiplayerPlaylistItem(item) },
                     Users = { localUser },
                     Host = localUser,
                 };
@@ -139,8 +137,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Size = new Vector2(250, 50),
-                    SelectedItem = new Bindable<PlaylistItem?>(item)
+                    Size = new Vector2(250, 50)
                 };
             });
         }

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs

@@ -81,6 +81,11 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("import beatmap", () =>
             {
                 beatmaps.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
+                Realm.Write(r =>
+                {
+                    foreach (var beatmapInfo in r.All<BeatmapInfo>())
+                        beatmapInfo.OnlineMD5Hash = beatmapInfo.MD5Hash;
+                });
                 importedSet = beatmaps.GetAllUsableBeatmapSets().First();
             });
 
@@ -269,7 +274,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             });
 
             AddStep("refresh rooms", () => this.ChildrenOfType<LoungeSubScreen>().Single().UpdateFilter());
-            AddUntilStep("wait for room", () => this.ChildrenOfType<DrawableRoom>().Any());
+            AddUntilStep("wait for room", () => this.ChildrenOfType<RoomPanel>().Any());
 
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("join room and immediately exit select", () =>
@@ -298,7 +303,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             });
 
             AddStep("refresh rooms", () => this.ChildrenOfType<LoungeSubScreen>().Single().UpdateFilter());
-            AddUntilStep("wait for room", () => this.ChildrenOfType<DrawableRoom>().Any());
+            AddUntilStep("wait for room", () => this.ChildrenOfType<RoomPanel>().Any());
 
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("join room", () => InputManager.Key(Key.Enter));
@@ -349,13 +354,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
             });
 
             AddStep("refresh rooms", () => this.ChildrenOfType<LoungeSubScreen>().Single().UpdateFilter());
-            AddUntilStep("wait for room", () => this.ChildrenOfType<DrawableRoom>().Any());
+            AddUntilStep("wait for room", () => this.ChildrenOfType<RoomPanel>().Any());
 
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("join room", () => InputManager.Key(Key.Enter));
 
-            DrawableLoungeRoom.PasswordEntryPopover? passwordEntryPopover = null;
-            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().FirstOrDefault()) != null);
+            LoungeRoomPanel.PasswordEntryPopover? passwordEntryPopover = null;
+            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().FirstOrDefault()) != null);
             AddStep("enter password in text box", () => passwordEntryPopover.ChildrenOfType<TextBox>().First().Text = "password");
             AddStep("press join room button", () => passwordEntryPopover.ChildrenOfType<OsuButton>().First().TriggerClick());
 
@@ -438,7 +443,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("Enter song select", () =>
             {
                 var currentSubScreen = ((Screens.OnlinePlay.Multiplayer.Multiplayer)multiplayerComponents.CurrentScreen).CurrentSubScreen;
-                ((MultiplayerMatchSubScreen)currentSubScreen).OpenSongSelection(item);
+                ((MultiplayerMatchSubScreen)currentSubScreen).ShowSongSelect(item);
             });
 
             AddUntilStep("wait for song select", () => this.ChildrenOfType<MultiplayerMatchSongSelect>().FirstOrDefault()?.BeatmapSetsLoaded == true);
@@ -479,7 +484,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("Enter song select", () =>
             {
                 var currentSubScreen = ((Screens.OnlinePlay.Multiplayer.Multiplayer)multiplayerComponents.CurrentScreen).CurrentSubScreen;
-                ((MultiplayerMatchSubScreen)currentSubScreen).OpenSongSelection(item);
+                ((MultiplayerMatchSubScreen)currentSubScreen).ShowSongSelect(item);
             });
 
             AddUntilStep("wait for song select", () => this.ChildrenOfType<MultiplayerMatchSongSelect>().FirstOrDefault()?.BeatmapSetsLoaded == true);
@@ -520,7 +525,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("Enter song select", () =>
             {
                 var currentSubScreen = ((Screens.OnlinePlay.Multiplayer.Multiplayer)multiplayerComponents.CurrentScreen).CurrentSubScreen;
-                ((MultiplayerMatchSubScreen)currentSubScreen).OpenSongSelection(item);
+                ((MultiplayerMatchSubScreen)currentSubScreen).ShowSongSelect(item);
             });
 
             AddUntilStep("wait for song select", () => this.ChildrenOfType<MultiplayerMatchSongSelect>().FirstOrDefault()?.BeatmapSetsLoaded == true);
@@ -652,7 +657,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("invoke on back button", () => multiplayerComponents.OnBackButton());
 
-            AddAssert("mod overlay is hidden", () => this.ChildrenOfType<RoomSubScreen>().Single().UserModsSelectOverlay.State.Value == Visibility.Hidden);
+            AddAssert("mod overlay is hidden", () => this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single().State.Value == Visibility.Hidden);
 
             AddAssert("dialog overlay is hidden", () => DialogOverlay.State.Value == Visibility.Hidden);
 
@@ -802,7 +807,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             });
 
             AddStep("refresh rooms", () => this.ChildrenOfType<LoungeSubScreen>().Single().UpdateFilter());
-            AddUntilStep("wait for room", () => this.ChildrenOfType<DrawableRoom>().Any());
+            AddUntilStep("wait for room", () => this.ChildrenOfType<RoomPanel>().Any());
             AddStep("select room", () => InputManager.Key(Key.Down));
 
             AddStep("disable polling", () => this.ChildrenOfType<LoungeListingPoller>().Single().TimeBetweenPolls.Value = 0);
@@ -823,11 +828,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddUntilStep("wait for room open", () => this.ChildrenOfType<MultiplayerMatchSubScreen>().FirstOrDefault()?.IsLoaded == true);
             AddUntilStep("wait for join", () => multiplayerClient.RoomJoined);
 
-            AddAssert("local room has correct settings", () =>
-            {
-                var localRoom = this.ChildrenOfType<MultiplayerMatchSubScreen>().Single().Room;
-                return localRoom.Name == multiplayerClient.ServerSideRooms[0].Name && localRoom.Playlist.Single().ID == 2;
-            });
+            AddAssert("local room has correct name", () => this.ChildrenOfType<MultiplayerRoomPanel>().Single().Room.Name, () => Is.EqualTo(multiplayerClient.ServerSideRooms[0].Name));
+            AddAssert("local room has correct playlist", () => this.ChildrenOfType<MultiplayerQueueList>().Single().Items.Single().ID, () => Is.EqualTo(2));
         }
 
         [Test]
@@ -924,7 +926,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             enterGameplay();
             AddStep("join other user", () => multiplayerClient.AddUser(new APIUser { Id = 1234 }));
-            AddStep("add item as other user", () => multiplayerClient.AddUserPlaylistItem(1234, TestMultiplayerClient.CreateMultiplayerPlaylistItem(
+            AddStep("add item as other user", () => multiplayerClient.AddUserPlaylistItem(1234, new MultiplayerPlaylistItem(
                 new PlaylistItem(beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First(b => b.Ruleset.OnlineID == 0)).BeatmapInfo)
                 {
                     RulesetID = new OsuRuleset().RulesetInfo.OnlineID,
@@ -956,7 +958,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             enterGameplay();
 
             AddStep("join other user", () => multiplayerClient.AddUser(new APIUser { Id = 1234 }));
-            AddStep("add item as other user", () => multiplayerClient.AddUserPlaylistItem(1234, TestMultiplayerClient.CreateMultiplayerPlaylistItem(
+            AddStep("add item as other user", () => multiplayerClient.AddUserPlaylistItem(1234, new MultiplayerPlaylistItem(
                 new PlaylistItem(beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First(b => b.Ruleset.OnlineID == 0)).BeatmapInfo)
                 {
                     RulesetID = new OsuRuleset().RulesetInfo.OnlineID,
@@ -1054,6 +1056,45 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("hidden is selected", () => SelectedMods.Value, () => Has.One.TypeOf(typeof(OsuModHidden)));
         }
 
+        [FlakyTest]
+        [Test]
+        public void TestGlobalBeatmapDoesNotChangeAtResults()
+        {
+            createRoom(() => new Room
+            {
+                Name = "Test Room",
+                QueueMode = QueueMode.AllPlayers,
+                Playlist =
+                [
+                    new PlaylistItem(beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First(b => b.Ruleset.OnlineID == 0)).BeatmapInfo)
+                    {
+                        RulesetID = new OsuRuleset().RulesetInfo.OnlineID,
+                        AllowedMods = new[] { new APIMod { Acronym = "HD" } },
+                    },
+                    new PlaylistItem(beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First(b => b.Ruleset.OnlineID == 1)).BeatmapInfo)
+                    {
+                        RulesetID = new TaikoRuleset().RulesetInfo.OnlineID,
+                        AllowedMods = new[] { new APIMod { Acronym = "HD" } },
+                    },
+                ]
+            });
+
+            enterGameplay();
+
+            // Gameplay runs in real-time, so we need to incrementally check if gameplay has finished in order to not time out.
+            for (double i = 1000; i < TestResources.QUICK_BEATMAP_LENGTH; i += 1000)
+            {
+                double time = i;
+                AddUntilStep($"wait for time > {i}", () => this.ChildrenOfType<GameplayClockContainer>().SingleOrDefault()?.CurrentTime > time);
+            }
+
+            AddUntilStep("wait for results", () => multiplayerComponents.CurrentScreen is ResultsScreen);
+
+            AddAssert("global beatmap still matches first playlist item", () => Beatmap.Value.BeatmapInfo.OnlineID, () => Is.EqualTo(multiplayerClient.ClientRoom!.Playlist[0].BeatmapID));
+            AddStep("return to match", () => multiplayerComponents.Exit());
+            AddAssert("global beatmap matches second playlist item", () => Beatmap.Value.BeatmapInfo.OnlineID, () => Is.EqualTo(multiplayerClient.ClientRoom!.Playlist[1].BeatmapID));
+        }
+
         private void enterGameplay()
         {
             pressReadyButton();

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerLoungeSubScreen.cs

@@ -45,7 +45,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("attempt join room", () => InputManager.Key(Key.Enter));
 
-            AddUntilStep("password prompt appeared", () => InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().Any());
+            AddUntilStep("password prompt appeared", () => InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().Any());
 
             AddAssert("textbox has focus", () => InputManager.FocusedDrawable is OsuPasswordTextBox);
 
@@ -53,7 +53,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("textbox lost focus", () => InputManager.FocusedDrawable is SearchTextBox);
 
             AddStep("hit escape", () => InputManager.Key(Key.Escape));
-            AddUntilStep("password prompt hidden", () => !InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().Any());
+            AddUntilStep("password prompt hidden", () => !InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().Any());
 
             AddAssert("room not joined", () => !MultiplayerClient.RoomJoined);
         }
@@ -65,9 +65,9 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("attempt join room", () => InputManager.Key(Key.Enter));
 
-            AddUntilStep("password prompt appeared", () => InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().Any());
+            AddUntilStep("password prompt appeared", () => InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().Any());
             AddStep("exit screen", () => Stack.Exit());
-            AddUntilStep("password prompt hidden", () => !InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().Any());
+            AddUntilStep("password prompt hidden", () => !InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().Any());
 
             AddAssert("room not joined", () => !MultiplayerClient.RoomJoined);
         }
@@ -75,12 +75,12 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestJoinRoomWithIncorrectPasswordViaButton()
         {
-            DrawableLoungeRoom.PasswordEntryPopover? passwordEntryPopover = null;
+            LoungeRoomPanel.PasswordEntryPopover? passwordEntryPopover = null;
 
             createRooms(GenerateRooms(1, withPassword: true));
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("attempt join room", () => InputManager.Key(Key.Enter));
-            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().FirstOrDefault()) != null);
+            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().FirstOrDefault()) != null);
             AddStep("enter password in text box", () => passwordEntryPopover.ChildrenOfType<TextBox>().First().Text = "wrong");
             AddStep("press join room button", () => passwordEntryPopover.ChildrenOfType<OsuButton>().First().TriggerClick());
 
@@ -94,12 +94,12 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestJoinRoomWithIncorrectPasswordViaEnter()
         {
-            DrawableLoungeRoom.PasswordEntryPopover? passwordEntryPopover = null;
+            LoungeRoomPanel.PasswordEntryPopover? passwordEntryPopover = null;
 
             createRooms(GenerateRooms(1, withPassword: true));
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("attempt join room", () => InputManager.Key(Key.Enter));
-            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().FirstOrDefault()) != null);
+            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().FirstOrDefault()) != null);
             AddStep("enter password in text box", () => passwordEntryPopover.ChildrenOfType<TextBox>().First().Text = "wrong");
             AddStep("press enter", () => InputManager.Key(Key.Enter));
 
@@ -113,12 +113,12 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestJoinRoomWithCorrectPassword()
         {
-            DrawableLoungeRoom.PasswordEntryPopover? passwordEntryPopover = null;
+            LoungeRoomPanel.PasswordEntryPopover? passwordEntryPopover = null;
 
             createRooms(GenerateRooms(1, withPassword: true));
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("attempt join room", () => InputManager.Key(Key.Enter));
-            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().FirstOrDefault()) != null);
+            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().FirstOrDefault()) != null);
             AddStep("enter password in text box", () => passwordEntryPopover.ChildrenOfType<TextBox>().First().Text = "password");
             AddStep("press join room button", () => passwordEntryPopover.ChildrenOfType<OsuButton>().First().TriggerClick());
 
@@ -128,12 +128,12 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestJoinRoomWithPasswordViaKeyboardOnly()
         {
-            DrawableLoungeRoom.PasswordEntryPopover? passwordEntryPopover = null;
+            LoungeRoomPanel.PasswordEntryPopover? passwordEntryPopover = null;
 
             createRooms(GenerateRooms(1, withPassword: true));
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("attempt join room", () => InputManager.Key(Key.Enter));
-            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().FirstOrDefault()) != null);
+            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().FirstOrDefault()) != null);
             AddStep("enter password in text box", () => passwordEntryPopover.ChildrenOfType<TextBox>().First().Text = "password");
             AddStep("press enter", () => InputManager.Key(Key.Enter));
 

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchFooter.cs

@@ -1,11 +1,11 @@
 // 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.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
-using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay;
+using osu.Game.Screens.OnlinePlay.Multiplayer;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Match;
 
 namespace osu.Game.Tests.Visual.Multiplayer
@@ -18,22 +18,33 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("create footer", () =>
             {
-                Child = new PopoverContainer
+                MultiplayerBeatmapAvailabilityTracker tracker = new MultiplayerBeatmapAvailabilityTracker();
+
+                Child = new DependencyProvidingContainer
                 {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.Both,
-                    Child = new Container
-                    {
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        RelativeSizeAxes = Axes.X,
-                        Height = 50,
-                        Child = new MultiplayerMatchFooter
+                    CachedDependencies =
+                    [
+                        (typeof(OnlinePlayBeatmapAvailabilityTracker), tracker)
+                    ],
+                    Children =
+                    [
+                        tracker,
+                        new PopoverContainer
                         {
-                            SelectedItem = new Bindable<PlaylistItem?>()
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            RelativeSizeAxes = Axes.Both,
+                            Child = new Container
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                RelativeSizeAxes = Axes.X,
+                                Height = 50,
+                                Child = new MultiplayerMatchFooter()
+                            }
                         }
-                    }
+                    ]
                 };
             });
         }

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs

@@ -1,12 +1,14 @@
 // 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.Audio;
 using osu.Framework.Extensions;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Platform;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
@@ -185,7 +187,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddUntilStep("mod select contents loaded",
                 () => this.ChildrenOfType<ModColumn>().Any() && this.ChildrenOfType<ModColumn>().All(col => col.IsLoaded && col.ItemsLoaded));
             AddUntilStep("mod select contains only double time mod",
-                () => this.ChildrenOfType<RoomSubScreen>().Single().UserModsSelectOverlay
+                () => this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single()
                           .ChildrenOfType<ModPanel>()
                           .SingleOrDefault(panel => panel.Visible)?.Mod is OsuModDoubleTime);
         }
@@ -211,7 +213,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("press toggle mod select key", () => InputManager.Key(Key.F1));
 
-            AddUntilStep("mod select shown", () => this.ChildrenOfType<RoomSubScreen>().Single().UserModsSelectOverlay.State.Value == Visibility.Visible);
+            AddUntilStep("mod select shown", () => this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single().State.Value == Visibility.Visible);
         }
 
         [Test]
@@ -234,7 +236,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("press toggle mod select key", () => InputManager.Key(Key.F1));
 
             AddWaitStep("wait some", 3);
-            AddAssert("mod select not shown", () => this.ChildrenOfType<RoomSubScreen>().Single().UserModsSelectOverlay.State.Value == Visibility.Hidden);
+            AddAssert("mod select not shown", () => this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single().State.Value == Visibility.Hidden);
         }
 
         [Test]
@@ -306,10 +308,10 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("mod select shows unranked", () => this.ChildrenOfType<RankingInformationDisplay>().Single().Ranked.Value == false);
             AddAssert("score multiplier = 1.20", () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value, () => Is.EqualTo(1.2).Within(0.01));
 
-            AddStep("select flashlight", () => screen.UserModsSelectOverlay.ChildrenOfType<ModPanel>().Single(m => m.Mod is ModFlashlight).TriggerClick());
+            AddStep("select flashlight", () => this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single().ChildrenOfType<ModPanel>().Single(m => m.Mod is ModFlashlight).TriggerClick());
             AddAssert("score multiplier = 1.35", () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value, () => Is.EqualTo(1.35).Within(0.01));
 
-            AddStep("change flashlight setting", () => ((OsuModFlashlight)screen.UserModsSelectOverlay.SelectedMods.Value.Single()).FollowDelay.Value = 1200);
+            AddStep("change flashlight setting", () => ((OsuModFlashlight)this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single().SelectedMods.Value.Single()).FollowDelay.Value = 1200);
             AddAssert("score multiplier = 1.20", () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value, () => Is.EqualTo(1.2).Within(0.01));
         }
 
@@ -330,10 +332,123 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddUntilStep("wait for join", () => RoomJoined);
 
-            AddUntilStep("button visible", () => this.ChildrenOfType<DrawableMatchRoom>().Single().ChangeSettingsButton?.Alpha, () => Is.GreaterThan(0));
+            AddUntilStep("button visible", () => this.ChildrenOfType<MultiplayerRoomPanel>().Single().ChangeSettingsButton.Alpha, () => Is.GreaterThan(0));
             AddStep("join other user", void () => MultiplayerClient.AddUser(new APIUser { Id = PLAYER_1_ID }));
             AddStep("make other user host", () => MultiplayerClient.TransferHost(PLAYER_1_ID));
-            AddAssert("button hidden", () => this.ChildrenOfType<DrawableMatchRoom>().Single().ChangeSettingsButton?.Alpha, () => Is.EqualTo(0));
+            AddAssert("button hidden", () => this.ChildrenOfType<MultiplayerRoomPanel>().Single().ChangeSettingsButton.Alpha, () => Is.EqualTo(0));
+        }
+
+        [Test]
+        public void TestUserModSelectUpdatesWhenNotVisible()
+        {
+            AddStep("add playlist item", () =>
+            {
+                room.Playlist =
+                [
+                    new PlaylistItem(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo)
+                    {
+                        RulesetID = new OsuRuleset().RulesetInfo.OnlineID,
+                        AllowedMods = [new APIMod(new OsuModFlashlight())]
+                    }
+                ];
+            });
+
+            ClickButtonWhenEnabled<MultiplayerMatchSettingsOverlay.CreateOrUpdateButton>();
+            AddUntilStep("wait for join", () => RoomJoined);
+
+            // 1. Open the mod select overlay and enable flashlight
+
+            ClickButtonWhenEnabled<UserModSelectButton>();
+            AddUntilStep("mod select contents loaded", () => this.ChildrenOfType<ModColumn>().Any() && this.ChildrenOfType<ModColumn>().All(col => col.IsLoaded && col.ItemsLoaded));
+            AddStep("click flashlight panel", () =>
+            {
+                ModPanel panel = this.ChildrenOfType<ModPanel>().Single(p => p.Mod is OsuModFlashlight);
+                InputManager.MoveMouseTo(panel);
+                InputManager.Click(MouseButton.Left);
+            });
+            AddUntilStep("flashlight mod enabled", () => MultiplayerClient.ClientRoom!.Users[0].Mods.Any());
+
+            // 2. Close the mod select overlay, edit the playlist to disable allowed mods, and then edit it again to re-enable allowed mods.
+
+            AddStep("close mod select overlay", () => this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single().Hide());
+            AddUntilStep("mod select overlay not present", () => !this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single().IsPresent);
+            AddStep("disable allowed mods", () => MultiplayerClient.EditPlaylistItem(new MultiplayerPlaylistItem(new PlaylistItem(MultiplayerClient.ServerRoom!.Playlist[0])
+            {
+                AllowedMods = []
+            })));
+            // This would normally be done as part of the above operation with an actual server.
+            AddStep("disable user mods", () => MultiplayerClient.ChangeUserMods(API.LocalUser.Value.OnlineID, Array.Empty<APIMod>()));
+            AddUntilStep("flashlight mod disabled", () => !MultiplayerClient.ClientRoom!.Users[0].Mods.Any());
+            AddStep("re-enable allowed mods", () => MultiplayerClient.EditPlaylistItem(new MultiplayerPlaylistItem(new PlaylistItem(MultiplayerClient.ServerRoom!.Playlist[0])
+            {
+                AllowedMods = [new APIMod(new OsuModFlashlight())]
+            })));
+            AddAssert("flashlight mod still disabled", () => !MultiplayerClient.ClientRoom!.Users[0].Mods.Any());
+
+            // 3. Open the mod select overlay, check that the flashlight mod panel is deactivated.
+
+            ClickButtonWhenEnabled<UserModSelectButton>();
+            AddUntilStep("mod select contents loaded", () => this.ChildrenOfType<ModColumn>().Any() && this.ChildrenOfType<ModColumn>().All(col => col.IsLoaded && col.ItemsLoaded));
+            AddAssert("flashlight mod still disabled", () => !MultiplayerClient.ClientRoom!.Users[0].Mods.Any());
+            AddAssert("flashlight mod panel not activated", () => !this.ChildrenOfType<ModPanel>().Single(p => p.Mod is OsuModFlashlight).Active.Value);
+        }
+
+        [Test]
+        public void TestStartCountdown()
+        {
+            AddStep("set playlist", () =>
+            {
+                room.Playlist =
+                [
+                    new PlaylistItem(beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First()).BeatmapInfo)
+                    {
+                        RulesetID = new OsuRuleset().RulesetInfo.OnlineID
+                    }
+                ];
+            });
+
+            ClickButtonWhenEnabled<MultiplayerMatchSettingsOverlay.CreateOrUpdateButton>();
+
+            AddUntilStep("wait for room join", () => RoomJoined);
+
+            AddStep("click countdown button", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<MultiplayerCountdownButton>().Single());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddStep("start a countdown", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<Popover>().Single().ChildrenOfType<Button>().First());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddUntilStep("countdown started", () => MultiplayerClient.ServerRoom!.ActiveCountdowns.Any());
+        }
+
+        [Test]
+        public void TestSettingsRemainsOpenOnRoomUpdate()
+        {
+            AddStep("set playlist", () =>
+            {
+                room.Playlist =
+                [
+                    new PlaylistItem(beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First()).BeatmapInfo)
+                    {
+                        RulesetID = new OsuRuleset().RulesetInfo.OnlineID
+                    }
+                ];
+            });
+
+            ClickButtonWhenEnabled<MultiplayerMatchSettingsOverlay.CreateOrUpdateButton>();
+
+            AddUntilStep("wait for room join", () => RoomJoined);
+
+            AddStep("open settings", () => this.ChildrenOfType<MultiplayerMatchSettingsOverlay>().Single().Show());
+            AddAssert("settings opened", () => this.ChildrenOfType<MultiplayerMatchSettingsOverlay>().Single().State.Value, () => Is.EqualTo(Visibility.Visible));
+
+            AddStep("trigger room update", () => MultiplayerClient.AddPlaylistItem(MultiplayerClient.ServerRoom!.Playlist[0].Clone()));
+            AddAssert("settings still open", () => this.ChildrenOfType<MultiplayerMatchSettingsOverlay>().Single().State.Value, () => Is.EqualTo(Visibility.Visible));
         }
 
         private partial class TestMultiplayerMatchSubScreen : MultiplayerMatchSubScreen

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerPlaylist.cs

@@ -6,7 +6,6 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
-using osu.Framework.Bindables;
 using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Platform;
@@ -32,7 +31,6 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private BeatmapManager beatmaps = null!;
         private BeatmapSetInfo importedSet = null!;
         private BeatmapInfo importedBeatmap = null!;
-        private Room room = null!;
 
         [BackgroundDependencyLoader]
         private void load(GameHost host, AudioManager audio)
@@ -47,19 +45,17 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             base.SetUpSteps();
 
-            AddStep("create room", () => room = CreateDefaultRoom());
-            AddStep("join room", () => JoinRoom(room));
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom()));
             WaitForJoined();
 
             AddStep("create list", () =>
             {
-                Child = list = new MultiplayerPlaylist(room)
+                Child = list = new MultiplayerPlaylist
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.Both,
-                    Size = new Vector2(0.4f, 0.8f),
-                    SelectedItem = new Bindable<PlaylistItem?>()
+                    Size = new Vector2(0.4f, 0.8f)
                 };
             });
 
@@ -158,37 +154,36 @@ namespace osu.Game.Tests.Visual.Multiplayer
             assertQueueTabCount(0);
         }
 
-        [Ignore("Expired items are initially removed from the room.")]
         [Test]
         public void TestJoinRoomWithMixedItemsAddedInCorrectLists()
         {
             AddStep("leave room", () => MultiplayerClient.LeaveRoom());
             AddUntilStep("wait for room part", () => !RoomJoined);
 
-            AddStep("join room with items", () =>
+            AddStep("join room with expired items", () =>
             {
-                API.Queue(new CreateRoomRequest(new Room
-                {
-                    Name = "test name",
-                    Playlist =
-                    [
-                        new PlaylistItem(new TestBeatmap(Ruleset.Value).BeatmapInfo)
-                        {
-                            RulesetID = Ruleset.Value.OnlineID
-                        },
-                        new PlaylistItem(new TestBeatmap(Ruleset.Value).BeatmapInfo)
-                        {
-                            RulesetID = Ruleset.Value.OnlineID,
-                            Expired = true
-                        }
-                    ]
-                }));
+                Room room = CreateDefaultRoom();
+                room.Playlist =
+                [
+                    new PlaylistItem(new TestBeatmap(Ruleset.Value).BeatmapInfo)
+                    {
+                        RulesetID = Ruleset.Value.OnlineID
+                    },
+                    new PlaylistItem(new TestBeatmap(Ruleset.Value).BeatmapInfo)
+                    {
+                        RulesetID = Ruleset.Value.OnlineID,
+                        Expired = true
+                    }
+                ];
+
+                JoinRoom(room);
             });
 
-            AddUntilStep("wait for room join", () => RoomJoined);
+            WaitForJoined();
 
-            assertItemInQueueListStep(1, 0);
-            assertItemInHistoryListStep(2, 0);
+            // IDs are offset by 1 because we've joined two rooms in this test.
+            assertItemInQueueListStep(2, 0);
+            assertItemInHistoryListStep(3, 0);
         }
 
         [Test]
@@ -220,7 +215,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         /// </summary>
         private void addItemStep(bool expired = false, int? userId = null) => AddStep("add item", () =>
         {
-            MultiplayerClient.AddUserPlaylistItem(userId ?? API.LocalUser.Value.OnlineID, TestMultiplayerClient.CreateMultiplayerPlaylistItem(new PlaylistItem(importedBeatmap)
+            MultiplayerClient.AddUserPlaylistItem(userId ?? API.LocalUser.Value.OnlineID, new MultiplayerPlaylistItem(new PlaylistItem(importedBeatmap)
             {
                 Expired = expired,
                 PlayedAt = DateTimeOffset.Now

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerQueueList.cs

@@ -49,13 +49,15 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("create playlist", () =>
             {
-                Child = playlist = new MultiplayerQueueList(room)
+                Child = playlist = new MultiplayerQueueList
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Size = new Vector2(500, 300),
+                    Size = new Vector2(500, 300)
                 };
 
+                playlist.Items.ReplaceRange(0, playlist.Items.Count, MultiplayerClient.ClientAPIRoom!.Playlist);
+
                 MultiplayerClient.ClientAPIRoom!.PropertyChanged += (_, e) =>
                 {
                     if (e.PropertyName == nameof(Room.Playlist))
@@ -132,13 +134,25 @@ namespace osu.Game.Tests.Visual.Multiplayer
             assertDeleteButtonVisibility(1, false);
         }
 
+        [Test]
+        public void TestChangeExistingItem()
+        {
+            AddStep("change beatmap", () => MultiplayerClient.EditPlaylistItem(new MultiplayerPlaylistItem
+            {
+                ID = playlist.Items[0].ID,
+                BeatmapID = 1337
+            }).WaitSafely());
+
+            AddUntilStep("first playlist item has new beatmap", () => playlist.Items[0].Beatmap.OnlineID, () => Is.EqualTo(1337));
+        }
+
         private void addPlaylistItem(Func<int> userId)
         {
             long itemId = -1;
 
             AddStep("add playlist item", () =>
             {
-                MultiplayerPlaylistItem item = TestMultiplayerClient.CreateMultiplayerPlaylistItem(new PlaylistItem(importedBeatmap));
+                MultiplayerPlaylistItem item = new MultiplayerPlaylistItem(new PlaylistItem(importedBeatmap));
 
                 MultiplayerClient.AddUserPlaylistItem(userId(), item).WaitSafely();
 

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerSpectateButton.cs

@@ -5,7 +5,6 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
-using osu.Framework.Bindables;
 using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -18,6 +17,8 @@ using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
 using osu.Game.Rulesets;
+using osu.Game.Screens.OnlinePlay;
+using osu.Game.Screens.OnlinePlay.Multiplayer;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Match;
 using osu.Game.Tests.Resources;
 using osuTK;
@@ -53,36 +54,46 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("create button", () =>
             {
-                AvailabilityTracker.SelectedItem.Value = room.Playlist.First();
-
                 importedSet = beatmaps.GetAllUsableBeatmapSets().First();
                 Beatmap.Value = beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First());
 
-                Child = new PopoverContainer
+                MultiplayerBeatmapAvailabilityTracker tracker = new MultiplayerBeatmapAvailabilityTracker();
+
+                Child = new DependencyProvidingContainer
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Child = new FillFlowContainer
-                    {
-                        AutoSizeAxes = Axes.Both,
-                        Direction = FillDirection.Vertical,
-                        Children = new Drawable[]
+                    CachedDependencies =
+                    [
+                        (typeof(OnlinePlayBeatmapAvailabilityTracker), tracker)
+                    ],
+                    Children =
+                    [
+                        tracker,
+                        new PopoverContainer
                         {
-                            spectateButton = new MultiplayerSpectateButton
+                            RelativeSizeAxes = Axes.Both,
+                            Child = new FillFlowContainer
                             {
-                                Anchor = Anchor.Centre,
-                                Origin = Anchor.Centre,
-                                Size = new Vector2(200, 50),
-                                SelectedItem = new Bindable<PlaylistItem?>(room.Playlist.First())
-                            },
-                            startControl = new MatchStartControl
-                            {
-                                Anchor = Anchor.Centre,
-                                Origin = Anchor.Centre,
-                                Size = new Vector2(200, 50),
-                                SelectedItem = new Bindable<PlaylistItem?>(room.Playlist.First())
+                                AutoSizeAxes = Axes.Both,
+                                Direction = FillDirection.Vertical,
+                                Children = new Drawable[]
+                                {
+                                    spectateButton = new MultiplayerSpectateButton
+                                    {
+                                        Anchor = Anchor.Centre,
+                                        Origin = Anchor.Centre,
+                                        Size = new Vector2(200, 50)
+                                    },
+                                    startControl = new MatchStartControl
+                                    {
+                                        Anchor = Anchor.Centre,
+                                        Origin = Anchor.Centre,
+                                        Size = new Vector2(200, 50)
+                                    }
+                                }
                             }
                         }
-                    }
+                    ]
                 };
             });
         }

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerUserModDisplay.cs

@@ -0,0 +1,47 @@
+// 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.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Testing;
+using osu.Game.Online.API;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.UI;
+using osu.Game.Screens.OnlinePlay.Multiplayer;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public partial class TestSceneMultiplayerUserModDisplay : MultiplayerTestScene
+    {
+        private MultiplayerUserModDisplay modDisplay = null!;
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom()));
+            WaitForJoined();
+
+            AddStep("add display", () => Child = modDisplay = new MultiplayerUserModDisplay
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre
+            });
+        }
+
+        [Test]
+        public void TestChangeMods()
+        {
+            AddStep("set DT", () => MultiplayerClient.ChangeUserMods([new OsuModDoubleTime()]).WaitSafely());
+            AddUntilStep("mod displayed", () => modDisplay.ChildrenOfType<ModIcon>().Count() == 1);
+
+            AddStep("set DT, HR", () => MultiplayerClient.ChangeUserMods([new OsuModDoubleTime(), new OsuModHardRock()]).WaitSafely());
+            AddUntilStep("mods displayed", () => modDisplay.ChildrenOfType<ModIcon>().Count() == 2);
+
+            AddStep("set no mods", () => MultiplayerClient.ChangeUserMods(Enumerable.Empty<APIMod>()).WaitSafely());
+            AddUntilStep("no mods displayed", () => !modDisplay.ChildrenOfType<ModIcon>().Any());
+        }
+    }
+}

osu.Game.Tests/Visual/Multiplayer/TestScenePlaylistsSongSelect.cs

@@ -6,8 +6,12 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Platform;
 using osu.Framework.Screens;
+using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
@@ -16,10 +20,12 @@ using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Screens.OnlinePlay;
 using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.OnlinePlay.Playlists;
 using osu.Game.Tests.Resources;
 using osu.Game.Tests.Visual.OnlinePlay;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
@@ -153,10 +159,40 @@ namespace osu.Game.Tests.Visual.Multiplayer
             });
         }
 
+        [Test]
+        public void TestFreeModSelectionDisable()
+        {
+            FooterButtonFreeMods freeMods = null!;
+
+            AddAssert("freestyle enabled", () => songSelect.Freestyle.Value, () => Is.True);
+            AddStep("click icon in free mods button", () =>
+            {
+                freeMods = this.ChildrenOfType<FooterButtonFreeMods>().Single();
+                InputManager.MoveMouseTo(freeMods.ChildrenOfType<SpriteIcon>().Single());
+                InputManager.Click(MouseButton.Left);
+            });
+            AddAssert("mod select not visible", () => this.ChildrenOfType<FreeModSelectOverlay>().Single().State.Value, () => Is.EqualTo(Visibility.Hidden));
+
+            AddStep("toggle freestyle off", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<FooterButtonFreestyle>().Single());
+                InputManager.Click(MouseButton.Left);
+            });
+            AddAssert("freestyle disabled", () => songSelect.Freestyle.Value, () => Is.False);
+            AddStep("click icon in free mods button", () =>
+            {
+                InputManager.MoveMouseTo(freeMods.ChildrenOfType<SpriteIcon>().Single());
+                InputManager.Click(MouseButton.Left);
+            });
+            AddAssert("mod select visible", () => this.ChildrenOfType<FreeModSelectOverlay>().Single().State.Value, () => Is.EqualTo(Visibility.Visible));
+        }
+
         private partial class TestPlaylistsSongSelect : PlaylistsSongSelect
         {
             public new MatchBeatmapDetailArea BeatmapDetails => (MatchBeatmapDetailArea)base.BeatmapDetails;
 
+            public new IBindable<bool> Freestyle => base.Freestyle;
+
             public TestPlaylistsSongSelect(Room room)
                 : base(room)
             {

osu.Game.Tests/Visual/Multiplayer/TestSceneRoomListing.cs

@@ -11,7 +11,6 @@ using osu.Framework.Testing;
 using osu.Game.Online.Rooms;
 using osu.Game.Rulesets.Catch;
 using osu.Game.Rulesets.Osu;
-using osu.Game.Rulesets.Taiko;
 using osu.Game.Screens.OnlinePlay.Lounge;
 using osu.Game.Screens.OnlinePlay.Lounge.Components;
 using osu.Game.Tests.Visual.OnlinePlay;
@@ -199,25 +198,9 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("add rooms", () => rooms.AddRange(GenerateRooms(3, withPassword: true)));
         }
 
-        [Test]
-        public void TestFreestyleBypassesRulesetFilter()
-        {
-            AddStep("apply taiko filter", () => container.Filter.Value = new FilterCriteria { Ruleset = new TaikoRuleset().RulesetInfo });
-
-            AddStep("add osu + freestyle room", () =>
-            {
-                var room = GenerateRooms(1, new OsuRuleset().RulesetInfo)[0];
-                room.Playlist[0].Freestyle = true;
-                room.CurrentPlaylistItem = room.Playlist[0];
-                rooms.Add(room);
-            });
-
-            AddAssert("room visible", () => container.DrawableRooms.Any());
-        }
-
         private bool checkRoomSelected(Room? room) => selectedRoom.Value == room;
 
         private Room? getRoomInFlow(int index) =>
-            (container.ChildrenOfType<FillFlowContainer<DrawableLoungeRoom>>().First().FlowingChildren.ElementAt(index) as DrawableRoom)?.Room;
+            (container.ChildrenOfType<FillFlowContainer<LoungeRoomPanel>>().First().FlowingChildren.ElementAt(index) as RoomPanel)?.Room;
     }
 }

osu.Game.Tests/Visual/Multiplayer/TestSceneRoomPanel.cs

@@ -18,13 +18,13 @@ using osu.Game.Overlays;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.OnlinePlay.Lounge;
 using osu.Game.Screens.OnlinePlay.Lounge.Components;
-using osu.Game.Screens.OnlinePlay.Match;
+using osu.Game.Screens.OnlinePlay.Multiplayer;
 using osu.Game.Tests.Beatmaps;
 using osuTK;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
-    public partial class TestSceneDrawableRoom : OsuTestScene
+    public partial class TestSceneRoomPanel : OsuTestScene
     {
         [Cached]
         protected readonly OverlayColourProvider ColourProvider = new OverlayColourProvider(OverlayColourScheme.Plum);
@@ -129,24 +129,24 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestEnableAndDisablePassword()
         {
-            DrawableRoom drawableRoom = null!;
+            RoomPanel panel = null!;
             Room room = null!;
 
-            AddStep("create room", () => Child = drawableRoom = createLoungeRoom(room = new Room
+            AddStep("create room", () => Child = panel = createLoungeRoom(room = new Room
             {
                 Name = "Room with password",
                 Type = MatchType.HeadToHead,
             }));
 
-            AddUntilStep("wait for panel load", () => drawableRoom.ChildrenOfType<DrawableRoomParticipantsList>().Any());
+            AddUntilStep("wait for panel load", () => panel.ChildrenOfType<DrawableRoomParticipantsList>().Any());
 
-            AddAssert("password icon hidden", () => Precision.AlmostEquals(0, drawableRoom.ChildrenOfType<DrawableRoom.PasswordProtectedIcon>().Single().Alpha));
+            AddAssert("password icon hidden", () => Precision.AlmostEquals(0, panel.ChildrenOfType<RoomPanel.PasswordProtectedIcon>().Single().Alpha));
 
             AddStep("set password", () => room.Password = "password");
-            AddAssert("password icon visible", () => Precision.AlmostEquals(1, drawableRoom.ChildrenOfType<DrawableRoom.PasswordProtectedIcon>().Single().Alpha));
+            AddAssert("password icon visible", () => Precision.AlmostEquals(1, panel.ChildrenOfType<RoomPanel.PasswordProtectedIcon>().Single().Alpha));
 
             AddStep("unset password", () => room.Password = string.Empty);
-            AddAssert("password icon hidden", () => Precision.AlmostEquals(0, drawableRoom.ChildrenOfType<DrawableRoom.PasswordProtectedIcon>().Single().Alpha));
+            AddAssert("password icon hidden", () => Precision.AlmostEquals(0, panel.ChildrenOfType<RoomPanel.PasswordProtectedIcon>().Single().Alpha));
         }
 
         [Test]
@@ -160,38 +160,29 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 Spacing = new Vector2(5),
                 Children = new[]
                 {
-                    new DrawableMatchRoom(new Room
+                    new MultiplayerRoomPanel(new Room
                     {
                         Name = "A host-only room",
                         QueueMode = QueueMode.HostOnly,
                         Type = MatchType.HeadToHead,
-                    })
-                    {
-                        SelectedItem = new Bindable<PlaylistItem?>()
-                    },
-                    new DrawableMatchRoom(new Room
+                    }),
+                    new MultiplayerRoomPanel(new Room
                     {
                         Name = "An all-players, team-versus room",
                         QueueMode = QueueMode.AllPlayers,
                         Type = MatchType.TeamVersus
-                    })
-                    {
-                        SelectedItem = new Bindable<PlaylistItem?>()
-                    },
-                    new DrawableMatchRoom(new Room
+                    }),
+                    new MultiplayerRoomPanel(new Room
                     {
                         Name = "A round-robin room",
                         QueueMode = QueueMode.AllPlayersRoundRobin,
                         Type = MatchType.HeadToHead
-                    })
-                    {
-                        SelectedItem = new Bindable<PlaylistItem?>()
-                    },
+                    }),
                 }
             });
         }
 
-        private DrawableRoom createLoungeRoom(Room room)
+        private RoomPanel createLoungeRoom(Room room)
         {
             room.Host ??= new APIUser { Username = "peppy", Id = 2 };
 
@@ -204,7 +195,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 }).ToArray();
             }
 
-            return new DrawableLoungeRoom(room)
+            return new LoungeRoomPanel(room)
             {
                 MatchingFilter = true,
                 SelectedRoom = selectedRoom

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

@@ -33,6 +33,10 @@ using osu.Game.Overlays.BeatmapListing;
 using osu.Game.Overlays.Mods;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Overlays.Toolbar;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mania;
+using osu.Game.Rulesets.Mania.Configuration;
+using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Scoring;
@@ -394,6 +398,60 @@ namespace osu.Game.Tests.Visual.Navigation
             }
         }
 
+        [Test]
+        public void TestScrollSpeedAdjustDuringGameplay()
+        {
+            Player player = null;
+
+            Screens.Select.SongSelect songSelect = null;
+            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
+            AddUntilStep("wait for song select", () => songSelect.BeatmapSetsLoaded);
+
+            AddStep("import beatmap", () => BeatmapImportHelper.LoadOszIntoOsu(Game).WaitSafely());
+
+            AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
+
+            AddStep("switch to mania ruleset", () =>
+            {
+                InputManager.PressKey(Key.LControl);
+                InputManager.Key(Key.Number4);
+                InputManager.ReleaseKey(Key.LControl);
+            });
+
+            AddStep("set mods", () => Game.SelectedMods.Value = new Mod[] { new OsuModNoFail() });
+            AddStep("press enter", () => InputManager.Key(Key.Enter));
+
+            AddUntilStep("wait for player", () =>
+            {
+                DismissAnyNotifications();
+                player = Game.ScreenStack.CurrentScreen as Player;
+                return player?.IsLoaded == true;
+            });
+
+            AddUntilStep("wait for track playing", () => Game.Beatmap.Value.Track.IsRunning);
+            checkScrollSpeed(8, 8);
+
+            AddStep("adjust scroll speed via keyboard", () => InputManager.Key(Key.F4));
+            checkScrollSpeed(9, 9);
+
+            AddStep("seek beyond 10 seconds", () => player.ChildrenOfType<GameplayClockContainer>().First().Seek(10500));
+            AddUntilStep("wait for seek", () => player.ChildrenOfType<GameplayClockContainer>().First().CurrentTime, () => Is.GreaterThan(10600));
+            AddStep("attempt adjust offset via keyboard", () => InputManager.Key(Key.F4));
+            checkScrollSpeed(9, 9);
+
+            AddStep("attempt adjust offset via config change", () => getConfigManager().SetValue(ManiaRulesetSetting.ScrollSpeed, 10.0));
+            checkScrollSpeed(10, 9);
+
+            void checkScrollSpeed(double configValue, double gameplayValue)
+            {
+                AddUntilStep($"config value is {configValue}", () => getConfigManager().Get<double>(ManiaRulesetSetting.ScrollSpeed), () => Is.EqualTo(configValue));
+                AddUntilStep($"gameplay value is {gameplayValue}", () => this.ChildrenOfType<DrawableManiaRuleset>().Single().TargetTimeRange,
+                    () => Is.EqualTo(DrawableManiaRuleset.ComputeScrollTime(gameplayValue)));
+            }
+
+            ManiaRulesetConfigManager getConfigManager() => ((ManiaRulesetConfigManager)Game.Dependencies.Get<IRulesetConfigCache>().GetConfigFor(new ManiaRuleset())!);
+        }
+
         [Test]
         public void TestOffsetAdjustDuringGameplay()
         {

osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs

@@ -99,8 +99,35 @@ namespace osu.Game.Tests.Visual.Online
                                 Fails = Enumerable.Range(1, 100).Select(i => i % 12 - 6).ToArray(),
                                 Retries = Enumerable.Range(-2, 100).Select(i => i % 12 - 6).ToArray(),
                             },
+                            TopTags =
+                            [
+                                new APIBeatmapTag { TagId = 4, VoteCount = 1 },
+                                new APIBeatmapTag { TagId = 2, VoteCount = 1 },
+                                new APIBeatmapTag { TagId = 23, VoteCount = 5 },
+                            ],
                         },
                     },
+                    RelatedTags =
+                    [
+                        new APITag
+                        {
+                            Id = 2,
+                            Name = "song representation/simple",
+                            Description = "Accessible and straightforward map design."
+                        },
+                        new APITag
+                        {
+                            Id = 4,
+                            Name = "style/clean",
+                            Description = "Visually uncluttered and organised patterns, often involving few overlaps and equal visual spacing between objects."
+                        },
+                        new APITag
+                        {
+                            Id = 23,
+                            Name = "aim/aim control",
+                            Description = "Patterns with velocity or direction changes which strongly go against a player's natural movement pattern."
+                        }
+                    ]
                 });
             });
 
@@ -289,12 +316,37 @@ namespace osu.Game.Tests.Visual.Online
             {
                 InputManager.MoveMouseTo(overlay.ChildrenOfType<DifficultyIcon>().ElementAt(0));
             });
-            AddAssert("guest mapper information not shown", () => overlay.ChildrenOfType<BeatmapPicker>().Single().ChildrenOfType<OsuSpriteText>().All(s => s.Text != "BanchoBot"));
+            AddAssert("guest mapper information not shown", () => overlay.ChildrenOfType<BeatmapPicker>().Single().ChildrenOfType<OsuSpriteText>().All(s => s.Text != "BanchoBot0"));
+            AddStep("move mouse to guest difficulty", () =>
+            {
+                InputManager.MoveMouseTo(overlay.ChildrenOfType<DifficultyIcon>().ElementAt(1));
+            });
+            AddAssert("guest mapper information shown", () => overlay.ChildrenOfType<BeatmapPicker>().Single().ChildrenOfType<OsuSpriteText>().Any(s => s.Text == "BanchoBot0"));
+        }
+
+        [Test]
+        public void TestBeatmapsetWithALotGuestOwner()
+        {
+            AddStep("show map with 2 mapper", () => overlay.ShowBeatmapSet(createBeatmapSetWithGuestDifficulty(2)));
+            AddStep("move mouse to guest difficulty", () =>
+            {
+                InputManager.MoveMouseTo(overlay.ChildrenOfType<DifficultyIcon>().ElementAt(1));
+            });
+            AddStep("show map with 3 mapper", () => overlay.ShowBeatmapSet(createBeatmapSetWithGuestDifficulty(3)));
+            AddStep("move mouse to guest difficulty", () =>
+            {
+                InputManager.MoveMouseTo(overlay.ChildrenOfType<DifficultyIcon>().ElementAt(1));
+            });
+            AddStep("show map with 10 mapper", () => overlay.ShowBeatmapSet(createBeatmapSetWithGuestDifficulty(10)));
+            AddStep("move mouse to guest difficulty", () =>
+            {
+                InputManager.MoveMouseTo(overlay.ChildrenOfType<DifficultyIcon>().ElementAt(1));
+            });
+            AddStep("show map with 20 mapper", () => overlay.ShowBeatmapSet(createBeatmapSetWithGuestDifficulty(20)));
             AddStep("move mouse to guest difficulty", () =>
             {
                 InputManager.MoveMouseTo(overlay.ChildrenOfType<DifficultyIcon>().ElementAt(1));
             });
-            AddAssert("guest mapper information shown", () => overlay.ChildrenOfType<BeatmapPicker>().Single().ChildrenOfType<OsuSpriteText>().Any(s => s.Text == "BanchoBot"));
         }
 
         private APIBeatmapSet createManyDifficultiesBeatmapSet()
@@ -336,22 +388,31 @@ namespace osu.Game.Tests.Visual.Online
             return beatmapSet;
         }
 
-        private APIBeatmapSet createBeatmapSetWithGuestDifficulty()
+        private APIBeatmapSet createBeatmapSetWithGuestDifficulty(int guestCount = 1)
         {
             var set = getBeatmapSet();
 
             var beatmaps = new List<APIBeatmap>();
+            var beatmapOwners = new List<APIBeatmap.BeatmapOwner>();
+            var ownersAPIUser = new List<APIUser>();
 
-            var guestUser = new APIUser
+            for (int i = 0; i < guestCount; i++)
             {
-                Username = @"BanchoBot",
-                Id = 3,
-            };
+                var guestUser = new APIUser
+                {
+                    Username = @$"BanchoBot{i}",
+                    Id = i + 3,
+                };
 
-            set.RelatedUsers = new[]
-            {
-                set.Author, guestUser
-            };
+                beatmapOwners.Add(new APIBeatmap.BeatmapOwner
+                {
+                    Username = @$"BanchoBot{i}",
+                    Id = i + 3,
+                });
+                ownersAPIUser.Add(guestUser);
+            }
+
+            set.RelatedUsers = new[] { set.Author }.Concat(ownersAPIUser).ToArray();
 
             beatmaps.Add(new APIBeatmap
             {
@@ -366,7 +427,7 @@ namespace osu.Game.Tests.Visual.Online
                     Fails = Enumerable.Range(1, 100).Select(j => j % 12 - 6).ToArray(),
                     Retries = Enumerable.Range(-2, 100).Select(j => j % 12 - 6).ToArray(),
                 },
-                Status = BeatmapOnlineStatus.Graveyard
+                Status = BeatmapOnlineStatus.Graveyard,
             });
 
             beatmaps.Add(new APIBeatmap
@@ -382,7 +443,8 @@ namespace osu.Game.Tests.Visual.Online
                     Fails = Enumerable.Range(1, 100).Select(j => j % 12 - 6).ToArray(),
                     Retries = Enumerable.Range(-2, 100).Select(j => j % 12 - 6).ToArray(),
                 },
-                Status = BeatmapOnlineStatus.Graveyard
+                Status = BeatmapOnlineStatus.Graveyard,
+                BeatmapOwners = beatmapOwners.ToArray(),
             });
 
             set.Beatmaps = beatmaps.ToArray();

osu.Game.Tests/Visual/Online/TestSceneChatOverlay.cs

@@ -215,6 +215,32 @@ namespace osu.Game.Tests.Visual.Online
             });
         }
 
+        [Test]
+        public void TestChannelCloseViaMiddleClick()
+        {
+            var testPMChannel = new Channel(testUser);
+
+            AddStep("Show overlay", () => chatOverlay.Show());
+            joinTestChannel(0);
+            joinChannel(testPMChannel);
+            AddStep("Select PM channel", () => clickDrawable(getChannelListItem(testPMChannel)));
+            AddStep("Middle click", () =>
+            {
+                var item = getChannelListItem(testPMChannel);
+                InputManager.MoveMouseTo(item);
+                InputManager.Click(MouseButton.Middle);
+            });
+            AddAssert("PM channel closed", () => !channelManager.JoinedChannels.Contains(testPMChannel));
+            AddStep("Select normal channel", () => clickDrawable(getChannelListItem(testChannel1)));
+            AddStep("Click close button", () =>
+            {
+                var item = getChannelListItem(testChannel1);
+                InputManager.MoveMouseTo(item);
+                InputManager.Click(MouseButton.Middle);
+            });
+            AddAssert("Normal channel closed", () => !channelManager.JoinedChannels.Contains(testChannel1));
+        }
+
         [Test]
         public void TestChannelCloseButton()
         {

osu.Game.Tests/Visual/Online/TestSceneFriendDisplay.cs

@@ -234,7 +234,7 @@ namespace osu.Game.Tests.Visual.Online
             {
                 Username = "flyte",
                 Id = 3103765,
-                IsOnline = true,
+                WasRecentlyOnline = true,
                 Statistics = new UserStatistics { GlobalRank = 1111 },
                 CountryCode = CountryCode.JP,
                 CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c6.jpg"
@@ -243,7 +243,7 @@ namespace osu.Game.Tests.Visual.Online
             {
                 Username = "peppy",
                 Id = 2,
-                IsOnline = false,
+                WasRecentlyOnline = false,
                 Statistics = new UserStatistics { GlobalRank = 2222 },
                 CountryCode = CountryCode.AU,
                 CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
@@ -256,7 +256,7 @@ namespace osu.Game.Tests.Visual.Online
                 Id = 8195163,
                 CountryCode = CountryCode.BY,
                 CoverUrl = "https://assets.ppy.sh/user-profile-covers/8195163/4a8e2ad5a02a2642b631438cfa6c6bd7e2f9db289be881cb27df18331f64144c.jpeg",
-                IsOnline = false,
+                WasRecentlyOnline = false,
                 LastVisit = DateTimeOffset.Now
             }
         };

osu.Game.Tests/Visual/Online/TestSceneImageProxying.cs

@@ -0,0 +1,52 @@
+// 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.Graphics.Containers.Markdown;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Testing;
+using osu.Game.Graphics.Containers.Markdown;
+using osu.Game.Overlays.Comments;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public partial class TestSceneImageProxying : OsuTestScene
+    {
+        [Test]
+        public void TestExternalImageLink()
+        {
+            MarkdownContainer markdown = null!;
+
+            // use base MarkdownContainer as a method of directly attempting to load an image without proxying logic.
+            AddStep("load external without proxying", () => Child = markdown = new MarkdownContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Text = "![](https://github.com/ppy/osu-wiki/blob/master/wiki/Announcement_messages/img/notification.png?raw=true)",
+            });
+            AddWaitStep("wait", 5);
+            AddAssert("image not loaded", () => markdown.ChildrenOfType<Sprite>().SingleOrDefault()?.Texture == null);
+
+            AddStep("load external with proxying", () => Child = markdown = new OsuMarkdownContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Text = "![](https://github.com/ppy/osu-wiki/blob/master/wiki/Announcement_messages/img/notification.png?raw=true)",
+            });
+            AddUntilStep("image loaded", () => markdown.ChildrenOfType<Sprite>().SingleOrDefault()?.Texture != null);
+        }
+
+        [Test]
+        public void TestExternalImageLinkInComments()
+        {
+            MarkdownContainer markdown = null!;
+
+            AddStep("load external with proxying", () => Child = markdown = new CommentMarkdownContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Text = "![](https://github.com/ppy/osu-wiki/blob/master/wiki/Announcement_messages/img/notification.png?raw=true)",
+            });
+            AddUntilStep("image loaded", () => markdown.ChildrenOfType<Sprite>().SingleOrDefault()?.Texture != null);
+        }
+    }
+}

osu.Game.Tests/Visual/Online/TestSceneUserClickableAvatar.cs

@@ -62,7 +62,7 @@ namespace osu.Game.Tests.Visual.Online
                 CountryCode = countryCode,
                 CoverUrl = cover,
                 Colour = color ?? "000000",
-                IsOnline = true
+                WasRecentlyOnline = true
             };
 
             return new ClickableAvatar(user, showPanel)

osu.Game.Tests/Visual/Online/TestSceneUserPanel.cs

@@ -77,7 +77,7 @@ namespace osu.Game.Tests.Visual.Online
                                 Id = 3103765,
                                 CountryCode = CountryCode.JP,
                                 CoverUrl = @"https://assets.ppy.sh/user-cover-presets/1/df28696b58541a9e67f6755918951d542d93bdf1da41720fcca2fd2c1ea8cf51.jpeg",
-                                IsOnline = true
+                                WasRecentlyOnline = true
                             }) { Width = 300 },
                             new UserGridPanel(new APIUser
                             {

osu.Game.Tests/Visual/Online/TestSceneUserProfileHeader.cs

@@ -79,7 +79,7 @@ namespace osu.Game.Tests.Visual.Online
                 Id = 1001,
                 Username = "IAmOnline",
                 LastVisit = DateTimeOffset.Now,
-                IsOnline = true,
+                WasRecentlyOnline = true,
             }, new OsuRuleset().RulesetInfo));
 
             AddStep("Show offline user", () => header.User.Value = new UserProfileData(new APIUser
@@ -87,7 +87,7 @@ namespace osu.Game.Tests.Visual.Online
                 Id = 1002,
                 Username = "IAmOffline",
                 LastVisit = DateTimeOffset.Now.AddDays(-10),
-                IsOnline = false,
+                WasRecentlyOnline = false,
             }, new OsuRuleset().RulesetInfo));
         }
 

osu.Game.Tests/Visual/Playlists/TestScenePlaylistsLoungeSubScreen.cs

@@ -61,9 +61,9 @@ namespace osu.Game.Tests.Visual.Playlists
             AddUntilStep("last room is not masked", () => checkRoomVisible(roomListing.DrawableRooms[^1]));
         }
 
-        private bool checkRoomVisible(DrawableRoom room) =>
+        private bool checkRoomVisible(RoomPanel panel) =>
             loungeScreen.ChildrenOfType<OsuScrollContainer>().First().ScreenSpaceDrawQuad
-                        .Contains(room.ScreenSpaceDrawQuad.Centre);
+                        .Contains(panel.ScreenSpaceDrawQuad.Centre);
 
         private void createRooms(params Room[] rooms)
         {

osu.Game.Tests/Visual/Playlists/TestScenePlaylistsRoomCreation.cs

@@ -176,6 +176,7 @@ namespace osu.Game.Tests.Visual.Playlists
                         RulesetID = new OsuRuleset().RulesetInfo.OnlineID
                     }
                 ];
+                room.EndDate = DateTimeOffset.Now.AddHours(1);
             });
 
             AddAssert("match has default beatmap", () => match.Beatmap.IsDefault);
@@ -212,6 +213,11 @@ namespace osu.Game.Tests.Visual.Playlists
 
             Debug.Assert(beatmap.BeatmapInfo.BeatmapSet != null);
             importedBeatmap = manager.Import(beatmap.BeatmapInfo.BeatmapSet)!.Value.Detach();
+            Realm.Write(r =>
+            {
+                foreach (var beatmapInfo in r.All<BeatmapInfo>())
+                    beatmapInfo.OnlineMD5Hash = beatmapInfo.MD5Hash;
+            });
         });
 
         private partial class TestPlaylistsRoomSubScreen : PlaylistsRoomSubScreen

osu.Game.Tests/Visual/Playlists/TestScenePlaylistsRoomSubScreen.cs

@@ -65,7 +65,8 @@ namespace osu.Game.Tests.Visual.Playlists
                         OnlineID = 1,
                         DifficultyName = "Osu 1",
                         Hash = Guid.NewGuid().ToString().ComputeMD5Hash(),
-                        MD5Hash = Guid.NewGuid().ToString().ComputeMD5Hash(),
+                        MD5Hash = "11111111",
+                        OnlineMD5Hash = "11111111",
                         Ruleset = new OsuRuleset().RulesetInfo,
                         Metadata =
                         {
@@ -79,7 +80,8 @@ namespace osu.Game.Tests.Visual.Playlists
                         OnlineID = 2,
                         DifficultyName = "Osu 2",
                         Hash = Guid.NewGuid().ToString().ComputeMD5Hash(),
-                        MD5Hash = Guid.NewGuid().ToString().ComputeMD5Hash(),
+                        MD5Hash = "22222222",
+                        OnlineMD5Hash = "22222222",
                         Ruleset = new OsuRuleset().RulesetInfo,
                         Metadata =
                         {
@@ -93,7 +95,8 @@ namespace osu.Game.Tests.Visual.Playlists
                         OnlineID = 3,
                         DifficultyName = "Taiko 1",
                         Hash = Guid.NewGuid().ToString().ComputeMD5Hash(),
-                        MD5Hash = Guid.NewGuid().ToString().ComputeMD5Hash(),
+                        MD5Hash = "33333333",
+                        OnlineMD5Hash = "33333333",
                         Ruleset = new TaikoRuleset().RulesetInfo,
                         Metadata =
                         {
@@ -107,7 +110,8 @@ namespace osu.Game.Tests.Visual.Playlists
                         OnlineID = 4,
                         DifficultyName = "Taiko 2",
                         Hash = Guid.NewGuid().ToString().ComputeMD5Hash(),
-                        MD5Hash = Guid.NewGuid().ToString().ComputeMD5Hash(),
+                        MD5Hash = "44444444",
+                        OnlineMD5Hash = "44444444",
                         Ruleset = new TaikoRuleset().RulesetInfo,
                         Metadata =
                         {

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

@@ -168,6 +168,19 @@ namespace osu.Game.Tests.Visual.Ranking
             };
         });
 
+        public static List<HitEvent> CreateHitEvents(double offset = 0, int count = 50)
+        {
+            var hitEvents = new List<HitEvent>();
+
+            for (int i = 0; i < count; i++)
+            {
+                for (int j = 0; j < count; j++)
+                    hitEvents.Add(new HitEvent(offset, 1.0, HitResult.Perfect, placeholder_object, placeholder_object, null));
+            }
+
+            return hitEvents;
+        }
+
         public static List<HitEvent> CreateDistributedHitEvents(double centre = 0, double range = 25)
         {
             var hitEvents = new List<HitEvent>();

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

@@ -105,6 +105,40 @@ namespace osu.Game.Tests.Visual.Ranking
             displayUpdate(statistics, statistics);
         }
 
+        [Test]
+        public void TestFromNothing()
+        {
+            createDisplay();
+            displayUpdate(
+                new UserStatistics(),
+                new UserStatistics
+                {
+                    GlobalRank = 12_345,
+                    Accuracy = 98.99,
+                    MaxCombo = 2_322,
+                    RankedScore = 23_123_543_456,
+                    TotalScore = 123_123_543_456,
+                    PP = 5_072
+                });
+        }
+
+        [Test]
+        public void TestToNothing()
+        {
+            createDisplay();
+            displayUpdate(
+                new UserStatistics
+                {
+                    GlobalRank = 12_345,
+                    Accuracy = 98.99,
+                    MaxCombo = 2_322,
+                    RankedScore = 23_123_543_456,
+                    TotalScore = 123_123_543_456,
+                    PP = 5_072
+                },
+                new UserStatistics());
+        }
+
         private void createDisplay() => AddStep("create display", () =>
         {
             statisticsUpdate.Value = null;