Merge remote-tracking branch 'upstream/master' into fix-selectionblueprint-order

2025-03-20 12:08:29 +08:00 · 2022-09-12 12:52:32 +02:00 · 2022-09-12 12:52:32 +02:00 · f48a743890
commit f48a743890
parent 837cc76019 00c9763d67
305 changed files with 5878 additions and 2223 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -1,5 +1,8 @@
 on: [push, pull_request]
 name: Continuous Integration
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true

 jobs:
  inspect-code:
--- a/Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform/EmptyFreeformRuleset.cs
+++ b/Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform/EmptyFreeformRuleset.cs
@ -77,5 +77,8 @@ namespace osu.Game.Rulesets.EmptyFreeform
                };
            }
        }
+
+        // Leave this line intact. It will bake the correct version into the ruleset on each build/release.
+        public override string RulesetAPIVersionSupported => CURRENT_RULESET_API_VERSION;
    }
 }
--- a/Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon/PippidonRuleset.cs
+++ b/Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon/PippidonRuleset.cs
@ -49,5 +49,8 @@ namespace osu.Game.Rulesets.Pippidon
        };

        public override Drawable CreateIcon() => new PippidonRulesetIcon(this);
+
+        // Leave this line intact. It will bake the correct version into the ruleset on each build/release.
+        public override string RulesetAPIVersionSupported => CURRENT_RULESET_API_VERSION;
    }
 }
--- a/Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling/EmptyScrollingRuleset.cs
+++ b/Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling/EmptyScrollingRuleset.cs
@ -54,5 +54,8 @@ namespace osu.Game.Rulesets.EmptyScrolling
            Text = ShortName[0].ToString(),
            Font = OsuFont.Default.With(size: 18),
        };
+
+        // Leave this line intact. It will bake the correct version into the ruleset on each build/release.
+        public override string RulesetAPIVersionSupported => CURRENT_RULESET_API_VERSION;
    }
 }
--- a/Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/PippidonRuleset.cs
+++ b/Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/PippidonRuleset.cs
@ -46,5 +46,8 @@ namespace osu.Game.Rulesets.Pippidon
        };

        public override Drawable CreateIcon() => new PippidonRulesetIcon(this);
+
+        // Leave this line intact. It will bake the correct version into the ruleset on each build/release.
+        public override string RulesetAPIVersionSupported => CURRENT_RULESET_API_VERSION;
    }
 }
--- a/osu.Android.props
+++ b/osu.Android.props
@ -51,8 +51,8 @@
    <Reference Include="Java.Interop" />
  </ItemGroup>
  <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2022.819.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2022.825.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2022.831.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2022.908.0" />
  </ItemGroup>
  <ItemGroup Label="Transitive Dependencies">
    <!-- Realm needs to be directly referenced in all Xamarin projects, as it will not pull in its transitive dependencies otherwise. -->
--- a/osu.Desktop/Security/ElevatedPrivilegesChecker.cs
+++ b/osu.Desktop/Security/ElevatedPrivilegesChecker.cs
@ -76,7 +76,7 @@ namespace osu.Desktop.Security
            private void load(OsuColour colours)
            {
                Icon = FontAwesome.Solid.ShieldAlt;
-                IconBackground.Colour = colours.YellowDark;
+                IconContent.Colour = colours.YellowDark;
            }
        }
    }
--- a/osu.Desktop/Updater/SquirrelUpdateManager.cs
+++ b/osu.Desktop/Updater/SquirrelUpdateManager.cs
@ -5,29 +5,24 @@ using System;
 using System.Runtime.Versioning;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Colour;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Logging;
 using osu.Game;
-using osu.Game.Graphics;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
-using osuTK;
-using osuTK.Graphics;
 using Squirrel;
 using Squirrel.SimpleSplat;
+using LogLevel = Squirrel.SimpleSplat.LogLevel;
+using UpdateManager = osu.Game.Updater.UpdateManager;

 namespace osu.Desktop.Updater
 {
    [SupportedOSPlatform("windows")]
-    public class SquirrelUpdateManager : osu.Game.Updater.UpdateManager
+    public class SquirrelUpdateManager : UpdateManager
    {
-        private UpdateManager? updateManager;
+        private Squirrel.UpdateManager? updateManager;
        private INotificationOverlay notificationOverlay = null!;

-        public Task PrepareUpdateAsync() => UpdateManager.RestartAppWhenExited();
+        public Task PrepareUpdateAsync() => Squirrel.UpdateManager.RestartAppWhenExited();

        private static readonly Logger logger = Logger.GetLogger("updater");

@ -38,6 +33,9 @@ namespace osu.Desktop.Updater

        private readonly SquirrelLogger squirrelLogger = new SquirrelLogger();

+        [Resolved]
+        private OsuGameBase game { get; set; } = null!;
+
        [BackgroundDependencyLoader]
        private void load(INotificationOverlay notifications)
        {
@ -66,7 +64,14 @@ namespace osu.Desktop.Updater
                    if (updatePending)
                    {
                        // the user may have dismissed the completion notice, so show it again.
-                        notificationOverlay.Post(new UpdateCompleteNotification(this));
+                        notificationOverlay.Post(new UpdateApplicationCompleteNotification
+                        {
+                            Activated = () =>
+                            {
+                                restartToApplyUpdate();
+                                return true;
+                            },
+                        });
                        return true;
                    }

@ -78,19 +83,21 @@ namespace osu.Desktop.Updater

                if (notification == null)
                {
-                    notification = new UpdateProgressNotification(this) { State = ProgressNotificationState.Active };
+                    notification = new UpdateProgressNotification
+                    {
+                        CompletionClickAction = restartToApplyUpdate,
+                    };
+
                    Schedule(() => notificationOverlay.Post(notification));
                }

-                notification.Progress = 0;
-                notification.Text = @"Downloading update...";
+                notification.StartDownload();

                try
                {
                    await updateManager.DownloadReleases(info.ReleasesToApply, p => notification.Progress = p / 100f).ConfigureAwait(false);

-                    notification.Progress = 0;
-                    notification.Text = @"Installing update...";
+                    notification.StartInstall();

                    await updateManager.ApplyReleases(info, p => notification.Progress = p / 100f).ConfigureAwait(false);

@ -110,9 +117,7 @@ namespace osu.Desktop.Updater
                    else
                    {
                        // In the case of an error, a separate notification will be displayed.
-                        notification.State = ProgressNotificationState.Cancelled;
-                        notification.Close();
-
+                        notification.FailDownload();
                        Logger.Error(e, @"update failed!");
                    }
                }
@ -134,84 +139,24 @@ namespace osu.Desktop.Updater
            return true;
        }

+        private bool restartToApplyUpdate()
+        {
+            PrepareUpdateAsync()
+                .ContinueWith(_ => Schedule(() => game.AttemptExit()));
+            return true;
+        }
+
        protected override void Dispose(bool isDisposing)
        {
            base.Dispose(isDisposing);
            updateManager?.Dispose();
        }

-        private class UpdateCompleteNotification : ProgressCompletionNotification
-        {
-            [Resolved]
-            private OsuGame game { get; set; } = null!;
-
-            public UpdateCompleteNotification(SquirrelUpdateManager updateManager)
-            {
-                Text = @"Update ready to install. Click to restart!";
-
-                Activated = () =>
-                {
-                    updateManager.PrepareUpdateAsync()
-                                 .ContinueWith(_ => updateManager.Schedule(() => game.AttemptExit()));
-                    return true;
-                };
-            }
-        }
-
-        private class UpdateProgressNotification : ProgressNotification
-        {
-            private readonly SquirrelUpdateManager updateManager;
-
-            public UpdateProgressNotification(SquirrelUpdateManager updateManager)
-            {
-                this.updateManager = updateManager;
-            }
-
-            protected override Notification CreateCompletionNotification()
-            {
-                return new UpdateCompleteNotification(updateManager);
-            }
-
-            [BackgroundDependencyLoader]
-            private void load(OsuColour colours)
-            {
-                IconContent.AddRange(new Drawable[]
-                {
-                    new Box
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Colour = ColourInfo.GradientVertical(colours.YellowDark, colours.Yellow)
-                    },
-                    new SpriteIcon
-                    {
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        Icon = FontAwesome.Solid.Upload,
-                        Colour = Color4.White,
-                        Size = new Vector2(20),
-                    }
-                });
-            }
-
-            public override void Close()
-            {
-                // cancelling updates is not currently supported by the underlying updater.
-                // only allow dismissing for now.
-
-                switch (State)
-                {
-                    case ProgressNotificationState.Cancelled:
-                        base.Close();
-                        break;
-                }
-            }
-        }
-
        private class SquirrelLogger : ILogger, IDisposable
        {
-            public Squirrel.SimpleSplat.LogLevel Level { get; set; } = Squirrel.SimpleSplat.LogLevel.Info;
+            public LogLevel Level { get; set; } = LogLevel.Info;

-            public void Write(string message, Squirrel.SimpleSplat.LogLevel logLevel)
+            public void Write(string message, LogLevel logLevel)
            {
                if (logLevel < Level)
                    return;
--- a/osu.Game.Rulesets.Catch.Tests/Editor/CatchSelectionBlueprintTestScene.cs
+++ b/osu.Game.Rulesets.Catch.Tests/Editor/CatchSelectionBlueprintTestScene.cs
@ -70,10 +70,17 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
            [Cached]
            private readonly BindableBeatDivisor beatDivisor;

+            protected override Container<Drawable> Content { get; } = new Container { RelativeSizeAxes = Axes.Both };
+
            public EditorBeatmapDependencyContainer(IBeatmap beatmap, BindableBeatDivisor beatDivisor)
            {
-                editorClock = new EditorClock(beatmap, beatDivisor);
                this.beatDivisor = beatDivisor;
+
+                InternalChildren = new Drawable[]
+                {
+                    editorClock = new EditorClock(beatmap, beatDivisor),
+                    Content,
+                };
            }
        }
    }
--- a/osu.Game.Rulesets.Catch.Tests/TestSceneCatchTouchInput.cs
+++ b/osu.Game.Rulesets.Catch.Tests/TestSceneCatchTouchInput.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 NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Testing;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    [TestFixture]
+    public class TestSceneCatchTouchInput : OsuTestScene
+    {
+        private CatchTouchInputMapper catchTouchInputMapper = null!;
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("create input overlay", () =>
+            {
+                Child = new CatchInputManager(new CatchRuleset().RulesetInfo)
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        catchTouchInputMapper = new CatchTouchInputMapper
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre
+                        }
+                    }
+                };
+            });
+        }
+
+        [Test]
+        public void TestBasic()
+        {
+            AddStep("show overlay", () => catchTouchInputMapper.Show());
+        }
+    }
+}
--- a/osu.Game.Rulesets.Catch/CatchInputManager.cs
+++ b/osu.Game.Rulesets.Catch/CatchInputManager.cs
@ -4,11 +4,13 @@
 #nullable disable

 using System.ComponentModel;
+using osu.Framework.Allocation;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.UI;

 namespace osu.Game.Rulesets.Catch
 {
+    [Cached]
    public class CatchInputManager : RulesetInputManager<CatchAction>
    {
        public CatchInputManager(RulesetInfo ruleset)
--- a/osu.Game.Rulesets.Catch/CatchRuleset.cs
+++ b/osu.Game.Rulesets.Catch/CatchRuleset.cs
@ -1,39 +1,37 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

-#nullable disable
-
-using osu.Game.Beatmaps;
-using osu.Game.Graphics;
-using osu.Game.Rulesets.Catch.Mods;
-using osu.Game.Rulesets.Catch.UI;
-using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.UI;
+using System;
 using System.Collections.Generic;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
-using osu.Game.Rulesets.Catch.Replays;
-using osu.Game.Rulesets.Replays.Types;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Legacy;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Difficulty;
-using osu.Game.Rulesets.Catch.Scoring;
-using osu.Game.Rulesets.Difficulty;
-using osu.Game.Rulesets.Scoring;
-using System;
-using osu.Framework.Extensions.EnumExtensions;
-using osu.Framework.Localisation;
 using osu.Game.Rulesets.Catch.Edit;
+using osu.Game.Rulesets.Catch.Mods;
+using osu.Game.Rulesets.Catch.Replays;
+using osu.Game.Rulesets.Catch.Scoring;
 using osu.Game.Rulesets.Catch.Skinning.Legacy;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Replays.Types;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI;
 using osu.Game.Skinning;

 namespace osu.Game.Rulesets.Catch
 {
    public class CatchRuleset : Ruleset, ILegacyRuleset
    {
-        public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod> mods = null) => new DrawableCatchRuleset(this, beatmap, mods);
+        public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod>? mods = null) => new DrawableCatchRuleset(this, beatmap, mods);

        public override ScoreProcessor CreateScoreProcessor() => new CatchScoreProcessor();

@ -43,6 +41,8 @@ namespace osu.Game.Rulesets.Catch

        public const string SHORT_NAME = "fruits";

+        public override string RulesetAPIVersionSupported => CURRENT_RULESET_API_VERSION;
+
        public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0) => new[]
        {
            new KeyBinding(InputKey.Z, CatchAction.MoveLeft),
--- a/osu.Game.Rulesets.Catch/Edit/Blueprints/Components/EditablePath.cs
+++ b/osu.Game.Rulesets.Catch/Edit/Blueprints/Components/EditablePath.cs
@ -56,7 +56,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints.Components
        public void UpdateFrom(ScrollingHitObjectContainer hitObjectContainer, JuiceStream hitObject)
        {
            while (path.Vertices.Count < InternalChildren.Count)
-                RemoveInternal(InternalChildren[^1]);
+                RemoveInternal(InternalChildren[^1], true);

            while (InternalChildren.Count < path.Vertices.Count)
                AddInternal(new VertexPiece());
--- a/osu.Game.Rulesets.Catch/Edit/Blueprints/Components/NestedOutlineContainer.cs
+++ b/osu.Game.Rulesets.Catch/Edit/Blueprints/Components/NestedOutlineContainer.cs
@ -30,7 +30,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints.Components
                                                     .Where(h => !(h is TinyDroplet)));

            while (nestedHitObjects.Count < InternalChildren.Count)
-                RemoveInternal(InternalChildren[^1]);
+                RemoveInternal(InternalChildren[^1], true);

            while (InternalChildren.Count < nestedHitObjects.Count)
                AddInternal(new FruitOutline());
--- a/osu.Game.Rulesets.Catch/UI/CatchTouchInputMapper.cs
+++ b/osu.Game.Rulesets.Catch/UI/CatchTouchInputMapper.cs
@ -0,0 +1,277 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Catch.UI
+{
+    public class CatchTouchInputMapper : VisibilityContainer
+    {
+        public override bool PropagatePositionalInputSubTree => true;
+        public override bool PropagateNonPositionalInputSubTree => true;
+
+        private readonly Dictionary<object, TouchCatchAction> trackedActionSources = new Dictionary<object, TouchCatchAction>();
+
+        private KeyBindingContainer<CatchAction> keyBindingContainer = null!;
+
+        private Container mainContent = null!;
+
+        private InputArea leftBox = null!;
+        private InputArea rightBox = null!;
+        private InputArea leftDashBox = null!;
+        private InputArea rightDashBox = null!;
+
+        [BackgroundDependencyLoader]
+        private void load(CatchInputManager catchInputManager, OsuColour colours)
+        {
+            const float width = 0.15f;
+
+            keyBindingContainer = catchInputManager.KeyBindingContainer;
+
+            RelativeSizeAxes = Axes.Both;
+
+            Children = new Drawable[]
+            {
+                mainContent = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 0,
+                    Children = new Drawable[]
+                    {
+                        new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Width = width,
+                            Children = new Drawable[]
+                            {
+                                leftDashBox = new InputArea(TouchCatchAction.DashLeft, trackedActionSources)
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Width = 0.5f,
+                                },
+                                leftBox = new InputArea(TouchCatchAction.MoveLeft, trackedActionSources)
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Width = 0.5f,
+                                    Colour = colours.Gray9,
+                                    Anchor = Anchor.TopRight,
+                                    Origin = Anchor.TopRight,
+                                },
+                            }
+                        },
+                        new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Width = width,
+                            Anchor = Anchor.TopRight,
+                            Origin = Anchor.TopRight,
+                            Children = new Drawable[]
+                            {
+                                rightBox = new InputArea(TouchCatchAction.MoveRight, trackedActionSources)
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Width = 0.5f,
+                                    Colour = colours.Gray9,
+                                },
+                                rightDashBox = new InputArea(TouchCatchAction.DashRight, trackedActionSources)
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Width = 0.5f,
+                                    Anchor = Anchor.TopRight,
+                                    Origin = Anchor.TopRight,
+                                },
+                            }
+                        },
+                    },
+                },
+            };
+        }
+
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            // Hide whenever the keyboard is used.
+            Hide();
+            return false;
+        }
+
+        protected override bool OnMouseDown(MouseDownEvent e)
+        {
+            return updateAction(e.Button, getTouchCatchActionFromInput(e.ScreenSpaceMousePosition));
+        }
+
+        protected override bool OnTouchDown(TouchDownEvent e)
+        {
+            return updateAction(e.Touch.Source, getTouchCatchActionFromInput(e.ScreenSpaceTouch.Position));
+        }
+
+        protected override bool OnMouseMove(MouseMoveEvent e)
+        {
+            Show();
+
+            TouchCatchAction? action = getTouchCatchActionFromInput(e.ScreenSpaceMousePosition);
+
+            // multiple mouse buttons may be pressed and handling the same action.
+            foreach (MouseButton button in e.PressedButtons)
+                updateAction(button, action);
+
+            return false;
+        }
+
+        protected override void OnTouchMove(TouchMoveEvent e)
+        {
+            updateAction(e.Touch.Source, getTouchCatchActionFromInput(e.ScreenSpaceTouch.Position));
+            base.OnTouchMove(e);
+        }
+
+        protected override void OnMouseUp(MouseUpEvent e)
+        {
+            updateAction(e.Button, null);
+            base.OnMouseUp(e);
+        }
+
+        protected override void OnTouchUp(TouchUpEvent e)
+        {
+            updateAction(e.Touch.Source, null);
+            base.OnTouchUp(e);
+        }
+
+        private bool updateAction(object source, TouchCatchAction? newAction)
+        {
+            TouchCatchAction? actionBefore = null;
+
+            if (trackedActionSources.TryGetValue(source, out TouchCatchAction found))
+                actionBefore = found;
+
+            if (actionBefore != newAction)
+            {
+                if (newAction != null)
+                    trackedActionSources[source] = newAction.Value;
+                else
+                    trackedActionSources.Remove(source);
+
+                updatePressedActions();
+            }
+
+            return newAction != null;
+        }
+
+        private void updatePressedActions()
+        {
+            Show();
+
+            if (trackedActionSources.ContainsValue(TouchCatchAction.DashLeft) || trackedActionSources.ContainsValue(TouchCatchAction.MoveLeft))
+                keyBindingContainer.TriggerPressed(CatchAction.MoveLeft);
+            else
+                keyBindingContainer.TriggerReleased(CatchAction.MoveLeft);
+
+            if (trackedActionSources.ContainsValue(TouchCatchAction.DashRight) || trackedActionSources.ContainsValue(TouchCatchAction.MoveRight))
+                keyBindingContainer.TriggerPressed(CatchAction.MoveRight);
+            else
+                keyBindingContainer.TriggerReleased(CatchAction.MoveRight);
+
+            if (trackedActionSources.ContainsValue(TouchCatchAction.DashLeft) || trackedActionSources.ContainsValue(TouchCatchAction.DashRight))
+                keyBindingContainer.TriggerPressed(CatchAction.Dash);
+            else
+                keyBindingContainer.TriggerReleased(CatchAction.Dash);
+        }
+
+        private TouchCatchAction? getTouchCatchActionFromInput(Vector2 screenSpaceInputPosition)
+        {
+            if (leftDashBox.Contains(screenSpaceInputPosition))
+                return TouchCatchAction.DashLeft;
+            if (rightDashBox.Contains(screenSpaceInputPosition))
+                return TouchCatchAction.DashRight;
+            if (leftBox.Contains(screenSpaceInputPosition))
+                return TouchCatchAction.MoveLeft;
+            if (rightBox.Contains(screenSpaceInputPosition))
+                return TouchCatchAction.MoveRight;
+
+            return null;
+        }
+
+        protected override void PopIn() => mainContent.FadeIn(300, Easing.OutQuint);
+
+        protected override void PopOut() => mainContent.FadeOut(300, Easing.OutQuint);
+
+        private class InputArea : CompositeDrawable, IKeyBindingHandler<CatchAction>
+        {
+            private readonly TouchCatchAction handledAction;
+
+            private readonly Box highlightOverlay;
+
+            private readonly IEnumerable<KeyValuePair<object, TouchCatchAction>> trackedActions;
+
+            private bool isHighlighted;
+
+            public InputArea(TouchCatchAction handledAction, IEnumerable<KeyValuePair<object, TouchCatchAction>> trackedActions)
+            {
+                this.handledAction = handledAction;
+                this.trackedActions = trackedActions;
+
+                InternalChildren = new Drawable[]
+                {
+                    new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Masking = true,
+                        CornerRadius = 10,
+                        Children = new Drawable[]
+                        {
+                            new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Alpha = 0.15f,
+                            },
+                            highlightOverlay = new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Alpha = 0,
+                                Blending = BlendingParameters.Additive,
+                            }
+                        }
+                    }
+                };
+            }
+
+            public bool OnPressed(KeyBindingPressEvent<CatchAction> _)
+            {
+                updateHighlight();
+                return false;
+            }
+
+            public void OnReleased(KeyBindingReleaseEvent<CatchAction> _)
+            {
+                updateHighlight();
+            }
+
+            private void updateHighlight()
+            {
+                bool isHandling = trackedActions.Any(a => a.Value == handledAction);
+
+                if (isHandling == isHighlighted)
+                    return;
+
+                isHighlighted = isHandling;
+                highlightOverlay.FadeTo(isHighlighted ? 0.1f : 0, isHighlighted ? 80 : 400, Easing.OutQuint);
+            }
+        }
+
+        public enum TouchCatchAction
+        {
+            MoveLeft,
+            MoveRight,
+            DashLeft,
+            DashRight,
+        }
+    }
+}
--- a/osu.Game.Rulesets.Catch/UI/Catcher.cs
+++ b/osu.Game.Rulesets.Catch/UI/Catcher.cs
@ -271,8 +271,8 @@ namespace osu.Game.Rulesets.Catch.UI
                    SetHyperDashState();
            }

-            caughtObjectContainer.RemoveAll(d => d.HitObject == drawableObject.HitObject);
-            droppedObjectTarget.RemoveAll(d => d.HitObject == drawableObject.HitObject);
+            caughtObjectContainer.RemoveAll(d => d.HitObject == drawableObject.HitObject, false);
+            droppedObjectTarget.RemoveAll(d => d.HitObject == drawableObject.HitObject, false);
        }

        /// <summary>
@ -430,7 +430,7 @@ namespace osu.Game.Rulesets.Catch.UI
        {
            var droppedObject = getDroppedObject(caughtObject);

-            caughtObjectContainer.Remove(caughtObject);
+            caughtObjectContainer.Remove(caughtObject, false);

            droppedObjectTarget.Add(droppedObject);

--- a/osu.Game.Rulesets.Catch/UI/CatcherTrailDisplay.cs
+++ b/osu.Game.Rulesets.Catch/UI/CatcherTrailDisplay.cs
@ -93,15 +93,15 @@ namespace osu.Game.Rulesets.Catch.UI
            switch (entry.Animation)
            {
                case CatcherTrailAnimation.Dashing:
-                    dashTrails.Remove(drawable);
+                    dashTrails.Remove(drawable, false);
                    break;

                case CatcherTrailAnimation.HyperDashing:
-                    hyperDashTrails.Remove(drawable);
+                    hyperDashTrails.Remove(drawable, false);
                    break;

                case CatcherTrailAnimation.HyperDashAfterImage:
-                    hyperDashAfterImages.Remove(drawable);
+                    hyperDashAfterImages.Remove(drawable, false);
                    break;
            }
        }
--- a/osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.cs
+++ b/osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.cs
@ -4,6 +4,7 @@
 #nullable disable

 using System.Collections.Generic;
+using osu.Framework.Allocation;
 using osu.Framework.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
@ -32,6 +33,12 @@ namespace osu.Game.Rulesets.Catch.UI
            TimeRange.Value = IBeatmapDifficultyInfo.DifficultyRange(beatmap.Difficulty.ApproachRate, 1800, 1200, 450);
        }

+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            KeyBindingInputManager.Add(new CatchTouchInputMapper());
+        }
+
        protected override ReplayInputHandler CreateReplayInputHandler(Replay replay) => new CatchFramedReplayInputHandler(replay);

        protected override ReplayRecorder CreateReplayRecorder(Score score) => new CatchReplayRecorder(score, (CatchPlayfield)Playfield);
--- a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaComposeScreen.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaComposeScreen.cs
@ -10,6 +10,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Database;
 using osu.Game.Overlays;
 using osu.Game.Rulesets.Edit;
@ -34,10 +35,14 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
        {
            AddStep("setup compose screen", () =>
            {
-                var editorBeatmap = new EditorBeatmap(new ManiaBeatmap(new StageDefinition { Columns = 4 })
+                var beatmap = new ManiaBeatmap(new StageDefinition { Columns = 4 })
                {
                    BeatmapInfo = { Ruleset = new ManiaRuleset().RulesetInfo },
-                });
+                };
+
+                beatmap.ControlPointInfo.Add(0, new TimingControlPoint());
+
+                var editorBeatmap = new EditorBeatmap(beatmap, new LegacyBeatmapSkin(beatmap.BeatmapInfo, null));

                Beatmap.Value = CreateWorkingBeatmap(editorBeatmap.PlayableBeatmap);

@ -50,7 +55,11 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
                        (typeof(IBeatSnapProvider), editorBeatmap),
                        (typeof(OverlayColourProvider), new OverlayColourProvider(OverlayColourScheme.Green)),
                    },
-                    Child = new ComposeScreen { State = { Value = Visibility.Visible } },
+                    Children = new Drawable[]
+                    {
+                        editorBeatmap,
+                        new ComposeScreen { State = { Value = Visibility.Visible } },
+                    }
                };
            });

--- a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaHitObjectComposer.cs
@ -35,7 +35,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
        public void Setup() => Schedule(() =>
        {
            BeatDivisor.Value = 8;
-            Clock.Seek(0);
+            EditorClock.Seek(0);

            Child = composer = new TestComposer { RelativeSizeAxes = Axes.Both };
        });
@ -53,7 +53,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
            {
                lastObject = this.ChildrenOfType<DrawableHitObject>().Single(d => d.HitObject == composer.EditorBeatmap.HitObjects.Last());
                originalTime = lastObject.HitObject.StartTime;
-                Clock.Seek(composer.EditorBeatmap.HitObjects.Last().StartTime);
+                EditorClock.Seek(composer.EditorBeatmap.HitObjects.Last().StartTime);
            });

            AddStep("select all objects", () => composer.EditorBeatmap.SelectedHitObjects.AddRange(composer.EditorBeatmap.HitObjects));
@ -90,7 +90,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
            {
                lastObject = this.ChildrenOfType<DrawableHitObject>().Single(d => d.HitObject == composer.EditorBeatmap.HitObjects.Last());
                originalTime = lastObject.HitObject.StartTime;
-                Clock.Seek(composer.EditorBeatmap.HitObjects.Last().StartTime);
+                EditorClock.Seek(composer.EditorBeatmap.HitObjects.Last().StartTime);
            });

            AddStep("select all objects", () => composer.EditorBeatmap.SelectedHitObjects.AddRange(composer.EditorBeatmap.HitObjects));
@ -125,7 +125,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
            AddStep("seek to last object", () =>
            {
                lastObject = this.ChildrenOfType<DrawableHitObject>().Single(d => d.HitObject == composer.EditorBeatmap.HitObjects.Last());
-                Clock.Seek(composer.EditorBeatmap.HitObjects.Last().StartTime);
+                EditorClock.Seek(composer.EditorBeatmap.HitObjects.Last().StartTime);
            });

            AddStep("select all objects", () => composer.EditorBeatmap.SelectedHitObjects.AddRange(composer.EditorBeatmap.HitObjects));
--- a/osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs
+++ b/osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs
@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

-#nullable disable
-
 using System;
 using osu.Framework.Configuration.Tracking;
 using osu.Game.Configuration;
@ -13,7 +11,7 @@ namespace osu.Game.Rulesets.Mania.Configuration
 {
    public class ManiaRulesetConfigManager : RulesetConfigManager<ManiaRulesetSetting>
    {
-        public ManiaRulesetConfigManager(SettingsStore settings, RulesetInfo ruleset, int? variant = null)
+        public ManiaRulesetConfigManager(SettingsStore? settings, RulesetInfo ruleset, int? variant = null)
            : base(settings, ruleset, variant)
        {
        }
@ -33,7 +31,7 @@ namespace osu.Game.Rulesets.Mania.Configuration
                scrollTime => new SettingDescription(
                    rawValue: scrollTime,
                    name: "Scroll Speed",
-                    value: $"{(int)Math.Round(DrawableManiaRuleset.MAX_TIME_RANGE / scrollTime)} ({scrollTime}ms)"
+                    value: $"{scrollTime}ms (speed {(int)Math.Round(DrawableManiaRuleset.MAX_TIME_RANGE / scrollTime)})"
                )
            )
        };
--- a/osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs
@ -31,7 +31,7 @@ namespace osu.Game.Rulesets.Mania.Difficulty
        private readonly bool isForCurrentRuleset;
        private readonly double originalOverallDifficulty;

-        public override int Version => 20220701;
+        public override int Version => 20220902;

        public ManiaDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
            : base(ruleset, beatmap)
--- a/osu.Game.Rulesets.Mania/ManiaRuleset.cs
+++ b/osu.Game.Rulesets.Mania/ManiaRuleset.cs
@ -1,14 +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.

-#nullable disable
-
 using System;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Mania.Mods;
-using osu.Game.Rulesets.Mania.UI;
-using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.UI;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Extensions.EnumExtensions;
@ -16,11 +9,10 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Localisation;
-using osu.Game.Graphics;
-using osu.Game.Rulesets.Mania.Replays;
-using osu.Game.Rulesets.Replays.Types;
+using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Difficulty;
@ -31,13 +23,19 @@ using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.Difficulty;
 using osu.Game.Rulesets.Mania.Edit;
 using osu.Game.Rulesets.Mania.Edit.Setup;
+using osu.Game.Rulesets.Mania.Mods;
+using osu.Game.Rulesets.Mania.Replays;
 using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mania.Skinning.Legacy;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Skinning;
+using osu.Game.Rulesets.UI;
 using osu.Game.Scoring;
 using osu.Game.Screens.Edit.Setup;
 using osu.Game.Screens.Ranking.Statistics;
+using osu.Game.Skinning;

 namespace osu.Game.Rulesets.Mania
 {
@ -48,7 +46,7 @@ namespace osu.Game.Rulesets.Mania
        /// </summary>
        public const int MAX_STAGE_KEYS = 10;

-        public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod> mods = null) => new DrawableManiaRuleset(this, beatmap, mods);
+        public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod>? mods = null) => new DrawableManiaRuleset(this, beatmap, mods);

        public override ScoreProcessor CreateScoreProcessor() => new ManiaScoreProcessor();

@ -60,6 +58,8 @@ namespace osu.Game.Rulesets.Mania

        public const string SHORT_NAME = "mania";

+        public override string RulesetAPIVersionSupported => CURRENT_RULESET_API_VERSION;
+
        public override HitObjectComposer CreateHitObjectComposer() => new ManiaHitObjectComposer(this);

        public override ISkin CreateLegacySkinProvider(ISkin skin, IBeatmap beatmap) => new ManiaLegacySkinTransformer(skin, beatmap);
@ -283,7 +283,7 @@ namespace osu.Game.Rulesets.Mania

        public override IConvertibleReplayFrame CreateConvertibleReplayFrame() => new ManiaReplayFrame();

-        public override IRulesetConfigManager CreateConfig(SettingsStore settings) => new ManiaRulesetConfigManager(settings, RulesetInfo);
+        public override IRulesetConfigManager CreateConfig(SettingsStore? settings) => new ManiaRulesetConfigManager(settings, RulesetInfo);

        public override RulesetSettingsSubsection CreateSettings() => new ManiaSettingsSubsection(this);

--- a/osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs
+++ b/osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs
@ -1,8 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

-#nullable disable
-
+using System;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Localisation;
@ -34,7 +33,7 @@ namespace osu.Game.Rulesets.Mania
                    LabelText = "Scrolling direction",
                    Current = config.GetBindable<ManiaScrollingDirection>(ManiaRulesetSetting.ScrollDirection)
                },
-                new SettingsSlider<double, TimeSlider>
+                new SettingsSlider<double, ManiaScrollSlider>
                {
                    LabelText = "Scroll speed",
                    Current = config.GetBindable<double>(ManiaRulesetSetting.ScrollTime),
@ -47,5 +46,10 @@ namespace osu.Game.Rulesets.Mania
                }
            };
        }
+
+        private class ManiaScrollSlider : OsuSliderBar<double>
+        {
+            public override LocalisableString TooltipText => $"{Current.Value}ms (speed {(int)Math.Round(DrawableManiaRuleset.MAX_TIME_RANGE / Current.Value)})";
+        }
    }
 }
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModPlayfieldCover.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModPlayfieldCover.cs
@ -31,7 +31,7 @@ namespace osu.Game.Rulesets.Mania.Mods
                HitObjectContainer hoc = column.HitObjectArea.HitObjectContainer;
                Container hocParent = (Container)hoc.Parent;

-                hocParent.Remove(hoc);
+                hocParent.Remove(hoc, false);
                hocParent.Add(new PlayfieldCoveringWrapper(hoc).With(c =>
                {
                    c.RelativeSizeAxes = Axes.Both;
--- a/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyBodyPiece.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyBodyPiece.cs
@ -155,7 +155,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
            else
            {
                lightContainer.FadeOut(120)
-                              .OnComplete(d => Column.TopLevelContainer.Remove(d));
+                              .OnComplete(d => Column.TopLevelContainer.Remove(d, false));
            }
        }

--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneObjectMerging.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneObjectMerging.cs
@ -3,9 +3,11 @@

 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Edit;
 using osu.Game.Rulesets.Osu.Objects;
 using osuTK;
 using osuTK.Input;
@ -14,6 +16,8 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
    public class TestSceneObjectMerging : TestSceneOsuEditor
    {
+        private OsuSelectionHandler selectionHandler => Editor.ChildrenOfType<OsuSelectionHandler>().First();
+
        [Test]
        public void TestSimpleMerge()
        {
@ -29,6 +33,9 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                EditorBeatmap.SelectedHitObjects.Add(circle2);
            });

+            moveMouseToHitObject(1);
+            AddAssert("merge option available", () => selectionHandler.ContextMenuItems.Any(o => o.Text.Value == "Merge selection"));
+
            mergeSelection();

            AddAssert("slider created", () => circle1 is not null && circle2 is not null && sliderCreatedFor(
@ -174,6 +181,57 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
            AddAssert("spinner not merged", () => EditorBeatmap.HitObjects.Contains(spinner));
        }

+        [Test]
+        public void TestIllegalMerge()
+        {
+            HitCircle? circle1 = null;
+            HitCircle? circle2 = null;
+
+            AddStep("add two circles on the same position", () =>
+            {
+                circle1 = new HitCircle();
+                circle2 = new HitCircle { Position = circle1.Position + Vector2.UnitX };
+                EditorClock.Seek(0);
+                EditorBeatmap.Add(circle1);
+                EditorBeatmap.Add(circle2);
+                EditorBeatmap.SelectedHitObjects.Add(circle1);
+                EditorBeatmap.SelectedHitObjects.Add(circle2);
+            });
+
+            moveMouseToHitObject(1);
+            AddAssert("merge option not available", () => selectionHandler.ContextMenuItems.Length > 0 && selectionHandler.ContextMenuItems.All(o => o.Text.Value != "Merge selection"));
+            mergeSelection();
+            AddAssert("circles not merged", () => circle1 is not null && circle2 is not null
+                                                                      && EditorBeatmap.HitObjects.Contains(circle1) && EditorBeatmap.HitObjects.Contains(circle2));
+        }
+
+        [Test]
+        public void TestSameStartTimeMerge()
+        {
+            HitCircle? circle1 = null;
+            HitCircle? circle2 = null;
+
+            AddStep("add two circles at the same time", () =>
+            {
+                circle1 = new HitCircle();
+                circle2 = new HitCircle { Position = circle1.Position + 100 * Vector2.UnitX };
+                EditorClock.Seek(0);
+                EditorBeatmap.Add(circle1);
+                EditorBeatmap.Add(circle2);
+                EditorBeatmap.SelectedHitObjects.Add(circle1);
+                EditorBeatmap.SelectedHitObjects.Add(circle2);
+            });
+
+            moveMouseToHitObject(1);
+            AddAssert("merge option available", () => selectionHandler.ContextMenuItems.Any(o => o.Text.Value == "Merge selection"));
+
+            mergeSelection();
+
+            AddAssert("slider created", () => circle1 is not null && circle2 is not null && sliderCreatedFor(
+                (pos: circle1.Position, pathType: PathType.Linear),
+                (pos: circle2.Position, pathType: null)));
+        }
+
        private void mergeSelection()
        {
            AddStep("merge selection", () =>
@ -225,5 +283,17 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor

            return mergedSlider.Samples[0] is not null;
        }
+
+        private void moveMouseToHitObject(int index)
+        {
+            AddStep($"hover mouse over hit object {index}", () =>
+            {
+                if (EditorBeatmap.HitObjects.Count <= index)
+                    return;
+
+                Vector2 position = ((OsuHitObject)EditorBeatmap.HitObjects[index]).Position;
+                InputManager.MoveMouseTo(selectionHandler.ToScreenSpace(position));
+            });
+        }
    }
 }
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuDistanceSnapGrid.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuDistanceSnapGrid.cs
@ -59,10 +59,9 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                }
            });

-            editorClock = new EditorClock(editorBeatmap);
-
            base.Content.Children = new Drawable[]
            {
+                editorClock = new EditorClock(editorBeatmap),
                snapProvider,
                Content
            };
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneFollowPoints.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneFollowPoints.cs
@ -195,7 +195,7 @@ namespace osu.Game.Rulesets.Osu.Tests
            {
                var drawableObject = getFunc.Invoke();

-                hitObjectContainer.Remove(drawableObject);
+                hitObjectContainer.Remove(drawableObject, false);
                followPointRenderer.RemoveFollowPoints(drawableObject.HitObject);
            });
        }
@ -212,7 +212,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                else
                    targetTime = getObject(hitObjectContainer.Count - 1).HitObject.StartTime + 1;

-                hitObjectContainer.Remove(toReorder);
+                hitObjectContainer.Remove(toReorder, false);
                toReorder.HitObject.StartTime = targetTime;
                hitObjectContainer.Add(toReorder);
            });
--- a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/FlashlightEvaluator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/FlashlightEvaluator.cs
@ -18,11 +18,14 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
        private const double min_velocity = 0.5;
        private const double slider_multiplier = 1.3;

+        private const double min_angle_multiplier = 0.2;
+
        /// <summary>
        /// Evaluates the difficulty of memorising and hitting an object, based on:
        /// <list type="bullet">
        /// <item><description>distance between a number of previous objects and the current object,</description></item>
        /// <item><description>the visual opacity of the current object,</description></item>
+        /// <item><description>the angle made by the current object,</description></item>
        /// <item><description>length and speed of the current object (for sliders),</description></item>
        /// <item><description>and whether the hidden mod is enabled.</description></item>
        /// </list>
@ -43,6 +46,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators

            OsuDifficultyHitObject lastObj = osuCurrent;

+            double angleRepeatCount = 0.0;
+
            // This is iterating backwards in time from the current object.
            for (int i = 0; i < Math.Min(current.Index, 10); i++)
            {
@ -66,6 +71,13 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
                    double opacityBonus = 1.0 + max_opacity_bonus * (1.0 - osuCurrent.OpacityAt(currentHitObject.StartTime, hidden));

                    result += stackNerf * opacityBonus * scalingFactor * jumpDistance / cumulativeStrainTime;
+
+                    if (currentObj.Angle != null && osuCurrent.Angle != null)
+                    {
+                        // Objects further back in time should count less for the nerf.
+                        if (Math.Abs(currentObj.Angle.Value - osuCurrent.Angle.Value) < 0.02)
+                            angleRepeatCount += Math.Max(1.0 - 0.1 * i, 0.0);
+                    }
                }

                lastObj = currentObj;
@ -77,6 +89,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
            if (hidden)
                result *= 1.0 + hidden_bonus;

+            // Nerf patterns with repeated angles.
+            result *= min_angle_multiplier + (1.0 - min_angle_multiplier) / (angleRepeatCount + 1.0);
+
            double sliderBonus = 0.0;

            if (osuCurrent.BaseObject is Slider osuSlider)
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
@ -25,7 +25,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
        private const double difficulty_multiplier = 0.0675;
        private double hitWindowGreat;

-        public override int Version => 20220701;
+        public override int Version => 20220902;

        public OsuDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
            : base(ruleset, beatmap)
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/Flashlight.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/Flashlight.cs
@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
            hasHiddenMod = mods.Any(m => m is OsuModHidden);
        }

-        private double skillMultiplier => 0.05;
+        private double skillMultiplier => 0.052;
        private double strainDecayBase => 0.15;

        private double currentStrain;
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs
@ -64,7 +64,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
            if (maxStrain == 0)
                return 0;

-            return objectStrains.Aggregate((total, next) => total + (1.0 / (1.0 + Math.Exp(-(next / maxStrain * 12.0 - 6.0)))));
+            return objectStrains.Sum(strain => 1.0 / (1.0 + Math.Exp(-(strain / maxStrain * 12.0 - 6.0))));
        }
    }
 }
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointPiece.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointPiece.cs
@ -6,6 +6,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
@ -53,6 +54,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
        private IBindable<Vector2> sliderPosition;
        private IBindable<float> sliderScale;

+        [UsedImplicitly]
+        private readonly IBindable<int> sliderVersion;
+
        public PathControlPointPiece(Slider slider, PathControlPoint controlPoint)
        {
            this.slider = slider;
@ -61,7 +65,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
            // we don't want to run the path type update on construction as it may inadvertently change the slider.
            cachePoints(slider);

-            slider.Path.Version.BindValueChanged(_ =>
+            sliderVersion = slider.Path.Version.GetBoundCopy();
+            sliderVersion.BindValueChanged(_ =>
            {
                cachePoints(slider);
                updatePathType();
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs
@ -89,6 +89,10 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders

                    HitObject.DifficultyControlPoint = nearestDifficultyPoint ?? new DifficultyControlPoint();
                    HitObject.Position = ToLocalSpace(result.ScreenSpacePosition);
+
+                    // Replacing the DifficultyControlPoint above doesn't trigger any kind of invalidation.
+                    // Without re-applying defaults, velocity won't be updated.
+                    ApplyDefaultsToHitObject();
                    break;

                case SliderPlacementState.Body:
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
@ -358,10 +358,10 @@ namespace osu.Game.Rulesets.Osu.Edit
        {
            var mergeableObjects = selectedMergeableObjects;

-            if (mergeableObjects.Length < 2)
+            if (!canMerge(mergeableObjects))
                return;

-            ChangeHandler?.BeginChange();
+            EditorBeatmap.BeginChange();

            // Have an initial slider object.
            var firstHitObject = mergeableObjects[0];
@ -437,7 +437,7 @@ namespace osu.Game.Rulesets.Osu.Edit
            SelectedItems.Clear();
            SelectedItems.Add(mergedHitObject);

-            ChangeHandler?.EndChange();
+            EditorBeatmap.EndChange();
        }

        protected override IEnumerable<MenuItem> GetContextMenuItemsForSelection(IEnumerable<SelectionBlueprint<HitObject>> selection)
@ -445,8 +445,13 @@ namespace osu.Game.Rulesets.Osu.Edit
            foreach (var item in base.GetContextMenuItemsForSelection(selection))
                yield return item;

-            if (selectedMergeableObjects.Length > 1)
+            if (canMerge(selectedMergeableObjects))
                yield return new OsuMenuItem("Merge selection", MenuItemType.Destructive, mergeSelection);
        }
+
+        private bool canMerge(IReadOnlyList<OsuHitObject> objects) =>
+            objects.Count > 1
+            && (objects.Any(h => h is Slider)
+                || objects.Zip(objects.Skip(1), (h1, h2) => Precision.DefinitelyBigger(Vector2.DistanceSquared(h1.Position, h2.Position), 1)).Any(x => x));
    }
 }
--- a/osu.Game.Rulesets.Osu/Mods/OsuModRandom.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModRandom.cs
@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.

 using System;
+using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Localisation;
 using osu.Framework.Utils;
@ -9,6 +10,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Osu.Utils;

@ -25,40 +27,100 @@ namespace osu.Game.Rulesets.Osu.Mods

        private static readonly float playfield_diagonal = OsuPlayfield.BASE_SIZE.LengthFast;

-        private Random? rng;
+        private Random random = null!;

        public void ApplyToBeatmap(IBeatmap beatmap)
        {
-            if (!(beatmap is OsuBeatmap osuBeatmap))
+            if (beatmap is not OsuBeatmap osuBeatmap)
                return;

            Seed.Value ??= RNG.Next();

-            rng = new Random((int)Seed.Value);
+            random = new Random((int)Seed.Value);

            var positionInfos = OsuHitObjectGenerationUtils.GeneratePositionInfos(osuBeatmap.HitObjects);

-            float rateOfChangeMultiplier = 0;
+            // Offsets the angles of all hit objects in a "section" by the same amount.
+            float sectionOffset = 0;

-            foreach (var positionInfo in positionInfos)
+            // Whether the angles are positive or negative (clockwise or counter-clockwise flow).
+            bool flowDirection = false;
+
+            for (int i = 0; i < positionInfos.Count; i++)
            {
-                // rateOfChangeMultiplier only changes every 5 iterations in a combo
-                // to prevent shaky-line-shaped streams
-                if (positionInfo.HitObject.IndexInCurrentCombo % 5 == 0)
-                    rateOfChangeMultiplier = (float)rng.NextDouble() * 2 - 1;
-
-                if (positionInfo == positionInfos.First())
+                if (shouldStartNewSection(osuBeatmap, positionInfos, i))
                {
-                    positionInfo.DistanceFromPrevious = (float)(rng.NextDouble() * OsuPlayfield.BASE_SIZE.Y / 2);
-                    positionInfo.RelativeAngle = (float)(rng.NextDouble() * 2 * Math.PI - Math.PI);
+                    sectionOffset = OsuHitObjectGenerationUtils.RandomGaussian(random, 0, 0.0008f);
+                    flowDirection = !flowDirection;
+                }
+
+                if (i == 0)
+                {
+                    positionInfos[i].DistanceFromPrevious = (float)(random.NextDouble() * OsuPlayfield.BASE_SIZE.Y / 2);
+                    positionInfos[i].RelativeAngle = (float)(random.NextDouble() * 2 * Math.PI - Math.PI);
                }
                else
                {
-                    positionInfo.RelativeAngle = rateOfChangeMultiplier * 2 * (float)Math.PI * Math.Min(1f, positionInfo.DistanceFromPrevious / (playfield_diagonal * 0.5f));
+                    // Offsets only the angle of the current hit object if a flow change occurs.
+                    float flowChangeOffset = 0;
+
+                    // Offsets only the angle of the current hit object.
+                    float oneTimeOffset = OsuHitObjectGenerationUtils.RandomGaussian(random, 0, 0.002f);
+
+                    if (shouldApplyFlowChange(positionInfos, i))
+                    {
+                        flowChangeOffset = OsuHitObjectGenerationUtils.RandomGaussian(random, 0, 0.002f);
+                        flowDirection = !flowDirection;
+                    }
+
+                    float totalOffset =
+                        // sectionOffset and oneTimeOffset should mainly affect patterns with large spacing.
+                        (sectionOffset + oneTimeOffset) * positionInfos[i].DistanceFromPrevious +
+                        // flowChangeOffset should mainly affect streams.
+                        flowChangeOffset * (playfield_diagonal - positionInfos[i].DistanceFromPrevious);
+
+                    positionInfos[i].RelativeAngle = getRelativeTargetAngle(positionInfos[i].DistanceFromPrevious, totalOffset, flowDirection);
                }
            }

            osuBeatmap.HitObjects = OsuHitObjectGenerationUtils.RepositionHitObjects(positionInfos);
        }
+
+        /// <param name="targetDistance">The target distance between the previous and the current <see cref="OsuHitObject"/>.</param>
+        /// <param name="offset">The angle (in rad) by which the target angle should be offset.</param>
+        /// <param name="flowDirection">Whether the relative angle should be positive or negative.</param>
+        private static float getRelativeTargetAngle(float targetDistance, float offset, bool flowDirection)
+        {
+            float angle = (float)(2.16 / (1 + 200 * Math.Exp(0.036 * (targetDistance - 310))) + 0.5 + offset);
+            float relativeAngle = (float)Math.PI - angle;
+            return flowDirection ? -relativeAngle : relativeAngle;
+        }
+
+        /// <returns>Whether a new section should be started at the current <see cref="OsuHitObject"/>.</returns>
+        private bool shouldStartNewSection(OsuBeatmap beatmap, IReadOnlyList<OsuHitObjectGenerationUtils.ObjectPositionInfo> positionInfos, int i)
+        {
+            if (i == 0)
+                return true;
+
+            // Exclude new-combo-spam and 1-2-combos.
+            bool previousObjectStartedCombo = positionInfos[Math.Max(0, i - 2)].HitObject.IndexInCurrentCombo > 1 &&
+                                              positionInfos[i - 1].HitObject.NewCombo;
+            bool previousObjectWasOnDownbeat = OsuHitObjectGenerationUtils.IsHitObjectOnBeat(beatmap, positionInfos[i - 1].HitObject, true);
+            bool previousObjectWasOnBeat = OsuHitObjectGenerationUtils.IsHitObjectOnBeat(beatmap, positionInfos[i - 1].HitObject);
+
+            return (previousObjectStartedCombo && random.NextDouble() < 0.6f) ||
+                   previousObjectWasOnDownbeat ||
+                   (previousObjectWasOnBeat && random.NextDouble() < 0.4f);
+        }
+
+        /// <returns>Whether a flow change should be applied at the current <see cref="OsuHitObject"/>.</returns>
+        private bool shouldApplyFlowChange(IReadOnlyList<OsuHitObjectGenerationUtils.ObjectPositionInfo> positionInfos, int i)
+        {
+            // Exclude new-combo-spam and 1-2-combos.
+            bool previousObjectStartedCombo = positionInfos[Math.Max(0, i - 2)].HitObject.IndexInCurrentCombo > 1 &&
+                                              positionInfos[i - 1].HitObject.NewCombo;
+
+            return previousObjectStartedCombo && random.NextDouble() < 0.6f;
+        }
    }
 }
--- a/osu.Game.Rulesets.Osu/Mods/OsuModTarget.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModTarget.cs
@ -59,6 +59,9 @@ namespace osu.Game.Rulesets.Osu.Mods
            Value = null
        };

+        [SettingSource("Metronome ticks", "Whether a metronome beat should play in the background")]
+        public Bindable<bool> Metronome { get; } = new BindableBool(true);
+
        #region Constants

        /// <summary>
@ -337,7 +340,8 @@ namespace osu.Game.Rulesets.Osu.Mods

        public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
        {
-            drawableRuleset.Overlays.Add(new MetronomeBeat(drawableRuleset.Beatmap.HitObjects.First().StartTime));
+            if (Metronome.Value)
+                drawableRuleset.Overlays.Add(new MetronomeBeat(drawableRuleset.Beatmap.HitObjects.First().StartTime));
        }

        #endregion
@ -358,10 +362,12 @@ namespace osu.Game.Rulesets.Osu.Mods
        {
            return breaks.Any(breakPeriod =>
            {
-                var firstObjAfterBreak = originalHitObjects.First(obj => almostBigger(obj.StartTime, breakPeriod.EndTime));
+                OsuHitObject? firstObjAfterBreak = originalHitObjects.FirstOrDefault(obj => almostBigger(obj.StartTime, breakPeriod.EndTime));

                return almostBigger(time, breakPeriod.StartTime)
-                       && definitelyBigger(firstObjAfterBreak.StartTime, time);
+                       // There should never really be a break section with no objects after it, but we've seen crashes from users with malformed beatmaps,
+                       // so it's best to guard against this.
+                       && (firstObjAfterBreak == null || definitelyBigger(firstObjAfterBreak.StartTime, time));
            });
        }

--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs
@ -77,7 +77,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
        // This is a bit ugly but we don't have the concept of InternalContent so it'll have to do for now. (https://github.com/ppy/osu-framework/issues/1690)
        protected override void AddInternal(Drawable drawable) => shakeContainer.Add(drawable);
        protected override void ClearInternal(bool disposeChildren = true) => shakeContainer.Clear(disposeChildren);
-        protected override bool RemoveInternal(Drawable drawable) => shakeContainer.Remove(drawable);
+        protected override bool RemoveInternal(Drawable drawable, bool disposeImmediately) => shakeContainer.Remove(drawable, disposeImmediately);

        protected sealed override double InitialLifetimeOffset => HitObject.TimePreempt;

--- a/osu.Game.Rulesets.Osu/Objects/Slider.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Slider.cs
@ -14,6 +14,7 @@ using osu.Framework.Caching;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Beatmaps.Formats;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
@ -165,11 +166,15 @@ namespace osu.Game.Rulesets.Osu.Objects
            base.ApplyDefaultsToSelf(controlPointInfo, difficulty);

            TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
+#pragma warning disable 618
+            var legacyDifficultyPoint = DifficultyControlPoint as LegacyBeatmapDecoder.LegacyDifficultyControlPoint;
+#pragma warning restore 618

            double scoringDistance = BASE_SCORING_DISTANCE * difficulty.SliderMultiplier * DifficultyControlPoint.SliderVelocity;
+            bool generateTicks = legacyDifficultyPoint?.GenerateTicks ?? true;

            Velocity = scoringDistance / timingPoint.BeatLength;
-            TickDistance = scoringDistance / difficulty.SliderTickRate * TickDistanceMultiplier;
+            TickDistance = generateTicks ? (scoringDistance / difficulty.SliderTickRate * TickDistanceMultiplier) : double.PositiveInfinity;
        }

        protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
--- a/osu.Game.Rulesets.Osu/OsuRuleset.cs
+++ b/osu.Game.Rulesets.Osu/OsuRuleset.cs
@ -1,50 +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.

-#nullable disable
-
-using osu.Game.Beatmaps;
-using osu.Game.Graphics;
-using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Rulesets.Osu.UI;
-using osu.Game.Rulesets.UI;
+using System;
 using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
-using osu.Game.Overlays.Settings;
 using osu.Framework.Input.Bindings;
-using osu.Game.Rulesets.Osu.Edit;
-using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Osu.Replays;
-using osu.Game.Rulesets.Replays.Types;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
+using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Configuration;
 using osu.Game.Rulesets.Osu.Difficulty;
-using osu.Game.Rulesets.Osu.Scoring;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Scoring;
-using osu.Game.Skinning;
-using System;
-using System.Linq;
-using osu.Framework.Extensions.EnumExtensions;
-using osu.Framework.Localisation;
+using osu.Game.Rulesets.Osu.Edit;
 using osu.Game.Rulesets.Osu.Edit.Setup;
+using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Osu.Skinning.Legacy;
 using osu.Game.Rulesets.Osu.Statistics;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.Replays.Types;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI;
+using osu.Game.Scoring;
 using osu.Game.Screens.Edit.Setup;
 using osu.Game.Screens.Ranking.Statistics;
+using osu.Game.Skinning;

 namespace osu.Game.Rulesets.Osu
 {
    public class OsuRuleset : Ruleset, ILegacyRuleset
    {
-        public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod> mods = null) => new DrawableOsuRuleset(this, beatmap, mods);
+        public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod>? mods = null) => new DrawableOsuRuleset(this, beatmap, mods);

        public override ScoreProcessor CreateScoreProcessor() => new OsuScoreProcessor();

@ -54,6 +52,8 @@ namespace osu.Game.Rulesets.Osu

        public const string SHORT_NAME = "osu";

+        public override string RulesetAPIVersionSupported => CURRENT_RULESET_API_VERSION;
+
        public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0) => new[]
        {
            new KeyBinding(InputKey.Z, OsuAction.LeftButton),
@ -237,7 +237,7 @@ namespace osu.Game.Rulesets.Osu

        public override IConvertibleReplayFrame CreateConvertibleReplayFrame() => new OsuReplayFrame();

-        public override IRulesetConfigManager CreateConfig(SettingsStore settings) => new OsuRulesetConfigManager(settings, RulesetInfo);
+        public override IRulesetConfigManager CreateConfig(SettingsStore? settings) => new OsuRulesetConfigManager(settings, RulesetInfo);

        protected override IEnumerable<HitResult> GetValidHitResults()
        {
--- a/osu.Game.Rulesets.Osu/Skinning/Default/SpinnerRotationTracker.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/Default/SpinnerRotationTracker.cs
@ -110,7 +110,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
            currentRotation += angle;
            // rate has to be applied each frame, because it's not guaranteed to be constant throughout playback
            // (see: ModTimeRamp)
-            drawableSpinner.Result.RateAdjustedRotation += (float)(Math.Abs(angle) * (gameplayClock?.TrueGameplayRate ?? Clock.Rate));
+            drawableSpinner.Result.RateAdjustedRotation += (float)(Math.Abs(angle) * (gameplayClock?.GetTrueGameplayRate() ?? Clock.Rate));
        }

        private void resetState(DrawableHitObject obj)
--- a/osu.Game.Rulesets.Osu/Utils/OsuHitObjectGenerationUtils.cs
+++ b/osu.Game.Rulesets.Osu/Utils/OsuHitObjectGenerationUtils.cs
@ -8,6 +8,7 @@ using System.Linq;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Objects;
 using osuTK;

@ -186,5 +187,39 @@ namespace osu.Game.Rulesets.Osu.Utils
                length * MathF.Sin(angle)
            );
        }
+
+        /// <param name="beatmap">The beatmap hitObject is a part of.</param>
+        /// <param name="hitObject">The <see cref="OsuHitObject"/> that should be checked.</param>
+        /// <param name="downbeatsOnly">If true, this method only returns true if hitObject is on a downbeat.
+        /// If false, it returns true if hitObject is on any beat.</param>
+        /// <returns>true if hitObject is on a (down-)beat, false otherwise.</returns>
+        public static bool IsHitObjectOnBeat(OsuBeatmap beatmap, OsuHitObject hitObject, bool downbeatsOnly = false)
+        {
+            var timingPoint = beatmap.ControlPointInfo.TimingPointAt(hitObject.StartTime);
+
+            double timeSinceTimingPoint = hitObject.StartTime - timingPoint.Time;
+
+            double beatLength = timingPoint.BeatLength;
+
+            if (downbeatsOnly)
+                beatLength *= timingPoint.TimeSignature.Numerator;
+
+            // Ensure within 1ms of expected location.
+            return Math.Abs(timeSinceTimingPoint + 1) % beatLength < 2;
+        }
+
+        /// <summary>
+        /// Generates a random number from a normal distribution using the Box-Muller transform.
+        /// </summary>
+        public static float RandomGaussian(Random rng, float mean = 0, float stdDev = 1)
+        {
+            // Generate 2 random numbers in the interval (0,1].
+            // x1 must not be 0 since log(0) = undefined.
+            double x1 = 1 - rng.NextDouble();
+            double x2 = 1 - rng.NextDouble();
+
+            double stdNormal = Math.Sqrt(-2 * Math.Log(x1)) * Math.Sin(2 * Math.PI * x2);
+            return mean + stdDev * (float)stdNormal;
+        }
    }
 }
--- a/osu.Game.Rulesets.Taiko.Tests/Editor/TestSceneTaikoHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/Editor/TestSceneTaikoHitObjectComposer.cs
@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Taiko.Tests.Editor
        public void Setup() => Schedule(() =>
        {
            BeatDivisor.Value = 8;
-            Clock.Seek(0);
+            EditorClock.Seek(0);

            Child = new TestComposer { RelativeSizeAxes = Axes.Both };
        });
--- a/osu.Game.Rulesets.Taiko.Tests/Judgements/JudgementTest.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/Judgements/JudgementTest.cs
@ -0,0 +1,96 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Extensions.TypeExtensions;
+using osu.Framework.Screens;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Scoring;
+using osu.Game.Screens.Play;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Judgements
+{
+    public class JudgementTest : RateAdjustedBeatmapTestScene
+    {
+        private ScoreAccessibleReplayPlayer currentPlayer = null!;
+        protected List<JudgementResult> JudgementResults { get; private set; } = null!;
+
+        protected void AssertJudgementCount(int count)
+        {
+            AddAssert($"{count} judgement{(count > 0 ? "s" : "")}", () => JudgementResults, () => Has.Count.EqualTo(count));
+        }
+
+        protected void AssertResult<T>(int index, HitResult expectedResult)
+        {
+            AddAssert($"{typeof(T).ReadableName()} ({index}) judged as {expectedResult}",
+                () => JudgementResults.Where(j => j.HitObject is T).OrderBy(j => j.HitObject.StartTime).ElementAt(index).Type,
+                () => Is.EqualTo(expectedResult));
+        }
+
+        protected void PerformTest(List<ReplayFrame> frames, Beatmap<TaikoHitObject>? beatmap = null)
+        {
+            AddStep("load player", () =>
+            {
+                Beatmap.Value = CreateWorkingBeatmap(beatmap);
+
+                var p = new ScoreAccessibleReplayPlayer(new Score { Replay = new Replay { Frames = frames } });
+
+                p.OnLoadComplete += _ =>
+                {
+                    p.ScoreProcessor.NewJudgement += result =>
+                    {
+                        if (currentPlayer == p) JudgementResults.Add(result);
+                    };
+                };
+
+                LoadScreen(currentPlayer = p);
+                JudgementResults = new List<JudgementResult>();
+            });
+
+            AddUntilStep("Beatmap at 0", () => Beatmap.Value.Track.CurrentTime == 0);
+            AddUntilStep("Wait until player is loaded", () => currentPlayer.IsCurrentScreen());
+            AddUntilStep("Wait for completion", () => currentPlayer.ScoreProcessor.HasCompleted.Value);
+        }
+
+        protected Beatmap<TaikoHitObject> CreateBeatmap(params TaikoHitObject[] hitObjects)
+        {
+            var beatmap = new Beatmap<TaikoHitObject>
+            {
+                HitObjects = hitObjects.ToList(),
+                BeatmapInfo =
+                {
+                    Difficulty = new BeatmapDifficulty { SliderTickRate = 4 },
+                    Ruleset = new TaikoRuleset().RulesetInfo
+                },
+            };
+
+            beatmap.ControlPointInfo.Add(0, new EffectControlPoint { ScrollSpeed = 0.1f });
+            return beatmap;
+        }
+
+        private class ScoreAccessibleReplayPlayer : ReplayPlayer
+        {
+            public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
+
+            protected override bool PauseOnFocusLost => false;
+
+            public ScoreAccessibleReplayPlayer(Score score)
+                : base(score, new PlayerConfiguration
+                {
+                    AllowPause = false,
+                    ShowResults = false,
+                })
+            {
+            }
+        }
+    }
+}
--- a/osu.Game.Rulesets.Taiko.Tests/Judgements/TestSceneDrumRollJudgements.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/Judgements/TestSceneDrumRollJudgements.cs
@ -0,0 +1,201 @@
+// 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.Rulesets.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Replays;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Judgements
+{
+    public class TestSceneDrumRollJudgements : JudgementTest
+    {
+        [Test]
+        public void TestHitAllDrumRoll()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(1000, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1001),
+                new TaikoReplayFrame(2000, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(2001),
+            }, CreateBeatmap(new DrumRoll
+            {
+                StartTime = hit_time,
+                Duration = 1000
+            }));
+
+            AssertJudgementCount(3);
+            AssertResult<DrumRollTick>(0, HitResult.SmallBonus);
+            AssertResult<DrumRollTick>(1, HitResult.SmallBonus);
+            AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
+        }
+
+        [Test]
+        public void TestHitSomeDrumRoll()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(2000, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(2001),
+            }, CreateBeatmap(new DrumRoll
+            {
+                StartTime = hit_time,
+                Duration = 1000
+            }));
+
+            AssertJudgementCount(3);
+            AssertResult<DrumRollTick>(0, HitResult.IgnoreMiss);
+            AssertResult<DrumRollTick>(1, HitResult.SmallBonus);
+            AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
+        }
+
+        [Test]
+        public void TestHitNoneDrumRoll()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+            }, CreateBeatmap(new DrumRoll
+            {
+                StartTime = hit_time,
+                Duration = 1000
+            }));
+
+            AssertJudgementCount(3);
+            AssertResult<DrumRollTick>(0, HitResult.IgnoreMiss);
+            AssertResult<DrumRollTick>(1, HitResult.IgnoreMiss);
+            AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
+        }
+
+        [Test]
+        public void TestHitAllStrongDrumRollWithOneKey()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(1000, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1001),
+                new TaikoReplayFrame(2000, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(2001),
+            }, CreateBeatmap(new DrumRoll
+            {
+                StartTime = hit_time,
+                Duration = 1000,
+                IsStrong = true
+            }));
+
+            AssertJudgementCount(6);
+
+            AssertResult<DrumRollTick>(0, HitResult.SmallBonus);
+            AssertResult<StrongNestedHitObject>(0, HitResult.LargeBonus);
+
+            AssertResult<DrumRollTick>(1, HitResult.SmallBonus);
+            AssertResult<StrongNestedHitObject>(1, HitResult.LargeBonus);
+
+            AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
+            AssertResult<StrongNestedHitObject>(2, HitResult.IgnoreHit);
+        }
+
+        [Test]
+        public void TestHitSomeStrongDrumRollWithOneKey()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(2000, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(2001),
+            }, CreateBeatmap(new DrumRoll
+            {
+                StartTime = hit_time,
+                Duration = 1000,
+                IsStrong = true
+            }));
+
+            AssertJudgementCount(6);
+
+            AssertResult<DrumRollTick>(0, HitResult.IgnoreMiss);
+            AssertResult<StrongNestedHitObject>(0, HitResult.IgnoreMiss);
+
+            AssertResult<DrumRollTick>(1, HitResult.SmallBonus);
+            AssertResult<StrongNestedHitObject>(1, HitResult.LargeBonus);
+
+            AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
+            AssertResult<StrongNestedHitObject>(2, HitResult.IgnoreHit);
+        }
+
+        [Test]
+        public void TestHitAllStrongDrumRollWithBothKeys()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(1000, TaikoAction.LeftCentre, TaikoAction.RightCentre),
+                new TaikoReplayFrame(1001),
+                new TaikoReplayFrame(2000, TaikoAction.LeftCentre, TaikoAction.RightCentre),
+                new TaikoReplayFrame(2001),
+            }, CreateBeatmap(new DrumRoll
+            {
+                StartTime = hit_time,
+                Duration = 1000,
+                IsStrong = true
+            }));
+
+            AssertJudgementCount(6);
+
+            AssertResult<DrumRollTick>(0, HitResult.SmallBonus);
+            AssertResult<StrongNestedHitObject>(0, HitResult.LargeBonus);
+
+            AssertResult<DrumRollTick>(1, HitResult.SmallBonus);
+            AssertResult<StrongNestedHitObject>(1, HitResult.LargeBonus);
+
+            AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
+            AssertResult<StrongNestedHitObject>(2, HitResult.IgnoreHit);
+        }
+
+        [Test]
+        public void TestHitSomeStrongDrumRollWithBothKeys()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(2000, TaikoAction.LeftCentre, TaikoAction.RightCentre),
+                new TaikoReplayFrame(2001),
+            }, CreateBeatmap(new DrumRoll
+            {
+                StartTime = hit_time,
+                Duration = 1000,
+                IsStrong = true
+            }));
+
+            AssertJudgementCount(6);
+
+            AssertResult<DrumRollTick>(0, HitResult.IgnoreMiss);
+            AssertResult<StrongNestedHitObject>(0, HitResult.IgnoreMiss);
+
+            AssertResult<DrumRollTick>(1, HitResult.SmallBonus);
+            AssertResult<StrongNestedHitObject>(1, HitResult.LargeBonus);
+
+            AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
+            AssertResult<StrongNestedHitObject>(2, HitResult.IgnoreHit);
+        }
+    }
+}
--- a/osu.Game.Rulesets.Taiko.Tests/Judgements/TestSceneHitJudgements.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/Judgements/TestSceneHitJudgements.cs
@ -0,0 +1,133 @@
+// 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.Rulesets.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Replays;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Judgements
+{
+    public class TestSceneHitJudgements : JudgementTest
+    {
+        [Test]
+        public void TestHitCentreHit()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(hit_time, TaikoAction.LeftCentre),
+            }, CreateBeatmap(new Hit
+            {
+                Type = HitType.Centre,
+                StartTime = hit_time
+            }));
+
+            AssertJudgementCount(1);
+            AssertResult<Hit>(0, HitResult.Great);
+        }
+
+        [Test]
+        public void TestHitRimHit()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(hit_time, TaikoAction.LeftRim),
+            }, CreateBeatmap(new Hit
+            {
+                Type = HitType.Rim,
+                StartTime = hit_time
+            }));
+
+            AssertJudgementCount(1);
+            AssertResult<Hit>(0, HitResult.Great);
+        }
+
+        [Test]
+        public void TestMissHit()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0)
+            }, CreateBeatmap(new Hit
+            {
+                Type = HitType.Centre,
+                StartTime = hit_time
+            }));
+
+            AssertJudgementCount(1);
+            AssertResult<Hit>(0, HitResult.Miss);
+        }
+
+        [Test]
+        public void TestHitStrongHitWithOneKey()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(hit_time, TaikoAction.LeftCentre),
+            }, CreateBeatmap(new Hit
+            {
+                Type = HitType.Centre,
+                StartTime = hit_time,
+                IsStrong = true
+            }));
+
+            AssertJudgementCount(2);
+            AssertResult<Hit>(0, HitResult.Great);
+            AssertResult<StrongNestedHitObject>(0, HitResult.IgnoreMiss);
+        }
+
+        [Test]
+        public void TestHitStrongHitWithBothKeys()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(hit_time, TaikoAction.LeftCentre, TaikoAction.RightCentre),
+            }, CreateBeatmap(new Hit
+            {
+                Type = HitType.Centre,
+                StartTime = hit_time,
+                IsStrong = true
+            }));
+
+            AssertJudgementCount(2);
+            AssertResult<Hit>(0, HitResult.Great);
+            AssertResult<StrongNestedHitObject>(0, HitResult.LargeBonus);
+        }
+
+        [Test]
+        public void TestMissStrongHit()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+            }, CreateBeatmap(new Hit
+            {
+                Type = HitType.Centre,
+                StartTime = hit_time,
+                IsStrong = true
+            }));
+
+            AssertJudgementCount(2);
+            AssertResult<Hit>(0, HitResult.Miss);
+            AssertResult<StrongNestedHitObject>(0, HitResult.IgnoreMiss);
+        }
+    }
+}
--- a/osu.Game.Rulesets.Taiko.Tests/Judgements/TestSceneSwellJudgements.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/Judgements/TestSceneSwellJudgements.cs
@ -0,0 +1,118 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Replays;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Judgements
+{
+    public class TestSceneSwellJudgements : JudgementTest
+    {
+        [Test]
+        public void TestHitAllSwell()
+        {
+            const double hit_time = 1000;
+
+            Swell swell = new Swell
+            {
+                StartTime = hit_time,
+                Duration = 1000,
+                RequiredHits = 10
+            };
+
+            List<ReplayFrame> frames = new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(2001),
+            };
+
+            for (int i = 0; i < swell.RequiredHits; i++)
+            {
+                double frameTime = 1000 + i * 50;
+                frames.Add(new TaikoReplayFrame(frameTime, i % 2 == 0 ? TaikoAction.LeftCentre : TaikoAction.LeftRim));
+                frames.Add(new TaikoReplayFrame(frameTime + 10));
+            }
+
+            PerformTest(frames, CreateBeatmap(swell));
+
+            AssertJudgementCount(11);
+
+            for (int i = 0; i < swell.RequiredHits; i++)
+                AssertResult<SwellTick>(i, HitResult.IgnoreHit);
+
+            AssertResult<Swell>(0, HitResult.LargeBonus);
+        }
+
+        [Test]
+        public void TestHitSomeSwell()
+        {
+            const double hit_time = 1000;
+
+            Swell swell = new Swell
+            {
+                StartTime = hit_time,
+                Duration = 1000,
+                RequiredHits = 10
+            };
+
+            List<ReplayFrame> frames = new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(2001),
+            };
+
+            for (int i = 0; i < swell.RequiredHits / 2; i++)
+            {
+                double frameTime = 1000 + i * 50;
+                frames.Add(new TaikoReplayFrame(frameTime, i % 2 == 0 ? TaikoAction.LeftCentre : TaikoAction.LeftRim));
+                frames.Add(new TaikoReplayFrame(frameTime + 10));
+            }
+
+            PerformTest(frames, CreateBeatmap(swell));
+
+            AssertJudgementCount(11);
+
+            for (int i = 0; i < swell.RequiredHits / 2; i++)
+                AssertResult<SwellTick>(i, HitResult.IgnoreHit);
+            for (int i = swell.RequiredHits / 2; i < swell.RequiredHits; i++)
+                AssertResult<SwellTick>(i, HitResult.IgnoreMiss);
+
+            AssertResult<Swell>(0, HitResult.IgnoreMiss);
+        }
+
+        [Test]
+        public void TestHitNoneSwell()
+        {
+            const double hit_time = 1000;
+
+            Swell swell = new Swell
+            {
+                StartTime = hit_time,
+                Duration = 1000,
+                RequiredHits = 10
+            };
+
+            List<ReplayFrame> frames = new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(2001),
+            };
+
+            PerformTest(frames, CreateBeatmap(swell));
+
+            AssertJudgementCount(11);
+
+            for (int i = 0; i < swell.RequiredHits; i++)
+                AssertResult<SwellTick>(i, HitResult.IgnoreMiss);
+
+            AssertResult<Swell>(0, HitResult.IgnoreMiss);
+
+            AddAssert("all tick offsets are 0", () => JudgementResults.Where(r => r.HitObject is SwellTick).All(r => r.TimeOffset == 0));
+        }
+    }
+}
--- a/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModPerfect.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModPerfect.cs
@ -25,11 +25,11 @@ namespace osu.Game.Rulesets.Taiko.Tests.Mods

        [TestCase(false)]
        [TestCase(true)]
-        public void TestDrumRoll(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new DrumRoll { StartTime = 1000, EndTime = 3000 }), shouldMiss);
+        public void TestDrumRoll(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new DrumRoll { StartTime = 1000, EndTime = 3000 }, false), shouldMiss);

        [TestCase(false)]
        [TestCase(true)]
-        public void TestSwell(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new Swell { StartTime = 1000, EndTime = 3000 }), shouldMiss);
+        public void TestSwell(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new Swell { StartTime = 1000, EndTime = 3000 }, false), shouldMiss);

        private class TestTaikoRuleset : TaikoRuleset
        {
--- a/osu.Game.Rulesets.Taiko.Tests/Skinning/TestSceneDrawableTaikoMascot.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/Skinning/TestSceneDrawableTaikoMascot.cs
@ -112,7 +112,6 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning

            assertStateAfterResult(new JudgementResult(new Hit(), new TaikoJudgement()) { Type = HitResult.Great }, TaikoMascotAnimationState.Idle);
            assertStateAfterResult(new JudgementResult(new Hit(), new TaikoJudgement()) { Type = HitResult.Miss }, TaikoMascotAnimationState.Fail);
-            assertStateAfterResult(new JudgementResult(new DrumRoll(), new TaikoDrumRollJudgement()) { Type = HitResult.Great }, TaikoMascotAnimationState.Idle);
            assertStateAfterResult(new JudgementResult(new Hit(), new TaikoJudgement()) { Type = HitResult.Ok }, TaikoMascotAnimationState.Idle);
        }

--- a/osu.Game.Rulesets.Taiko.Tests/TestSceneDrumRollJudgements.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/TestSceneDrumRollJudgements.cs
@ -1,38 +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.
-
-#nullable disable
-
-using System.Linq;
-using NUnit.Framework;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Taiko.Objects;
-
-namespace osu.Game.Rulesets.Taiko.Tests
-{
-    public class TestSceneDrumRollJudgements : TestSceneTaikoPlayer
-    {
-        [Test]
-        public void TestStrongDrumRollFullyJudgedOnKilled()
-        {
-            AddUntilStep("gameplay finished", () => Player.ScoreProcessor.HasCompleted.Value);
-            AddAssert("all judgements are misses", () => Player.Results.All(r => r.Type == r.Judgement.MinResult));
-        }
-
-        protected override bool Autoplay => false;
-
-        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new Beatmap<TaikoHitObject>
-        {
-            BeatmapInfo = { Ruleset = new TaikoRuleset().RulesetInfo },
-            HitObjects =
-            {
-                new DrumRoll
-                {
-                    StartTime = 1000,
-                    Duration = 1000,
-                    IsStrong = true
-                }
-            }
-        };
-    }
-}
--- a/osu.Game.Rulesets.Taiko.Tests/TestSceneSwellJudgements.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/TestSceneSwellJudgements.cs
@ -1,42 +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.
-
-#nullable disable
-
-using System.Linq;
-using NUnit.Framework;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Taiko.Objects;
-
-namespace osu.Game.Rulesets.Taiko.Tests
-{
-    public class TestSceneSwellJudgements : TestSceneTaikoPlayer
-    {
-        [Test]
-        public void TestZeroTickTimeOffsets()
-        {
-            AddUntilStep("gameplay finished", () => Player.ScoreProcessor.HasCompleted.Value);
-            AddAssert("all tick offsets are 0", () => Player.Results.Where(r => r.HitObject is SwellTick).All(r => r.TimeOffset == 0));
-        }
-
-        protected override bool Autoplay => true;
-
-        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset)
-        {
-            var beatmap = new Beatmap<TaikoHitObject>
-            {
-                BeatmapInfo = { Ruleset = new TaikoRuleset().RulesetInfo },
-                HitObjects =
-                {
-                    new Swell
-                    {
-                        StartTime = 1000,
-                        Duration = 1000,
-                    }
-                }
-            };
-
-            return beatmap;
-        }
-    }
-}
--- a/osu.Game.Rulesets.Taiko.Tests/TestSceneTaikoSuddenDeath.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/TestSceneTaikoSuddenDeath.cs
@ -38,7 +38,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
            };

        [Test]
-        public void TestSpinnerDoesFail()
+        public void TestSwellDoesNotFail()
        {
            bool judged = false;
            AddStep("Setup judgements", () =>
@ -47,7 +47,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
                Player.ScoreProcessor.NewJudgement += _ => judged = true;
            });
            AddUntilStep("swell judged", () => judged);
-            AddAssert("failed", () => Player.GameplayState.HasFailed);
+            AddAssert("not failed", () => !Player.GameplayState.HasFailed);
        }
    }
 }
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs
@ -25,7 +25,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
    {
        private const double difficulty_multiplier = 1.35;

-        public override int Version => 20220701;
+        public override int Version => 20220902;

        public TaikoDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
            : base(ruleset, beatmap)
--- a/osu.Game.Rulesets.Taiko/Judgements/TaikoDrumRollJudgement.cs
+++ b/osu.Game.Rulesets.Taiko/Judgements/TaikoDrumRollJudgement.cs
@ -1,25 +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.
-
-#nullable disable
-
-using osu.Game.Rulesets.Scoring;
-
-namespace osu.Game.Rulesets.Taiko.Judgements
-{
-    public class TaikoDrumRollJudgement : TaikoJudgement
-    {
-        protected override double HealthIncreaseFor(HitResult result)
-        {
-            // Drum rolls can be ignored with no health penalty
-            switch (result)
-            {
-                case HitResult.Miss:
-                    return 0;
-
-                default:
-                    return base.HealthIncreaseFor(result);
-            }
-        }
-    }
-}
--- a/osu.Game.Rulesets.Taiko/Judgements/TaikoDrumRollTickJudgement.cs
+++ b/osu.Game.Rulesets.Taiko/Judgements/TaikoDrumRollTickJudgement.cs
@ -9,18 +9,8 @@ namespace osu.Game.Rulesets.Taiko.Judgements
 {
    public class TaikoDrumRollTickJudgement : TaikoJudgement
    {
-        public override HitResult MaxResult => HitResult.SmallTickHit;
+        public override HitResult MaxResult => HitResult.SmallBonus;

-        protected override double HealthIncreaseFor(HitResult result)
-        {
-            switch (result)
-            {
-                case HitResult.SmallTickHit:
-                    return 0.15;
-
-                default:
-                    return 0;
-            }
-        }
+        protected override double HealthIncreaseFor(HitResult result) => 0;
    }
 }
--- a/osu.Game.Rulesets.Taiko/Judgements/TaikoStrongJudgement.cs
+++ b/osu.Game.Rulesets.Taiko/Judgements/TaikoStrongJudgement.cs
@ -9,7 +9,7 @@ namespace osu.Game.Rulesets.Taiko.Judgements
 {
    public class TaikoStrongJudgement : TaikoJudgement
    {
-        public override HitResult MaxResult => HitResult.SmallBonus;
+        public override HitResult MaxResult => HitResult.LargeBonus;

        // MainObject already changes the HP
        protected override double HealthIncreaseFor(HitResult result) => 0;
--- a/osu.Game.Rulesets.Taiko/Judgements/TaikoSwellJudgement.cs
+++ b/osu.Game.Rulesets.Taiko/Judgements/TaikoSwellJudgement.cs
@ -9,11 +9,13 @@ namespace osu.Game.Rulesets.Taiko.Judgements
 {
    public class TaikoSwellJudgement : TaikoJudgement
    {
+        public override HitResult MaxResult => HitResult.LargeBonus;
+
        protected override double HealthIncreaseFor(HitResult result)
        {
            switch (result)
            {
-                case HitResult.Miss:
+                case HitResult.IgnoreMiss:
                    return -0.65;

                default:
--- a/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableDrumRoll.cs
+++ b/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableDrumRoll.cs
@ -4,7 +4,6 @@
 #nullable disable

 using System;
-using System.Linq;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Utils;
@ -17,7 +16,6 @@ using osu.Framework.Graphics.Primitives;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Skinning.Default;
 using osu.Game.Skinning;
 using osuTK;
@ -43,6 +41,8 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
        private Color4 colourIdle;
        private Color4 colourEngaged;

+        public override bool DisplayResult => false;
+
        public DrawableDrumRoll()
            : this(null)
        {
@ -143,14 +143,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
            if (timeOffset < 0)
                return;

-            int countHit = NestedHitObjects.Count(o => o.IsHit);
-
-            if (countHit >= HitObject.RequiredGoodHits)
-            {
-                ApplyResult(r => r.Type = countHit >= HitObject.RequiredGreatHits ? HitResult.Great : HitResult.Ok);
-            }
-            else
-                ApplyResult(r => r.Type = r.Judgement.MinResult);
+            ApplyResult(r => r.Type = r.Judgement.MaxResult);
        }

        protected override void UpdateHitStateTransforms(ArmedState state)
--- a/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwell.cs
+++ b/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwell.cs
@ -16,7 +16,6 @@ using osuTK.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Skinning.Default;
 using osu.Game.Skinning;

@ -39,6 +38,8 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
        private readonly CircularContainer targetRing;
        private readonly CircularContainer expandingRing;

+        public override bool DisplayResult => false;
+
        public DrawableSwell()
            : this(null)
        {
@ -201,7 +202,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                expandingRing.ScaleTo(1f + Math.Min(target_ring_scale - 1f, (target_ring_scale - 1f) * completion * 1.3f), 260, Easing.OutQuint);

                if (numHits == HitObject.RequiredHits)
-                    ApplyResult(r => r.Type = HitResult.Great);
+                    ApplyResult(r => r.Type = r.Judgement.MaxResult);
            }
            else
            {
@ -222,7 +223,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                        tick.TriggerResult(false);
                }

-                ApplyResult(r => r.Type = numHits > HitObject.RequiredHits / 2 ? HitResult.Ok : r.Judgement.MinResult);
+                ApplyResult(r => r.Type = numHits == HitObject.RequiredHits ? r.Judgement.MaxResult : r.Judgement.MinResult);
            }
        }

--- a/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs
+++ b/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs
@ -56,7 +56,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables

            isProxied = true;

-            nonProxiedContent.Remove(Content);
+            nonProxiedContent.Remove(Content, false);
            proxiedContent.Add(Content);
        }

@ -70,7 +70,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables

            isProxied = false;

-            proxiedContent.Remove(Content);
+            proxiedContent.Remove(Content, false);
            nonProxiedContent.Add(Content);
        }

@ -141,7 +141,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
            Size = BaseSize = new Vector2(TaikoHitObject.DEFAULT_SIZE);

            if (MainPiece != null)
-                Content.Remove(MainPiece);
+                Content.Remove(MainPiece, true);

            Content.Add(MainPiece = CreateMainPiece());
        }
--- a/osu.Game.Rulesets.Taiko/Objects/DrumRoll.cs
+++ b/osu.Game.Rulesets.Taiko/Objects/DrumRoll.cs
@ -4,7 +4,6 @@
 #nullable disable

 using osu.Game.Rulesets.Objects.Types;
-using System;
 using System.Threading;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
@ -12,7 +11,6 @@ using osu.Game.Beatmaps.Formats;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.Taiko.Judgements;
 using osuTK;

 namespace osu.Game.Rulesets.Taiko.Objects
@ -42,24 +40,12 @@ namespace osu.Game.Rulesets.Taiko.Objects
        /// </summary>
        public int TickRate = 1;

-        /// <summary>
-        /// Number of drum roll ticks required for a "Good" hit.
-        /// </summary>
-        public double RequiredGoodHits { get; protected set; }
-
-        /// <summary>
-        /// Number of drum roll ticks required for a "Great" hit.
-        /// </summary>
-        public double RequiredGreatHits { get; protected set; }
-
        /// <summary>
        /// The length (in milliseconds) between ticks of this drumroll.
        /// <para>Half of this value is the hit window of the ticks.</para>
        /// </summary>
        private double tickSpacing = 100;

-        private float overallDifficulty = BeatmapDifficulty.DEFAULT_DIFFICULTY;
-
        protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, IBeatmapDifficultyInfo difficulty)
        {
            base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
@ -70,16 +56,12 @@ namespace osu.Game.Rulesets.Taiko.Objects
            Velocity = scoringDistance / timingPoint.BeatLength;

            tickSpacing = timingPoint.BeatLength / TickRate;
-            overallDifficulty = difficulty.OverallDifficulty;
        }

        protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
        {
            createTicks(cancellationToken);

-            RequiredGoodHits = NestedHitObjects.Count * Math.Min(0.15, 0.05 + 0.10 / 6 * overallDifficulty);
-            RequiredGreatHits = NestedHitObjects.Count * Math.Min(0.30, 0.10 + 0.20 / 6 * overallDifficulty);
-
            base.CreateNestedHitObjects(cancellationToken);
        }

@ -106,7 +88,7 @@ namespace osu.Game.Rulesets.Taiko.Objects
            }
        }

-        public override Judgement CreateJudgement() => new TaikoDrumRollJudgement();
+        public override Judgement CreateJudgement() => new IgnoreJudgement();

        protected override HitWindows CreateHitWindows() => HitWindows.Empty;

@ -114,6 +96,8 @@ namespace osu.Game.Rulesets.Taiko.Objects

        public class StrongNestedHit : StrongNestedHitObject
        {
+            // The strong hit of the drum roll doesn't actually provide any score.
+            public override Judgement CreateJudgement() => new IgnoreJudgement();
        }

        #region LegacyBeatmapEncoder
--- a/osu.Game.Rulesets.Taiko/TaikoRuleset.cs
+++ b/osu.Game.Rulesets.Taiko/TaikoRuleset.cs
@ -1,35 +1,33 @@
 // 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 osu.Game.Beatmaps;
-using osu.Game.Graphics;
-using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Taiko.Mods;
-using osu.Game.Rulesets.Taiko.UI;
-using osu.Game.Rulesets.UI;
+using System;
 using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
-using osu.Game.Rulesets.Replays.Types;
-using osu.Game.Rulesets.Taiko.Replays;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Legacy;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Beatmaps;
 using osu.Game.Rulesets.Taiko.Difficulty;
-using osu.Game.Rulesets.Taiko.Scoring;
-using osu.Game.Scoring;
-using System;
-using System.Linq;
-using osu.Framework.Extensions.EnumExtensions;
-using osu.Framework.Localisation;
-using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Taiko.Edit;
+using osu.Game.Rulesets.Taiko.Mods;
 using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Replays;
+using osu.Game.Rulesets.Taiko.Scoring;
 using osu.Game.Rulesets.Taiko.Skinning.Legacy;
+using osu.Game.Rulesets.Taiko.UI;
+using osu.Game.Rulesets.UI;
+using osu.Game.Scoring;
 using osu.Game.Screens.Ranking.Statistics;
 using osu.Game.Skinning;

@ -37,7 +35,7 @@ namespace osu.Game.Rulesets.Taiko
 {
    public class TaikoRuleset : Ruleset, ILegacyRuleset
    {
-        public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod> mods = null) => new DrawableTaikoRuleset(this, beatmap, mods);
+        public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod>? mods = null) => new DrawableTaikoRuleset(this, beatmap, mods);

        public override ScoreProcessor CreateScoreProcessor() => new TaikoScoreProcessor();

@ -49,6 +47,8 @@ namespace osu.Game.Rulesets.Taiko

        public const string SHORT_NAME = "taiko";

+        public override string RulesetAPIVersionSupported => CURRENT_RULESET_API_VERSION;
+
        public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0) => new[]
        {
            new KeyBinding(InputKey.MouseLeft, TaikoAction.LeftCentre),
@ -197,11 +197,8 @@ namespace osu.Game.Rulesets.Taiko
        {
            switch (result)
            {
-                case HitResult.SmallTickHit:
-                    return "drum tick";
-
                case HitResult.SmallBonus:
-                    return "strong bonus";
+                    return "bonus";
            }

            return base.GetDisplayNameForHitResult(result);
--- a/osu.Game.Rulesets.Taiko/UI/TaikoPlayfield.cs
+++ b/osu.Game.Rulesets.Taiko/UI/TaikoPlayfield.cs
@ -317,6 +317,9 @@ namespace osu.Game.Rulesets.Taiko.UI
                    break;

                default:
+                    if (!result.Type.IsScorable())
+                        break;
+
                    judgementContainer.Add(judgementPools[result.Type].Get(j =>
                    {
                        j.Apply(result, judgedObject);
--- a/osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapDecoderTest.cs
+++ b/osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapDecoderTest.cs
@ -919,5 +919,30 @@ namespace osu.Game.Tests.Beatmaps.Formats
                Assert.That(controlPoints[1].Position, Is.Not.EqualTo(Vector2.Zero));
            }
        }
+
+        [Test]
+        public void TestNaNControlPoints()
+        {
+            var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
+
+            using (var resStream = TestResources.OpenResource("nan-control-points.osu"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                var controlPoints = (LegacyControlPointInfo)decoder.Decode(stream).ControlPointInfo;
+
+                Assert.That(controlPoints.TimingPoints.Count, Is.EqualTo(1));
+                Assert.That(controlPoints.DifficultyPoints.Count, Is.EqualTo(2));
+
+                Assert.That(controlPoints.TimingPointAt(1000).BeatLength, Is.EqualTo(500));
+
+                Assert.That(controlPoints.DifficultyPointAt(2000).SliderVelocity, Is.EqualTo(1));
+                Assert.That(controlPoints.DifficultyPointAt(3000).SliderVelocity, Is.EqualTo(1));
+
+#pragma warning disable 618
+                Assert.That(((LegacyBeatmapDecoder.LegacyDifficultyControlPoint)controlPoints.DifficultyPointAt(2000)).GenerateTicks, Is.False);
+                Assert.That(((LegacyBeatmapDecoder.LegacyDifficultyControlPoint)controlPoints.DifficultyPointAt(3000)).GenerateTicks, Is.True);
+#pragma warning restore 618
+            }
+        }
    }
 }
--- a/osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs
+++ b/osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs
@ -67,6 +67,24 @@ namespace osu.Game.Tests.Beatmaps.Formats
            }
        }

+        [Test]
+        public void TestDecodeTaikoReplay()
+        {
+            var decoder = new TestLegacyScoreDecoder();
+
+            using (var resourceStream = TestResources.OpenResource("Replays/taiko-replay.osr"))
+            {
+                var score = decoder.Parse(resourceStream);
+
+                Assert.AreEqual(1, score.ScoreInfo.Ruleset.OnlineID);
+                Assert.AreEqual(4, score.ScoreInfo.Statistics[HitResult.Great]);
+                Assert.AreEqual(2, score.ScoreInfo.Statistics[HitResult.LargeBonus]);
+                Assert.AreEqual(4, score.ScoreInfo.MaxCombo);
+
+                Assert.That(score.Replay.Frames, Is.Not.Empty);
+            }
+        }
+
        [TestCase(3, true)]
        [TestCase(6, false)]
        [TestCase(LegacyBeatmapDecoder.LATEST_VERSION, false)]
--- a/osu.Game.Tests/Beatmaps/Formats/LegacyStoryboardDecoderTest.cs
+++ b/osu.Game.Tests/Beatmaps/Formats/LegacyStoryboardDecoderTest.cs
@ -97,6 +97,25 @@ namespace osu.Game.Tests.Beatmaps.Formats
            }
        }

+        [Test]
+        public void TestCorrectAnimationStartTime()
+        {
+            var decoder = new LegacyStoryboardDecoder();
+
+            using (var resStream = TestResources.OpenResource("animation-starts-before-alpha.osb"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                var storyboard = decoder.Decode(stream);
+
+                StoryboardLayer background = storyboard.Layers.Single(l => l.Depth == 3);
+                Assert.AreEqual(1, background.Elements.Count);
+
+                Assert.AreEqual(2000, background.Elements[0].StartTime);
+                // This property should be used in DrawableStoryboardAnimation as a starting point for animation playback.
+                Assert.AreEqual(1000, (background.Elements[0] as StoryboardAnimation)?.EarliestTransformTime);
+            }
+        }
+
        [Test]
        public void TestOutOfOrderStartTimes()
        {
@ -117,6 +136,26 @@ namespace osu.Game.Tests.Beatmaps.Formats
            }
        }

+        [Test]
+        public void TestEarliestStartTimeWithLoopAlphas()
+        {
+            var decoder = new LegacyStoryboardDecoder();
+
+            using (var resStream = TestResources.OpenResource("loop-containing-earlier-non-zero-fade.osb"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                var storyboard = decoder.Decode(stream);
+
+                StoryboardLayer background = storyboard.Layers.Single(l => l.Depth == 3);
+                Assert.AreEqual(2, background.Elements.Count);
+
+                Assert.AreEqual(1000, background.Elements[0].StartTime);
+                Assert.AreEqual(1000, background.Elements[1].StartTime);
+
+                Assert.AreEqual(1000, storyboard.EarliestEventTime);
+            }
+        }
+
        [Test]
        public void TestDecodeVariableWithSuffix()
        {
--- a/osu.Game.Tests/Beatmaps/Formats/ParsingTest.cs
+++ b/osu.Game.Tests/Beatmaps/Formats/ParsingTest.cs
@ -14,7 +14,12 @@ namespace osu.Game.Tests.Beatmaps.Formats
    public class ParsingTest
    {
        [Test]
-        public void TestNaNHandling() => allThrow<FormatException>("NaN");
+        public void TestNaNHandling()
+        {
+            allThrow<FormatException>("NaN");
+            Assert.That(Parsing.ParseFloat("NaN", allowNaN: true), Is.NaN);
+            Assert.That(Parsing.ParseDouble("NaN", allowNaN: true), Is.NaN);
+        }

        [Test]
        public void TestBadStringHandling() => allThrow<FormatException>("Random string 123");
--- a/osu.Game.Tests/Database/RulesetStoreTests.cs
+++ b/osu.Game.Tests/Database/RulesetStoreTests.cs
@ -1,11 +1,19 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

-#nullable disable
-
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Difficulty;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.UI;

 namespace osu.Game.Tests.Database
 {
@ -51,5 +59,105 @@ namespace osu.Game.Tests.Database
                Assert.IsFalse(rulesets.GetRuleset("mania")?.IsManaged);
            });
        }
+
+        [Test]
+        public void TestRulesetThrowingOnMethods()
+        {
+            RunTestWithRealm((realm, storage) =>
+            {
+                LoadTestRuleset.Version = Ruleset.CURRENT_RULESET_API_VERSION;
+                LoadTestRuleset.HasImplementations = false;
+
+                var ruleset = new LoadTestRuleset();
+                string rulesetShortName = ruleset.RulesetInfo.ShortName;
+
+                realm.Write(r => r.Add(new RulesetInfo(rulesetShortName, ruleset.RulesetInfo.Name, ruleset.RulesetInfo.InstantiationInfo, ruleset.RulesetInfo.OnlineID)
+                {
+                    Available = true,
+                }));
+
+                Assert.That(realm.Run(r => r.Find<RulesetInfo>(rulesetShortName).Available), Is.True);
+
+                // Availability is updated on construction of a RealmRulesetStore
+                var _ = new RealmRulesetStore(realm, storage);
+
+                Assert.That(realm.Run(r => r.Find<RulesetInfo>(rulesetShortName).Available), Is.False);
+            });
+        }
+
+        [Test]
+        public void TestOutdatedRulesetNotAvailable()
+        {
+            RunTestWithRealm((realm, storage) =>
+            {
+                LoadTestRuleset.Version = "2021.101.0";
+                LoadTestRuleset.HasImplementations = true;
+
+                var ruleset = new LoadTestRuleset();
+                string rulesetShortName = ruleset.RulesetInfo.ShortName;
+
+                realm.Write(r => r.Add(new RulesetInfo(rulesetShortName, ruleset.RulesetInfo.Name, ruleset.RulesetInfo.InstantiationInfo, ruleset.RulesetInfo.OnlineID)
+                {
+                    Available = true,
+                }));
+
+                Assert.That(realm.Run(r => r.Find<RulesetInfo>(rulesetShortName).Available), Is.True);
+
+                // Availability is updated on construction of a RealmRulesetStore
+                var _ = new RealmRulesetStore(realm, storage);
+
+                Assert.That(realm.Run(r => r.Find<RulesetInfo>(rulesetShortName).Available), Is.False);
+
+                // Simulate the ruleset getting updated
+                LoadTestRuleset.Version = Ruleset.CURRENT_RULESET_API_VERSION;
+                var __ = new RealmRulesetStore(realm, storage);
+
+                Assert.That(realm.Run(r => r.Find<RulesetInfo>(rulesetShortName).Available), Is.True);
+            });
+        }
+
+        private class LoadTestRuleset : Ruleset
+        {
+            public override string RulesetAPIVersionSupported => Version;
+
+            public static bool HasImplementations = true;
+
+            public static string Version { get; set; } = CURRENT_RULESET_API_VERSION;
+
+            public override IEnumerable<Mod> GetModsFor(ModType type)
+            {
+                if (!HasImplementations)
+                    throw new NotImplementedException();
+
+                return Array.Empty<Mod>();
+            }
+
+            public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod>? mods = null)
+            {
+                if (!HasImplementations)
+                    throw new NotImplementedException();
+
+                return new DrawableOsuRuleset(new OsuRuleset(), beatmap, mods);
+            }
+
+            public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap)
+            {
+                if (!HasImplementations)
+                    throw new NotImplementedException();
+
+                return new OsuBeatmapConverter(beatmap, new OsuRuleset());
+            }
+
+            public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap)
+            {
+                if (!HasImplementations)
+                    throw new NotImplementedException();
+
+                return new OsuDifficultyCalculator(new OsuRuleset().RulesetInfo, beatmap);
+            }
+
+            public override string Description => "outdated ruleset";
+            public override string ShortName => "ruleset-outdated";
+        }
    }
 }
--- a/osu.Game.Tests/Editing/Checks/CheckAudioQualityTest.cs
+++ b/osu.Game.Tests/Editing/Checks/CheckAudioQualityTest.cs
@ -7,10 +7,12 @@ using System.Linq;
 using Moq;
 using NUnit.Framework;
 using osu.Framework.Audio.Track;
+using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Checks;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Tests.Visual;

 namespace osu.Game.Tests.Editing.Checks
 {
@ -109,7 +111,7 @@ namespace osu.Game.Tests.Editing.Checks
        /// <param name="audioBitrate">The bitrate of the audio file the beatmap uses.</param>
        private Mock<IWorkingBeatmap> getMockWorkingBeatmap(int? audioBitrate)
        {
-            var mockTrack = new Mock<Track>();
+            var mockTrack = new Mock<OsuTestScene.ClockBackedTestWorkingBeatmap.TrackVirtualManual>(new FramedClock(), "virtual");
            mockTrack.SetupGet(t => t.Bitrate).Returns(audioBitrate);

            var mockWorkingBeatmap = new Mock<IWorkingBeatmap>();
--- a/osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs
+++ b/osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs
@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

-#nullable disable
-
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@ -23,13 +21,13 @@ namespace osu.Game.Tests.Editing
    [HeadlessTest]
    public class TestSceneHitObjectComposerDistanceSnapping : EditorClockTestScene
    {
-        private TestHitObjectComposer composer;
+        private TestHitObjectComposer composer = null!;

        [Cached(typeof(EditorBeatmap))]
        [Cached(typeof(IBeatSnapProvider))]
        private readonly EditorBeatmap editorBeatmap;

-        protected override Container<Drawable> Content { get; }
+        protected override Container<Drawable> Content { get; } = new Container { RelativeSizeAxes = Axes.Both };

        public TestSceneHitObjectComposerDistanceSnapping()
        {
@ -40,15 +38,9 @@ namespace osu.Game.Tests.Editing
                {
                    editorBeatmap = new EditorBeatmap(new OsuBeatmap
                    {
-                        BeatmapInfo =
-                        {
-                            Ruleset = new OsuRuleset().RulesetInfo,
-                        },
+                        BeatmapInfo = { Ruleset = new OsuRuleset().RulesetInfo },
                    }),
-                    Content = new Container
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                    }
+                    Content
                },
            });
        }
@ -205,7 +197,7 @@ namespace osu.Game.Tests.Editing
            assertSnappedDistance(400, 400);
        }

-        private void assertSnapDistance(float expectedDistance, HitObject hitObject = null)
+        private void assertSnapDistance(float expectedDistance, HitObject? hitObject = null)
            => AddAssert($"distance is {expectedDistance}", () => composer.GetBeatSnapDistanceAt(hitObject ?? new HitObject()), () => Is.EqualTo(expectedDistance));

        private void assertDurationToDistance(double duration, float expectedDistance)
--- a/osu.Game.Tests/Gameplay/TestSceneScoreProcessor.cs
+++ b/osu.Game.Tests/Gameplay/TestSceneScoreProcessor.cs
@ -124,14 +124,19 @@ namespace osu.Game.Tests.Gameplay

            Assert.That(score.Rank, Is.EqualTo(ScoreRank.F));
            Assert.That(score.Passed, Is.False);
-            Assert.That(score.Statistics.Count(kvp => kvp.Value > 0), Is.EqualTo(7));
+            Assert.That(score.Statistics.Sum(kvp => kvp.Value), Is.EqualTo(4));
+            Assert.That(score.MaximumStatistics.Sum(kvp => kvp.Value), Is.EqualTo(8));
+
            Assert.That(score.Statistics[HitResult.Ok], Is.EqualTo(1));
-            Assert.That(score.Statistics[HitResult.Miss], Is.EqualTo(1));
            Assert.That(score.Statistics[HitResult.LargeTickHit], Is.EqualTo(1));
-            Assert.That(score.Statistics[HitResult.LargeTickMiss], Is.EqualTo(1));
-            Assert.That(score.Statistics[HitResult.SmallTickMiss], Is.EqualTo(2));
+            Assert.That(score.Statistics[HitResult.SmallTickMiss], Is.EqualTo(1));
            Assert.That(score.Statistics[HitResult.SmallBonus], Is.EqualTo(1));
-            Assert.That(score.Statistics[HitResult.IgnoreMiss], Is.EqualTo(1));
+
+            Assert.That(score.MaximumStatistics[HitResult.Perfect], Is.EqualTo(2));
+            Assert.That(score.MaximumStatistics[HitResult.LargeTickHit], Is.EqualTo(2));
+            Assert.That(score.MaximumStatistics[HitResult.SmallTickHit], Is.EqualTo(2));
+            Assert.That(score.MaximumStatistics[HitResult.SmallBonus], Is.EqualTo(1));
+            Assert.That(score.MaximumStatistics[HitResult.LargeBonus], Is.EqualTo(1));
        }

        private class TestJudgement : Judgement
--- a/osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs
+++ b/osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs
@ -118,17 +118,31 @@ namespace osu.Game.Tests.NonVisual.Filtering
            Assert.IsNull(filterCriteria.BPM.Max);
        }

-        private static readonly object[] length_query_examples =
+        private static readonly object[] correct_length_query_examples =
        {
-            new object[] { "6ms", TimeSpan.FromMilliseconds(6), TimeSpan.FromMilliseconds(1) },
            new object[] { "23s", TimeSpan.FromSeconds(23), TimeSpan.FromSeconds(1) },
            new object[] { "9m", TimeSpan.FromMinutes(9), TimeSpan.FromMinutes(1) },
            new object[] { "0.25h", TimeSpan.FromHours(0.25), TimeSpan.FromHours(1) },
            new object[] { "70", TimeSpan.FromSeconds(70), TimeSpan.FromSeconds(1) },
+            new object[] { "7m27s", TimeSpan.FromSeconds(447), TimeSpan.FromSeconds(1) },
+            new object[] { "7:27", TimeSpan.FromSeconds(447), TimeSpan.FromSeconds(1) },
+            new object[] { "1h2m3s", TimeSpan.FromSeconds(3723), TimeSpan.FromSeconds(1) },
+            new object[] { "1h2m3.5s", TimeSpan.FromSeconds(3723.5), TimeSpan.FromSeconds(1) },
+            new object[] { "1:2:3", TimeSpan.FromSeconds(3723), TimeSpan.FromSeconds(1) },
+            new object[] { "1:02:03", TimeSpan.FromSeconds(3723), TimeSpan.FromSeconds(1) },
+            new object[] { "6", TimeSpan.FromSeconds(6), TimeSpan.FromSeconds(1) },
+            new object[] { "6.5", TimeSpan.FromSeconds(6.5), TimeSpan.FromSeconds(1) },
+            new object[] { "6.5s", TimeSpan.FromSeconds(6.5), TimeSpan.FromSeconds(1) },
+            new object[] { "6.5m", TimeSpan.FromMinutes(6.5), TimeSpan.FromMinutes(1) },
+            new object[] { "6h5m", TimeSpan.FromMinutes(365), TimeSpan.FromMinutes(1) },
+            new object[] { "65m", TimeSpan.FromMinutes(65), TimeSpan.FromMinutes(1) },
+            new object[] { "90s", TimeSpan.FromSeconds(90), TimeSpan.FromSeconds(1) },
+            new object[] { "80m20s", TimeSpan.FromSeconds(4820), TimeSpan.FromSeconds(1) },
+            new object[] { "1h20s", TimeSpan.FromSeconds(3620), TimeSpan.FromSeconds(1) },
        };

        [Test]
-        [TestCaseSource(nameof(length_query_examples))]
+        [TestCaseSource(nameof(correct_length_query_examples))]
        public void TestApplyLengthQueries(string lengthQuery, TimeSpan expectedLength, TimeSpan scale)
        {
            string query = $"length={lengthQuery} time";
@ -140,6 +154,29 @@ namespace osu.Game.Tests.NonVisual.Filtering
            Assert.AreEqual(expectedLength.TotalMilliseconds + scale.TotalMilliseconds / 2.0, filterCriteria.Length.Max);
        }

+        private static readonly object[] incorrect_length_query_examples =
+        {
+            new object[] { "7.5m27s" },
+            new object[] { "7m27" },
+            new object[] { "7m7m7m" },
+            new object[] { "7m70s" },
+            new object[] { "5s6m" },
+            new object[] { "0:" },
+            new object[] { ":0" },
+            new object[] { "0:3:" },
+            new object[] { "3:15.5" },
+        };
+
+        [Test]
+        [TestCaseSource(nameof(incorrect_length_query_examples))]
+        public void TestInvalidLengthQueries(string lengthQuery)
+        {
+            string query = $"length={lengthQuery} time";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.AreEqual(false, filterCriteria.Length.HasFilter);
+        }
+
        [Test]
        public void TestApplyDivisorQueries()
        {
--- a/osu.Game.Tests/NonVisual/GameplayClockContainerTest.cs
+++ b/osu.Game.Tests/NonVisual/GameplayClockContainerTest.cs
@ -1,8 +1,9 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

-using System.Collections.Generic;
 using NUnit.Framework;
+using osu.Framework.Audio;
+using osu.Framework.Bindables;
 using osu.Framework.Timing;
 using osu.Game.Screens.Play;

@ -13,21 +14,20 @@ namespace osu.Game.Tests.NonVisual
    {
        [TestCase(0)]
        [TestCase(1)]
-        public void TestTrueGameplayRateWithZeroAdjustment(double underlyingClockRate)
+        public void TestTrueGameplayRateWithGameplayAdjustment(double underlyingClockRate)
        {
            var framedClock = new FramedClock(new ManualClock { Rate = underlyingClockRate });
            var gameplayClock = new TestGameplayClockContainer(framedClock);

-            Assert.That(gameplayClock.TrueGameplayRate, Is.EqualTo(0));
+            Assert.That(gameplayClock.GetTrueGameplayRate(), Is.EqualTo(2));
        }

        private class TestGameplayClockContainer : GameplayClockContainer
        {
-            public override IEnumerable<double> NonGameplayAdjustments => new[] { 0.0 };
-
            public TestGameplayClockContainer(IFrameBasedClock underlyingClock)
                : base(underlyingClock)
            {
+                AdjustmentsFromMods.AddAdjustment(AdjustableProperty.Frequency, new BindableDouble(2.0));
            }
        }
    }
--- a/osu.Game.Tests/Resources/Archives/modified-default-20220818.osk
+++ b/osu.Game.Tests/Resources/Archives/modified-default-20220818.osk
--- a/osu.Game.Tests/Resources/Replays/taiko-replay.osr
+++ b/osu.Game.Tests/Resources/Replays/taiko-replay.osr
--- a/osu.Game.Tests/Resources/TestResources.cs
+++ b/osu.Game.Tests/Resources/TestResources.cs
@ -194,8 +194,16 @@ namespace osu.Game.Tests.Resources
                [HitResult.LargeTickHit] = 100,
                [HitResult.LargeTickMiss] = 50,
                [HitResult.SmallBonus] = 10,
-                [HitResult.SmallBonus] = 50
+                [HitResult.LargeBonus] = 50
            },
+            MaximumStatistics = new Dictionary<HitResult, int>
+            {
+                [HitResult.Perfect] = 971,
+                [HitResult.SmallTickHit] = 75,
+                [HitResult.LargeTickHit] = 150,
+                [HitResult.SmallBonus] = 10,
+                [HitResult.LargeBonus] = 50,
+            }
        };

        private class TestModHardRock : ModHardRock
--- a/osu.Game.Tests/Resources/animation-starts-before-alpha.osb
+++ b/osu.Game.Tests/Resources/animation-starts-before-alpha.osb
@ -0,0 +1,5 @@
+[Events]
+//Storyboard Layer 0 (Background)
+Animation,Background,Centre,"img.jpg",320,240,2,150,LoopForever
+ S,0,1000,1500,0.08 // animation should start playing from this point in time..
+ F,0,2000,,0,1      // .. not this point in time
--- a/osu.Game.Tests/Resources/loop-containing-earlier-non-zero-fade.osb
+++ b/osu.Game.Tests/Resources/loop-containing-earlier-non-zero-fade.osb
@ -0,0 +1,14 @@
+osu file format v14
+
+[Events]
+//Storyboard Layer 0 (Background)
+Sprite,Background,TopCentre,"img.jpg",320,240
+ L,1000,1
+  F,0,0,,1       // fade inside a loop with non-zero alpha and an earlier start time should be the true start time..
+ F,0,2000,,0     // ..not a zero alpha fade with a later start time
+
+Sprite,Background,TopCentre,"img.jpg",320,240
+ L,2000,1
+  F,0,0,24,0     // fade inside a loop with zero alpha but later start time than the top-level zero alpha start time.
+  F,0,24,48,1
+ F,0,1000,,1     // ..so this should be the true start time
--- a/osu.Game.Tests/Resources/nan-control-points.osu
+++ b/osu.Game.Tests/Resources/nan-control-points.osu
@ -0,0 +1,15 @@
+osu file format v14
+
+[TimingPoints]
+
+// NaN bpm (should be rejected)
+0,NaN,4,2,0,100,1,0
+
+// 120 bpm
+1000,500,4,2,0,100,1,0
+
+// NaN slider velocity
+2000,NaN,4,3,0,100,0,1
+
+// 1.0x slider velocity
+3000,-100,4,3,0,100,0,1
--- a/osu.Game.Tests/Rulesets/Scoring/ScoreProcessorTest.cs
+++ b/osu.Game.Tests/Rulesets/Scoring/ScoreProcessorTest.cs
@ -307,7 +307,7 @@ namespace osu.Game.Tests.Rulesets.Scoring
                HitObjects = { new TestHitObject(result) }
            });

-            Assert.That(scoreProcessor.ComputeFinalScore(ScoringMode.Standardised, new ScoreInfo
+            Assert.That(scoreProcessor.ComputeScore(ScoringMode.Standardised, new ScoreInfo
            {
                Ruleset = new TestRuleset().RulesetInfo,
                MaxCombo = result.AffectsCombo() ? 1 : 0,
@ -350,7 +350,7 @@ namespace osu.Game.Tests.Rulesets.Scoring
                }
            };

-            double totalScore = new TestScoreProcessor().ComputeFinalScore(ScoringMode.Standardised, testScore);
+            double totalScore = new TestScoreProcessor().ComputeScore(ScoringMode.Standardised, testScore);
            Assert.That(totalScore, Is.EqualTo(750_000)); // 500K from accuracy (100%), and 250K from combo (50%).
        }
 #pragma warning restore CS0618
--- a/osu.Game.Tests/Skins/SkinDeserialisationTest.cs
+++ b/osu.Game.Tests/Skins/SkinDeserialisationTest.cs
@ -36,7 +36,9 @@ namespace osu.Game.Tests.Skins
            "Archives/modified-default-20220723.osk",
            "Archives/modified-classic-20220723.osk",
            // Covers legacy song progress, UR counter, colour hit error metre.
-            "Archives/modified-classic-20220801.osk"
+            "Archives/modified-classic-20220801.osk",
+            // Covers clicks/s counter
+            "Archives/modified-default-20220818.osk"
        };

        /// <summary>
--- a/osu.Game.Tests/Visual/Background/TestSceneSeasonalBackgroundLoader.cs
+++ b/osu.Game.Tests/Visual/Background/TestSceneSeasonalBackgroundLoader.cs
@ -171,7 +171,7 @@ namespace osu.Game.Tests.Visual.Background
            => AddStep("create loader", () =>
            {
                if (backgroundLoader != null)
-                    Remove(backgroundLoader);
+                    Remove(backgroundLoader, true);

                Add(backgroundLoader = new SeasonalBackgroundLoader());
            });
--- a/osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapCard.cs
+++ b/osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapCard.cs
@ -15,12 +15,14 @@ using osu.Framework.Testing;
 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.Graphics.Containers;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osuTK;
+using osuTK.Input;

 namespace osu.Game.Tests.Visual.Beatmaps
 {
@ -295,5 +297,22 @@ namespace osu.Game.Tests.Visual.Beatmaps

            BeatmapCardNormal firstCard() => this.ChildrenOfType<BeatmapCardNormal>().First();
        }
+
+        [Test]
+        public void TestPlayButtonByTouchInput()
+        {
+            AddStep("create cards", () => Child = createContent(OverlayColourScheme.Blue, beatmapSetInfo => new BeatmapCardNormal(beatmapSetInfo)));
+
+            // mimics touch input
+            AddStep("touch play button area on first card", () =>
+            {
+                InputManager.MoveMouseTo(firstCard().ChildrenOfType<PlayButton>().Single());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("first card is playing", () => firstCard().ChildrenOfType<PlayButton>().Single().Playing.Value);
+
+            BeatmapCardNormal firstCard() => this.ChildrenOfType<BeatmapCardNormal>().First();
+        }
    }
 }
--- a/osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapCardDownloadButton.cs
+++ b/osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapCardDownloadButton.cs
@ -9,6 +9,7 @@ using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Drawables.Cards.Buttons;
 using osu.Game.Configuration;
+using osu.Game.Online;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osu.Game.Resources.Localisation.Web;
@ -58,6 +59,7 @@ namespace osu.Game.Tests.Visual.Beatmaps
                {
                    Anchor = Anchor.Centre,
                    Origin = Anchor.Centre,
+                    State = { Value = DownloadState.NotDownloaded },
                    Scale = new Vector2(2)
                };
            });
--- a/osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapCardThumbnail.cs
+++ b/osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapCardThumbnail.cs
@ -42,7 +42,7 @@ namespace osu.Game.Tests.Visual.Beatmaps
                };
            });
            AddStep("enable dim", () => thumbnail.Dimmed.Value = true);
-            AddUntilStep("button visible", () => playButton.IsPresent);
+            AddUntilStep("button visible", () => playButton.Alpha == 1);

            AddStep("click button", () =>
            {
@ -70,7 +70,7 @@ namespace osu.Game.Tests.Visual.Beatmaps

            AddStep("disable dim", () => thumbnail.Dimmed.Value = false);
            AddWaitStep("wait some", 3);
-            AddAssert("button still visible", () => playButton.IsPresent);
+            AddAssert("button still visible", () => playButton.Alpha == 1);

            // The track plays in real-time, so we need to check for progress in increments to avoid timeout.
            AddUntilStep("progress > 0.25", () => thumbnail.ChildrenOfType<PlayButton>().Single().Progress.Value > 0.25);
@ -78,7 +78,7 @@ namespace osu.Game.Tests.Visual.Beatmaps
            AddUntilStep("progress > 0.75", () => thumbnail.ChildrenOfType<PlayButton>().Single().Progress.Value > 0.75);

            AddUntilStep("wait for track to end", () => !playButton.Playing.Value);
-            AddUntilStep("button hidden", () => !playButton.IsPresent);
+            AddUntilStep("button hidden", () => playButton.Alpha == 0);
        }

        private void iconIs(IconUsage usage) => AddUntilStep("icon is correct", () => playButton.ChildrenOfType<SpriteIcon>().Any(icon => icon.Icon.Equals(usage)));
--- a/osu.Game.Tests/Visual/Editing/TestSceneComposeScreen.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneComposeScreen.cs
@ -9,6 +9,7 @@ using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Overlays;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Osu;
@ -34,9 +35,11 @@ namespace osu.Game.Tests.Visual.Editing
            {
                var beatmap = new OsuBeatmap
                {
-                    BeatmapInfo = { Ruleset = new OsuRuleset().RulesetInfo }
+                    BeatmapInfo = { Ruleset = new OsuRuleset().RulesetInfo },
                };

+                beatmap.ControlPointInfo.Add(0, new TimingControlPoint());
+
                editorBeatmap = new EditorBeatmap(beatmap, new LegacyBeatmapSkin(beatmap.BeatmapInfo, null));

                Beatmap.Value = CreateWorkingBeatmap(editorBeatmap.PlayableBeatmap);
@ -50,7 +53,11 @@ namespace osu.Game.Tests.Visual.Editing
                        (typeof(IBeatSnapProvider), editorBeatmap),
                        (typeof(OverlayColourProvider), new OverlayColourProvider(OverlayColourScheme.Green)),
                    },
-                    Child = new ComposeScreen { State = { Value = Visibility.Visible } },
+                    Children = new Drawable[]
+                    {
+                        editorBeatmap,
+                        new ComposeScreen { State = { Value = Visibility.Visible } },
+                    }
                };
            });

--- a/osu.Game.Tests/Visual/Editing/TestSceneDifficultyDelete.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneDifficultyDelete.cs
@ -0,0 +1,85 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Storyboards;
+using osu.Game.Tests.Beatmaps.IO;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Editing
+{
+    public class TestSceneDifficultyDelete : EditorTestScene
+    {
+        protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
+        protected override bool IsolateSavingFromDatabase => false;
+
+        [Resolved]
+        private OsuGameBase game { get; set; } = null!;
+
+        [Resolved]
+        private BeatmapManager beatmaps { get; set; } = null!;
+
+        private BeatmapSetInfo importedBeatmapSet = null!;
+
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null!)
+            => beatmaps.GetWorkingBeatmap(importedBeatmapSet.Beatmaps.First());
+
+        public override void SetUpSteps()
+        {
+            AddStep("import test beatmap", () => importedBeatmapSet = BeatmapImportHelper.LoadOszIntoOsu(game, virtualTrack: true).GetResultSafely());
+            base.SetUpSteps();
+        }
+
+        [Test]
+        public void TestDeleteDifficulties()
+        {
+            Guid deletedDifficultyID = Guid.Empty;
+            int countBeforeDeletion = 0;
+            string beatmapSetHashBefore = string.Empty;
+
+            for (int i = 0; i < 12; i++)
+            {
+                // Will be reloaded after each deletion.
+                AddUntilStep("wait for editor to load", () => Editor?.ReadyForUse == true);
+
+                AddStep("store selected difficulty", () =>
+                {
+                    deletedDifficultyID = EditorBeatmap.BeatmapInfo.ID;
+                    countBeforeDeletion = Beatmap.Value.BeatmapSetInfo.Beatmaps.Count;
+                    beatmapSetHashBefore = Beatmap.Value.BeatmapSetInfo.Hash;
+                });
+
+                AddStep("click File", () => this.ChildrenOfType<DrawableOsuMenuItem>().First().TriggerClick());
+
+                if (i == 11)
+                {
+                    // last difficulty shouldn't be able to be deleted.
+                    AddAssert("Delete menu item disabled", () => getDeleteMenuItem().Item.Action.Disabled);
+                }
+                else
+                {
+                    AddStep("click delete", () => getDeleteMenuItem().TriggerClick());
+                    AddUntilStep("wait for dialog", () => DialogOverlay.CurrentDialog != null);
+                    AddStep("confirm", () => InputManager.Key(Key.Number1));
+
+                    AddAssert($"difficulty {i} is deleted", () => Beatmap.Value.BeatmapSetInfo.Beatmaps.Select(b => b.ID), () => Does.Not.Contain(deletedDifficultyID));
+                    AddAssert("count decreased by one", () => Beatmap.Value.BeatmapSetInfo.Beatmaps.Count, () => Is.EqualTo(countBeforeDeletion - 1));
+                    AddAssert("set hash changed", () => Beatmap.Value.BeatmapSetInfo.Hash, () => Is.Not.EqualTo(beatmapSetHashBefore));
+                }
+            }
+        }
+
+        private DrawableOsuMenuItem getDeleteMenuItem() => this.ChildrenOfType<DrawableOsuMenuItem>()
+                                                               .Single(item => item.ChildrenOfType<SpriteText>().Any(text => text.Text.ToString().StartsWith("Delete", StringComparison.Ordinal)));
+    }
+}
--- a/osu.Game.Tests/Visual/Editing/TestSceneEditorClock.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneEditorClock.cs
@ -55,51 +55,51 @@ namespace osu.Game.Tests.Visual.Editing
        [Test]
        public void TestStopAtTrackEnd()
        {
-            AddStep("reset clock", () => Clock.Seek(0));
+            AddStep("reset clock", () => EditorClock.Seek(0));

-            AddStep("start clock", () => Clock.Start());
-            AddAssert("clock running", () => Clock.IsRunning);
+            AddStep("start clock", () => EditorClock.Start());
+            AddAssert("clock running", () => EditorClock.IsRunning);

-            AddStep("seek near end", () => Clock.Seek(Clock.TrackLength - 250));
-            AddUntilStep("clock stops", () => !Clock.IsRunning);
+            AddStep("seek near end", () => EditorClock.Seek(EditorClock.TrackLength - 250));
+            AddUntilStep("clock stops", () => !EditorClock.IsRunning);

-            AddUntilStep("clock stopped at end", () => Clock.CurrentTime, () => Is.EqualTo(Clock.TrackLength));
+            AddUntilStep("clock stopped at end", () => EditorClock.CurrentTime - EditorClock.TotalAppliedOffset, () => Is.EqualTo(EditorClock.TrackLength));

-            AddStep("start clock again", () => Clock.Start());
-            AddAssert("clock looped to start", () => Clock.IsRunning && Clock.CurrentTime < 500);
+            AddStep("start clock again", () => EditorClock.Start());
+            AddAssert("clock looped to start", () => EditorClock.IsRunning && EditorClock.CurrentTime < 500);
        }

        [Test]
        public void TestWrapWhenStoppedAtTrackEnd()
        {
-            AddStep("reset clock", () => Clock.Seek(0));
+            AddStep("reset clock", () => EditorClock.Seek(0));

-            AddStep("stop clock", () => Clock.Stop());
-            AddAssert("clock stopped", () => !Clock.IsRunning);
+            AddStep("stop clock", () => EditorClock.Stop());
+            AddAssert("clock stopped", () => !EditorClock.IsRunning);

-            AddStep("seek exactly to end", () => Clock.Seek(Clock.TrackLength));
-            AddAssert("clock stopped at end", () => Clock.CurrentTime, () => Is.EqualTo(Clock.TrackLength));
+            AddStep("seek exactly to end", () => EditorClock.Seek(EditorClock.TrackLength));
+            AddAssert("clock stopped at end", () => EditorClock.CurrentTime, () => Is.EqualTo(EditorClock.TrackLength));

-            AddStep("start clock again", () => Clock.Start());
-            AddAssert("clock looped to start", () => Clock.IsRunning && Clock.CurrentTime < 500);
+            AddStep("start clock again", () => EditorClock.Start());
+            AddAssert("clock looped to start", () => EditorClock.IsRunning && EditorClock.CurrentTime < 500);
        }

        [Test]
        public void TestClampWhenSeekOutsideBeatmapBounds()
        {
-            AddStep("stop clock", () => Clock.Stop());
+            AddStep("stop clock", () => EditorClock.Stop());

-            AddStep("seek before start time", () => Clock.Seek(-1000));
-            AddAssert("time is clamped to 0", () => Clock.CurrentTime, () => Is.EqualTo(0));
+            AddStep("seek before start time", () => EditorClock.Seek(-1000));
+            AddAssert("time is clamped to 0", () => EditorClock.CurrentTime, () => Is.EqualTo(0));

-            AddStep("seek beyond track length", () => Clock.Seek(Clock.TrackLength + 1000));
-            AddAssert("time is clamped to track length", () => Clock.CurrentTime, () => Is.EqualTo(Clock.TrackLength));
+            AddStep("seek beyond track length", () => EditorClock.Seek(EditorClock.TrackLength + 1000));
+            AddAssert("time is clamped to track length", () => EditorClock.CurrentTime, () => Is.EqualTo(EditorClock.TrackLength));

-            AddStep("seek smoothly before start time", () => Clock.SeekSmoothlyTo(-1000));
-            AddUntilStep("time is clamped to 0", () => Clock.CurrentTime, () => Is.EqualTo(0));
+            AddStep("seek smoothly before start time", () => EditorClock.SeekSmoothlyTo(-1000));
+            AddUntilStep("time is clamped to 0", () => EditorClock.CurrentTime, () => Is.EqualTo(0));

-            AddStep("seek smoothly beyond track length", () => Clock.SeekSmoothlyTo(Clock.TrackLength + 1000));
-            AddUntilStep("time is clamped to track length", () => Clock.CurrentTime, () => Is.EqualTo(Clock.TrackLength));
+            AddStep("seek smoothly beyond track length", () => EditorClock.SeekSmoothlyTo(EditorClock.TrackLength + 1000));
+            AddUntilStep("time is clamped to track length", () => EditorClock.CurrentTime, () => Is.EqualTo(EditorClock.TrackLength));
        }

        protected override void Dispose(bool isDisposing)
--- a/osu.Game.Tests/Visual/Editing/TestSceneEditorSeekSnapping.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneEditorSeekSnapping.cs
@ -28,6 +28,11 @@ namespace osu.Game.Tests.Visual.Editing
        {
            base.LoadComplete();

+            Child = new TimingPointVisualiser(Beatmap.Value.Beatmap, 5000) { Clock = EditorClock };
+        }
+
+        protected override Beatmap CreateEditorClockBeatmap()
+        {
            var testBeatmap = new Beatmap
            {
                ControlPointInfo = new ControlPointInfo(),
@ -45,9 +50,7 @@ namespace osu.Game.Tests.Visual.Editing
            testBeatmap.ControlPointInfo.Add(450, new TimingControlPoint { BeatLength = 100 });
            testBeatmap.ControlPointInfo.Add(500, new TimingControlPoint { BeatLength = 307.69230769230802 });

-            Beatmap.Value = CreateWorkingBeatmap(testBeatmap);
-
-            Child = new TimingPointVisualiser(testBeatmap, 5000) { Clock = Clock };
+            return testBeatmap;
        }

        /// <summary>
@ -59,17 +62,17 @@ namespace osu.Game.Tests.Visual.Editing
            reset();

            // Forwards
-            AddStep("Seek(0)", () => Clock.Seek(0));
+            AddStep("Seek(0)", () => EditorClock.Seek(0));
            checkTime(0);
-            AddStep("Seek(33)", () => Clock.Seek(33));
+            AddStep("Seek(33)", () => EditorClock.Seek(33));
            checkTime(33);
-            AddStep("Seek(89)", () => Clock.Seek(89));
+            AddStep("Seek(89)", () => EditorClock.Seek(89));
            checkTime(89);

            // Backwards
-            AddStep("Seek(25)", () => Clock.Seek(25));
+            AddStep("Seek(25)", () => EditorClock.Seek(25));
            checkTime(25);
-            AddStep("Seek(0)", () => Clock.Seek(0));
+            AddStep("Seek(0)", () => EditorClock.Seek(0));
            checkTime(0);
        }

@ -82,19 +85,19 @@ namespace osu.Game.Tests.Visual.Editing
        {
            reset();

-            AddStep("Seek(0), Snap", () => Clock.SeekSnapped(0));
+            AddStep("Seek(0), Snap", () => EditorClock.SeekSnapped(0));
            checkTime(0);
-            AddStep("Seek(50), Snap", () => Clock.SeekSnapped(50));
+            AddStep("Seek(50), Snap", () => EditorClock.SeekSnapped(50));
            checkTime(50);
-            AddStep("Seek(100), Snap", () => Clock.SeekSnapped(100));
+            AddStep("Seek(100), Snap", () => EditorClock.SeekSnapped(100));
            checkTime(100);
-            AddStep("Seek(175), Snap", () => Clock.SeekSnapped(175));
+            AddStep("Seek(175), Snap", () => EditorClock.SeekSnapped(175));
            checkTime(175);
-            AddStep("Seek(350), Snap", () => Clock.SeekSnapped(350));
+            AddStep("Seek(350), Snap", () => EditorClock.SeekSnapped(350));
            checkTime(350);
-            AddStep("Seek(400), Snap", () => Clock.SeekSnapped(400));
+            AddStep("Seek(400), Snap", () => EditorClock.SeekSnapped(400));
            checkTime(400);
-            AddStep("Seek(450), Snap", () => Clock.SeekSnapped(450));
+            AddStep("Seek(450), Snap", () => EditorClock.SeekSnapped(450));
            checkTime(450);
        }

@ -107,17 +110,17 @@ namespace osu.Game.Tests.Visual.Editing
        {
            reset();

-            AddStep("Seek(24), Snap", () => Clock.SeekSnapped(24));
+            AddStep("Seek(24), Snap", () => EditorClock.SeekSnapped(24));
            checkTime(0);
-            AddStep("Seek(26), Snap", () => Clock.SeekSnapped(26));
+            AddStep("Seek(26), Snap", () => EditorClock.SeekSnapped(26));
            checkTime(50);
-            AddStep("Seek(150), Snap", () => Clock.SeekSnapped(150));
+            AddStep("Seek(150), Snap", () => EditorClock.SeekSnapped(150));
            checkTime(100);
-            AddStep("Seek(170), Snap", () => Clock.SeekSnapped(170));
+            AddStep("Seek(170), Snap", () => EditorClock.SeekSnapped(170));
            checkTime(175);
-            AddStep("Seek(274), Snap", () => Clock.SeekSnapped(274));
+            AddStep("Seek(274), Snap", () => EditorClock.SeekSnapped(274));
            checkTime(175);
-            AddStep("Seek(276), Snap", () => Clock.SeekSnapped(276));
+            AddStep("Seek(276), Snap", () => EditorClock.SeekSnapped(276));
            checkTime(350);
        }

@ -129,15 +132,15 @@ namespace osu.Game.Tests.Visual.Editing
        {
            reset();

-            AddStep("SeekForward", () => Clock.SeekForward());
+            AddStep("SeekForward", () => EditorClock.SeekForward());
            checkTime(50);
-            AddStep("SeekForward", () => Clock.SeekForward());
+            AddStep("SeekForward", () => EditorClock.SeekForward());
            checkTime(100);
-            AddStep("SeekForward", () => Clock.SeekForward());
+            AddStep("SeekForward", () => EditorClock.SeekForward());
            checkTime(200);
-            AddStep("SeekForward", () => Clock.SeekForward());
+            AddStep("SeekForward", () => EditorClock.SeekForward());
            checkTime(400);
-            AddStep("SeekForward", () => Clock.SeekForward());
+            AddStep("SeekForward", () => EditorClock.SeekForward());
            checkTime(450);
        }

@ -149,17 +152,17 @@ namespace osu.Game.Tests.Visual.Editing
        {
            reset();

-            AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
+            AddStep("SeekForward, Snap", () => EditorClock.SeekForward(true));
            checkTime(50);
-            AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
+            AddStep("SeekForward, Snap", () => EditorClock.SeekForward(true));
            checkTime(100);
-            AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
+            AddStep("SeekForward, Snap", () => EditorClock.SeekForward(true));
            checkTime(175);
-            AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
+            AddStep("SeekForward, Snap", () => EditorClock.SeekForward(true));
            checkTime(350);
-            AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
+            AddStep("SeekForward, Snap", () => EditorClock.SeekForward(true));
            checkTime(400);
-            AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
+            AddStep("SeekForward, Snap", () => EditorClock.SeekForward(true));
            checkTime(450);
        }

@ -172,30 +175,30 @@ namespace osu.Game.Tests.Visual.Editing
        {
            reset();

-            AddStep("Seek(49)", () => Clock.Seek(49));
+            AddStep("Seek(49)", () => EditorClock.Seek(49));
            checkTime(49);
-            AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
+            AddStep("SeekForward, Snap", () => EditorClock.SeekForward(true));
            checkTime(50);
-            AddStep("Seek(49.999)", () => Clock.Seek(49.999));
-            AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
+            AddStep("Seek(49.999)", () => EditorClock.Seek(49.999));
+            AddStep("SeekForward, Snap", () => EditorClock.SeekForward(true));
            checkTime(100);
-            AddStep("Seek(99)", () => Clock.Seek(99));
-            AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
+            AddStep("Seek(99)", () => EditorClock.Seek(99));
+            AddStep("SeekForward, Snap", () => EditorClock.SeekForward(true));
            checkTime(100);
-            AddStep("Seek(99.999)", () => Clock.Seek(99.999));
-            AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
+            AddStep("Seek(99.999)", () => EditorClock.Seek(99.999));
+            AddStep("SeekForward, Snap", () => EditorClock.SeekForward(true));
            checkTime(150);
-            AddStep("Seek(174)", () => Clock.Seek(174));
-            AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
+            AddStep("Seek(174)", () => EditorClock.Seek(174));
+            AddStep("SeekForward, Snap", () => EditorClock.SeekForward(true));
            checkTime(175);
-            AddStep("Seek(349)", () => Clock.Seek(349));
-            AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
+            AddStep("Seek(349)", () => EditorClock.Seek(349));
+            AddStep("SeekForward, Snap", () => EditorClock.SeekForward(true));
            checkTime(350);
-            AddStep("Seek(399)", () => Clock.Seek(399));
-            AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
+            AddStep("Seek(399)", () => EditorClock.Seek(399));
+            AddStep("SeekForward, Snap", () => EditorClock.SeekForward(true));
            checkTime(400);
-            AddStep("Seek(449)", () => Clock.Seek(449));
-            AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
+            AddStep("Seek(449)", () => EditorClock.Seek(449));
+            AddStep("SeekForward, Snap", () => EditorClock.SeekForward(true));
            checkTime(450);
        }

@ -207,17 +210,17 @@ namespace osu.Game.Tests.Visual.Editing
        {
            reset();

-            AddStep("Seek(450)", () => Clock.Seek(450));
+            AddStep("Seek(450)", () => EditorClock.Seek(450));
            checkTime(450);
-            AddStep("SeekBackward", () => Clock.SeekBackward());
+            AddStep("SeekBackward", () => EditorClock.SeekBackward());
            checkTime(400);
-            AddStep("SeekBackward", () => Clock.SeekBackward());
+            AddStep("SeekBackward", () => EditorClock.SeekBackward());
            checkTime(350);
-            AddStep("SeekBackward", () => Clock.SeekBackward());
+            AddStep("SeekBackward", () => EditorClock.SeekBackward());
            checkTime(150);
-            AddStep("SeekBackward", () => Clock.SeekBackward());
+            AddStep("SeekBackward", () => EditorClock.SeekBackward());
            checkTime(50);
-            AddStep("SeekBackward", () => Clock.SeekBackward());
+            AddStep("SeekBackward", () => EditorClock.SeekBackward());
            checkTime(0);
        }

@ -229,19 +232,19 @@ namespace osu.Game.Tests.Visual.Editing
        {
            reset();

-            AddStep("Seek(450)", () => Clock.Seek(450));
+            AddStep("Seek(450)", () => EditorClock.Seek(450));
            checkTime(450);
-            AddStep("SeekBackward, Snap", () => Clock.SeekBackward(true));
+            AddStep("SeekBackward, Snap", () => EditorClock.SeekBackward(true));
            checkTime(400);
-            AddStep("SeekBackward, Snap", () => Clock.SeekBackward(true));
+            AddStep("SeekBackward, Snap", () => EditorClock.SeekBackward(true));
            checkTime(350);
-            AddStep("SeekBackward, Snap", () => Clock.SeekBackward(true));
+            AddStep("SeekBackward, Snap", () => EditorClock.SeekBackward(true));
            checkTime(175);
-            AddStep("SeekBackward, Snap", () => Clock.SeekBackward(true));
+            AddStep("SeekBackward, Snap", () => EditorClock.SeekBackward(true));
            checkTime(100);
-            AddStep("SeekBackward, Snap", () => Clock.SeekBackward(true));
+            AddStep("SeekBackward, Snap", () => EditorClock.SeekBackward(true));
            checkTime(50);
-            AddStep("SeekBackward, Snap", () => Clock.SeekBackward(true));
+            AddStep("SeekBackward, Snap", () => EditorClock.SeekBackward(true));
            checkTime(0);
        }

@ -254,18 +257,18 @@ namespace osu.Game.Tests.Visual.Editing
        {
            reset();

-            AddStep("Seek(451)", () => Clock.Seek(451));
+            AddStep("Seek(451)", () => EditorClock.Seek(451));
            checkTime(451);
-            AddStep("SeekBackward, Snap", () => Clock.SeekBackward(true));
+            AddStep("SeekBackward, Snap", () => EditorClock.SeekBackward(true));
            checkTime(450);
-            AddStep("Seek(450.999)", () => Clock.Seek(450.999));
-            AddStep("SeekBackward, Snap", () => Clock.SeekBackward(true));
+            AddStep("Seek(450.999)", () => EditorClock.Seek(450.999));
+            AddStep("SeekBackward, Snap", () => EditorClock.SeekBackward(true));
            checkTime(450);
-            AddStep("Seek(401)", () => Clock.Seek(401));
-            AddStep("SeekBackward, Snap", () => Clock.SeekBackward(true));
+            AddStep("Seek(401)", () => EditorClock.Seek(401));
+            AddStep("SeekBackward, Snap", () => EditorClock.SeekBackward(true));
            checkTime(400);
-            AddStep("Seek(401.999)", () => Clock.Seek(401.999));
-            AddStep("SeekBackward, Snap", () => Clock.SeekBackward(true));
+            AddStep("Seek(401.999)", () => EditorClock.Seek(401.999));
+            AddStep("SeekBackward, Snap", () => EditorClock.SeekBackward(true));
            checkTime(400);
        }

@ -279,37 +282,37 @@ namespace osu.Game.Tests.Visual.Editing

            double lastTime = 0;

-            AddStep("Seek(0)", () => Clock.Seek(0));
+            AddStep("Seek(0)", () => EditorClock.Seek(0));
            checkTime(0);

            for (int i = 0; i < 9; i++)
            {
                AddStep("SeekForward, Snap", () =>
                {
-                    lastTime = Clock.CurrentTime;
-                    Clock.SeekForward(true);
+                    lastTime = EditorClock.CurrentTime;
+                    EditorClock.SeekForward(true);
                });
-                AddAssert("Time > lastTime", () => Clock.CurrentTime > lastTime);
+                AddAssert("Time > lastTime", () => EditorClock.CurrentTime > lastTime);
            }

            for (int i = 0; i < 9; i++)
            {
                AddStep("SeekBackward, Snap", () =>
                {
-                    lastTime = Clock.CurrentTime;
-                    Clock.SeekBackward(true);
+                    lastTime = EditorClock.CurrentTime;
+                    EditorClock.SeekBackward(true);
                });
-                AddAssert("Time < lastTime", () => Clock.CurrentTime < lastTime);
+                AddAssert("Time < lastTime", () => EditorClock.CurrentTime < lastTime);
            }

            checkTime(0);
        }

-        private void checkTime(double expectedTime) => AddAssert($"Current time is {expectedTime}", () => Clock.CurrentTime, () => Is.EqualTo(expectedTime));
+        private void checkTime(double expectedTime) => AddUntilStep($"Current time is {expectedTime}", () => EditorClock.CurrentTime, () => Is.EqualTo(expectedTime));

        private void reset()
        {
-            AddStep("Reset", () => Clock.Seek(0));
+            AddStep("Reset", () => EditorClock.Seek(0));
        }

        private class TimingPointVisualiser : CompositeDrawable
--- a/osu.Game.Tests/Visual/Editing/TestSceneTapTimingControl.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneTapTimingControl.cs
@ -113,7 +113,7 @@ namespace osu.Game.Tests.Visual.Editing
                       .TriggerClick();
            });

-            AddUntilStep("wait for track playing", () => Clock.IsRunning);
+            AddUntilStep("wait for track playing", () => EditorClock.IsRunning);

            AddStep("click reset button", () =>
            {
@ -122,7 +122,7 @@ namespace osu.Game.Tests.Visual.Editing
                       .TriggerClick();
            });

-            AddUntilStep("wait for track stopped", () => !Clock.IsRunning);
+            AddUntilStep("wait for track stopped", () => !EditorClock.IsRunning);
        }

        protected override void Dispose(bool isDisposing)
--- a/osu.Game.Tests/Visual/Editing/TestSceneTimelineBlueprintContainer.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneTimelineBlueprintContainer.cs
@ -17,7 +17,7 @@ namespace osu.Game.Tests.Visual.Editing
        protected override void LoadComplete()
        {
            base.LoadComplete();
-            Clock.Seek(10000);
+            EditorClock.Seek(10000);
        }
    }
 }
--- a/osu.Game.Tests/Visual/Editing/TestSceneTimelineZoom.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneTimelineZoom.cs
@ -17,8 +17,6 @@ namespace osu.Game.Tests.Visual.Editing
        {
            double initialVisibleRange = 0;

-            AddUntilStep("wait for load", () => MusicController.TrackLoaded);
-
            AddStep("reset zoom", () => TimelineArea.Timeline.Zoom = 100);
            AddStep("get initial range", () => initialVisibleRange = TimelineArea.Timeline.VisibleRange);

@ -36,8 +34,6 @@ namespace osu.Game.Tests.Visual.Editing
        {
            double initialVisibleRange = 0;

-            AddUntilStep("wait for load", () => MusicController.TrackLoaded);
-
            AddStep("reset timeline size", () => TimelineArea.Timeline.Width = 1);
            AddStep("get initial range", () => initialVisibleRange = TimelineArea.Timeline.VisibleRange);

--- a/osu.Game.Tests/Visual/Editing/TestSceneTimingScreen.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneTimingScreen.cs
@ -53,7 +53,7 @@ namespace osu.Game.Tests.Visual.Editing
        [SetUpSteps]
        public void SetUpSteps()
        {
-            AddStep("Stop clock", () => Clock.Stop());
+            AddStep("Stop clock", () => EditorClock.Stop());

            AddUntilStep("wait for rows to load", () => Child.ChildrenOfType<EffectRowAttribute>().Any());
        }
@ -68,10 +68,10 @@ namespace osu.Game.Tests.Visual.Editing
            });

            AddUntilStep("Selection changed", () => timingScreen.SelectedGroup.Value.Time == 54670);
-            AddUntilStep("Ensure seeked to correct time", () => Clock.CurrentTimeAccurate == 54670);
+            AddUntilStep("Ensure seeked to correct time", () => EditorClock.CurrentTimeAccurate == 54670);

-            AddStep("Seek to just before next point", () => Clock.Seek(69000));
-            AddStep("Start clock", () => Clock.Start());
+            AddStep("Seek to just before next point", () => EditorClock.Seek(69000));
+            AddStep("Start clock", () => EditorClock.Start());

            AddUntilStep("Selection changed", () => timingScreen.SelectedGroup.Value.Time == 69670);
        }
@ -86,9 +86,9 @@ namespace osu.Game.Tests.Visual.Editing
            });

            AddUntilStep("Selection changed", () => timingScreen.SelectedGroup.Value.Time == 54670);
-            AddUntilStep("Ensure seeked to correct time", () => Clock.CurrentTimeAccurate == 54670);
+            AddUntilStep("Ensure seeked to correct time", () => EditorClock.CurrentTimeAccurate == 54670);

-            AddStep("Seek to later", () => Clock.Seek(80000));
+            AddStep("Seek to later", () => EditorClock.Seek(80000));
            AddUntilStep("Selection changed", () => timingScreen.SelectedGroup.Value.Time == 69670);
        }

--- a/osu.Game.Tests/Visual/Editing/TimelineTestScene.cs
+++ b/osu.Game.Tests/Visual/Editing/TimelineTestScene.cs
@ -3,18 +3,21 @@

 #nullable disable

+using System.Diagnostics;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.Cursor;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Compose.Components.Timeline;
+using osu.Game.Storyboards;
 using osuTK;
 using osuTK.Graphics;

@ -28,10 +31,14 @@ namespace osu.Game.Tests.Visual.Editing

        protected EditorBeatmap EditorBeatmap { get; private set; }

-        [BackgroundDependencyLoader]
-        private void load(AudioManager audio)
+        [Resolved]
+        private AudioManager audio { get; set; }
+
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null) => new WaveformTestBeatmap(audio);
+
+        protected override void LoadComplete()
        {
-            Beatmap.Value = new WaveformTestBeatmap(audio);
+            base.LoadComplete();

            var playable = Beatmap.Value.GetPlayableBeatmap(Beatmap.Value.BeatmapInfo.Ruleset);
            EditorBeatmap = new EditorBeatmap(playable);
@ -39,7 +46,10 @@ namespace osu.Game.Tests.Visual.Editing
            Dependencies.Cache(EditorBeatmap);
            Dependencies.CacheAs<IBeatSnapProvider>(EditorBeatmap);

-            Composer = playable.BeatmapInfo.Ruleset.CreateInstance().CreateHitObjectComposer().With(d => d.Alpha = 0);
+            Composer = playable.BeatmapInfo.Ruleset.CreateInstance().CreateHitObjectComposer();
+            Debug.Assert(Composer != null);
+
+            Composer.Alpha = 0;

            Add(new OsuContextMenuContainer
            {
@ -68,11 +78,11 @@ namespace osu.Game.Tests.Visual.Editing
            });
        }

-        protected override void LoadComplete()
+        [SetUpSteps]
+        public void SetUpSteps()
        {
-            base.LoadComplete();
-
-            Clock.Seek(2500);
+            AddUntilStep("wait for track loaded", () => MusicController.TrackLoaded);
+            AddStep("seek forward", () => EditorClock.Seek(2500));
        }

        public abstract Drawable CreateTestComponent();
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapSkinFallbacks.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapSkinFallbacks.cs
@ -87,7 +87,7 @@ namespace osu.Game.Tests.Visual.Gameplay
            Add(expectedComponentsAdjustmentContainer);
            expectedComponentsAdjustmentContainer.UpdateSubTree();
            var expectedInfo = expectedComponentsContainer.CreateSkinnableInfo();
-            Remove(expectedComponentsAdjustmentContainer);
+            Remove(expectedComponentsAdjustmentContainer, true);

            return almostEqual(actualInfo, expectedInfo);
        }
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneClicksPerSecondCalculator.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneClicksPerSecondCalculator.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 NUnit.Framework;
+using osu.Framework.Audio;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Testing;
+using osu.Framework.Timing;
+using osu.Game.Screens.Play;
+using osu.Game.Screens.Play.HUD.ClicksPerSecond;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneClicksPerSecondCalculator : OsuTestScene
+    {
+        private ClicksPerSecondCalculator calculator = null!;
+
+        private TestGameplayClock manualGameplayClock = null!;
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("create components", () =>
+            {
+                manualGameplayClock = new TestGameplayClock();
+
+                Child = new DependencyProvidingContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    CachedDependencies = new (Type, object)[] { (typeof(IGameplayClock), manualGameplayClock) },
+                    Children = new Drawable[]
+                    {
+                        calculator = new ClicksPerSecondCalculator(),
+                        new DependencyProvidingContainer
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            CachedDependencies = new (Type, object)[] { (typeof(ClicksPerSecondCalculator), calculator) },
+                            Child = new ClicksPerSecondCounter
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Scale = new Vector2(5),
+                            }
+                        }
+                    },
+                };
+            });
+        }
+
+        [Test]
+        public void TestBasicConsistency()
+        {
+            seek(1000);
+            AddStep("add inputs in past", () => addInputs(new double[] { 0, 100, 200, 300, 400, 500, 600, 700, 800, 900 }));
+            checkClicksPerSecondValue(10);
+        }
+
+        [Test]
+        public void TestRateAdjustConsistency()
+        {
+            seek(1000);
+            AddStep("add inputs in past", () => addInputs(new double[] { 0, 100, 200, 300, 400, 500, 600, 700, 800, 900 }));
+            checkClicksPerSecondValue(10);
+            AddStep("set rate 0.5x", () => manualGameplayClock.TrueGameplayRate = 0.5);
+            checkClicksPerSecondValue(5);
+        }
+
+        [Test]
+        public void TestInputsDiscardedOnRewind()
+        {
+            seek(1000);
+            AddStep("add inputs in past", () => addInputs(new double[] { 0, 100, 200, 300, 400, 500, 600, 700, 800, 900 }));
+            checkClicksPerSecondValue(10);
+            seek(500);
+            checkClicksPerSecondValue(6);
+            seek(1000);
+            checkClicksPerSecondValue(6);
+        }
+
+        private void checkClicksPerSecondValue(int i) => AddAssert("clicks/s is correct", () => calculator.Value, () => Is.EqualTo(i));
+
+        private void seekClockImmediately(double time) => manualGameplayClock.CurrentTime = time;
+
+        private void seek(double time) => AddStep($"Seek to {time}ms", () => seekClockImmediately(time));
+
+        private void addInputs(IEnumerable<double> inputs)
+        {
+            double baseTime = manualGameplayClock.CurrentTime;
+
+            foreach (double timestamp in inputs)
+            {
+                seekClockImmediately(timestamp);
+                calculator.AddInputTimestamp();
+            }
+
+            seekClockImmediately(baseTime);
+        }
+
+        private class TestGameplayClock : IGameplayClock
+        {
+            public double CurrentTime { get; set; }
+
+            public double Rate => 1;
+
+            public bool IsRunning => true;
+
+            public double TrueGameplayRate { set => adjustableAudioComponent.Tempo.Value = value; }
+
+            private readonly AudioAdjustments adjustableAudioComponent = new AudioAdjustments();
+
+            public void ProcessFrame()
+            {
+            }
+
+            public double ElapsedFrameTime => throw new NotImplementedException();
+            public double FramesPerSecond => throw new NotImplementedException();
+            public FrameTimeInfo TimeInfo => throw new NotImplementedException();
+            public double StartTime => throw new NotImplementedException();
+
+            public IAdjustableAudioComponent AdjustmentsFromMods => adjustableAudioComponent;
+
+            public IEnumerable<double> NonGameplayAdjustments => throw new NotImplementedException();
+            public IBindable<bool> IsPaused => throw new NotImplementedException();
+        }
+    }
+}
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneDrawableStoryboardSprite.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneDrawableStoryboardSprite.cs
@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

-#nullable disable
-
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
@ -73,6 +71,18 @@ namespace osu.Game.Tests.Visual.Gameplay
            AddAssert("origin flipped", () => sprites.All(s => s.Origin == Anchor.BottomRight));
        }

+        [Test]
+        public void TestZeroScale()
+        {
+            const string lookup_name = "hitcircleoverlay";
+
+            AddStep("allow skin lookup", () => storyboard.UseSkinSprites = true);
+            AddStep("create sprites", () => SetContents(_ => createSprite(lookup_name, Anchor.TopLeft, Vector2.Zero)));
+            AddAssert("sprites present", () => sprites.All(s => s.IsPresent));
+            AddStep("scale sprite", () => sprites.ForEach(s => s.VectorScale = new Vector2(0, 1)));
+            AddAssert("sprites not present", () => sprites.All(s => !s.IsPresent));
+        }
+
        [Test]
        public void TestNegativeScale()
        {
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneLeadIn.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneLeadIn.cs
@ -66,18 +66,20 @@ namespace osu.Game.Tests.Visual.Gameplay
        [TestCase(-10000, -10000, true)]
        public void TestStoryboardProducesCorrectStartTimeFadeInAfterOtherEvents(double firstStoryboardEvent, double expectedStartTime, bool addEventToLoop)
        {
+            const double loop_start_time = -20000;
+
            var storyboard = new Storyboard();

            var sprite = new StoryboardSprite("unknown", Anchor.TopLeft, Vector2.Zero);

            // these should be ignored as we have an alpha visibility blocker proceeding this command.
-            sprite.TimelineGroup.Scale.Add(Easing.None, -20000, -18000, 0, 1);
-            var loopGroup = sprite.AddLoop(-20000, 50);
-            loopGroup.Scale.Add(Easing.None, -20000, -18000, 0, 1);
+            sprite.TimelineGroup.Scale.Add(Easing.None, loop_start_time, -18000, 0, 1);
+            var loopGroup = sprite.AddLoop(loop_start_time, 50);
+            loopGroup.Scale.Add(Easing.None, loop_start_time, -18000, 0, 1);

            var target = addEventToLoop ? loopGroup : sprite.TimelineGroup;
-            double targetTime = addEventToLoop ? 20000 : 0;
-            target.Alpha.Add(Easing.None, targetTime + firstStoryboardEvent, targetTime + firstStoryboardEvent + 500, 0, 1);
+            double loopRelativeOffset = addEventToLoop ? -loop_start_time : 0;
+            target.Alpha.Add(Easing.None, loopRelativeOffset + firstStoryboardEvent, loopRelativeOffset + firstStoryboardEvent + 500, 0, 1);

            // these should be ignored due to being in the future.
            sprite.TimelineGroup.Alpha.Add(Easing.None, 18000, 20000, 0, 1);
--- a/osu.Game.Tests/Visual/Gameplay/TestScenePause.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestScenePause.cs
@ -66,7 +66,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                Player.OnUpdate += _ =>
                {
                    double currentTime = Player.GameplayClockContainer.CurrentTime;
-                    alwaysGoingForward &= currentTime >= lastTime;
+                    alwaysGoingForward &= currentTime >= lastTime - 500;
                    lastTime = currentTime;
                };
            });
@ -77,7 +77,7 @@ namespace osu.Game.Tests.Visual.Gameplay

            resumeAndConfirm();

-            AddAssert("time didn't go backwards", () => alwaysGoingForward);
+            AddAssert("time didn't go too far backwards", () => alwaysGoingForward);

            AddStep("reset offset", () => LocalConfig.SetValue(OsuSetting.AudioOffset, 0.0));
        }
@ -90,6 +90,9 @@ namespace osu.Game.Tests.Visual.Gameplay
            AddAssert("player not playing", () => !Player.LocalUserPlaying.Value);

            resumeAndConfirm();
+
+            AddAssert("Resumed without seeking forward", () => Player.LastResumeTime, () => Is.LessThanOrEqualTo(Player.LastPauseTime));
+
            AddUntilStep("player playing", () => Player.LocalUserPlaying.Value);
        }

@ -367,7 +370,7 @@ namespace osu.Game.Tests.Visual.Gameplay

        private void confirmNoTrackAdjustments()
        {
-            AddAssert("track has no adjustments", () => Beatmap.Value.Track.AggregateFrequency.Value == 1);
+            AddUntilStep("track has no adjustments", () => Beatmap.Value.Track.AggregateFrequency.Value, () => Is.EqualTo(1));
        }

        private void restart() => AddStep("restart", () => Player.Restart());
@ -378,7 +381,16 @@ namespace osu.Game.Tests.Visual.Gameplay
            AddAssert("pause overlay " + (isShown ? "shown" : "hidden"), () => Player.PauseOverlayVisible == isShown);

        private void confirmClockRunning(bool isRunning) =>
-            AddUntilStep("clock " + (isRunning ? "running" : "stopped"), () => Player.GameplayClockContainer.IsRunning == isRunning);
+            AddUntilStep("clock " + (isRunning ? "running" : "stopped"), () =>
+            {
+                bool completed = Player.GameplayClockContainer.IsRunning == isRunning;
+
+                if (completed)
+                {
+                }
+
+                return completed;
+            });

        protected override bool AllowFail => true;

@ -386,6 +398,9 @@ namespace osu.Game.Tests.Visual.Gameplay

        protected class PausePlayer : TestPlayer
        {
+            public double LastPauseTime { get; private set; }
+            public double LastResumeTime { get; private set; }
+
            public bool FailOverlayVisible => FailOverlay.State.Value == Visibility.Visible;

            public bool PauseOverlayVisible => PauseOverlay.State.Value == Visibility.Visible;
@ -399,6 +414,23 @@ namespace osu.Game.Tests.Visual.Gameplay
                base.OnEntering(e);
                GameplayClockContainer.Stop();
            }
+
+            private bool? isRunning;
+
+            protected override void UpdateAfterChildren()
+            {
+                base.UpdateAfterChildren();
+
+                if (GameplayClockContainer.IsRunning != isRunning)
+                {
+                    isRunning = GameplayClockContainer.IsRunning;
+
+                    if (isRunning.Value)
+                        LastResumeTime = GameplayClockContainer.CurrentTime;
+                    else
+                        LastPauseTime = GameplayClockContainer.CurrentTime;
+                }
+            }
        }
    }
 }
--- a/Show More
+++ b/Show More