Merge branch 'ppy:master' into Colour_hit_meter_improved

osu.Android.props

@@ -52,7 +52,7 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="ppy.osu.Game.Resources" Version="2022.831.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2022.825.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. -->

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());
+        }
+    }
+}

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)

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());

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());

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,
+        }
+    }
+}

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);
 

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;
             }
         }

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);

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;
@@ -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)})"
                 )
             )
         };

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)})";
+        }
     }
 }

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;

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));
             }
         }
 

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);
             });

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:

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;
+        }
     }
 }

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

@@ -362,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));
             });
         }
 

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;
 

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)

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;
+        }
     }
 }

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,
+                })
+            {
+            }
+        }
+    }
+}

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);
+        }
+    }
+}

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);
+        }
+    }
+}

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));
+        }
+    }
+}

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
         {

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);
         }
 

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
-                }
-            }
-        };
-    }
-}

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;
-        }
-    }
-}

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);
         }
     }
 }

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);
-            }
-        }
-    }
-}

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;
     }
 }

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;

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:

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)

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);
             }
         }
 

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());
         }

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

osu.Game.Rulesets.Taiko/TaikoRuleset.cs

@@ -199,11 +199,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);

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);

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)]

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

@@ -117,6 +117,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()
         {

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>();

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));
             }
         }
     }

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

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>

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());
             });

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();
+        }
     }
 }

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)
                 };
             });

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)));

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)));
+    }
+}

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);
         }

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();
+        }
+    }
+}

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()
         {

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);

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

@@ -370,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());

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

@@ -301,7 +301,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddAssert("check for notification", () => notificationOverlay.UnreadCount.Value, () => Is.EqualTo(1));
 
-            clickNotificationIfAny();
+            clickNotification();
 
             AddAssert("check " + volumeName, assert);
 
@@ -370,8 +370,12 @@ namespace osu.Game.Tests.Visual.Gameplay
                 batteryInfo.SetChargeLevel(chargeLevel);
             }));
             AddUntilStep("wait for player", () => player?.LoadState == LoadState.Ready);
-            AddAssert($"notification {(shouldWarn ? "triggered" : "not triggered")}", () => notificationOverlay.UnreadCount.Value == (shouldWarn ? 1 : 0));
-            clickNotificationIfAny();
+
+            if (shouldWarn)
+                clickNotification();
+            else
+                AddAssert("notification not triggered", () => notificationOverlay.UnreadCount.Value == 0);
+
             AddUntilStep("wait for player load", () => player.IsLoaded);
         }
 
@@ -436,9 +440,13 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddUntilStep("skip button not visible", () => !checkSkipButtonVisible());
         }
 
-        private void clickNotificationIfAny()
+        private void clickNotification()
         {
-            AddStep("click notification", () => notificationOverlay.ChildrenOfType<Notification>().FirstOrDefault()?.TriggerClick());
+            Notification notification = null;
+
+            AddUntilStep("wait for notification", () => (notification = notificationOverlay.ChildrenOfType<Notification>().FirstOrDefault()) != null);
+            AddStep("open notification overlay", () => notificationOverlay.Show());
+            AddStep("click notification", () => notification.TriggerClick());
         }
 
         private EpilepsyWarning getWarning() => loader.ChildrenOfType<EpilepsyWarning>().SingleOrDefault();

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

@@ -81,9 +81,11 @@ namespace osu.Game.Tests.Visual.Gameplay
             CreateTest();
 
             AddUntilStep("fail screen displayed", () => Player.ChildrenOfType<FailOverlay>().First().State.Value == Visibility.Visible);
+            AddUntilStep("wait for button clickable", () => Player.ChildrenOfType<SaveFailedScoreButton>().First().ChildrenOfType<OsuClickableContainer>().First().Enabled.Value);
+
             AddUntilStep("score not in database", () => Realm.Run(r => r.Find<ScoreInfo>(Player.Score.ScoreInfo.ID) == null));
             AddStep("click save button", () => Player.ChildrenOfType<SaveFailedScoreButton>().First().ChildrenOfType<OsuClickableContainer>().First().TriggerClick());
-            AddUntilStep("score not in database", () => Realm.Run(r => r.Find<ScoreInfo>(Player.Score.ScoreInfo.ID) != null));
+            AddUntilStep("score in database", () => Realm.Run(r => r.Find<ScoreInfo>(Player.Score.ScoreInfo.ID) != null));
         }
 
         [Test]

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

@@ -202,7 +202,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddUntilStep("wait for load", () => downloadButton.IsLoaded);
 
-            AddAssert("state is not downloaded", () => downloadButton.State.Value == DownloadState.NotDownloaded);
+            AddAssert("state is unknown", () => downloadButton.State.Value == DownloadState.Unknown);
             AddAssert("button is not enabled", () => !downloadButton.ChildrenOfType<DownloadButton>().First().Enabled.Value);
         }
 

osu.Game.Tests/Visual/Gameplay/TestSceneSkinEditor.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.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
@@ -22,7 +20,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 {
     public class TestSceneSkinEditor : PlayerTestScene
     {
-        private SkinEditor skinEditor;
+        private SkinEditor? skinEditor;
 
         protected override bool Autoplay => true;
 
@@ -42,29 +40,33 @@ namespace osu.Game.Tests.Visual.Gameplay
                 Player.ScaleTo(0.4f);
                 LoadComponentAsync(skinEditor = new SkinEditor(Player), Add);
             });
-            AddUntilStep("wait for loaded", () => skinEditor.IsLoaded);
+            AddUntilStep("wait for loaded", () => skinEditor!.IsLoaded);
         }
 
         [Test]
         public void TestToggleEditor()
         {
-            AddToggleStep("toggle editor visibility", _ => skinEditor.ToggleVisibility());
+            AddToggleStep("toggle editor visibility", _ => skinEditor!.ToggleVisibility());
         }
 
         [Test]
         public void TestEditComponent()
         {
-            BarHitErrorMeter hitErrorMeter = null;
+            BarHitErrorMeter hitErrorMeter = null!;
 
             AddStep("select bar hit error blueprint", () =>
             {
                 var blueprint = skinEditor.ChildrenOfType<SkinBlueprint>().First(b => b.Item is BarHitErrorMeter);
 
                 hitErrorMeter = (BarHitErrorMeter)blueprint.Item;
-                skinEditor.SelectedComponents.Clear();
+                skinEditor!.SelectedComponents.Clear();
                 skinEditor.SelectedComponents.Add(blueprint.Item);
             });
 
+            AddStep("move by keyboard", () => InputManager.Key(Key.Right));
+
+            AddAssert("hitErrorMeter moved", () => hitErrorMeter.X != 0);
+
             AddAssert("value is default", () => hitErrorMeter.JudgementLineThickness.IsDefault);
 
             AddStep("hover first slider", () =>

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

@@ -63,7 +63,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             base.TearDownSteps();
             AddStep("stop watching user", () => spectatorClient.StopWatchingUser(dummy_user_id));
-            AddStep("remove test spectator client", () => Remove(spectatorClient));
+            AddStep("remove test spectator client", () => Remove(spectatorClient, false));
         }
     }
 }

osu.Game.Tests/Visual/Gameplay/TestSceneStoryboard.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;
@@ -24,8 +22,9 @@ namespace osu.Game.Tests.Visual.Gameplay
     [TestFixture]
     public class TestSceneStoryboard : OsuTestScene
     {
-        private Container<DrawableStoryboard> storyboardContainer;
-        private DrawableStoryboard storyboard;
+        private Container<DrawableStoryboard> storyboardContainer = null!;
+
+        private DrawableStoryboard? storyboard;
 
         [Test]
         public void TestStoryboard()
@@ -40,7 +39,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestStoryboardMissingVideo()
         {
-            AddStep("Load storyboard with missing video", loadStoryboardNoVideo);
+            AddStep("Load storyboard with missing video", () => loadStoryboard("storyboard_no_video.osu"));
         }
 
         [BackgroundDependencyLoader]
@@ -77,53 +76,44 @@ namespace osu.Game.Tests.Visual.Gameplay
             Beatmap.BindValueChanged(beatmapChanged, true);
         }
 
-        private void beatmapChanged(ValueChangedEvent<WorkingBeatmap> e) => loadStoryboard(e.NewValue);
+        private void beatmapChanged(ValueChangedEvent<WorkingBeatmap> e) => loadStoryboard(e.NewValue.Storyboard);
 
         private void restart()
         {
             var track = Beatmap.Value.Track;
 
             track.Reset();
-            loadStoryboard(Beatmap.Value);
+            loadStoryboard(Beatmap.Value.Storyboard);
             track.Start();
         }
 
-        private void loadStoryboard(IWorkingBeatmap working)
+        private void loadStoryboard(Storyboard toLoad)
         {
             if (storyboard != null)
-                storyboardContainer.Remove(storyboard);
+                storyboardContainer.Remove(storyboard, true);
 
             var decoupledClock = new DecoupleableInterpolatingFramedClock { IsCoupled = true };
             storyboardContainer.Clock = decoupledClock;
 
-            storyboard = working.Storyboard.CreateDrawable(SelectedMods.Value);
+            storyboard = toLoad.CreateDrawable(SelectedMods.Value);
             storyboard.Passing = false;
 
-            storyboardContainer.Add(storyboard);
-            decoupledClock.ChangeSource(working.Track);
-        }
-
-        private void loadStoryboardNoVideo()
-        {
-            if (storyboard != null)
-                storyboardContainer.Remove(storyboard);
-
-            var decoupledClock = new DecoupleableInterpolatingFramedClock { IsCoupled = true };
-            storyboardContainer.Clock = decoupledClock;
-
-            Storyboard sb;
-
-            using (var str = TestResources.OpenResource("storyboard_no_video.osu"))
-            using (var bfr = new LineBufferedReader(str))
-            {
-                var decoder = new LegacyStoryboardDecoder();
-                sb = decoder.Decode(bfr);
-            }
-
-            storyboard = sb.CreateDrawable(SelectedMods.Value);
-
             storyboardContainer.Add(storyboard);
             decoupledClock.ChangeSource(Beatmap.Value.Track);
         }
+
+        private void loadStoryboard(string filename)
+        {
+            Storyboard loaded;
+
+            using (var str = TestResources.OpenResource(filename))
+            using (var bfr = new LineBufferedReader(str))
+            {
+                var decoder = new LegacyStoryboardDecoder();
+                loaded = decoder.Decode(bfr);
+            }
+
+            loadStoryboard(loaded);
+        }
     }
 }

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

@@ -62,8 +62,8 @@ namespace osu.Game.Tests.Visual.Menus
         [SetUp]
         public void SetUp() => Schedule(() =>
         {
-            Remove(nowPlayingOverlay);
-            Remove(volumeOverlay);
+            Remove(nowPlayingOverlay, false);
+            Remove(volumeOverlay, false);
 
             Children = new Drawable[]
             {

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

@@ -91,8 +91,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                                          break;
 
                                      case StopCountdownRequest:
-                                         multiplayerRoom.Countdown = null;
-                                         raiseRoomUpdated();
+                                         clearRoomCountdown();
                                          break;
                                  }
                              });
@@ -244,14 +243,14 @@ namespace osu.Game.Tests.Visual.Multiplayer
             });
 
             AddStep("start countdown", () => multiplayerClient.Object.SendMatchRequest(new StartMatchCountdownRequest { Duration = TimeSpan.FromMinutes(1) }).WaitSafely());
-            AddUntilStep("countdown started", () => multiplayerRoom.Countdown != null);
+            AddUntilStep("countdown started", () => multiplayerRoom.ActiveCountdowns.Any());
 
             AddStep("transfer host to local user", () => transferHost(localUser));
             AddUntilStep("local user is host", () => multiplayerRoom.Host?.Equals(multiplayerClient.Object.LocalUser) == true);
 
             ClickButtonWhenEnabled<MultiplayerReadyButton>();
             checkLocalUserState(MultiplayerUserState.Ready);
-            AddAssert("countdown still active", () => multiplayerRoom.Countdown != null);
+            AddAssert("countdown still active", () => multiplayerRoom.ActiveCountdowns.Any());
         }
 
         [Test]
@@ -392,7 +391,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         private void setRoomCountdown(TimeSpan duration)
         {
-            multiplayerRoom.Countdown = new MatchStartCountdown { TimeRemaining = duration };
+            multiplayerRoom.ActiveCountdowns.Add(new MatchStartCountdown { TimeRemaining = duration });
+            raiseRoomUpdated();
+        }
+
+        private void clearRoomCountdown()
+        {
+            multiplayerRoom.ActiveCountdowns.Clear();
             raiseRoomUpdated();
         }
 

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

@@ -13,9 +13,11 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
+using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
+using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.UI;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Spectate;
 using osu.Game.Screens.Play;
@@ -332,6 +334,18 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddUntilStep("player 2 playing from correct point in time", () => getPlayer(PLAYER_2_ID).ChildrenOfType<DrawableRuleset>().Single().FrameStableClock.CurrentTime > 30000);
         }
 
+        [Test]
+        public void TestGameplayRateAdjust()
+        {
+            start(getPlayerIds(4), mods: new[] { new APIMod(new OsuModDoubleTime()) });
+
+            loadSpectateScreen();
+
+            sendFrames(getPlayerIds(4), 300);
+
+            AddUntilStep("wait for correct track speed", () => Beatmap.Value.Track.Rate, () => Is.EqualTo(1.5));
+        }
+
         [Test]
         public void TestPlayersLeaveWhileSpectating()
         {
@@ -420,7 +434,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         private void start(int userId, int? beatmapId = null) => start(new[] { userId }, beatmapId);
 
-        private void start(int[] userIds, int? beatmapId = null)
+        private void start(int[] userIds, int? beatmapId = null, APIMod[]? mods = null)
         {
             AddStep("start play", () =>
             {
@@ -429,10 +443,11 @@ namespace osu.Game.Tests.Visual.Multiplayer
                     var user = new MultiplayerRoomUser(id)
                     {
                         User = new APIUser { Id = id },
+                        Mods = mods ?? Array.Empty<APIMod>(),
                     };
 
-                    OnlinePlayDependencies.MultiplayerClient.AddUser(user.User, true);
-                    SpectatorClient.SendStartPlay(id, beatmapId ?? importedBeatmapId);
+                    OnlinePlayDependencies.MultiplayerClient.AddUser(user, true);
+                    SpectatorClient.SendStartPlay(id, beatmapId ?? importedBeatmapId, mods);
 
                     playingUsers.Add(user);
                 }

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

@@ -19,7 +19,6 @@ using osu.Game.Database;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays.Mods;
 using osu.Game.Rulesets;
-using osu.Game.Rulesets.Catch;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
@@ -68,37 +67,6 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddUntilStep("wait for present", () => songSelect.IsCurrentScreen() && songSelect.BeatmapSetsLoaded);
         }
 
-        [Test]
-        public void TestBeatmapRevertedOnExitIfNoSelection()
-        {
-            BeatmapInfo selectedBeatmap = null;
-
-            AddStep("select beatmap",
-                () => songSelect.Carousel.SelectBeatmap(selectedBeatmap = beatmaps.Where(beatmap => beatmap.Ruleset.OnlineID == new OsuRuleset().LegacyID).ElementAt(1)));
-            AddUntilStep("wait for selection", () => Beatmap.Value.BeatmapInfo.Equals(selectedBeatmap));
-
-            AddStep("exit song select", () => songSelect.Exit());
-            AddAssert("beatmap reverted", () => Beatmap.IsDefault);
-        }
-
-        [Test]
-        public void TestModsRevertedOnExitIfNoSelection()
-        {
-            AddStep("change mods", () => SelectedMods.Value = new[] { new OsuModDoubleTime() });
-
-            AddStep("exit song select", () => songSelect.Exit());
-            AddAssert("mods reverted", () => SelectedMods.Value.Count == 0);
-        }
-
-        [Test]
-        public void TestRulesetRevertedOnExitIfNoSelection()
-        {
-            AddStep("change ruleset", () => Ruleset.Value = new CatchRuleset().RulesetInfo);
-
-            AddStep("exit song select", () => songSelect.Exit());
-            AddAssert("ruleset reverted", () => Ruleset.Value.Equals(new OsuRuleset().RulesetInfo));
-        }
-
         [Test]
         public void TestBeatmapConfirmed()
         {
@@ -152,8 +120,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             public new BeatmapCarousel Carousel => base.Carousel;
 
-            public TestMultiplayerMatchSongSelect(Room room, WorkingBeatmap beatmap = null, RulesetInfo ruleset = null)
-                : base(room, null, beatmap, ruleset)
+            public TestMultiplayerMatchSongSelect(Room room)
+                : base(room)
             {
             }
         }

osu.Game.Tests/Visual/Navigation/TestSceneStartupImport.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.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
@@ -13,7 +11,7 @@ namespace osu.Game.Tests.Visual.Navigation
 {
     public class TestSceneStartupImport : OsuGameTestScene
     {
-        private string importFilename;
+        private string? importFilename;
 
         protected override TestOsuGame CreateTestGame() => new TestOsuGame(LocalStorage, API, new[] { importFilename });
 

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

@@ -34,7 +34,7 @@ namespace osu.Game.Tests.Visual.Navigation
 
             AddStep("force save config", () => Game.LocalConfig.Save());
 
-            AddStep("remove game", () => Remove(Game));
+            AddStep("remove game", () => Remove(Game, true));
 
             AddStep("create game again", CreateGame);
 

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

@@ -60,7 +60,7 @@ namespace osu.Game.Tests.Visual.Online
                             {
                                 if (selected.Text == mod.Acronym)
                                 {
-                                    selectedMods.Remove(selected);
+                                    selectedMods.Remove(selected, true);
                                     break;
                                 }
                             }

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

@@ -154,7 +154,7 @@ namespace osu.Game.Tests.Visual.Online
             });
         }
 
-        private int onlineID = 1;
+        private ulong onlineID = 1;
 
         private APIScoresCollection createScores()
         {

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -20,7 +18,7 @@ namespace osu.Game.Tests.Visual.Ranking
 {
     public class TestSceneHitEventTimingDistributionGraph : OsuTestScene
     {
-        private HitEventTimingDistributionGraph graph;
+        private HitEventTimingDistributionGraph graph = null!;
 
         private static readonly HitObject placeholder_object = new HitCircle();
 
@@ -43,6 +41,65 @@ namespace osu.Game.Tests.Visual.Ranking
             createTest(Enumerable.Range(-150, 300).Select(i => new HitEvent(i / 50f, HitResult.Perfect, placeholder_object, placeholder_object, null)).ToList());
         }
 
+        [Test]
+        public void TestSparse()
+        {
+            createTest(new List<HitEvent>
+            {
+                new HitEvent(-7, HitResult.Perfect, placeholder_object, placeholder_object, null),
+                new HitEvent(-6, HitResult.Perfect, placeholder_object, placeholder_object, null),
+                new HitEvent(-5, HitResult.Perfect, placeholder_object, placeholder_object, null),
+                new HitEvent(5, HitResult.Perfect, placeholder_object, placeholder_object, null),
+                new HitEvent(6, HitResult.Perfect, placeholder_object, placeholder_object, null),
+                new HitEvent(7, HitResult.Perfect, placeholder_object, placeholder_object, null),
+            });
+        }
+
+        [Test]
+        public void TestVariousTypesOfHitResult()
+        {
+            createTest(CreateDistributedHitEvents(0, 50).Select(h =>
+            {
+                double offset = Math.Abs(h.TimeOffset);
+                HitResult result = offset > 36 ? HitResult.Miss
+                    : offset > 32 ? HitResult.Meh
+                    : offset > 24 ? HitResult.Ok
+                    : offset > 16 ? HitResult.Good
+                    : offset > 8 ? HitResult.Great
+                    : HitResult.Perfect;
+                return new HitEvent(h.TimeOffset, result, placeholder_object, placeholder_object, null);
+            }).ToList());
+        }
+
+        [Test]
+        public void TestMultipleWindowsOfHitResult()
+        {
+            var wide = CreateDistributedHitEvents(0, 50).Select(h =>
+            {
+                double offset = Math.Abs(h.TimeOffset);
+                HitResult result = offset > 36 ? HitResult.Miss
+                    : offset > 32 ? HitResult.Meh
+                    : offset > 24 ? HitResult.Ok
+                    : offset > 16 ? HitResult.Good
+                    : offset > 8 ? HitResult.Great
+                    : HitResult.Perfect;
+
+                return new HitEvent(h.TimeOffset, result, placeholder_object, placeholder_object, null);
+            });
+            var narrow = CreateDistributedHitEvents(0, 50).Select(h =>
+            {
+                double offset = Math.Abs(h.TimeOffset);
+                HitResult result = offset > 25 ? HitResult.Miss
+                    : offset > 20 ? HitResult.Meh
+                    : offset > 15 ? HitResult.Ok
+                    : offset > 10 ? HitResult.Good
+                    : offset > 5 ? HitResult.Great
+                    : HitResult.Perfect;
+                return new HitEvent(h.TimeOffset, result, placeholder_object, placeholder_object, null);
+            });
+            createTest(wide.Concat(narrow).ToList());
+        }
+
         [Test]
         public void TestZeroTimeOffset()
         {

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

@@ -173,7 +173,7 @@ namespace osu.Game.Tests.Visual.SongSelect
                     if (isIterating)
                         AddUntilStep("selection changed", () => !carousel.SelectedBeatmapInfo?.Equals(selection) == true);
                     else
-                        AddUntilStep("selection not changed", () => carousel.SelectedBeatmapInfo.Equals(selection));
+                        AddUntilStep("selection not changed", () => carousel.SelectedBeatmapInfo?.Equals(selection) == true);
                 }
             }
         }
@@ -382,7 +382,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             // buffer the selection
             setSelected(3, 2);
 
-            AddStep("get search text", () => searchText = carousel.SelectedBeatmapSet.Metadata.Title);
+            AddStep("get search text", () => searchText = carousel.SelectedBeatmapSet!.Metadata.Title);
 
             setSelected(1, 3);
 
@@ -701,7 +701,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             setSelected(2, 1);
             AddAssert("Selection is non-null", () => currentSelection != null);
 
-            AddStep("Remove selected", () => carousel.RemoveBeatmapSet(carousel.SelectedBeatmapSet));
+            AddStep("Remove selected", () => carousel.RemoveBeatmapSet(carousel.SelectedBeatmapSet!));
             waitForSelection(2);
 
             AddStep("Remove first", () => carousel.RemoveBeatmapSet(carousel.BeatmapSets.First()));
@@ -804,7 +804,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddStep("filter to ruleset 0", () =>
                 carousel.Filter(new FilterCriteria { Ruleset = rulesets.AvailableRulesets.ElementAt(0) }, false));
             AddStep("select filtered map skipping filtered", () => carousel.SelectBeatmap(testMixed.Beatmaps[1], false));
-            AddAssert("unfiltered beatmap not selected", () => carousel.SelectedBeatmapInfo.Ruleset.OnlineID == 0);
+            AddAssert("unfiltered beatmap not selected", () => carousel.SelectedBeatmapInfo?.Ruleset.OnlineID == 0);
 
             AddStep("remove mixed set", () =>
             {
@@ -854,7 +854,7 @@ namespace osu.Game.Tests.Visual.SongSelect
                 AddStep("Restore no filter", () =>
                 {
                     carousel.Filter(new FilterCriteria(), false);
-                    eagerSelectedIDs.Add(carousel.SelectedBeatmapSet.ID);
+                    eagerSelectedIDs.Add(carousel.SelectedBeatmapSet!.ID);
                 });
             }
 
@@ -899,10 +899,10 @@ namespace osu.Game.Tests.Visual.SongSelect
                 AddStep("Restore different ruleset filter", () =>
                 {
                     carousel.Filter(new FilterCriteria { Ruleset = rulesets.GetRuleset(1) }, false);
-                    eagerSelectedIDs.Add(carousel.SelectedBeatmapSet.ID);
+                    eagerSelectedIDs.Add(carousel.SelectedBeatmapSet!.ID);
                 });
 
-                AddAssert("selection changed", () => !carousel.SelectedBeatmapInfo.Equals(manySets.First().Beatmaps.First()));
+                AddAssert("selection changed", () => !carousel.SelectedBeatmapInfo!.Equals(manySets.First().Beatmaps.First()));
             }
 
             AddAssert("Selection was random", () => eagerSelectedIDs.Count > 2);

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

@@ -98,7 +98,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
                 OsuLogo logo = new OsuLogo { Scale = new Vector2(0.15f) };
 
-                Remove(testDifficultyCache);
+                Remove(testDifficultyCache, false);
 
                 Children = new Drawable[]
                 {

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

@@ -1,10 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading.Tasks;
 using NUnit.Framework;
@@ -13,6 +12,7 @@ using osu.Framework.Audio;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions;
 using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Platform;
 using osu.Framework.Screens;
@@ -46,11 +46,12 @@ namespace osu.Game.Tests.Visual.SongSelect
     [TestFixture]
     public class TestScenePlaySongSelect : ScreenTestScene
     {
-        private BeatmapManager manager;
-        private RulesetStore rulesets;
-        private MusicController music;
-        private WorkingBeatmap defaultBeatmap;
-        private TestSongSelect songSelect;
+        private BeatmapManager manager = null!;
+        private RulesetStore rulesets = null!;
+        private MusicController music = null!;
+        private WorkingBeatmap defaultBeatmap = null!;
+        private OsuConfigManager config = null!;
+        private TestSongSelect? songSelect;
 
         [BackgroundDependencyLoader]
         private void load(GameHost host, AudioManager audio)
@@ -69,8 +70,6 @@ namespace osu.Game.Tests.Visual.SongSelect
             Dependencies.Cache(config = new OsuConfigManager(LocalStorage));
         }
 
-        private OsuConfigManager config;
-
         public override void SetUpSteps()
         {
             base.SetUpSteps();
@@ -85,7 +84,7 @@ namespace osu.Game.Tests.Visual.SongSelect
                 songSelect = null;
             });
 
-            AddStep("delete all beatmaps", () => manager?.Delete());
+            AddStep("delete all beatmaps", () => manager.Delete());
         }
 
         [Test]
@@ -98,7 +97,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             addRulesetImportStep(0);
             AddUntilStep("wait for placeholder hidden", () => getPlaceholder()?.State.Value == Visibility.Hidden);
 
-            AddStep("delete all beatmaps", () => manager?.Delete());
+            AddStep("delete all beatmaps", () => manager.Delete());
             AddUntilStep("wait for placeholder visible", () => getPlaceholder()?.State.Value == Visibility.Visible);
         }
 
@@ -144,7 +143,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             createSongSelect();
 
-            AddAssert("filter count is 1", () => songSelect.FilterCount == 1);
+            AddAssert("filter count is 1", () => songSelect?.FilterCount == 1);
         }
 
         [Test]
@@ -156,7 +155,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             waitForInitialSelection();
 
-            WorkingBeatmap selected = null;
+            WorkingBeatmap? selected = null;
 
             AddStep("store selected beatmap", () => selected = Beatmap.Value);
 
@@ -166,7 +165,7 @@ namespace osu.Game.Tests.Visual.SongSelect
                 InputManager.Key(Key.Enter);
             });
 
-            AddUntilStep("wait for not current", () => !songSelect.IsCurrentScreen());
+            AddUntilStep("wait for not current", () => !songSelect!.IsCurrentScreen());
             AddAssert("ensure selection changed", () => selected != Beatmap.Value);
         }
 
@@ -179,7 +178,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             waitForInitialSelection();
 
-            WorkingBeatmap selected = null;
+            WorkingBeatmap? selected = null;
 
             AddStep("store selected beatmap", () => selected = Beatmap.Value);
 
@@ -189,7 +188,7 @@ namespace osu.Game.Tests.Visual.SongSelect
                 InputManager.Key(Key.Down);
             });
 
-            AddUntilStep("wait for not current", () => !songSelect.IsCurrentScreen());
+            AddUntilStep("wait for not current", () => !songSelect!.IsCurrentScreen());
             AddAssert("ensure selection didn't change", () => selected == Beatmap.Value);
         }
 
@@ -202,23 +201,23 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddUntilStep("wait for initial selection", () => !Beatmap.IsDefault);
 
-            WorkingBeatmap selected = null;
+            WorkingBeatmap? selected = null;
 
             AddStep("store selected beatmap", () => selected = Beatmap.Value);
 
-            AddUntilStep("wait for beatmaps to load", () => songSelect.Carousel.ChildrenOfType<DrawableCarouselBeatmap>().Any());
+            AddUntilStep("wait for beatmaps to load", () => songSelect!.Carousel.ChildrenOfType<DrawableCarouselBeatmap>().Any());
 
             AddStep("select next and enter", () =>
             {
-                InputManager.MoveMouseTo(songSelect.Carousel.ChildrenOfType<DrawableCarouselBeatmap>()
-                                                   .First(b => !((CarouselBeatmap)b.Item).BeatmapInfo.Equals(songSelect.Carousel.SelectedBeatmapInfo)));
+                InputManager.MoveMouseTo(songSelect!.Carousel.ChildrenOfType<DrawableCarouselBeatmap>()
+                                                    .First(b => !((CarouselBeatmap)b.Item).BeatmapInfo.Equals(songSelect!.Carousel.SelectedBeatmapInfo)));
 
                 InputManager.Click(MouseButton.Left);
 
                 InputManager.Key(Key.Enter);
             });
 
-            AddUntilStep("wait for not current", () => !songSelect.IsCurrentScreen());
+            AddUntilStep("wait for not current", () => !songSelect!.IsCurrentScreen());
             AddAssert("ensure selection changed", () => selected != Beatmap.Value);
         }
 
@@ -231,14 +230,14 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             waitForInitialSelection();
 
-            WorkingBeatmap selected = null;
+            WorkingBeatmap? selected = null;
 
             AddStep("store selected beatmap", () => selected = Beatmap.Value);
 
             AddStep("select next and enter", () =>
             {
-                InputManager.MoveMouseTo(songSelect.Carousel.ChildrenOfType<DrawableCarouselBeatmap>()
-                                                   .First(b => !((CarouselBeatmap)b.Item).BeatmapInfo.Equals(songSelect.Carousel.SelectedBeatmapInfo)));
+                InputManager.MoveMouseTo(songSelect!.Carousel.ChildrenOfType<DrawableCarouselBeatmap>()
+                                                    .First(b => !((CarouselBeatmap)b.Item).BeatmapInfo.Equals(songSelect!.Carousel.SelectedBeatmapInfo)));
 
                 InputManager.PressButton(MouseButton.Left);
 
@@ -247,7 +246,7 @@ namespace osu.Game.Tests.Visual.SongSelect
                 InputManager.ReleaseButton(MouseButton.Left);
             });
 
-            AddUntilStep("wait for not current", () => !songSelect.IsCurrentScreen());
+            AddUntilStep("wait for not current", () => !songSelect!.IsCurrentScreen());
             AddAssert("ensure selection didn't change", () => selected == Beatmap.Value);
         }
 
@@ -260,11 +259,11 @@ namespace osu.Game.Tests.Visual.SongSelect
             createSongSelect();
 
             AddStep("push child screen", () => Stack.Push(new TestSceneOsuScreenStack.TestScreen("test child")));
-            AddUntilStep("wait for not current", () => !songSelect.IsCurrentScreen());
+            AddUntilStep("wait for not current", () => !songSelect!.IsCurrentScreen());
 
-            AddStep("return", () => songSelect.MakeCurrent());
-            AddUntilStep("wait for current", () => songSelect.IsCurrentScreen());
-            AddAssert("filter count is 1", () => songSelect.FilterCount == 1);
+            AddStep("return", () => songSelect!.MakeCurrent());
+            AddUntilStep("wait for current", () => songSelect!.IsCurrentScreen());
+            AddAssert("filter count is 1", () => songSelect!.FilterCount == 1);
         }
 
         [Test]
@@ -278,13 +277,13 @@ namespace osu.Game.Tests.Visual.SongSelect
             createSongSelect();
 
             AddStep("push child screen", () => Stack.Push(new TestSceneOsuScreenStack.TestScreen("test child")));
-            AddUntilStep("wait for not current", () => !songSelect.IsCurrentScreen());
+            AddUntilStep("wait for not current", () => !songSelect!.IsCurrentScreen());
 
             AddStep("change convert setting", () => config.SetValue(OsuSetting.ShowConvertedBeatmaps, true));
 
-            AddStep("return", () => songSelect.MakeCurrent());
-            AddUntilStep("wait for current", () => songSelect.IsCurrentScreen());
-            AddAssert("filter count is 2", () => songSelect.FilterCount == 2);
+            AddStep("return", () => songSelect!.MakeCurrent());
+            AddUntilStep("wait for current", () => songSelect!.IsCurrentScreen());
+            AddAssert("filter count is 2", () => songSelect!.FilterCount == 2);
         }
 
         [Test]
@@ -295,7 +294,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             createSongSelect();
 
             AddStep("push child screen", () => Stack.Push(new TestSceneOsuScreenStack.TestScreen("test child")));
-            AddUntilStep("wait for not current", () => !songSelect.IsCurrentScreen());
+            AddUntilStep("wait for not current", () => !songSelect!.IsCurrentScreen());
 
             AddStep("update beatmap", () =>
             {
@@ -304,9 +303,9 @@ namespace osu.Game.Tests.Visual.SongSelect
                 Beatmap.Value = manager.GetWorkingBeatmap(anotherBeatmap);
             });
 
-            AddStep("return", () => songSelect.MakeCurrent());
-            AddUntilStep("wait for current", () => songSelect.IsCurrentScreen());
-            AddAssert("carousel updated", () => songSelect.Carousel.SelectedBeatmapInfo.Equals(Beatmap.Value.BeatmapInfo));
+            AddStep("return", () => songSelect!.MakeCurrent());
+            AddUntilStep("wait for current", () => songSelect!.IsCurrentScreen());
+            AddAssert("carousel updated", () => songSelect!.Carousel.SelectedBeatmapInfo?.Equals(Beatmap.Value.BeatmapInfo) == true);
         }
 
         [Test]
@@ -318,15 +317,15 @@ namespace osu.Game.Tests.Visual.SongSelect
             addRulesetImportStep(0);
 
             checkMusicPlaying(true);
-            AddStep("select first", () => songSelect.Carousel.SelectBeatmap(songSelect.Carousel.BeatmapSets.First().Beatmaps.First()));
+            AddStep("select first", () => songSelect!.Carousel.SelectBeatmap(songSelect!.Carousel.BeatmapSets.First().Beatmaps.First()));
             checkMusicPlaying(true);
 
             AddStep("manual pause", () => music.TogglePause());
             checkMusicPlaying(false);
-            AddStep("select next difficulty", () => songSelect.Carousel.SelectNext(skipDifficulties: false));
+            AddStep("select next difficulty", () => songSelect!.Carousel.SelectNext(skipDifficulties: false));
             checkMusicPlaying(false);
 
-            AddStep("select next set", () => songSelect.Carousel.SelectNext());
+            AddStep("select next set", () => songSelect!.Carousel.SelectNext());
             checkMusicPlaying(true);
         }
 
@@ -366,13 +365,13 @@ namespace osu.Game.Tests.Visual.SongSelect
         public void TestDummy()
         {
             createSongSelect();
-            AddUntilStep("dummy selected", () => songSelect.CurrentBeatmap == defaultBeatmap);
+            AddUntilStep("dummy selected", () => songSelect!.CurrentBeatmap == defaultBeatmap);
 
-            AddUntilStep("dummy shown on wedge", () => songSelect.CurrentBeatmapDetailsBeatmap == defaultBeatmap);
+            AddUntilStep("dummy shown on wedge", () => songSelect!.CurrentBeatmapDetailsBeatmap == defaultBeatmap);
 
             addManyTestMaps();
 
-            AddUntilStep("random map selected", () => songSelect.CurrentBeatmap != defaultBeatmap);
+            AddUntilStep("random map selected", () => songSelect!.CurrentBeatmap != defaultBeatmap);
         }
 
         [Test]
@@ -381,7 +380,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             createSongSelect();
             addManyTestMaps();
 
-            AddUntilStep("random map selected", () => songSelect.CurrentBeatmap != defaultBeatmap);
+            AddUntilStep("random map selected", () => songSelect!.CurrentBeatmap != defaultBeatmap);
 
             AddStep(@"Sort by Artist", () => config.SetValue(OsuSetting.SongSelectSortingMode, SortMode.Artist));
             AddStep(@"Sort by Title", () => config.SetValue(OsuSetting.SongSelectSortingMode, SortMode.Title));
@@ -398,7 +397,7 @@ namespace osu.Game.Tests.Visual.SongSelect
         {
             createSongSelect();
             addRulesetImportStep(2);
-            AddUntilStep("no selection", () => songSelect.Carousel.SelectedBeatmapInfo == null);
+            AddUntilStep("no selection", () => songSelect!.Carousel.SelectedBeatmapInfo == null);
         }
 
         [Test]
@@ -408,13 +407,13 @@ namespace osu.Game.Tests.Visual.SongSelect
             changeRuleset(2);
             addRulesetImportStep(2);
             addRulesetImportStep(1);
-            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmapInfo.Ruleset.OnlineID == 2);
+            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo?.Ruleset.OnlineID == 2);
 
             changeRuleset(1);
-            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmapInfo.Ruleset.OnlineID == 1);
+            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo?.Ruleset.OnlineID == 1);
 
             changeRuleset(0);
-            AddUntilStep("no selection", () => songSelect.Carousel.SelectedBeatmapInfo == null);
+            AddUntilStep("no selection", () => songSelect!.Carousel.SelectedBeatmapInfo == null);
         }
 
         [Test]
@@ -423,7 +422,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             createSongSelect();
             changeRuleset(0);
 
-            Live<BeatmapSetInfo> original = null!;
+            Live<BeatmapSetInfo>? original = null;
             int originalOnlineSetID = 0;
 
             AddStep(@"Sort by artist", () => config.SetValue(OsuSetting.SongSelectSortingMode, SortMode.Artist));
@@ -431,12 +430,17 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddStep("import original", () =>
             {
                 original = manager.Import(new ImportTask(TestResources.GetQuickTestBeatmapForImport())).GetResultSafely();
-                originalOnlineSetID = original!.Value.OnlineID;
+
+                Debug.Assert(original != null);
+
+                originalOnlineSetID = original.Value.OnlineID;
             });
 
             // This will move the beatmap set to a different location in the carousel.
             AddStep("Update original with bogus info", () =>
             {
+                Debug.Assert(original != null);
+
                 original.PerformWrite(set =>
                 {
                     foreach (var beatmap in set.Beatmaps)
@@ -457,13 +461,19 @@ namespace osu.Game.Tests.Visual.SongSelect
                 manager.Import(testBeatmapSetInfo);
             }, 10);
 
-            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmapInfo?.BeatmapSet?.OnlineID == originalOnlineSetID);
+            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo?.BeatmapSet?.OnlineID == originalOnlineSetID);
 
-            Task<Live<BeatmapSetInfo>> updateTask = null!;
-            AddStep("update beatmap", () => updateTask = manager.ImportAsUpdate(new ProgressNotification(), new ImportTask(TestResources.GetQuickTestBeatmapForImport()), original.Value));
+            Task<Live<BeatmapSetInfo>?> updateTask = null!;
+
+            AddStep("update beatmap", () =>
+            {
+                Debug.Assert(original != null);
+
+                updateTask = manager.ImportAsUpdate(new ProgressNotification(), new ImportTask(TestResources.GetQuickTestBeatmapForImport()), original.Value);
+            });
             AddUntilStep("wait for update completion", () => updateTask.IsCompleted);
 
-            AddUntilStep("retained selection", () => songSelect.Carousel.SelectedBeatmapInfo?.BeatmapSet?.OnlineID == originalOnlineSetID);
+            AddUntilStep("retained selection", () => songSelect!.Carousel.SelectedBeatmapInfo?.BeatmapSet?.OnlineID == originalOnlineSetID);
         }
 
         [Test]
@@ -473,13 +483,13 @@ namespace osu.Game.Tests.Visual.SongSelect
             changeRuleset(2);
 
             addRulesetImportStep(2);
-            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmapInfo.Ruleset.OnlineID == 2);
+            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo?.Ruleset.OnlineID == 2);
 
             addRulesetImportStep(0);
             addRulesetImportStep(0);
             addRulesetImportStep(0);
 
-            BeatmapInfo target = null;
+            BeatmapInfo? target = null;
 
             AddStep("select beatmap/ruleset externally", () =>
             {
@@ -490,10 +500,10 @@ namespace osu.Game.Tests.Visual.SongSelect
                 Beatmap.Value = manager.GetWorkingBeatmap(target);
             });
 
-            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmapInfo.Equals(target));
+            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo?.Equals(target) == true);
 
             // this is an important check, to make sure updateComponentFromBeatmap() was actually run
-            AddUntilStep("selection shown on wedge", () => songSelect.CurrentBeatmapDetailsBeatmap.BeatmapInfo.MatchesOnlineID(target));
+            AddUntilStep("selection shown on wedge", () => songSelect!.CurrentBeatmapDetailsBeatmap.BeatmapInfo.MatchesOnlineID(target));
         }
 
         [Test]
@@ -503,13 +513,13 @@ namespace osu.Game.Tests.Visual.SongSelect
             changeRuleset(2);
 
             addRulesetImportStep(2);
-            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmapInfo.Ruleset.OnlineID == 2);
+            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo?.Ruleset.OnlineID == 2);
 
             addRulesetImportStep(0);
             addRulesetImportStep(0);
             addRulesetImportStep(0);
 
-            BeatmapInfo target = null;
+            BeatmapInfo? target = null;
 
             AddStep("select beatmap/ruleset externally", () =>
             {
@@ -520,12 +530,12 @@ namespace osu.Game.Tests.Visual.SongSelect
                 Ruleset.Value = rulesets.AvailableRulesets.First(r => r.OnlineID == 0);
             });
 
-            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmapInfo.Equals(target));
+            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo?.Equals(target) == true);
 
             AddUntilStep("has correct ruleset", () => Ruleset.Value.OnlineID == 0);
 
             // this is an important check, to make sure updateComponentFromBeatmap() was actually run
-            AddUntilStep("selection shown on wedge", () => songSelect.CurrentBeatmapDetailsBeatmap.BeatmapInfo.MatchesOnlineID(target));
+            AddUntilStep("selection shown on wedge", () => songSelect!.CurrentBeatmapDetailsBeatmap.BeatmapInfo.MatchesOnlineID(target));
         }
 
         [Test]
@@ -543,12 +553,12 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddStep("change ruleset", () =>
             {
                 SelectedMods.ValueChanged += onModChange;
-                songSelect.Ruleset.ValueChanged += onRulesetChange;
+                songSelect!.Ruleset.ValueChanged += onRulesetChange;
 
                 Ruleset.Value = new TaikoRuleset().RulesetInfo;
 
                 SelectedMods.ValueChanged -= onModChange;
-                songSelect.Ruleset.ValueChanged -= onRulesetChange;
+                songSelect!.Ruleset.ValueChanged -= onRulesetChange;
             });
 
             AddAssert("mods changed before ruleset", () => modChangeIndex < rulesetChangeIndex);
@@ -579,18 +589,18 @@ namespace osu.Game.Tests.Visual.SongSelect
         {
             createSongSelect();
             addManyTestMaps();
-            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmapInfo != null);
+            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo != null);
 
             bool startRequested = false;
 
             AddStep("set filter and finalize", () =>
             {
-                songSelect.StartRequested = () => startRequested = true;
+                songSelect!.StartRequested = () => startRequested = true;
 
-                songSelect.Carousel.Filter(new FilterCriteria { SearchText = "somestringthatshouldn'tbematchable" });
-                songSelect.FinaliseSelection();
+                songSelect!.Carousel.Filter(new FilterCriteria { SearchText = "somestringthatshouldn'tbematchable" });
+                songSelect!.FinaliseSelection();
 
-                songSelect.StartRequested = null;
+                songSelect!.StartRequested = null;
             });
 
             AddAssert("start not requested", () => !startRequested);
@@ -610,15 +620,15 @@ namespace osu.Game.Tests.Visual.SongSelect
             // used for filter check below
             AddStep("allow convert display", () => config.SetValue(OsuSetting.ShowConvertedBeatmaps, true));
 
-            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmapInfo != null);
+            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo != null);
 
-            AddStep("set filter text", () => songSelect.FilterControl.ChildrenOfType<SearchTextBox>().First().Text = "nonono");
+            AddStep("set filter text", () => songSelect!.FilterControl.ChildrenOfType<SearchTextBox>().First().Text = "nonono");
 
             AddUntilStep("dummy selected", () => Beatmap.Value is DummyWorkingBeatmap);
 
-            AddUntilStep("has no selection", () => songSelect.Carousel.SelectedBeatmapInfo == null);
+            AddUntilStep("has no selection", () => songSelect!.Carousel.SelectedBeatmapInfo == null);
 
-            BeatmapInfo target = null;
+            BeatmapInfo? target = null;
 
             int targetRuleset = differentRuleset ? 1 : 0;
 
@@ -632,24 +642,24 @@ namespace osu.Game.Tests.Visual.SongSelect
                 Beatmap.Value = manager.GetWorkingBeatmap(target);
             });
 
-            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmapInfo != null);
+            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo != null);
 
             AddAssert("selected only shows expected ruleset (plus converts)", () =>
             {
-                var selectedPanel = songSelect.Carousel.ChildrenOfType<DrawableCarouselBeatmapSet>().First(s => s.Item.State.Value == CarouselItemState.Selected);
+                var selectedPanel = songSelect!.Carousel.ChildrenOfType<DrawableCarouselBeatmapSet>().First(s => s.Item.State.Value == CarouselItemState.Selected);
 
                 // special case for converts checked here.
                 return selectedPanel.ChildrenOfType<FilterableDifficultyIcon>().All(i =>
                     i.IsFiltered || i.Item.BeatmapInfo.Ruleset.OnlineID == targetRuleset || i.Item.BeatmapInfo.Ruleset.OnlineID == 0);
             });
 
-            AddUntilStep("carousel has correct", () => songSelect.Carousel.SelectedBeatmapInfo?.MatchesOnlineID(target) == true);
+            AddUntilStep("carousel has correct", () => songSelect!.Carousel.SelectedBeatmapInfo?.MatchesOnlineID(target) == true);
             AddUntilStep("game has correct", () => Beatmap.Value.BeatmapInfo.MatchesOnlineID(target));
 
-            AddStep("reset filter text", () => songSelect.FilterControl.ChildrenOfType<SearchTextBox>().First().Text = string.Empty);
+            AddStep("reset filter text", () => songSelect!.FilterControl.ChildrenOfType<SearchTextBox>().First().Text = string.Empty);
 
             AddAssert("game still correct", () => Beatmap.Value?.BeatmapInfo.MatchesOnlineID(target) == true);
-            AddAssert("carousel still correct", () => songSelect.Carousel.SelectedBeatmapInfo.MatchesOnlineID(target));
+            AddAssert("carousel still correct", () => songSelect!.Carousel.SelectedBeatmapInfo.MatchesOnlineID(target));
         }
 
         [Test]
@@ -662,15 +672,15 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             changeRuleset(0);
 
-            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmapInfo != null);
+            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo != null);
 
-            AddStep("set filter text", () => songSelect.FilterControl.ChildrenOfType<SearchTextBox>().First().Text = "nonono");
+            AddStep("set filter text", () => songSelect!.FilterControl.ChildrenOfType<SearchTextBox>().First().Text = "nonono");
 
             AddUntilStep("dummy selected", () => Beatmap.Value is DummyWorkingBeatmap);
 
-            AddUntilStep("has no selection", () => songSelect.Carousel.SelectedBeatmapInfo == null);
+            AddUntilStep("has no selection", () => songSelect!.Carousel.SelectedBeatmapInfo == null);
 
-            BeatmapInfo target = null;
+            BeatmapInfo? target = null;
 
             AddStep("select beatmap externally", () =>
             {
@@ -682,15 +692,15 @@ namespace osu.Game.Tests.Visual.SongSelect
                 Beatmap.Value = manager.GetWorkingBeatmap(target);
             });
 
-            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmapInfo != null);
+            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo != null);
 
-            AddUntilStep("carousel has correct", () => songSelect.Carousel.SelectedBeatmapInfo?.MatchesOnlineID(target) == true);
+            AddUntilStep("carousel has correct", () => songSelect!.Carousel.SelectedBeatmapInfo?.MatchesOnlineID(target) == true);
             AddUntilStep("game has correct", () => Beatmap.Value.BeatmapInfo.MatchesOnlineID(target));
 
-            AddStep("set filter text", () => songSelect.FilterControl.ChildrenOfType<SearchTextBox>().First().Text = "nononoo");
+            AddStep("set filter text", () => songSelect!.FilterControl.ChildrenOfType<SearchTextBox>().First().Text = "nononoo");
 
             AddUntilStep("game lost selection", () => Beatmap.Value is DummyWorkingBeatmap);
-            AddAssert("carousel lost selection", () => songSelect.Carousel.SelectedBeatmapInfo == null);
+            AddAssert("carousel lost selection", () => songSelect!.Carousel.SelectedBeatmapInfo == null);
         }
 
         [Test]
@@ -711,11 +721,11 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddUntilStep("wait for player", () => Stack.CurrentScreen is PlayerLoader);
 
-            AddAssert("autoplay selected", () => songSelect.Mods.Value.Single() is ModAutoplay);
+            AddAssert("autoplay selected", () => songSelect!.Mods.Value.Single() is ModAutoplay);
 
-            AddUntilStep("wait for return to ss", () => songSelect.IsCurrentScreen());
+            AddUntilStep("wait for return to ss", () => songSelect!.IsCurrentScreen());
 
-            AddAssert("no mods selected", () => songSelect.Mods.Value.Count == 0);
+            AddAssert("no mods selected", () => songSelect!.Mods.Value.Count == 0);
         }
 
         [Test]
@@ -738,11 +748,11 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddUntilStep("wait for player", () => Stack.CurrentScreen is PlayerLoader);
 
-            AddAssert("autoplay selected", () => songSelect.Mods.Value.Single() is ModAutoplay);
+            AddAssert("autoplay selected", () => songSelect!.Mods.Value.Single() is ModAutoplay);
 
-            AddUntilStep("wait for return to ss", () => songSelect.IsCurrentScreen());
+            AddUntilStep("wait for return to ss", () => songSelect!.IsCurrentScreen());
 
-            AddAssert("autoplay still selected", () => songSelect.Mods.Value.Single() is ModAutoplay);
+            AddAssert("autoplay still selected", () => songSelect!.Mods.Value.Single() is ModAutoplay);
         }
 
         [Test]
@@ -765,11 +775,11 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddUntilStep("wait for player", () => Stack.CurrentScreen is PlayerLoader);
 
-            AddAssert("only autoplay selected", () => songSelect.Mods.Value.Single() is ModAutoplay);
+            AddAssert("only autoplay selected", () => songSelect!.Mods.Value.Single() is ModAutoplay);
 
-            AddUntilStep("wait for return to ss", () => songSelect.IsCurrentScreen());
+            AddUntilStep("wait for return to ss", () => songSelect!.IsCurrentScreen());
 
-            AddAssert("relax returned", () => songSelect.Mods.Value.Single() is ModRelax);
+            AddAssert("relax returned", () => songSelect!.Mods.Value.Single() is ModRelax);
         }
 
         [Test]
@@ -778,10 +788,10 @@ namespace osu.Game.Tests.Visual.SongSelect
             Guid? previousID = null;
             createSongSelect();
             addRulesetImportStep(0);
-            AddStep("Move to last difficulty", () => songSelect.Carousel.SelectBeatmap(songSelect.Carousel.BeatmapSets.First().Beatmaps.Last()));
-            AddStep("Store current ID", () => previousID = songSelect.Carousel.SelectedBeatmapInfo.ID);
-            AddStep("Hide first beatmap", () => manager.Hide(songSelect.Carousel.SelectedBeatmapSet.Beatmaps.First()));
-            AddAssert("Selected beatmap has not changed", () => songSelect.Carousel.SelectedBeatmapInfo.ID == previousID);
+            AddStep("Move to last difficulty", () => songSelect!.Carousel.SelectBeatmap(songSelect!.Carousel.BeatmapSets.First().Beatmaps.Last()));
+            AddStep("Store current ID", () => previousID = songSelect!.Carousel.SelectedBeatmapInfo!.ID);
+            AddStep("Hide first beatmap", () => manager.Hide(songSelect!.Carousel.SelectedBeatmapSet!.Beatmaps.First()));
+            AddAssert("Selected beatmap has not changed", () => songSelect!.Carousel.SelectedBeatmapInfo?.ID == previousID);
         }
 
         [Test]
@@ -792,17 +802,24 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddUntilStep("wait for selection", () => !Beatmap.IsDefault);
 
-            DrawableCarouselBeatmapSet set = null;
+            DrawableCarouselBeatmapSet set = null!;
             AddStep("Find the DrawableCarouselBeatmapSet", () =>
             {
-                set = songSelect.Carousel.ChildrenOfType<DrawableCarouselBeatmapSet>().First();
+                set = songSelect!.Carousel.ChildrenOfType<DrawableCarouselBeatmapSet>().First();
             });
 
-            FilterableDifficultyIcon difficultyIcon = null;
+            FilterableDifficultyIcon difficultyIcon = null!;
+
             AddUntilStep("Find an icon", () =>
             {
-                return (difficultyIcon = set.ChildrenOfType<FilterableDifficultyIcon>()
-                                            .FirstOrDefault(icon => getDifficultyIconIndex(set, icon) != getCurrentBeatmapIndex())) != null;
+                var foundIcon = set.ChildrenOfType<FilterableDifficultyIcon>()
+                                   .FirstOrDefault(icon => getDifficultyIconIndex(set, icon) != getCurrentBeatmapIndex());
+
+                if (foundIcon == null)
+                    return false;
+
+                difficultyIcon = foundIcon;
+                return true;
             });
 
             AddStep("Click on a difficulty", () =>
@@ -815,21 +832,24 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddAssert("Selected beatmap correct", () => getCurrentBeatmapIndex() == getDifficultyIconIndex(set, difficultyIcon));
 
             double? maxBPM = null;
-            AddStep("Filter some difficulties", () => songSelect.Carousel.Filter(new FilterCriteria
+            AddStep("Filter some difficulties", () => songSelect!.Carousel.Filter(new FilterCriteria
             {
                 BPM = new FilterCriteria.OptionalRange<double>
                 {
-                    Min = maxBPM = songSelect.Carousel.SelectedBeatmapSet.MaxBPM,
+                    Min = maxBPM = songSelect!.Carousel.SelectedBeatmapSet!.MaxBPM,
                     IsLowerInclusive = true
                 }
             }));
 
-            BeatmapInfo filteredBeatmap = null;
-            FilterableDifficultyIcon filteredIcon = null;
+            BeatmapInfo? filteredBeatmap = null;
+            FilterableDifficultyIcon? filteredIcon = null;
 
             AddStep("Get filtered icon", () =>
             {
-                var selectedSet = songSelect.Carousel.SelectedBeatmapSet;
+                var selectedSet = songSelect!.Carousel.SelectedBeatmapSet;
+
+                Debug.Assert(selectedSet != null);
+
                 filteredBeatmap = selectedSet.Beatmaps.First(b => b.BPM < maxBPM);
                 int filteredBeatmapIndex = getBeatmapIndex(selectedSet, filteredBeatmap);
                 filteredIcon = set.ChildrenOfType<FilterableDifficultyIcon>().ElementAt(filteredBeatmapIndex);
@@ -842,7 +862,7 @@ namespace osu.Game.Tests.Visual.SongSelect
                 InputManager.Click(MouseButton.Left);
             });
 
-            AddAssert("Selected beatmap correct", () => songSelect.Carousel.SelectedBeatmapInfo.Equals(filteredBeatmap));
+            AddAssert("Selected beatmap correct", () => songSelect!.Carousel.SelectedBeatmapInfo?.Equals(filteredBeatmap) == true);
         }
 
         [Test]
@@ -907,14 +927,14 @@ namespace osu.Game.Tests.Visual.SongSelect
                 manager.Import(TestResources.CreateTestBeatmapSetInfo(3, usableRulesets));
             });
 
-            DrawableCarouselBeatmapSet set = null;
+            DrawableCarouselBeatmapSet? set = null;
             AddUntilStep("Find the DrawableCarouselBeatmapSet", () =>
             {
-                set = songSelect.Carousel.ChildrenOfType<DrawableCarouselBeatmapSet>().FirstOrDefault();
+                set = songSelect!.Carousel.ChildrenOfType<DrawableCarouselBeatmapSet>().FirstOrDefault();
                 return set != null;
             });
 
-            FilterableDifficultyIcon difficultyIcon = null;
+            FilterableDifficultyIcon? difficultyIcon = null;
             AddUntilStep("Find an icon for different ruleset", () =>
             {
                 difficultyIcon = set.ChildrenOfType<FilterableDifficultyIcon>()
@@ -937,7 +957,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddUntilStep("Check ruleset changed to mania", () => Ruleset.Value.OnlineID == 3);
 
-            AddAssert("Selected beatmap still same set", () => songSelect.Carousel.SelectedBeatmapInfo.BeatmapSet?.OnlineID == previousSetID);
+            AddAssert("Selected beatmap still same set", () => songSelect!.Carousel.SelectedBeatmapInfo?.BeatmapSet?.OnlineID == previousSetID);
             AddAssert("Selected beatmap is mania", () => Beatmap.Value.BeatmapInfo.Ruleset.OnlineID == 3);
         }
 
@@ -948,7 +968,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             createSongSelect();
 
-            BeatmapSetInfo imported = null;
+            BeatmapSetInfo? imported = null;
 
             AddStep("import huge difficulty count map", () =>
             {
@@ -956,20 +976,27 @@ namespace osu.Game.Tests.Visual.SongSelect
                 imported = manager.Import(TestResources.CreateTestBeatmapSetInfo(50, usableRulesets))?.Value;
             });
 
-            AddStep("select the first beatmap of import", () => Beatmap.Value = manager.GetWorkingBeatmap(imported.Beatmaps.First()));
+            AddStep("select the first beatmap of import", () => Beatmap.Value = manager.GetWorkingBeatmap(imported?.Beatmaps.First()));
 
-            DrawableCarouselBeatmapSet set = null;
+            DrawableCarouselBeatmapSet? set = null;
             AddUntilStep("Find the DrawableCarouselBeatmapSet", () =>
             {
-                set = songSelect.Carousel.ChildrenOfType<DrawableCarouselBeatmapSet>().FirstOrDefault();
+                set = songSelect!.Carousel.ChildrenOfType<DrawableCarouselBeatmapSet>().FirstOrDefault();
                 return set != null;
             });
 
-            GroupedDifficultyIcon groupIcon = null;
+            GroupedDifficultyIcon groupIcon = null!;
+
             AddUntilStep("Find group icon for different ruleset", () =>
             {
-                return (groupIcon = set.ChildrenOfType<GroupedDifficultyIcon>()
-                                       .FirstOrDefault(icon => icon.Items.First().BeatmapInfo.Ruleset.OnlineID == 3)) != null;
+                var foundIcon = set.ChildrenOfType<GroupedDifficultyIcon>()
+                                   .FirstOrDefault(icon => icon.Items.First().BeatmapInfo.Ruleset.OnlineID == 3);
+
+                if (foundIcon == null)
+                    return false;
+
+                groupIcon = foundIcon;
+                return true;
             });
 
             AddAssert("Check ruleset is osu!", () => Ruleset.Value.OnlineID == 0);
@@ -1004,7 +1031,7 @@ namespace osu.Game.Tests.Visual.SongSelect
                 // this ruleset change should be overridden by the present.
                 Ruleset.Value = getSwitchBeatmap().Ruleset;
 
-                songSelect.PresentScore(new ScoreInfo
+                songSelect!.PresentScore(new ScoreInfo
                 {
                     User = new APIUser { Username = "woo" },
                     BeatmapInfo = getPresentBeatmap(),
@@ -1012,7 +1039,7 @@ namespace osu.Game.Tests.Visual.SongSelect
                 });
             });
 
-            AddUntilStep("wait for results screen presented", () => !songSelect.IsCurrentScreen());
+            AddUntilStep("wait for results screen presented", () => !songSelect!.IsCurrentScreen());
 
             AddAssert("check beatmap is correct for score", () => Beatmap.Value.BeatmapInfo.MatchesOnlineID(getPresentBeatmap()));
             AddAssert("check ruleset is correct for score", () => Ruleset.Value.OnlineID == 0);
@@ -1038,10 +1065,10 @@ namespace osu.Game.Tests.Visual.SongSelect
                 // this beatmap change should be overridden by the present.
                 Beatmap.Value = manager.GetWorkingBeatmap(getSwitchBeatmap());
 
-                songSelect.PresentScore(TestResources.CreateTestScoreInfo(getPresentBeatmap()));
+                songSelect!.PresentScore(TestResources.CreateTestScoreInfo(getPresentBeatmap()));
             });
 
-            AddUntilStep("wait for results screen presented", () => !songSelect.IsCurrentScreen());
+            AddUntilStep("wait for results screen presented", () => !songSelect!.IsCurrentScreen());
 
             AddAssert("check beatmap is correct for score", () => Beatmap.Value.BeatmapInfo.MatchesOnlineID(getPresentBeatmap()));
             AddAssert("check ruleset is correct for score", () => Ruleset.Value.OnlineID == 0);
@@ -1054,23 +1081,29 @@ namespace osu.Game.Tests.Visual.SongSelect
             createSongSelect();
 
             AddStep("toggle mod overlay on", () => InputManager.Key(Key.F1));
-            AddUntilStep("mod overlay shown", () => songSelect.ModSelect.State.Value == Visibility.Visible);
+            AddUntilStep("mod overlay shown", () => songSelect!.ModSelect.State.Value == Visibility.Visible);
 
             AddStep("toggle mod overlay off", () => InputManager.Key(Key.F1));
-            AddUntilStep("mod overlay hidden", () => songSelect.ModSelect.State.Value == Visibility.Hidden);
+            AddUntilStep("mod overlay hidden", () => songSelect!.ModSelect.State.Value == Visibility.Hidden);
         }
 
         private void waitForInitialSelection()
         {
             AddUntilStep("wait for initial selection", () => !Beatmap.IsDefault);
-            AddUntilStep("wait for difficulty panels visible", () => songSelect.Carousel.ChildrenOfType<DrawableCarouselBeatmap>().Any());
+            AddUntilStep("wait for difficulty panels visible", () => songSelect!.Carousel.ChildrenOfType<DrawableCarouselBeatmap>().Any());
         }
 
         private int getBeatmapIndex(BeatmapSetInfo set, BeatmapInfo info) => set.Beatmaps.IndexOf(info);
 
-        private NoResultsPlaceholder getPlaceholder() => songSelect.ChildrenOfType<NoResultsPlaceholder>().FirstOrDefault();
+        private NoResultsPlaceholder? getPlaceholder() => songSelect!.ChildrenOfType<NoResultsPlaceholder>().FirstOrDefault();
 
-        private int getCurrentBeatmapIndex() => getBeatmapIndex(songSelect.Carousel.SelectedBeatmapSet, songSelect.Carousel.SelectedBeatmapInfo);
+        private int getCurrentBeatmapIndex()
+        {
+            Debug.Assert(songSelect!.Carousel.SelectedBeatmapSet != null);
+            Debug.Assert(songSelect!.Carousel.SelectedBeatmapInfo != null);
+
+            return getBeatmapIndex(songSelect!.Carousel.SelectedBeatmapSet, songSelect!.Carousel.SelectedBeatmapInfo);
+        }
 
         private int getDifficultyIconIndex(DrawableCarouselBeatmapSet set, FilterableDifficultyIcon icon)
         {
@@ -1079,14 +1112,14 @@ namespace osu.Game.Tests.Visual.SongSelect
 
         private void addRulesetImportStep(int id)
         {
-            Live<BeatmapSetInfo> imported = null;
+            Live<BeatmapSetInfo>? imported = null;
             AddStep($"import test map for ruleset {id}", () => imported = importForRuleset(id));
             // This is specifically for cases where the add is happening post song select load.
             // For cases where song select is null, the assertions are provided by the load checks.
-            AddUntilStep("wait for imported to arrive in carousel", () => songSelect == null || songSelect.Carousel.BeatmapSets.Any(s => s.ID == imported?.ID));
+            AddUntilStep("wait for imported to arrive in carousel", () => songSelect == null || songSelect!.Carousel.BeatmapSets.Any(s => s.ID == imported?.ID));
         }
 
-        private Live<BeatmapSetInfo> importForRuleset(int id) => manager.Import(TestResources.CreateTestBeatmapSetInfo(3, rulesets.AvailableRulesets.Where(r => r.OnlineID == id).ToArray()));
+        private Live<BeatmapSetInfo>? importForRuleset(int id) => manager.Import(TestResources.CreateTestBeatmapSetInfo(3, rulesets.AvailableRulesets.Where(r => r.OnlineID == id).ToArray()));
 
         private void checkMusicPlaying(bool playing) =>
             AddUntilStep($"music {(playing ? "" : "not ")}playing", () => music.IsPlaying == playing);
@@ -1098,8 +1131,8 @@ namespace osu.Game.Tests.Visual.SongSelect
         private void createSongSelect()
         {
             AddStep("create song select", () => LoadScreen(songSelect = new TestSongSelect()));
-            AddUntilStep("wait for present", () => songSelect.IsCurrentScreen());
-            AddUntilStep("wait for carousel loaded", () => songSelect.Carousel.IsAlive);
+            AddUntilStep("wait for present", () => songSelect!.IsCurrentScreen());
+            AddUntilStep("wait for carousel loaded", () => songSelect!.Carousel.IsAlive);
         }
 
         /// <summary>
@@ -1123,12 +1156,14 @@ namespace osu.Game.Tests.Visual.SongSelect
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
-            rulesets?.Dispose();
+
+            if (rulesets.IsNotNull())
+                rulesets.Dispose();
         }
 
         private class TestSongSelect : PlaySongSelect
         {
-            public Action StartRequested;
+            public Action? StartRequested;
 
             public new Bindable<RulesetInfo> Ruleset => base.Ruleset;
 

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

@@ -259,7 +259,7 @@ namespace osu.Game.Tests.Visual.UserInterface
 
         private void removeFacade()
         {
-            trackingContainer.Remove(logoFacade);
+            trackingContainer.Remove(logoFacade, false);
             visualBox.Colour = Color4.White;
             moveLogoFacade();
         }

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

@@ -7,6 +7,7 @@ using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Overlays;
@@ -23,9 +24,12 @@ namespace osu.Game.Tests.Visual.UserInterface
 
         private SpriteText displayedCount = null!;
 
+        public double TimeToCompleteProgress { get; set; } = 2000;
+
         [SetUp]
         public void SetUp() => Schedule(() =>
         {
+            TimeToCompleteProgress = 2000;
             progressingNotifications.Clear();
 
             Content.Children = new Drawable[]
@@ -41,10 +45,36 @@ namespace osu.Game.Tests.Visual.UserInterface
             notificationOverlay.UnreadCount.ValueChanged += count => { displayedCount.Text = $"displayed count: {count.NewValue}"; };
         });
 
+        [Test]
+        public void TestPresence()
+        {
+            AddAssert("tray not present", () => !notificationOverlay.ChildrenOfType<NotificationOverlayToastTray>().Single().IsPresent);
+            AddAssert("overlay not present", () => !notificationOverlay.IsPresent);
+
+            AddStep(@"post notification", sendBackgroundNotification);
+
+            AddUntilStep("wait tray not present", () => !notificationOverlay.ChildrenOfType<NotificationOverlayToastTray>().Single().IsPresent);
+            AddUntilStep("wait overlay not present", () => !notificationOverlay.IsPresent);
+        }
+
+        [Test]
+        public void TestPresenceWithManualDismiss()
+        {
+            AddAssert("tray not present", () => !notificationOverlay.ChildrenOfType<NotificationOverlayToastTray>().Single().IsPresent);
+            AddAssert("overlay not present", () => !notificationOverlay.IsPresent);
+
+            AddStep(@"post notification", sendBackgroundNotification);
+            AddStep("click notification", () => notificationOverlay.ChildrenOfType<Notification>().Single().TriggerClick());
+
+            AddUntilStep("wait tray not present", () => !notificationOverlay.ChildrenOfType<NotificationOverlayToastTray>().Single().IsPresent);
+            AddUntilStep("wait overlay not present", () => !notificationOverlay.IsPresent);
+        }
+
         [Test]
         public void TestCompleteProgress()
         {
             ProgressNotification notification = null!;
+
             AddStep("add progress notification", () =>
             {
                 notification = new ProgressNotification
@@ -57,6 +87,31 @@ namespace osu.Game.Tests.Visual.UserInterface
             });
 
             AddUntilStep("wait completion", () => notification.State == ProgressNotificationState.Completed);
+
+            AddAssert("Completion toast shown", () => notificationOverlay.ToastCount == 1);
+            AddUntilStep("wait forwarded", () => notificationOverlay.ToastCount == 0);
+        }
+
+        [Test]
+        public void TestCompleteProgressSlow()
+        {
+            ProgressNotification notification = null!;
+
+            AddStep("Set progress slow", () => TimeToCompleteProgress *= 2);
+            AddStep("add progress notification", () =>
+            {
+                notification = new ProgressNotification
+                {
+                    Text = @"Uploading to BSS...",
+                    CompletionText = "Uploaded to BSS!",
+                };
+                notificationOverlay.Post(notification);
+                progressingNotifications.Add(notification);
+            });
+
+            AddUntilStep("wait completion", () => notification.State == ProgressNotificationState.Completed);
+
+            AddAssert("Completion toast shown", () => notificationOverlay.ToastCount == 1);
         }
 
         [Test]
@@ -177,7 +232,7 @@ namespace osu.Game.Tests.Visual.UserInterface
             foreach (var n in progressingNotifications.FindAll(n => n.State == ProgressNotificationState.Active))
             {
                 if (n.Progress < 1)
-                    n.Progress += (float)(Time.Elapsed / 2000);
+                    n.Progress += (float)(Time.Elapsed / TimeToCompleteProgress);
                 else
                     n.State = ProgressNotificationState.Completed;
             }

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

@@ -0,0 +1,94 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneSizePreservingSpriteText : OsuGridTestScene
+    {
+        private readonly List<Container> parentContainers = new List<Container>();
+        private readonly List<UprightAspectMaintainingContainer> childContainers = new List<UprightAspectMaintainingContainer>();
+        private readonly OsuSpriteText osuSpriteText = new OsuSpriteText();
+        private readonly SizePreservingSpriteText sizePreservingSpriteText = new SizePreservingSpriteText();
+
+        public TestSceneSizePreservingSpriteText()
+            : base(1, 2)
+        {
+            for (int i = 0; i < 2; i++)
+            {
+                UprightAspectMaintainingContainer childContainer;
+                Container parentContainer = new Container
+                {
+                    Origin = Anchor.BottomRight,
+                    Anchor = Anchor.BottomCentre,
+                    AutoSizeAxes = Axes.Both,
+                    Rotation = 45,
+                    Y = -200,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = Colour4.Red,
+                        },
+                        childContainer = new UprightAspectMaintainingContainer
+                        {
+                            AutoSizeAxes = Axes.Both,
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Children = new Drawable[]
+                            {
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = Colour4.Blue,
+                                },
+                            }
+                        },
+                    }
+                };
+
+                Container cellInfo = new Container
+                {
+                    Origin = Anchor.TopCentre,
+                    Anchor = Anchor.TopCentre,
+                    Margin = new MarginPadding
+                    {
+                        Top = 100,
+                    },
+                    Child = new OsuSpriteText
+                    {
+                        Text = (i == 0) ? "OsuSpriteText" : "SizePreservingSpriteText",
+                        Font = OsuFont.GetFont(Typeface.Inter, weight: FontWeight.Bold, size: 40),
+                        Origin = Anchor.TopCentre,
+                        Anchor = Anchor.TopCentre,
+                    },
+                };
+
+                parentContainers.Add(parentContainer);
+                childContainers.Add(childContainer);
+                Cell(i).Add(cellInfo);
+                Cell(i).Add(parentContainer);
+            }
+
+            childContainers[0].Add(osuSpriteText);
+            childContainers[1].Add(sizePreservingSpriteText);
+            osuSpriteText.Font = sizePreservingSpriteText.Font = OsuFont.GetFont(Typeface.Venera, weight: FontWeight.Bold, size: 20);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+            osuSpriteText.Text = sizePreservingSpriteText.Text = DateTime.Now.ToString(CultureInfo.InvariantCulture);
+        }
+    }
+}

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

@@ -0,0 +1,244 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics;
+using osu.Framework.Utils;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics;
+using osuTK.Graphics;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneUprightAspectMaintainingContainer : OsuGridTestScene
+    {
+        private const int rows = 3;
+        private const int columns = 4;
+
+        private readonly ScaleMode[] scaleModeValues = { ScaleMode.NoScaling, ScaleMode.Horizontal, ScaleMode.Vertical };
+        private readonly float[] scalingFactorValues = { 1.0f / 3, 1.0f / 2, 1.0f, 1.5f };
+
+        private readonly List<List<Container>> parentContainers = new List<List<Container>>(rows);
+        private readonly List<List<UprightAspectMaintainingContainer>> childContainers = new List<List<UprightAspectMaintainingContainer>>(rows);
+
+        // Preferably should be set to (4 * 2^n)
+        private const int rotation_step_count = 3;
+
+        private readonly List<int> flipStates = new List<int>();
+        private readonly List<float> rotationSteps = new List<float>();
+        private readonly List<float> scaleSteps = new List<float>();
+
+        public TestSceneUprightAspectMaintainingContainer()
+            : base(rows, columns)
+        {
+            for (int i = 0; i < rows; i++)
+            {
+                parentContainers.Add(new List<Container>());
+                childContainers.Add(new List<UprightAspectMaintainingContainer>());
+
+                for (int j = 0; j < columns; j++)
+                {
+                    UprightAspectMaintainingContainer child;
+                    Container parent = new Container
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Height = 80,
+                        Width = 80,
+                        Children = new Drawable[]
+                        {
+                            new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Colour = new Color4(255, 0, 0, 160),
+                            },
+                            new OsuSpriteText
+                            {
+                                Text = "Parent",
+                            },
+                            child = new UprightAspectMaintainingContainer
+                            {
+                                Origin = Anchor.Centre,
+                                Anchor = Anchor.Centre,
+                                AutoSizeAxes = Axes.Both,
+
+                                // These are the parameters being Tested
+                                Scaling = scaleModeValues[i],
+                                ScalingFactor = scalingFactorValues[j],
+
+                                Children = new Drawable[]
+                                {
+                                    new Box
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                        Colour = new Color4(0, 0, 255, 160),
+                                    },
+                                    new OsuSpriteText
+                                    {
+                                        Text = "Text",
+                                        Font = OsuFont.Numeric,
+                                        Origin = Anchor.Centre,
+                                        Anchor = Anchor.Centre,
+                                        Padding = new MarginPadding
+                                        {
+                                            Horizontal = 4,
+                                            Vertical = 4,
+                                        }
+                                    },
+                                }
+                            }
+                        }
+                    };
+
+                    Container cellInfo = new Container
+                    {
+                        Children = new Drawable[]
+                        {
+                            new OsuSpriteText
+                            {
+                                Text = "Scaling: " + scaleModeValues[i].ToString(),
+                            },
+                            new OsuSpriteText
+                            {
+                                Text = "ScalingFactor: " + scalingFactorValues[j].ToString("0.00"),
+                                Margin = new MarginPadding
+                                {
+                                    Top = 15,
+                                },
+                            },
+                        },
+                    };
+
+                    Cell(i * columns + j).Add(cellInfo);
+                    Cell(i * columns + j).Add(parent);
+                    parentContainers[i].Add(parent);
+                    childContainers[i].Add(child);
+                }
+            }
+
+            flipStates.AddRange(new[] { 1, -1 });
+            rotationSteps.AddRange(Enumerable.Range(0, rotation_step_count).Select(x => 360f * ((float)x / rotation_step_count)));
+            scaleSteps.AddRange(new[] { 1, 0.3f, 1.5f });
+        }
+
+        [Test]
+        public void ExplicitlySizedParent()
+        {
+            var parentStates = from xFlip in flipStates
+                               from yFlip in flipStates
+                               from xScale in scaleSteps
+                               from yScale in scaleSteps
+                               from rotation in rotationSteps
+                               select new { xFlip, yFlip, xScale, yScale, rotation };
+
+            foreach (var state in parentStates)
+            {
+                Vector2 parentScale = new Vector2(state.xFlip * state.xScale, state.yFlip * state.yScale);
+                float parentRotation = state.rotation;
+
+                AddStep("S: (" + parentScale.X.ToString("0.00") + ", " + parentScale.Y.ToString("0.00") + "), R: " + parentRotation.ToString("0.00"), () =>
+                {
+                    foreach (List<Container> list in parentContainers)
+                    {
+                        foreach (Container container in list)
+                        {
+                            container.Scale = parentScale;
+                            container.Rotation = parentRotation;
+                        }
+                    }
+                });
+
+                AddAssert("Check if state is valid", () =>
+                {
+                    foreach (int i in Enumerable.Range(0, parentContainers.Count))
+                    {
+                        foreach (int j in Enumerable.Range(0, parentContainers[i].Count))
+                        {
+                            if (!uprightAspectMaintainingContainerStateIsValid(parentContainers[i][j], childContainers[i][j]))
+                                return false;
+                        }
+                    }
+
+                    return true;
+                });
+            }
+        }
+
+        private bool uprightAspectMaintainingContainerStateIsValid(Container parent, UprightAspectMaintainingContainer child)
+        {
+            Matrix3 parentMatrix = parent.DrawInfo.Matrix;
+            Matrix3 childMatrix = child.DrawInfo.Matrix;
+            Vector3 childScale = childMatrix.ExtractScale();
+            Vector3 parentScale = parentMatrix.ExtractScale();
+
+            // Orientation check
+            if (!(isNearlyZero(MathF.Abs(childMatrix.M21)) && isNearlyZero(MathF.Abs(childMatrix.M12))))
+                return false;
+
+            // flip check
+            if (!(childMatrix.M11 * childMatrix.M22 > 0))
+                return false;
+
+            // Aspect ratio check
+            if (!isNearlyZero(childScale.X - childScale.Y))
+                return false;
+
+            // ScalingMode check
+            switch (child.Scaling)
+            {
+                case ScaleMode.NoScaling:
+                    if (!(isNearlyZero(childMatrix.M11 - 1.0f) && isNearlyZero(childMatrix.M22 - 1.0f)))
+                        return false;
+
+                    break;
+
+                case ScaleMode.Vertical:
+                    if (!(checkScaling(child.ScalingFactor, parentScale.Y, childScale.Y)))
+                        return false;
+
+                    break;
+
+                case ScaleMode.Horizontal:
+                    if (!(checkScaling(child.ScalingFactor, parentScale.X, childScale.X)))
+                        return false;
+
+                    break;
+            }
+
+            return true;
+        }
+
+        private bool checkScaling(float scalingFactor, float parentScale, float childScale)
+        {
+            if (scalingFactor <= 1.0f)
+            {
+                if (!isNearlyZero(1.0f + (parentScale - 1.0f) * scalingFactor - childScale))
+                    return false;
+            }
+            else if (scalingFactor > 1.0f)
+            {
+                if (parentScale < 1.0f)
+                {
+                    if (!isNearlyZero((parentScale * (1.0f / scalingFactor)) - childScale))
+                        return false;
+                }
+                else if (!isNearlyZero(parentScale * scalingFactor - childScale))
+                    return false;
+            }
+
+            return true;
+        }
+
+        private bool isNearlyZero(float f, float epsilon = Precision.FLOAT_EPSILON)
+        {
+            return f < epsilon;
+        }
+    }
+}

osu.Game.Tournament.Tests/Screens/TestSceneGameplayScreen.cs

@@ -53,7 +53,7 @@ namespace osu.Game.Tournament.Tests.Screens
         {
             AddStep("setup screen", () =>
             {
-                Remove(chat);
+                Remove(chat, false);
 
                 Children = new Drawable[]
                 {

osu.Game.Tournament/Models/TournamentMatch.cs

@@ -106,13 +106,16 @@ namespace osu.Game.Tournament.Models
         }
 
         /// <summary>
-        /// Initialise this match with zeroed scores. Will be a noop if either team is not present.
+        /// Initialise this match with zeroed scores. Will be a noop if either team is not present or if either of the scores are non-zero.
         /// </summary>
         public void StartMatch()
         {
             if (Team1.Value == null || Team2.Value == null)
                 return;
 
+            if (Team1Score.Value > 0 || Team2Score.Value > 0)
+                return;
+
             Team1Score.Value = 0;
             Team2Score.Value = 0;
         }

osu.Game.Tournament/Screens/Drawings/Components/Group.cs

@@ -93,7 +93,7 @@ namespace osu.Game.Tournament.Screens.Drawings.Components
         {
             allTeams.RemoveAll(gt => gt.Team == team);
 
-            if (teams.RemoveAll(gt => gt.Team == team) > 0)
+            if (teams.RemoveAll(gt => gt.Team == team, true) > 0)
             {
                 TeamsCount--;
                 return true;

osu.Game.Tournament/Screens/Drawings/Components/ScrollingTeamContainer.cs

@@ -170,7 +170,7 @@ namespace osu.Game.Tournament.Screens.Drawings.Components
 
             availableTeams.Add(team);
 
-            RemoveAll(c => c is ScrollingTeam);
+            RemoveAll(c => c is ScrollingTeam, true);
             setScrollState(ScrollState.Idle);
         }
 
@@ -186,7 +186,7 @@ namespace osu.Game.Tournament.Screens.Drawings.Components
         public void ClearTeams()
         {
             availableTeams.Clear();
-            RemoveAll(c => c is ScrollingTeam);
+            RemoveAll(c => c is ScrollingTeam, true);
             setScrollState(ScrollState.Idle);
         }
 

osu.Game.Tournament/Screens/Drawings/Components/VisualiserContainer.cs

@@ -57,7 +57,7 @@ namespace osu.Game.Tournament.Screens.Drawings.Components
             if (allLines.Count == 0)
                 return;
 
-            Remove(allLines.First());
+            Remove(allLines.First(), true);
             allLines.Remove(allLines.First());
         }
 

osu.Game.Tournament/Screens/Editors/TournamentEditorScreen.cs

@@ -106,7 +106,7 @@ namespace osu.Game.Tournament.Screens.Editors
                         break;
 
                     case NotifyCollectionChangedAction.Remove:
-                        args.OldItems.Cast<TModel>().ForEach(i => flow.RemoveAll(d => d.Model == i));
+                        args.OldItems.Cast<TModel>().ForEach(i => flow.RemoveAll(d => d.Model == i, true));
                         break;
                 }
             };

osu.Game.Tournament/Screens/Gameplay/Components/TeamScoreDisplay.cs

@@ -25,6 +25,7 @@ namespace osu.Game.Tournament.Screens.Gameplay.Components
 
         public bool ShowScore
         {
+            get => teamDisplay.ShowScore;
             set => teamDisplay.ShowScore = value;
         }
 
@@ -92,10 +93,14 @@ namespace osu.Game.Tournament.Screens.Gameplay.Components
 
         private void teamChanged(ValueChangedEvent<TournamentTeam> team)
         {
+            bool wasShowingScores = teamDisplay?.ShowScore ?? false;
+
             InternalChildren = new Drawable[]
             {
                 teamDisplay = new TeamDisplay(team.NewValue, teamColour, currentTeamScore, currentMatch.Value?.PointsToWin ?? 0),
             };
+
+            teamDisplay.ShowScore = wasShowingScores;
         }
     }
 }

osu.Game.Tournament/Screens/Ladder/Components/DrawableTournamentMatch.cs

@@ -280,7 +280,7 @@ namespace osu.Game.Tournament.Screens.Ladder.Components
 
         protected override bool OnClick(ClickEvent e)
         {
-            if (editorInfo == null || Match is ConditionalTournamentMatch)
+            if (editorInfo == null || Match is ConditionalTournamentMatch || e.Button != MouseButton.Left)
                 return false;
 
             Selected = true;

osu.Game.Tournament/Screens/MapPool/MapPoolScreen.cs

@@ -46,7 +46,10 @@ namespace osu.Game.Tournament.Screens.MapPool
                     Loop = true,
                     RelativeSizeAxes = Axes.Both,
                 },
-                new MatchHeader(),
+                new MatchHeader
+                {
+                    ShowScores = true,
+                },
                 mapFlows = new FillFlowContainer<FillFlowContainer<TournamentBeatmapPanel>>
                 {
                     Y = 160,

osu.Game/BackgroundBeatmapProcessor.cs

@@ -7,6 +7,7 @@ using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Newtonsoft.Json;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -14,6 +15,7 @@ using osu.Framework.Logging;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Rulesets;
+using osu.Game.Scoring;
 using osu.Game.Screens.Play;
 
 namespace osu.Game
@@ -23,6 +25,9 @@ namespace osu.Game
         [Resolved]
         private RulesetStore rulesetStore { get; set; } = null!;
 
+        [Resolved]
+        private ScoreManager scoreManager { get; set; } = null!;
+
         [Resolved]
         private RealmAccess realmAccess { get; set; } = null!;
 
@@ -46,6 +51,7 @@ namespace osu.Game
                 Logger.Log("Beginning background beatmap processing..");
                 checkForOutdatedStarRatings();
                 processBeatmapSetsWithMissingMetrics();
+                processScoresWithMissingStatistics();
             }).ContinueWith(t =>
             {
                 if (t.Exception?.InnerException is ObjectDisposedException)
@@ -140,5 +146,52 @@ namespace osu.Game
                 });
             }
         }
+
+        private void processScoresWithMissingStatistics()
+        {
+            HashSet<Guid> scoreIds = new HashSet<Guid>();
+
+            Logger.Log("Querying for scores to reprocess...");
+
+            realmAccess.Run(r =>
+            {
+                foreach (var score in r.All<ScoreInfo>())
+                {
+                    if (score.Statistics.Sum(kvp => kvp.Value) > 0 && score.MaximumStatistics.Sum(kvp => kvp.Value) == 0)
+                        scoreIds.Add(score.ID);
+                }
+            });
+
+            Logger.Log($"Found {scoreIds.Count} scores which require reprocessing.");
+
+            foreach (var id in scoreIds)
+            {
+                while (localUserPlayInfo?.IsPlaying.Value == true)
+                {
+                    Logger.Log("Background processing sleeping due to active gameplay...");
+                    Thread.Sleep(TimeToSleepDuringGameplay);
+                }
+
+                try
+                {
+                    var score = scoreManager.Query(s => s.ID == id);
+
+                    scoreManager.PopulateMaximumStatistics(score);
+
+                    // Can't use async overload because we're not on the update thread.
+                    // ReSharper disable once MethodHasAsyncOverload
+                    realmAccess.Write(r =>
+                    {
+                        r.Find<ScoreInfo>(id).MaximumStatisticsJson = JsonConvert.SerializeObject(score.MaximumStatistics);
+                    });
+
+                    Logger.Log($"Populated maximum statistics for score {id}");
+                }
+                catch (Exception e)
+                {
+                    Logger.Log(@$"Failed to populate maximum statistics for {id}: {e}");
+                }
+            }
+        }
     }
 }

osu.Game/Beatmaps/BeatmapManager.cs

@@ -319,8 +319,7 @@ namespace osu.Game.Beatmaps
 
                 AddFile(setInfo, stream, createBeatmapFilenameFromMetadata(beatmapInfo));
 
-                setInfo.Hash = beatmapImporter.ComputeHash(setInfo);
-                setInfo.Status = BeatmapOnlineStatus.LocallyModified;
+                updateHashAndMarkDirty(setInfo);
 
                 Realm.Write(r =>
                 {
@@ -363,6 +362,33 @@ namespace osu.Game.Beatmaps
             });
         }
 
+        /// <summary>
+        /// Delete a beatmap difficulty immediately.
+        /// </summary>
+        /// <remarks>
+        /// There's no undoing this operation, as we don't have a soft-deletion flag on <see cref="BeatmapInfo"/>.
+        /// This may be a future consideration if there's a user requirement for undeleting support.
+        /// </remarks>
+        public void DeleteDifficultyImmediately(BeatmapInfo beatmapInfo)
+        {
+            Realm.Write(r =>
+            {
+                if (!beatmapInfo.IsManaged)
+                    beatmapInfo = r.Find<BeatmapInfo>(beatmapInfo.ID);
+
+                Debug.Assert(beatmapInfo.BeatmapSet != null);
+                Debug.Assert(beatmapInfo.File != null);
+
+                var setInfo = beatmapInfo.BeatmapSet;
+
+                DeleteFile(setInfo, beatmapInfo.File);
+                setInfo.Beatmaps.Remove(beatmapInfo);
+
+                updateHashAndMarkDirty(setInfo);
+                workingBeatmapCache.Invalidate(setInfo);
+            });
+        }
+
         /// <summary>
         /// Delete videos from a list of beatmaps.
         /// This will post notifications tracking progress.
@@ -416,6 +442,12 @@ namespace osu.Game.Beatmaps
         public Task<Live<BeatmapSetInfo>?> ImportAsUpdate(ProgressNotification notification, ImportTask importTask, BeatmapSetInfo original) =>
             beatmapImporter.ImportAsUpdate(notification, importTask, original);
 
+        private void updateHashAndMarkDirty(BeatmapSetInfo setInfo)
+        {
+            setInfo.Hash = beatmapImporter.ComputeHash(setInfo);
+            setInfo.Status = BeatmapOnlineStatus.LocallyModified;
+        }
+
         #region Implementation of ICanAcceptFiles
 
         public Task Import(params string[] paths) => beatmapImporter.Import(paths);

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

@@ -17,8 +17,7 @@ namespace osu.Game.Beatmaps.Drawables.Cards.Buttons
 {
     public class DownloadButton : BeatmapCardIconButton
     {
-        public IBindable<DownloadState> State => state;
-        private readonly Bindable<DownloadState> state = new Bindable<DownloadState>();
+        public Bindable<DownloadState> State { get; } = new Bindable<DownloadState>();
 
         private readonly APIBeatmapSet beatmapSet;
 
@@ -48,14 +47,19 @@ namespace osu.Game.Beatmaps.Drawables.Cards.Buttons
         {
             base.LoadComplete();
             preferNoVideo.BindValueChanged(_ => updateState());
-            state.BindValueChanged(_ => updateState(), true);
+            State.BindValueChanged(_ => updateState(), true);
             FinishTransforms(true);
         }
 
         private void updateState()
         {
-            switch (state.Value)
+            switch (State.Value)
             {
+                case DownloadState.Unknown:
+                    Action = null;
+                    TooltipText = string.Empty;
+                    break;
+
                 case DownloadState.Downloading:
                 case DownloadState.Importing:
                     Action = null;

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

@@ -41,6 +41,9 @@ namespace osu.Game.Beatmaps.Drawables.Cards.Buttons
 
             Anchor = Origin = Anchor.Centre;
 
+            // needed for touch input to work when card is not hovered/expanded
+            AlwaysPresent = true;
+
             Children = new Drawable[]
             {
                 icon = new SpriteIcon

osu.Game/Beatmaps/FramedBeatmapClock.cs

@@ -121,7 +121,18 @@ namespace osu.Game.Beatmaps
         protected override void Update()
         {
             base.Update();
-            finalClockSource.ProcessFrame();
+
+            if (Source != null && Source is not IAdjustableClock && Source.CurrentTime < decoupledClock.CurrentTime)
+            {
+                // InterpolatingFramedClock won't interpolate backwards unless its source has an ElapsedFrameTime.
+                // See https://github.com/ppy/osu-framework/blob/ba1385330cc501f34937e08257e586c84e35d772/osu.Framework/Timing/InterpolatingFramedClock.cs#L91-L93
+                // This is not always the case here when doing large seeks.
+                // (Of note, this is not an issue if the source is adjustable, as the source is seeked to be in time by DecoupleableInterpolatingFramedClock).
+                // Rather than trying to get around this by fixing the framework clock stack, let's work around it for now.
+                Seek(Source.CurrentTime);
+            }
+            else
+                finalClockSource.ProcessFrame();
         }
 
         public double TotalAppliedOffset

osu.Game/Database/RealmArchiveModelImporter.cs

@@ -108,47 +108,42 @@ namespace osu.Game.Database
 
             bool isBatchImport = tasks.Length >= minimum_items_considered_batch_import;
 
-            try
+            await Task.WhenAll(tasks.Select(async task =>
             {
-                await Task.WhenAll(tasks.Select(async task =>
+                if (notification.CancellationToken.IsCancellationRequested)
+                    return;
+
+                try
                 {
-                    notification.CancellationToken.ThrowIfCancellationRequested();
+                    var model = await Import(task, isBatchImport, notification.CancellationToken).ConfigureAwait(false);
 
-                    try
+                    lock (imported)
                     {
-                        var model = await Import(task, isBatchImport, notification.CancellationToken).ConfigureAwait(false);
+                        if (model != null)
+                            imported.Add(model);
+                        current++;
 
-                        lock (imported)
-                        {
-                            if (model != null)
-                                imported.Add(model);
-                            current++;
+                        notification.Text = $"Imported {current} of {tasks.Length} {HumanisedModelName}s";
+                        notification.Progress = (float)current / tasks.Length;
+                    }
+                }
+                catch (OperationCanceledException)
+                {
+                }
+                catch (Exception e)
+                {
+                    Logger.Error(e, $@"Could not import ({task})", LoggingTarget.Database);
+                }
+            })).ConfigureAwait(false);
 
-                            notification.Text = $"Imported {current} of {tasks.Length} {HumanisedModelName}s";
-                            notification.Progress = (float)current / tasks.Length;
-                        }
-                    }
-                    catch (TaskCanceledException)
-                    {
-                        throw;
-                    }
-                    catch (Exception e)
-                    {
-                        Logger.Error(e, $@"Could not import ({task})", LoggingTarget.Database);
-                    }
-                })).ConfigureAwait(false);
-            }
-            catch (OperationCanceledException)
+            if (imported.Count == 0)
             {
-                if (imported.Count == 0)
+                if (notification.CancellationToken.IsCancellationRequested)
                 {
                     notification.State = ProgressNotificationState.Cancelled;
                     return imported;
                 }
-            }
 
-            if (imported.Count == 0)
-            {
                 notification.Text = $"{HumanisedModelName.Humanize(LetterCasing.Title)} import failed!";
                 notification.State = ProgressNotificationState.Cancelled;
             }

osu.Game/Graphics/Backgrounds/Background.cs

@@ -57,7 +57,7 @@ namespace osu.Game.Graphics.Backgrounds
         {
             if (bufferedContainer == null && newBlurSigma != Vector2.Zero)
             {
-                RemoveInternal(Sprite);
+                RemoveInternal(Sprite, false);
 
                 AddInternal(bufferedContainer = new BufferedContainer(cachedFrameBuffer: true)
                 {

osu.Game/Graphics/Containers/Markdown/OsuMarkdownContainer.cs

@@ -4,7 +4,9 @@
 #nullable disable
 
 using Markdig;
-using Markdig.Extensions.AutoIdentifiers;
+using Markdig.Extensions.AutoLinks;
+using Markdig.Extensions.EmphasisExtras;
+using Markdig.Extensions.Footnotes;
 using Markdig.Extensions.Tables;
 using Markdig.Extensions.Yaml;
 using Markdig.Syntax;
@@ -18,6 +20,18 @@ namespace osu.Game.Graphics.Containers.Markdown
 {
     public class OsuMarkdownContainer : MarkdownContainer
     {
+        /// <summary>
+        /// Allows this markdown container to parse and link footnotes.
+        /// </summary>
+        /// <seealso cref="FootnoteExtension"/>
+        protected virtual bool Footnotes => false;
+
+        /// <summary>
+        /// Allows this markdown container to make URL text clickable.
+        /// </summary>
+        /// <seealso cref="AutoLinkExtension"/>
+        protected virtual bool Autolinks => false;
+
         public OsuMarkdownContainer()
         {
             LineSpacing = 21;
@@ -78,10 +92,22 @@ namespace osu.Game.Graphics.Containers.Markdown
             return new OsuMarkdownUnorderedListItem(level);
         }
 
+        // reference: https://github.com/ppy/osu-web/blob/05488a96b25b5a09f2d97c54c06dd2bae59d1dc8/app/Libraries/Markdown/OsuMarkdown.php#L301
         protected override MarkdownPipeline CreateBuilder()
-            => new MarkdownPipelineBuilder().UseAutoIdentifiers(AutoIdentifierOptions.GitHub)
-                                            .UseEmojiAndSmiley()
-                                            .UseYamlFrontMatter()
-                                            .UseAdvancedExtensions().Build();
+        {
+            var pipeline = new MarkdownPipelineBuilder()
+                           .UseAutoIdentifiers()
+                           .UsePipeTables()
+                           .UseEmphasisExtras(EmphasisExtraOptions.Strikethrough)
+                           .UseYamlFrontMatter();
+
+            if (Footnotes)
+                pipeline = pipeline.UseFootnotes();
+
+            if (Autolinks)
+                pipeline = pipeline.UseAutoLinks();
+
+            return pipeline.Build();
+        }
     }
 }

osu.Game/Graphics/Containers/SectionsContainer.cs

@@ -35,7 +35,7 @@ namespace osu.Game.Graphics.Containers
                 if (value == expandableHeader) return;
 
                 if (expandableHeader != null)
-                    RemoveInternal(expandableHeader);
+                    RemoveInternal(expandableHeader, false);
 
                 expandableHeader = value;
 
@@ -55,6 +55,7 @@ namespace osu.Game.Graphics.Containers
 
                 fixedHeader?.Expire();
                 fixedHeader = value;
+
                 if (value == null) return;
 
                 AddInternal(fixedHeader);
@@ -70,8 +71,10 @@ namespace osu.Game.Graphics.Containers
                 if (value == footer) return;
 
                 if (footer != null)
-                    scrollContainer.Remove(footer);
+                    scrollContainer.Remove(footer, false);
+
                 footer = value;
+
                 if (value == null) return;
 
                 footer.Anchor |= Anchor.y2;

osu.Game/Graphics/Containers/SelectionCycleFillFlowContainer.cs

@@ -59,7 +59,7 @@ namespace osu.Game.Graphics.Containers
             drawable.StateChanged += state => selectionChanged(drawable, state);
         }
 
-        public override bool Remove(T drawable)
+        public override bool Remove(T drawable, bool disposeImmediately)
             => throw new NotSupportedException($"Cannot remove drawables from {nameof(SelectionCycleFillFlowContainer<T>)}");
 
         private void setSelected(int? value)

osu.Game/Graphics/Containers/UprightAspectMaintainingContainer.cs

@@ -0,0 +1,119 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Layout;
+using osuTK;
+
+namespace osu.Game.Graphics.Containers
+{
+    /// <summary>
+    /// A container that reverts any rotation (and optionally scale) applied by its direct parent.
+    /// </summary>
+    public class UprightAspectMaintainingContainer : Container
+    {
+        /// <summary>
+        /// Controls how much this container scales compared to its parent (default is 1.0f).
+        /// </summary>
+        public float ScalingFactor { get; set; } = 1;
+
+        /// <summary>
+        /// Controls the scaling of this container.
+        /// </summary>
+        public ScaleMode Scaling { get; set; } = ScaleMode.Vertical;
+
+        private readonly LayoutValue layout = new LayoutValue(Invalidation.DrawInfo, InvalidationSource.Parent);
+
+        public UprightAspectMaintainingContainer()
+        {
+            AddLayout(layout);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (!layout.IsValid)
+            {
+                keepUprightAndUnstretched();
+                layout.Validate();
+            }
+        }
+
+        /// <summary>
+        /// Keeps the drawable upright and unstretched preventing it from being rotated, sheared, scaled or flipped with its Parent.
+        /// </summary>
+        private void keepUprightAndUnstretched()
+        {
+            // Decomposes the inverse of the parent DrawInfo.Matrix into rotation, shear and scale.
+            var parentMatrix = Parent.DrawInfo.Matrix;
+
+            // Remove Translation.>
+            parentMatrix.M31 = 0.0f;
+            parentMatrix.M32 = 0.0f;
+
+            Matrix3 reversedParent = parentMatrix.Inverted();
+
+            // Extract the rotation.
+            float angle = MathF.Atan2(reversedParent.M12, reversedParent.M11);
+            Rotation = MathHelper.RadiansToDegrees(angle);
+
+            // Remove rotation from the C matrix so that it only contains shear and scale.
+            Matrix3 m = Matrix3.CreateRotationZ(-angle);
+            reversedParent *= m;
+
+            // Extract shear.
+            float alpha = reversedParent.M21 / reversedParent.M22;
+            Shear = new Vector2(-alpha, 0);
+
+            // Etract scale.
+            float sx = reversedParent.M11;
+            float sy = reversedParent.M22;
+
+            Vector3 parentScale = parentMatrix.ExtractScale();
+
+            float usedScale = 1.0f;
+
+            switch (Scaling)
+            {
+                case ScaleMode.Horizontal:
+                    usedScale = parentScale.X;
+                    break;
+
+                case ScaleMode.Vertical:
+                    usedScale = parentScale.Y;
+                    break;
+            }
+
+            if (Scaling != ScaleMode.NoScaling)
+            {
+                if (ScalingFactor < 1.0f)
+                    usedScale = 1.0f + (usedScale - 1.0f) * ScalingFactor;
+                if (ScalingFactor > 1.0f)
+                    usedScale = (usedScale < 1.0f) ? usedScale * (1.0f / ScalingFactor) : usedScale * ScalingFactor;
+            }
+
+            Scale = new Vector2(sx * usedScale, sy * usedScale);
+        }
+    }
+
+    public enum ScaleMode
+    {
+        /// <summary>
+        /// Prevent this container from scaling.
+        /// </summary>
+        NoScaling,
+
+        /// <summary>
+        /// Scale uniformly (maintaining aspect ratio) based on the vertical scale of the parent.
+        /// </summary>
+        Vertical,
+
+        /// <summary>
+        /// Scale uniformly (maintaining aspect ratio) based on the horizontal scale of the parent.
+        /// </summary>
+        Horizontal,
+    }
+}

osu.Game/Graphics/OsuColour.cs

@@ -102,26 +102,31 @@ namespace osu.Game.Graphics
         /// <summary>
         /// Retrieves the colour for a <see cref="HitResult"/>.
         /// </summary>
-        public Color4 ForHitResult(HitResult judgement)
+        public Color4 ForHitResult(HitResult result)
         {
-            switch (judgement)
+            switch (result)
             {
-                case HitResult.Perfect:
-                case HitResult.Great:
-                    return Blue;
-
-                case HitResult.Ok:
-                case HitResult.Good:
-                    return Green;
+                case HitResult.SmallTickMiss:
+                case HitResult.LargeTickMiss:
+                case HitResult.Miss:
+                    return Red;
 
                 case HitResult.Meh:
                     return Yellow;
 
-                case HitResult.Miss:
-                    return Red;
+                case HitResult.Ok:
+                    return Green;
+
+                case HitResult.Good:
+                    return GreenLight;
+
+                case HitResult.SmallTickHit:
+                case HitResult.LargeTickHit:
+                case HitResult.Great:
+                    return Blue;
 
                 default:
-                    return Color4.White;
+                    return BlueLight;
             }
         }