Merge pull request #33450 from bdach/freestyle-consistent-compatibility

Disallow selected mods from being valid for freestyle as required mods due to them not being consistently compatible with other mods across rulesets

.github/workflows/_diffcalc_processor.yml

@@ -36,7 +36,7 @@ jobs:
   generator:
     name: Run
     runs-on: self-hosted
-    timeout-minutes: 720
+    timeout-minutes: 1440
 
     outputs:
       target: ${{ steps.run.outputs.target }}

.github/workflows/deploy.yml

@@ -0,0 +1,87 @@
+name: Pack and nuget
+
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  notify_pending_production_deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Submit pending deployment notification
+        run: |
+          export TITLE="Pending osu Production Deployment: $GITHUB_REF_NAME"
+          export URL="https://github.com/ppy/osu/actions/runs/$GITHUB_RUN_ID"
+          export DESCRIPTION="Awaiting approval for building NuGet packages for tag $GITHUB_REF_NAME:
+          [View Workflow Run]($URL)"
+          export ACTOR_ICON="https://avatars.githubusercontent.com/u/$GITHUB_ACTOR_ID"
+
+          BODY="$(jq --null-input '{
+            "embeds": [
+              {
+                "title": env.TITLE,
+                "color": 15098112,
+                "description": env.DESCRIPTION,
+                "url": env.URL,
+                "author": {
+                  "name": env.GITHUB_ACTOR,
+                  "icon_url": env.ACTOR_ICON
+                }
+              }
+            ]
+          }')"
+
+          curl \
+            -H "Content-Type: application/json" \
+            -d "$BODY" \
+            "${{ secrets.DISCORD_INFRA_WEBHOOK_URL }}"
+
+  pack:
+    name: Pack
+    runs-on: ubuntu-latest
+    environment: production
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set artifacts directory
+        id: artifactsPath
+        run: echo "::set-output name=nuget_artifacts::${{github.workspace}}/artifacts"
+
+      - name: Install .NET 8.0.x
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: "8.0.x"
+
+      - name: Pack
+        run: |
+          # Replace project references in templates with package reference, because they're included as source files.
+          dotnet remove Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform/osu.Game.Rulesets.EmptyFreeform.csproj reference osu.Game/osu.Game.csproj
+          dotnet remove Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon/osu.Game.Rulesets.Pippidon.csproj reference osu.Game/osu.Game.csproj
+          dotnet remove Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling/osu.Game.Rulesets.EmptyScrolling.csproj reference osu.Game/osu.Game.csproj
+          dotnet remove Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/osu.Game.Rulesets.Pippidon.csproj reference osu.Game/osu.Game.csproj
+
+          dotnet add Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform/osu.Game.Rulesets.EmptyFreeform.csproj package ppy.osu.Game -n -v ${{ github.ref_name }}
+          dotnet add Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon/osu.Game.Rulesets.Pippidon.csproj package ppy.osu.Game -n -v ${{ github.ref_name }}
+          dotnet add Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling/osu.Game.Rulesets.EmptyScrolling.csproj package ppy.osu.Game -n -v ${{ github.ref_name }}
+          dotnet add Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/osu.Game.Rulesets.Pippidon.csproj package ppy.osu.Game -n -v ${{ github.ref_name }}
+
+          # Pack
+          dotnet pack -c Release osu.Game /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release osu.Game.Rulesets.Osu /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release osu.Game.Rulesets.Taiko /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release osu.Game.Rulesets.Catch /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release osu.Game.Rulesets.Mania /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release Templates /p:Version=${{ github.ref_name }} -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: osu
+          path: |
+            ${{steps.artifactsPath.outputs.nuget_artifacts}}/*.nupkg
+            ${{steps.artifactsPath.outputs.nuget_artifacts}}/*.snupkg
+
+      - name: Publish packages to nuget.org
+        run: dotnet nuget push ${{steps.artifactsPath.outputs.nuget_artifacts}}/*.nupkg --api-key ${{ secrets.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json

CodeAnalysis/BannedSymbols.txt

@@ -21,3 +21,7 @@ M:Humanizer.InflectorExtensions.Kebaberize(System.String);Humanizer's .Kebaberiz
 M:osuTK.MathHelper.Clamp(System.Int32,System.Int32,System.Int32)~System.Int32;Use Math.Clamp() instead.
 M:osuTK.MathHelper.Clamp(System.Single,System.Single,System.Single)~System.Single;This osuTK helper has unsafe semantics when one of the bounds provided is NaN. Use Math.Clamp() instead.
 M:osuTK.MathHelper.Clamp(System.Double,System.Double,System.Double)~System.Double;This osuTK helper has unsafe semantics when one of the bounds provided is NaN. Use Math.Clamp() instead.
+M:TagLib.File.Create(System.String);TagLib's MIME type detection changes behaviour depending on CultureInfo.CurrentCulture. Use TagLibUtils.GetTagLibFile() instead.
+M:TagLib.File.Create(TagLib.File.IFileAbstraction);TagLib's MIME type detection changes behaviour depending on CultureInfo.CurrentCulture. Use TagLibUtils.GetTagLibFile() instead.
+M:TagLib.File.Create(System.String,TagLib.ReadStyle);TagLib's MIME type detection changes behaviour depending on CultureInfo.CurrentCulture. Use TagLibUtils.GetTagLibFile() instead.
+M:TagLib.File.Create(TagLib.File.IFileAbstraction,TagLib.ReadStyle);TagLib's MIME type detection changes behaviour depending on CultureInfo.CurrentCulture. Use TagLibUtils.GetTagLibFile() instead.

Directory.Build.props

@@ -3,6 +3,10 @@
   <PropertyGroup Label="C#">
     <LangVersion>12.0</LangVersion>
     <Nullable>enable</Nullable>
+    <!-- Stabilises hot reload, see: https://platform.uno/docs/articles/studio/Hot%20Reload/hot-reload-overview.html?tabs=vswin%2Cwindows%2Cskia-desktop%2Ccommon-issues -->
+    <GenerateAssemblyInfo Condition="'$(Configuration)'=='Debug'">false</GenerateAssemblyInfo>
+    <!-- Required due to the above  -->
+    <NoWarn Condition="'$(Configuration)'=='Debug'">$(NoWarn);CA1416</NoWarn>
   </PropertyGroup>
   <PropertyGroup>
     <ApplicationManifest>$(MSBuildThisFileDirectory)app.manifest</ApplicationManifest>

appveyor.yml

@@ -1,32 +0,0 @@
-clone_depth: 1
-version: '{branch}-{build}'
-image: Visual Studio 2022
-cache:
-  - '%LOCALAPPDATA%\NuGet\v3-cache -> appveyor.yml'
-
-dotnet_csproj:
-  patch: true
-  file: 'osu.Game\osu.Game.csproj' # Use wildcard when it's able to exclude Xamarin projects
-  version: '0.0.{build}'
-
-before_build:
-  - cmd: dotnet --info # Useful when version mismatch between CI and local
-  - cmd: dotnet workload install maui-android # Change to `dotnet workload restore` once there's no old projects
-  - cmd: dotnet workload install maui-ios # Change to `dotnet workload restore` once there's no old projects
-  - cmd: nuget restore -verbosity quiet # Only nuget.exe knows both new (.NET Core) and old (Xamarin) projects
-
-build:
-  project: osu.sln
-  parallel: true
-  verbosity: minimal
-  publish_nuget: true
-
-after_build:
-  - ps: .\InspectCode.ps1
-
-test:
-  assemblies:
-    except:
-      - '**\*Android*'
-      - '**\*iOS*'
-      - 'build\**\*'

appveyor_deploy.yml

@@ -1,86 +0,0 @@
-clone_depth: 1
-version: '{build}'
-image: Visual Studio 2022
-test: off
-skip_non_tags: true
-configuration: Release
-
-environment:
-  matrix:
-    - job_name: osu-game
-    - job_name: osu-ruleset
-      job_depends_on: osu-game
-    - job_name: taiko-ruleset
-      job_depends_on: osu-game
-    - job_name: catch-ruleset
-      job_depends_on: osu-game
-    - job_name: mania-ruleset
-      job_depends_on: osu-game
-    - job_name: templates
-      job_depends_on: osu-game
-
-nuget:
-  project_feed: true
-
-for:
-  -
-    matrix:
-      only:
-        - job_name: osu-game
-    build_script:
-      - cmd: dotnet pack osu.Game\osu.Game.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: osu-ruleset
-    build_script:
-      - cmd: dotnet remove osu.Game.Rulesets.Osu\osu.Game.Rulesets.Osu.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet add osu.Game.Rulesets.Osu\osu.Game.Rulesets.Osu.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet pack osu.Game.Rulesets.Osu\osu.Game.Rulesets.Osu.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: taiko-ruleset
-    build_script:
-      - cmd: dotnet remove osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet add osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet pack osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: catch-ruleset
-    build_script:
-      - cmd: dotnet remove osu.Game.Rulesets.Catch\osu.Game.Rulesets.Catch.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet add osu.Game.Rulesets.Catch\osu.Game.Rulesets.Catch.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet pack osu.Game.Rulesets.Catch\osu.Game.Rulesets.Catch.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: mania-ruleset
-    build_script:
-      - cmd: dotnet remove osu.Game.Rulesets.Mania\osu.Game.Rulesets.Mania.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet add osu.Game.Rulesets.Mania\osu.Game.Rulesets.Mania.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet pack osu.Game.Rulesets.Mania\osu.Game.Rulesets.Mania.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: templates
-    build_script:
-      - cmd: dotnet remove Templates\Rulesets\ruleset-empty\osu.Game.Rulesets.EmptyFreeform\osu.Game.Rulesets.EmptyFreeform.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet remove Templates\Rulesets\ruleset-example\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet remove Templates\Rulesets\ruleset-scrolling-empty\osu.Game.Rulesets.EmptyScrolling\osu.Game.Rulesets.EmptyScrolling.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet remove Templates\Rulesets\ruleset-scrolling-example\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj reference osu.Game\osu.Game.csproj
-
-      - cmd: dotnet add Templates\Rulesets\ruleset-empty\osu.Game.Rulesets.EmptyFreeform\osu.Game.Rulesets.EmptyFreeform.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet add Templates\Rulesets\ruleset-example\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet add Templates\Rulesets\ruleset-scrolling-empty\osu.Game.Rulesets.EmptyScrolling\osu.Game.Rulesets.EmptyScrolling.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet add Templates\Rulesets\ruleset-scrolling-example\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-
-      - cmd: dotnet pack Templates\osu.Game.Templates.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-
-artifacts:
-  - path: '**\*.nupkg'
-
-deploy:
-  - provider: Environment
-    name: nuget

osu.Android.props

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

osu.Desktop/OsuGameDesktop.cs

@@ -17,6 +17,7 @@ using osu.Framework.Logging;
 using osu.Game.Updater;
 using osu.Desktop.Windows;
 using osu.Framework.Allocation;
+using osu.Game.Configuration;
 using osu.Game.IO;
 using osu.Game.IPC;
 using osu.Game.Online.Multiplayer;
@@ -33,6 +34,8 @@ namespace osu.Desktop
         [Cached(typeof(IHighPerformanceSessionManager))]
         private readonly HighPerformanceSessionManager highPerformanceSessionManager = new HighPerformanceSessionManager();
 
+        public bool IsFirstRun { get; init; }
+
         public OsuGameDesktop(string[]? args = null)
             : base(args)
         {
@@ -104,6 +107,14 @@ namespace osu.Desktop
 
         protected override UpdateManager CreateUpdateManager()
         {
+            // If this is the first time we've run the game, ie it is being installed,
+            // reset the user's release stream to "lazer".
+            //
+            // This ensures that if a user is trying to recover from a failed startup on an unstable release stream,
+            // the game doesn't immediately try and update them back to the release stream after starting up.
+            if (IsFirstRun)
+                LocalConfig.SetValue(OsuSetting.ReleaseStream, ReleaseStream.Lazer);
+
             if (IsPackageManaged)
                 return new NoActionUpdateManager();
 

osu.Desktop/Program.cs

@@ -28,6 +28,8 @@ namespace osu.Desktop
 
         private static LegacyTcpIpcProvider? legacyIpc;
 
+        private static bool isFirstRun;
+
         [STAThread]
         public static void Main(string[] args)
         {
@@ -135,7 +137,12 @@ namespace osu.Desktop
                 if (tournamentClient)
                     host.Run(new TournamentGame());
                 else
-                    host.Run(new OsuGameDesktop(args));
+                {
+                    host.Run(new OsuGameDesktop(args)
+                    {
+                        IsFirstRun = isFirstRun
+                    });
+                }
             }
         }
 
@@ -177,6 +184,8 @@ namespace osu.Desktop
 
             var app = VelopackApp.Build();
 
+            app.WithFirstRun(_ => isFirstRun = true);
+
             if (OperatingSystem.IsWindows())
                 configureWindows(app);
 

osu.Desktop/Updater/VelopackUpdateManager.cs

@@ -4,8 +4,10 @@
 using System;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Logging;
 using osu.Game;
+using osu.Game.Configuration;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Screens.Play;
@@ -16,8 +18,8 @@ namespace osu.Desktop.Updater
 {
     public partial class VelopackUpdateManager : Game.Updater.UpdateManager
     {
-        private readonly UpdateManager updateManager;
-        private INotificationOverlay notificationOverlay = null!;
+        [Resolved]
+        private INotificationOverlay notificationOverlay { get; set; } = null!;
 
         [Resolved]
         private OsuGameBase game { get; set; } = null!;
@@ -25,22 +27,32 @@ namespace osu.Desktop.Updater
         [Resolved]
         private ILocalUserPlayInfo? localUserInfo { get; set; }
 
+        [Resolved]
+        private OsuConfigManager osuConfigManager { get; set; } = null!;
+
         private bool isInGameplay => localUserInfo?.PlayingState.Value != LocalUserPlayingState.NotPlaying;
 
+        private readonly Bindable<ReleaseStream> releaseStream = new Bindable<ReleaseStream>();
+        private UpdateManager? updateManager;
         private UpdateInfo? pendingUpdate;
 
-        public VelopackUpdateManager()
+        protected override void LoadComplete()
         {
-            updateManager = new UpdateManager(new GithubSource(@"https://github.com/ppy/osu", null, false), new UpdateOptions
+            // Used by the base implementation.
+            osuConfigManager.BindWith(OsuSetting.ReleaseStream, releaseStream);
+            releaseStream.BindValueChanged(_ => onReleaseStreamChanged(), true);
+
+            base.LoadComplete();
+        }
+
+        private void onReleaseStreamChanged()
+        {
+            updateManager = new UpdateManager(new GithubSource(@"https://github.com/ppy/osu", null, releaseStream.Value == ReleaseStream.Tachyon), new UpdateOptions
             {
                 AllowVersionDowngrade = true,
             });
-        }
 
-        [BackgroundDependencyLoader]
-        private void load(INotificationOverlay notifications)
-        {
-            notificationOverlay = notifications;
+            Schedule(() => Task.Run(CheckForUpdateAsync));
         }
 
         protected override async Task<bool> PerformUpdateCheck() => await checkForUpdateAsync().ConfigureAwait(false);
@@ -76,6 +88,12 @@ namespace osu.Desktop.Updater
                     return true;
                 }
 
+                if (updateManager == null)
+                {
+                    scheduleRecheck = true;
+                    return false;
+                }
+
                 pendingUpdate = await updateManager.CheckForUpdatesAsync().ConfigureAwait(false);
 
                 // No update is available. We'll check again later.
@@ -141,6 +159,9 @@ namespace osu.Desktop.Updater
 
         private async Task restartToApplyUpdate()
         {
+            if (updateManager == null)
+                return;
+
             await updateManager.WaitExitThenApplyUpdatesAsync(pendingUpdate?.TargetFullRelease).ConfigureAwait(false);
             Schedule(() => game.AttemptExit());
         }

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

@@ -0,0 +1,75 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Testing;
+using osu.Framework.Timing;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.Replays;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Storyboards;
+using osu.Game.Tests.Visual;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    public partial class TestSceneReplayRecording : PlayerTestScene
+    {
+        protected override Ruleset CreatePlayerRuleset() => new CatchRuleset();
+
+        [Resolved]
+        private AudioManager audioManager { get; set; } = null!;
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new Beatmap
+        {
+            HitObjects =
+            {
+                new Fruit { StartTime = 0, },
+                new Fruit { StartTime = 5000, },
+                new Fruit { StartTime = 10000, },
+                new Fruit { StartTime = 15000, }
+            }
+        };
+
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard? storyboard = null) =>
+            new ClockBackedTestWorkingBeatmap(beatmap, storyboard, new FramedClock(new ManualClock { Rate = 1 }), audioManager);
+
+        [Test]
+        public void TestRecording()
+        {
+            seekTo(0);
+            AddStep("start moving left", () => InputManager.PressKey(Key.Left));
+            seekTo(5000);
+            AddStep("end moving left", () => InputManager.ReleaseKey(Key.Left));
+            AddAssert("catcher max left", () => this.ChildrenOfType<Catcher>().Single().X, () => Is.EqualTo(0));
+            AddAssert("movement to left recorded to replay", () => Player.Score.Replay.Frames.OfType<CatchReplayFrame>().Any(f => f.Actions.SequenceEqual([CatchAction.MoveLeft])));
+            AddAssert("replay reached left edge", () => Player.Score.Replay.Frames.OfType<CatchReplayFrame>().Any(f => Precision.AlmostEquals(f.Position, 0)));
+
+            AddStep("start dashing right", () =>
+            {
+                InputManager.PressKey(Key.LShift);
+                InputManager.PressKey(Key.Right);
+            });
+            seekTo(10000);
+            AddStep("end dashing right", () =>
+            {
+                InputManager.ReleaseKey(Key.LShift);
+                InputManager.ReleaseKey(Key.Right);
+            });
+            AddAssert("catcher max right", () => this.ChildrenOfType<Catcher>().Single().X, () => Is.EqualTo(CatchPlayfield.WIDTH));
+            AddAssert("dash to right recorded to replay", () => Player.Score.Replay.Frames.OfType<CatchReplayFrame>().Any(f => f.Actions.SequenceEqual([CatchAction.Dash, CatchAction.MoveRight])));
+            AddAssert("replay reached right edge", () => Player.Score.Replay.Frames.OfType<CatchReplayFrame>().Any(f => Precision.AlmostEquals(f.Position, CatchPlayfield.WIDTH)));
+        }
+
+        private void seekTo(double time)
+        {
+            AddStep($"seek to {time}ms", () => Player.GameplayClockContainer.Seek(time));
+            AddUntilStep("wait for seek to finish", () => Player.DrawableRuleset.FrameStableClock.CurrentTime, () => Is.EqualTo(time).Within(500));
+        }
+    }
+}

osu.Game.Rulesets.Catch/Edit/CatchBeatmapVerifier.cs

@@ -5,6 +5,7 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Rulesets.Catch.Edit.Checks;
 using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
 using osu.Game.Rulesets.Edit.Checks.Components;
 
 namespace osu.Game.Rulesets.Catch.Edit
@@ -13,7 +14,11 @@ namespace osu.Game.Rulesets.Catch.Edit
     {
         private readonly List<ICheck> checks = new List<ICheck>
         {
+            // Compose
             new CheckBananaShowerGap(),
+            new CheckConcurrentObjects(),
+
+            // Settings
             new CheckCatchAbnormalDifficultySettings(),
         };
 

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

@@ -6,6 +6,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
+using osu.Game.Extensions;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Mods;
 
@@ -36,6 +37,24 @@ 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 ExtendedIconInformation
+        {
+            get
+            {
+                if (UserAdjustedSettingsCount != 1)
+                    return string.Empty;
+
+                if (!CircleSize.IsDefault) return format("CS", CircleSize);
+                if (!ApproachRate.IsDefault) return format("AR", ApproachRate);
+                if (!OverallDifficulty.IsDefault) return format("OD", OverallDifficulty);
+                if (!DrainRate.IsDefault) return format("HP", DrainRate);
+
+                return string.Empty;
+
+                string format(string acronym, DifficultyBindable bindable) => $"{acronym}{bindable.Value!.Value.ToStandardFormattedString(1)}";
+            }
+        }
+
         public override IEnumerable<(LocalisableString setting, LocalisableString value)> SettingDescription
         {
             get

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.Catch/Skinning/Legacy/CatchLegacySkinTransformer.cs

@@ -49,6 +49,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
                             {
                                 var keyCounter = container.OfType<LegacyKeyCounterDisplay>().FirstOrDefault();
                                 var spectatorList = container.OfType<SpectatorList>().FirstOrDefault();
+                                var leaderboard = container.OfType<DrawableGameplayLeaderboard>().FirstOrDefault();
 
                                 if (keyCounter != null)
                                 {
@@ -64,12 +65,20 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
                                     spectatorList.Origin = Anchor.BottomLeft;
                                     spectatorList.Position = new Vector2(10, -10);
                                 }
+
+                                if (leaderboard != null)
+                                {
+                                    leaderboard.Anchor = Anchor.CentreLeft;
+                                    leaderboard.Origin = Anchor.CentreLeft;
+                                    leaderboard.X = 10;
+                                }
                             })
                             {
                                 Children = new Drawable[]
                                 {
                                     new LegacyKeyCounterDisplay(),
                                     new SpectatorList(),
+                                    new DrawableGameplayLeaderboard(),
                                 }
                             };
                     }

osu.Game.Rulesets.Catch/UI/CatchPlayfieldAdjustmentContainer.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 osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -68,7 +69,7 @@ namespace osu.Game.Rulesets.Catch.UI
                 // needs to be scaled down to remain playable.
                 const float base_aspect_ratio = 1024f / 768f;
                 float aspectRatio = osuGame.ScalingContainerTargetDrawSize.X / osuGame.ScalingContainerTargetDrawSize.Y;
-                scaleContainer.Scale = new Vector2(base_aspect_ratio / aspectRatio);
+                scaleContainer.Scale = new Vector2(Math.Min(1, base_aspect_ratio / aspectRatio));
             }
         }
 

osu.Game.Rulesets.Mania.Tests/Editor/Checks/CheckManiaConcurrentObjectsTest.cs

@@ -0,0 +1,87 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
+using osu.Game.Rulesets.Mania.Edit.Checks;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Tests.Beatmaps;
+
+namespace osu.Game.Rulesets.Mania.Tests.Editor.Checks
+{
+    [TestFixture]
+    public class CheckManiaConcurrentObjectsTest
+    {
+        private CheckConcurrentObjects check = null!;
+
+        [SetUp]
+        public void Setup()
+        {
+            check = new CheckManiaConcurrentObjects();
+        }
+
+        [Test]
+        public void TestHoldNotesSeparateOnSameColumn()
+        {
+            assertOk(new List<HitObject>
+            {
+                createHoldNote(startTime: 100, endTime: 400.75d, column: 1),
+                createHoldNote(startTime: 500, endTime: 900.75d, column: 1)
+            });
+        }
+
+        [Test]
+        public void TestHoldNotesConcurrentOnDifferentColumns()
+        {
+            assertOk(new List<HitObject>
+            {
+                createHoldNote(startTime: 100, endTime: 400.75d, column: 1),
+                createHoldNote(startTime: 300, endTime: 700.75d, column: 2)
+            });
+        }
+
+        [Test]
+        public void TestHoldNotesConcurrentOnSameColumn()
+        {
+            assertConcurrentSame(new List<HitObject>
+            {
+                createHoldNote(startTime: 100, endTime: 400.75d, column: 1),
+                createHoldNote(startTime: 300, endTime: 700.75d, column: 1)
+            });
+        }
+
+        private void assertOk(List<HitObject> hitobjects)
+        {
+            Assert.That(check.Run(getContext(hitobjects)), Is.Empty);
+        }
+
+        private void assertConcurrentSame(List<HitObject> hitobjects, int count = 1)
+        {
+            var issues = check.Run(getContext(hitobjects)).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(count));
+            Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrentSame));
+        }
+
+        private BeatmapVerifierContext getContext(List<HitObject> hitobjects)
+        {
+            var beatmap = new Beatmap<HitObject> { HitObjects = hitobjects };
+            return new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+        }
+
+        private HoldNote createHoldNote(double startTime, double endTime, int column)
+        {
+            return new HoldNote
+            {
+                StartTime = startTime,
+                EndTime = endTime,
+                Column = column
+            };
+        }
+    }
+}

osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModPerfect.cs

@@ -31,9 +31,12 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
         public void TestHoldNote(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new HoldNote { StartTime = 1000, EndTime = 3000 }), shouldMiss);
 
         [Test]
-        public void TestGreatHit() => CreateModTest(new ModTestData
+        public void TestPerfectHits([Values] bool requirePerfectHits) => CreateModTest(new ModTestData
         {
-            Mod = new ManiaModPerfect(),
+            Mod = new ManiaModPerfect
+            {
+                RequirePerfectHits = { Value = requirePerfectHits }
+            },
             PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(false),
             Autoplay = false,
             CreateBeatmap = () => new Beatmap
@@ -47,6 +50,32 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
                 },
             },
             ReplayFrames = new List<ReplayFrame>
+            {
+                new ManiaReplayFrame(1000, ManiaAction.Key1),
+                new ManiaReplayFrame(2000)
+            }
+        });
+
+        [Test]
+        public void TestGreatHit([Values] bool requirePerfectHits) => CreateModTest(new ModTestData
+        {
+            Mod = new ManiaModPerfect
+            {
+                RequirePerfectHits = { Value = requirePerfectHits }
+            },
+            PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(requirePerfectHits),
+            Autoplay = false,
+            CreateBeatmap = () => new Beatmap
+            {
+                HitObjects = new List<HitObject>
+                {
+                    new Note
+                    {
+                        StartTime = 1000,
+                    }
+                },
+            },
+            ReplayFrames = new List<ReplayFrame>
             {
                 new ManiaReplayFrame(1020, ManiaAction.Key1),
                 new ManiaReplayFrame(2000)

osu.Game.Rulesets.Mania.Tests/Skinning/TestSceneHoldNote.cs

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
             {
                 foreach (var holdNote in CreatedDrawables.SelectMany(d => d.ChildrenOfType<DrawableHoldNote>()))
                 {
-                    ((Bindable<bool>)holdNote.IsHitting).Value = v;
+                    ((Bindable<bool>)holdNote.IsHolding).Value = v;
                 }
             });
         }

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

@@ -297,34 +297,202 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 3.1f, -123d, HitResult.Miss },
         };
 
+        private static readonly object[][] score_v1_non_convert_hard_rock_test_cases =
+        {
+            // OD = 5 test cases.
+            // This leads to "effective" OD of 7.
+            // PERFECT hit window is [-11ms, 11ms]
+            // GREAT   hit window is [-35ms, 35ms]
+            // GOOD    hit window is [-58ms, 58ms]
+            // OK      hit window is [-80ms, 80ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-97ms, ----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 5f, -10d, HitResult.Perfect },
+            new object[] { 5f, -11d, HitResult.Perfect },
+            new object[] { 5f, -12d, HitResult.Great },
+            new object[] { 5f, -13d, HitResult.Great },
+            new object[] { 5f, -34d, HitResult.Great },
+            new object[] { 5f, -35d, HitResult.Great },
+            new object[] { 5f, -36d, HitResult.Good },
+            new object[] { 5f, -37d, HitResult.Good },
+            new object[] { 5f, -57d, HitResult.Good },
+            new object[] { 5f, -58d, HitResult.Good },
+            new object[] { 5f, -59d, HitResult.Ok },
+            new object[] { 5f, -60d, HitResult.Ok },
+            new object[] { 5f, -79d, HitResult.Ok },
+            new object[] { 5f, -80d, HitResult.Ok },
+            new object[] { 5f, -81d, HitResult.Meh },
+            new object[] { 5f, -82d, HitResult.Meh },
+            new object[] { 5f, -96d, HitResult.Meh },
+            new object[] { 5f, -97d, HitResult.Meh },
+            new object[] { 5f, -98d, HitResult.Miss },
+            new object[] { 5f, -99d, HitResult.Miss },
+            new object[] { 5f, 79d, HitResult.Ok },
+            new object[] { 5f, 80d, HitResult.Miss },
+            new object[] { 5f, 81d, HitResult.Miss },
+            new object[] { 5f, 82d, HitResult.Miss },
+            new object[] { 5f, 96d, HitResult.Miss },
+            new object[] { 5f, 97d, HitResult.Miss },
+            new object[] { 5f, 98d, HitResult.Miss },
+            new object[] { 5f, 99d, HitResult.Miss },
+
+            // OD = 9.3 test cases.
+            // This leads to "effective" OD of 13.02.
+            // Note that contrary to other rulesets this does NOT cap out to OD 10!
+            // PERFECT hit window is [-11ms, 11ms]
+            // GREAT   hit window is [-25ms, 25ms]
+            // GOOD    hit window is [-49ms, 49ms]
+            // OK      hit window is [-70ms, 70ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-87ms, ----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 9.3f, 10d, HitResult.Perfect },
+            new object[] { 9.3f, 11d, HitResult.Perfect },
+            new object[] { 9.3f, 12d, HitResult.Great },
+            new object[] { 9.3f, 13d, HitResult.Great },
+            new object[] { 9.3f, 24d, HitResult.Great },
+            new object[] { 9.3f, 25d, HitResult.Great },
+            new object[] { 9.3f, 26d, HitResult.Good },
+            new object[] { 9.3f, 27d, HitResult.Good },
+            new object[] { 9.3f, 48d, HitResult.Good },
+            new object[] { 9.3f, 49d, HitResult.Good },
+            new object[] { 9.3f, 50d, HitResult.Ok },
+            new object[] { 9.3f, 51d, HitResult.Ok },
+            new object[] { 9.3f, 69d, HitResult.Ok },
+            new object[] { 9.3f, 70d, HitResult.Miss },
+            new object[] { 9.3f, 71d, HitResult.Miss },
+            new object[] { 9.3f, 72d, HitResult.Miss },
+            new object[] { 9.3f, 86d, HitResult.Miss },
+            new object[] { 9.3f, 87d, HitResult.Miss },
+            new object[] { 9.3f, 88d, HitResult.Miss },
+            new object[] { 9.3f, 89d, HitResult.Miss },
+            new object[] { 9.3f, -69d, HitResult.Ok },
+            new object[] { 9.3f, -70d, HitResult.Ok },
+            new object[] { 9.3f, -71d, HitResult.Meh },
+            new object[] { 9.3f, -72d, HitResult.Meh },
+            new object[] { 9.3f, -86d, HitResult.Meh },
+            new object[] { 9.3f, -87d, HitResult.Meh },
+            new object[] { 9.3f, -88d, HitResult.Miss },
+            new object[] { 9.3f, -89d, HitResult.Miss },
+        };
+
+        private static readonly object[][] score_v1_non_convert_easy_test_cases =
+        {
+            // Assume OD = 5 (other values are not tested, even OD 5 is enough to exercise the flooring logic).
+            // PERFECT hit window is [ -22ms,  22ms]
+            // GREAT   hit window is [ -68ms,  68ms]
+            // GOOD    hit window is [-114ms, 114ms]
+            // OK      hit window is [-156ms, 156ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-190ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 5f, -21d, HitResult.Perfect },
+            new object[] { 5f, -22d, HitResult.Perfect },
+            new object[] { 5f, -23d, HitResult.Great },
+            new object[] { 5f, -24d, HitResult.Great },
+            new object[] { 5f, -67d, HitResult.Great },
+            new object[] { 5f, -68d, HitResult.Great },
+            new object[] { 5f, -69d, HitResult.Good },
+            new object[] { 5f, -70d, HitResult.Good },
+            new object[] { 5f, -113d, HitResult.Good },
+            new object[] { 5f, -114d, HitResult.Good },
+            new object[] { 5f, -115d, HitResult.Ok },
+            new object[] { 5f, -116d, HitResult.Ok },
+            new object[] { 5f, -155d, HitResult.Ok },
+            new object[] { 5f, -156d, HitResult.Ok },
+            new object[] { 5f, -157d, HitResult.Meh },
+            new object[] { 5f, -158d, HitResult.Meh },
+            new object[] { 5f, -189d, HitResult.Meh },
+            new object[] { 5f, -190d, HitResult.Meh },
+            new object[] { 5f, -191d, HitResult.Miss },
+            new object[] { 5f, -192d, HitResult.Miss },
+            new object[] { 5f, 155d, HitResult.Ok },
+            new object[] { 5f, 156d, HitResult.Miss },
+            new object[] { 5f, 157d, HitResult.Miss },
+            new object[] { 5f, 158d, HitResult.Miss },
+            new object[] { 5f, 189d, HitResult.Miss },
+            new object[] { 5f, 190d, HitResult.Miss },
+            new object[] { 5f, 191d, HitResult.Miss },
+            new object[] { 5f, 192d, HitResult.Miss },
+        };
+
+        private static readonly object[][] score_v1_non_convert_double_time_test_cases =
+        {
+            // Assume OD = 5 (other values are not tested, even OD 5 is enough to exercise the flooring logic).
+            // PERFECT hit window is [ -24ms,  24ms]
+            // GREAT   hit window is [ -73ms,  73ms]
+            // GOOD    hit window is [-123ms, 123ms]
+            // OK      hit window is [-168ms, 168ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-204ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 5f, -23d, HitResult.Perfect },
+            new object[] { 5f, -24d, HitResult.Perfect },
+            new object[] { 5f, -25d, HitResult.Great },
+            new object[] { 5f, -26d, HitResult.Great },
+            new object[] { 5f, -72d, HitResult.Great },
+            new object[] { 5f, -73d, HitResult.Great },
+            new object[] { 5f, -74d, HitResult.Good },
+            new object[] { 5f, -75d, HitResult.Good },
+            new object[] { 5f, -122d, HitResult.Good },
+            new object[] { 5f, -123d, HitResult.Good },
+            new object[] { 5f, -124d, HitResult.Ok },
+            new object[] { 5f, -125d, HitResult.Ok },
+            new object[] { 5f, -167d, HitResult.Ok },
+            new object[] { 5f, -168d, HitResult.Ok },
+            new object[] { 5f, -169d, HitResult.Meh },
+            new object[] { 5f, -170d, HitResult.Meh },
+            new object[] { 5f, -203d, HitResult.Meh },
+            new object[] { 5f, -204d, HitResult.Meh },
+            new object[] { 5f, -205d, HitResult.Miss },
+            new object[] { 5f, -206d, HitResult.Miss },
+            new object[] { 5f, 167d, HitResult.Ok },
+            new object[] { 5f, 168d, HitResult.Miss },
+            new object[] { 5f, 169d, HitResult.Miss },
+            new object[] { 5f, 170d, HitResult.Miss },
+            new object[] { 5f, 203d, HitResult.Miss },
+            new object[] { 5f, 204d, HitResult.Miss },
+            new object[] { 5f, 205d, HitResult.Miss },
+            new object[] { 5f, 206d, HitResult.Miss },
+        };
+
+        private static readonly object[][] score_v1_non_convert_half_time_test_cases =
+        {
+            // Assume OD = 5 (other values are not tested, even OD 5 is enough to exercise the flooring logic).
+            // PERFECT hit window is [ -12ms,  12ms]
+            // GREAT   hit window is [ -36ms,  36ms]
+            // GOOD    hit window is [ -61ms,  61ms]
+            // OK      hit window is [ -84ms,  84ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-102ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 5f, -11d, HitResult.Perfect },
+            new object[] { 5f, -12d, HitResult.Perfect },
+            new object[] { 5f, -13d, HitResult.Great },
+            new object[] { 5f, -14d, HitResult.Great },
+            new object[] { 5f, -35d, HitResult.Great },
+            new object[] { 5f, -36d, HitResult.Great },
+            new object[] { 5f, -37d, HitResult.Good },
+            new object[] { 5f, -38d, HitResult.Good },
+            new object[] { 5f, -60d, HitResult.Good },
+            new object[] { 5f, -61d, HitResult.Good },
+            new object[] { 5f, -62d, HitResult.Ok },
+            new object[] { 5f, -63d, HitResult.Ok },
+            new object[] { 5f, -83d, HitResult.Ok },
+            new object[] { 5f, -84d, HitResult.Ok },
+            new object[] { 5f, -85d, HitResult.Meh },
+            new object[] { 5f, -86d, HitResult.Meh },
+            new object[] { 5f, -101d, HitResult.Meh },
+            new object[] { 5f, -102d, HitResult.Meh },
+            new object[] { 5f, -103d, HitResult.Miss },
+            new object[] { 5f, -104d, HitResult.Miss },
+            new object[] { 5f, 83d, HitResult.Ok },
+            new object[] { 5f, 84d, HitResult.Miss },
+            new object[] { 5f, 85d, HitResult.Miss },
+            new object[] { 5f, 86d, HitResult.Miss },
+            new object[] { 5f, 101d, HitResult.Miss },
+            new object[] { 5f, 102d, HitResult.Miss },
+            new object[] { 5f, 103d, HitResult.Miss },
+            new object[] { 5f, 104d, HitResult.Miss },
+        };
+
+        private const double note_time = 300;
+
         [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 beatmap = createNonConvertBeatmap(overallDifficulty);
 
             var replay = new Replay
             {
@@ -352,31 +520,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         [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 beatmap = createNonConvertBeatmap(overallDifficulty);
 
             var replay = new Replay
             {
@@ -403,29 +547,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         [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 beatmap = createConvertBeatmap(overallDifficulty);
 
             var replay = new Replay
             {
@@ -450,6 +572,172 @@ namespace osu.Game.Rulesets.Mania.Tests
             RunTest($@"SV1 convert single note @ OD{overallDifficulty}", beatmap, $@"SV1 convert {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
         }
 
+        [TestCaseSource(nameof(score_v1_non_convert_hard_rock_test_cases))]
+        public void TestHitWindowTreatmentWithScoreV1AndHardRockNonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            var beatmap = createNonConvertBeatmap(overallDifficulty);
+
+            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 ManiaModHardRock()],
+                }
+            };
+
+            RunTest($@"SV1+HR single note @ OD{overallDifficulty}", beatmap, $@"SV1+HR {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        [TestCaseSource(nameof(score_v1_non_convert_easy_test_cases))]
+        public void TestHitWindowTreatmentWithScoreV1AndEasyNonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            var beatmap = createNonConvertBeatmap(overallDifficulty);
+
+            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 ManiaModEasy()],
+                }
+            };
+
+            RunTest($@"SV1+EZ single note @ OD{overallDifficulty}", beatmap, $@"SV1+EZ {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        [TestCaseSource(nameof(score_v1_non_convert_double_time_test_cases))]
+        public void TestHitWindowTreatmentWithScoreV1AndDoubleTimeNonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            var beatmap = createNonConvertBeatmap(overallDifficulty);
+
+            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 ManiaModDoubleTime()],
+                }
+            };
+
+            RunTest($@"SV1+DT single note @ OD{overallDifficulty}", beatmap, $@"SV1+DT {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        [TestCaseSource(nameof(score_v1_non_convert_half_time_test_cases))]
+        public void TestHitWindowTreatmentWithScoreV1AndHalfTimeNonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            var beatmap = createNonConvertBeatmap(overallDifficulty);
+
+            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 ManiaModHalfTime()],
+                }
+            };
+
+            RunTest($@"SV1+HT single note @ OD{overallDifficulty}", beatmap, $@"SV1+HT {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        private static ManiaBeatmap createNonConvertBeatmap(float overallDifficulty)
+        {
+            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,
+            };
+            return beatmap;
+        }
+
+        private static Beatmap createConvertBeatmap(float overallDifficulty)
+        {
+            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,
+            };
+            return beatmap;
+        }
+
         private class FakeCircle : HitObject, IHasPosition
         {
             public float X

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

@@ -18,7 +18,12 @@ namespace osu.Game.Rulesets.Mania.Tests
         protected override Ruleset CreatePlayerRuleset() => new ManiaRuleset();
 
         [SetUp]
-        public void SetUp() => Schedule(() => toggleTouchControls(false));
+        public void SetUp() => Schedule(() =>
+        {
+            InputManager.EndTouch(new Touch(TouchSource.Touch1, Vector2.Zero));
+            InputManager.EndTouch(new Touch(TouchSource.Touch2, Vector2.Zero));
+            toggleTouchControls(false);
+        });
 
         #region Without touch controls
 
@@ -71,6 +76,35 @@ namespace osu.Game.Rulesets.Mania.Tests
                 () => Does.Not.Contain(getColumn(0).Action.Value));
         }
 
+        [Test]
+        public void TestBetweenTwoColumns()
+        {
+            AddStep("touch after column 0", () =>
+            {
+                var column = getColumn(0);
+                InputManager.BeginTouch(new Touch(TouchSource.Touch1, column.ToScreenSpace(new Vector2(column.LayoutSize.X + 0.5f, column.LayoutSize.Y / 2))));
+            });
+            AddAssert("column 0 pressed",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Contain(getColumn(0).Action.Value));
+            AddStep("release finger", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, getColumn(0).ScreenSpaceDrawQuad.Centre)));
+            AddAssert("column 0 released",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Not.Contain(getColumn(0).Action.Value));
+            AddStep("touch before column 1", () =>
+            {
+                var column = getColumn(1);
+                InputManager.BeginTouch(new Touch(TouchSource.Touch1, column.ToScreenSpace(new Vector2(-0.5f, column.LayoutSize.Y / 2))));
+            });
+            AddAssert("column 1 pressed",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Contain(getColumn(1).Action.Value));
+            AddStep("release finger", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, getColumn(0).ScreenSpaceDrawQuad.Centre)));
+            AddAssert("column 1 released",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Not.Contain(getColumn(1).Action.Value));
+        }
+
         #endregion
 
         #region With touch controls
@@ -132,6 +166,38 @@ namespace osu.Game.Rulesets.Mania.Tests
                 () => Does.Not.Contain(getColumn(0).Action.Value));
         }
 
+        [Test]
+        public void TestTouchControlBetweenTwoColumns()
+        {
+            AddStep("enable touch controls", () => toggleTouchControls(true));
+
+            AddStep("touch after receptor 0", () =>
+            {
+                var column = getReceptor(0);
+                InputManager.BeginTouch(new Touch(TouchSource.Touch1, column.ToScreenSpace(new Vector2(column.LayoutSize.X + 1f, column.LayoutSize.Y / 2))));
+            });
+
+            AddAssert("column 0 pressed",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Contain(getReceptor(0).Action.Value));
+            AddStep("release finger", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, getReceptor(0).ScreenSpaceDrawQuad.Centre)));
+            AddAssert("column 0 released",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Not.Contain(getReceptor(0).Action.Value));
+            AddStep("touch before receptor 1", () =>
+            {
+                var column = getReceptor(1);
+                InputManager.BeginTouch(new Touch(TouchSource.Touch1, column.ToScreenSpace(new Vector2(-1f, column.LayoutSize.Y / 2))));
+            });
+            AddAssert("column 1 pressed",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Contain(getReceptor(1).Action.Value));
+            AddStep("release finger", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, getReceptor(0).ScreenSpaceDrawQuad.Centre)));
+            AddAssert("column 1 released",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Not.Contain(getReceptor(1).Action.Value));
+        }
+
         #endregion
 
         private void toggleTouchControls(bool enabled)

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

@@ -0,0 +1,61 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Replays;
+using osu.Game.Storyboards;
+using osu.Game.Tests.Visual;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public partial class TestSceneReplayRecording : PlayerTestScene
+    {
+        protected override Ruleset CreatePlayerRuleset() => new ManiaRuleset();
+
+        [Resolved]
+        private AudioManager audioManager { get; set; } = null!;
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new ManiaBeatmap(new StageDefinition(1))
+        {
+            HitObjects =
+            {
+                new Note { StartTime = 0, },
+                new Note { StartTime = 5000, },
+                new Note { StartTime = 10000, },
+                new Note { StartTime = 15000, }
+            },
+            Difficulty = { CircleSize = 1 },
+            BeatmapInfo =
+            {
+                Ruleset = ruleset,
+            }
+        };
+
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard? storyboard = null) =>
+            new ClockBackedTestWorkingBeatmap(beatmap, storyboard, new FramedClock(new ManualClock { Rate = 1 }), audioManager);
+
+        [Test]
+        public void TestRecording()
+        {
+            seekTo(0);
+            AddStep("press space", () => InputManager.PressKey(Key.Space));
+            seekTo(15);
+            AddStep("release space", () => InputManager.ReleaseKey(Key.Space));
+            AddUntilStep("button press recorded to replay", () => Player.Score.Replay.Frames.OfType<ManiaReplayFrame>().Any(f => f.Actions.SequenceEqual([ManiaAction.Key1])));
+        }
+
+        private void seekTo(double time)
+        {
+            AddStep($"seek to {time}ms", () => Player.GameplayClockContainer.Seek(time));
+            AddUntilStep("wait for seek to finish", () => Player.DrawableRuleset.FrameStableClock.CurrentTime, () => Is.EqualTo(time).Within(500));
+        }
+    }
+}

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

@@ -0,0 +1,125 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+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.Rulesets.UI;
+using osu.Game.Scoring;
+using osu.Game.Screens.Play;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public partial class TestSceneReplayRewinding : RateAdjustedBeatmapTestScene
+    {
+        private ReplayPlayer currentPlayer = null!;
+
+        [Test]
+        public void TestRewindingToMiddleOfHoldNote()
+        {
+            Score score = null!;
+
+            var beatmap = new ManiaBeatmap(new StageDefinition(4))
+            {
+                HitObjects =
+                {
+                    new HoldNote
+                    {
+                        StartTime = 500,
+                        EndTime = 1500,
+                        Column = 2
+                    }
+                }
+            };
+
+            AddStep(@"create replay", () => score = new Score
+            {
+                Replay = new Replay
+                {
+                    Frames =
+                    {
+                        new ManiaReplayFrame(500, ManiaAction.Key3),
+                        new ManiaReplayFrame(1500),
+                    }
+                },
+                ScoreInfo = new ScoreInfo()
+            });
+
+            AddStep(@"set beatmap", () => Beatmap.Value = CreateWorkingBeatmap(beatmap));
+            AddStep(@"set ruleset", () => Ruleset.Value = beatmap.BeatmapInfo.Ruleset);
+            AddStep(@"push player", () => LoadScreen(currentPlayer = new ReplayPlayer(score)));
+
+            AddUntilStep(@"wait until player is loaded", () => currentPlayer.IsCurrentScreen());
+            AddUntilStep(@"wait for hold to be judged", () => currentPlayer.ChildrenOfType<IFrameStableClock>().Single().CurrentTime, () => Is.GreaterThan(1600));
+            AddStep(@"seek to middle of hold note", () => currentPlayer.Seek(1000));
+            AddUntilStep(@"wait for gameplay to complete", () => currentPlayer.GameplayState.HasCompleted);
+            AddAssert(@"no misses registered", () => currentPlayer.GameplayState.ScoreProcessor.Statistics.GetValueOrDefault(HitResult.Miss), () => Is.Zero);
+
+            AddStep(@"exit player", () => currentPlayer.Exit());
+        }
+
+        [Test]
+        public void TestCorrectComboAccountingForConcurrentObjects()
+        {
+            Score score = null!;
+
+            var beatmap = new ManiaBeatmap(new StageDefinition(4))
+            {
+                HitObjects =
+                {
+                    new Note
+                    {
+                        StartTime = 500,
+                        Column = 0,
+                    },
+                    new Note
+                    {
+                        StartTime = 500,
+                        Column = 2,
+                    },
+                    new HoldNote
+                    {
+                        StartTime = 1000,
+                        EndTime = 1500,
+                        Column = 1,
+                    }
+                }
+            };
+
+            AddStep(@"create replay", () => score = new Score
+            {
+                Replay = new Replay
+                {
+                    Frames =
+                    {
+                        new ManiaReplayFrame(500, ManiaAction.Key1, ManiaAction.Key3),
+                        new ManiaReplayFrame(520),
+                        new ManiaReplayFrame(1000, ManiaAction.Key2),
+                        new ManiaReplayFrame(1500),
+                    }
+                },
+                ScoreInfo = new ScoreInfo()
+            });
+
+            AddStep(@"set beatmap", () => Beatmap.Value = CreateWorkingBeatmap(beatmap));
+            AddStep(@"set ruleset", () => Ruleset.Value = beatmap.BeatmapInfo.Ruleset);
+            AddStep(@"push player", () => LoadScreen(currentPlayer = new ReplayPlayer(score)));
+
+            AddUntilStep(@"wait until player is loaded", () => currentPlayer.IsCurrentScreen());
+            AddUntilStep(@"wait for objects to be judged", () => currentPlayer.ChildrenOfType<IFrameStableClock>().Single().CurrentTime, () => Is.GreaterThan(1600));
+            AddStep(@"stop gameplay", () => currentPlayer.ChildrenOfType<GameplayClockContainer>().Single().Stop());
+            AddStep(@"seek to start", () => currentPlayer.Seek(0));
+            AddAssert(@"combo is 0", () => currentPlayer.GameplayState.ScoreProcessor.Combo.Value, () => Is.Zero);
+
+            AddStep(@"exit player", () => currentPlayer.Exit());
+        }
+    }
+}

osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs

@@ -0,0 +1,43 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
+using osu.Game.Rulesets.Edit.Checks.Components;
+using osu.Game.Rulesets.Objects.Types;
+
+namespace osu.Game.Rulesets.Mania.Edit.Checks
+{
+    public class CheckManiaConcurrentObjects : CheckConcurrentObjects
+    {
+        public override IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            var hitObjects = context.Beatmap.HitObjects;
+
+            for (int i = 0; i < hitObjects.Count - 1; ++i)
+            {
+                var hitobject = hitObjects[i];
+
+                for (int j = i + 1; j < hitObjects.Count; ++j)
+                {
+                    var nextHitobject = hitObjects[j];
+
+                    // Mania hitobjects are only considered concurrent if they also share the same column.
+                    if ((hitobject as IHasColumn)?.Column != (nextHitobject as IHasColumn)?.Column)
+                        continue;
+
+                    // Two hitobjects cannot be concurrent without also being concurrent with all objects in between.
+                    // So if the next object is not concurrent, then we know no future objects will be either.
+                    if (!AreConcurrent(hitobject, nextHitobject))
+                        break;
+
+                    if (hitobject.GetType() == nextHitobject.GetType())
+                        yield return new IssueTemplateConcurrentSame(this).Create(hitobject, nextHitobject);
+                    else
+                        yield return new IssueTemplateConcurrentDifferent(this).Create(hitobject, nextHitobject);
+                }
+            }
+        }
+    }
+}

osu.Game.Rulesets.Mania/Edit/ManiaBeatmapVerifier.cs

@@ -13,6 +13,9 @@ namespace osu.Game.Rulesets.Mania.Edit
     {
         private readonly List<ICheck> checks = new List<ICheck>
         {
+            // Compose
+            new CheckManiaConcurrentObjects(),
+
             // Settings
             new CheckKeyCount(),
             new CheckManiaAbnormalDifficultySettings(),

osu.Game.Rulesets.Mania/Judgements/HoldNoteJudgementResult.cs

@@ -0,0 +1,48 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mania.Objects;
+
+namespace osu.Game.Rulesets.Mania.Judgements
+{
+    public class HoldNoteJudgementResult : JudgementResult
+    {
+        private Stack<(double time, bool holding)> holdingState { get; } = new Stack<(double, bool)>();
+
+        public HoldNoteJudgementResult(HoldNote hitObject, Judgement judgement)
+            : base(hitObject, judgement)
+        {
+            holdingState.Push((double.NegativeInfinity, false));
+        }
+
+        private (double time, bool holding) getLastReport(double currentTime)
+        {
+            while (holdingState.Peek().time > currentTime)
+                holdingState.Pop();
+
+            return holdingState.Peek();
+        }
+
+        public bool IsHolding(double currentTime) => getLastReport(currentTime).holding;
+
+        public bool DroppedHoldAfter(double time)
+        {
+            foreach (var state in holdingState)
+            {
+                if (state.time >= time && !state.holding)
+                    return true;
+            }
+
+            return false;
+        }
+
+        public void ReportHoldState(double currentTime, bool holding)
+        {
+            var lastReport = getLastReport(currentTime);
+            if (holding != lastReport.holding)
+                holdingState.Push((currentTime, holding));
+        }
+    }
+}

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

@@ -29,6 +29,8 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override bool Ranked => false;
 
+        public override bool ValidForFreestyleAsRequiredMod => false;
+
         [SettingSource("Coverage", "The proportion of playfield height that notes will be hidden for.")]
         public override BindableNumber<float> Coverage { get; } = new BindableFloat(0.5f)
         {

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/Mods/ManiaModFadeIn.cs

@@ -14,6 +14,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override string Acronym => "FI";
         public override LocalisableString Description => @"Keys appear out of nowhere!";
         public override double ScoreMultiplier => 1;
+        public override bool ValidForFreestyleAsRequiredMod => false;
 
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[]
         {

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

@@ -62,7 +62,7 @@ namespace osu.Game.Rulesets.Mania.Mods
             protected override void CheckForResult(bool userTriggered, double timeOffset)
             {
                 // apply perfect once the tail is reached
-                if (HoldNote.HoldStartTime != null && timeOffset >= 0)
+                if (HoldNote.IsHolding.Value && timeOffset >= 0)
                     ApplyResult(GetCappedResult(HitResult.Perfect));
                 else
                     base.CheckForResult(userTriggered, timeOffset);

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

@@ -1,6 +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 osu.Framework.Bindables;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
@@ -9,13 +11,16 @@ namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModPerfect : ModPerfect
     {
+        [SettingSource("Require perfect hits")]
+        public BindableBool RequirePerfectHits { get; } = new BindableBool();
+
         protected override bool FailCondition(HealthProcessor healthProcessor, JudgementResult result)
         {
             if (!isRelevantResult(result.Judgement.MinResult) && !isRelevantResult(result.Judgement.MaxResult) && !isRelevantResult(result.Type))
                 return false;
 
             // Mania allows imperfect "Great" hits without failing.
-            if (result.Judgement.MaxResult == HitResult.Perfect)
+            if (result.Judgement.MaxResult == HitResult.Perfect && !RequirePerfectHits.Value)
                 return result.Type < HitResult.Great;
 
             return result.Type != result.Judgement.MaxResult;

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNote.cs

@@ -11,6 +11,8 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Game.Audio;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Mania.Skinning.Default;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -29,9 +31,9 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
     {
         public override bool DisplayResult => false;
 
-        public IBindable<bool> IsHitting => isHitting;
+        public IBindable<bool> IsHolding => isHolding;
 
-        private readonly Bindable<bool> isHitting = new Bindable<bool>();
+        private readonly Bindable<bool> isHolding = new Bindable<bool>();
 
         public DrawableHoldNoteHead Head => headContainer.Child;
         public DrawableHoldNoteTail Tail => tailContainer.Child;
@@ -55,16 +57,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
         private SkinnableDrawable bodyPiece;
 
-        /// <summary>
-        /// Time at which the user started holding this hold note. Null if the user is not holding this hold note.
-        /// </summary>
-        public double? HoldStartTime { get; private set; }
-
-        /// <summary>
-        /// Used to decide whether to visually clamp the hold note to the judgement line.
-        /// </summary>
-        private double? releaseTime;
-
         public DrawableHoldNote()
             : this(null)
         {
@@ -126,7 +118,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
             base.LoadComplete();
 
-            isHitting.BindValueChanged(updateSlidingSample, true);
+            isHolding.BindValueChanged(updateSlidingSample, true);
         }
 
         protected override void OnApply()
@@ -134,8 +126,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             base.OnApply();
 
             sizingContainer.Size = Vector2.One;
-            HoldStartTime = null;
-            releaseTime = null;
         }
 
         protected override void AddNestedHitObject(DrawableHitObject hitObject)
@@ -214,11 +204,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
             base.Update();
 
-            if (Time.Current < releaseTime)
-                releaseTime = null;
-
-            if (Time.Current < HoldStartTime)
-                endHold();
+            isHolding.Value = Result.IsHolding(Time.Current);
 
             // Pad the full size container so its contents (i.e. the masking container) reach under the tail.
             // This is required for the tail to not be masked away, since it lies outside the bounds of the hold note.
@@ -249,7 +235,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 //
                 // As per stable, this should not apply for early hits, waiting until the object starts to touch the
                 // judgement area first.
-                if (Head.IsHit && releaseTime == null && DrawHeight > 0)
+                if (Head.IsHit && !Result.DroppedHoldAfter(HitObject.StartTime) && DrawHeight > 0)
                 {
                     // How far past the hit target this hold note is.
                     float yOffset = Direction.Value == ScrollingDirection.Up ? -Y : Y;
@@ -260,6 +246,10 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 sizingContainer.Height = 1;
         }
 
+        protected override JudgementResult CreateResult(Judgement judgement) => new HoldNoteJudgementResult(HitObject, judgement);
+
+        public new HoldNoteJudgementResult Result => (HoldNoteJudgementResult)base.Result;
+
         protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
             if (Tail.AllJudged)
@@ -274,7 +264,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                     Body.TriggerResult(Tail.IsHit);
 
                 // Important that this is always called when a result is applied.
-                endHold();
+                Result.ReportHoldState(Time.Current, false);
             }
         }
 
@@ -283,7 +273,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             base.MissForcefully();
 
             // Important that this is always called when a result is applied.
-            endHold();
+            Result.ReportHoldState(Time.Current, false);
         }
 
         public bool OnPressed(KeyBindingPressEvent<ManiaAction> e)
@@ -317,8 +307,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             if (timeOffset < -Head.HitObject.HitWindows.WindowFor(HitResult.Miss))
                 return;
 
-            HoldStartTime = Time.Current;
-            isHitting.Value = true;
+            Result.ReportHoldState(Time.Current, true);
         }
 
         public void OnReleased(KeyBindingReleaseEvent<ManiaAction> e)
@@ -337,22 +326,15 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             // the user has released too early (before the tail).
             //
             // In such a case, we want to record this against the DrawableHoldNoteBody.
-            if (HoldStartTime != null)
+            if (isHolding.Value)
             {
                 Tail.UpdateResult();
                 Body.TriggerResult(Tail.IsHit);
 
-                endHold();
-                releaseTime = Time.Current;
+                Result.ReportHoldState(Time.Current, false);
             }
         }
 
-        private void endHold()
-        {
-            HoldStartTime = null;
-            isHitting.Value = false;
-        }
-
         protected override void LoadSamples()
         {
             // Note: base.LoadSamples() isn't called since the slider plays the tail's hitsounds for the time being.

osu.Game.Rulesets.Mania/Skinning/Argon/ArgonHoldBodyPiece.cs

@@ -48,7 +48,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
 
                 AccentColour.BindTo(holdNote.AccentColour);
                 hittingLayer.AccentColour.BindTo(holdNote.AccentColour);
-                ((IBindable<bool>)hittingLayer.IsHitting).BindTo(holdNote.IsHitting);
+                ((IBindable<bool>)hittingLayer.IsHitting).BindTo(holdNote.IsHolding);
             }
 
             AccentColour.BindValueChanged(colour =>

osu.Game.Rulesets.Mania/Skinning/Argon/ArgonHoldNoteTailPiece.cs

@@ -103,7 +103,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
             hittingLayer.AccentColour.BindTo(holdNoteTail.HoldNote.AccentColour);
 
             hittingLayer.IsHitting.UnbindBindings();
-            ((IBindable<bool>)hittingLayer.IsHitting).BindTo(holdNoteTail.HoldNote.IsHitting);
+            ((IBindable<bool>)hittingLayer.IsHitting).BindTo(holdNoteTail.HoldNote.IsHolding);
         }
 
         private void onDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)

osu.Game.Rulesets.Mania/Skinning/Argon/ManiaArgonSkinTransformer.cs

@@ -40,9 +40,13 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
                         case GlobalSkinnableContainers.MainHUDComponents:
                             return new DefaultSkinComponentsContainer(container =>
                             {
+                                var leaderboard = container.OfType<DrawableGameplayLeaderboard>().FirstOrDefault();
                                 var combo = container.ChildrenOfType<ArgonManiaComboCounter>().FirstOrDefault();
                                 var spectatorList = container.OfType<SpectatorList>().FirstOrDefault();
 
+                                if (leaderboard != null)
+                                    leaderboard.Position = new Vector2(36, 115);
+
                                 if (combo != null)
                                 {
                                     combo.ShowLabel.Value = false;
@@ -55,6 +59,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
                                     spectatorList.Position = new Vector2(36, -66);
                             })
                             {
+                                new DrawableGameplayLeaderboard(),
                                 new ArgonManiaComboCounter(),
                                 new SpectatorList
                                 {
@@ -131,8 +136,9 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
 
                 switch (maniaLookup.Lookup)
                 {
-                    case LegacyManiaSkinConfigurationLookups.ColumnSpacing:
-                        return SkinUtils.As<TValue>(new Bindable<float>(2));
+                    case LegacyManiaSkinConfigurationLookups.LeftColumnSpacing:
+                    case LegacyManiaSkinConfigurationLookups.RightColumnSpacing:
+                        return SkinUtils.As<TValue>(new Bindable<float>(1));
 
                     case LegacyManiaSkinConfigurationLookups.StagePaddingBottom:
                     case LegacyManiaSkinConfigurationLookups.StagePaddingTop:
@@ -146,7 +152,6 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
                         return SkinUtils.As<TValue>(new Bindable<float>(width));
 
                     case LegacyManiaSkinConfigurationLookups.ColumnBackgroundColour:
-
                         var colour = getColourForLayout(columnIndex, stage);
 
                         return SkinUtils.As<TValue>(new Bindable<Color4>(colour));

osu.Game.Rulesets.Mania/Skinning/Default/DefaultBodyPiece.cs

@@ -46,7 +46,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Default
                 var holdNote = (DrawableHoldNote)drawableObject;
 
                 AccentColour.BindTo(drawableObject.AccentColour);
-                IsHitting.BindTo(holdNote.IsHitting);
+                IsHitting.BindTo(holdNote.IsHolding);
             }
 
             AccentColour.BindValueChanged(onAccentChanged, true);

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

@@ -86,7 +86,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
             var wrapMode = bodyStyle == LegacyNoteBodyStyle.Stretch ? WrapMode.ClampToEdge : WrapMode.Repeat;
 
             direction.BindTo(scrollingInfo.Direction);
-            isHitting.BindTo(holdNote.IsHitting);
+            isHitting.BindTo(holdNote.IsHolding);
 
             bodySprite = skin.GetAnimation(imageName, wrapMode, wrapMode, true, true, frameLength: 30)?.With(d =>
             {

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

@@ -98,6 +98,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
                             {
                                 var combo = container.ChildrenOfType<LegacyManiaComboCounter>().FirstOrDefault();
                                 var spectatorList = container.OfType<SpectatorList>().FirstOrDefault();
+                                var leaderboard = container.OfType<DrawableGameplayLeaderboard>().FirstOrDefault();
 
                                 if (combo != null)
                                 {
@@ -112,10 +113,18 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
                                     spectatorList.Origin = Anchor.BottomLeft;
                                     spectatorList.Position = new Vector2(10, -10);
                                 }
+
+                                if (leaderboard != null)
+                                {
+                                    leaderboard.Anchor = Anchor.CentreLeft;
+                                    leaderboard.Origin = Anchor.CentreLeft;
+                                    leaderboard.X = 10;
+                                }
                             })
                             {
                                 new LegacyManiaComboCounter(),
                                 new SpectatorList(),
+                                new DrawableGameplayLeaderboard(),
                             };
                     }
 

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

@@ -60,6 +60,9 @@ namespace osu.Game.Rulesets.Mania.UI
 
         private IBindable<ManiaMobileLayout> mobilePlayStyle = null!;
 
+        private float leftColumnSpacing;
+        private float rightColumnSpacing;
+
         public Column(int index, bool isSpecial)
         {
             Index = index;
@@ -126,6 +129,14 @@ namespace osu.Game.Rulesets.Mania.UI
         private void onSourceChanged()
         {
             AccentColour.Value = skin.GetManiaSkinConfig<Color4>(LegacyManiaSkinConfigurationLookups.ColumnBackgroundColour, Index)?.Value ?? Color4.Black;
+
+            leftColumnSpacing = skin.GetConfig<ManiaSkinConfigurationLookup, float>(
+                                        new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.LeftColumnSpacing, Index))
+                                    ?.Value ?? Stage.COLUMN_SPACING;
+
+            rightColumnSpacing = skin.GetConfig<ManiaSkinConfigurationLookup, float>(
+                                         new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.RightColumnSpacing, Index))
+                                     ?.Value ?? Stage.COLUMN_SPACING;
         }
 
         protected override void LoadComplete()
@@ -187,8 +198,11 @@ namespace osu.Game.Rulesets.Mania.UI
         }
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos)
-            // This probably shouldn't exist as is, but the columns in the stage are separated by a 1px border
-            => DrawRectangle.Inflate(new Vector2(Stage.COLUMN_SPACING / 2, 0)).Contains(ToLocalSpace(screenSpacePos));
+        {
+            // Extend input coverage to the gaps close to this column.
+            var spacingInflation = new MarginPadding { Left = leftColumnSpacing, Right = rightColumnSpacing };
+            return DrawRectangle.Inflate(spacingInflation).Contains(ToLocalSpace(screenSpacePos));
+        }
 
         #region Touch Input
 

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

@@ -124,14 +124,15 @@ namespace osu.Game.Rulesets.Mania.UI
 
             for (int i = 0; i < stageDefinition.Columns; i++)
             {
-                if (i > 0)
-                {
-                    float spacing = skin.GetConfig<ManiaSkinConfigurationLookup, float>(
-                                            new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.ColumnSpacing, i - 1))
+                float leftSpacing = skin.GetConfig<ManiaSkinConfigurationLookup, float>(
+                                            new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.LeftColumnSpacing, i))
                                         ?.Value ?? Stage.COLUMN_SPACING;
 
-                    columns[i].Margin = new MarginPadding { Left = spacing };
-                }
+                float rightSpacing = skin.GetConfig<ManiaSkinConfigurationLookup, float>(
+                                             new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.RightColumnSpacing, i))
+                                         ?.Value ?? Stage.COLUMN_SPACING;
+
+                columns[i].Margin = new MarginPadding { Left = leftSpacing, Right = rightSpacing };
 
                 float? width = skin.GetConfig<ManiaSkinConfigurationLookup, float>(
                                        new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.ColumnWidth, i))

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

@@ -74,6 +74,7 @@ namespace osu.Game.Rulesets.Mania.UI
                     receptorGridContent.Add(new ColumnInputReceptor
                     {
                         Action = { BindTarget = column.Action },
+                        Spacing = { BindTarget = Spacing },
                     });
                     receptorGridDimensions.Add(new Dimension());
 
@@ -122,6 +123,7 @@ namespace osu.Game.Rulesets.Mania.UI
         public partial class ColumnInputReceptor : CompositeDrawable
         {
             public readonly IBindable<ManiaAction> Action = new Bindable<ManiaAction>();
+            public readonly IBindable<float> Spacing = new BindableFloat();
 
             private readonly Box highlightOverlay;
 
@@ -159,6 +161,10 @@ namespace osu.Game.Rulesets.Mania.UI
                 };
             }
 
+            public override bool ReceivePositionalInputAt(Vector2 screenSpacePos)
+                // Extend input coverage to the gaps close to this receptor.
+                => DrawRectangle.Inflate(new Vector2(Spacing.Value / 2, 0)).Contains(ToLocalSpace(screenSpacePos));
+
             protected override bool OnTouchDown(TouchDownEvent e)
             {
                 updateButton(true);

osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModStrictTracking.cs

@@ -49,5 +49,59 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
             },
             PassCondition = () => Player.ScoreProcessor.Combo.Value == 2
         });
+
+        [Test]
+        public void TestRewind()
+        {
+            bool seekedBack = false;
+            bool missRecorded = false;
+
+            CreateModTest(new ModTestData
+            {
+                Mod = new OsuModStrictTracking(),
+                Autoplay = false,
+                CreateBeatmap = () => new Beatmap
+                {
+                    HitObjects = new List<HitObject>
+                    {
+                        new Slider
+                        {
+                            StartTime = 1000,
+                            Path = new SliderPath
+                            {
+                                ControlPoints =
+                                {
+                                    new PathControlPoint(),
+                                    new PathControlPoint(new Vector2(0, 100))
+                                }
+                            }
+                        }
+                    }
+                },
+                ReplayFrames = new List<ReplayFrame>
+                {
+                    new OsuReplayFrame(0, new Vector2(100, 0)),
+                    new OsuReplayFrame(1000, new Vector2(100, 0)),
+                    new OsuReplayFrame(1050, new Vector2()),
+                    new OsuReplayFrame(1100, new Vector2(), OsuAction.LeftButton),
+                    new OsuReplayFrame(1750, new Vector2(0, 100), OsuAction.LeftButton),
+                    new OsuReplayFrame(1751, new Vector2(0, 100)),
+                },
+                PassCondition = () => seekedBack && !missRecorded,
+            });
+            AddStep("subscribe to new judgements", () => Player.ScoreProcessor.NewJudgement += j =>
+            {
+                if (!j.IsHit)
+                    missRecorded = true;
+            });
+            AddUntilStep("wait for gameplay completion", () => Player.GameplayState.HasCompleted);
+            AddAssert("no misses", () => missRecorded, () => Is.False);
+            AddStep("seek back", () =>
+            {
+                Player.GameplayClockContainer.Stop();
+                Player.Seek(1040);
+                seekedBack = true;
+            });
+        }
     }
 }

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

@@ -6,6 +6,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Rulesets.Osu.UI;
@@ -23,7 +24,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         protected override string? ExportLocation => null;
 
-        private static readonly object[][] test_cases =
+        private static readonly object[][] no_mod_test_cases =
         {
             // With respect to notation,
             // square brackets `[]` represent *closed* or *inclusive* bounds,
@@ -65,30 +66,73 @@ namespace osu.Game.Rulesets.Osu.Tests
             new object[] { 5.7f, 144d, HitResult.Miss },
         };
 
-        [TestCaseSource(nameof(test_cases))]
+        private static readonly object[][] hard_rock_test_cases =
+        {
+            // OD = 5 test cases.
+            // This leads to "effective" OD of 7.
+            // GREAT hit window is ( -38ms,  38ms)
+            // OK    hit window is ( -84ms,  84ms)
+            // MEH   hit window is (-130ms, 130ms)
+            new object[] { 5f, 36d, HitResult.Great },
+            new object[] { 5f, 37d, HitResult.Great },
+            new object[] { 5f, 38d, HitResult.Ok },
+            new object[] { 5f, 39d, HitResult.Ok },
+            new object[] { 5f, 82d, HitResult.Ok },
+            new object[] { 5f, 83d, HitResult.Ok },
+            new object[] { 5f, 84d, HitResult.Meh },
+            new object[] { 5f, 85d, HitResult.Meh },
+            new object[] { 5f, 128d, HitResult.Meh },
+            new object[] { 5f, 129d, HitResult.Meh },
+            new object[] { 5f, 130d, HitResult.Miss },
+            new object[] { 5f, 131d, HitResult.Miss },
+
+            // OD = 8 test cases.
+            // This would lead to "effective" OD of 11.2,
+            // but the effects are capped to OD 10.
+            // GREAT hit window is ( -20ms,  20ms)
+            // OK    hit window is ( -60ms,  60ms)
+            // MEH   hit window is (-100ms, 100ms)
+            new object[] { 8f, 18d, HitResult.Great },
+            new object[] { 8f, 19d, HitResult.Great },
+            new object[] { 8f, 20d, HitResult.Ok },
+            new object[] { 8f, 21d, HitResult.Ok },
+            new object[] { 8f, 58d, HitResult.Ok },
+            new object[] { 8f, 59d, HitResult.Ok },
+            new object[] { 8f, 60d, HitResult.Meh },
+            new object[] { 8f, 61d, HitResult.Meh },
+            new object[] { 8f, 98d, HitResult.Meh },
+            new object[] { 8f, 99d, HitResult.Meh },
+            new object[] { 8f, 100d, HitResult.Miss },
+            new object[] { 8f, 101d, HitResult.Miss },
+        };
+
+        private static readonly object[][] easy_test_cases =
+        {
+            // OD = 5 test cases.
+            // This leads to "effective" OD of 2.5.
+            // GREAT hit window is ( -65ms,  65ms)
+            // OK    hit window is (-120ms, 120ms)
+            // MEH   hit window is (-175ms, 175ms)
+            new object[] { 5f, 63d, HitResult.Great },
+            new object[] { 5f, 64d, HitResult.Great },
+            new object[] { 5f, 65d, HitResult.Ok },
+            new object[] { 5f, 66d, HitResult.Ok },
+            new object[] { 5f, 118d, HitResult.Ok },
+            new object[] { 5f, 119d, HitResult.Ok },
+            new object[] { 5f, 120d, HitResult.Meh },
+            new object[] { 5f, 121d, HitResult.Meh },
+            new object[] { 5f, 173d, HitResult.Meh },
+            new object[] { 5f, 174d, HitResult.Meh },
+            new object[] { 5f, 175d, HitResult.Miss },
+            new object[] { 5f, 176d, HitResult.Miss },
+        };
+
+        private const double hit_circle_time = 100;
+
+        [TestCaseSource(nameof(no_mod_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 beatmap = createBeatmap(overallDifficulty);
 
             var replay = new Replay
             {
@@ -114,5 +158,91 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             RunTest($@"single circle @ OD{overallDifficulty}", beatmap, $@"{hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
         }
+
+        [TestCaseSource(nameof(hard_rock_test_cases))]
+        public void TestHitWindowTreatmentWithHardRock(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            var beatmap = createBeatmap(overallDifficulty);
+
+            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,
+                    Mods = [new OsuModHardRock()]
+                }
+            };
+
+            RunTest($@"HR single circle @ OD{overallDifficulty}", beatmap, $@"HR {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        [TestCaseSource(nameof(easy_test_cases))]
+        public void TestHitWindowTreatmentWithEasy(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            var beatmap = createBeatmap(overallDifficulty);
+
+            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,
+                    Mods = [new OsuModEasy()]
+                }
+            };
+
+            RunTest($@"EZ single circle @ OD{overallDifficulty}", beatmap, $@"EZ {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        private static OsuBeatmap createBeatmap(float overallDifficulty)
+        {
+            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,
+            };
+            return beatmap;
+        }
     }
 }

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

@@ -8,6 +8,7 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Testing;
+using osu.Framework.Timing;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Osu.Configuration;
 using osu.Game.Rulesets.Osu.Replays;
@@ -26,6 +27,8 @@ namespace osu.Game.Rulesets.Osu.Tests
         [Cached]
         private OsuRulesetConfigManager config = new OsuRulesetConfigManager(null, new OsuRuleset().RulesetInfo);
 
+        private readonly StopwatchClock clock = new StopwatchClock();
+
         [SetUpSteps]
         public void SetUpSteps()
         {
@@ -35,7 +38,10 @@ namespace osu.Game.Rulesets.Osu.Tests
                 {
                     new OsuPlayfieldAdjustmentContainer
                     {
-                        Child = analysisContainer = new TestReplayAnalysisOverlay(fabricateReplay()),
+                        Child = analysisContainer = new TestReplayAnalysisOverlay(fabricateReplay())
+                        {
+                            Clock = new FramedClock(clock)
+                        },
                     },
                     settings = new ReplayAnalysisSettings(config),
                 };
@@ -55,11 +61,23 @@ namespace osu.Game.Rulesets.Osu.Tests
                 settings.ShowAimMarkers.Value = true;
                 settings.ShowCursorPath.Value = true;
             });
+            AddToggleStep("toggle pause", running =>
+            {
+                if (running)
+                    clock.Stop();
+                else
+                    clock.Start();
+            });
         }
 
         [Test]
         public void TestHitMarkers()
         {
+            AddStep("stop at 2000", () =>
+            {
+                clock.Stop();
+                clock.Seek(2000);
+            });
             AddStep("enable hit markers", () => settings.ShowClickMarkers.Value = true);
             AddUntilStep("hit markers visible", () => analysisContainer.HitMarkersVisible);
             AddStep("disable hit markers", () => settings.ShowClickMarkers.Value = false);
@@ -69,6 +87,11 @@ namespace osu.Game.Rulesets.Osu.Tests
         [Test]
         public void TestAimMarker()
         {
+            AddStep("stop at 2000", () =>
+            {
+                clock.Stop();
+                clock.Seek(2000);
+            });
             AddStep("enable aim markers", () => settings.ShowAimMarkers.Value = true);
             AddUntilStep("aim markers visible", () => analysisContainer.AimMarkersVisible);
             AddStep("disable aim markers", () => settings.ShowAimMarkers.Value = false);
@@ -78,6 +101,11 @@ namespace osu.Game.Rulesets.Osu.Tests
         [Test]
         public void TestAimLines()
         {
+            AddStep("stop at 2000", () =>
+            {
+                clock.Stop();
+                clock.Seek(2000);
+            });
             AddStep("enable aim lines", () => settings.ShowCursorPath.Value = true);
             AddUntilStep("aim lines visible", () => analysisContainer.AimLinesVisible);
             AddStep("disable aim lines", () => settings.ShowCursorPath.Value = false);
@@ -87,7 +115,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         private Replay fabricateReplay()
         {
             var frames = new List<ReplayFrame>();
-            var random = new Random();
+            var random = new Random(20250522);
             int posX = 250;
             int posY = 250;
 
@@ -109,7 +137,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
                 frames.Add(new OsuReplayFrame
                 {
-                    Time = Time.Current + i * 15,
+                    Time = i * 15,
                     Position = new Vector2(posX, posY),
                     Actions = actions.ToList(),
                 });

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

@@ -0,0 +1,87 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Storyboards;
+using osu.Game.Tests.Visual;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public partial class TestSceneReplayRecording : PlayerTestScene
+    {
+        protected override Ruleset CreatePlayerRuleset() => new OsuRuleset();
+
+        [Resolved]
+        private AudioManager audioManager { get; set; } = null!;
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new Beatmap
+        {
+            HitObjects =
+            {
+                new HitCircle
+                {
+                    Position = OsuPlayfield.BASE_SIZE / 2,
+                    StartTime = 0,
+                },
+                new HitCircle
+                {
+                    Position = OsuPlayfield.BASE_SIZE / 2,
+                    StartTime = 5000,
+                },
+                new HitCircle
+                {
+                    Position = OsuPlayfield.BASE_SIZE / 2,
+                    StartTime = 10000,
+                },
+                new HitCircle
+                {
+                    Position = OsuPlayfield.BASE_SIZE / 2,
+                    StartTime = 15000,
+                }
+            }
+        };
+
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard? storyboard = null) =>
+            new ClockBackedTestWorkingBeatmap(beatmap, storyboard, new FramedClock(new ManualClock { Rate = 1 }), audioManager);
+
+        [Test]
+        public void TestRecording()
+        {
+            seekTo(0);
+            AddStep("move cursor to circle", () => InputManager.MoveMouseTo(Player.DrawableRuleset.Playfield.HitObjectContainer.AliveObjects.Single()));
+            AddStep("press X", () => InputManager.PressKey(Key.X));
+            seekTo(15);
+            AddStep("release X", () => InputManager.ReleaseKey(Key.X));
+            AddAssert("right button press recorded to replay", () => Player.Score.Replay.Frames.OfType<OsuReplayFrame>().Any(f => f.Actions.SequenceEqual([OsuAction.RightButton])));
+
+            seekTo(5000);
+            AddStep("move cursor to circle", () => InputManager.MoveMouseTo(Player.DrawableRuleset.Playfield.HitObjectContainer.AliveObjects.Single()));
+            AddStep("press Z", () => InputManager.PressKey(Key.Z));
+            seekTo(5015);
+            AddStep("release Z", () => InputManager.ReleaseKey(Key.Z));
+            AddAssert("left button press recorded to replay", () => Player.Score.Replay.Frames.OfType<OsuReplayFrame>().Any(f => f.Actions.SequenceEqual([OsuAction.LeftButton])));
+
+            seekTo(10000);
+            AddStep("move cursor to circle", () => InputManager.MoveMouseTo(Player.DrawableRuleset.Playfield.HitObjectContainer.AliveObjects.Single()));
+            AddStep("press C", () => InputManager.PressKey(Key.C));
+            seekTo(10015);
+            AddStep("release C", () => InputManager.ReleaseKey(Key.C));
+            AddAssert("smoke button press recorded to replay", () => Player.Score.Replay.Frames.OfType<OsuReplayFrame>().Any(f => f.Actions.SequenceEqual([OsuAction.Smoke])));
+        }
+
+        private void seekTo(double time)
+        {
+            AddStep($"seek to {time}ms", () => Player.GameplayClockContainer.Seek(time));
+            AddUntilStep("wait for seek to finish", () => Player.DrawableRuleset.FrameStableClock.CurrentTime, () => Is.EqualTo(time).Within(500));
+        }
+    }
+}

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

@@ -22,6 +22,7 @@ using osu.Game.Rulesets.UI;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play;
 using osu.Game.Storyboards;
+using osu.Game.Tests;
 using osu.Game.Tests.Visual;
 using osuTK;
 
@@ -107,6 +108,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         }
 
         [Test]
+        [FlakyTest]
         public void TestVibrateWithoutSpinningOnCentreWithDoubleTime()
         {
             List<ReplayFrame> frames = new List<ReplayFrame>();

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

@@ -15,7 +15,11 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
 {
     public class OsuBeatmapProcessor : BeatmapProcessor
     {
-        private const int stack_distance = 3;
+        /// <summary>
+        /// The maximum distance between the end of one object and the start of another
+        /// which allows the objects to be stacked on top of another.
+        /// </summary>
+        public const int STACK_DISTANCE = 3;
 
         public OsuBeatmapProcessor(IBeatmap beatmap)
             : base(beatmap)
@@ -93,8 +97,8 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                             // We are no longer within stacking range of the next object.
                             break;
 
-                        if (Vector2Extensions.Distance(stackBaseObject.Position, objectN.Position) < stack_distance
-                            || (stackBaseObject is Slider && Vector2Extensions.Distance(stackBaseObject.EndPosition, objectN.Position) < stack_distance))
+                        if (Vector2Extensions.Distance(stackBaseObject.Position, objectN.Position) < STACK_DISTANCE
+                            || (stackBaseObject is Slider && Vector2Extensions.Distance(stackBaseObject.EndPosition, objectN.Position) < STACK_DISTANCE))
                         {
                             stackBaseIndex = n;
 
@@ -163,7 +167,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                          *        o <- hitCircle has stack of -1
                          *         o <- hitCircle has stack of -2
                          */
-                        if (objectN is Slider && Vector2Extensions.Distance(objectN.EndPosition, objectI.Position) < stack_distance)
+                        if (objectN is Slider && Vector2Extensions.Distance(objectN.EndPosition, objectI.Position) < STACK_DISTANCE)
                         {
                             int offset = objectI.StackHeight - objectN.StackHeight + 1;
 
@@ -171,7 +175,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                             {
                                 // For each object which was declared under this slider, we will offset it to appear *below* the slider end (rather than above).
                                 OsuHitObject objectJ = hitObjects[j];
-                                if (Vector2Extensions.Distance(objectN.EndPosition, objectJ.Position) < stack_distance)
+                                if (Vector2Extensions.Distance(objectN.EndPosition, objectJ.Position) < STACK_DISTANCE)
                                     objectJ.StackHeight -= offset;
                             }
 
@@ -180,7 +184,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                             break;
                         }
 
-                        if (Vector2Extensions.Distance(objectN.Position, objectI.Position) < stack_distance)
+                        if (Vector2Extensions.Distance(objectN.Position, objectI.Position) < STACK_DISTANCE)
                         {
                             // Keep processing as if there are no sliders.  If we come across a slider, this gets cancelled out.
                             //NOTE: Sliders with start positions stacking are a special case that is also handled here.
@@ -204,7 +208,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                             // We are no longer within stacking range of the previous object.
                             break;
 
-                        if (Vector2Extensions.Distance(objectN.EndPosition, objectI.Position) < stack_distance)
+                        if (Vector2Extensions.Distance(objectN.EndPosition, objectI.Position) < STACK_DISTANCE)
                         {
                             objectN.StackHeight = objectI.StackHeight + 1;
                             objectI = objectN;
@@ -245,12 +249,12 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                     // Effects of this can be seen on https://osu.ppy.sh/beatmapsets/243#osu/1146 at sliders around 86647 ms, where
                     // if we use `EndTime` here it would result in unexpected stacking.
 
-                    if (Vector2Extensions.Distance(hitObjects[j].Position, currHitObject.Position) < stack_distance)
+                    if (Vector2Extensions.Distance(hitObjects[j].Position, currHitObject.Position) < STACK_DISTANCE)
                     {
                         currHitObject.StackHeight++;
                         startTime = hitObjects[j].StartTime;
                     }
-                    else if (Vector2Extensions.Distance(hitObjects[j].Position, position2) < stack_distance)
+                    else if (Vector2Extensions.Distance(hitObjects[j].Position, position2) < STACK_DISTANCE)
                     {
                         // Case for sliders - bump notes down and right, rather than up and left.
                         sliderStack++;

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

@@ -275,6 +275,13 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             else
             {
                 double minDistance = distanceSnapProvider?.GetBeatSnapDistance() * oldVelocityMultiplier ?? 1;
+                // do not allow the slider to extend beyond the path's calculated distance.
+                // this can happen in two specific circumstances:
+                // - floating point issues (`minDistance` is just ever so slightly larger than the calculated distance)
+                // - the slider was placed with a higher beat snap active than the current one,
+                //   therefore snapping it to the current beat snap distance would mean extrapolating it beyond its actual shape as defined by its control points
+                minDistance = Math.Min(minDistance, HitObject.Path.CalculatedDistance);
+
                 // Add a small amount to the proposed distance to make it easier to snap to the full length of the slider.
                 proposedDistance = distanceSnapProvider?.FindSnappedDistance((float)proposedDistance + 1, HitObject.StartTime, HitObject) ?? proposedDistance;
                 proposedDistance = Math.Clamp(proposedDistance, minDistance, HitObject.Path.CalculatedDistance);

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

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
 using osu.Game.Rulesets.Edit.Checks.Components;
 using osu.Game.Rulesets.Osu.Edit.Checks;
 
@@ -16,6 +17,7 @@ namespace osu.Game.Rulesets.Osu.Edit
             // Compose
             new CheckOffscreenObjects(),
             new CheckTooShortSpinners(),
+            new CheckConcurrentObjects(),
 
             // Spread
             new CheckTimeDistanceEquality(),

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

@@ -7,6 +7,7 @@ using osu.Game.Input.Bindings;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Objects;
 using osuTK;
 
@@ -16,10 +17,15 @@ namespace osu.Game.Rulesets.Osu.Edit
     {
         public override double ReadCurrentDistanceSnap(HitObject before, HitObject after)
         {
+            // If the pair of hit objects in question here could feasibly be on the same stack, do not provide a distance snap value -
+            // they're likely too close to one another for the distance snap value to be useful anyway even if they somehow are not.
+            if (Vector2.Distance(((OsuHitObject)before).EndPosition, ((OsuHitObject)after).Position) < OsuBeatmapProcessor.STACK_DISTANCE)
+                return 0;
+
             var lastObjectWithVelocity = EditorBeatmap.HitObjects.TakeWhile(ho => ho != after).OfType<IHasSliderVelocity>().LastOrDefault();
 
             float expectedDistance = DurationToDistance(after.StartTime - before.GetEndTime(), before.StartTime, lastObjectWithVelocity);
-            float actualDistance = Vector2.Distance(((OsuHitObject)before).EndPosition, ((OsuHitObject)after).Position);
+            float actualDistance = Vector2.Distance(((OsuHitObject)before).StackedEndPosition, ((OsuHitObject)after).StackedPosition);
 
             return actualDistance / expectedDistance;
         }

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

@@ -254,11 +254,15 @@ namespace osu.Game.Rulesets.Osu.Edit
         [CanBeNull]
         public SnapResult TrySnapToDistanceGrid(Vector2 screenSpacePosition, double? fixedTime = null)
         {
-            if (DistanceSnapProvider.DistanceSnapToggle.Value != TernaryState.True || distanceSnapGrid == null)
+            if (DistanceSnapProvider.DistanceSnapToggle.Value != TernaryState.True || distanceSnapGrid?.IsLoaded != true)
                 return null;
 
             var playfield = PlayfieldAtScreenSpacePosition(screenSpacePosition);
             (Vector2 pos, double time) = distanceSnapGrid.GetSnappedPosition(distanceSnapGrid.ToLocalSpace(screenSpacePosition), fixedTime);
+
+            if (pos.X < 0 || pos.X > OsuPlayfield.BASE_SIZE.X || pos.Y < 0 || pos.Y > OsuPlayfield.BASE_SIZE.Y)
+                return null;
+
             return new SnapResult(distanceSnapGrid.ToScreenSpace(pos), time, playfield);
         }
 

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

@@ -7,6 +7,7 @@ using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Configuration;
+using osu.Game.Extensions;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Objects;
@@ -36,6 +37,24 @@ namespace osu.Game.Rulesets.Osu.Mods
             ReadCurrentFromDifficulty = diff => diff.ApproachRate,
         };
 
+        public override string ExtendedIconInformation
+        {
+            get
+            {
+                if (UserAdjustedSettingsCount != 1)
+                    return string.Empty;
+
+                if (!CircleSize.IsDefault) return format("CS", CircleSize);
+                if (!ApproachRate.IsDefault) return format("AR", ApproachRate);
+                if (!OverallDifficulty.IsDefault) return format("OD", OverallDifficulty);
+                if (!DrainRate.IsDefault) return format("HP", DrainRate);
+
+                return string.Empty;
+
+                string format(string acronym, DifficultyBindable bindable) => $"{acronym}{bindable.Value!.Value.ToStandardFormattedString(1)}";
+            }
+        }
+
         public override IEnumerable<(LocalisableString setting, LocalisableString value)> SettingDescription
         {
             get

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/OsuModFreezeFrame.cs

@@ -43,7 +43,10 @@ namespace osu.Game.Rulesets.Osu.Mods
 
             foreach (var obj in beatmap.HitObjects.OfType<OsuHitObject>())
             {
-                if (obj.NewCombo) { lastNewComboTime = obj.StartTime; }
+                if (obj.NewCombo)
+                {
+                    lastNewComboTime = obj.StartTime;
+                }
 
                 applyFadeInAdjustment(obj);
             }

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

@@ -16,6 +16,7 @@ using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
@@ -39,6 +40,9 @@ namespace osu.Game.Rulesets.Osu.Mods
                     if (slider.Time.Current < slider.HitObject.StartTime)
                         return;
 
+                    if ((slider.Clock as IGameplayClock)?.IsRewinding == true)
+                        return;
+
                     var tail = slider.NestedHitObjects.OfType<StrictTrackingDrawableSliderTail>().First();
 
                     if (!tail.Judged)

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

@@ -176,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/Skinning/Argon/ArgonSliderBody.cs

@@ -3,12 +3,16 @@
 
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Game.Rulesets.Osu.Skinning.Default;
+using osu.Game.Skinning;
 using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Skinning.Argon
 {
     public partial class ArgonSliderBody : PlaySliderBody
     {
+        // Eventually this would be a user setting.
+        public float BodyAlpha { get; init; } = 1;
+
         protected override void LoadComplete()
         {
             const float path_radius = ArgonMainCirclePiece.OUTER_GRADIENT_SIZE / 2;
@@ -26,6 +30,11 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
 
         protected override Default.DrawableSliderPath CreateSliderPath() => new DrawableSliderPath();
 
+        protected override Color4 GetBodyAccentColour(ISkinSource skin, Color4 hitObjectAccentColour)
+        {
+            return base.GetBodyAccentColour(skin, hitObjectAccentColour).Opacity(BodyAlpha);
+        }
+
         private partial class DrawableSliderPath : Default.DrawableSliderPath
         {
             protected override Color4 ColourAt(float position)

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

@@ -16,13 +16,15 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
 
         public override Drawable? GetDrawableComponent(ISkinComponentLookup lookup)
         {
+            bool isPro = Skin is ArgonProSkin;
+
             switch (lookup)
             {
                 case SkinComponentLookup<HitResult> resultComponent:
                     HitResult result = resultComponent.Component;
 
                     // This should eventually be moved to a skin setting, when supported.
-                    if (Skin is ArgonProSkin && (result == HitResult.Great || result == HitResult.Perfect))
+                    if (isPro && (result == HitResult.Great || result == HitResult.Perfect))
                         return Drawable.Empty();
 
                     switch (result)
@@ -46,7 +48,10 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
                             return new ArgonMainCirclePiece(false);
 
                         case OsuSkinComponents.SliderBody:
-                            return new ArgonSliderBody();
+                            return new ArgonSliderBody
+                            {
+                                BodyAlpha = isPro ? 0.92f : 0.98f
+                            };
 
                         case OsuSkinComponents.SliderBall:
                             return new ArgonSliderBall();

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

@@ -44,10 +44,11 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
 
             SnakingOut.BindTo(configSnakingOut);
 
-            BorderColour = skin.GetConfig<OsuSkinColour, Color4>(OsuSkinColour.SliderBorder)?.Value ?? Color4.White;
+            BorderColour = GetBorderColour(skin);
         }
 
-        protected virtual Color4 GetBodyAccentColour(ISkinSource skin, Color4 hitObjectAccentColour) =>
-            skin.GetConfig<OsuSkinColour, Color4>(OsuSkinColour.SliderTrackOverride)?.Value ?? hitObjectAccentColour;
+        protected virtual Color4 GetBorderColour(ISkinSource skin) => Color4.White;
+
+        protected virtual Color4 GetBodyAccentColour(ISkinSource skin, Color4 hitObjectAccentColour) => hitObjectAccentColour;
     }
 }

osu.Game.Rulesets.Osu/Skinning/Legacy/LegacySliderBody.cs

@@ -15,11 +15,12 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
     {
         protected override DrawableSliderPath CreateSliderPath() => new LegacyDrawableSliderPath();
 
+        protected override Color4 GetBorderColour(ISkinSource skin)
+            => skin.GetConfig<OsuSkinColour, Color4>(OsuSkinColour.SliderBorder)?.Value ?? Color4.White;
+
         protected override Color4 GetBodyAccentColour(ISkinSource skin, Color4 hitObjectAccentColour)
-        {
             // legacy skins use a constant value for slider track alpha, regardless of the source colour.
-            return base.GetBodyAccentColour(skin, hitObjectAccentColour).Opacity(0.7f);
-        }
+            => (skin.GetConfig<OsuSkinColour, Color4>(OsuSkinColour.SliderTrackOverride)?.Value ?? hitObjectAccentColour).Opacity(0.7f);
 
         private partial class LegacyDrawableSliderPath : DrawableSliderPath
         {

osu.Game.Rulesets.Osu/Skinning/Legacy/OsuLegacySkinTransformer.cs

@@ -72,6 +72,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 
                                 var combo = container.OfType<LegacyDefaultComboCounter>().FirstOrDefault();
                                 var spectatorList = container.OfType<SpectatorList>().FirstOrDefault();
+                                var leaderboard = container.OfType<DrawableGameplayLeaderboard>().FirstOrDefault();
 
                                 Vector2 pos = new Vector2();
 
@@ -89,6 +90,16 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                                     spectatorList.Anchor = Anchor.BottomLeft;
                                     spectatorList.Origin = Anchor.BottomLeft;
                                     spectatorList.Position = pos;
+
+                                    // maximum height of the spectator list is around ~172 units
+                                    pos += new Vector2(0, -185);
+                                }
+
+                                if (leaderboard != null)
+                                {
+                                    leaderboard.Anchor = Anchor.BottomLeft;
+                                    leaderboard.Origin = Anchor.BottomLeft;
+                                    leaderboard.Position = pos;
                                 }
                             })
                             {
@@ -97,6 +108,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                                     new LegacyDefaultComboCounter(),
                                     new LegacyKeyCounterDisplay(),
                                     new SpectatorList(),
+                                    new DrawableGameplayLeaderboard(),
                                 }
                             };
                     }

osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModSimplifiedRhythm.cs

@@ -0,0 +1,152 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.Taiko.Mods;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Replays;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Mods
+{
+    public partial class TestSceneTaikoModSimplifiedRhythm : TaikoModTestScene
+    {
+        [Test]
+        public void TestOneThirdConversion()
+        {
+            CreateModTest(new ModTestData
+            {
+                Mod = new TaikoModSimplifiedRhythm
+                {
+                    OneThirdConversion = { Value = true },
+                },
+                Autoplay = false,
+                CreateBeatmap = () => new Beatmap
+                {
+                    HitObjects = new List<HitObject>
+                    {
+                        new Hit { StartTime = 1000, Type = HitType.Centre },
+                        new Hit { StartTime = 1500, Type = HitType.Centre },
+                        new Hit { StartTime = 2000, Type = HitType.Centre },
+                        new Hit { StartTime = 2333, Type = HitType.Rim }, // mod removes this
+                        new Hit { StartTime = 2666, Type = HitType.Centre }, // mod moves this to 2500
+                        new Hit { StartTime = 3000, Type = HitType.Centre },
+                        new Hit { StartTime = 3500, Type = HitType.Centre },
+                    },
+                },
+                ReplayFrames = new List<ReplayFrame>
+                {
+                    new TaikoReplayFrame(1000, TaikoAction.LeftCentre),
+                    new TaikoReplayFrame(1200),
+                    new TaikoReplayFrame(1500, TaikoAction.LeftCentre),
+                    new TaikoReplayFrame(1700),
+                    new TaikoReplayFrame(2000, TaikoAction.LeftCentre),
+                    new TaikoReplayFrame(2200),
+                    new TaikoReplayFrame(2500, TaikoAction.LeftCentre),
+                    new TaikoReplayFrame(2700),
+                    new TaikoReplayFrame(3000, TaikoAction.LeftCentre),
+                    new TaikoReplayFrame(3200),
+                    new TaikoReplayFrame(3500, TaikoAction.LeftCentre),
+                    new TaikoReplayFrame(3700),
+                },
+                PassCondition = () => Player.ScoreProcessor.Combo.Value == 6 && Player.ScoreProcessor.Accuracy.Value == 1
+            });
+        }
+
+        [Test]
+        public void TestOneSixthConversion() => CreateModTest(new ModTestData
+        {
+            Mod = new TaikoModSimplifiedRhythm
+            {
+                OneSixthConversion = { Value = true }
+            },
+            Autoplay = false,
+            CreateBeatmap = () => new Beatmap
+            {
+                HitObjects = new List<HitObject>
+                {
+                    new Hit { StartTime = 1000, Type = HitType.Centre },
+                    new Hit { StartTime = 1250, Type = HitType.Centre },
+                    new Hit { StartTime = 1500, Type = HitType.Centre },
+                    new Hit { StartTime = 1666, Type = HitType.Rim }, // mod removes this
+                    new Hit { StartTime = 1833, Type = HitType.Centre }, // mod moves this to 1750
+                    new Hit { StartTime = 2000, Type = HitType.Centre },
+                    new Hit { StartTime = 2250, Type = HitType.Centre },
+                },
+            },
+            ReplayFrames = new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(1000, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1200),
+                new TaikoReplayFrame(1250, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1450),
+                new TaikoReplayFrame(1500, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1600),
+                new TaikoReplayFrame(1750, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1800),
+                new TaikoReplayFrame(2000, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(2200),
+                new TaikoReplayFrame(2250, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(2450),
+            },
+            PassCondition = () => Player.ScoreProcessor.Combo.Value == 6 && Player.ScoreProcessor.Accuracy.Value == 1
+        });
+
+        [Test]
+        public void TestOneEighthConversion() => CreateModTest(new ModTestData
+        {
+            Mod = new TaikoModSimplifiedRhythm
+            {
+                OneEighthConversion = { Value = true }
+            },
+            Autoplay = false,
+            CreateBeatmap = () =>
+            {
+                const double one_eighth_timing = 125;
+
+                return new Beatmap
+                {
+                    HitObjects = new List<HitObject>
+                    {
+                        new Hit { StartTime = 1000, Type = HitType.Centre },
+                        new Hit { StartTime = 1250, Type = HitType.Centre },
+                        new Hit { StartTime = 1500, Type = HitType.Centre },
+                        new Hit { StartTime = 1500 + one_eighth_timing * 1, Type = HitType.Rim }, // mod removes this
+                        new Hit { StartTime = 1500 + one_eighth_timing * 2 },
+                        new Hit { StartTime = 2000, Type = HitType.Centre },
+                        new Hit { StartTime = 2000 + one_eighth_timing * 1, Type = HitType.Centre }, // mod removes this
+                        new Hit { StartTime = 2000 + one_eighth_timing * 2, Type = HitType.Centre },
+                        new Hit { StartTime = 2000 + one_eighth_timing * 3, Type = HitType.Centre }, // mod removes this
+                        new Hit { StartTime = 2000 + one_eighth_timing * 4, Type = HitType.Centre },
+                        new Hit { StartTime = 2000 + one_eighth_timing * 5, Type = HitType.Centre }, // mod removes this
+                        new Hit { StartTime = 2000 + one_eighth_timing * 6, Type = HitType.Centre },
+                        new Hit { StartTime = 2000 + one_eighth_timing * 7, Type = HitType.Centre }, // mod removes this
+                    },
+                };
+            },
+            ReplayFrames = new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(1000, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1000),
+                new TaikoReplayFrame(1250, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1250),
+                new TaikoReplayFrame(1500, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1500),
+                new TaikoReplayFrame(1750, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1750),
+                new TaikoReplayFrame(2000, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(2000),
+                new TaikoReplayFrame(2250, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(2250),
+                new TaikoReplayFrame(2500, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(2500),
+                new TaikoReplayFrame(2750, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(2750),
+            },
+            PassCondition = () => Player.ScoreProcessor.Combo.Value == 8 && Player.ScoreProcessor.Accuracy.Value == 1
+        });
+    }
+}

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

@@ -7,6 +7,7 @@ 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.Mods;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Rulesets.Taiko.Replays;
 using osu.Game.Scoring;
@@ -21,7 +22,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
         protected override Ruleset CreateRuleset() => new TaikoRuleset();
 
-        private static readonly object[][] test_cases =
+        private static readonly object[][] no_mod_test_cases =
         {
             // With respect to notation,
             // square brackets `[]` represent *closed* or *inclusive* bounds,
@@ -52,30 +53,58 @@ namespace osu.Game.Rulesets.Taiko.Tests
             new object[] { 7.8f, -64d, HitResult.Miss },
         };
 
-        [TestCaseSource(nameof(test_cases))]
+        private static readonly object[][] hard_rock_test_cases =
+        {
+            // OD = 5 test cases.
+            // This leads to "effective" OD of 7.
+            // GREAT hit window is (-29ms, 29ms)
+            // OK    hit window is (-68ms, 68ms)
+            new object[] { 5f, -27d, HitResult.Great },
+            new object[] { 5f, -28d, HitResult.Great },
+            new object[] { 5f, -29d, HitResult.Ok },
+            new object[] { 5f, -30d, HitResult.Ok },
+            new object[] { 5f, -66d, HitResult.Ok },
+            new object[] { 5f, -67d, HitResult.Ok },
+            new object[] { 5f, -68d, HitResult.Miss },
+            new object[] { 5f, -69d, HitResult.Miss },
+
+            // OD = 7.8 test cases.
+            // This would lead to "effective" OD of 10.92,
+            // but the effects are capped to OD 10.
+            // GREAT hit window is (-20ms, 20ms)
+            // OK    hit window is (-50ms, 50ms)
+            new object[] { 7.8f, -18d, HitResult.Great },
+            new object[] { 7.8f, -19d, HitResult.Great },
+            new object[] { 7.8f, -20d, HitResult.Ok },
+            new object[] { 7.8f, -21d, HitResult.Ok },
+            new object[] { 7.8f, -48d, HitResult.Ok },
+            new object[] { 7.8f, -49d, HitResult.Ok },
+            new object[] { 7.8f, -50d, HitResult.Miss },
+            new object[] { 7.8f, -51d, HitResult.Miss },
+        };
+
+        private static readonly object[][] easy_test_cases =
+        {
+            // OD = 5 test cases.
+            // This leads to "effective" OD of 2.5.
+            // GREAT hit window is ( -42ms,  42ms)
+            // OK    hit window is (-100ms, 100ms)
+            new object[] { 5f, -40d, HitResult.Great },
+            new object[] { 5f, -41d, HitResult.Great },
+            new object[] { 5f, -42d, HitResult.Ok },
+            new object[] { 5f, -43d, HitResult.Ok },
+            new object[] { 5f, -98d, HitResult.Ok },
+            new object[] { 5f, -99d, HitResult.Ok },
+            new object[] { 5f, -100d, HitResult.Miss },
+            new object[] { 5f, -101d, HitResult.Miss },
+        };
+
+        private const double hit_time = 100;
+
+        [TestCaseSource(nameof(no_mod_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 beatmap = createBeatmap(overallDifficulty);
 
             var replay = new Replay
             {
@@ -98,5 +127,85 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
             RunTest($@"single hit @ OD{overallDifficulty}", beatmap, $@"{hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
         }
+
+        [TestCaseSource(nameof(hard_rock_test_cases))]
+        public void TestHitWindowTreatmentWithHardRock(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            var beatmap = createBeatmap(overallDifficulty);
+
+            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,
+                    Mods = [new TaikoModHardRock()]
+                }
+            };
+
+            RunTest($@"HR single hit @ OD{overallDifficulty}", beatmap, $@"HR {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        [TestCaseSource(nameof(easy_test_cases))]
+        public void TestHitWindowTreatmentWithEasy(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            var beatmap = createBeatmap(overallDifficulty);
+
+            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,
+                    Mods = [new TaikoModHardRock()]
+                }
+            };
+
+            RunTest($@"EZ single hit @ OD{overallDifficulty}", beatmap, $@"EZ {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        private static TaikoBeatmap createBeatmap(float overallDifficulty)
+        {
+            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,
+            };
+            return beatmap;
+        }
     }
 }

osu.Game.Rulesets.Taiko.Tests/TestSceneReplayRecording.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.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Replays;
+using osu.Game.Storyboards;
+using osu.Game.Tests.Visual;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Taiko.Tests
+{
+    public partial class TestSceneReplayRecording : PlayerTestScene
+    {
+        protected override Ruleset CreatePlayerRuleset() => new TaikoRuleset();
+
+        [Resolved]
+        private AudioManager audioManager { get; set; } = null!;
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new Beatmap
+        {
+            HitObjects =
+            {
+                new Hit { StartTime = 0, },
+                new Hit { StartTime = 5000, },
+                new Hit { StartTime = 10000, },
+                new Hit { StartTime = 15000, }
+            }
+        };
+
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard? storyboard = null) =>
+            new ClockBackedTestWorkingBeatmap(beatmap, storyboard, new FramedClock(new ManualClock { Rate = 1 }), audioManager);
+
+        [Test]
+        public void TestRecording()
+        {
+            seekTo(0);
+            AddStep("press D", () => InputManager.PressKey(Key.D));
+            seekTo(15);
+            AddStep("release D", () => InputManager.ReleaseKey(Key.D));
+            AddAssert("left rim press recorded to replay", () => Player.Score.Replay.Frames.OfType<TaikoReplayFrame>().Any(f => f.Actions.SequenceEqual([TaikoAction.LeftRim])));
+
+            seekTo(5000);
+            AddStep("press F", () => InputManager.PressKey(Key.F));
+            seekTo(5015);
+            AddStep("release F", () => InputManager.ReleaseKey(Key.F));
+            AddAssert("left centre press recorded to replay", () => Player.Score.Replay.Frames.OfType<TaikoReplayFrame>().Any(f => f.Actions.SequenceEqual([TaikoAction.LeftCentre])));
+
+            seekTo(10000);
+            AddStep("press J", () => InputManager.PressKey(Key.J));
+            seekTo(10015);
+            AddStep("release J", () => InputManager.ReleaseKey(Key.J));
+            AddAssert("right centre press recorded to replay", () => Player.Score.Replay.Frames.OfType<TaikoReplayFrame>().Any(f => f.Actions.SequenceEqual([TaikoAction.RightCentre])));
+
+            seekTo(15000);
+            AddStep("press K", () => InputManager.PressKey(Key.K));
+            seekTo(15015);
+            AddStep("release K", () => InputManager.ReleaseKey(Key.K));
+            AddAssert("right rim press recorded to replay", () => Player.Score.Replay.Frames.OfType<TaikoReplayFrame>().Any(f => f.Actions.SequenceEqual([TaikoAction.RightRim])));
+        }
+
+        private void seekTo(double time)
+        {
+            AddStep($"seek to {time}ms", () => Player.GameplayClockContainer.Seek(time));
+            AddUntilStep("wait for seek to finish", () => Player.DrawableRuleset.FrameStableClock.CurrentTime, () => Is.EqualTo(time).Within(500));
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Edit/TaikoBeatmapVerifier.cs

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
 using osu.Game.Rulesets.Edit.Checks.Components;
 using osu.Game.Rulesets.Taiko.Edit.Checks;
 
@@ -13,6 +14,10 @@ namespace osu.Game.Rulesets.Taiko.Edit
     {
         private readonly List<ICheck> checks = new List<ICheck>
         {
+            // Compose
+            new CheckConcurrentObjects(),
+
+            // Settings
             new CheckTaikoAbnormalDifficultySettings(),
         };
 

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

@@ -5,6 +5,7 @@ using System.Collections.Generic;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
+using osu.Game.Extensions;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Taiko.Mods
@@ -20,6 +21,23 @@ namespace osu.Game.Rulesets.Taiko.Mods
             ReadCurrentFromDifficulty = _ => 1,
         };
 
+        public override string ExtendedIconInformation
+        {
+            get
+            {
+                if (UserAdjustedSettingsCount != 1)
+                    return string.Empty;
+
+                if (!ScrollSpeed.IsDefault) return format("SC", ScrollSpeed);
+                if (!OverallDifficulty.IsDefault) return format("OD", OverallDifficulty);
+                if (!DrainRate.IsDefault) return format("HP", DrainRate);
+
+                return string.Empty;
+
+                string format(string acronym, DifficultyBindable bindable) => $"{acronym}{bindable.Value!.Value.ToStandardFormattedString(1)}";
+            }
+        }
+
         public override IEnumerable<(LocalisableString setting, LocalisableString value)> SettingDescription
         {
             get

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

@@ -0,0 +1,130 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Bindables;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Taiko.Beatmaps;
+using osu.Game.Rulesets.Taiko.Objects;
+
+namespace osu.Game.Rulesets.Taiko.Mods
+{
+    public class TaikoModSimplifiedRhythm : Mod, IApplicableToBeatmap
+    {
+        public override string Name => "Simplified Rhythm";
+        public override string Acronym => "SR";
+        public override double ScoreMultiplier => 0.6;
+        public override LocalisableString Description => "Simplify tricky rhythms!";
+        public override ModType Type => ModType.DifficultyReduction;
+
+        [SettingSource("1/3 to 1/2 conversion", "Converts 1/3 patterns to 1/2 rhythm.")]
+        public Bindable<bool> OneThirdConversion { get; } = new BindableBool();
+
+        [SettingSource("1/6 to 1/4 conversion", "Converts 1/6 patterns to 1/4 rhythm.")]
+        public Bindable<bool> OneSixthConversion { get; } = new BindableBool(true);
+
+        [SettingSource("1/8 to 1/4 conversion", "Converts 1/8 patterns to 1/4 rhythm.")]
+        public Bindable<bool> OneEighthConversion { get; } = new BindableBool();
+
+        public void ApplyToBeatmap(IBeatmap beatmap)
+        {
+            var taikoBeatmap = (TaikoBeatmap)beatmap;
+            var controlPointInfo = taikoBeatmap.ControlPointInfo;
+
+            Hit[] hits = taikoBeatmap.HitObjects.Where(obj => obj is Hit).Cast<Hit>().ToArray();
+
+            if (hits.Length == 0)
+                return;
+
+            var conversions = new List<(int, int)>();
+
+            if (OneEighthConversion.Value) conversions.Add((8, 4));
+            if (OneSixthConversion.Value) conversions.Add((6, 4));
+            if (OneThirdConversion.Value) conversions.Add((3, 2));
+
+            bool inPattern = false;
+
+            foreach ((int baseRhythm, int adjustedRhythm) in conversions)
+            {
+                int patternStartIndex = 0;
+
+                for (int i = 1; i < hits.Length; i++)
+                {
+                    double snapValue = getSnapBetweenNotes(controlPointInfo, hits[i - 1], hits[i]);
+
+                    if (inPattern)
+                    {
+                        // pattern continues
+                        if (snapValue == baseRhythm) continue;
+
+                        inPattern = false;
+
+                        processPattern(i);
+                    }
+                    else
+                    {
+                        if (snapValue == baseRhythm)
+                        {
+                            patternStartIndex = i - 1;
+                            inPattern = true;
+                        }
+                    }
+                }
+
+                // Process the last pattern if we reached the end of the beatmap and are still in a pattern.
+                if (inPattern)
+                    processPattern(hits.Length);
+
+                void processPattern(int patternEndIndex)
+                {
+                    // Iterate through the pattern
+                    for (int j = patternStartIndex; j < patternEndIndex; j++)
+                    {
+                        int indexInPattern = j - patternStartIndex;
+
+                        switch (baseRhythm)
+                        {
+                            // 1/8: Remove every second note
+                            case 8:
+                            {
+                                if (indexInPattern % 2 == 1)
+                                {
+                                    taikoBeatmap.HitObjects.Remove(hits[j]);
+                                }
+
+                                break;
+                            }
+
+                            // 1/6 and 1/3: Remove every second note and adjust time of every third
+                            case 6:
+                            case 3:
+                            {
+                                if (indexInPattern % 3 == 1)
+                                    taikoBeatmap.HitObjects.Remove(hits[j]);
+                                else if (indexInPattern % 3 == 2)
+                                    hits[j].StartTime = hits[j + 1].StartTime - controlPointInfo.TimingPointAt(hits[j].StartTime).BeatLength / adjustedRhythm;
+
+                                break;
+                            }
+
+                            default:
+                                throw new ArgumentOutOfRangeException(nameof(baseRhythm));
+                        }
+                    }
+                }
+            }
+        }
+
+        private int getSnapBetweenNotes(ControlPointInfo controlPointInfo, Hit currentNote, Hit nextNote)
+        {
+            var currentTimingPoint = controlPointInfo.TimingPointAt(currentNote.StartTime);
+            return controlPointInfo.GetClosestBeatDivisor(currentTimingPoint.Time + (nextNote.StartTime - currentNote.StartTime));
+        }
+    }
+}

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

@@ -62,7 +62,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
                 foreach (BreakPeriod b in drawableRuleset.Beatmap.Breaks)
                     periods.Add(new Period(b.StartTime, getValidJudgementTime(ruleset.Objects.First(h => h.StartTime >= b.EndTime)) - 1));
 
-                static double getValidJudgementTime(HitObject hitObject) => hitObject.StartTime - hitObject.HitWindows.WindowFor(HitResult.Meh);
+                static double getValidJudgementTime(HitObject hitObject) => hitObject.StartTime - hitObject.HitWindows.WindowFor(HitResult.Ok);
             }
 
             nonGameplayPeriods = new PeriodTracker(periods);

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

@@ -1,9 +1,12 @@
 // 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 osu.Framework.Graphics;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play.HUD;
 using osu.Game.Skinning;
+using osuTK;
 
 namespace osu.Game.Rulesets.Taiko.Skinning.Argon
 {
@@ -18,6 +21,59 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Argon
         {
             switch (lookup)
             {
+                case GlobalSkinnableContainerLookup containerLookup:
+                    // Only handle per ruleset defaults here.
+                    if (containerLookup.Ruleset == null)
+                        return base.GetDrawableComponent(lookup);
+
+                    switch (containerLookup.Lookup)
+                    {
+                        case GlobalSkinnableContainers.MainHUDComponents:
+                            return new DefaultSkinComponentsContainer(container =>
+                            {
+                                var leaderboard = container.OfType<DrawableGameplayLeaderboard>().FirstOrDefault();
+                                var comboCounter = container.OfType<ArgonComboCounter>().FirstOrDefault();
+                                var spectatorList = container.OfType<SpectatorList>().FirstOrDefault();
+
+                                if (leaderboard != null)
+                                {
+                                    leaderboard.Anchor = leaderboard.Origin = Anchor.BottomLeft;
+                                    leaderboard.Position = new Vector2(36, -140);
+                                    leaderboard.Height = 140;
+                                }
+
+                                if (comboCounter != null)
+                                    comboCounter.Position = new Vector2(36, -66);
+
+                                if (spectatorList != null)
+                                {
+                                    spectatorList.Position = new Vector2(320, -280);
+                                    spectatorList.Anchor = Anchor.BottomLeft;
+                                    spectatorList.Origin = Anchor.TopLeft;
+                                }
+                            })
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Children = new Drawable[]
+                                {
+                                    new DrawableGameplayLeaderboard(),
+                                    new ArgonComboCounter
+                                    {
+                                        Anchor = Anchor.BottomLeft,
+                                        Origin = Anchor.BottomLeft,
+                                        Scale = new Vector2(1.3f),
+                                    },
+                                    new SpectatorList
+                                    {
+                                        Anchor = Anchor.BottomLeft,
+                                        Origin = Anchor.BottomLeft,
+                                    }
+                                },
+                            };
+                    }
+
+                    return null;
+
                 case SkinComponentLookup<HitResult> resultComponent:
                     // This should eventually be moved to a skin setting, when supported.
                     if (Skin is ArgonProSkin && resultComponent.Component >= HitResult.Great)

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

@@ -0,0 +1,76 @@
+// 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 osu.Framework.Graphics;
+using osu.Game.Graphics;
+using osu.Game.Screens.Play.HUD;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Taiko.Skinning.Default
+{
+    public class TaikoTrianglesSkinTransformer : SkinTransformer
+    {
+        public TaikoTrianglesSkinTransformer(ISkin skin)
+            : base(skin)
+        {
+        }
+
+        public override Drawable? GetDrawableComponent(ISkinComponentLookup lookup)
+        {
+            switch (lookup)
+            {
+                case GlobalSkinnableContainerLookup containerLookup:
+                {
+                    // Only handle per ruleset defaults here.
+                    if (containerLookup.Ruleset == null)
+                        return base.GetDrawableComponent(lookup);
+
+                    switch (containerLookup.Lookup)
+                    {
+                        case GlobalSkinnableContainers.MainHUDComponents:
+                            return new DefaultSkinComponentsContainer(container =>
+                            {
+                                var leaderboard = container.OfType<DrawableGameplayLeaderboard>().FirstOrDefault();
+                                var spectatorList = container.OfType<SpectatorList>().FirstOrDefault();
+
+                                if (leaderboard != null)
+                                {
+                                    leaderboard.Position = new Vector2(40, -100);
+                                    leaderboard.Height = 180;
+                                    leaderboard.Anchor = Anchor.BottomLeft;
+                                    leaderboard.Origin = Anchor.BottomLeft;
+                                }
+
+                                if (spectatorList != null)
+                                {
+                                    spectatorList.HeaderFont.Value = Typeface.Venera;
+                                    spectatorList.HeaderColour.Value = new OsuColour().BlueLighter;
+                                    spectatorList.Anchor = Anchor.BottomLeft;
+                                    spectatorList.Origin = Anchor.TopLeft;
+                                    spectatorList.Position = new Vector2(320, -280);
+                                }
+                            })
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Children = new Drawable[]
+                                {
+                                    new DrawableGameplayLeaderboard(),
+                                    new SpectatorList
+                                    {
+                                        Anchor = Anchor.BottomLeft,
+                                        Origin = Anchor.BottomLeft,
+                                    }
+                                },
+                            };
+                    }
+
+                    return null;
+                }
+            }
+
+            return base.GetDrawableComponent(lookup);
+        }
+    }
+}

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

@@ -3,12 +3,15 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Graphics;
 using osu.Game.Audio;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.UI;
+using osu.Game.Screens.Play.HUD;
 using osu.Game.Skinning;
+using osuTK;
 
 namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
 {
@@ -29,119 +32,180 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
 
         public override Drawable? GetDrawableComponent(ISkinComponentLookup lookup)
         {
-            if (lookup is SkinComponentLookup<HitResult>)
+            switch (lookup)
             {
-                // if a taiko skin is providing explosion sprites, hide the judgements completely
-                if (hasExplosion.Value)
-                    return Drawable.Empty().With(d => d.Expire());
-            }
-
-            if (lookup is TaikoSkinComponentLookup taikoComponent)
-            {
-                switch (taikoComponent.Component)
+                case GlobalSkinnableContainerLookup containerLookup:
                 {
-                    case TaikoSkinComponents.DrumRollBody:
-                        if (GetTexture("taiko-roll-middle") != null)
-                            return new LegacyDrumRoll();
+                    // Modifications for global components.
+                    if (containerLookup.Ruleset == null)
+                        return base.GetDrawableComponent(lookup);
 
+                    // we don't have enough assets to display these components (this is especially the case on a "beatmap" skin).
+                    if (!IsProvidingLegacyResources)
                         return null;
 
-                    case TaikoSkinComponents.InputDrum:
-                        if (hasBarLeft)
-                            return new LegacyInputDrum();
+                    switch (containerLookup.Lookup)
+                    {
+                        case GlobalSkinnableContainers.MainHUDComponents:
+                            return new DefaultSkinComponentsContainer(container =>
+                            {
+                                var combo = container.OfType<LegacyDefaultComboCounter>().FirstOrDefault();
+                                var spectatorList = container.OfType<SpectatorList>().FirstOrDefault();
+                                var leaderboard = container.OfType<DrawableGameplayLeaderboard>().FirstOrDefault();
 
-                        return null;
+                                Vector2 pos = new Vector2();
 
-                    case TaikoSkinComponents.DrumSamplePlayer:
-                        return null;
+                                if (combo != null)
+                                {
+                                    combo.Anchor = Anchor.BottomLeft;
+                                    combo.Origin = Anchor.BottomLeft;
+                                    combo.Scale = new Vector2(1.28f);
 
-                    case TaikoSkinComponents.CentreHit:
-                    case TaikoSkinComponents.RimHit:
-                        if (hasHitCircle)
-                            return new LegacyHit(taikoComponent.Component);
+                                    pos += new Vector2(10, -(combo.DrawHeight * 1.56f + 20) * combo.Scale.X);
+                                }
 
-                        return null;
+                                if (leaderboard != null)
+                                {
+                                    leaderboard.Anchor = Anchor.BottomLeft;
+                                    leaderboard.Origin = Anchor.BottomLeft;
+                                    leaderboard.Position = pos;
+                                    leaderboard.Height = 170;
+                                    pos += new Vector2(10 + leaderboard.Width, -leaderboard.Height);
+                                }
 
-                    case TaikoSkinComponents.DrumRollTick:
-                        return this.GetAnimation("sliderscorepoint", false, false);
+                                if (spectatorList != null)
+                                {
+                                    spectatorList.Anchor = Anchor.BottomLeft;
+                                    spectatorList.Origin = Anchor.TopLeft;
+                                    spectatorList.Position = pos;
+                                }
+                            })
+                            {
+                                new LegacyDefaultComboCounter(),
+                                new SpectatorList(),
+                                new DrawableGameplayLeaderboard(),
+                            };
+                    }
 
-                    case TaikoSkinComponents.Swell:
-                        if (GetTexture("spinner-circle") != null)
-                            return new LegacySwell();
+                    return null;
+                }
 
-                        return null;
+                case SkinComponentLookup<HitResult>:
+                {
+                    // if a taiko skin is providing explosion sprites, hide the judgements completely
+                    if (hasExplosion.Value)
+                        return Drawable.Empty().With(d => d.Expire());
 
-                    case TaikoSkinComponents.HitTarget:
-                        if (GetTexture("taikobigcircle") != null)
-                            return new TaikoLegacyHitTarget();
+                    break;
+                }
 
-                        return null;
+                case TaikoSkinComponentLookup taikoComponent:
+                {
+                    switch (taikoComponent.Component)
+                    {
+                        case TaikoSkinComponents.DrumRollBody:
+                            if (GetTexture("taiko-roll-middle") != null)
+                                return new LegacyDrumRoll();
 
-                    case TaikoSkinComponents.PlayfieldBackgroundRight:
-                        if (GetTexture("taiko-bar-right") != null)
-                            return new TaikoLegacyPlayfieldBackgroundRight();
+                            return null;
 
-                        return null;
+                        case TaikoSkinComponents.InputDrum:
+                            if (hasBarLeft)
+                                return new LegacyInputDrum();
 
-                    case TaikoSkinComponents.PlayfieldBackgroundLeft:
-                        // This is displayed inside LegacyInputDrum. It is required to be there for layout purposes (can be seen on legacy skins).
-                        if (GetTexture("taiko-bar-right") != null)
-                            return Drawable.Empty();
+                            return null;
 
-                        return null;
+                        case TaikoSkinComponents.DrumSamplePlayer:
+                            return null;
 
-                    case TaikoSkinComponents.BarLine:
-                        if (GetTexture("taiko-barline") != null)
-                            return new LegacyBarLine();
+                        case TaikoSkinComponents.CentreHit:
+                        case TaikoSkinComponents.RimHit:
+                            if (hasHitCircle)
+                                return new LegacyHit(taikoComponent.Component);
 
-                        return null;
+                            return null;
 
-                    case TaikoSkinComponents.TaikoExplosionMiss:
-                        var missSprite = this.GetAnimation(getHitName(taikoComponent.Component), true, false);
-                        if (missSprite != null)
-                            return new LegacyHitExplosion(missSprite);
+                        case TaikoSkinComponents.DrumRollTick:
+                            return this.GetAnimation("sliderscorepoint", false, false);
 
-                        return null;
+                        case TaikoSkinComponents.Swell:
+                            if (GetTexture("spinner-circle") != null)
+                                return new LegacySwell();
 
-                    case TaikoSkinComponents.TaikoExplosionOk:
-                    case TaikoSkinComponents.TaikoExplosionGreat:
-                        string hitName = getHitName(taikoComponent.Component);
-                        var hitSprite = this.GetAnimation(hitName, true, false);
+                            return null;
 
-                        if (hitSprite != null)
-                        {
-                            var strongHitSprite = this.GetAnimation($"{hitName}k", true, false);
+                        case TaikoSkinComponents.HitTarget:
+                            if (GetTexture("taikobigcircle") != null)
+                                return new TaikoLegacyHitTarget();
 
-                            return new LegacyHitExplosion(hitSprite, strongHitSprite);
-                        }
+                            return null;
 
-                        return null;
+                        case TaikoSkinComponents.PlayfieldBackgroundRight:
+                            if (GetTexture("taiko-bar-right") != null)
+                                return new TaikoLegacyPlayfieldBackgroundRight();
 
-                    case TaikoSkinComponents.TaikoExplosionKiai:
-                        // suppress the default kiai explosion if the skin brings its own sprites.
-                        // the drawable needs to expire as soon as possible to avoid accumulating empty drawables on the playfield.
-                        if (hasExplosion.Value)
-                            return Drawable.Empty().With(d => d.Expire());
+                            return null;
 
-                        return null;
+                        case TaikoSkinComponents.PlayfieldBackgroundLeft:
+                            // This is displayed inside LegacyInputDrum. It is required to be there for layout purposes (can be seen on legacy skins).
+                            if (GetTexture("taiko-bar-right") != null)
+                                return Drawable.Empty();
 
-                    case TaikoSkinComponents.Scroller:
-                        if (GetTexture("taiko-slider") != null)
-                            return new LegacyTaikoScroller();
+                            return null;
 
-                        return null;
+                        case TaikoSkinComponents.BarLine:
+                            if (GetTexture("taiko-barline") != null)
+                                return new LegacyBarLine();
 
-                    case TaikoSkinComponents.Mascot:
-                        return new DrawableTaikoMascot();
+                            return null;
 
-                    case TaikoSkinComponents.KiaiGlow:
-                        if (GetTexture("taiko-glow") != null)
-                            return new LegacyKiaiGlow();
+                        case TaikoSkinComponents.TaikoExplosionMiss:
+                            var missSprite = this.GetAnimation(getHitName(taikoComponent.Component), true, false);
+                            if (missSprite != null)
+                                return new LegacyHitExplosion(missSprite);
 
-                        return null;
+                            return null;
 
-                    default:
-                        throw new UnsupportedSkinComponentException(lookup);
+                        case TaikoSkinComponents.TaikoExplosionOk:
+                        case TaikoSkinComponents.TaikoExplosionGreat:
+                            string hitName = getHitName(taikoComponent.Component);
+                            var hitSprite = this.GetAnimation(hitName, true, false);
+
+                            if (hitSprite != null)
+                            {
+                                var strongHitSprite = this.GetAnimation($"{hitName}k", true, false);
+
+                                return new LegacyHitExplosion(hitSprite, strongHitSprite);
+                            }
+
+                            return null;
+
+                        case TaikoSkinComponents.TaikoExplosionKiai:
+                            // suppress the default kiai explosion if the skin brings its own sprites.
+                            // the drawable needs to expire as soon as possible to avoid accumulating empty drawables on the playfield.
+                            if (hasExplosion.Value)
+                                return Drawable.Empty().With(d => d.Expire());
+
+                            return null;
+
+                        case TaikoSkinComponents.Scroller:
+                            if (GetTexture("taiko-slider") != null)
+                                return new LegacyTaikoScroller();
+
+                            return null;
+
+                        case TaikoSkinComponents.Mascot:
+                            return new DrawableTaikoMascot();
+
+                        case TaikoSkinComponents.KiaiGlow:
+                            if (GetTexture("taiko-glow") != null)
+                                return new LegacyKiaiGlow();
+
+                            return null;
+
+                        default:
+                            throw new UnsupportedSkinComponentException(lookup);
+                    }
                 }
             }
 

osu.Game.Rulesets.Taiko/TaikoRuleset.cs

@@ -36,6 +36,7 @@ using osu.Game.Configuration;
 using osu.Game.Rulesets.Scoring.Legacy;
 using osu.Game.Rulesets.Taiko.Configuration;
 using osu.Game.Rulesets.Taiko.Edit.Setup;
+using osu.Game.Rulesets.Taiko.Skinning.Default;
 using osu.Game.Screens.Edit.Setup;
 
 namespace osu.Game.Rulesets.Taiko
@@ -57,6 +58,9 @@ namespace osu.Game.Rulesets.Taiko
                 case ArgonSkin:
                     return new TaikoArgonSkinTransformer(skin);
 
+                case TrianglesSkin:
+                    return new TaikoTrianglesSkinTransformer(skin);
+
                 case LegacySkin:
                     return new TaikoLegacySkinTransformer(skin);
             }
@@ -130,6 +134,7 @@ namespace osu.Game.Rulesets.Taiko
                         new TaikoModEasy(),
                         new TaikoModNoFail(),
                         new MultiMod(new TaikoModHalfTime(), new TaikoModDaycore()),
+                        new TaikoModSimplifiedRhythm(),
                     };
 
                 case ModType.DifficultyIncrease:

osu.Game.Tests/Beatmaps/TestSceneBeatmapDifficultyCache.cs

@@ -32,7 +32,7 @@ namespace osu.Game.Tests.Beatmaps
 
         private TestBeatmapDifficultyCache difficultyCache;
 
-        private IBindable<StarDifficulty?> starDifficultyBindable;
+        private IBindable<StarDifficulty> starDifficultyBindable;
 
         [BackgroundDependencyLoader]
         private void load(OsuGameBase osu)
@@ -52,7 +52,7 @@ namespace osu.Game.Tests.Beatmaps
                 starDifficultyBindable = difficultyCache.GetBindableDifficulty(importedSet.Beatmaps.First());
             });
 
-            AddUntilStep($"star difficulty -> {BASE_STARS}", () => starDifficultyBindable.Value?.Stars == BASE_STARS);
+            AddUntilStep($"star difficulty -> {BASE_STARS}", () => starDifficultyBindable.Value.Stars == BASE_STARS);
         }
 
         [Test]
@@ -67,13 +67,13 @@ namespace osu.Game.Tests.Beatmaps
             });
 
             AddStep("change selected mod to DT", () => SelectedMods.Value = new[] { dt = new OsuModDoubleTime { SpeedChange = { Value = 1.5 } } });
-            AddUntilStep($"star difficulty -> {BASE_STARS + 1.5}", () => starDifficultyBindable.Value?.Stars == BASE_STARS + 1.5);
+            AddUntilStep($"star difficulty -> {BASE_STARS + 1.5}", () => starDifficultyBindable.Value.Stars == BASE_STARS + 1.5);
 
             AddStep("change DT speed to 1.25", () => dt.SpeedChange.Value = 1.25);
-            AddUntilStep($"star difficulty -> {BASE_STARS + 1.25}", () => starDifficultyBindable.Value?.Stars == BASE_STARS + 1.25);
+            AddUntilStep($"star difficulty -> {BASE_STARS + 1.25}", () => starDifficultyBindable.Value.Stars == BASE_STARS + 1.25);
 
             AddStep("change selected mod to NC", () => SelectedMods.Value = new[] { new OsuModNightcore { SpeedChange = { Value = 1.75 } } });
-            AddUntilStep($"star difficulty -> {BASE_STARS + 1.75}", () => starDifficultyBindable.Value?.Stars == BASE_STARS + 1.75);
+            AddUntilStep($"star difficulty -> {BASE_STARS + 1.75}", () => starDifficultyBindable.Value.Stars == BASE_STARS + 1.75);
         }
 
         [Test]
@@ -88,15 +88,15 @@ namespace osu.Game.Tests.Beatmaps
             });
 
             AddStep("change selected mod to DA", () => SelectedMods.Value = new[] { difficultyAdjust = new OsuModDifficultyAdjust() });
-            AddUntilStep($"star difficulty -> {BASE_STARS}", () => starDifficultyBindable.Value?.Stars == BASE_STARS);
+            AddUntilStep($"star difficulty -> {BASE_STARS}", () => starDifficultyBindable.Value.Stars == BASE_STARS);
 
             AddStep("change DA difficulty to 0.5", () => difficultyAdjust.OverallDifficulty.Value = 0.5f);
-            AddUntilStep($"star difficulty -> {BASE_STARS * 0.5f}", () => starDifficultyBindable.Value?.Stars == BASE_STARS / 2);
+            AddUntilStep($"star difficulty -> {BASE_STARS * 0.5f}", () => starDifficultyBindable.Value.Stars == BASE_STARS / 2);
 
             // hash code of 0 (the value) conflicts with the hash code of null (the initial/default value).
             // it's important that the mod reference and its underlying bindable references stay the same to demonstrate this failure.
             AddStep("change DA difficulty to 0", () => difficultyAdjust.OverallDifficulty.Value = 0);
-            AddUntilStep("star difficulty -> 0", () => starDifficultyBindable.Value?.Stars == 0);
+            AddUntilStep("star difficulty -> 0", () => starDifficultyBindable.Value.Stars == 0);
         }
 
         [Test]

osu.Game.Tests/Editing/Checks/CheckConcurrentObjectsTest.cs

@@ -114,36 +114,6 @@ namespace osu.Game.Tests.Editing.Checks
             Assert.That(issues.Any(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrentSame));
         }
 
-        [Test]
-        public void TestHoldNotesSeparateOnSameColumn()
-        {
-            assertOk(new List<HitObject>
-            {
-                getHoldNoteMock(startTime: 100, endTime: 400.75d, column: 1).Object,
-                getHoldNoteMock(startTime: 500, endTime: 900.75d, column: 1).Object
-            });
-        }
-
-        [Test]
-        public void TestHoldNotesConcurrentOnDifferentColumns()
-        {
-            assertOk(new List<HitObject>
-            {
-                getHoldNoteMock(startTime: 100, endTime: 400.75d, column: 1).Object,
-                getHoldNoteMock(startTime: 300, endTime: 700.75d, column: 2).Object
-            });
-        }
-
-        [Test]
-        public void TestHoldNotesConcurrentOnSameColumn()
-        {
-            assertConcurrentSame(new List<HitObject>
-            {
-                getHoldNoteMock(startTime: 100, endTime: 400.75d, column: 1).Object,
-                getHoldNoteMock(startTime: 300, endTime: 700.75d, column: 1).Object
-            });
-        }
-
         private Mock<Slider> getSliderMock(double startTime, double endTime, int repeats = 0)
         {
             var mock = new Mock<Slider>();

osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs

@@ -3,9 +3,7 @@
 
 using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
@@ -27,33 +25,34 @@ namespace osu.Game.Tests.Editing
     public partial class TestSceneHitObjectComposerDistanceSnapping : EditorClockTestScene
     {
         private TestHitObjectComposer composer = null!;
-
-        [Cached(typeof(EditorBeatmap))]
-        [Cached(typeof(IBeatSnapProvider))]
-        private readonly EditorBeatmap editorBeatmap;
-
-        protected override Container<Drawable> Content { get; } = new PopoverContainer { RelativeSizeAxes = Axes.Both };
-
-        public TestSceneHitObjectComposerDistanceSnapping()
-        {
-            base.Content.Add(new Container
-            {
-                RelativeSizeAxes = Axes.Both,
-                Children = new Drawable[]
-                {
-                    editorBeatmap = new EditorBeatmap(new OsuBeatmap
-                    {
-                        BeatmapInfo = { Ruleset = new OsuRuleset().RulesetInfo },
-                    }),
-                    Content
-                },
-            });
-        }
+        private EditorBeatmap editorBeatmap = null!;
 
         [SetUp]
         public void Setup() => Schedule(() =>
         {
-            Child = composer = new TestHitObjectComposer();
+            editorBeatmap = new EditorBeatmap(new OsuBeatmap
+            {
+                BeatmapInfo = { Ruleset = new OsuRuleset().RulesetInfo },
+            });
+
+            Child = new DependencyProvidingContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                CachedDependencies =
+                [
+                    (typeof(EditorBeatmap), editorBeatmap),
+                    (typeof(IBeatSnapProvider), editorBeatmap)
+                ],
+                Children = new Drawable[]
+                {
+                    editorBeatmap,
+                    new PopoverContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Child = composer = new TestHitObjectComposer()
+                    }
+                }
+            };
 
             BeatDivisor.Value = 1;
 
@@ -247,16 +246,23 @@ namespace osu.Game.Tests.Editing
         }
 
         private void assertSnapDistance(float expectedDistance, IHasSliderVelocity? hasSliderVelocity = null)
-            => AddAssert($"distance is {expectedDistance}", () => composer.DistanceSnapProvider.GetBeatSnapDistance(hasSliderVelocity), () => Is.EqualTo(expectedDistance).Within(Precision.FLOAT_EPSILON));
+            => AddAssert($"distance is {expectedDistance}", () => composer.DistanceSnapProvider.GetBeatSnapDistance(hasSliderVelocity),
+                () => Is.EqualTo(expectedDistance).Within(Precision.FLOAT_EPSILON));
 
         private void assertDurationToDistance(double duration, float expectedDistance, HitObject? referenceObject = null)
-            => AddAssert($"duration = {duration} -> distance = {expectedDistance}", () => composer.DistanceSnapProvider.DurationToDistance(duration, referenceObject?.StartTime ?? 0, referenceObject as IHasSliderVelocity), () => Is.EqualTo(expectedDistance).Within(Precision.FLOAT_EPSILON));
+            => AddAssert($"duration = {duration} -> distance = {expectedDistance}",
+                () => composer.DistanceSnapProvider.DurationToDistance(duration, referenceObject?.StartTime ?? 0, referenceObject as IHasSliderVelocity),
+                () => Is.EqualTo(expectedDistance).Within(Precision.FLOAT_EPSILON));
 
         private void assertDistanceToDuration(float distance, double expectedDuration, HitObject? referenceObject = null)
-            => AddAssert($"distance = {distance} -> duration = {expectedDuration}", () => composer.DistanceSnapProvider.DistanceToDuration(distance, referenceObject?.StartTime ?? 0, referenceObject as IHasSliderVelocity), () => Is.EqualTo(expectedDuration).Within(Precision.FLOAT_EPSILON));
+            => AddAssert($"distance = {distance} -> duration = {expectedDuration}",
+                () => composer.DistanceSnapProvider.DistanceToDuration(distance, referenceObject?.StartTime ?? 0, referenceObject as IHasSliderVelocity),
+                () => Is.EqualTo(expectedDuration).Within(Precision.FLOAT_EPSILON));
 
         private void assertSnappedDistance(float distance, float expectedDistance, HitObject? referenceObject = null)
-            => AddAssert($"distance = {distance} -> distance = {expectedDistance} (snapped)", () => composer.DistanceSnapProvider.FindSnappedDistance(distance, referenceObject?.GetEndTime() ?? 0, referenceObject as IHasSliderVelocity), () => Is.EqualTo(expectedDistance).Within(Precision.FLOAT_EPSILON));
+            => AddAssert($"distance = {distance} -> distance = {expectedDistance} (snapped)",
+                () => composer.DistanceSnapProvider.FindSnappedDistance(distance, referenceObject?.GetEndTime() ?? 0, referenceObject as IHasSliderVelocity),
+                () => Is.EqualTo(expectedDistance).Within(Precision.FLOAT_EPSILON));
 
         private partial class TestHitObjectComposer : OsuHitObjectComposer
         {

osu.Game.Tests/Extensions/NumberFormattingExtensionsTest.cs

@@ -43,5 +43,12 @@ namespace osu.Game.Tests.Extensions
         {
             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/Mods/ModUtilsTest.cs

@@ -2,14 +2,20 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using Moq;
 using NUnit.Framework;
+using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.Localisation;
 using osu.Game.Online.Rooms;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Catch;
+using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Taiko;
 using osu.Game.Rulesets.Taiko.Mods;
 using osu.Game.Utils;
 
@@ -182,98 +188,6 @@ namespace osu.Game.Tests.Mods
             },
         };
 
-        private static readonly object[] invalid_multiplayer_mod_test_scenarios =
-        {
-            // incompatible pair.
-            new object[]
-            {
-                new Mod[] { new OsuModHidden(), new OsuModApproachDifferent() },
-                new[] { typeof(OsuModHidden), typeof(OsuModApproachDifferent) }
-            },
-            // incompatible pair with derived class.
-            new object[]
-            {
-                new Mod[] { new OsuModDeflate(), new OsuModApproachDifferent() },
-                new[] { typeof(OsuModDeflate), typeof(OsuModApproachDifferent) }
-            },
-            // system mod.
-            new object[]
-            {
-                new Mod[] { new OsuModHidden(), new OsuModTouchDevice() },
-                new[] { typeof(OsuModTouchDevice) }
-            },
-            // multi mod.
-            new object[]
-            {
-                new Mod[] { new MultiMod(new OsuModSuddenDeath(), new OsuModPerfect()) },
-                new[] { typeof(MultiMod) }
-            },
-            // invalid multiplayer mod.
-            new object[]
-            {
-                new Mod[] { new OsuModHidden(), new InvalidMultiplayerMod() },
-                new[] { typeof(InvalidMultiplayerMod) }
-            },
-            // invalid free mod is valid for multiplayer global.
-            new object[]
-            {
-                new Mod[] { new OsuModHidden(), new InvalidMultiplayerFreeMod() },
-                Array.Empty<Type>()
-            },
-            // valid pair.
-            new object[]
-            {
-                new Mod[] { new OsuModHidden(), new OsuModHardRock() },
-                Array.Empty<Type>()
-            },
-        };
-
-        private static readonly object[] invalid_free_mod_test_scenarios =
-        {
-            // system mod.
-            new object[]
-            {
-                new Mod[] { new OsuModHidden(), new OsuModTouchDevice() },
-                new[] { typeof(OsuModTouchDevice) }
-            },
-            // multi mod.
-            new object[]
-            {
-                new Mod[] { new MultiMod(new OsuModSuddenDeath(), new OsuModPerfect()) },
-                new[] { typeof(MultiMod) }
-            },
-            // invalid multiplayer mod.
-            new object[]
-            {
-                new Mod[] { new OsuModHidden(), new InvalidMultiplayerMod() },
-                new[] { typeof(InvalidMultiplayerMod) }
-            },
-            // invalid free mod.
-            new object[]
-            {
-                new Mod[] { new OsuModHidden(), new InvalidMultiplayerFreeMod() },
-                new[] { typeof(InvalidMultiplayerFreeMod) }
-            },
-            // incompatible pair is valid for free mods.
-            new object[]
-            {
-                new Mod[] { new OsuModHidden(), new OsuModApproachDifferent() },
-                Array.Empty<Type>(),
-            },
-            // incompatible pair with derived class is valid for free mods.
-            new object[]
-            {
-                new Mod[] { new OsuModDeflate(), new OsuModSpinIn() },
-                Array.Empty<Type>(),
-            },
-            // valid pair.
-            new object[]
-            {
-                new Mod[] { new OsuModHidden(), new OsuModHardRock() },
-                Array.Empty<Type>()
-            },
-        };
-
         [TestCaseSource(nameof(invalid_mod_test_scenarios))]
         public void TestInvalidModScenarios(Mod[] inputMods, Type[] expectedInvalid)
         {
@@ -287,32 +201,6 @@ namespace osu.Game.Tests.Mods
                 Assert.That(invalid?.Select(t => t.GetType()), Is.EquivalentTo(expectedInvalid));
         }
 
-        [TestCaseSource(nameof(invalid_multiplayer_mod_test_scenarios))]
-        public void TestInvalidMultiplayerModScenarios(Mod[] inputMods, Type[] expectedInvalid)
-        {
-            bool isValid = ModUtils.CheckValidRequiredModsForMultiplayer(inputMods, out var invalid);
-
-            Assert.That(isValid, Is.EqualTo(expectedInvalid.Length == 0));
-
-            if (isValid)
-                Assert.IsNull(invalid);
-            else
-                Assert.That(invalid?.Select(t => t.GetType()), Is.EquivalentTo(expectedInvalid));
-        }
-
-        [TestCaseSource(nameof(invalid_free_mod_test_scenarios))]
-        public void TestInvalidFreeModScenarios(Mod[] inputMods, Type[] expectedInvalid)
-        {
-            bool isValid = ModUtils.CheckValidFreeModsForMultiplayer(inputMods, out var invalid);
-
-            Assert.That(isValid, Is.EqualTo(expectedInvalid.Length == 0));
-
-            if (isValid)
-                Assert.IsNull(invalid);
-            else
-                Assert.That(invalid?.Select(t => t.GetType()), Is.EquivalentTo(expectedInvalid));
-        }
-
         [Test]
         public void TestModBelongsToRuleset()
         {
@@ -343,38 +231,160 @@ namespace osu.Game.Tests.Mods
             Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.055).ToString(), "1.06x");
         }
 
-        [Test]
-        public void TestRoomModValidity()
+        private static readonly object[] multiplayer_mod_test_scenarios =
         {
-            Assert.IsTrue(ModUtils.IsValidModForMatchType(new OsuModHardRock(), MatchType.Playlists));
-            Assert.IsTrue(ModUtils.IsValidModForMatchType(new OsuModDoubleTime(), MatchType.Playlists));
-            Assert.IsTrue(ModUtils.IsValidModForMatchType(new ModAdaptiveSpeed(), MatchType.Playlists));
-            Assert.IsFalse(ModUtils.IsValidModForMatchType(new OsuModAutoplay(), MatchType.Playlists));
-            Assert.IsFalse(ModUtils.IsValidModForMatchType(new OsuModTouchDevice(), MatchType.Playlists));
+            // valid - as allowed mod.
+            new MultiplayerTestScenario(false, false, [new OsuModBarrelRoll()], []),
+            new MultiplayerTestScenario(false, true, [new OsuModBarrelRoll()], []),
+            // valid - as allowed mod (incompatible pair).
+            new MultiplayerTestScenario(false, false, [new OsuModHardRock(), new OsuModEasy()], []),
+            new MultiplayerTestScenario(false, true, [new OsuModHardRock(), new OsuModEasy()], []),
+            // valid - as allowed mod (incompatible pair with derived classes).
+            new MultiplayerTestScenario(false, false, [new OsuModDeflate(), new OsuModApproachDifferent()], []),
+            new MultiplayerTestScenario(false, true, [new OsuModDeflate(), new OsuModApproachDifferent()], []),
+            // valid - as allowed mod (not implemented in all rulesets).
+            new MultiplayerTestScenario(false, false, [new OsuModBarrelRoll()], []),
+            new MultiplayerTestScenario(false, true, [new OsuModBarrelRoll()], []),
+            // valid - as required mod.
+            new MultiplayerTestScenario(true, false, [new OsuModStrictTracking()], []),
+            // valid - as required mod when not freestyle.
+            new MultiplayerTestScenario(true, false, [new InvalidFreestyleRequiredMod()], []),
+            // valid - as required mod when freestyle (implemented in all rulesets).
+            new MultiplayerTestScenario(true, true, [new OsuModEasy()], []),
+            new MultiplayerTestScenario(true, true, [new OsuModNoFail()], []),
+            new MultiplayerTestScenario(true, true, [new OsuModHalfTime()], []),
+            new MultiplayerTestScenario(true, true, [new OsuModDaycore()], []),
+            new MultiplayerTestScenario(true, true, [new OsuModHardRock()], []),
+            new MultiplayerTestScenario(true, true, [new OsuModSuddenDeath()], []),
+            new MultiplayerTestScenario(true, true, [new OsuModPerfect()], []),
+            new MultiplayerTestScenario(true, true, [new OsuModDoubleTime()], []),
+            new MultiplayerTestScenario(true, true, [new OsuModNightcore()], []),
+            new MultiplayerTestScenario(true, true, [new OsuModDifficultyAdjust()], []),
+            new MultiplayerTestScenario(true, true, [new ModWindUp()], []),
+            new MultiplayerTestScenario(true, true, [new ModWindDown()], []),
+            new MultiplayerTestScenario(true, true, [new OsuModMuted()], []),
 
-            Assert.IsTrue(ModUtils.IsValidModForMatchType(new OsuModHardRock(), MatchType.HeadToHead));
-            Assert.IsTrue(ModUtils.IsValidModForMatchType(new OsuModDoubleTime(), MatchType.HeadToHead));
-            // For now, adaptive speed isn't allowed in multiplayer because it's a per-user rate adjustment.
-            Assert.IsFalse(ModUtils.IsValidModForMatchType(new ModAdaptiveSpeed(), MatchType.HeadToHead));
-            Assert.IsFalse(ModUtils.IsValidModForMatchType(new OsuModAutoplay(), MatchType.HeadToHead));
-            Assert.IsFalse(ModUtils.IsValidModForMatchType(new OsuModTouchDevice(), MatchType.HeadToHead));
+            // invalid - always (system mod)
+            new MultiplayerTestScenario(false, false, [new OsuModTouchDevice()], [typeof(OsuModTouchDevice)]),
+            new MultiplayerTestScenario(true, false, [new OsuModTouchDevice()], [typeof(OsuModTouchDevice)]),
+            // invalid - always (multi mod).
+            new MultiplayerTestScenario(false, false, [new MultiMod()], [typeof(MultiMod)]),
+            new MultiplayerTestScenario(true, false, [new MultiMod()], [typeof(MultiMod)]),
+            // invalid - always (disallowed by mod)
+            new MultiplayerTestScenario(false, false, [new InvalidMultiplayerMod()], [typeof(InvalidMultiplayerMod)]),
+            new MultiplayerTestScenario(true, false, [new InvalidMultiplayerMod()], [typeof(InvalidMultiplayerMod)]),
+            new MultiplayerTestScenario(false, false, [new OsuModAutoplay()], [typeof(OsuModAutoplay)]),
+            new MultiplayerTestScenario(true, false, [new OsuModAutoplay()], [typeof(OsuModAutoplay)]),
+            // invalid - always (changes play length - for now not allowed in multiplayer).
+            new MultiplayerTestScenario(false, false, [new ModAdaptiveSpeed()], [typeof(ModAdaptiveSpeed)]),
+            new MultiplayerTestScenario(true, false, [new ModAdaptiveSpeed()], [typeof(ModAdaptiveSpeed)]),
+            // invalid - as allowed mod (disallowed by mod).
+            new MultiplayerTestScenario(false, false, [new InvalidMultiplayerFreeMod()], [typeof(InvalidMultiplayerFreeMod)]),
+            new MultiplayerTestScenario(false, true, [new InvalidMultiplayerFreeMod()], [typeof(InvalidMultiplayerFreeMod)]),
+            // invalid - as allowed mod (changes play length - for now not allowed in multiplayer).
+            new MultiplayerTestScenario(false, false, [new OsuModHalfTime()], [typeof(OsuModHalfTime)]),
+            new MultiplayerTestScenario(false, false, [new OsuModDaycore()], [typeof(OsuModDaycore)]),
+            new MultiplayerTestScenario(false, false, [new OsuModDoubleTime()], [typeof(OsuModDoubleTime)]),
+            new MultiplayerTestScenario(false, false, [new OsuModNightcore()], [typeof(OsuModNightcore)]),
+            // invalid - as required mod (incompatible pair)
+            new MultiplayerTestScenario(true, false, [new OsuModHidden(), new OsuModApproachDifferent()], [typeof(OsuModHidden), typeof(OsuModApproachDifferent)]),
+            new MultiplayerTestScenario(true, true, [new OsuModHidden(), new OsuModApproachDifferent()], [typeof(OsuModHidden), typeof(OsuModApproachDifferent)]),
+            new MultiplayerTestScenario(true, false, [new OsuModDeflate(), new OsuModApproachDifferent()], [typeof(OsuModDeflate), typeof(OsuModApproachDifferent)]),
+            new MultiplayerTestScenario(true, true, [new OsuModDeflate(), new OsuModApproachDifferent()], [typeof(OsuModDeflate), typeof(OsuModApproachDifferent)]),
+            // invalid - as required mod when freestyle (disallowed by mod).
+            new MultiplayerTestScenario(true, true, [new InvalidFreestyleRequiredMod()], [typeof(InvalidFreestyleRequiredMod)]),
+            // invalid - as required mod when freestyle (not implemented in all rulesets).
+            new MultiplayerTestScenario(true, true, [new OsuModStrictTracking()], [typeof(OsuModStrictTracking)]),
+            new MultiplayerTestScenario(true, true, [new OsuModBarrelRoll()], [typeof(OsuModBarrelRoll)]),
+        };
+
+        [TestCaseSource(nameof(multiplayer_mod_test_scenarios))]
+        public void TestMultiplayerModScenarios(MultiplayerTestScenario scenario)
+        {
+            List<Mod>? invalidMods;
+            bool isValid = scenario.IsRequired
+                ? ModUtils.CheckValidRequiredModsForMultiplayer(scenario.Mods, scenario.IsFreestyle, out invalidMods)
+                : ModUtils.CheckValidAllowedModsForMultiplayer(scenario.Mods, scenario.IsFreestyle, out invalidMods);
+
+            Assert.That(isValid, Is.EqualTo(scenario.InvalidTypes.Length == 0));
+
+            if (isValid)
+                Assert.IsNull(invalidMods);
+            else
+                Assert.That(invalidMods?.Select(t => t.GetType()), Is.EquivalentTo(scenario.InvalidTypes));
         }
 
         [Test]
-        public void TestRoomFreeModValidity()
+        public void TestPlaylistsModScenarios()
         {
-            Assert.IsTrue(ModUtils.IsValidFreeModForMatchType(new OsuModHardRock(), MatchType.Playlists));
-            Assert.IsTrue(ModUtils.IsValidFreeModForMatchType(new OsuModDoubleTime(), MatchType.Playlists));
-            Assert.IsTrue(ModUtils.IsValidFreeModForMatchType(new ModAdaptiveSpeed(), MatchType.Playlists));
-            Assert.IsFalse(ModUtils.IsValidFreeModForMatchType(new OsuModAutoplay(), MatchType.Playlists));
-            Assert.IsFalse(ModUtils.IsValidFreeModForMatchType(new OsuModTouchDevice(), MatchType.Playlists));
+            // The rest are tested by TestMultiplayerModScenarios.
+            Assert.IsTrue(ModUtils.IsValidModForMatch(new OsuModHardRock(), false, MatchType.Playlists, false));
+            Assert.IsTrue(ModUtils.IsValidModForMatch(new OsuModHardRock(), true, MatchType.Playlists, false));
+            Assert.IsTrue(ModUtils.IsValidModForMatch(new OsuModDoubleTime(), false, MatchType.Playlists, false));
+            Assert.IsTrue(ModUtils.IsValidModForMatch(new OsuModDoubleTime(), true, MatchType.Playlists, false));
+            Assert.IsTrue(ModUtils.IsValidModForMatch(new ModAdaptiveSpeed(), false, MatchType.Playlists, false));
+            Assert.IsTrue(ModUtils.IsValidModForMatch(new ModAdaptiveSpeed(), true, MatchType.Playlists, false));
+        }
 
-            Assert.IsTrue(ModUtils.IsValidFreeModForMatchType(new OsuModHardRock(), MatchType.HeadToHead));
-            // For now, all rate adjustment mods aren't allowed as free mods in multiplayer.
-            Assert.IsFalse(ModUtils.IsValidFreeModForMatchType(new OsuModDoubleTime(), MatchType.HeadToHead));
-            Assert.IsFalse(ModUtils.IsValidFreeModForMatchType(new ModAdaptiveSpeed(), MatchType.HeadToHead));
-            Assert.IsFalse(ModUtils.IsValidFreeModForMatchType(new OsuModAutoplay(), MatchType.HeadToHead));
-            Assert.IsFalse(ModUtils.IsValidFreeModForMatchType(new OsuModTouchDevice(), MatchType.HeadToHead));
+        [Test]
+        public void TestFreestyleRulesetCompatibility()
+        {
+            HashSet<string> commonAcronyms = new HashSet<string>();
+
+            commonAcronyms.UnionWith(new OsuRuleset().CreateAllMods().Select(m => m.Acronym));
+            commonAcronyms.IntersectWith(new TaikoRuleset().CreateAllMods().Select(m => m.Acronym));
+            commonAcronyms.IntersectWith(new CatchRuleset().CreateAllMods().Select(m => m.Acronym));
+            commonAcronyms.IntersectWith(new ManiaRuleset().CreateAllMods().Select(m => m.Acronym));
+
+            Assert.Multiple(() =>
+            {
+                foreach (var ruleset in new Ruleset[] { new OsuRuleset(), new TaikoRuleset(), new CatchRuleset(), new ManiaRuleset() })
+                {
+                    foreach (var mod in ruleset.CreateAllMods())
+                    {
+                        if (mod.ValidForFreestyleAsRequiredMod && mod.UserPlayable && !commonAcronyms.Contains(mod.Acronym))
+                            Assert.Fail($"{mod.GetType().ReadableName()} declares {nameof(Mod.ValidForFreestyleAsRequiredMod)} but does not exist in all four basic rulesets!");
+
+                        // downgraded to warning, because there are valid reasons why they may still not be specified to be valid for freestyle as required
+                        // (see `TestModsValidForRequiredFreestyleAreConsistentlyCompatibleAcrossRulesets()` test case below).
+                        if (!mod.ValidForFreestyleAsRequiredMod && mod.UserPlayable && commonAcronyms.Contains(mod.Acronym))
+                            Assert.Warn($"{mod.GetType().ReadableName()} does not declare {nameof(Mod.ValidForFreestyleAsRequiredMod)} but exists in all four basic rulesets.");
+                    }
+                }
+            });
+        }
+
+        [Test]
+        public void TestModsValidForRequiredFreestyleAreConsistentlyCompatibleAcrossRulesets()
+        {
+            Dictionary<(string firstMod, string secondMod), bool> compatibilityMap = new Dictionary<(string, string), bool>();
+
+            Assert.Multiple(() =>
+            {
+                for (int rulesetId = 0; rulesetId < 4; ++rulesetId)
+                {
+                    var rulesetStore = new AssemblyRulesetStore();
+                    var ruleset = rulesetStore.GetRuleset(rulesetId)!.CreateInstance();
+
+                    var modsValidForFreestyleAsRequired = ruleset.CreateAllMods().Where(m => m.ValidForFreestyleAsRequiredMod).OrderBy(m => m.Acronym).ToList();
+
+                    for (int i = 0; i < modsValidForFreestyleAsRequired.Count; i++)
+                    {
+                        for (int j = i; j < modsValidForFreestyleAsRequired.Count; ++j)
+                        {
+                            var first = modsValidForFreestyleAsRequired[i];
+                            var second = modsValidForFreestyleAsRequired[j];
+
+                            bool compatible = ModUtils.CheckCompatibleSet([first, second]);
+
+                            if (!compatibilityMap.TryGetValue((first.Acronym, second.Acronym), out bool previousCompatible))
+                                compatibilityMap[(first.Acronym, second.Acronym)] = compatible;
+                            else if (previousCompatible != compatible)
+                                Assert.Fail($"{first.Acronym} and {second.Acronym} declare {nameof(Mod.ValidForFreestyleAsRequiredMod)} while not being consistently compatible in all four rulesets!");
+                        }
+                    }
+                }
+            });
         }
 
         public abstract class CustomMod1 : Mod, IModCompatibilitySpecification
@@ -385,7 +395,7 @@ namespace osu.Game.Tests.Mods
         {
         }
 
-        public class InvalidMultiplayerMod : Mod
+        private class InvalidMultiplayerMod : Mod
         {
             public override string Name => string.Empty;
             public override LocalisableString Description => string.Empty;
@@ -406,18 +416,22 @@ namespace osu.Game.Tests.Mods
             public override bool ValidForMultiplayerAsFreeMod => false;
         }
 
-        public class EditableMod : Mod
+        public class InvalidFreestyleRequiredMod : Mod
         {
             public override string Name => string.Empty;
             public override LocalisableString Description => string.Empty;
+            public override double ScoreMultiplier => 1;
             public override string Acronym => string.Empty;
-            public override double ScoreMultiplier => Multiplier;
-
-            public double Multiplier = 1;
+            public override bool HasImplementation => true;
+            public override bool ValidForFreestyleAsRequiredMod => false;
         }
 
-        public interface IModCompatibilitySpecification
+        public interface IModCompatibilitySpecification;
+
+        public readonly record struct MultiplayerTestScenario(bool IsRequired, bool IsFreestyle, Mod[] Mods, Type[] InvalidTypes)
         {
+            public override string ToString()
+                => $"{IsRequired}, {IsFreestyle}, [{string.Join(',', Mods.Select(m => m.GetType().ReadableName()))}], [{string.Join(',', InvalidTypes.Select(t => t.ReadableName()))}]";
         }
     }
 }

osu.Game.Tests/Resources/TestResources.cs

@@ -29,6 +29,11 @@ namespace osu.Game.Tests.Resources
     {
         public const double QUICK_BEATMAP_LENGTH = 10000;
 
+        public const string COVER_IMAGE_1 = "https://assets.ppy.sh/user-cover-presets/1/df28696b58541a9e67f6755918951d542d93bdf1da41720fcca2fd2c1ea8cf51.jpeg";
+        public const string COVER_IMAGE_2 = "https://assets.ppy.sh/user-cover-presets/7/4a0ccb7b7fdd5c4238b11f0e7c686760fe2c99c6472b19400e82d1a8ff503e31.jpeg";
+        public const string COVER_IMAGE_3 = "https://assets.ppy.sh/user-cover-presets/12/6e8d3402c8080c2d9549a98321e1bff111dd9c94603ccdb237597479cab6e8a7.jpeg";
+        public const string COVER_IMAGE_4 = "https://assets.ppy.sh/user-cover-presets/17/80f82e4c2b27d8d6eed3ce89708ec27343e5ac63389cba6b5fb4550776562d08.jpeg";
+
         private static readonly TemporaryNativeStorage temp_storage = new TemporaryNativeStorage("TestResources");
 
         public static DllResourceStore GetStore() => new DllResourceStore(typeof(TestResources).Assembly);
@@ -178,7 +183,7 @@ namespace osu.Game.Tests.Resources
             {
                 Id = 2,
                 Username = "peppy",
-                CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                CoverUrl = COVER_IMAGE_3,
             },
             BeatmapInfo = beatmap,
             BeatmapHash = beatmap.Hash,

osu.Game.Tests/Rulesets/Scoring/ScoreProcessorTest.cs

@@ -421,6 +421,65 @@ namespace osu.Game.Tests.Rulesets.Scoring
             Assert.That(scoreProcessor.Rank.Value, Is.EqualTo(ScoreRank.SH));
         }
 
+        [Test]
+        public void TestComboAccounting([Values] bool shuffleResults)
+        {
+            var testBeatmap = new Beatmap
+            {
+                HitObjects = Enumerable.Range(1, 40).Select(i => new TestHitObject(HitResult.Perfect, HitResult.Miss)).ToList<HitObject>(),
+            };
+            scoreProcessor.ApplyBeatmap(testBeatmap);
+
+            var results = new List<JudgementResult>();
+            JudgementResult judgementResult;
+
+            for (int i = 0; i < 25; ++i)
+            {
+                judgementResult = new JudgementResult(testBeatmap.HitObjects[i], new TestJudgement(HitResult.Perfect, HitResult.Miss))
+                {
+                    Type = HitResult.Perfect
+                };
+                results.Add(judgementResult);
+                scoreProcessor.ApplyResult(judgementResult);
+                Assert.That(scoreProcessor.Combo.Value, Is.EqualTo(i + 1));
+            }
+
+            judgementResult = new JudgementResult(testBeatmap.HitObjects[25], new TestJudgement(HitResult.Perfect, HitResult.Miss))
+            {
+                Type = HitResult.Miss
+            };
+            results.Add(judgementResult);
+            scoreProcessor.ApplyResult(judgementResult);
+            Assert.That(scoreProcessor.Combo.Value, Is.EqualTo(0));
+
+            for (int i = 26; i < 40; ++i)
+            {
+                judgementResult = new JudgementResult(testBeatmap.HitObjects[i], new TestJudgement(HitResult.Perfect, HitResult.Miss))
+                {
+                    Type = HitResult.Perfect
+                };
+                results.Add(judgementResult);
+                scoreProcessor.ApplyResult(judgementResult);
+                Assert.That(scoreProcessor.Combo.Value, Is.EqualTo(i - 25));
+            }
+
+            Assert.That(scoreProcessor.MaximumStatistics[HitResult.Perfect], Is.EqualTo(40));
+            Assert.That(scoreProcessor.Combo.Value, Is.EqualTo(14));
+            Assert.That(scoreProcessor.HighestCombo.Value, Is.EqualTo(25));
+
+            // random shuffle is VERY extreme and overkill.
+            // it might not work correctly for any other `ScoreProcessor` property, and the intermediate results likely make no sense.
+            // the goal is only to demonstrate idempotency to zero when reverting all results.
+            var random = new Random(20250519);
+            var toRevert = shuffleResults ? results.OrderBy(_ => random.Next()).ToList() : Enumerable.Reverse(results);
+
+            foreach (var result in toRevert)
+                scoreProcessor.RevertResult(result);
+
+            Assert.That(scoreProcessor.Combo.Value, Is.Zero);
+            Assert.That(scoreProcessor.HighestCombo.Value, Is.Zero);
+        }
+
         private class TestJudgement : Judgement
         {
             public override HitResult MaxResult { get; }

osu.Game.Tests/Skins/SkinDeserialisationTest.cs

@@ -75,6 +75,8 @@ namespace osu.Game.Tests.Skins
             "Archives/modified-argon-20250116.osk",
             // Covers player team flag
             "Archives/modified-argon-20250214.osk",
+            // Covers skinnable leaderboard
+            "Archives/modified-argon-20250424.osk",
         };
 
         /// <summary>

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

@@ -16,6 +16,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Drawables;
 using osu.Game.Beatmaps.Drawables.Cards;
 using osu.Game.Beatmaps.Drawables.Cards.Buttons;
+using osu.Game.Beatmaps.Drawables.Cards.Statistics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
@@ -63,7 +64,11 @@ namespace osu.Game.Tests.Visual.Beatmaps
             withStatistics.NominationStatus = new BeatmapSetNominationStatus
             {
                 Current = 1,
-                Required = 2
+                RequiredMeta =
+                {
+                    MainRuleset = 2,
+                    NonMainRuleset = 1,
+                }
             };
 
             var undownloadable = getUndownloadableBeatmapSet();
@@ -78,7 +83,11 @@ namespace osu.Game.Tests.Visual.Beatmaps
             someDifficulties.NominationStatus = new BeatmapSetNominationStatus
             {
                 Current = 2,
-                Required = 2
+                RequiredMeta =
+                {
+                    MainRuleset = 2,
+                    NonMainRuleset = 1,
+                }
             };
 
             var manyDifficulties = getManyDifficultiesBeatmapSet(100);
@@ -220,6 +229,9 @@ namespace osu.Game.Tests.Visual.Beatmaps
         }
 
         private Drawable createContent(OverlayColourScheme colourScheme, Func<APIBeatmapSet, Drawable> creationFunc)
+            => createContent(colourScheme, testCases.Select(creationFunc).ToArray());
+
+        private Drawable createContent(OverlayColourScheme colourScheme, Drawable[] cards)
         {
             var colourProvider = new OverlayColourProvider(colourScheme);
 
@@ -247,7 +259,7 @@ namespace osu.Game.Tests.Visual.Beatmaps
                             Direction = FillDirection.Full,
                             Padding = new MarginPadding(10),
                             Spacing = new Vector2(10),
-                            ChildrenEnumerable = testCases.Select(creationFunc)
+                            ChildrenEnumerable = cards
                         }
                     }
                 }
@@ -320,5 +332,54 @@ namespace osu.Game.Tests.Visual.Beatmaps
 
             BeatmapCardNormal firstCard() => this.ChildrenOfType<BeatmapCardNormal>().First();
         }
+
+        [Test]
+        public void TestNominations()
+        {
+            AddStep("create cards", () =>
+            {
+                var singleRuleset = CreateAPIBeatmapSet(Ruleset.Value);
+                singleRuleset.HypeStatus = new BeatmapSetHypeStatus();
+                singleRuleset.NominationStatus = new BeatmapSetNominationStatus
+                {
+                    Current = 4,
+                    RequiredMeta =
+                    {
+                        MainRuleset = 5,
+                        NonMainRuleset = 1,
+                    }
+                };
+
+                var multipleRulesets = getManyDifficultiesBeatmapSet(3);
+                multipleRulesets.HypeStatus = new BeatmapSetHypeStatus();
+                multipleRulesets.NominationStatus = new BeatmapSetNominationStatus
+                {
+                    Current = 4,
+                    RequiredMeta =
+                    {
+                        MainRuleset = 5,
+                        NonMainRuleset = 1,
+                    }
+                };
+
+                Child = createContent(OverlayColourScheme.Blue, new Drawable[]
+                {
+                    new BeatmapCardNormal(singleRuleset),
+                    new BeatmapCardNormal(multipleRulesets),
+                });
+            });
+
+            // first card: only has main ruleset, required nominations = main_ruleset = 5
+            AddAssert("first card has single ruleset", () => firstCard().BeatmapSet.Beatmaps.GroupBy(b => b.Ruleset).Count(), () => Is.EqualTo(1));
+            AddAssert("first card nominations = 4/5", () => firstCard().ChildrenOfType<NominationsStatistic>().Single().TooltipText.ToString(), () => Is.EqualTo("Nominations: 4/5"));
+
+            // second card: has non-main rulesets, required nominations = main_ruleset + non_main_ruleset * (count of non-main rulesets) = 5 + 1 * 2 = 7
+            AddAssert("second card has three rulesets", () => secondCard().BeatmapSet.Beatmaps.GroupBy(b => b.Ruleset).Count(), () => Is.EqualTo(3));
+            AddAssert("second card nominations = 4/7", () => secondCard().ChildrenOfType<NominationsStatistic>().Single().TooltipText.ToString(), () => Is.EqualTo("Nominations: 4/7"));
+
+            // order is reversed due to the cards being inside a reverse child-id fill flow.
+            BeatmapCardNormal firstCard() => this.ChildrenOfType<BeatmapCardNormal>().ElementAt(1);
+            BeatmapCardNormal secondCard() => this.ChildrenOfType<BeatmapCardNormal>().ElementAt(0);
+        }
     }
 }

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

@@ -20,6 +20,7 @@ namespace osu.Game.Tests.Visual.Beatmaps
     public partial class TestSceneBeatmapSetOnlineStatusPill : ThemeComparisonTestScene
     {
         private bool showUnknownStatus;
+        private bool animated = true;
 
         protected override Drawable CreateContent() => new FillFlowContainer
         {
@@ -37,10 +38,11 @@ namespace osu.Game.Tests.Visual.Beatmaps
                     new BeatmapSetOnlineStatusPill
                     {
                         ShowUnknownStatus = showUnknownStatus,
+                        Animated = animated,
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
                         Status = status
-                    }
+                    },
                 }
             })
         };
@@ -64,6 +66,12 @@ namespace osu.Game.Tests.Visual.Beatmaps
                 CreateThemedContent(OverlayColourScheme.Red);
             });
 
+            AddStep("toggle animate", () =>
+            {
+                animated = !animated;
+                CreateThemedContent(OverlayColourScheme.Red);
+            });
+
             AddStep("unset fixed width", () => statusPills.ForEach(pill => pill.AutoSizeAxes = Axes.Both));
         }
 

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

@@ -16,6 +16,7 @@ using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
 using osu.Game.Screens.OnlinePlay.DailyChallenge;
 using osu.Game.Screens.OnlinePlay.DailyChallenge.Events;
+using osu.Game.Tests.Resources;
 
 namespace osu.Game.Tests.Visual.DailyChallenge
 {
@@ -129,7 +130,7 @@ namespace osu.Game.Tests.Visual.DailyChallenge
                 {
                     Id = 2,
                     Username = "peppy",
-                    CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                    CoverUrl = TestResources.COVER_IMAGE_3,
                 }, RNG.Next(1_000_000), null);
 
                 feed.AddNewScore(ev);
@@ -141,7 +142,7 @@ namespace osu.Game.Tests.Visual.DailyChallenge
                 {
                     Id = 2,
                     Username = "peppy",
-                    CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                    CoverUrl = TestResources.COVER_IMAGE_3,
                 }, RNG.Next(1_000_000), RNG.Next(1, 1000));
 
                 feed.AddNewScore(ev);

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

@@ -63,7 +63,7 @@ namespace osu.Game.Tests.Visual.DailyChallenge
                 {
                     Id = 2,
                     Username = "peppy",
-                    CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                    CoverUrl = TestResources.COVER_IMAGE_3,
                 }, RNG.Next(1_000_000), null);
 
                 feed.AddNewScore(ev);
@@ -75,7 +75,7 @@ namespace osu.Game.Tests.Visual.DailyChallenge
                 {
                     Id = 2,
                     Username = "peppy",
-                    CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                    CoverUrl = TestResources.COVER_IMAGE_3,
                 }, RNG.Next(1_000_000), RNG.Next(11, 1000));
 
                 var testScore = TestResources.CreateTestScoreInfo();
@@ -90,7 +90,7 @@ namespace osu.Game.Tests.Visual.DailyChallenge
                 {
                     Id = 2,
                     Username = "peppy",
-                    CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                    CoverUrl = TestResources.COVER_IMAGE_3,
                 }, RNG.Next(1_000_000), RNG.Next(1, 10));
 
                 feed.AddNewScore(ev);
@@ -108,7 +108,7 @@ namespace osu.Game.Tests.Visual.DailyChallenge
                     {
                         Id = 2,
                         Username = "peppy",
-                        CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                        CoverUrl = TestResources.COVER_IMAGE_3,
                     }, RNG.Next(1_000_000), null);
 
                     feed.AddNewScore(ev);

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

@@ -13,6 +13,7 @@ using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
 using osu.Game.Screens.OnlinePlay.DailyChallenge;
 using osu.Game.Screens.OnlinePlay.DailyChallenge.Events;
+using osu.Game.Tests.Resources;
 
 namespace osu.Game.Tests.Visual.DailyChallenge
 {
@@ -65,7 +66,7 @@ namespace osu.Game.Tests.Visual.DailyChallenge
                 {
                     Id = 2,
                     Username = "peppy",
-                    CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                    CoverUrl = TestResources.COVER_IMAGE_3,
                 }, RNG.Next(1_000_000), null);
 
                 breakdown.AddNewScore(ev);
@@ -85,7 +86,7 @@ namespace osu.Game.Tests.Visual.DailyChallenge
                     {
                         Id = 2,
                         Username = "peppy",
-                        CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                        CoverUrl = TestResources.COVER_IMAGE_3,
                     }, RNG.Next(1_000_000), null);
 
                     breakdown.AddNewScore(ev);

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

@@ -59,7 +59,7 @@ namespace osu.Game.Tests.Visual.DailyChallenge
                 {
                     Id = 2,
                     Username = "peppy",
-                    CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                    CoverUrl = TestResources.COVER_IMAGE_3,
                 }, RNG.Next(1_000_000), null);
 
                 totals.AddNewScore(ev);
@@ -73,7 +73,7 @@ namespace osu.Game.Tests.Visual.DailyChallenge
                     {
                         Id = 2,
                         Username = "peppy",
-                        CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                        CoverUrl = TestResources.COVER_IMAGE_3,
                     }, RNG.Next(1_000_000), RNG.Next(11, 1000));
 
                     var testScore = TestResources.CreateTestScoreInfo();

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

@@ -1,10 +1,16 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Threading;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps.Drawables.Cards;
 using osu.Game.Overlays;
 using osu.Game.Screens.Edit.Submission;
 using osuTK;
@@ -16,9 +22,16 @@ namespace osu.Game.Tests.Visual.Editing
         [Cached]
         private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Aquamarine);
 
+        [Resolved]
+        private AudioManager audio { get; set; } = null!;
+
+        private Sample? completeSample;
+
         [Test]
         public void TestAppearance()
         {
+            float incrementingProgress = 0;
+
             SubmissionStageProgress progress = null!;
 
             AddStep("create content", () => Child = new Container
@@ -36,12 +49,119 @@ namespace osu.Game.Tests.Visual.Editing
             });
             AddStep("not started", () => progress.SetNotStarted());
             AddStep("indeterminate progress", () => progress.SetInProgress());
-            AddStep("30% progress", () => progress.SetInProgress(0.3f));
-            AddStep("70% progress", () => progress.SetInProgress(0.7f));
+            AddStep("increase progress to 100", () =>
+            {
+                incrementingProgress = 0;
+
+                ScheduledDelegate? task = null;
+
+                task = Scheduler.AddDelayed(() =>
+                {
+                    if (incrementingProgress >= 1)
+                    {
+                        // ReSharper disable once AccessToModifiedClosure
+                        task?.Cancel();
+                        return;
+                    }
+
+                    if (RNG.NextDouble() < 0.01)
+                        progress.SetInProgress(incrementingProgress += RNG.NextSingle(0.08f));
+                }, 0, true);
+            });
+
+            AddUntilStep("wait for completed", () => incrementingProgress >= 1);
             AddStep("completed", () => progress.SetCompleted());
             AddStep("failed", () => progress.SetFailed("the foobarator has defrobnicated"));
             AddStep("failed with long message", () => progress.SetFailed("this is a very very very very VERY VEEEEEEEEEEEEEEEEEEEEEEEEERY long error message like you would never believe"));
             AddStep("canceled", () => progress.SetCanceled());
         }
+
+        [Test]
+        public void TestAudioSequence()
+        {
+            SubmissionStageProgress[] stages = new SubmissionStageProgress[4];
+            Container? cardContainer = null;
+
+            AddStep("prepare", () =>
+            {
+                Child = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Size = new Vector2(1),
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Child = new FillFlowContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Size = new Vector2(0.8f),
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Direction = FillDirection.Vertical,
+                        Spacing = new Vector2(0, 5),
+                        Children = new Drawable[]
+                        {
+                            stages[0] = new SubmissionStageProgress
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                StageDescription = "Export...",
+                                StageIndex = 0
+                            },
+                            stages[1] = new SubmissionStageProgress
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                StageDescription = "CreateSet...",
+                                StageIndex = 1
+                            },
+                            stages[2] = new SubmissionStageProgress
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                StageDescription = "Upload...",
+                                StageIndex = 2
+                            },
+                            stages[3] = new SubmissionStageProgress
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                StageDescription = "Update...",
+                                StageIndex = 3
+                            },
+                            cardContainer = new Container
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                            }
+                        }
+                    }
+                };
+
+                completeSample = audio.Samples.Get(@"UI/bss-complete");
+            });
+
+            for (int i = 0; i < stages.Length; i++)
+            {
+                int step = i;
+                AddStep($"{step}: not started", () => stages[step].SetNotStarted());
+                AddStep($"{step}: indeterminate progress", () => stages[step].SetInProgress());
+                AddStep($"{step}: 25% progress", () => stages[step].SetInProgress(0.25f));
+                AddStep($"{step}: 70% progress", () => stages[step].SetInProgress(0.7f));
+                AddStep($"{step}: completed", () => stages[step].SetCompleted());
+            }
+
+            AddWaitStep("pause for timing", 2);
+
+            AddStep("Sequence Complete", () =>
+            {
+                var beatmapSet = CreateAPIBeatmapSet(Ruleset.Value);
+                beatmapSet.Beatmaps = Enumerable.Repeat(beatmapSet.Beatmaps.First(), 100).ToArray();
+                LoadComponentAsync(new BeatmapCardExtra(beatmapSet, false), loaded =>
+                {
+                    cardContainer?.Add(loaded);
+                    completeSample?.Play();
+                });
+            });
+        }
     }
 }

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

@@ -108,7 +108,10 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             public bool IsRunning => true;
 
-            public double TrueGameplayRate { set => adjustableAudioComponent.Tempo.Value = value; }
+            public double TrueGameplayRate
+            {
+                set => adjustableAudioComponent.Tempo.Value = value;
+            }
 
             private readonly AudioAdjustments adjustableAudioComponent = new AudioAdjustments();
 

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

@@ -1,12 +1,12 @@
 // 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.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Extensions.PolygonExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -16,6 +16,7 @@ using osu.Framework.Utils;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Screens.Play.HUD;
+using osu.Game.Screens.Select.Leaderboards;
 using osuTK;
 
 namespace osu.Game.Tests.Visual.Gameplay
@@ -23,7 +24,10 @@ namespace osu.Game.Tests.Visual.Gameplay
     [TestFixture]
     public partial class TestSceneGameplayLeaderboard : OsuTestScene
     {
-        private TestGameplayLeaderboard leaderboard;
+        private TestDrawableGameplayLeaderboard leaderboard = null!;
+
+        [Cached(typeof(IGameplayLeaderboardProvider))]
+        private TestGameplayLeaderboardProvider leaderboardProvider = new TestGameplayLeaderboardProvider();
 
         private readonly BindableLong playerScore = new BindableLong();
 
@@ -31,8 +35,8 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddStep("toggle expanded", () =>
             {
-                if (leaderboard != null)
-                    leaderboard.Expanded.Value = !leaderboard.Expanded.Value;
+                if (leaderboard.IsNotNull())
+                    leaderboard.ForceExpand.Value = !leaderboard.ForceExpand.Value;
             });
 
             AddSliderStep("set player score", 50, 5000000, 1222333, v => playerScore.Value = v);
@@ -46,21 +50,21 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("add many scores in one go", () =>
             {
                 for (int i = 0; i < 32; i++)
-                    createRandomScore(new APIUser { Username = $"Player {i + 1}" });
+                    leaderboardProvider.CreateRandomScore(new APIUser { Username = $"Player {i + 1}" });
 
                 // Add player at end to force an animation down the whole list.
                 playerScore.Value = 0;
-                createLeaderboardScore(playerScore, new APIUser { Username = "You", Id = 3 }, true);
+                leaderboardProvider.CreateLeaderboardScore(playerScore, new APIUser { Username = "You", Id = 3 }, true);
             });
 
             // Gameplay leaderboard has custom scroll logic, which when coupled with LayoutDuration
             // has caused layout to not work in the past.
 
             AddUntilStep("wait for fill flow layout",
-                () => leaderboard.ChildrenOfType<FillFlowContainer<GameplayLeaderboardScore>>().First().ScreenSpaceDrawQuad.Intersects(leaderboard.ScreenSpaceDrawQuad));
+                () => leaderboard.ChildrenOfType<FillFlowContainer<DrawableGameplayLeaderboardScore>>().First().ScreenSpaceDrawQuad.Intersects(leaderboard.ScreenSpaceDrawQuad));
 
             AddUntilStep("wait for some scores not masked away",
-                () => leaderboard.ChildrenOfType<GameplayLeaderboardScore>().Any(s => leaderboard.ScreenSpaceDrawQuad.Contains(s.ScreenSpaceDrawQuad.Centre)));
+                () => leaderboard.ChildrenOfType<DrawableGameplayLeaderboardScore>().Any(s => leaderboard.ScreenSpaceDrawQuad.Contains(s.ScreenSpaceDrawQuad.Centre)));
 
             AddUntilStep("wait for tracked score fully visible", () => leaderboard.ScreenSpaceDrawQuad.Intersects(leaderboard.TrackedScore!.ScreenSpaceDrawQuad));
 
@@ -73,33 +77,6 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddUntilStep("wait for tracked score fully visible", () => leaderboard.ScreenSpaceDrawQuad.Intersects(leaderboard.TrackedScore!.ScreenSpaceDrawQuad));
         }
 
-        [Test]
-        public void TestPlayerScore()
-        {
-            createLeaderboard();
-            addLocalPlayer();
-
-            var player2Score = new BindableLong(1234567);
-            var player3Score = new BindableLong(1111111);
-
-            AddStep("add player 2", () => createLeaderboardScore(player2Score, new APIUser { Username = "Player 2" }));
-            AddStep("add player 3", () => createLeaderboardScore(player3Score, new APIUser { Username = "Player 3" }));
-
-            AddUntilStep("is player 2 position #1", () => leaderboard.CheckPositionByUsername("Player 2", 1));
-            AddUntilStep("is player position #2", () => leaderboard.CheckPositionByUsername("You", 2));
-            AddUntilStep("is player 3 position #3", () => leaderboard.CheckPositionByUsername("Player 3", 3));
-
-            AddStep("set score above player 3", () => player2Score.Value = playerScore.Value - 500);
-            AddUntilStep("is player position #1", () => leaderboard.CheckPositionByUsername("You", 1));
-            AddUntilStep("is player 2 position #2", () => leaderboard.CheckPositionByUsername("Player 2", 2));
-            AddUntilStep("is player 3 position #3", () => leaderboard.CheckPositionByUsername("Player 3", 3));
-
-            AddStep("set score below players", () => player2Score.Value = playerScore.Value - 123456);
-            AddUntilStep("is player position #1", () => leaderboard.CheckPositionByUsername("You", 1));
-            AddUntilStep("is player 3 position #2", () => leaderboard.CheckPositionByUsername("Player 3", 2));
-            AddUntilStep("is player 2 position #3", () => leaderboard.CheckPositionByUsername("Player 2", 3));
-        }
-
         [Test]
         public void TestRandomScores()
         {
@@ -107,7 +84,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             addLocalPlayer();
 
             int playerNumber = 1;
-            AddRepeatStep("add player with random score", () => createRandomScore(new APIUser { Username = $"Player {playerNumber++}" }), 10);
+            AddRepeatStep("add player with random score", () => leaderboardProvider.CreateRandomScore(new APIUser { Username = $"Player {playerNumber++}" }), 10);
         }
 
         [Test]
@@ -116,30 +93,10 @@ namespace osu.Game.Tests.Visual.Gameplay
             createLeaderboard();
             addLocalPlayer();
 
-            AddStep("add peppy", () => createRandomScore(new APIUser { Username = "peppy", Id = 2 }));
-            AddStep("add smoogipoo", () => createRandomScore(new APIUser { Username = "smoogipoo", Id = 1040328 }));
-            AddStep("add flyte", () => createRandomScore(new APIUser { Username = "flyte", Id = 3103765 }));
-            AddStep("add frenzibyte", () => createRandomScore(new APIUser { Username = "frenzibyte", Id = 14210502 }));
-        }
-
-        [Test]
-        public void TestMaxHeight()
-        {
-            createLeaderboard();
-            addLocalPlayer();
-
-            int playerNumber = 1;
-            AddRepeatStep("add 3 other players", () => createRandomScore(new APIUser { Username = $"Player {playerNumber++}" }), 3);
-            checkHeight(4);
-
-            AddRepeatStep("add 4 other players", () => createRandomScore(new APIUser { Username = $"Player {playerNumber++}" }), 4);
-            checkHeight(8);
-
-            AddRepeatStep("add 4 other players", () => createRandomScore(new APIUser { Username = $"Player {playerNumber++}" }), 4);
-            checkHeight(8);
-
-            void checkHeight(int panelCount)
-                => AddAssert($"leaderboard height is {panelCount} panels high", () => leaderboard.DrawHeight == (GameplayLeaderboardScore.PANEL_HEIGHT + leaderboard.Spacing) * panelCount);
+            AddStep("add peppy", () => leaderboardProvider.CreateRandomScore(new APIUser { Username = "peppy", Id = 2 }));
+            AddStep("add smoogipoo", () => leaderboardProvider.CreateRandomScore(new APIUser { Username = "smoogipoo", Id = 1040328 }));
+            AddStep("add flyte", () => leaderboardProvider.CreateRandomScore(new APIUser { Username = "flyte", Id = 3103765 }));
+            AddStep("add frenzibyte", () => leaderboardProvider.CreateRandomScore(new APIUser { Username = "frenzibyte", Id = 14210502 }));
         }
 
         [Test]
@@ -166,12 +123,12 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             int playerNumber = 1;
 
-            AddRepeatStep("add 3 other players", () => createRandomScore(new APIUser { Username = $"Player {playerNumber++}" }), 3);
+            AddRepeatStep("add 3 other players", () => leaderboardProvider.CreateRandomScore(new APIUser { Username = $"Player {playerNumber++}" }), 3);
             AddUntilStep("no pink color scores",
                 () => leaderboard.ChildrenOfType<Box>().Select(b => ((Colour4)b.Colour).ToHex()),
                 () => Does.Not.Contain("#FF549A"));
 
-            AddRepeatStep("add 3 friend score", () => createRandomScore(friend), 3);
+            AddRepeatStep("add 3 friend score", () => leaderboardProvider.CreateRandomScore(friend), 3);
             AddUntilStep("at least one friend score is pink",
                 () => leaderboard.GetAllScoresForUsername("my friend")
                                  .SelectMany(score => score.ChildrenOfType<Box>())
@@ -184,7 +141,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("add local player", () =>
             {
                 playerScore.Value = 1222333;
-                createLeaderboardScore(playerScore, new APIUser { Username = "You", Id = 3 }, true);
+                leaderboardProvider.CreateLeaderboardScore(playerScore, new APIUser { Username = "You", Id = 3 }, true);
             });
         }
 
@@ -192,7 +149,8 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddStep("create leaderboard", () =>
             {
-                Child = leaderboard = new TestGameplayLeaderboard
+                leaderboardProvider.Scores.Clear();
+                Child = leaderboard = new TestDrawableGameplayLeaderboard
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -201,27 +159,28 @@ namespace osu.Game.Tests.Visual.Gameplay
             });
         }
 
-        private void createRandomScore(APIUser user) => createLeaderboardScore(new BindableLong(RNG.Next(0, 5_000_000)), user);
-
-        private void createLeaderboardScore(BindableLong score, APIUser user, bool isTracked = false)
-        {
-            var leaderboardScore = leaderboard.Add(user, isTracked);
-            leaderboardScore.TotalScore.BindTo(score);
-        }
-
-        private partial class TestGameplayLeaderboard : GameplayLeaderboard
+        private partial class TestDrawableGameplayLeaderboard : DrawableGameplayLeaderboard
         {
             public float Spacing => Flow.Spacing.Y;
 
-            public bool CheckPositionByUsername(string username, int? expectedPosition)
-            {
-                var scoreItem = Flow.FirstOrDefault(i => i.User?.Username == username);
+            public IEnumerable<DrawableGameplayLeaderboardScore> GetAllScoresForUsername(string username)
+                => Flow.Where(i => i.User?.Username == username);
+        }
 
-                return scoreItem != null && scoreItem.ScorePosition == expectedPosition;
+        public class TestGameplayLeaderboardProvider : IGameplayLeaderboardProvider
+        {
+            public BindableList<GameplayLeaderboardScore> Scores { get; } = new BindableList<GameplayLeaderboardScore>();
+
+            public GameplayLeaderboardScore CreateRandomScore(APIUser user) => CreateLeaderboardScore(new BindableLong(RNG.Next(0, 5_000_000)), user);
+
+            public GameplayLeaderboardScore CreateLeaderboardScore(BindableLong totalScore, APIUser user, bool isTracked = false)
+            {
+                var score = new GameplayLeaderboardScore(user, isTracked, totalScore);
+                Scores.Add(score);
+                return score;
             }
 
-            public IEnumerable<GameplayLeaderboardScore> GetAllScoresForUsername(string username)
-                => Flow.Where(i => i.User?.Username == username);
+            IBindableList<GameplayLeaderboardScore> IGameplayLeaderboardProvider.Scores => Scores;
         }
     }
 }

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

@@ -21,6 +21,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         private bool seek;
 
         [Test]
+        [FlakyTest]
         public void TestAllSamplesStopDuringSeek()
         {
             DrawableSlider? slider = null;

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

@@ -0,0 +1,167 @@
+// 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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Track;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Rendering;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.IO.Stores;
+using osu.Framework.Platform;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Database;
+using osu.Game.IO;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Spectator;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Scoring;
+using osu.Game.Screens.Play;
+using osu.Game.Screens.Select.Leaderboards;
+using osu.Game.Skinning;
+using osu.Game.Tests.Gameplay;
+using osu.Game.Tests.Visual.Spectator;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    [Description(@"Exercises the appearance of the HUD overlay on various skin and ruleset combinations.")]
+    public partial class TestSceneHUDOverlayRulesetLayouts : OsuTestScene, IStorageResourceProvider
+    {
+        private readonly Dictionary<string, ISkin> skins = new Dictionary<string, ISkin>();
+
+        [Resolved]
+        private GameHost host { get; set; } = null!;
+
+        [Resolved]
+        private RulesetStore rulesets { get; set; } = null!;
+
+        [Resolved]
+        private OsuConfigManager configManager { get; set; } = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            skins["argon"] = new ArgonSkin(this);
+            skins["triangles"] = new TrianglesSkin(this);
+            skins["legacy"] = new DefaultLegacySkin(this);
+        }
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddToggleStep("toggle leaderboard", b => configManager.SetValue(OsuSetting.GameplayLeaderboard, b));
+        }
+
+        [Test]
+        public void TestLayout(
+            [Values("argon", "triangles", "legacy")]
+            string skinName,
+            [Values("osu", "taiko", "fruits", "mania")]
+            string rulesetName)
+        {
+            AddStep("create content", () =>
+            {
+                var rulesetInfo = rulesets.GetRuleset(rulesetName);
+                var ruleset = rulesetInfo!.CreateInstance();
+                var beatmap = ruleset.CreateBeatmapConverter(new Beatmap()).Convert();
+                var drawableRuleset = ruleset.CreateDrawableRulesetWith(beatmap);
+
+                ISkin provider = ruleset.CreateSkinTransformer(skins[skinName], beatmap)!;
+
+                var gameplayState = TestGameplayState.Create(ruleset);
+                ((Bindable<LocalUserPlayingState>)gameplayState.PlayingState).Value = LocalUserPlayingState.Playing;
+                var spectatorClient = new TestSpectatorClient();
+
+                for (int i = 0; i < 15; ++i)
+                {
+                    ((ISpectatorClient)spectatorClient).UserStartedWatching([
+                        new SpectatorUser
+                        {
+                            OnlineID = i,
+                            Username = $"User {i}"
+                        }
+                    ]);
+                }
+
+                GameplayClockContainer gameplayClock;
+
+                List<(Type, object)> dependencies =
+                [
+                    (typeof(GameplayState), gameplayState),
+                    (typeof(ScoreProcessor), gameplayState.ScoreProcessor),
+                    (typeof(HealthProcessor), gameplayState.HealthProcessor),
+                    (typeof(IGameplayClock), gameplayClock = new GameplayClockContainer(new TrackVirtual(60000), false, false)),
+                    (typeof(SpectatorClient), spectatorClient),
+                    (typeof(IGameplayLeaderboardProvider), new TestGameplayLeaderboardProvider()),
+                ];
+
+                if (drawableRuleset is IDrawableScrollingRuleset scrolling)
+                    dependencies.Add((typeof(IScrollingInfo), scrolling.ScrollingInfo));
+
+                Child = new DependencyProvidingContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    CachedDependencies = dependencies.ToArray(),
+                    Children = new Drawable[]
+                    {
+                        spectatorClient,
+                        new SkinProvidingContainer(provider)
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Children = new Drawable[]
+                            {
+                                drawableRuleset,
+                                new HUDOverlay(drawableRuleset, [])
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                }
+                            }
+                        }
+                    }
+                };
+
+                gameplayClock.Start();
+            });
+        }
+
+        private class TestGameplayLeaderboardProvider : IGameplayLeaderboardProvider
+        {
+            IBindableList<GameplayLeaderboardScore> IGameplayLeaderboardProvider.Scores => Scores;
+            public BindableList<GameplayLeaderboardScore> Scores { get; } = new BindableList<GameplayLeaderboardScore>();
+            public bool IsPartial { get; } = false;
+
+            public TestGameplayLeaderboardProvider()
+            {
+                for (int i = 0; i < 20; ++i)
+                {
+                    Scores.Add(new GameplayLeaderboardScore(new ScoreInfo
+                    {
+                        User = new APIUser { Username = $"User {i}" },
+                        TotalScore = (20 - i) * 50_000,
+                        Accuracy = i * 0.05,
+                        Combo = i * 50
+                    }, i == 19));
+                }
+            }
+        }
+
+        #region IResourceStorageProvider
+
+        public IRenderer Renderer => host.Renderer;
+        public AudioManager AudioManager => Audio;
+        public IResourceStore<byte[]> Files => null!;
+        public new IResourceStore<byte[]> Resources => base.Resources;
+        public IResourceStore<TextureUpload> CreateTextureLoaderStore(IResourceStore<byte[]> underlyingStore) => host.CreateTextureLoaderStore(underlyingStore);
+        RealmAccess IStorageResourceProvider.RealmAccess => null!;
+
+        #endregion
+    }
+}

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

@@ -204,12 +204,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                 Origin = Anchor.Centre,
                 Direction = FillDirection.Vertical,
                 AutoSizeAxes = Axes.Both,
-                Children = new[]
-                {
-                    new OsuSpriteText { Text = $@"Great: {hitWindows?.WindowFor(HitResult.Great)}" },
-                    new OsuSpriteText { Text = $@"Good: {hitWindows?.WindowFor(HitResult.Ok)}" },
-                    new OsuSpriteText { Text = $@"Meh: {hitWindows?.WindowFor(HitResult.Meh)}" },
-                }
+                ChildrenEnumerable = hitWindows?.GetAllAvailableWindows().Select(w => new OsuSpriteText { Text = $@"{w.result}: {w.length}" }) ?? []
             });
 
             Add(new BarHitErrorMeter

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

@@ -69,6 +69,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         }
 
         [Test]
+        [FlakyTest]
         public void TestFadeOnIdle()
         {
             createTest();
@@ -144,7 +145,8 @@ namespace osu.Game.Tests.Visual.Gameplay
         }
 
         [Test]
-        public void TestDoesntFadeOnMouseDown()
+        [FlakyTest]
+        public void TestDoesNotFadeOnMouseDown()
         {
             createTest();
 

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

@@ -1,124 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Collections.Generic;
-using System.Linq;
-using NUnit.Framework;
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Framework.Testing;
-using osu.Framework.Utils;
-using osu.Game.Configuration;
-using osu.Game.Online.API.Requests.Responses;
-using osu.Game.Rulesets.Osu;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Scoring;
-using osu.Game.Screens.Play.HUD;
-using osu.Game.Screens.Select;
-using osu.Game.Tests.Gameplay;
-
-namespace osu.Game.Tests.Visual.Gameplay
-{
-    public partial class TestSceneSoloGameplayLeaderboard : OsuTestScene
-    {
-        [Cached(typeof(ScoreProcessor))]
-        private readonly ScoreProcessor scoreProcessor = TestGameplayState.Create(new OsuRuleset()).ScoreProcessor;
-
-        private readonly BindableList<ScoreInfo> scores = new BindableList<ScoreInfo>();
-
-        private readonly Bindable<bool> configVisibility = new Bindable<bool>();
-        private readonly Bindable<PlayBeatmapDetailArea.TabType> beatmapTabType = new Bindable<PlayBeatmapDetailArea.TabType>();
-
-        private SoloGameplayLeaderboard leaderboard = null!;
-
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
-        {
-            config.BindWith(OsuSetting.GameplayLeaderboard, configVisibility);
-            config.BindWith(OsuSetting.BeatmapDetailTab, beatmapTabType);
-        }
-
-        [SetUpSteps]
-        public void SetUpSteps()
-        {
-            AddStep("clear scores", () => scores.Clear());
-
-            AddStep("create component", () =>
-            {
-                var trackingUser = new APIUser
-                {
-                    Username = "local user",
-                    Id = 2,
-                };
-
-                Child = leaderboard = new SoloGameplayLeaderboard(trackingUser)
-                {
-                    Scores = { BindTarget = scores },
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    AlwaysVisible = { Value = false },
-                    Expanded = { Value = true },
-                };
-            });
-
-            AddStep("add scores", () => scores.AddRange(createSampleScores()));
-        }
-
-        [Test]
-        public void TestLocalUser()
-        {
-            AddSliderStep("score", 0, 1000000, 500000, v => scoreProcessor.TotalScore.Value = v);
-            AddSliderStep("accuracy", 0f, 1f, 0.5f, v => scoreProcessor.Accuracy.Value = v);
-            AddSliderStep("combo", 0, 10000, 0, v => scoreProcessor.HighestCombo.Value = v);
-            AddStep("toggle expanded", () => leaderboard.Expanded.Value = !leaderboard.Expanded.Value);
-        }
-
-        [TestCase(PlayBeatmapDetailArea.TabType.Local, 51)]
-        [TestCase(PlayBeatmapDetailArea.TabType.Global, null)]
-        [TestCase(PlayBeatmapDetailArea.TabType.Country, null)]
-        [TestCase(PlayBeatmapDetailArea.TabType.Friends, null)]
-        public void TestTrackedScorePosition(PlayBeatmapDetailArea.TabType tabType, int? expectedOverflowIndex)
-        {
-            AddStep($"change TabType to {tabType}", () => beatmapTabType.Value = tabType);
-            AddUntilStep("tracked player is #50", () => leaderboard.TrackedScore?.ScorePosition, () => Is.EqualTo(50));
-
-            AddStep("add one more score", () => scores.Add(new ScoreInfo { User = new APIUser { Username = "New player 1" }, TotalScore = RNG.Next(600000, 1000000) }));
-
-            AddUntilStep("wait for sort", () => leaderboard.ChildrenOfType<GameplayLeaderboardScore>().First().ScorePosition != null);
-
-            if (expectedOverflowIndex == null)
-                AddUntilStep("tracked player has null position", () => leaderboard.TrackedScore?.ScorePosition, () => Is.Null);
-            else
-                AddUntilStep($"tracked player is #{expectedOverflowIndex}", () => leaderboard.TrackedScore?.ScorePosition, () => Is.EqualTo(expectedOverflowIndex));
-        }
-
-        [Test]
-        public void TestVisibility()
-        {
-            AddStep("set config visible true", () => configVisibility.Value = true);
-            AddUntilStep("leaderboard visible", () => leaderboard.Alpha == 1);
-
-            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()
-        {
-            return new[]
-            {
-                new ScoreInfo { User = new APIUser { Username = @"peppy" }, TotalScore = RNG.Next(500000, 1000000) },
-                new ScoreInfo { User = new APIUser { Username = @"smoogipoo" }, TotalScore = RNG.Next(500000, 1000000) },
-                new ScoreInfo { User = new APIUser { Username = @"spaceman_atlas" }, TotalScore = RNG.Next(500000, 1000000) },
-                new ScoreInfo { User = new APIUser { Username = @"frenzibyte" }, TotalScore = RNG.Next(500000, 1000000) },
-                new ScoreInfo { User = new APIUser { Username = @"Susko3" }, TotalScore = RNG.Next(500000, 1000000) },
-            }.Concat(Enumerable.Range(0, 44).Select(i => new ScoreInfo { User = new APIUser { Username = $"User {i + 1}" }, TotalScore = 1000000 - i * 10000 })).ToList();
-        }
-    }
-}

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

@@ -0,0 +1,165 @@
+// 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.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Testing;
+using osu.Game.Online.Leaderboards;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Scoring;
+using osu.Game.Screens.Play;
+using osu.Game.Screens.Select.Leaderboards;
+using osu.Game.Tests.Gameplay;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    [HeadlessTest]
+    public partial class TestSceneSoloGameplayLeaderboardProvider : OsuTestScene
+    {
+        [Test]
+        public void TestLocalLeaderboardHasPositionsAutofilled()
+        {
+            SoloGameplayLeaderboardProvider provider = null!;
+
+            var leaderboardManager = new LeaderboardManager();
+            LoadComponent(leaderboardManager);
+            var gameplayState = TestGameplayState.Create(new OsuRuleset());
+
+            AddStep("fetch local", () => leaderboardManager.FetchWithCriteria(new LeaderboardCriteria(Beatmap.Value.BeatmapInfo, Ruleset.Value, BeatmapLeaderboardScope.Local, null)));
+            AddStep("set scores", () =>
+            {
+                // this is dodgy but anything less dodgy is a lot of work
+                ((Bindable<LeaderboardScores?>)leaderboardManager.Scores).Value = LeaderboardScores.Success(
+                    Enumerable.Range(1, 100).Select(i => new ScoreInfo
+                    {
+                        TotalScore = 10_000 * (100 - i),
+                        Position = i,
+                    }).ToArray(),
+                    1337,
+                    null
+                );
+            });
+            AddStep("create content", () => Child = new DependencyProvidingContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                CachedDependencies =
+                [
+                    (typeof(LeaderboardManager), leaderboardManager),
+                    (typeof(GameplayState), gameplayState)
+                ],
+                Children = new Drawable[]
+                {
+                    leaderboardManager,
+                    provider = new SoloGameplayLeaderboardProvider()
+                }
+            });
+            AddUntilStep("tracked score shows #101", () => provider.Scores.Single(s => s.Tracked).Position.Value, () => Is.EqualTo(101));
+            AddUntilStep("tracked score ordered #101", () => provider.Scores.Single(s => s.Tracked).DisplayOrder.Value, () => Is.EqualTo(101));
+            AddStep("move score to #20", () => gameplayState.ScoreProcessor.TotalScore.Value = 802_000);
+            AddUntilStep("tracked score shows #20", () => provider.Scores.Single(s => s.Tracked).Position.Value, () => Is.EqualTo(20));
+            AddUntilStep("tracked score ordered #20", () => provider.Scores.Single(s => s.Tracked).DisplayOrder.Value, () => Is.EqualTo(20));
+            AddStep("move score to #1", () => gameplayState.ScoreProcessor.TotalScore.Value = 1_002_000);
+            AddUntilStep("tracked score shows #1", () => provider.Scores.Single(s => s.Tracked).Position.Value, () => Is.EqualTo(1));
+            AddUntilStep("tracked score ordered #1", () => provider.Scores.Single(s => s.Tracked).DisplayOrder.Value, () => Is.EqualTo(1));
+        }
+
+        [Test]
+        public void TestFullGlobalLeaderboard()
+        {
+            SoloGameplayLeaderboardProvider provider = null!;
+
+            var leaderboardManager = new LeaderboardManager();
+            LoadComponent(leaderboardManager);
+            var gameplayState = TestGameplayState.Create(new OsuRuleset());
+
+            AddStep("fetch local", () => leaderboardManager.FetchWithCriteria(new LeaderboardCriteria(Beatmap.Value.BeatmapInfo, Ruleset.Value, BeatmapLeaderboardScope.Global, null)));
+            AddStep("set scores", () =>
+            {
+                // this is dodgy but anything less dodgy is a lot of work
+                ((Bindable<LeaderboardScores?>)leaderboardManager.Scores).Value = LeaderboardScores.Success(
+                    Enumerable.Range(1, 40).Select(i => new ScoreInfo
+                    {
+                        TotalScore = 600_000 + 10_000 * (40 - i),
+                        Position = i,
+                    }).ToArray(),
+                    1337,
+                    null
+                );
+            });
+            AddStep("create content", () => Child = new DependencyProvidingContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                CachedDependencies =
+                [
+                    (typeof(LeaderboardManager), leaderboardManager),
+                    (typeof(GameplayState), gameplayState)
+                ],
+                Children = new Drawable[]
+                {
+                    leaderboardManager,
+                    provider = new SoloGameplayLeaderboardProvider()
+                }
+            });
+            AddUntilStep("tracked score shows #41", () => provider.Scores.Single(s => s.Tracked).Position.Value, () => Is.EqualTo(41));
+            AddUntilStep("tracked score ordered #41", () => provider.Scores.Single(s => s.Tracked).DisplayOrder.Value, () => Is.EqualTo(41));
+            AddStep("move score to #20", () => gameplayState.ScoreProcessor.TotalScore.Value = 802_000);
+            AddUntilStep("tracked score shows #20", () => provider.Scores.Single(s => s.Tracked).Position.Value, () => Is.EqualTo(20));
+            AddUntilStep("tracked score ordered #20", () => provider.Scores.Single(s => s.Tracked).DisplayOrder.Value, () => Is.EqualTo(20));
+            AddStep("move score to #1", () => gameplayState.ScoreProcessor.TotalScore.Value = 1_002_000);
+            AddUntilStep("tracked score shows #1", () => provider.Scores.Single(s => s.Tracked).Position.Value, () => Is.EqualTo(1));
+            AddUntilStep("tracked score ordered #1", () => provider.Scores.Single(s => s.Tracked).DisplayOrder.Value, () => Is.EqualTo(1));
+        }
+
+        [Test]
+        public void TestPartialGlobalLeaderboard()
+        {
+            SoloGameplayLeaderboardProvider provider = null!;
+
+            var leaderboardManager = new LeaderboardManager();
+            LoadComponent(leaderboardManager);
+            var gameplayState = TestGameplayState.Create(new OsuRuleset());
+
+            AddStep("fetch local", () => leaderboardManager.FetchWithCriteria(new LeaderboardCriteria(Beatmap.Value.BeatmapInfo, Ruleset.Value, BeatmapLeaderboardScope.Global, null)));
+            AddStep("set scores", () =>
+            {
+                // this is dodgy but anything less dodgy is a lot of work
+                ((Bindable<LeaderboardScores?>)leaderboardManager.Scores).Value = LeaderboardScores.Success(
+                    Enumerable.Range(1, 50).Select(i => new ScoreInfo
+                    {
+                        TotalScore = 500_000 + 10_000 * (50 - i),
+                        Position = i
+                    }).ToArray(),
+                    1337,
+                    new ScoreInfo { TotalScore = 200_000 }
+                );
+            });
+            AddStep("create content", () => Child = new DependencyProvidingContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                CachedDependencies =
+                [
+                    (typeof(LeaderboardManager), leaderboardManager),
+                    (typeof(GameplayState), gameplayState)
+                ],
+                Children = new Drawable[]
+                {
+                    leaderboardManager,
+                    provider = new SoloGameplayLeaderboardProvider()
+                }
+            });
+            AddUntilStep("tracked score shows no position", () => provider.Scores.Single(s => s.Tracked).Position.Value, () => Is.Null);
+            AddUntilStep("tracked score ordered #52", () => provider.Scores.Single(s => s.Tracked).DisplayOrder.Value, () => Is.EqualTo(52));
+            AddStep("move score above user best", () => gameplayState.ScoreProcessor.TotalScore.Value = 202_000);
+            AddUntilStep("tracked score shows no position", () => provider.Scores.Single(s => s.Tracked).Position.Value, () => Is.Null);
+            AddUntilStep("tracked score ordered #51", () => provider.Scores.Single(s => s.Tracked).DisplayOrder.Value, () => Is.EqualTo(51));
+            AddStep("move score to #20", () => gameplayState.ScoreProcessor.TotalScore.Value = 802_000);
+            AddUntilStep("tracked score shows #20", () => provider.Scores.Single(s => s.Tracked).Position.Value, () => Is.EqualTo(20));
+            AddUntilStep("tracked score ordered #20", () => provider.Scores.Single(s => s.Tracked).DisplayOrder.Value, () => Is.EqualTo(20));
+            AddStep("move score to #1", () => gameplayState.ScoreProcessor.TotalScore.Value = 1_002_000);
+            AddUntilStep("tracked score shows #1", () => provider.Scores.Single(s => s.Tracked).Position.Value, () => Is.EqualTo(1));
+            AddUntilStep("tracked score ordered #1", () => provider.Scores.Single(s => s.Tracked).DisplayOrder.Value, () => Is.EqualTo(1));
+        }
+    }
+}

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/Multiplayer/MultiplayerGameplayLeaderboardTestScene.cs

@@ -10,6 +10,7 @@ using Moq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Configuration;
@@ -20,6 +21,7 @@ using osu.Game.Online.Spectator;
 using osu.Game.Replays.Legacy;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play.HUD;
+using osu.Game.Screens.Select.Leaderboards;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
@@ -29,11 +31,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         protected readonly BindableList<MultiplayerRoomUser> MultiplayerUsers = new BindableList<MultiplayerRoomUser>();
 
-        protected MultiplayerGameplayLeaderboard? Leaderboard { get; private set; }
+        protected MultiplayerLeaderboardProvider? LeaderboardProvider { get; private set; }
+
+        protected DrawableGameplayLeaderboard? Leaderboard { get; private set; }
 
         protected virtual MultiplayerRoomUser CreateUser(int userId) => new MultiplayerRoomUser(userId);
 
-        protected abstract MultiplayerGameplayLeaderboard CreateLeaderboard();
+        protected abstract MultiplayerLeaderboardProvider CreateLeaderboardProvider();
 
         private readonly BindableList<int> multiplayerUserIds = new BindableList<int>();
         private readonly BindableDictionary<int, SpectatorState> watchedUserStates = new BindableDictionary<int, SpectatorState>();
@@ -124,19 +128,38 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("create leaderboard", () =>
             {
-                Leaderboard?.Expire();
+                Clear(true);
 
                 Beatmap.Value = CreateWorkingBeatmap(Ruleset.Value);
 
-                LoadComponentAsync(Leaderboard = CreateLeaderboard(), Add);
+                LoadComponentAsync(LeaderboardProvider = CreateLeaderboardProvider(), Add);
+                Add(new DependencyProvidingContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    CachedDependencies = [(typeof(IGameplayLeaderboardProvider), LeaderboardProvider)],
+                    Child = Leaderboard = new DrawableGameplayLeaderboard
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    }
+                });
             });
 
             AddUntilStep("wait for load", () => Leaderboard!.IsLoaded);
 
-            AddStep("check watch requests were sent", () =>
+            AddUntilStep("check watch requests were sent", () =>
             {
-                foreach (var user in MultiplayerUsers)
-                    spectatorClient.Verify(s => s.WatchUser(user.UserID), Times.Once);
+                try
+                {
+                    foreach (var user in MultiplayerUsers)
+                        spectatorClient.Verify(s => s.WatchUser(user.UserID), Times.Once);
+
+                    return true;
+                }
+                catch (MockException)
+                {
+                    return false;
+                }
             });
         }
 
@@ -144,7 +167,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         public void TestScoreUpdates()
         {
             AddRepeatStep("update state", UpdateUserStatesRandomly, 100);
-            AddToggleStep("switch compact mode", expanded => Leaderboard!.Expanded.Value = expanded);
+            AddToggleStep("switch compact mode", expanded => Leaderboard!.ForceExpand.Value = expanded);
         }
 
         [Test]
@@ -159,10 +182,18 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 return false;
             });
 
-            AddStep("check stop watching requests were sent", () =>
+            AddUntilStep("check stop watching requests were sent", () =>
             {
-                foreach (var user in MultiplayerUsers)
-                    spectatorClient.Verify(s => s.StopWatchingUser(user.UserID), Times.Once);
+                try
+                {
+                    foreach (var user in MultiplayerUsers)
+                        spectatorClient.Verify(s => s.StopWatchingUser(user.UserID), Times.Once);
+                    return true;
+                }
+                catch (MockException)
+                {
+                    return false;
+                }
             });
         }
 
@@ -204,12 +235,14 @@ namespace osu.Game.Tests.Visual.Multiplayer
                         header.Combo++;
                         header.MaxCombo = Math.Max(header.MaxCombo, header.Combo);
                         header.Statistics[HitResult.Meh]++;
+                        header.TotalScore += 50;
                         break;
 
                     default:
                         header.Combo++;
                         header.MaxCombo = Math.Max(header.MaxCombo, header.Combo);
                         header.Statistics[HitResult.Great]++;
+                        header.TotalScore += 300;
                         break;
                 }
 
@@ -218,3 +251,4 @@ namespace osu.Game.Tests.Visual.Multiplayer
         }
     }
 }
+

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

@@ -9,15 +9,16 @@ using osu.Framework.Testing;
 using osu.Framework.Timing;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Multiplayer;
-using osu.Game.Screens.OnlinePlay.Multiplayer.Spectate;
 using osu.Game.Screens.Play.HUD;
+using osu.Game.Screens.Select.Leaderboards;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
     public partial class TestSceneMultiSpectatorLeaderboard : MultiplayerTestScene
     {
         private Dictionary<int, ManualClock> clocks = null!;
-        private MultiSpectatorLeaderboard? leaderboard;
+        private MultiSpectatorLeaderboardProvider? leaderboardProvider;
+        private DrawableGameplayLeaderboard leaderboard = null!;
 
         [SetUpSteps]
         public override void SetUpSteps()
@@ -29,7 +30,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("reset", () =>
             {
-                leaderboard?.RemoveAndDisposeImmediately();
+                Clear(true);
 
                 clocks = new Dictionary<int, ManualClock>
                 {
@@ -48,21 +49,27 @@ namespace osu.Game.Tests.Visual.Multiplayer
             {
                 Beatmap.Value = CreateWorkingBeatmap(Ruleset.Value);
 
-                LoadComponentAsync(leaderboard = new MultiSpectatorLeaderboard(clocks.Keys.Select(id => new MultiplayerRoomUser(id)).ToArray())
+                LoadComponentAsync(leaderboardProvider = new MultiSpectatorLeaderboardProvider(clocks.Keys.Select(id => new MultiplayerRoomUser(id)).ToArray()), Add);
+                Add(new DependencyProvidingContainer
                 {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    Expanded = { Value = true }
-                }, Add);
+                    RelativeSizeAxes = Axes.Both,
+                    CachedDependencies = [(typeof(IGameplayLeaderboardProvider), leaderboardProvider)],
+                    Child = leaderboard = new DrawableGameplayLeaderboard
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        ForceExpand = { Value = true }
+                    }
+                });
             });
 
-            AddUntilStep("wait for load", () => leaderboard!.IsLoaded);
-            AddUntilStep("wait for user population", () => leaderboard.ChildrenOfType<GameplayLeaderboardScore>().Count() == 2);
+            AddUntilStep("wait for load", () => leaderboard.IsLoaded);
+            AddUntilStep("wait for user population", () => leaderboard.ChildrenOfType<DrawableGameplayLeaderboardScore>().Count() == 2);
 
             AddStep("add clock sources", () =>
             {
                 foreach ((int userId, var clock) in clocks)
-                    leaderboard!.AddClock(userId, clock);
+                    leaderboardProvider!.AddClock(userId, clock);
             });
         }
 
@@ -123,6 +130,6 @@ namespace osu.Game.Tests.Visual.Multiplayer
             => AddStep($"set user {userId} time {time}", () => clocks[userId].CurrentTime = time);
 
         private void assertCombo(int userId, int expectedCombo)
-            => AddUntilStep($"player {userId} has {expectedCombo} combo", () => this.ChildrenOfType<GameplayLeaderboardScore>().Single(s => s.User?.OnlineID == userId).Combo.Value == expectedCombo);
+            => AddUntilStep($"player {userId} has {expectedCombo} combo", () => this.ChildrenOfType<DrawableGameplayLeaderboardScore>().Single(s => s.User?.OnlineID == userId).Combo.Value == expectedCombo);
     }
 }

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

@@ -303,6 +303,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         }
 
         [Test]
+        [FlakyTest]
         public void TestMostInSyncUserIsAudioSource()
         {
             start(new[] { PLAYER_1_ID, PLAYER_2_ID });
@@ -560,7 +561,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         private PlayerArea getInstance(int userId) => spectatorScreen.ChildrenOfType<PlayerArea>().Single(p => p.UserId == userId);
 
-        private GameplayLeaderboardScore getLeaderboardScore(int userId) => spectatorScreen.ChildrenOfType<GameplayLeaderboardScore>().Single(s => s.User?.OnlineID == userId);
+        private DrawableGameplayLeaderboardScore getLeaderboardScore(int userId) => spectatorScreen.Leaderboard.ChildrenOfType<DrawableGameplayLeaderboardScore>().Single(s => s.User?.OnlineID == userId);
 
         private int[] getPlayerIds(int count) => Enumerable.Range(PLAYER_1_ID, count).ToArray();
     }