Update resources

CodeAnalysis/BannedSymbols.txt

@@ -15,8 +15,6 @@ M:Realms.CollectionExtensions.SubscribeForNotifications`1(System.Collections.Gen
 M:System.Threading.Tasks.Task.Wait();Don't use Task.Wait. Use Task.WaitSafely() to ensure we avoid deadlocks.
 P:System.Threading.Tasks.Task`1.Result;Don't use Task.Result. Use Task.GetResultSafely() to ensure we avoid deadlocks.
 M:System.Threading.ManualResetEventSlim.Wait();Specify a timeout to avoid waiting forever.
-M:System.Char.ToLower(System.Char);char.ToLower() changes behaviour depending on CultureInfo.CurrentCulture. Use char.ToLowerInvariant() instead. If wanting culture-sensitive behaviour, explicitly provide CultureInfo.CurrentCulture.
-M:System.Char.ToUpper(System.Char);char.ToUpper() changes behaviour depending on CultureInfo.CurrentCulture. Use char.ToUpperInvariant() instead. If wanting culture-sensitive behaviour, explicitly provide CultureInfo.CurrentCulture.
 M:System.String.ToLower();string.ToLower() changes behaviour depending on CultureInfo.CurrentCulture. Use string.ToLowerInvariant() instead. If wanting culture-sensitive behaviour, explicitly provide CultureInfo.CurrentCulture or use LocalisableString.
 M:System.String.ToUpper();string.ToUpper() changes behaviour depending on CultureInfo.CurrentCulture. Use string.ToUpperInvariant() instead. If wanting culture-sensitive behaviour, explicitly provide CultureInfo.CurrentCulture or use LocalisableString.
 M:Humanizer.InflectorExtensions.Pascalize(System.String);Humanizer's .Pascalize() extension method changes behaviour depending on CultureInfo.CurrentCulture. Use StringDehumanizeExtensions.ToPascalCase() instead.

osu.Android.props

@@ -51,8 +51,8 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2022.1021.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2022.1022.1" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2022.1008.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2022.916.1" />
   </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/Mods/TestSceneCatchModFlashlight.cs

@@ -1,23 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using NUnit.Framework;
-using osu.Game.Rulesets.Catch.Mods;
-using osu.Game.Tests.Visual;
-
-namespace osu.Game.Rulesets.Catch.Tests.Mods
-{
-    public class TestSceneCatchModFlashlight : ModTestScene
-    {
-        protected override Ruleset CreatePlayerRuleset() => new CatchRuleset();
-
-        [TestCase(1f)]
-        [TestCase(0.5f)]
-        [TestCase(1.25f)]
-        [TestCase(1.5f)]
-        public void TestSizeMultiplier(float sizeMultiplier) => CreateModTest(new ModTestData { Mod = new CatchModFlashlight { SizeMultiplier = { Value = sizeMultiplier } }, PassCondition = () => true });
-
-        [Test]
-        public void TestComboBasedSize([Values] bool comboBasedSize) => CreateModTest(new ModTestData { Mod = new CatchModFlashlight { ComboBasedSize = { Value = comboBasedSize } }, PassCondition = () => true });
-    }
-}

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

@@ -1,10 +1,10 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+#nullable disable
+
 using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Utils;
 using osu.Game.Rulesets.Catch.Objects;
@@ -12,8 +12,6 @@ using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Screens.Play;
-using osu.Game.Tests.Visual;
 using osuTK;
 using osuTK.Graphics;
 
@@ -21,28 +19,15 @@ namespace osu.Game.Rulesets.Catch.Tests
 {
     public class TestSceneComboCounter : CatchSkinnableTestScene
     {
-        private ScoreProcessor scoreProcessor = null!;
+        private ScoreProcessor scoreProcessor;
 
         private Color4 judgedObjectColour = Color4.White;
 
-        private readonly Bindable<bool> showHud = new Bindable<bool>(true);
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            Dependencies.CacheAs<Player>(new TestPlayer
-            {
-                ShowingOverlayComponents = { BindTarget = showHud },
-            });
-        }
-
         [SetUp]
         public void SetUp() => Schedule(() =>
         {
             scoreProcessor = new ScoreProcessor(new CatchRuleset());
 
-            showHud.Value = true;
-
             SetContents(_ => new CatchComboDisplay
             {
                 Anchor = Anchor.Centre,
@@ -66,15 +51,9 @@ namespace osu.Game.Rulesets.Catch.Tests
                     1f
                 );
             });
-
-            AddStep("set hud to never show", () => showHud.Value = false);
-            AddRepeatStep("perform hit", () => performJudgement(HitResult.Great), 5);
-
-            AddStep("set hud to show", () => showHud.Value = true);
-            AddRepeatStep("perform hit", () => performJudgement(HitResult.Great), 5);
         }
 
-        private void performJudgement(HitResult type, Judgement? judgement = null)
+        private void performJudgement(HitResult type, Judgement judgement = null)
         {
             var judgedObject = new DrawableFruit(new Fruit()) { AccentColour = { Value = judgedObjectColour } };
 

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

@@ -36,7 +36,5 @@ namespace osu.Game.Rulesets.Catch.Edit
 
             return base.CreateHitObjectBlueprintFor(hitObject);
         }
-
-        protected sealed override DragBox CreateDragBox() => new ScrollingDragBox(Composer.Playfield);
     }
 }

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

@@ -1,49 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Catch.UI;
-using osu.Game.Rulesets.UI;
-using osuTK;
-
-namespace osu.Game.Rulesets.Catch.Edit
-{
-    public class CatchEditorPlayfieldAdjustmentContainer : PlayfieldAdjustmentContainer
-    {
-        protected override Container<Drawable> Content => content;
-        private readonly Container content;
-
-        public CatchEditorPlayfieldAdjustmentContainer()
-        {
-            Anchor = Anchor.TopCentre;
-            Origin = Anchor.TopCentre;
-            Size = new Vector2(0.8f, 0.9f);
-
-            InternalChild = new ScalingContainer
-            {
-                Anchor = Anchor.TopCentre,
-                Origin = Anchor.TopCentre,
-                Child = content = new Container { RelativeSizeAxes = Axes.Both },
-            };
-        }
-
-        private class ScalingContainer : Container
-        {
-            public ScalingContainer()
-            {
-                RelativeSizeAxes = Axes.Y;
-                Width = CatchPlayfield.WIDTH;
-            }
-
-            protected override void Update()
-            {
-                base.Update();
-
-                Scale = new Vector2(Math.Min(Parent.ChildSize.X / CatchPlayfield.WIDTH, Parent.ChildSize.Y / CatchPlayfield.HEIGHT));
-                Height = 1 / Scale.Y;
-            }
-        }
-    }
-}

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

@@ -12,10 +12,8 @@ using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input;
-using osu.Framework.Input.Events;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Input.Bindings;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Edit;
@@ -39,12 +37,6 @@ namespace osu.Game.Rulesets.Catch.Edit
 
         private InputManager inputManager;
 
-        private readonly BindableDouble timeRangeMultiplier = new BindableDouble(1)
-        {
-            MinValue = 1,
-            MaxValue = 10,
-        };
-
         public CatchHitObjectComposer(CatchRuleset ruleset)
             : base(ruleset)
         {
@@ -59,10 +51,7 @@ namespace osu.Game.Rulesets.Catch.Edit
 
             LayerBelowRuleset.Add(new PlayfieldBorder
             {
-                Anchor = Anchor.BottomCentre,
-                Origin = Anchor.BottomCentre,
-                RelativeSizeAxes = Axes.X,
-                Height = CatchPlayfield.HEIGHT,
+                RelativeSizeAxes = Axes.Both,
                 PlayfieldBorderStyle = { Value = PlayfieldBorderStyle.Corners }
             });
 
@@ -88,30 +77,8 @@ namespace osu.Game.Rulesets.Catch.Edit
             updateDistanceSnapGrid();
         }
 
-        public override bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
-        {
-            switch (e.Action)
-            {
-                // Note that right now these are hard to use as the default key bindings conflict with existing editor key bindings.
-                // In the future we will want to expose this via UI and potentially change the key bindings to be editor-specific.
-                // May be worth considering standardising "zoom" behaviour with what the timeline uses (ie. alt-wheel) but that may cause new conflicts.
-                case GlobalAction.IncreaseScrollSpeed:
-                    this.TransformBindableTo(timeRangeMultiplier, timeRangeMultiplier.Value - 1, 200, Easing.OutQuint);
-                    break;
-
-                case GlobalAction.DecreaseScrollSpeed:
-                    this.TransformBindableTo(timeRangeMultiplier, timeRangeMultiplier.Value + 1, 200, Easing.OutQuint);
-                    break;
-            }
-
-            return base.OnPressed(e);
-        }
-
         protected override DrawableRuleset<CatchHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods = null) =>
-            new DrawableCatchEditorRuleset(ruleset, beatmap, mods)
-            {
-                TimeRangeMultiplier = { BindTarget = timeRangeMultiplier, }
-            };
+            new DrawableCatchEditorRuleset(ruleset, beatmap, mods);
 
         protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
         {

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

@@ -4,7 +4,6 @@
 #nullable disable
 
 using System.Collections.Generic;
-using osu.Framework.Bindables;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Mods;
@@ -14,24 +13,11 @@ namespace osu.Game.Rulesets.Catch.Edit
 {
     public class DrawableCatchEditorRuleset : DrawableCatchRuleset
     {
-        public readonly BindableDouble TimeRangeMultiplier = new BindableDouble(1);
-
         public DrawableCatchEditorRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods = null)
             : base(ruleset, beatmap, mods)
         {
         }
 
-        protected override void Update()
-        {
-            base.Update();
-
-            double gamePlayTimeRange = GetTimeRange(Beatmap.Difficulty.ApproachRate);
-            float playfieldStretch = Playfield.DrawHeight / CatchPlayfield.HEIGHT;
-            TimeRange.Value = gamePlayTimeRange * TimeRangeMultiplier.Value * playfieldStretch;
-        }
-
         protected override Playfield CreatePlayfield() => new CatchEditorPlayfield(Beatmap.Difficulty);
-
-        public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new CatchEditorPlayfieldAdjustmentContainer();
     }
 }

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

@@ -45,7 +45,7 @@ namespace osu.Game.Rulesets.Catch.Mods
             {
                 this.playfield = playfield;
 
-                FlashlightSize = new Vector2(0, GetSize());
+                FlashlightSize = new Vector2(0, GetSizeFor(0));
                 FlashlightSmoothness = 1.4f;
             }
 
@@ -66,9 +66,9 @@ namespace osu.Game.Rulesets.Catch.Mods
                 FlashlightPosition = playfield.CatcherArea.ToSpaceOfOtherDrawable(playfield.Catcher.DrawPosition, this);
             }
 
-            protected override void UpdateFlashlightSize(float size)
+            protected override void OnComboChange(ValueChangedEvent<int> e)
             {
-                this.TransformTo(nameof(FlashlightSize), new Vector2(0, size), FLASHLIGHT_FADE_DURATION);
+                this.TransformTo(nameof(FlashlightSize), new Vector2(0, GetSizeFor(e.NewValue)), FLASHLIGHT_FADE_DURATION);
             }
 
             protected override string FragmentShader => "CircularFlashlight";

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

@@ -19,20 +19,17 @@ namespace osu.Game.Rulesets.Catch.Mods
     {
         public override LocalisableString Description => @"Use the mouse to control the catcher.";
 
-        private DrawableCatchRuleset drawableRuleset = null!;
+        private DrawableRuleset<CatchHitObject> drawableRuleset = null!;
 
         public void ApplyToDrawableRuleset(DrawableRuleset<CatchHitObject> drawableRuleset)
         {
-            this.drawableRuleset = (DrawableCatchRuleset)drawableRuleset;
+            this.drawableRuleset = drawableRuleset;
         }
 
         public void ApplyToPlayer(Player player)
         {
             if (!drawableRuleset.HasReplayLoaded.Value)
-            {
-                var catchPlayfield = (CatchPlayfield)drawableRuleset.Playfield;
-                catchPlayfield.CatcherArea.Add(new MouseInputHelper(catchPlayfield.CatcherArea));
-            }
+                drawableRuleset.Cursor.Add(new MouseInputHelper((CatchPlayfield)drawableRuleset.Playfield));
         }
 
         private class MouseInputHelper : Drawable, IKeyBindingHandler<CatchAction>, IRequireHighFrequencyMousePosition
@@ -41,10 +38,9 @@ namespace osu.Game.Rulesets.Catch.Mods
 
             public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
 
-            public MouseInputHelper(CatcherArea catcherArea)
+            public MouseInputHelper(CatchPlayfield playfield)
             {
-                this.catcherArea = catcherArea;
-
+                catcherArea = playfield.CatcherArea;
                 RelativeSizeAxes = Axes.Both;
             }
 

osu.Game.Rulesets.Catch/Skinning/Legacy/CatchLegacySkinTransformer.cs

@@ -13,10 +13,6 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
 {
     public class CatchLegacySkinTransformer : LegacySkinTransformer
     {
-        public override bool IsProvidingLegacyResources => base.IsProvidingLegacyResources || hasPear;
-
-        private bool hasPear => GetTexture("fruit-pear") != null;
-
         /// <summary>
         /// For simplicity, let's use legacy combo font texture existence as a way to identify legacy skins from default.
         /// </summary>
@@ -53,7 +49,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
                 switch (catchSkinComponent.Component)
                 {
                     case CatchSkinComponents.Fruit:
-                        if (hasPear)
+                        if (GetTexture("fruit-pear") != null)
                             return new LegacyFruitPiece();
 
                         return null;

osu.Game.Rulesets.Catch/Skinning/Legacy/LegacyCatchComboCounter.cs

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+#nullable disable
+
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Catch.UI;

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

@@ -1,13 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
+#nullable disable
+
+using JetBrains.Annotations;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Screens.Play;
 using osu.Game.Skinning;
 using osuTK.Graphics;
 
@@ -20,29 +19,14 @@ namespace osu.Game.Rulesets.Catch.UI
     {
         private int currentCombo;
 
-        public ICatchComboCounter? ComboCounter => Drawable as ICatchComboCounter;
-
-        private readonly IBindable<bool> showCombo = new BindableBool(true);
+        [CanBeNull]
+        public ICatchComboCounter ComboCounter => Drawable as ICatchComboCounter;
 
         public CatchComboDisplay()
             : base(new CatchSkinComponent(CatchSkinComponents.CatchComboCounter), _ => Empty())
         {
         }
 
-        [Resolved(canBeNull: true)]
-        private Player? player { get; set; }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            if (player != null)
-            {
-                showCombo.BindTo(player.ShowingOverlayComponents);
-                showCombo.BindValueChanged(s => this.FadeTo(s.NewValue ? 1 : 0, HUDOverlay.FADE_DURATION, HUDOverlay.FADE_EASING), true);
-            }
-        }
-
         protected override void SkinChanged(ISkinSource skin)
         {
             base.SkinChanged(skin);

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

@@ -23,12 +23,6 @@ namespace osu.Game.Rulesets.Catch.UI
         /// </summary>
         public const float WIDTH = 512;
 
-        /// <summary>
-        /// The height of the playfield.
-        /// This doesn't include the catcher area.
-        /// </summary>
-        public const float HEIGHT = 384;
-
         /// <summary>
         /// The center position of the playfield.
         /// </summary>

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

@@ -31,7 +31,7 @@ namespace osu.Game.Rulesets.Catch.UI
             : base(ruleset, beatmap, mods)
         {
             Direction.Value = ScrollingDirection.Down;
-            TimeRange.Value = GetTimeRange(beatmap.Difficulty.ApproachRate);
+            TimeRange.Value = IBeatmapDifficultyInfo.DifficultyRange(beatmap.Difficulty.ApproachRate, 1800, 1200, 450);
         }
 
         [BackgroundDependencyLoader]
@@ -42,8 +42,6 @@ namespace osu.Game.Rulesets.Catch.UI
                 KeyBindingInputManager.Add(new CatchTouchInputMapper());
         }
 
-        protected double GetTimeRange(float approachRate) => IBeatmapDifficultyInfo.DifficultyRange(approachRate, 1800, 1200, 450);
-
         protected override ReplayInputHandler CreateReplayInputHandler(Replay replay) => new CatchFramedReplayInputHandler(replay);
 
         protected override ReplayRecorder CreateReplayRecorder(Score score) => new CatchReplayRecorder(score, (CatchPlayfield)Playfield);

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

@@ -3,11 +3,9 @@
 
 #nullable disable
 
-using System.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
-using osu.Game.Input.Bindings;
 using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Mania.Tests
@@ -39,7 +37,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 {
                 }
 
-                protected override void ReloadMappings(IQueryable<RealmKeyBinding> realmKeyBindings)
+                protected override void ReloadMappings()
                 {
                     KeyBindings = DefaultKeyBindings;
                 }

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

@@ -1,23 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using NUnit.Framework;
-using osu.Game.Rulesets.Mania.Mods;
-using osu.Game.Tests.Visual;
-
-namespace osu.Game.Rulesets.Mania.Tests.Mods
-{
-    public class TestSceneManiaModFlashlight : ModTestScene
-    {
-        protected override Ruleset CreatePlayerRuleset() => new ManiaRuleset();
-
-        [TestCase(1f)]
-        [TestCase(0.5f)]
-        [TestCase(1.5f)]
-        [TestCase(3f)]
-        public void TestSizeMultiplier(float sizeMultiplier) => CreateModTest(new ModTestData { Mod = new ManiaModFlashlight { SizeMultiplier = { Value = sizeMultiplier } }, PassCondition = () => true });
-
-        [Test]
-        public void TestComboBasedSize([Values] bool comboBasedSize) => CreateModTest(new ModTestData { Mod = new ManiaModFlashlight { ComboBasedSize = { Value = comboBasedSize } }, PassCondition = () => true });
-    }
-}

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

@@ -38,7 +38,7 @@ namespace osu.Game.Rulesets.Mania.Difficulty
             countOk = score.Statistics.GetValueOrDefault(HitResult.Ok);
             countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
             countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
-            scoreAccuracy = calculateCustomAccuracy();
+            scoreAccuracy = customAccuracy;
 
             // Arbitrary initial value for scaling pp in order to standardize distributions across game modes.
             // The specific number has no intrinsic meaning and can be adjusted as needed.
@@ -73,12 +73,6 @@ namespace osu.Game.Rulesets.Mania.Difficulty
         /// <summary>
         /// Accuracy used to weight judgements independently from the score's actual accuracy.
         /// </summary>
-        private double calculateCustomAccuracy()
-        {
-            if (totalHits == 0)
-                return 0;
-
-            return (countPerfect * 320 + countGreat * 300 + countGood * 200 + countOk * 100 + countMeh * 50) / (totalHits * 320);
-        }
+        private double customAccuracy => (countPerfect * 320 + countGreat * 300 + countGood * 200 + countOk * 100 + countMeh * 50) / (totalHits * 320);
     }
 }

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

@@ -33,7 +33,5 @@ namespace osu.Game.Rulesets.Mania.Edit
         }
 
         protected override SelectionHandler<HitObject> CreateSelectionHandler() => new ManiaSelectionHandler();
-
-        protected sealed override DragBox CreateDragBox() => new ScrollingDragBox(Composer.Playfield);
     }
 }

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

@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Mania.Mods
             public ManiaFlashlight(ManiaModFlashlight modFlashlight)
                 : base(modFlashlight)
             {
-                FlashlightSize = new Vector2(DrawWidth, GetSize());
+                FlashlightSize = new Vector2(DrawWidth, GetSizeFor(0));
 
                 AddLayout(flashlightProperties);
             }
@@ -54,9 +54,9 @@ namespace osu.Game.Rulesets.Mania.Mods
                 }
             }
 
-            protected override void UpdateFlashlightSize(float size)
+            protected override void OnComboChange(ValueChangedEvent<int> e)
             {
-                this.TransformTo(nameof(FlashlightSize), new Vector2(DrawWidth, size), FLASHLIGHT_FADE_DURATION);
+                this.TransformTo(nameof(FlashlightSize), new Vector2(DrawWidth, GetSizeFor(e.NewValue)), FLASHLIGHT_FADE_DURATION);
             }
 
             protected override string FragmentShader => "RectangularFlashlight";

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

@@ -4,14 +4,12 @@
 #nullable disable
 
 using System;
-using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
-using osu.Game.Audio;
 using osu.Game.Rulesets.Mania.Skinning.Default;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -40,8 +38,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         private Container<DrawableHoldNoteTail> tailContainer;
         private Container<DrawableHoldNoteTick> tickContainer;
 
-        private PausableSkinnableSound slidingSample;
-
         /// <summary>
         /// Contains the size of the hold note covering the whole head/tail bounds. The size of this container changes as the hold note is being pressed.
         /// </summary>
@@ -112,7 +108,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 },
                 tickContainer = new Container<DrawableHoldNoteTick> { RelativeSizeAxes = Axes.Both },
                 tailContainer = new Container<DrawableHoldNoteTail> { RelativeSizeAxes = Axes.Both },
-                slidingSample = new PausableSkinnableSound { Looping = true }
             });
 
             maskedContents.AddRange(new[]
@@ -123,13 +118,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             });
         }
 
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            isHitting.BindValueChanged(updateSlidingSample, true);
-        }
-
         protected override void OnApply()
         {
             base.OnApply();
@@ -334,38 +322,5 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             HoldStartTime = null;
             isHitting.Value = false;
         }
-
-        protected override void LoadSamples()
-        {
-            // Note: base.LoadSamples() isn't called since the slider plays the tail's hitsounds for the time being.
-
-            if (HitObject.SampleControlPoint == null)
-            {
-                throw new InvalidOperationException($"{nameof(HitObject)}s must always have an attached {nameof(HitObject.SampleControlPoint)}."
-                                                    + $" This is an indication that {nameof(HitObject.ApplyDefaults)} has not been invoked on {this}.");
-            }
-
-            slidingSample.Samples = HitObject.CreateSlidingSamples().Select(s => HitObject.SampleControlPoint.ApplyTo(s)).Cast<ISampleInfo>().ToArray();
-        }
-
-        public override void StopAllSamples()
-        {
-            base.StopAllSamples();
-            slidingSample?.Stop();
-        }
-
-        private void updateSlidingSample(ValueChangedEvent<bool> tracking)
-        {
-            if (tracking.NewValue)
-                slidingSample?.Play();
-            else
-                slidingSample?.Stop();
-        }
-
-        protected override void OnFree()
-        {
-            slidingSample.Samples = null;
-            base.OnFree();
-        }
     }
 }

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

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
@@ -90,15 +89,13 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
 
                         Color4 colour;
 
-                        const int total_colours = 7;
-
                         if (stage.IsSpecialColumn(column))
                             colour = new Color4(159, 101, 255, 255);
                         else
                         {
-                            switch (column % total_colours)
+                            switch (column % 8)
                             {
-                                case 0:
+                                default:
                                     colour = new Color4(240, 216, 0, 255);
                                     break;
 
@@ -115,19 +112,20 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
                                     break;
 
                                 case 4:
-                                    colour = new Color4(0, 96, 240, 255);
+                                    colour = new Color4(178, 0, 240, 255);
                                     break;
 
                                 case 5:
-                                    colour = new Color4(0, 226, 240, 255);
+                                    colour = new Color4(0, 96, 240, 255);
                                     break;
 
                                 case 6:
-                                    colour = new Color4(0, 240, 96, 255);
+                                    colour = new Color4(0, 226, 240, 255);
                                     break;
 
-                                default:
-                                    throw new ArgumentOutOfRangeException();
+                                case 7:
+                                    colour = new Color4(0, 240, 96, 255);
+                                    break;
                             }
                         }
 

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

@@ -19,8 +19,6 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 {
     public class ManiaLegacySkinTransformer : LegacySkinTransformer
     {
-        public override bool IsProvidingLegacyResources => base.IsProvidingLegacyResources || hasKeyTexture.Value;
-
         /// <summary>
         /// Mapping of <see cref="HitResult"/> to their corresponding
         /// <see cref="LegacyManiaSkinConfigurationLookups"/> value.

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuDistanceSnapGrid.cs

@@ -12,7 +12,6 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Overlays;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Edit;
@@ -34,9 +33,6 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
         [Cached(typeof(IBeatSnapProvider))]
         private readonly EditorBeatmap editorBeatmap;
 
-        [Cached]
-        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Aquamarine);
-
         [Cached]
         private readonly EditorClock editorClock;
 

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderStreamConversion.cs

@@ -148,37 +148,6 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             });
         }
 
-        [Test]
-        public void TestFloatEdgeCaseConversion()
-        {
-            Slider slider = null;
-
-            AddStep("select first slider", () =>
-            {
-                slider = (Slider)EditorBeatmap.HitObjects.First(h => h is Slider);
-                EditorClock.Seek(slider.StartTime);
-                EditorBeatmap.SelectedHitObjects.Add(slider);
-            });
-
-            AddStep("change to these specific circumstances", () =>
-            {
-                EditorBeatmap.Difficulty.SliderMultiplier = 1;
-                var timingPoint = EditorBeatmap.ControlPointInfo.TimingPointAt(slider.StartTime);
-                timingPoint.BeatLength = 352.941176470588;
-                slider.Path.ControlPoints[^1].Position = new Vector2(-110, 16);
-                slider.Path.ExpectedDistance.Value = 100;
-            });
-
-            convertToStream();
-
-            AddAssert("stream created", () => streamCreatedFor(slider,
-                (time: 0, pathPosition: 0),
-                (time: 0.25, pathPosition: 0.25),
-                (time: 0.5, pathPosition: 0.5),
-                (time: 0.75, pathPosition: 0.75),
-                (time: 1, pathPosition: 1)));
-        }
-
         private bool streamCreatedFor(Slider slider, params (double time, double pathPosition)[] expectedCircles)
         {
             if (EditorBeatmap.HitObjects.Contains(slider))

osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModFlashlight.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.
-
-using NUnit.Framework;
-using osu.Game.Rulesets.Osu.Mods;
-
-namespace osu.Game.Rulesets.Osu.Tests.Mods
-{
-    public class TestSceneOsuModFlashlight : OsuModTestScene
-    {
-        [TestCase(600)]
-        [TestCase(120)]
-        [TestCase(1200)]
-        public void TestFollowDelay(double followDelay) => CreateModTest(new ModTestData { Mod = new OsuModFlashlight { FollowDelay = { Value = followDelay } }, PassCondition = () => true });
-
-        [TestCase(1f)]
-        [TestCase(0.5f)]
-        [TestCase(1.5f)]
-        [TestCase(2f)]
-        public void TestSizeMultiplier(float sizeMultiplier) => CreateModTest(new ModTestData { Mod = new OsuModFlashlight { SizeMultiplier = { Value = sizeMultiplier } }, PassCondition = () => true });
-
-        [Test]
-        public void TestComboBasedSize([Values] bool comboBasedSize) => CreateModTest(new ModTestData { Mod = new OsuModFlashlight { ComboBasedSize = { Value = comboBasedSize } }, PassCondition = () => true });
-    }
-}

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

@@ -4,7 +4,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Utils;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
@@ -13,7 +12,6 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osu.Game.Rulesets.Osu.UI;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests.Mods
@@ -147,10 +145,6 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
 
         private bool isBreak() => Player.IsBreakTime.Value;
 
-        private OsuPlayfield playfield => (OsuPlayfield)Player.DrawableRuleset.Playfield;
-
-        private bool cursorAlphaAlmostEquals(float alpha) =>
-            Precision.AlmostEquals(playfield.Cursor.AsNonNull().Alpha, alpha, 0.1f) &&
-            Precision.AlmostEquals(playfield.Smoke.Alpha, alpha, 0.1f);
+        private bool cursorAlphaAlmostEquals(float alpha) => Precision.AlmostEquals(Player.DrawableRuleset.Cursor.Alpha, alpha, 0.1f);
     }
 }

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

@@ -0,0 +1,21 @@
+// 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.Mods;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestSceneOsuFlashlight : TestSceneOsuPlayer
+    {
+        protected override TestPlayer CreatePlayer(Ruleset ruleset)
+        {
+            SelectedMods.Value = new Mod[] { new OsuModAutoplay(), new OsuModFlashlight(), };
+
+            return base.CreatePlayer(ruleset);
+        }
+    }
+}

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

@@ -14,7 +14,6 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Skinning.Legacy;
 using osu.Game.Skinning;
 using osu.Game.Tests.Visual;
 using osuTK;
@@ -69,8 +68,10 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             AddStep("create slider", () =>
             {
-                var skin = skinManager.GetSkin(DefaultLegacySkin.CreateInfo());
-                var provider = Ruleset.Value.CreateInstance().CreateSkinTransformer(skin, Beatmap.Value.Beatmap);
+                var tintingSkin = skinManager.GetSkin(DefaultLegacySkin.CreateInfo());
+                tintingSkin.Configuration.ConfigDictionary["AllowSliderBallTint"] = "1";
+
+                var provider = Ruleset.Value.CreateInstance().CreateSkinTransformer(tintingSkin, Beatmap.Value.Beatmap);
 
                 Child = new SkinProvidingContainer(provider)
                 {
@@ -91,10 +92,10 @@ namespace osu.Game.Rulesets.Osu.Tests
             });
 
             AddStep("set accent white", () => dho.AccentColour.Value = Color4.White);
-            AddAssert("ball is white", () => dho.ChildrenOfType<LegacySliderBall>().Single().BallColour == Color4.White);
+            AddAssert("ball is white", () => dho.ChildrenOfType<DrawableSliderBall>().Single().AccentColour == Color4.White);
 
             AddStep("set accent red", () => dho.AccentColour.Value = Color4.Red);
-            AddAssert("ball is red", () => dho.ChildrenOfType<LegacySliderBall>().Single().BallColour == Color4.Red);
+            AddAssert("ball is red", () => dho.ChildrenOfType<DrawableSliderBall>().Single().AccentColour == Color4.Red);
         }
 
         private Slider prepareObject(Slider slider)

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

@@ -342,7 +342,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                 double positionWithRepeats = (time - HitObject.StartTime) / HitObject.Duration * HitObject.SpanCount();
                 double pathPosition = positionWithRepeats - (int)positionWithRepeats;
                 // every second span is in the reverse direction - need to reverse the path position.
-                if (positionWithRepeats % 2 >= 1)
+                if (Precision.AlmostBigger(positionWithRepeats % 2, 1))
                     pathPosition = 1 - pathPosition;
 
                 Vector2 position = HitObject.Position + HitObject.Path.PositionAt(pathPosition);

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

@@ -60,9 +60,6 @@ namespace osu.Game.Rulesets.Osu.Edit
         [BackgroundDependencyLoader]
         private void load()
         {
-            // Give a bit of breathing room around the playfield content.
-            PlayfieldContentContainer.Padding = new MarginPadding(10);
-
             LayerBelowRuleset.AddRange(new Drawable[]
             {
                 distanceSnapGridContainer = new Container

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

@@ -62,7 +62,7 @@ namespace osu.Game.Rulesets.Osu.Mods
             {
                 followDelay = modFlashlight.FollowDelay.Value;
 
-                FlashlightSize = new Vector2(0, GetSize());
+                FlashlightSize = new Vector2(0, GetSizeFor(0));
                 FlashlightSmoothness = 1.4f;
             }
 
@@ -83,9 +83,9 @@ namespace osu.Game.Rulesets.Osu.Mods
                 return base.OnMouseMove(e);
             }
 
-            protected override void UpdateFlashlightSize(float size)
+            protected override void OnComboChange(ValueChangedEvent<int> e)
             {
-                this.TransformTo(nameof(FlashlightSize), new Vector2(0, size), FLASHLIGHT_FADE_DURATION);
+                this.TransformTo(nameof(FlashlightSize), new Vector2(0, GetSizeFor(e.NewValue)), FLASHLIGHT_FADE_DURATION);
             }
 
             protected override string FragmentShader => "CircularFlashlight";

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

@@ -3,7 +3,6 @@
 
 using System;
 using osu.Framework.Bindables;
-using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Framework.Timing;
@@ -47,7 +46,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public void Update(Playfield playfield)
         {
-            var cursorPos = playfield.Cursor.AsNonNull().ActiveCursor.DrawPosition;
+            var cursorPos = playfield.Cursor.ActiveCursor.DrawPosition;
 
             foreach (var drawable in playfield.HitObjectContainer.AliveObjects)
             {

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

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Localisation;
@@ -10,7 +9,6 @@ using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.UI;
 using osu.Game.Utils;
 
@@ -35,15 +33,9 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public void Update(Playfield playfield)
         {
-            var osuPlayfield = (OsuPlayfield)playfield;
-            Debug.Assert(osuPlayfield.Cursor != null);
-
-            bool shouldAlwaysShowCursor = IsBreakTime.Value || spinnerPeriods.IsInAny(osuPlayfield.Clock.CurrentTime);
+            bool shouldAlwaysShowCursor = IsBreakTime.Value || spinnerPeriods.IsInAny(playfield.Clock.CurrentTime);
             float targetAlpha = shouldAlwaysShowCursor ? 1 : ComboBasedAlpha;
-            float currentAlpha = (float)Interpolation.Lerp(osuPlayfield.Cursor.Alpha, targetAlpha, Math.Clamp(osuPlayfield.Time.Elapsed / TRANSITION_DURATION, 0, 1));
-
-            osuPlayfield.Cursor.Alpha = currentAlpha;
-            osuPlayfield.Smoke.Alpha = currentAlpha;
+            playfield.Cursor.Alpha = (float)Interpolation.Lerp(playfield.Cursor.Alpha, targetAlpha, Math.Clamp(playfield.Time.Elapsed / TRANSITION_DURATION, 0, 1));
         }
     }
 }

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

@@ -20,9 +20,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     public class OsuModRelax : ModRelax, IUpdatableByPlayfield, IApplicableToDrawableRuleset<OsuHitObject>, IApplicableToPlayer
     {
         public override LocalisableString Description => @"You don't need to click. Give your clicking/tapping fingers a break from the heat of things.";
-
-        public override Type[] IncompatibleMods =>
-            base.IncompatibleMods.Concat(new[] { typeof(OsuModAutopilot), typeof(OsuModMagnetised), typeof(OsuModAlternate), typeof(OsuModSingleTap) }).ToArray();
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModAutopilot), typeof(OsuModMagnetised), typeof(OsuModAlternate), typeof(OsuModSingleTap) }).ToArray();
 
         /// <summary>
         /// How early before a hitobject's start time to trigger a hit.
@@ -53,7 +51,7 @@ namespace osu.Game.Rulesets.Osu.Mods
                 return;
             }
 
-            osuInputManager.AllowGameplayInputs = false;
+            osuInputManager.AllowUserPresses = false;
         }
 
         public void Update(Playfield playfield)

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

@@ -3,7 +3,6 @@
 
 using System;
 using osu.Framework.Bindables;
-using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Localisation;
 using osu.Framework.Timing;
 using osu.Framework.Utils;
@@ -46,7 +45,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public void Update(Playfield playfield)
         {
-            var cursorPos = playfield.Cursor.AsNonNull().ActiveCursor.DrawPosition;
+            var cursorPos = playfield.Cursor.ActiveCursor.DrawPosition;
 
             foreach (var drawable in playfield.HitObjectContainer.AliveObjects)
             {

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

@@ -14,10 +14,12 @@ using osu.Game.Audio;
 using osu.Game.Graphics.Containers;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Skinning;
 using osu.Game.Rulesets.Osu.Skinning.Default;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;
 using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -104,6 +106,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             {
                 foreach (var drawableHitObject in NestedHitObjects)
                     drawableHitObject.AccentColour.Value = colour.NewValue;
+                updateBallTint();
             }, true);
 
             Tracking.BindValueChanged(updateSlidingSample);
@@ -254,6 +257,22 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             SliderBody?.RecyclePath();
         }
 
+        protected override void ApplySkin(ISkinSource skin, bool allowFallback)
+        {
+            base.ApplySkin(skin, allowFallback);
+
+            updateBallTint();
+        }
+
+        private void updateBallTint()
+        {
+            if (CurrentSkin == null)
+                return;
+
+            bool allowBallTint = CurrentSkin.GetConfig<OsuSkinConfiguration, bool>(OsuSkinConfiguration.AllowSliderBallTint)?.Value ?? false;
+            Ball.AccentColour = allowBallTint ? AccentColour.Value : Color4.White;
+        }
+
         protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
             if (userTriggered || Time.Current < HitObject.EndTime)
@@ -312,7 +331,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
             base.UpdateHitStateTransforms(state);
 
-            const float fade_out_time = 240;
+            const float fade_out_time = 450;
 
             switch (state)
             {
@@ -322,7 +341,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     break;
             }
 
-            this.FadeOut(fade_out_time).Expire();
+            this.FadeOut(fade_out_time, Easing.OutQuint).Expire();
         }
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => SliderBody?.ReceivePositionalInputAt(screenSpacePos) ?? base.ReceivePositionalInputAt(screenSpacePos);

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

@@ -11,20 +11,28 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input;
 using osu.Framework.Input.Events;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Skinning.Default;
 using osu.Game.Skinning;
 using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
-    public class DrawableSliderBall : CircularContainer, ISliderProgress, IRequireHighFrequencyMousePosition
+    public class DrawableSliderBall : CircularContainer, ISliderProgress, IRequireHighFrequencyMousePosition, IHasAccentColour
     {
         public const float FOLLOW_AREA = 2.4f;
 
         public Func<OsuAction?> GetInitialHitAction;
 
+        public Color4 AccentColour
+        {
+            get => ball.Colour;
+            set => ball.Colour = value;
+        }
+
         private Drawable followCircleReceptor;
         private DrawableSlider drawableSlider;
         private Drawable ball;
@@ -178,22 +186,17 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         private Vector2? lastPosition;
 
-        private bool rewinding;
-
         public void UpdateProgress(double completionProgress)
         {
             Position = drawableSlider.HitObject.CurvePositionAt(completionProgress);
 
             var diff = lastPosition.HasValue ? lastPosition.Value - Position : Position - drawableSlider.HitObject.CurvePositionAt(completionProgress + 0.01f);
 
-            if (Clock.ElapsedFrameTime != 0)
-                rewinding = Clock.ElapsedFrameTime < 0;
-
             // Ensure the value is substantially high enough to allow for Atan2 to get a valid angle.
             if (diff.LengthFast < 0.01f)
                 return;
 
-            ball.Rotation = -90 + (float)(-Math.Atan2(diff.X, diff.Y) * 180 / Math.PI) + (rewinding ? 180 : 0);
+            ball.Rotation = -90 + (float)(-Math.Atan2(diff.X, diff.Y) * 180 / Math.PI);
             lastPosition = Position;
         }
     }

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

@@ -57,7 +57,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         /// </summary>
         public readonly IBindable<double> SpinsPerMinute = new BindableDouble();
 
-        private const double fade_out_duration = 240;
+        private const double fade_out_duration = 160;
 
         public DrawableSpinner()
             : this(null)

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

@@ -34,6 +34,21 @@ namespace osu.Game.Rulesets.Osu.Objects
 
         public override IList<HitSampleInfo> AuxiliarySamples => CreateSlidingSamples().Concat(TailSamples).ToArray();
 
+        public IList<HitSampleInfo> CreateSlidingSamples()
+        {
+            var slidingSamples = new List<HitSampleInfo>();
+
+            var normalSample = Samples.FirstOrDefault(s => s.Name == HitSampleInfo.HIT_NORMAL);
+            if (normalSample != null)
+                slidingSamples.Add(normalSample.With("sliderslide"));
+
+            var whistleSample = Samples.FirstOrDefault(s => s.Name == HitSampleInfo.HIT_WHISTLE);
+            if (whistleSample != null)
+                slidingSamples.Add(whistleSample.With("sliderwhistle"));
+
+            return slidingSamples;
+        }
+
         private readonly Cached<Vector2> endPositionCache = new Cached<Vector2>();
 
         public override Vector2 EndPosition => endPositionCache.IsValid ? endPositionCache.Value : endPositionCache.Value = Position + this.CurvePositionAt(1);

osu.Game.Rulesets.Osu/OsuInputManager.cs

@@ -5,12 +5,10 @@
 
 using System.Collections.Generic;
 using System.ComponentModel;
-using System.Linq;
 using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Framework.Input.StateChanges.Events;
-using osu.Game.Input.Bindings;
 using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Osu
@@ -19,16 +17,9 @@ namespace osu.Game.Rulesets.Osu
     {
         public IEnumerable<OsuAction> PressedActions => KeyBindingContainer.PressedActions;
 
-        /// <summary>
-        /// Whether gameplay input buttons should be allowed.
-        /// Defaults to <c>true</c>, generally used for mods like Relax which turn off main inputs.
-        /// </summary>
-        /// <remarks>
-        /// Of note, auxiliary inputs like the "smoke" key are left usable.
-        /// </remarks>
-        public bool AllowGameplayInputs
+        public bool AllowUserPresses
         {
-            set => ((OsuKeyBindingContainer)KeyBindingContainer).AllowGameplayInputs = value;
+            set => ((OsuKeyBindingContainer)KeyBindingContainer).AllowUserPresses = value;
         }
 
         /// <summary>
@@ -67,36 +58,18 @@ namespace osu.Game.Rulesets.Osu
 
         private class OsuKeyBindingContainer : RulesetKeyBindingContainer
         {
-            private bool allowGameplayInputs = true;
-
-            /// <summary>
-            /// Whether gameplay input buttons should be allowed.
-            /// Defaults to <c>true</c>, generally used for mods like Relax which turn off main inputs.
-            /// </summary>
-            /// <remarks>
-            /// Of note, auxiliary inputs like the "smoke" key are left usable.
-            /// </remarks>
-            public bool AllowGameplayInputs
-            {
-                get => allowGameplayInputs;
-                set
-                {
-                    allowGameplayInputs = value;
-                    ReloadMappings();
-                }
-            }
+            public bool AllowUserPresses = true;
 
             public OsuKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
                 : base(ruleset, variant, unique)
             {
             }
 
-            protected override void ReloadMappings(IQueryable<RealmKeyBinding> realmKeyBindings)
+            protected override bool Handle(UIEvent e)
             {
-                base.ReloadMappings(realmKeyBindings);
+                if (!AllowUserPresses) return false;
 
-                if (!AllowGameplayInputs)
-                    KeyBindings = KeyBindings.Where(b => b.GetAction<OsuAction>() == OsuAction.Smoke).ToList();
+                return base.Handle(e);
             }
         }
     }

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

@@ -75,7 +75,6 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
             {
                 default:
                     JudgementText
-                        .FadeInFromZero(300, Easing.OutQuint)
                         .ScaleTo(Vector2.One)
                         .ScaleTo(new Vector2(1.2f), 1800, Easing.OutQuint);
                     break;
@@ -97,7 +96,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
             ringExplosion?.PlayAnimation();
         }
 
-        public Drawable? GetAboveHitObjectsProxiedContent() => JudgementText.CreateProxy();
+        public Drawable? GetAboveHitObjectsProxiedContent() => null;
 
         private class RingExplosion : CompositeDrawable
         {

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

@@ -108,23 +108,18 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
         {
             base.LoadComplete();
 
-            indexInCurrentCombo.BindValueChanged(index => number.Text = (index.NewValue + 1).ToString(), true);
-
             accentColour.BindValueChanged(colour =>
             {
-                // A colour transform is applied.
-                // Without removing transforms first, when it is rewound it may apply an old colour.
-                outerGradient.ClearTransforms(targetMember: nameof(Colour));
-                outerGradient.Colour = ColourInfo.GradientVertical(colour.NewValue, colour.NewValue.Darken(0.1f));
-
                 outerFill.Colour = innerFill.Colour = colour.NewValue.Darken(4);
+                outerGradient.Colour = ColourInfo.GradientVertical(colour.NewValue, colour.NewValue.Darken(0.1f));
                 innerGradient.Colour = ColourInfo.GradientVertical(colour.NewValue.Darken(0.5f), colour.NewValue.Darken(0.6f));
                 flash.Colour = colour.NewValue;
-
-                updateStateTransforms(drawableObject, drawableObject.State.Value);
             }, true);
 
+            indexInCurrentCombo.BindValueChanged(index => number.Text = (index.NewValue + 1).ToString(), true);
+
             drawableObject.ApplyCustomUpdateState += updateStateTransforms;
+            updateStateTransforms(drawableObject, drawableObject.State.Value);
         }
 
         private void updateStateTransforms(DrawableHitObject drawableHitObject, ArmedState state)
@@ -178,7 +173,11 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
                                 .FadeOut(flash_in_duration);
                         }
 
+                        // The flash layer starts white to give the wanted brightness, but is almost immediately
+                        // recoloured to the accent colour. This would more correctly be done with two layers (one for the initial flash)
+                        // but works well enough with the colour fade.
                         flash.FadeTo(1, flash_in_duration, Easing.OutQuint);
+                        flash.FlashColour(accentColour.Value, fade_out_time, Easing.OutQuint);
 
                         this.FadeOut(fade_out_time, Easing.OutQuad);
                         break;

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

@@ -134,10 +134,10 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                 switch (state)
                 {
                     case ArmedState.Hit:
-                        CircleSprite.FadeOut(legacy_fade_duration);
+                        CircleSprite.FadeOut(legacy_fade_duration, Easing.Out);
                         CircleSprite.ScaleTo(1.4f, legacy_fade_duration, Easing.Out);
 
-                        OverlaySprite.FadeOut(legacy_fade_duration);
+                        OverlaySprite.FadeOut(legacy_fade_duration, Easing.Out);
                         OverlaySprite.ScaleTo(1.4f, legacy_fade_duration, Easing.Out);
 
                         if (hasNumber)
@@ -146,11 +146,11 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 
                             if (legacyVersion >= 2.0m)
                                 // legacy skins of version 2.0 and newer only apply very short fade out to the number piece.
-                                hitCircleText.FadeOut(legacy_fade_duration / 4);
+                                hitCircleText.FadeOut(legacy_fade_duration / 4, Easing.Out);
                             else
                             {
                                 // old skins scale and fade it normally along other pieces.
-                                hitCircleText.FadeOut(legacy_fade_duration);
+                                hitCircleText.FadeOut(legacy_fade_duration, Easing.Out);
                                 hitCircleText.ScaleTo(1.4f, legacy_fade_duration, Easing.Out);
                             }
                         }

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

@@ -107,8 +107,8 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                     using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimePreempt))
                         this.FadeOut();
 
-                    using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimeFadeIn))
-                        this.FadeInFromZero(spinner.TimeFadeIn);
+                    using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimeFadeIn / 2))
+                        this.FadeInFromZero(spinner.TimeFadeIn / 2);
 
                     using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimePreempt))
                     {

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

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
@@ -22,8 +21,6 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
         [Resolved(canBeNull: true)]
         private DrawableHitObject? parentObject { get; set; }
 
-        public Color4 BallColour => animationContent.Colour;
-
         private Sprite layerNd = null!;
         private Sprite layerSpec = null!;
 
@@ -64,8 +61,6 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
             };
         }
 
-        private readonly IBindable<Color4> accentColour = new Bindable<Color4>();
-
         protected override void LoadComplete()
         {
             base.LoadComplete();
@@ -74,12 +69,6 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
             {
                 parentObject.ApplyCustomUpdateState += updateStateTransforms;
                 updateStateTransforms(parentObject, parentObject.State.Value);
-
-                if (skin.GetConfig<SkinConfiguration.LegacySetting, bool>(SkinConfiguration.LegacySetting.AllowSliderBallTint)?.Value == true)
-                {
-                    accentColour.BindTo(parentObject.AccentColour);
-                    accentColour.BindValueChanged(a => animationContent.Colour = a.NewValue, true);
-                }
             }
         }
 

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

@@ -65,7 +65,6 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                 {
                     spin = new Sprite
                     {
-                        Alpha = 0,
                         Anchor = Anchor.TopCentre,
                         Origin = Anchor.Centre,
                         Texture = source.GetTexture("spinner-spin"),
@@ -83,7 +82,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                     },
                     bonusCounter = new LegacySpriteText(LegacyFont.Score)
                     {
-                        Alpha = 0,
+                        Alpha = 0f,
                         Anchor = Anchor.TopCentre,
                         Origin = Anchor.Centre,
                         Scale = new Vector2(SPRITE_SCALE),
@@ -180,9 +179,6 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                         spmCounter.MoveToOffset(new Vector2(0, -spm_hide_offset), d.HitObject.TimeFadeIn, Easing.Out);
                     }
 
-                    using (BeginAbsoluteSequence(d.HitObject.StartTime - d.HitObject.TimeFadeIn / 2))
-                        spin.FadeInFromZero(d.HitObject.TimeFadeIn / 2);
-
                     using (BeginAbsoluteSequence(d.HitObject.StartTime))
                         ApproachCircle?.ScaleTo(SPRITE_SCALE * 0.1f, d.HitObject.Duration);
 

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

@@ -13,8 +13,6 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 {
     public class OsuLegacySkinTransformer : LegacySkinTransformer
     {
-        public override bool IsProvidingLegacyResources => base.IsProvidingLegacyResources || hasHitCircle.Value;
-
         private readonly Lazy<bool> hasHitCircle;
 
         /// <summary>

osu.Game.Rulesets.Osu/Skinning/OsuSkinConfiguration.cs

@@ -9,6 +9,7 @@ namespace osu.Game.Rulesets.Osu.Skinning
     {
         SliderBorderSize,
         SliderPathRadius,
+        AllowSliderBallTint,
         CursorCentre,
         CursorExpand,
         CursorRotate,

osu.Game.Rulesets.Osu/Skinning/SmokeSegment.cs

@@ -4,7 +4,6 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
@@ -15,7 +14,6 @@ using osu.Framework.Graphics.Rendering.Vertices;
 using osu.Framework.Graphics.Shaders;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Utils;
-using osu.Game.Utils;
 using osuTK;
 using osuTK.Graphics;
 
@@ -23,6 +21,8 @@ namespace osu.Game.Rulesets.Osu.Skinning
 {
     public abstract class SmokeSegment : Drawable, ITexturedShaderDrawable
     {
+        private const int max_point_count = 18_000;
+
         // fade anim values
         private const double initial_fade_out_duration = 4000;
 
@@ -84,6 +84,12 @@ namespace osu.Game.Rulesets.Osu.Skinning
             totalDistance = pointInterval;
         }
 
+        private Vector2 nextPointDirection()
+        {
+            float angle = RNG.NextSingle(0, 2 * MathF.PI);
+            return new Vector2(MathF.Sin(angle), -MathF.Cos(angle));
+        }
+
         public void AddPosition(Vector2 position, double time)
         {
             lastPosition ??= position;
@@ -100,27 +106,33 @@ namespace osu.Game.Rulesets.Osu.Skinning
                 Vector2 pointPos = (pointInterval - (totalDistance - delta)) * increment + (Vector2)lastPosition;
                 increment *= pointInterval;
 
+                if (SmokePoints.Count > 0 && SmokePoints[^1].Time > time)
+                {
+                    int index = ~SmokePoints.BinarySearch(new SmokePoint { Time = time }, new SmokePoint.UpperBoundComparer());
+                    SmokePoints.RemoveRange(index, SmokePoints.Count - index);
+                }
+
                 totalDistance %= pointInterval;
 
-                if (SmokePoints.Count == 0 || SmokePoints[^1].Time <= time)
+                for (int i = 0; i < count; i++)
                 {
-                    for (int i = 0; i < count; i++)
+                    SmokePoints.Add(new SmokePoint
                     {
-                        SmokePoints.Add(new SmokePoint
-                        {
-                            Position = pointPos,
-                            Time = time,
-                            Angle = RNG.NextSingle(0, 2 * MathF.PI),
-                        });
+                        Position = pointPos,
+                        Time = time,
+                        Direction = nextPointDirection(),
+                    });
 
-                        pointPos += increment;
-                    }
+                    pointPos += increment;
                 }
 
                 Invalidate(Invalidation.DrawNode);
             }
 
             lastPosition = position;
+
+            if (SmokePoints.Count >= max_point_count)
+                FinishDrawing(time);
         }
 
         public void FinishDrawing(double time)
@@ -144,7 +156,7 @@ namespace osu.Game.Rulesets.Osu.Skinning
         {
             public Vector2 Position;
             public double Time;
-            public float Angle;
+            public Vector2 Direction;
 
             public struct UpperBoundComparer : IComparer<SmokePoint>
             {
@@ -158,17 +170,6 @@ namespace osu.Game.Rulesets.Osu.Skinning
                     return x.Time > target.Time ? 1 : -1;
                 }
             }
-
-            public struct LowerBoundComparer : IComparer<SmokePoint>
-            {
-                public int Compare(SmokePoint x, SmokePoint target)
-                {
-                    // Similar logic as UpperBoundComparer, except returned index will always be
-                    // the first element larger or equal
-
-                    return x.Time < target.Time ? -1 : 1;
-                }
-            }
         }
 
         protected class SmokeDrawNode : TexturedShaderDrawNode
@@ -184,17 +185,17 @@ namespace osu.Game.Rulesets.Osu.Skinning
             private float radius;
             private Vector2 drawSize;
             private Texture? texture;
-            private int rotationSeed;
-            private int firstVisiblePointIndex;
 
             // anim calculation vars (color, scale, direction)
             private double initialFadeOutDurationTrunc;
-            private double firstVisiblePointTimeAfterSmokeEnded;
+            private double firstVisiblePointTime;
 
             private double initialFadeOutTime;
             private double reFadeInTime;
             private double finalFadeOutTime;
 
+            private Random rotationRNG = new Random();
+
             public SmokeDrawNode(ITexturedShaderDrawable source)
                 : base(source)
             {
@@ -204,6 +205,9 @@ namespace osu.Game.Rulesets.Osu.Skinning
             {
                 base.ApplyState();
 
+                points.Clear();
+                points.AddRange(Source.SmokePoints);
+
                 radius = Source.radius;
                 drawSize = Source.DrawSize;
                 texture = Source.Texture;
@@ -212,21 +216,14 @@ namespace osu.Game.Rulesets.Osu.Skinning
                 SmokeEndTime = Source.smokeEndTime;
                 CurrentTime = Source.Clock.CurrentTime;
 
-                rotationSeed = Source.rotationSeed;
+                rotationRNG = new Random(Source.rotationSeed);
 
                 initialFadeOutDurationTrunc = Math.Min(initial_fade_out_duration, SmokeEndTime - SmokeStartTime);
-                firstVisiblePointTimeAfterSmokeEnded = SmokeEndTime - initialFadeOutDurationTrunc;
+                firstVisiblePointTime = SmokeEndTime - initialFadeOutDurationTrunc;
 
-                initialFadeOutTime = Math.Min(CurrentTime, SmokeEndTime);
-                reFadeInTime = CurrentTime - initialFadeOutDurationTrunc - firstVisiblePointTimeAfterSmokeEnded * (1 - 1 / re_fade_in_speed);
-                finalFadeOutTime = CurrentTime - initialFadeOutDurationTrunc - firstVisiblePointTimeAfterSmokeEnded * (1 - 1 / final_fade_out_speed);
-
-                double firstVisiblePointTime = Math.Min(SmokeEndTime, CurrentTime) - initialFadeOutDurationTrunc;
-                firstVisiblePointIndex = ~Source.SmokePoints.BinarySearch(new SmokePoint { Time = firstVisiblePointTime }, new SmokePoint.LowerBoundComparer());
-                int futurePointIndex = ~Source.SmokePoints.BinarySearch(new SmokePoint { Time = CurrentTime }, new SmokePoint.UpperBoundComparer());
-
-                points.Clear();
-                points.AddRange(Source.SmokePoints.Skip(firstVisiblePointIndex).Take(futurePointIndex - firstVisiblePointIndex));
+                initialFadeOutTime = CurrentTime;
+                reFadeInTime = CurrentTime - initialFadeOutDurationTrunc - firstVisiblePointTime * (1 - 1 / re_fade_in_speed);
+                finalFadeOutTime = CurrentTime - initialFadeOutDurationTrunc - firstVisiblePointTime * (1 - 1 / final_fade_out_speed);
             }
 
             public sealed override void Draw(IRenderer renderer)
@@ -236,14 +233,7 @@ namespace osu.Game.Rulesets.Osu.Skinning
                 if (points.Count == 0)
                     return;
 
-                quadBatch ??= renderer.CreateQuadBatch<TexturedVertex2D>(200, 4);
-
-                if (points.Count > quadBatch.Size && quadBatch.Size != IRenderer.MAX_QUADS)
-                {
-                    int batchSize = Math.Min(quadBatch.Size * 2, IRenderer.MAX_QUADS);
-                    quadBatch = renderer.CreateQuadBatch<TexturedVertex2D>(batchSize, 4);
-                }
-
+                quadBatch ??= renderer.CreateQuadBatch<TexturedVertex2D>(max_point_count / 10, 10);
                 texture ??= renderer.WhitePixel;
                 RectangleF textureRect = texture.GetTextureRect();
 
@@ -255,8 +245,8 @@ namespace osu.Game.Rulesets.Osu.Skinning
                 shader.Bind();
                 texture.Bind();
 
-                for (int i = 0; i < points.Count; i++)
-                    drawPointQuad(points[i], textureRect, i + firstVisiblePointIndex);
+                foreach (var point in points)
+                    drawPointQuad(point, textureRect);
 
                 shader.Unbind();
                 renderer.PopLocalMatrix();
@@ -270,34 +260,30 @@ namespace osu.Game.Rulesets.Osu.Skinning
             {
                 var color = Color4.White;
 
-                double timeDoingFinalFadeOut = finalFadeOutTime - point.Time / final_fade_out_speed;
+                double timeDoingInitialFadeOut = Math.Min(initialFadeOutTime, SmokeEndTime) - point.Time;
 
-                if (timeDoingFinalFadeOut > 0 && point.Time >= firstVisiblePointTimeAfterSmokeEnded)
+                if (timeDoingInitialFadeOut > 0)
                 {
-                    float fraction = Math.Clamp((float)(timeDoingFinalFadeOut / final_fade_out_duration), 0, 1);
-                    fraction = MathF.Pow(fraction, 5);
-                    color.A = (1 - fraction) * re_fade_in_alpha;
+                    float fraction = Math.Clamp((float)(timeDoingInitialFadeOut / initial_fade_out_duration), 0, 1);
+                    color.A = (1 - fraction) * initial_alpha;
                 }
-                else
+
+                if (color.A > 0)
                 {
-                    double timeDoingInitialFadeOut = initialFadeOutTime - point.Time;
+                    double timeDoingReFadeIn = reFadeInTime - point.Time / re_fade_in_speed;
+                    double timeDoingFinalFadeOut = finalFadeOutTime - point.Time / final_fade_out_speed;
 
-                    if (timeDoingInitialFadeOut > 0)
+                    if (timeDoingFinalFadeOut > 0)
                     {
-                        float fraction = Math.Clamp((float)(timeDoingInitialFadeOut / initial_fade_out_duration), 0, 1);
-                        color.A = (1 - fraction) * initial_alpha;
+                        float fraction = Math.Clamp((float)(timeDoingFinalFadeOut / final_fade_out_duration), 0, 1);
+                        fraction = MathF.Pow(fraction, 5);
+                        color.A = (1 - fraction) * re_fade_in_alpha;
                     }
-
-                    if (point.Time > firstVisiblePointTimeAfterSmokeEnded)
+                    else if (timeDoingReFadeIn > 0)
                     {
-                        double timeDoingReFadeIn = reFadeInTime - point.Time / re_fade_in_speed;
-
-                        if (timeDoingReFadeIn > 0)
-                        {
-                            float fraction = Math.Clamp((float)(timeDoingReFadeIn / re_fade_in_duration), 0, 1);
-                            fraction = 1 - MathF.Pow(1 - fraction, 5);
-                            color.A = fraction * (re_fade_in_alpha - color.A) + color.A;
-                        }
+                        float fraction = Math.Clamp((float)(timeDoingReFadeIn / re_fade_in_duration), 0, 1);
+                        fraction = 1 - MathF.Pow(1 - fraction, 5);
+                        color.A = fraction * (re_fade_in_alpha - color.A) + color.A;
                     }
                 }
 
@@ -312,33 +298,33 @@ namespace osu.Game.Rulesets.Osu.Skinning
                 return fraction * (final_scale - initial_scale) + initial_scale;
             }
 
-            protected virtual Vector2 PointDirection(SmokePoint point, int index)
+            protected virtual Vector2 PointDirection(SmokePoint point)
             {
+                float initialAngle = MathF.Atan2(point.Direction.Y, point.Direction.X);
+                float finalAngle = initialAngle + nextRotation();
+
                 double timeDoingRotation = CurrentTime - point.Time;
                 float fraction = Math.Clamp((float)(timeDoingRotation / rotation_duration), 0, 1);
                 fraction = 1 - MathF.Pow(1 - fraction, 5);
-                float angle = fraction * getRotation(index) + point.Angle;
+                float angle = fraction * (finalAngle - initialAngle) + initialAngle;
 
                 return new Vector2(MathF.Sin(angle), -MathF.Cos(angle));
             }
 
-            private float getRotation(int index) => max_rotation * (StatelessRNG.NextSingle(rotationSeed, index) * 2 - 1);
+            private float nextRotation() => max_rotation * ((float)rotationRNG.NextDouble() * 2 - 1);
 
-            private void drawPointQuad(SmokePoint point, RectangleF textureRect, int index)
+            private void drawPointQuad(SmokePoint point, RectangleF textureRect)
             {
                 Debug.Assert(quadBatch != null);
 
                 var colour = PointColour(point);
-                if (colour.A == 0)
-                    return;
-
                 float scale = PointScale(point);
-                if (scale == 0)
-                    return;
-
-                var dir = PointDirection(point, index);
+                var dir = PointDirection(point);
                 var ortho = dir.PerpendicularLeft;
 
+                if (colour.A == 0 || scale == 0)
+                    return;
+
                 var localTopLeft = point.Position + (radius * scale * (-ortho - dir));
                 var localTopRight = point.Position + (radius * scale * (-ortho + dir));
                 var localBotLeft = point.Position + (radius * scale * (ortho - dir));

osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs

@@ -36,7 +36,6 @@ namespace osu.Game.Rulesets.Osu.UI
         private readonly ProxyContainer spinnerProxies;
         private readonly JudgementContainer<DrawableOsuJudgement> judgementLayer;
 
-        public SmokeContainer Smoke { get; }
         public FollowPointRenderer FollowPoints { get; }
 
         public static readonly Vector2 BASE_SIZE = new Vector2(512, 384);
@@ -55,7 +54,7 @@ namespace osu.Game.Rulesets.Osu.UI
             InternalChildren = new Drawable[]
             {
                 playfieldBorder = new PlayfieldBorder { RelativeSizeAxes = Axes.Both },
-                Smoke = new SmokeContainer { RelativeSizeAxes = Axes.Both },
+                new SmokeContainer { RelativeSizeAxes = Axes.Both },
                 spinnerProxies = new ProxyContainer { RelativeSizeAxes = Axes.Both },
                 FollowPoints = new FollowPointRenderer { RelativeSizeAxes = Axes.Both },
                 judgementLayer = new JudgementContainer<DrawableOsuJudgement> { RelativeSizeAxes = Axes.Both },

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

@@ -1,20 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using NUnit.Framework;
-using osu.Game.Rulesets.Taiko.Mods;
-
-namespace osu.Game.Rulesets.Taiko.Tests.Mods
-{
-    public class TestSceneTaikoModFlashlight : TaikoModTestScene
-    {
-        [TestCase(1f)]
-        [TestCase(0.5f)]
-        [TestCase(1.25f)]
-        [TestCase(1.5f)]
-        public void TestSizeMultiplier(float sizeMultiplier) => CreateModTest(new ModTestData { Mod = new TaikoModFlashlight { SizeMultiplier = { Value = sizeMultiplier } }, PassCondition = () => true });
-
-        [Test]
-        public void TestComboBasedSize([Values] bool comboBasedSize) => CreateModTest(new ModTestData { Mod = new TaikoModFlashlight { ComboBasedSize = { Value = comboBasedSize } }, PassCondition = () => true });
-    }
-}

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

@@ -1,87 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Linq;
-using NUnit.Framework;
-using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Beatmaps.Timing;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Taiko.Objects;
-using osu.Game.Tests.Visual;
-
-namespace osu.Game.Rulesets.Taiko.Tests
-{
-    public class TestSceneBarLineGeneration : OsuTestScene
-    {
-        [Test]
-        public void TestCloseBarLineGeneration()
-        {
-            const double start_time = 1000;
-
-            var beatmap = new Beatmap<TaikoHitObject>
-            {
-                HitObjects =
-                {
-                    new Hit
-                    {
-                        Type = HitType.Centre,
-                        StartTime = start_time
-                    }
-                },
-                BeatmapInfo =
-                {
-                    Difficulty = new BeatmapDifficulty { SliderTickRate = 4 },
-                    Ruleset = new TaikoRuleset().RulesetInfo
-                },
-            };
-
-            beatmap.ControlPointInfo.Add(start_time, new TimingControlPoint());
-            beatmap.ControlPointInfo.Add(start_time + 1, new TimingControlPoint());
-
-            var barlines = new BarLineGenerator<BarLine>(beatmap).BarLines;
-
-            AddAssert("first barline generated", () => barlines.Any(b => b.StartTime == start_time));
-            AddAssert("second barline generated", () => barlines.Any(b => b.StartTime == start_time + 1));
-        }
-
-        [Test]
-        public void TestOmitBarLineEffectPoint()
-        {
-            const double start_time = 1000;
-            const double beat_length = 500;
-
-            const int time_signature_numerator = 4;
-
-            var beatmap = new Beatmap<TaikoHitObject>
-            {
-                HitObjects =
-                {
-                    new Hit
-                    {
-                        Type = HitType.Centre,
-                        StartTime = start_time
-                    }
-                },
-                BeatmapInfo =
-                {
-                    Difficulty = new BeatmapDifficulty { SliderTickRate = 4 },
-                    Ruleset = new TaikoRuleset().RulesetInfo
-                },
-            };
-
-            beatmap.ControlPointInfo.Add(start_time, new TimingControlPoint
-            {
-                BeatLength = beat_length,
-                TimeSignature = new TimeSignature(time_signature_numerator)
-            });
-
-            beatmap.ControlPointInfo.Add(start_time, new EffectControlPoint { OmitFirstBarLine = true });
-
-            var barlines = new BarLineGenerator<BarLine>(beatmap).BarLines;
-
-            AddAssert("first barline ommited", () => barlines.All(b => b.StartTime != start_time));
-            AddAssert("second barline generated", () => barlines.Any(b => b.StartTime == start_time + (beat_length * time_signature_numerator)));
-        }
-    }
-}

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

@@ -47,21 +47,21 @@ namespace osu.Game.Rulesets.Taiko.Mods
             {
                 this.taikoPlayfield = taikoPlayfield;
 
-                FlashlightSize = adjustSize(GetSize());
+                FlashlightSize = getSizeFor(0);
                 FlashlightSmoothness = 1.4f;
 
                 AddLayout(flashlightProperties);
             }
 
-            private Vector2 adjustSize(float size)
+            private Vector2 getSizeFor(int combo)
             {
                 // Preserve flashlight size through the playfield's aspect adjustment.
-                return new Vector2(0, size * taikoPlayfield.DrawHeight / TaikoPlayfield.DEFAULT_HEIGHT);
+                return new Vector2(0, GetSizeFor(combo) * taikoPlayfield.DrawHeight / TaikoPlayfield.DEFAULT_HEIGHT);
             }
 
-            protected override void UpdateFlashlightSize(float size)
+            protected override void OnComboChange(ValueChangedEvent<int> e)
             {
-                this.TransformTo(nameof(FlashlightSize), adjustSize(size), FLASHLIGHT_FADE_DURATION);
+                this.TransformTo(nameof(FlashlightSize), getSizeFor(e.NewValue), FLASHLIGHT_FADE_DURATION);
             }
 
             protected override string FragmentShader => "CircularFlashlight";
@@ -75,7 +75,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
                     FlashlightPosition = ToLocalSpace(taikoPlayfield.HitTarget.ScreenSpaceDrawQuad.Centre);
 
                     ClearTransforms(targetMember: nameof(FlashlightSize));
-                    FlashlightSize = adjustSize(Combo.Value);
+                    FlashlightSize = getSizeFor(Combo.Value);
 
                     flashlightProperties.Validate();
                 }

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

@@ -14,13 +14,8 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
 {
     public class TaikoLegacySkinTransformer : LegacySkinTransformer
     {
-        public override bool IsProvidingLegacyResources => base.IsProvidingLegacyResources || hasHitCircle || hasBarLeft;
-
         private readonly Lazy<bool> hasExplosion;
 
-        private bool hasHitCircle => GetTexture("taikohitcircle") != null;
-        private bool hasBarLeft => GetTexture("taiko-bar-left") != null;
-
         public TaikoLegacySkinTransformer(ISkin skin)
             : base(skin)
         {
@@ -47,14 +42,14 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
                         return null;
 
                     case TaikoSkinComponents.InputDrum:
-                        if (hasBarLeft)
+                        if (GetTexture("taiko-bar-left") != null)
                             return new LegacyInputDrum();
 
                         return null;
 
                     case TaikoSkinComponents.CentreHit:
                     case TaikoSkinComponents.RimHit:
-                        if (hasHitCircle)
+                        if (GetTexture("taikohitcircle") != null)
                             return new LegacyHit(taikoComponent.Component);
 
                         return null;

osu.Game.Tests/Beatmaps/WorkingBeatmapManagerTest.cs

@@ -9,10 +9,8 @@ using osu.Framework.Extensions;
 using osu.Framework.Platform;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
-using osu.Game.Collections;
 using osu.Game.Database;
 using osu.Game.Rulesets;
-using osu.Game.Rulesets.Osu;
 using osu.Game.Tests.Resources;
 using osu.Game.Tests.Visual;
 
@@ -98,41 +96,5 @@ namespace osu.Game.Tests.Beatmaps
             var second = beatmaps.GetWorkingBeatmap(beatmap, true);
             Assert.That(first, Is.Not.SameAs(second));
         });
-
-        [Test]
-        public void TestSavePreservesCollections() => AddStep("run test", () =>
-        {
-            var beatmap = Realm.Run(r => r.Find<BeatmapInfo>(importedSet.Beatmaps.First().ID).Detach());
-
-            var working = beatmaps.GetWorkingBeatmap(beatmap);
-
-            Assert.That(working.BeatmapInfo.BeatmapSet?.Files, Has.Count.GreaterThan(0));
-
-            string initialHash = working.BeatmapInfo.MD5Hash;
-
-            var preserveCollection = new BeatmapCollection("test contained");
-            preserveCollection.BeatmapMD5Hashes.Add(initialHash);
-
-            var noNewCollection = new BeatmapCollection("test not contained");
-
-            Realm.Write(r =>
-            {
-                r.Add(preserveCollection);
-                r.Add(noNewCollection);
-            });
-
-            Assert.That(preserveCollection.BeatmapMD5Hashes, Does.Contain(initialHash));
-            Assert.That(noNewCollection.BeatmapMD5Hashes, Does.Not.Contain(initialHash));
-
-            beatmaps.Save(working.BeatmapInfo, working.GetPlayableBeatmap(new OsuRuleset().RulesetInfo));
-
-            string finalHash = working.BeatmapInfo.MD5Hash;
-
-            Assert.That(finalHash, Is.Not.SameAs(initialHash));
-
-            Assert.That(preserveCollection.BeatmapMD5Hashes, Does.Not.Contain(initialHash));
-            Assert.That(preserveCollection.BeatmapMD5Hashes, Does.Contain(finalHash));
-            Assert.That(noNewCollection.BeatmapMD5Hashes, Does.Not.Contain(finalHash));
-        });
     }
 }

osu.Game.Tests/Skins/SkinDeserialisationTest.cs

@@ -38,9 +38,7 @@ namespace osu.Game.Tests.Skins
             // Covers legacy song progress, UR counter, colour hit error metre.
             "Archives/modified-classic-20220801.osk",
             // Covers clicks/s counter
-            "Archives/modified-default-20220818.osk",
-            // Covers longest combo counter
-            "Archives/modified-default-20221012.osk"
+            "Archives/modified-default-20220818.osk"
         };
 
         /// <summary>

osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs

@@ -244,10 +244,7 @@ namespace osu.Game.Tests.Visual.Background
         public void TestResumeFromPlayer()
         {
             performFullSetup();
-            AddStep("Move mouse to Visual Settings location", () => InputManager.MoveMouseTo(playerLoader.ScreenSpaceDrawQuad.TopRight
-                                                                                             + new Vector2(-playerLoader.VisualSettingsPos.ScreenSpaceDrawQuad.Width,
-                                                                                                 playerLoader.VisualSettingsPos.ScreenSpaceDrawQuad.Height / 2
-                                                                                             )));
+            AddStep("Move mouse to Visual Settings", () => InputManager.MoveMouseTo(playerLoader.VisualSettingsPos));
             AddStep("Resume PlayerLoader", () => player.Restart());
             AddUntilStep("Screen is dimmed and blur applied", () => songSelect.IsBackgroundDimmed() && songSelect.IsUserBlurApplied());
             AddStep("Move mouse to center of screen", () => InputManager.MoveMouseTo(playerLoader.ScreenPos));

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

@@ -4,10 +4,8 @@
 #nullable disable
 
 using NUnit.Framework;
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
-using osu.Game.Overlays;
 using osu.Game.Screens.Edit.Components.RadioButtons;
 
 namespace osu.Game.Tests.Visual.Editing
@@ -15,9 +13,6 @@ namespace osu.Game.Tests.Visual.Editing
     [TestFixture]
     public class TestSceneEditorComposeRadioButtons : OsuTestScene
     {
-        [Cached]
-        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Aquamarine);
-
         public TestSceneEditorComposeRadioButtons()
         {
             EditorRadioButtonCollection collection;

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

@@ -148,6 +148,10 @@ namespace osu.Game.Tests.Visual.Editing
             });
 
             AddAssert("no circles placed", () => editorBeatmap.HitObjects.Count == 0);
+
+            AddStep("place circle", () => InputManager.Click(MouseButton.Left));
+
+            AddAssert("circle placed", () => editorBeatmap.HitObjects.Count == 1);
         }
 
         [Test]

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

@@ -29,18 +29,16 @@ namespace osu.Game.Tests.Visual.Editing
         private TimelineBlueprintContainer blueprintContainer
             => Editor.ChildrenOfType<TimelineBlueprintContainer>().First();
 
-        private Vector2 getPosition(HitObject hitObject) =>
-            blueprintContainer.SelectionBlueprints.First(s => s.Item == hitObject).ScreenSpaceDrawQuad.Centre;
-
-        private Vector2 getMiddlePosition(HitObject hitObject1, HitObject hitObject2) =>
-            (getPosition(hitObject1) + getPosition(hitObject2)) / 2;
-
         private void moveMouseToObject(Func<HitObject> targetFunc)
         {
             AddStep("move mouse to object", () =>
             {
-                var hitObject = targetFunc();
-                InputManager.MoveMouseTo(getPosition(hitObject));
+                var pos = blueprintContainer.SelectionBlueprints
+                                            .First(s => s.Item == targetFunc())
+                                            .ChildrenOfType<TimelineHitObjectBlueprint>()
+                                            .First().ScreenSpaceDrawQuad.Centre;
+
+                InputManager.MoveMouseTo(pos);
             });
         }
 
@@ -264,56 +262,6 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("release shift", () => InputManager.ReleaseKey(Key.ShiftLeft));
         }
 
-        [Test]
-        public void TestBasicDragSelection()
-        {
-            var addedObjects = new[]
-            {
-                new HitCircle { StartTime = 0 },
-                new HitCircle { StartTime = 500, Position = new Vector2(100) },
-                new HitCircle { StartTime = 1000, Position = new Vector2(200) },
-                new HitCircle { StartTime = 1500, Position = new Vector2(300) },
-            };
-            AddStep("add hitobjects", () => EditorBeatmap.AddRange(addedObjects));
-
-            AddStep("move mouse", () => InputManager.MoveMouseTo(getMiddlePosition(addedObjects[0], addedObjects[1])));
-            AddStep("mouse down", () => InputManager.PressButton(MouseButton.Left));
-
-            AddStep("drag to select", () => InputManager.MoveMouseTo(getMiddlePosition(addedObjects[2], addedObjects[3])));
-            assertSelectionIs(new[] { addedObjects[1], addedObjects[2] });
-
-            AddStep("drag to deselect", () => InputManager.MoveMouseTo(getMiddlePosition(addedObjects[1], addedObjects[2])));
-            assertSelectionIs(new[] { addedObjects[1] });
-
-            AddStep("mouse up", () => InputManager.ReleaseButton(MouseButton.Left));
-            assertSelectionIs(new[] { addedObjects[1] });
-        }
-
-        [Test]
-        public void TestFastDragSelection()
-        {
-            var addedObjects = new[]
-            {
-                new HitCircle { StartTime = 0 },
-                new HitCircle { StartTime = 500 },
-                new HitCircle { StartTime = 20000, Position = new Vector2(100) },
-                new HitCircle { StartTime = 31000, Position = new Vector2(200) },
-                new HitCircle { StartTime = 60000, Position = new Vector2(300) },
-            };
-
-            AddStep("add hitobjects", () => EditorBeatmap.AddRange(addedObjects));
-
-            AddStep("move mouse", () => InputManager.MoveMouseTo(getMiddlePosition(addedObjects[0], addedObjects[1])));
-            AddStep("mouse down", () => InputManager.PressButton(MouseButton.Left));
-            AddStep("start drag", () => InputManager.MoveMouseTo(getPosition(addedObjects[1])));
-
-            AddStep("jump editor clock", () => EditorClock.Seek(30000));
-            AddStep("jump editor clock", () => EditorClock.Seek(60000));
-            AddStep("end drag", () => InputManager.ReleaseButton(MouseButton.Left));
-            assertSelectionIs(addedObjects.Skip(1));
-            AddAssert("all blueprints are present", () => blueprintContainer.SelectionBlueprints.Count == EditorBeatmap.SelectedHitObjects.Count);
-        }
-
         private void assertSelectionIs(IEnumerable<HitObject> hitObjects)
             => AddAssert("correct hitobjects selected", () => EditorBeatmap.SelectedHitObjects.OrderBy(h => h.StartTime).SequenceEqual(hitObjects));
     }

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

@@ -55,7 +55,7 @@ namespace osu.Game.Tests.Visual.Editing
                             }
                         }
                     },
-                    new MenuCursorContainer()
+                    new MenuCursor()
                 };
 
                 scrollContainer.Add(innerBox = new Box

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

@@ -16,7 +16,6 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play;
-using osu.Game.Screens.Play.HUD;
 using osu.Game.Screens.Play.HUD.HitErrorMeters;
 using osu.Game.Skinning;
 using osu.Game.Tests.Gameplay;
@@ -149,42 +148,6 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("key counters still hidden", () => !keyCounterFlow.IsPresent);
         }
 
-        [Test]
-        public void TestInputDoesntWorkWhenHUDHidden()
-        {
-            SongProgressBar getSongProgress() => hudOverlay.ChildrenOfType<SongProgressBar>().Single();
-
-            bool seeked = false;
-
-            createNew();
-
-            AddStep("bind seek", () =>
-            {
-                seeked = false;
-
-                var progress = getSongProgress();
-
-                progress.ShowHandle = true;
-                progress.OnSeek += _ => seeked = true;
-            });
-
-            AddStep("set showhud false", () => hudOverlay.ShowHud.Value = false);
-            AddUntilStep("hidetarget is hidden", () => !hideTarget.IsPresent);
-
-            AddStep("attempt seek", () =>
-            {
-                InputManager.MoveMouseTo(getSongProgress());
-                InputManager.Click(MouseButton.Left);
-            });
-
-            AddAssert("seek not performed", () => !seeked);
-
-            AddStep("set showhud true", () => hudOverlay.ShowHud.Value = true);
-
-            AddStep("attempt seek", () => InputManager.Click(MouseButton.Left));
-            AddAssert("seek performed", () => seeked);
-        }
-
         [Test]
         public void TestHiddenHUDDoesntBlockComponentUpdates()
         {

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

@@ -214,7 +214,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private void addControlPoints(IList<MultiplierControlPoint> controlPoints, double sequenceStartTime)
         {
-            controlPoints.ForEach(point => point.Time += sequenceStartTime);
+            controlPoints.ForEach(point => point.StartTime += sequenceStartTime);
 
             scrollContainers.ForEach(container =>
             {
@@ -224,7 +224,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             foreach (var playfield in playfields)
             {
                 foreach (var controlPoint in controlPoints)
-                    playfield.Add(createDrawablePoint(playfield, controlPoint.Time));
+                    playfield.Add(createDrawablePoint(playfield, controlPoint.StartTime));
             }
         }
 

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

@@ -97,23 +97,14 @@ namespace osu.Game.Tests.Visual.Multiplayer
         }
 
         [Test]
-        public void TestSingleItemDoesNotHaveDeleteButton()
-        {
-            AddStep("set all players queue mode", () => MultiplayerClient.ChangeSettings(new MultiplayerRoomSettings { QueueMode = QueueMode.AllPlayers }).WaitSafely());
-            AddUntilStep("wait for queue mode change", () => MultiplayerClient.ClientAPIRoom?.QueueMode.Value == QueueMode.AllPlayers);
-
-            assertDeleteButtonVisibility(0, false);
-        }
-
-        [Test]
-        public void TestCurrentItemHasDeleteButtonIfNotSingle()
+        public void TestCurrentItemDoesNotHaveDeleteButton()
         {
             AddStep("set all players queue mode", () => MultiplayerClient.ChangeSettings(new MultiplayerRoomSettings { QueueMode = QueueMode.AllPlayers }).WaitSafely());
             AddUntilStep("wait for queue mode change", () => MultiplayerClient.ClientAPIRoom?.QueueMode.Value == QueueMode.AllPlayers);
 
             addPlaylistItem(() => API.LocalUser.Value.OnlineID);
 
-            assertDeleteButtonVisibility(0, true);
+            assertDeleteButtonVisibility(0, false);
             assertDeleteButtonVisibility(1, true);
 
             AddStep("finish current item", () => MultiplayerClient.FinishCurrentItem().WaitSafely());

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

@@ -25,7 +25,6 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
 using osu.Game.Screens.Menu;
 using osu.Game.Skinning;
-using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Navigation
 {
@@ -80,16 +79,6 @@ namespace osu.Game.Tests.Visual.Navigation
         [Resolved]
         private OsuGameBase gameBase { get; set; }
 
-        [Test]
-        public void TestCursorHidesWhenIdle()
-        {
-            AddStep("click mouse", () => InputManager.Click(MouseButton.Left));
-            AddUntilStep("wait until idle", () => Game.IsIdle.Value);
-            AddUntilStep("menu cursor hidden", () => Game.GlobalCursorDisplay.MenuCursor.ActiveCursor.Alpha == 0);
-            AddStep("click mouse", () => InputManager.Click(MouseButton.Left));
-            AddUntilStep("menu cursor shown", () => Game.GlobalCursorDisplay.MenuCursor.ActiveCursor.Alpha == 1);
-        }
-
         [Test]
         public void TestNullRulesetHandled()
         {

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

@@ -1,257 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using NUnit.Framework;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Testing;
-using osu.Game.Graphics.Containers;
-using osu.Game.Graphics.Sprites;
-using osu.Game.Graphics.UserInterface;
-using osu.Game.Online.API;
-using osu.Game.Online.API.Requests;
-using osu.Game.Online.API.Requests.Responses;
-using osu.Game.Overlays;
-using osu.Game.Overlays.Comments;
-using osuTK.Input;
-
-namespace osu.Game.Tests.Visual.Online
-{
-    public class TestSceneCommentActions : OsuManualInputManagerTestScene
-    {
-        private Container<Drawable> content = null!;
-        protected override Container<Drawable> Content => content;
-        private DummyAPIAccess dummyAPI => (DummyAPIAccess)API;
-
-        [Cached(typeof(IDialogOverlay))]
-        private readonly DialogOverlay dialogOverlay = new DialogOverlay();
-
-        [Cached]
-        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Purple);
-
-        private CommentsContainer commentsContainer = null!;
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            base.Content.AddRange(new Drawable[]
-            {
-                content = new OsuScrollContainer
-                {
-                    RelativeSizeAxes = Axes.Both
-                },
-                dialogOverlay
-            });
-        }
-
-        [SetUpSteps]
-        public void SetUp()
-        {
-            Schedule(() =>
-            {
-                API.Login("test", "test");
-                Child = commentsContainer = new CommentsContainer();
-            });
-        }
-
-        [Test]
-        public void TestNonOwnCommentCantBeDeleted()
-        {
-            addTestComments();
-
-            AddUntilStep("First comment has button", () =>
-            {
-                var comments = this.ChildrenOfType<DrawableComment>();
-                var ourComment = comments.SingleOrDefault(x => x.Comment.Id == 1);
-                return ourComment != null && ourComment.ChildrenOfType<OsuSpriteText>().Any(x => x.Text == "Delete");
-            });
-
-            AddAssert("Second doesn't", () =>
-            {
-                var comments = this.ChildrenOfType<DrawableComment>();
-                var ourComment = comments.Single(x => x.Comment.Id == 2);
-                return ourComment.ChildrenOfType<OsuSpriteText>().All(x => x.Text != "Delete");
-            });
-        }
-
-        private readonly ManualResetEventSlim deletionPerformed = new ManualResetEventSlim();
-
-        [Test]
-        public void TestDeletion()
-        {
-            DrawableComment? ourComment = null;
-
-            addTestComments();
-            AddUntilStep("Comment exists", () =>
-            {
-                var comments = this.ChildrenOfType<DrawableComment>();
-                ourComment = comments.SingleOrDefault(x => x.Comment.Id == 1);
-                return ourComment != null;
-            });
-            AddStep("It has delete button", () =>
-            {
-                var btn = ourComment.ChildrenOfType<OsuSpriteText>().Single(x => x.Text == "Delete");
-                InputManager.MoveMouseTo(btn);
-            });
-            AddStep("Click delete button", () =>
-            {
-                InputManager.Click(MouseButton.Left);
-            });
-            AddStep("Setup request handling", () =>
-            {
-                deletionPerformed.Reset();
-
-                dummyAPI.HandleRequest = request =>
-                {
-                    if (!(request is CommentDeleteRequest req))
-                        return false;
-
-                    if (req.CommentId != 1)
-                        return false;
-
-                    CommentBundle cb = new CommentBundle
-                    {
-                        Comments = new List<Comment>
-                        {
-                            new Comment
-                            {
-                                Id = 2,
-                                Message = "This is a comment by another user",
-                                UserId = API.LocalUser.Value.Id + 1,
-                                CreatedAt = DateTimeOffset.Now,
-                                User = new APIUser
-                                {
-                                    Id = API.LocalUser.Value.Id + 1,
-                                    Username = "Another user"
-                                }
-                            },
-                        },
-                        IncludedComments = new List<Comment>(),
-                        PinnedComments = new List<Comment>(),
-                    };
-
-                    Task.Run(() =>
-                    {
-                        deletionPerformed.Wait(10000);
-                        req.TriggerSuccess(cb);
-                    });
-
-                    return true;
-                };
-            });
-            AddStep("Confirm dialog", () => InputManager.Key(Key.Number1));
-
-            AddAssert("Loading spinner shown", () => commentsContainer.ChildrenOfType<LoadingSpinner>().Any(d => d.IsPresent));
-
-            AddStep("Complete request", () => deletionPerformed.Set());
-
-            AddUntilStep("Comment is deleted locally", () => this.ChildrenOfType<DrawableComment>().Single(x => x.Comment.Id == 1).WasDeleted);
-        }
-
-        [Test]
-        public void TestDeletionFail()
-        {
-            DrawableComment? ourComment = null;
-            bool delete = false;
-
-            addTestComments();
-            AddUntilStep("Comment exists", () =>
-            {
-                var comments = this.ChildrenOfType<DrawableComment>();
-                ourComment = comments.SingleOrDefault(x => x.Comment.Id == 1);
-                return ourComment != null;
-            });
-            AddStep("It has delete button", () =>
-            {
-                var btn = ourComment.ChildrenOfType<OsuSpriteText>().Single(x => x.Text == "Delete");
-                InputManager.MoveMouseTo(btn);
-            });
-            AddStep("Click delete button", () =>
-            {
-                InputManager.Click(MouseButton.Left);
-            });
-            AddStep("Setup request handling", () =>
-            {
-                dummyAPI.HandleRequest = request =>
-                {
-                    if (request is not CommentDeleteRequest req)
-                        return false;
-
-                    req.TriggerFailure(new Exception());
-                    delete = true;
-                    return false;
-                };
-            });
-            AddStep("Confirm dialog", () => InputManager.Key(Key.Number1));
-            AddUntilStep("Deletion requested", () => delete);
-            AddUntilStep("Comment is available", () =>
-            {
-                return !this.ChildrenOfType<DrawableComment>().Single(x => x.Comment.Id == 1).WasDeleted;
-            });
-            AddAssert("Loading spinner hidden", () =>
-            {
-                return ourComment.ChildrenOfType<LoadingSpinner>().All(d => !d.IsPresent);
-            });
-            AddAssert("Actions available", () =>
-            {
-                return ourComment.ChildrenOfType<LinkFlowContainer>().Single(x => x.Name == @"Actions buttons").IsPresent;
-            });
-        }
-
-        private void addTestComments()
-        {
-            AddStep("set up response", () =>
-            {
-                CommentBundle cb = new CommentBundle
-                {
-                    Comments = new List<Comment>
-                    {
-                        new Comment
-                        {
-                            Id = 1,
-                            Message = "This is our comment",
-                            UserId = API.LocalUser.Value.Id,
-                            CreatedAt = DateTimeOffset.Now,
-                            User = API.LocalUser.Value,
-                        },
-                        new Comment
-                        {
-                            Id = 2,
-                            Message = "This is a comment by another user",
-                            UserId = API.LocalUser.Value.Id + 1,
-                            CreatedAt = DateTimeOffset.Now,
-                            User = new APIUser
-                            {
-                                Id = API.LocalUser.Value.Id + 1,
-                                Username = "Another user"
-                            }
-                        },
-                    },
-                    IncludedComments = new List<Comment>(),
-                    PinnedComments = new List<Comment>(),
-                };
-                setUpCommentsResponse(cb);
-            });
-
-            AddStep("show comments", () => commentsContainer.ShowComments(CommentableType.Beatmapset, 123));
-        }
-
-        private void setUpCommentsResponse(CommentBundle commentBundle)
-        {
-            dummyAPI.HandleRequest = request =>
-            {
-                if (!(request is GetCommentsRequest getCommentsRequest))
-                    return false;
-
-                getCommentsRequest.TriggerSuccess(commentBundle);
-                return true;
-            };
-        }
-    }
-}

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

@@ -189,16 +189,6 @@ Line after image";
             });
         }
 
-        [Test]
-        public void TestFlag()
-        {
-            AddStep("Add flag", () =>
-            {
-                markdownContainer.CurrentPath = @"https://dev.ppy.sh";
-                markdownContainer.Text = "::{flag=\"AU\"}:: ::{flag=\"ZZ\"}::";
-            });
-        }
-
         private class TestMarkdownContainer : WikiMarkdownContainer
         {
             public LinkInline Link;

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

@@ -6,18 +6,14 @@ using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
-using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Online.API;
-using osu.Game.Overlays;
-using osu.Game.Overlays.Dialog;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Carousel;
 using osu.Game.Tests.Online;
 using osu.Game.Tests.Resources;
-using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.SongSelect
 {
@@ -45,7 +41,17 @@ namespace osu.Game.Tests.Visual.SongSelect
         [SetUpSteps]
         public void SetUpSteps()
         {
-            AddStep("create carousel", () => Child = createCarousel());
+            AddStep("create carousel", () =>
+            {
+                Child = carousel = new BeatmapCarousel
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    BeatmapSets = new List<BeatmapSetInfo>
+                    {
+                        (testBeatmapSetInfo = TestResources.CreateTestBeatmapSetInfo()),
+                    }
+                };
+            });
 
             AddUntilStep("wait for load", () => carousel.BeatmapSetsLoaded);
 
@@ -146,62 +152,5 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddUntilStep("wait for button enabled", () => getUpdateButton()?.Enabled.Value == true);
         }
-
-        [Test]
-        public void TestUpdateLocalBeatmap()
-        {
-            DialogOverlay dialogOverlay = null!;
-            UpdateBeatmapSetButton? updateButton = null;
-
-            AddStep("create carousel with dialog overlay", () =>
-            {
-                dialogOverlay = new DialogOverlay();
-
-                Child = new DependencyProvidingContainer
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    CachedDependencies = new (Type, object)[] { (typeof(IDialogOverlay), dialogOverlay), },
-                    Children = new Drawable[]
-                    {
-                        createCarousel(),
-                        dialogOverlay,
-                    },
-                };
-            });
-
-            AddStep("setup beatmap state", () =>
-            {
-                testBeatmapSetInfo.Beatmaps.First().OnlineMD5Hash = "different hash";
-                testBeatmapSetInfo.Beatmaps.First().LastOnlineUpdate = DateTimeOffset.Now;
-                testBeatmapSetInfo.Status = BeatmapOnlineStatus.LocallyModified;
-
-                carousel.UpdateBeatmapSet(testBeatmapSetInfo);
-            });
-
-            AddUntilStep("wait for update button", () => (updateButton = getUpdateButton()) != null);
-            AddStep("click button", () => updateButton.AsNonNull().TriggerClick());
-
-            AddAssert("dialog displayed", () => dialogOverlay.CurrentDialog is UpdateLocalConfirmationDialog);
-            AddStep("click confirmation", () =>
-            {
-                InputManager.MoveMouseTo(dialogOverlay.CurrentDialog.ChildrenOfType<PopupDialogButton>().First());
-                InputManager.PressButton(MouseButton.Left);
-            });
-
-            AddUntilStep("update started", () => beatmapDownloader.GetExistingDownload(testBeatmapSetInfo) != null);
-            AddStep("release mouse button", () => InputManager.ReleaseButton(MouseButton.Left));
-        }
-
-        private BeatmapCarousel createCarousel()
-        {
-            return carousel = new BeatmapCarousel
-            {
-                RelativeSizeAxes = Axes.Both,
-                BeatmapSets = new List<BeatmapSetInfo>
-                {
-                    (testBeatmapSetInfo = TestResources.CreateTestBeatmapSetInfo()),
-                }
-            };
-        }
     }
 }

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

@@ -15,7 +15,6 @@ using osu.Game.Graphics.Cursor;
 using osu.Game.Graphics.Sprites;
 using osuTK;
 using osuTK.Graphics;
-using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.UserInterface
 {
@@ -82,24 +81,25 @@ namespace osu.Game.Tests.Visual.UserInterface
             };
 
             AddToggleStep("Smooth transitions", b => cursorBoxes.ForEach(box => box.SmoothTransition = b));
-        }
 
-        [SetUp]
-        public void SetUp() => Schedule(moveOut);
+            testUserCursor();
+            testLocalCursor();
+            testUserCursorOverride();
+            testMultipleLocalCursors();
+        }
 
         /// <summary>
         /// -- Green Box --
         /// Tests whether hovering in and out of a drawable that provides the user cursor (green)
         /// results in the correct visibility state for that cursor.
         /// </summary>
-        [Test]
-        public void TestUserCursor()
+        private void testUserCursor()
         {
             AddStep("Move to green area", () => InputManager.MoveMouseTo(cursorBoxes[0]));
-            AddAssert("Check green cursor visible", () => checkVisible(cursorBoxes[0].Cursor));
-            AddAssert("Check green cursor at mouse", () => checkAtMouse(cursorBoxes[0].Cursor));
+            AddAssert("Check green cursor visible", () => checkVisible(cursorBoxes[0].MenuCursor));
+            AddAssert("Check green cursor at mouse", () => checkAtMouse(cursorBoxes[0].MenuCursor));
             AddStep("Move out", moveOut);
-            AddAssert("Check green cursor invisible", () => !checkVisible(cursorBoxes[0].Cursor));
+            AddAssert("Check green cursor invisible", () => !checkVisible(cursorBoxes[0].MenuCursor));
             AddAssert("Check global cursor visible", () => checkVisible(globalCursorDisplay.MenuCursor));
         }
 
@@ -108,16 +108,15 @@ namespace osu.Game.Tests.Visual.UserInterface
         /// Tests whether hovering in and out of a drawable that provides a local cursor (purple)
         /// results in the correct visibility and state for that cursor.
         /// </summary>
-        [Test]
-        public void TestLocalCursor()
+        private void testLocalCursor()
         {
             AddStep("Move to purple area", () => InputManager.MoveMouseTo(cursorBoxes[3]));
-            AddAssert("Check purple cursor visible", () => checkVisible(cursorBoxes[3].Cursor));
-            AddAssert("Check purple cursor at mouse", () => checkAtMouse(cursorBoxes[3].Cursor));
+            AddAssert("Check purple cursor visible", () => checkVisible(cursorBoxes[3].MenuCursor));
+            AddAssert("Check purple cursor at mouse", () => checkAtMouse(cursorBoxes[3].MenuCursor));
             AddAssert("Check global cursor visible", () => checkVisible(globalCursorDisplay.MenuCursor));
             AddAssert("Check global cursor at mouse", () => checkAtMouse(globalCursorDisplay.MenuCursor));
             AddStep("Move out", moveOut);
-            AddAssert("Check purple cursor visible", () => checkVisible(cursorBoxes[3].Cursor));
+            AddAssert("Check purple cursor visible", () => checkVisible(cursorBoxes[3].MenuCursor));
             AddAssert("Check global cursor visible", () => checkVisible(globalCursorDisplay.MenuCursor));
         }
 
@@ -126,98 +125,47 @@ namespace osu.Game.Tests.Visual.UserInterface
         /// Tests whether overriding a user cursor (green) with another user cursor (blue)
         /// results in the correct visibility and states for the cursors.
         /// </summary>
-        [Test]
-        public void TestUserCursorOverride()
+        private void testUserCursorOverride()
         {
             AddStep("Move to blue-green boundary", () => InputManager.MoveMouseTo(cursorBoxes[1].ScreenSpaceDrawQuad.BottomRight - new Vector2(10)));
-            AddAssert("Check blue cursor visible", () => checkVisible(cursorBoxes[1].Cursor));
-            AddAssert("Check green cursor invisible", () => !checkVisible(cursorBoxes[0].Cursor));
-            AddAssert("Check blue cursor at mouse", () => checkAtMouse(cursorBoxes[1].Cursor));
+            AddAssert("Check blue cursor visible", () => checkVisible(cursorBoxes[1].MenuCursor));
+            AddAssert("Check green cursor invisible", () => !checkVisible(cursorBoxes[0].MenuCursor));
+            AddAssert("Check blue cursor at mouse", () => checkAtMouse(cursorBoxes[1].MenuCursor));
             AddStep("Move out", moveOut);
-            AddAssert("Check blue cursor not visible", () => !checkVisible(cursorBoxes[1].Cursor));
-            AddAssert("Check green cursor not visible", () => !checkVisible(cursorBoxes[0].Cursor));
+            AddAssert("Check blue cursor not visible", () => !checkVisible(cursorBoxes[1].MenuCursor));
+            AddAssert("Check green cursor not visible", () => !checkVisible(cursorBoxes[0].MenuCursor));
         }
 
         /// <summary>
         /// -- Yellow-Purple Box Boundary --
         /// Tests whether multiple local cursors (purple + yellow) may be visible and at the mouse position at the same time.
         /// </summary>
-        [Test]
-        public void TestMultipleLocalCursors()
+        private void testMultipleLocalCursors()
         {
             AddStep("Move to yellow-purple boundary", () => InputManager.MoveMouseTo(cursorBoxes[5].ScreenSpaceDrawQuad.BottomRight - new Vector2(10)));
-            AddAssert("Check purple cursor visible", () => checkVisible(cursorBoxes[3].Cursor));
-            AddAssert("Check purple cursor at mouse", () => checkAtMouse(cursorBoxes[3].Cursor));
-            AddAssert("Check yellow cursor visible", () => checkVisible(cursorBoxes[5].Cursor));
-            AddAssert("Check yellow cursor at mouse", () => checkAtMouse(cursorBoxes[5].Cursor));
+            AddAssert("Check purple cursor visible", () => checkVisible(cursorBoxes[3].MenuCursor));
+            AddAssert("Check purple cursor at mouse", () => checkAtMouse(cursorBoxes[3].MenuCursor));
+            AddAssert("Check yellow cursor visible", () => checkVisible(cursorBoxes[5].MenuCursor));
+            AddAssert("Check yellow cursor at mouse", () => checkAtMouse(cursorBoxes[5].MenuCursor));
             AddStep("Move out", moveOut);
-            AddAssert("Check purple cursor visible", () => checkVisible(cursorBoxes[3].Cursor));
-            AddAssert("Check yellow cursor visible", () => checkVisible(cursorBoxes[5].Cursor));
+            AddAssert("Check purple cursor visible", () => checkVisible(cursorBoxes[3].MenuCursor));
+            AddAssert("Check yellow cursor visible", () => checkVisible(cursorBoxes[5].MenuCursor));
         }
 
         /// <summary>
         /// -- Yellow-Blue Box Boundary --
         /// Tests whether a local cursor (yellow) may be displayed along with a user cursor override (blue).
         /// </summary>
-        [Test]
-        public void TestUserOverrideWithLocal()
+        private void testUserOverrideWithLocal()
         {
-            AddStep("Move to yellow-blue boundary", () => InputManager.MoveMouseTo(cursorBoxes[5].ScreenSpaceDrawQuad.TopRight - new Vector2(10, 0)));
-            AddAssert("Check blue cursor visible", () => checkVisible(cursorBoxes[1].Cursor));
-            AddAssert("Check blue cursor at mouse", () => checkAtMouse(cursorBoxes[1].Cursor));
-            AddAssert("Check yellow cursor visible", () => checkVisible(cursorBoxes[5].Cursor));
-            AddAssert("Check yellow cursor at mouse", () => checkAtMouse(cursorBoxes[5].Cursor));
+            AddStep("Move to yellow-blue boundary", () => InputManager.MoveMouseTo(cursorBoxes[5].ScreenSpaceDrawQuad.TopRight - new Vector2(10)));
+            AddAssert("Check blue cursor visible", () => checkVisible(cursorBoxes[1].MenuCursor));
+            AddAssert("Check blue cursor at mouse", () => checkAtMouse(cursorBoxes[1].MenuCursor));
+            AddAssert("Check yellow cursor visible", () => checkVisible(cursorBoxes[5].MenuCursor));
+            AddAssert("Check yellow cursor at mouse", () => checkAtMouse(cursorBoxes[5].MenuCursor));
             AddStep("Move out", moveOut);
-            AddAssert("Check blue cursor invisible", () => !checkVisible(cursorBoxes[1].Cursor));
-            AddAssert("Check yellow cursor visible", () => checkVisible(cursorBoxes[5].Cursor));
-        }
-
-        /// <summary>
-        /// Ensures non-mouse input hides global cursor on a "local cursor" area (which doesn't hide global cursor).
-        /// </summary>
-        [Test]
-        public void TestKeyboardLocalCursor([Values] bool clickToShow)
-        {
-            AddStep("Enable cursor hiding", () => globalCursorDisplay.MenuCursor.HideCursorOnNonMouseInput = true);
-            AddStep("Move to purple area", () => InputManager.MoveMouseTo(cursorBoxes[3].ScreenSpaceDrawQuad.Centre + new Vector2(10, 0)));
-            AddAssert("Check purple cursor visible", () => checkVisible(cursorBoxes[3].Cursor));
-            AddAssert("Check global cursor alpha is 1", () => globalCursorDisplay.MenuCursor.Alpha == 1);
-
-            AddStep("Press key", () => InputManager.Key(Key.A));
-            AddAssert("Check purple cursor still visible", () => checkVisible(cursorBoxes[3].Cursor));
-            AddUntilStep("Check global cursor alpha is 0", () => globalCursorDisplay.MenuCursor.ActiveCursor.Alpha == 0);
-
-            if (clickToShow)
-                AddStep("Click mouse", () => InputManager.Click(MouseButton.Left));
-            else
-                AddStep("Move mouse", () => InputManager.MoveMouseTo(InputManager.CurrentState.Mouse.Position + Vector2.One));
-
-            AddAssert("Check purple cursor still visible", () => checkVisible(cursorBoxes[3].Cursor));
-            AddUntilStep("Check global cursor alpha is 1", () => globalCursorDisplay.MenuCursor.ActiveCursor.Alpha == 1);
-        }
-
-        /// <summary>
-        /// Ensures mouse input after non-mouse input doesn't show global cursor on a "user cursor" area (which hides global cursor).
-        /// </summary>
-        [Test]
-        public void TestKeyboardUserCursor([Values] bool clickToShow)
-        {
-            AddStep("Enable cursor hiding", () => globalCursorDisplay.MenuCursor.HideCursorOnNonMouseInput = true);
-            AddStep("Move to green area", () => InputManager.MoveMouseTo(cursorBoxes[0]));
-            AddAssert("Check green cursor visible", () => checkVisible(cursorBoxes[0].Cursor));
-            AddAssert("Check global cursor alpha is 0", () => !checkVisible(globalCursorDisplay.MenuCursor) && globalCursorDisplay.MenuCursor.ActiveCursor.Alpha == 0);
-
-            AddStep("Press key", () => InputManager.Key(Key.A));
-            AddAssert("Check green cursor still visible", () => checkVisible(cursorBoxes[0].Cursor));
-            AddAssert("Check global cursor alpha is still 0", () => !checkVisible(globalCursorDisplay.MenuCursor) && globalCursorDisplay.MenuCursor.ActiveCursor.Alpha == 0);
-
-            if (clickToShow)
-                AddStep("Click mouse", () => InputManager.Click(MouseButton.Left));
-            else
-                AddStep("Move mouse", () => InputManager.MoveMouseTo(InputManager.CurrentState.Mouse.Position + Vector2.One));
-
-            AddAssert("Check green cursor still visible", () => checkVisible(cursorBoxes[0].Cursor));
-            AddAssert("Check global cursor alpha is still 0", () => !checkVisible(globalCursorDisplay.MenuCursor) && globalCursorDisplay.MenuCursor.ActiveCursor.Alpha == 0);
+            AddAssert("Check blue cursor invisible", () => !checkVisible(cursorBoxes[1].MenuCursor));
+            AddAssert("Check yellow cursor visible", () => checkVisible(cursorBoxes[5].MenuCursor));
         }
 
         /// <summary>
@@ -243,7 +191,7 @@ namespace osu.Game.Tests.Visual.UserInterface
         {
             public bool SmoothTransition;
 
-            public CursorContainer Cursor { get; }
+            public CursorContainer MenuCursor { get; }
             public bool ProvidingUserCursor { get; }
 
             public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => base.ReceivePositionalInputAt(screenSpacePos) || (SmoothTransition && !ProvidingUserCursor);
@@ -270,7 +218,7 @@ namespace osu.Game.Tests.Visual.UserInterface
                         Origin = Anchor.Centre,
                         Text = providesUserCursor ? "User cursor" : "Local cursor"
                     },
-                    Cursor = new TestCursorContainer
+                    MenuCursor = new TestCursorContainer
                     {
                         State = { Value = providesUserCursor ? Visibility.Hidden : Visibility.Visible },
                     }

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

@@ -5,14 +5,12 @@
 
 using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Testing;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Settings;
-using osuTK;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.UserInterface
@@ -22,17 +20,11 @@ namespace osu.Game.Tests.Visual.UserInterface
     {
         private SettingsToolboxGroup group;
 
-        [Cached]
-        private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
-
         [SetUp]
         public void SetUp() => Schedule(() =>
         {
             Child = group = new SettingsToolboxGroup("example")
             {
-                Scale = new Vector2(3),
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
                 Children = new Drawable[]
                 {
                     new RoundedButton

osu.Game/Beatmaps/BeatmapImporter.cs

@@ -141,9 +141,18 @@ namespace osu.Game.Beatmaps
             // Handle collections using permissive difficulty name to track difficulties.
             foreach (var originalBeatmap in original.Beatmaps)
             {
-                updated.Beatmaps
-                       .FirstOrDefault(b => b.DifficultyName == originalBeatmap.DifficultyName)?
-                       .TransferCollectionReferences(realm, originalBeatmap.MD5Hash);
+                var updatedBeatmap = updated.Beatmaps.FirstOrDefault(b => b.DifficultyName == originalBeatmap.DifficultyName);
+
+                if (updatedBeatmap == null)
+                    continue;
+
+                var collections = realm.All<BeatmapCollection>().AsEnumerable().Where(c => c.BeatmapMD5Hashes.Contains(originalBeatmap.MD5Hash));
+
+                foreach (var c in collections)
+                {
+                    c.BeatmapMD5Hashes.Remove(originalBeatmap.MD5Hash);
+                    c.BeatmapMD5Hashes.Add(updatedBeatmap.MD5Hash);
+                }
             }
         }
 

osu.Game/Beatmaps/BeatmapInfo.cs

@@ -8,7 +8,6 @@ using JetBrains.Annotations;
 using Newtonsoft.Json;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Collections;
 using osu.Game.Database;
 using osu.Game.Models;
 using osu.Game.Online.API.Requests.Responses;
@@ -214,23 +213,6 @@ namespace osu.Game.Beatmaps
             return fileHashX == fileHashY;
         }
 
-        /// <summary>
-        /// When updating a beatmap, its hashes will change. Collections currently track beatmaps by hash, so they need to be updated.
-        /// This method will handle updating
-        /// </summary>
-        /// <param name="realm">A realm instance in an active write transaction.</param>
-        /// <param name="previousMD5Hash">The previous MD5 hash of the beatmap before update.</param>
-        public void TransferCollectionReferences(Realm realm, string previousMD5Hash)
-        {
-            var collections = realm.All<BeatmapCollection>().AsEnumerable().Where(c => c.BeatmapMD5Hashes.Contains(previousMD5Hash));
-
-            foreach (var c in collections)
-            {
-                c.BeatmapMD5Hashes.Remove(previousMD5Hash);
-                c.BeatmapMD5Hashes.Add(MD5Hash);
-            }
-        }
-
         IBeatmapMetadataInfo IBeatmapInfo.Metadata => Metadata;
         IBeatmapSetInfo? IBeatmapInfo.BeatmapSet => BeatmapSet;
         IRulesetInfo IBeatmapInfo.Ruleset => Ruleset;

osu.Game/Beatmaps/BeatmapManager.cs

@@ -311,8 +311,6 @@ namespace osu.Game.Beatmaps
                 if (existingFileInfo != null)
                     DeleteFile(setInfo, existingFileInfo);
 
-                string oldMd5Hash = beatmapInfo.MD5Hash;
-
                 beatmapInfo.MD5Hash = stream.ComputeMD5Hash();
                 beatmapInfo.Hash = stream.ComputeSHA2Hash();
 
@@ -329,8 +327,6 @@ namespace osu.Game.Beatmaps
 
                     setInfo.CopyChangesToRealm(liveBeatmapSet);
 
-                    beatmapInfo.TransferCollectionReferences(r, oldMd5Hash);
-
                     ProcessBeatmap?.Invoke((liveBeatmapSet, false));
                 });
             }

osu.Game/Beatmaps/ControlPoints/ControlPoint.cs

@@ -9,8 +9,11 @@ using osuTK.Graphics;
 
 namespace osu.Game.Beatmaps.ControlPoints
 {
-    public abstract class ControlPoint : IComparable<ControlPoint>, IDeepCloneable<ControlPoint>, IEquatable<ControlPoint>, IControlPoint
+    public abstract class ControlPoint : IComparable<ControlPoint>, IDeepCloneable<ControlPoint>, IEquatable<ControlPoint>
     {
+        /// <summary>
+        /// The time at which the control point takes effect.
+        /// </summary>
         [JsonIgnore]
         public double Time { get; set; }
 

osu.Game/Beatmaps/ControlPoints/ControlPointInfo.cs

@@ -196,8 +196,8 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// <param name="time">The time to find the control point at.</param>
         /// <param name="fallback">The control point to use when <paramref name="time"/> is before any control points.</param>
         /// <returns>The active control point at <paramref name="time"/>, or a fallback <see cref="ControlPoint"/> if none found.</returns>
-        public static T BinarySearchWithFallback<T>(IReadOnlyList<T> list, double time, T fallback)
-            where T : class, IControlPoint
+        protected T BinarySearchWithFallback<T>(IReadOnlyList<T> list, double time, T fallback)
+            where T : ControlPoint
         {
             return BinarySearch(list, time) ?? fallback;
         }
@@ -207,9 +207,9 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// </summary>
         /// <param name="list">The list to search.</param>
         /// <param name="time">The time to find the control point at.</param>
-        /// <returns>The active control point at <paramref name="time"/>. Will return <c>null</c> if there are no control points, or if the time is before the first control point.</returns>
-        public static T BinarySearch<T>(IReadOnlyList<T> list, double time)
-            where T : class, IControlPoint
+        /// <returns>The active control point at <paramref name="time"/>.</returns>
+        protected virtual T BinarySearch<T>(IReadOnlyList<T> list, double time)
+            where T : ControlPoint
         {
             if (list == null)
                 throw new ArgumentNullException(nameof(list));

osu.Game/Beatmaps/ControlPoints/IControlPoint.cs

@@ -1,13 +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.
-
-namespace osu.Game.Beatmaps.ControlPoints
-{
-    public interface IControlPoint
-    {
-        /// <summary>
-        /// The time at which the control point takes effect.
-        /// </summary>
-        double Time { get; }
-    }
-}

osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs

@@ -355,14 +355,6 @@ namespace osu.Game.Beatmaps.Formats
 
             switch (type)
             {
-                case LegacyEventType.Sprite:
-                    // Generally, the background is the first thing defined in a beatmap file.
-                    // In some older beatmaps, it is not present and replaced by a storyboard-level background instead.
-                    // Allow the first sprite (by file order) to act as the background in such cases.
-                    if (string.IsNullOrEmpty(beatmap.BeatmapInfo.Metadata.BackgroundFile))
-                        beatmap.BeatmapInfo.Metadata.BackgroundFile = CleanFilename(split[3]);
-                    break;
-
                 case LegacyEventType.Background:
                     beatmap.BeatmapInfo.Metadata.BackgroundFile = CleanFilename(split[2]);
                     break;

osu.Game/Beatmaps/IWorkingBeatmap.cs

@@ -134,6 +134,6 @@ namespace osu.Game.Beatmaps
         /// <summary>
         /// Reads the correct track restart point from beatmap metadata and sets looping to enabled.
         /// </summary>
-        void PrepareTrackForPreview(bool looping, double offsetFromPreviewPoint = 0);
+        void PrepareTrackForPreview(bool looping);
     }
 }

osu.Game/Beatmaps/WorkingBeatmap.cs

@@ -110,7 +110,7 @@ namespace osu.Game.Beatmaps
 
         public Track LoadTrack() => track = GetBeatmapTrack() ?? GetVirtualTrack(1000);
 
-        public void PrepareTrackForPreview(bool looping, double offsetFromPreviewPoint = 0)
+        public void PrepareTrackForPreview(bool looping)
         {
             Track.Looping = looping;
             Track.RestartPoint = Metadata.PreviewTime;
@@ -125,8 +125,6 @@ namespace osu.Game.Beatmaps
 
                 Track.RestartPoint = 0.4f * Track.Length;
             }
-
-            Track.RestartPoint += offsetFromPreviewPoint;
         }
 
         /// <summary>

osu.Game/Database/ModelDownloader.cs

@@ -45,7 +45,7 @@ namespace osu.Game.Database
 
         public bool Download(T model, bool minimiseDownloadSize = false) => Download(model, minimiseDownloadSize, null);
 
-        public void DownloadAsUpdate(TModel originalModel, bool minimiseDownloadSize) => Download(originalModel, minimiseDownloadSize, originalModel);
+        public void DownloadAsUpdate(TModel originalModel) => Download(originalModel, false, originalModel);
 
         protected bool Download(T model, bool minimiseDownloadSize, TModel? originalModel)
         {

osu.Game/Database/RealmArchiveModelImporter.cs

@@ -294,38 +294,15 @@ namespace osu.Game.Database
                 // Log output here will be missing a valid hash in non-batch imports.
                 LogForModel(item, $@"Beginning import from {archive?.Name ?? "unknown"}...");
 
-                List<RealmNamedFileUsage> files = new List<RealmNamedFileUsage>();
-
-                if (archive != null)
-                {
-                    // Import files to the disk store.
-                    // We intentionally delay adding to realm to avoid blocking on a write during disk operations.
-                    foreach (var filenames in getShortenedFilenames(archive))
-                    {
-                        using (Stream s = archive.GetStream(filenames.original))
-                            files.Add(new RealmNamedFileUsage(Files.Add(s, realm, false), filenames.shortened));
-                    }
-                }
-
-                using (var transaction = realm.BeginWrite())
-                {
-                    // Add all files to realm in one go.
-                    // This is done ahead of the main transaction to ensure we can correctly cleanup the files, even if the import fails.
-                    foreach (var file in files)
-                    {
-                        if (!file.File.IsManaged)
-                            realm.Add(file.File, true);
-                    }
-
-                    transaction.Commit();
-                }
-
-                item.Files.AddRange(files);
-                item.Hash = ComputeHash(item);
-
                 // TODO: do we want to make the transaction this local? not 100% sure, will need further investigation.
                 using (var transaction = realm.BeginWrite())
                 {
+                    if (archive != null)
+                        // TODO: look into rollback of file additions (or delayed commit).
+                        item.Files.AddRange(createFileInfos(archive, Files, realm));
+
+                    item.Hash = ComputeHash(item);
+
                     // TODO: we may want to run this outside of the transaction.
                     Populate(item, archive, realm, cancellationToken);
 
@@ -448,6 +425,16 @@ namespace osu.Game.Database
         {
             var fileInfos = new List<RealmNamedFileUsage>();
 
+            // import files to manager
+            foreach (var filenames in getShortenedFilenames(reader))
+            {
+                using (Stream s = reader.GetStream(filenames.original))
+                {
+                    var item = new RealmNamedFileUsage(files.Add(s, realm), filenames.shortened);
+                    fileInfos.Add(item);
+                }
+            }
+
             return fileInfos;
         }
 

osu.Game/Database/RealmFileStore.cs

@@ -40,8 +40,8 @@ namespace osu.Game.Database
         /// </summary>
         /// <param name="data">The file data stream.</param>
         /// <param name="realm">The realm instance to add to. Should already be in a transaction.</param>
-        /// <param name="addToRealm">Whether the <see cref="RealmFile"/> should immediately be added to the underlying realm. If <c>false</c> is provided here, the instance must be manually added.</param>
-        public RealmFile Add(Stream data, Realm realm, bool addToRealm = true)
+        /// <returns></returns>
+        public RealmFile Add(Stream data, Realm realm)
         {
             string hash = data.ComputeSHA2Hash();
 
@@ -52,7 +52,7 @@ namespace osu.Game.Database
             if (!checkFileExistsAndMatchesHash(file))
                 copyToStore(file, data);
 
-            if (addToRealm && !file.IsManaged)
+            if (!file.IsManaged)
                 realm.Add(file);
 
             return file;

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

@@ -5,7 +5,6 @@
 
 using Markdig;
 using Markdig.Extensions.AutoLinks;
-using Markdig.Extensions.CustomContainers;
 using Markdig.Extensions.EmphasisExtras;
 using Markdig.Extensions.Footnotes;
 using Markdig.Extensions.Tables;
@@ -33,12 +32,6 @@ namespace osu.Game.Graphics.Containers.Markdown
         /// <seealso cref="AutoLinkExtension"/>
         protected virtual bool Autolinks => false;
 
-        /// <summary>
-        /// Allows this markdown container to parse custom containers (used for flags and infoboxes).
-        /// </summary>
-        /// <seealso cref="CustomContainerExtension"/>
-        protected virtual bool CustomContainers => false;
-
         public OsuMarkdownContainer()
         {
             LineSpacing = 21;
@@ -114,9 +107,6 @@ namespace osu.Game.Graphics.Containers.Markdown
             if (Autolinks)
                 pipeline = pipeline.UseAutoLinks();
 
-            if (CustomContainers)
-                pipeline.UseCustomContainers();
-
             return pipeline.Build();
         }
     }

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

@@ -3,9 +3,6 @@
 
 #nullable disable
 
-using System;
-using System.Linq;
-using Markdig.Extensions.CustomContainers;
 using Markdig.Syntax.Inlines;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
@@ -14,9 +11,6 @@ using osu.Framework.Graphics.Containers.Markdown;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Overlays;
-using osu.Game.Users;
-using osu.Game.Users.Drawables;
-using osuTK;
 
 namespace osu.Game.Graphics.Containers.Markdown
 {
@@ -39,31 +33,6 @@ namespace osu.Game.Graphics.Containers.Markdown
         protected override SpriteText CreateEmphasisedSpriteText(bool bold, bool italic)
             => CreateSpriteText().With(t => t.Font = t.Font.With(weight: bold ? FontWeight.Bold : FontWeight.Regular, italics: italic));
 
-        protected override void AddCustomComponent(CustomContainerInline inline)
-        {
-            if (!(inline.FirstChild is LiteralInline literal))
-            {
-                base.AddCustomComponent(inline);
-                return;
-            }
-
-            string[] attributes = literal.Content.ToString().Trim(' ', '{', '}').Split();
-            string flagAttribute = attributes.SingleOrDefault(a => a.StartsWith(@"flag", StringComparison.Ordinal));
-
-            if (flagAttribute == null)
-            {
-                base.AddCustomComponent(inline);
-                return;
-            }
-
-            string flag = flagAttribute.Split('=').Last().Trim('"');
-
-            if (!Enum.TryParse<CountryCode>(flag, out var countryCode))
-                countryCode = CountryCode.Unknown;
-
-            AddDrawable(new DrawableFlag(countryCode) { Size = new Vector2(20, 15) });
-        }
-
         private class OsuMarkdownInlineCode : Container
         {
             [Resolved]

osu.Game/Graphics/Cursor/GlobalCursorDisplay.cs

@@ -13,7 +13,7 @@ using osu.Game.Configuration;
 namespace osu.Game.Graphics.Cursor
 {
     /// <summary>
-    /// A container which provides the main <see cref="MenuCursorContainer"/>.
+    /// A container which provides the main <see cref="Cursor.MenuCursor"/>.
     /// Also handles cases where a more localised cursor is provided by another component (via <see cref="IProvideCursor"/>).
     /// </summary>
     public class GlobalCursorDisplay : Container, IProvideCursor
@@ -23,9 +23,7 @@ namespace osu.Game.Graphics.Cursor
         /// </summary>
         internal bool ShowCursor = true;
 
-        CursorContainer IProvideCursor.Cursor => MenuCursor;
-
-        public MenuCursorContainer MenuCursor { get; }
+        public CursorContainer MenuCursor { get; }
 
         public bool ProvidingUserCursor => true;
 
@@ -44,8 +42,8 @@ namespace osu.Game.Graphics.Cursor
         {
             AddRangeInternal(new Drawable[]
             {
-                Content = new Container { RelativeSizeAxes = Axes.Both },
-                MenuCursor = new MenuCursorContainer { State = { Value = Visibility.Hidden } }
+                MenuCursor = new MenuCursor { State = { Value = Visibility.Hidden } },
+                Content = new Container { RelativeSizeAxes = Axes.Both }
             });
         }
 
@@ -66,7 +64,7 @@ namespace osu.Game.Graphics.Cursor
 
             if (!hasValidInput || !ShowCursor)
             {
-                currentOverrideProvider?.Cursor?.Hide();
+                currentOverrideProvider?.MenuCursor?.Hide();
                 currentOverrideProvider = null;
                 return;
             }
@@ -85,8 +83,8 @@ namespace osu.Game.Graphics.Cursor
             if (currentOverrideProvider == newOverrideProvider)
                 return;
 
-            currentOverrideProvider?.Cursor?.Hide();
-            newOverrideProvider.Cursor?.Show();
+            currentOverrideProvider?.MenuCursor?.Hide();
+            newOverrideProvider.MenuCursor?.Show();
 
             currentOverrideProvider = newOverrideProvider;
         }

osu.Game/Graphics/Cursor/IProvideCursor.cs

@@ -17,10 +17,10 @@ namespace osu.Game.Graphics.Cursor
         /// The cursor provided by this <see cref="IDrawable"/>.
         /// May be null if no cursor should be visible.
         /// </summary>
-        CursorContainer Cursor { get; }
+        CursorContainer MenuCursor { get; }
 
         /// <summary>
-        /// Whether <see cref="Cursor"/> should be displayed as the singular user cursor. This will temporarily hide any other user cursor.
+        /// Whether <see cref="MenuCursor"/> should be displayed as the singular user cursor. This will temporarily hide any other user cursor.
         /// This value is checked every frame and may be used to control whether multiple cursors are displayed (e.g. watching replays).
         /// </summary>
         bool ProvidingUserCursor { get; }

osu.Game/Graphics/Cursor/MenuCursor.cs

@@ -1,7 +1,10 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+#nullable disable
+
 using System;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
@@ -18,43 +21,24 @@ using osuTK;
 
 namespace osu.Game.Graphics.Cursor
 {
-    public class MenuCursorContainer : CursorContainer
+    public class MenuCursor : CursorContainer
     {
         private readonly IBindable<bool> screenshotCursorVisibility = new Bindable<bool>(true);
         public override bool IsPresent => screenshotCursorVisibility.Value && base.IsPresent;
 
-        private bool hideCursorOnNonMouseInput;
-
-        public bool HideCursorOnNonMouseInput
-        {
-            get => hideCursorOnNonMouseInput;
-            set
-            {
-                if (hideCursorOnNonMouseInput == value)
-                    return;
-
-                hideCursorOnNonMouseInput = value;
-                updateState();
-            }
-        }
-
         protected override Drawable CreateCursor() => activeCursor = new Cursor();
 
-        private Cursor activeCursor = null!;
+        private Cursor activeCursor;
 
+        private Bindable<bool> cursorRotate;
         private DragRotationState dragRotationState;
         private Vector2 positionMouseDown;
+
+        private Sample tapSample;
         private Vector2 lastMovePosition;
 
-        private Bindable<bool> cursorRotate = null!;
-        private Sample tapSample = null!;
-
-        private MouseInputDetector mouseInputDetector = null!;
-
-        private bool visible;
-
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config, ScreenshotManager? screenshotManager, AudioManager audio)
+        [BackgroundDependencyLoader(true)]
+        private void load([NotNull] OsuConfigManager config, [CanBeNull] ScreenshotManager screenshotManager, AudioManager audio)
         {
             cursorRotate = config.GetBindable<bool>(OsuSetting.CursorRotation);
 
@@ -62,45 +46,6 @@ namespace osu.Game.Graphics.Cursor
                 screenshotCursorVisibility.BindTo(screenshotManager.CursorVisibility);
 
             tapSample = audio.Samples.Get(@"UI/cursor-tap");
-
-            Add(mouseInputDetector = new MouseInputDetector());
-        }
-
-        [Resolved]
-        private OsuGame? game { get; set; }
-
-        private readonly IBindable<bool> lastInputWasMouse = new BindableBool();
-        private readonly IBindable<bool> isIdle = new BindableBool();
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            lastInputWasMouse.BindTo(mouseInputDetector.LastInputWasMouseSource);
-            lastInputWasMouse.BindValueChanged(_ => updateState(), true);
-
-            if (game != null)
-            {
-                isIdle.BindTo(game.IsIdle);
-                isIdle.BindValueChanged(_ => updateState());
-            }
-        }
-
-        protected override void UpdateState(ValueChangedEvent<Visibility> state) => updateState();
-
-        private void updateState()
-        {
-            bool combinedVisibility = State.Value == Visibility.Visible && (lastInputWasMouse.Value || !hideCursorOnNonMouseInput) && !isIdle.Value;
-
-            if (visible == combinedVisibility)
-                return;
-
-            visible = combinedVisibility;
-
-            if (visible)
-                PopIn();
-            else
-                PopOut();
         }
 
         protected override void Update()
@@ -218,11 +163,11 @@ namespace osu.Game.Graphics.Cursor
 
         public class Cursor : Container
         {
-            private Container cursorContainer = null!;
-            private Bindable<float> cursorScale = null!;
+            private Container cursorContainer;
+            private Bindable<float> cursorScale;
             private const float base_scale = 0.15f;
 
-            public Sprite AdditiveLayer = null!;
+            public Sprite AdditiveLayer;
 
             public Cursor()
             {
@@ -259,40 +204,6 @@ namespace osu.Game.Graphics.Cursor
             }
         }
 
-        private class MouseInputDetector : Component
-        {
-            /// <summary>
-            /// Whether the last input applied to the game is sourced from mouse.
-            /// </summary>
-            public IBindable<bool> LastInputWasMouseSource => lastInputWasMouseSource;
-
-            private readonly Bindable<bool> lastInputWasMouseSource = new Bindable<bool>();
-
-            public MouseInputDetector()
-            {
-                RelativeSizeAxes = Axes.Both;
-            }
-
-            protected override bool Handle(UIEvent e)
-            {
-                switch (e)
-                {
-                    case MouseDownEvent:
-                    case MouseMoveEvent:
-                        lastInputWasMouseSource.Value = true;
-                        return false;
-
-                    case KeyDownEvent keyDown when !keyDown.Repeat:
-                    case JoystickPressEvent:
-                    case MidiDownEvent:
-                        lastInputWasMouseSource.Value = false;
-                        return false;
-                }
-
-                return false;
-            }
-        }
-
         private enum DragRotationState
         {
             NotDragging,

osu.Game/Graphics/UserInterface/ExternalLinkButton.cs

@@ -10,6 +10,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
+using osu.Game.Localisation;
 using osu.Framework.Platform;
 using osu.Game.Overlays;
 using osu.Game.Overlays.OSD;
@@ -93,7 +94,15 @@ namespace osu.Game.Graphics.UserInterface
         private void copyUrl()
         {
             host.GetClipboard()?.SetText(Link);
-            onScreenDisplay?.Display(new CopyUrlToast());
+            onScreenDisplay?.Display(new CopyUrlToast(ToastStrings.UrlCopied));
+        }
+
+        private class CopyUrlToast : Toast
+        {
+            public CopyUrlToast(LocalisableString value)
+                : base(UserInterfaceStrings.GeneralHeader, value, "")
+            {
+            }
         }
     }
 }

osu.Game/Graphics/UserInterface/HoverSampleSet.cs

@@ -15,9 +15,6 @@ namespace osu.Game.Graphics.UserInterface
         [Description("button")]
         Button,
 
-        [Description("button-sidebar")]
-        ButtonSidebar,
-
         [Description("toolbar")]
         Toolbar,
 

osu.Game/Graphics/UserInterface/OsuSliderBar.cs

@@ -44,8 +44,6 @@ namespace osu.Game.Graphics.UserInterface
 
         public virtual LocalisableString TooltipText { get; private set; }
 
-        public bool PlaySamplesOnAdjust { get; set; } = true;
-
         /// <summary>
         /// Whether to format the tooltip as a percentage or the actual value.
         /// </summary>
@@ -189,9 +187,6 @@ namespace osu.Game.Graphics.UserInterface
 
         private void playSample(T value)
         {
-            if (!PlaySamplesOnAdjust)
-                return;
-
             if (Clock == null || Clock.CurrentTime - lastSampleTime <= 30)
                 return;
 

osu.Game/Input/Bindings/DatabasedKeyBindingContainer.cs

@@ -55,13 +55,13 @@ namespace osu.Game.Input.Bindings
             {
                 // The first fire of this is a bit redundant as this is being called in base.LoadComplete,
                 // but this is safest in case the subscription is restored after a context recycle.
-                ReloadMappings(sender.AsQueryable());
+                reloadMappings(sender.AsQueryable());
             });
 
             base.LoadComplete();
         }
 
-        protected sealed override void ReloadMappings() => ReloadMappings(queryRealmKeyBindings(realm.Realm));
+        protected override void ReloadMappings() => reloadMappings(queryRealmKeyBindings(realm.Realm));
 
         private IQueryable<RealmKeyBinding> queryRealmKeyBindings(Realm realm)
         {
@@ -70,7 +70,7 @@ namespace osu.Game.Input.Bindings
                         .Where(b => b.RulesetName == rulesetName && b.Variant == variant);
         }
 
-        protected virtual void ReloadMappings(IQueryable<RealmKeyBinding> realmKeyBindings)
+        private void reloadMappings(IQueryable<RealmKeyBinding> realmKeyBindings)
         {
             var defaults = DefaultKeyBindings.ToList();
 

osu.Game/Localisation/PopupDialogStrings.cs

@@ -1,24 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Localisation;
-
-namespace osu.Game.Localisation
-{
-    public static class PopupDialogStrings
-    {
-        private const string prefix = @"osu.Game.Resources.Localisation.PopupDialog";
-
-        /// <summary>
-        /// "Are you sure you want to update this beatmap?"
-        /// </summary>
-        public static LocalisableString UpdateLocallyModifiedText => new TranslatableString(getKey(@"update_locally_modified_text"), @"Are you sure you want to update this beatmap?");
-
-        /// <summary>
-        /// "This will discard all local changes you have on that beatmap."
-        /// </summary>
-        public static LocalisableString UpdateLocallyModifiedDescription => new TranslatableString(getKey(@"update_locally_modified_description"), @"This will discard all local changes you have on that beatmap.");
-
-        private static string getKey(string key) => $@"{prefix}:{key}";
-    }
-}

osu.Game/Online/API/Requests/CommentDeleteRequest.cs

@@ -1,28 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Net.Http;
-using osu.Framework.IO.Network;
-using osu.Game.Online.API.Requests.Responses;
-
-namespace osu.Game.Online.API.Requests
-{
-    public class CommentDeleteRequest : APIRequest<CommentBundle>
-    {
-        public readonly long CommentId;
-
-        public CommentDeleteRequest(long id)
-        {
-            CommentId = id;
-        }
-
-        protected override WebRequest CreateWebRequest()
-        {
-            var req = base.CreateWebRequest();
-            req.Method = HttpMethod.Delete;
-            return req;
-        }
-
-        protected override string Target => $@"comments/{CommentId}";
-    }
-}

osu.Game/Online/API/Requests/Responses/Comment.cs

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+#nullable disable
+
 using Newtonsoft.Json;
 using System;
 
@@ -14,18 +16,18 @@ namespace osu.Game.Online.API.Requests.Responses
         [JsonProperty(@"parent_id")]
         public long? ParentId { get; set; }
 
-        public Comment? ParentComment { get; set; }
+        public Comment ParentComment { get; set; }
 
         [JsonProperty(@"user_id")]
         public long? UserId { get; set; }
 
-        public APIUser? User { get; set; }
+        public APIUser User { get; set; }
 
         [JsonProperty(@"message")]
-        public string Message { get; set; } = null!;
+        public string Message { get; set; }
 
         [JsonProperty(@"message_html")]
-        public string? MessageHtml { get; set; }
+        public string MessageHtml { get; set; }
 
         [JsonProperty(@"replies_count")]
         public int RepliesCount { get; set; }
@@ -34,13 +36,13 @@ namespace osu.Game.Online.API.Requests.Responses
         public int VotesCount { get; set; }
 
         [JsonProperty(@"commenatble_type")]
-        public string CommentableType { get; set; } = null!;
+        public string CommentableType { get; set; }
 
         [JsonProperty(@"commentable_id")]
         public int CommentableId { get; set; }
 
         [JsonProperty(@"legacy_name")]
-        public string? LegacyName { get; set; }
+        public string LegacyName { get; set; }
 
         [JsonProperty(@"created_at")]
         public DateTimeOffset CreatedAt { get; set; }
@@ -60,7 +62,7 @@ namespace osu.Game.Online.API.Requests.Responses
         [JsonProperty(@"pinned")]
         public bool Pinned { get; set; }
 
-        public APIUser? EditedUser { get; set; }
+        public APIUser EditedUser { get; set; }
 
         public bool IsTopLevel => !ParentId.HasValue;
 

osu.Game/Online/API/Requests/Responses/SoloScoreInfo.cs

@@ -114,7 +114,6 @@ namespace osu.Game.Online.API.Requests.Responses
         [JsonProperty("has_replay")]
         public bool HasReplay { get; set; }
 
-        // These properties are calculated or not relevant to any external usage.
         public bool ShouldSerializeID() => false;
         public bool ShouldSerializeUser() => false;
         public bool ShouldSerializeBeatmap() => false;
@@ -123,18 +122,6 @@ namespace osu.Game.Online.API.Requests.Responses
         public bool ShouldSerializeOnlineID() => false;
         public bool ShouldSerializeHasReplay() => false;
 
-        // These fields only need to be serialised if they hold values.
-        // Generally this is required because this model may be used by server-side components, but
-        // we don't want to bother sending these fields in score submission requests, for instance.
-        public bool ShouldSerializeEndedAt() => EndedAt != default;
-        public bool ShouldSerializeStartedAt() => StartedAt != default;
-        public bool ShouldSerializeLegacyScoreId() => LegacyScoreId != null;
-        public bool ShouldSerializeLegacyTotalScore() => LegacyTotalScore != null;
-        public bool ShouldSerializeMods() => Mods.Length > 0;
-        public bool ShouldSerializeUserID() => UserID > 0;
-        public bool ShouldSerializeBeatmapID() => BeatmapID > 0;
-        public bool ShouldSerializeBuildID() => BuildID != null;
-
         #endregion
 
         public override string ToString() => $"score_id: {ID} user_id: {UserID}";

osu.Game/Online/Rooms/MultiplayerScore.cs

@@ -65,7 +65,7 @@ namespace osu.Game.Online.Rooms
         [CanBeNull]
         public MultiplayerScoresAround ScoresAround { get; set; }
 
-        public ScoreInfo CreateScoreInfo(ScoreManager scoreManager, RulesetStore rulesets, PlaylistItem playlistItem, [NotNull] BeatmapInfo beatmap)
+        public ScoreInfo CreateScoreInfo(RulesetStore rulesets, PlaylistItem playlistItem, [NotNull] BeatmapInfo beatmap)
         {
             var ruleset = rulesets.GetRuleset(playlistItem.RulesetID);
             if (ruleset == null)
@@ -90,8 +90,6 @@ namespace osu.Game.Online.Rooms
                 Position = Position,
             };
 
-            scoreManager.PopulateMaximumStatistics(scoreInfo);
-
             return scoreInfo;
         }
     }

osu.Game/OsuGame.cs

@@ -70,7 +70,6 @@ namespace osu.Game
     /// The full osu! experience. Builds on top of <see cref="OsuGameBase"/> to add menus and binding logic
     /// for initial components that are generally retrieved via DI.
     /// </summary>
-    [Cached(typeof(OsuGame))]
     public class OsuGame : OsuGameBase, IKeyBindingHandler<GlobalAction>, ILocalUserPlayInfo, IPerformFromScreenRunner, IOverlayManager, ILinkHandler
     {
         /// <summary>
@@ -137,11 +136,6 @@ namespace osu.Game
 
         private IdleTracker idleTracker;
 
-        /// <summary>
-        /// Whether the user is currently in an idle state.
-        /// </summary>
-        public IBindable<bool> IsIdle => idleTracker.IsIdle;
-
         /// <summary>
         /// Whether overlays should be able to be opened game-wide. Value is sourced from the current active screen.
         /// </summary>
@@ -272,6 +266,8 @@ namespace osu.Game
         [BackgroundDependencyLoader]
         private void load()
         {
+            dependencies.CacheAs(this);
+
             SentryLogger.AttachUser(API.LocalUser);
 
             dependencies.Cache(osuLogo = new OsuLogo { Alpha = 0 });
@@ -567,15 +563,6 @@ namespace osu.Game
 
             // This should be able to be performed from song select, but that is disabled for now
             // due to the weird decoupled ruleset logic (which can cause a crash in certain filter scenarios).
-            //
-            // As a special case, if the beatmap and ruleset already match, allow immediately displaying the score from song select.
-            // This is guaranteed to not crash, and feels better from a user's perspective (ie. if they are clicking a score in the
-            // song select leaderboard).
-            IEnumerable<Type> validScreens =
-                Beatmap.Value.BeatmapInfo.Equals(databasedBeatmap) && Ruleset.Value.Equals(databasedScore.ScoreInfo.Ruleset)
-                    ? new[] { typeof(SongSelect) }
-                    : Array.Empty<Type>();
-
             PerformFromScreen(screen =>
             {
                 Logger.Log($"{nameof(PresentScore)} updating beatmap ({databasedBeatmap}) and ruleset ({databasedScore.ScoreInfo.Ruleset}) to match score");
@@ -593,7 +580,7 @@ namespace osu.Game
                         screen.Push(new SoloResultsScreen(databasedScore.ScoreInfo, false));
                         break;
                 }
-            }, validScreens: validScreens);
+            });
         }
 
         public override Task Import(params ImportTask[] imports)
@@ -1059,7 +1046,7 @@ namespace osu.Game
 
             Logger.NewEntry += entry =>
             {
-                if (entry.Level < LogLevel.Important || entry.Target != LoggingTarget.Input || !entry.Message.StartsWith(tablet_prefix, StringComparison.OrdinalIgnoreCase))
+                if (entry.Level < LogLevel.Important || !entry.Message.StartsWith(tablet_prefix, StringComparison.OrdinalIgnoreCase))
                     return;
 
                 string message = entry.Message.Replace(tablet_prefix, string.Empty);
@@ -1333,8 +1320,6 @@ namespace osu.Game
                 OverlayActivationMode.BindTo(newOsuScreen.OverlayActivationMode);
                 API.Activity.BindTo(newOsuScreen.Activity);
 
-                GlobalCursorDisplay.MenuCursor.HideCursorOnNonMouseInput = newOsuScreen.HideMenuCursorOnNonMouseInput;
-
                 if (newOsuScreen.HideOverlaysOnEnter)
                     CloseAllOverlays();
                 else