Merge branch 'master' into DynamicHealthProcessor

.github/ISSUE_TEMPLATE/bug-issue.yml

@@ -11,6 +11,10 @@ body:
         - Current open `priority:0` issues, filterable [here](https://github.com/ppy/osu/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3Apriority%3A0).
         - And most importantly, search for your issue both in the [issue listing](https://github.com/ppy/osu/issues) and the [Q&A discussion listing](https://github.com/ppy/osu/discussions/categories/q-a). If you find that it already exists, respond with a reaction or add any further information that may be helpful.
 
+        # ATTENTION LINUX USERS
+
+        If you are having an issue and it is hardware related, **please open a [q&a discussion](https://github.com/ppy/osu/discussions/categories/q-a)** instead of an issue. There's a high chance your issue is due to your system configuration, and not our software.
+
   - type: dropdown
     attributes:
       label: Type

osu.Android.props

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

osu.Game.Rulesets.Catch.Tests/Mods/TestSceneCatchModPerfect.cs

@@ -11,7 +11,7 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Tests.Mods
 {
-    public partial class TestSceneCatchModPerfect : ModPerfectTestScene
+    public partial class TestSceneCatchModPerfect : ModFailConditionTestScene
     {
         protected override Ruleset CreatePlayerRuleset() => new CatchRuleset();
 

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

@@ -0,0 +1,72 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    public partial class TestSceneOutOfBoundsObjects : TestSceneCatchPlayer
+    {
+        protected override bool Autoplay => true;
+
+        [Test]
+        public void TestNoOutOfBoundsObjects()
+        {
+            bool anyObjectOutOfBounds = false;
+
+            AddStep("reset flag", () => anyObjectOutOfBounds = false);
+
+            AddUntilStep("check for out-of-bounds objects",
+                () =>
+                {
+                    anyObjectOutOfBounds |= Player.ChildrenOfType<DrawableCatchHitObject>().Any(dho => dho.X < 0 || dho.X > CatchPlayfield.WIDTH);
+                    return Player.ScoreProcessor.HasCompleted.Value;
+                });
+
+            AddAssert("no out of bound objects found", () => !anyObjectOutOfBounds);
+        }
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new Beatmap
+        {
+            BeatmapInfo = new BeatmapInfo
+            {
+                Ruleset = ruleset,
+            },
+            HitObjects = new List<HitObject>
+            {
+                new Fruit { StartTime = 1000, X = -50 },
+                new Fruit { StartTime = 1200, X = CatchPlayfield.WIDTH + 50 },
+                new JuiceStream
+                {
+                    StartTime = 1500,
+                    X = 10,
+                    Path = new SliderPath(PathType.LINEAR, new[]
+                    {
+                        Vector2.Zero,
+                        new Vector2(-200, 0)
+                    })
+                },
+                new JuiceStream
+                {
+                    StartTime = 3000,
+                    X = CatchPlayfield.WIDTH - 10,
+                    Path = new SliderPath(PathType.LINEAR, new[]
+                    {
+                        Vector2.Zero,
+                        new Vector2(200, 0)
+                    })
+                },
+            }
+        };
+    }
+}

osu.Game.Rulesets.Catch/Objects/Drawables/DrawablePalpableCatchHitObject.cs

@@ -1,10 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Catch.UI;
 using osuTK;
 using osuTK.Graphics;
 
@@ -70,7 +72,10 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
 
         private void updateXPosition(ValueChangedEvent<float> _)
         {
-            X = OriginalXBindable.Value + XOffsetBindable.Value;
+            // same as `CatchHitObject.EffectiveX`.
+            // not using that property directly to support scenarios where `HitObject` may not necessarily be present
+            // for this pooled drawable.
+            X = Math.Clamp(OriginalXBindable.Value + XOffsetBindable.Value, 0, CatchPlayfield.WIDTH);
         }
 
         protected override void OnApply()

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

@@ -1,14 +1,19 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
 using NUnit.Framework;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Replays;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Replays;
 using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Mania.Tests.Mods
 {
-    public partial class TestSceneManiaModPerfect : ModPerfectTestScene
+    public partial class TestSceneManiaModPerfect : ModFailConditionTestScene
     {
         protected override Ruleset CreatePlayerRuleset() => new ManiaRuleset();
 
@@ -24,5 +29,52 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
         [TestCase(false)]
         [TestCase(true)]
         public void TestHoldNote(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new HoldNote { StartTime = 1000, EndTime = 3000 }), shouldMiss);
+
+        [Test]
+        public void TestGreatHit() => CreateModTest(new ModTestData
+        {
+            Mod = new ManiaModPerfect(),
+            PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(false),
+            Autoplay = false,
+            Beatmap = new Beatmap
+            {
+                HitObjects = new List<HitObject>
+                {
+                    new Note
+                    {
+                        StartTime = 1000,
+                    }
+                },
+            },
+            ReplayFrames = new List<ReplayFrame>
+            {
+                new ManiaReplayFrame(1020, ManiaAction.Key1),
+                new ManiaReplayFrame(2000)
+            }
+        });
+
+        [Test]
+        public void TestBreakOnHoldNote() => CreateModTest(new ModTestData
+        {
+            Mod = new ManiaModPerfect(),
+            PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(true) && Player.Results.Count == 2,
+            Autoplay = false,
+            Beatmap = new Beatmap
+            {
+                HitObjects = new List<HitObject>
+                {
+                    new HoldNote
+                    {
+                        StartTime = 1000,
+                        EndTime = 3000,
+                    },
+                },
+            },
+            ReplayFrames = new List<ReplayFrame>
+            {
+                new ManiaReplayFrame(1000, ManiaAction.Key1),
+                new ManiaReplayFrame(2000)
+            }
+        });
     }
 }

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

@@ -0,0 +1,72 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Mods;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Replays;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Mania.Tests.Mods
+{
+    public partial class TestSceneManiaModSuddenDeath : ModFailConditionTestScene
+    {
+        protected override Ruleset CreatePlayerRuleset() => new ManiaRuleset();
+
+        public TestSceneManiaModSuddenDeath()
+            : base(new ManiaModSuddenDeath())
+        {
+        }
+
+        [Test]
+        public void TestGreatHit() => CreateModTest(new ModTestData
+        {
+            Mod = new ManiaModSuddenDeath(),
+            PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(false),
+            Autoplay = false,
+            Beatmap = new Beatmap
+            {
+                HitObjects = new List<HitObject>
+                {
+                    new Note
+                    {
+                        StartTime = 1000,
+                    }
+                },
+            },
+            ReplayFrames = new List<ReplayFrame>
+            {
+                new ManiaReplayFrame(1020, ManiaAction.Key1),
+                new ManiaReplayFrame(2000)
+            }
+        });
+
+        [Test]
+        public void TestBreakOnHoldNote() => CreateModTest(new ModTestData
+        {
+            Mod = new ManiaModSuddenDeath(),
+            PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(true) && Player.Results.Count == 2,
+            Autoplay = false,
+            Beatmap = new Beatmap
+            {
+                HitObjects = new List<HitObject>
+                {
+                    new HoldNote
+                    {
+                        StartTime = 1000,
+                        EndTime = 3000,
+                    },
+                },
+            },
+            ReplayFrames = new List<ReplayFrame>
+            {
+                new ManiaReplayFrame(1000, ManiaAction.Key1),
+                new ManiaReplayFrame(2000)
+            }
+        });
+    }
+}

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

@@ -1,11 +1,26 @@
 // 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.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModPerfect : ModPerfect
     {
+        protected override bool FailCondition(HealthProcessor healthProcessor, JudgementResult result)
+        {
+            if (!isRelevantResult(result.Judgement.MinResult) && !isRelevantResult(result.Judgement.MaxResult) && !isRelevantResult(result.Type))
+                return false;
+
+            // Mania allows imperfect "Great" hits without failing.
+            if (result.Judgement.MaxResult == HitResult.Perfect)
+                return result.Type < HitResult.Great;
+
+            return result.Type != result.Judgement.MaxResult;
+        }
+
+        private bool isRelevantResult(HitResult result) => result.AffectsAccuracy() || result.AffectsCombo();
     }
 }

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

@@ -19,12 +19,14 @@ using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Replays;
+using osu.Game.Rulesets.Mania.Skinning;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Scoring;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
@@ -57,6 +59,9 @@ namespace osu.Game.Rulesets.Mania.UI
         // Stores the current speed adjustment active in gameplay.
         private readonly Track speedAdjustmentTrack = new TrackVirtual(0);
 
+        [Resolved]
+        private ISkinSource skin { get; set; }
+
         public DrawableManiaRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods = null)
             : base(ruleset, beatmap, mods)
         {
@@ -104,7 +109,20 @@ namespace osu.Game.Rulesets.Mania.UI
             updateTimeRange();
         }
 
-        private void updateTimeRange() => TimeRange.Value = smoothTimeRange * speedAdjustmentTrack.AggregateTempo.Value * speedAdjustmentTrack.AggregateFrequency.Value;
+        private void updateTimeRange()
+        {
+            float hitPosition = skin.GetConfig<ManiaSkinConfigurationLookup, float>(
+                                    new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.HitPosition))?.Value
+                                ?? Stage.HIT_TARGET_POSITION;
+
+            const float length_to_default_hit_position = 768 - LegacyManiaSkinConfiguration.DEFAULT_HIT_POSITION;
+            float lengthToHitPosition = 768 - hitPosition;
+
+            // This scaling factor preserves the scroll speed as the scroll length varies from changes to the hit position.
+            float scale = lengthToHitPosition / length_to_default_hit_position;
+
+            TimeRange.Value = smoothTimeRange * speedAdjustmentTrack.AggregateTempo.Value * speedAdjustmentTrack.AggregateFrequency.Value * scale;
+        }
 
         /// <summary>
         /// Computes a scroll time (in milliseconds) from a scroll speed in the range of 1-40.

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

@@ -1,17 +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.
 
+using System.Collections.Generic;
 using NUnit.Framework;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Replays;
 using osu.Game.Tests.Visual;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests.Mods
 {
-    public partial class TestSceneOsuModPerfect : ModPerfectTestScene
+    public partial class TestSceneOsuModPerfect : ModFailConditionTestScene
     {
         protected override Ruleset CreatePlayerRuleset() => new OsuRuleset();
 
@@ -50,5 +54,30 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
 
             CreateHitObjectTest(new HitObjectTestData(spinner), shouldMiss);
         }
+
+        [Test]
+        public void TestMissSliderTail() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModPerfect(),
+            PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(true),
+            Autoplay = false,
+            Beatmap = new Beatmap
+            {
+                HitObjects = new List<HitObject>
+                {
+                    new Slider
+                    {
+                        Position = new Vector2(256, 192),
+                        StartTime = 1000,
+                        Path = new SliderPath(PathType.LINEAR, new[] { Vector2.Zero, new Vector2(100, 0), })
+                    },
+                },
+            },
+            ReplayFrames = new List<ReplayFrame>
+            {
+                new OsuReplayFrame(1000, new Vector2(256, 192), OsuAction.LeftButton),
+                new OsuReplayFrame(1001, new Vector2(256, 192)),
+            }
+        });
     }
 }

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

@@ -0,0 +1,53 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Replays;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests.Mods
+{
+    public partial class TestSceneOsuModStrictTracking : OsuModTestScene
+    {
+        [Test]
+        public void TestSliderInput() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModStrictTracking(),
+            Autoplay = false,
+            Beatmap = new Beatmap
+            {
+                HitObjects = new List<HitObject>
+                {
+                    new Slider
+                    {
+                        StartTime = 1000,
+                        Path = new SliderPath
+                        {
+                            ControlPoints =
+                            {
+                                new PathControlPoint(),
+                                new PathControlPoint(new Vector2(0, 100))
+                            }
+                        }
+                    }
+                }
+            },
+            ReplayFrames = new List<ReplayFrame>
+            {
+                new OsuReplayFrame(0, new Vector2(), OsuAction.LeftButton),
+                new OsuReplayFrame(500, new Vector2(200, 0), OsuAction.LeftButton),
+                new OsuReplayFrame(501, new Vector2(200, 0)),
+                new OsuReplayFrame(1000, new Vector2(), OsuAction.LeftButton),
+                new OsuReplayFrame(1750, new Vector2(0, 100), OsuAction.LeftButton),
+                new OsuReplayFrame(1751, new Vector2(0, 100)),
+            },
+            PassCondition = () => Player.ScoreProcessor.Combo.Value == 2
+        });
+    }
+}

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

@@ -0,0 +1,77 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests.Mods
+{
+    public partial class TestSceneOsuModSuddenDeath : ModFailConditionTestScene
+    {
+        protected override Ruleset CreatePlayerRuleset() => new OsuRuleset();
+
+        public TestSceneOsuModSuddenDeath()
+            : base(new OsuModSuddenDeath())
+        {
+        }
+
+        [Test]
+        public void TestMissTail() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModSuddenDeath(),
+            PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(false),
+            Autoplay = false,
+            Beatmap = new Beatmap
+            {
+                HitObjects = new List<HitObject>
+                {
+                    new Slider
+                    {
+                        Position = new Vector2(256, 192),
+                        StartTime = 1000,
+                        Path = new SliderPath(PathType.LINEAR, new[] { Vector2.Zero, new Vector2(100, 0), })
+                    },
+                },
+            },
+            ReplayFrames = new List<ReplayFrame>
+            {
+                new OsuReplayFrame(1000, new Vector2(256, 192), OsuAction.LeftButton),
+                new OsuReplayFrame(1001, new Vector2(256, 192)),
+            }
+        });
+
+        [Test]
+        public void TestMissTick() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModSuddenDeath(),
+            PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(true),
+            Autoplay = false,
+            Beatmap = new Beatmap
+            {
+                HitObjects = new List<HitObject>
+                {
+                    new Slider
+                    {
+                        Position = new Vector2(256, 192),
+                        StartTime = 1000,
+                        Path = new SliderPath(PathType.LINEAR, new[] { Vector2.Zero, new Vector2(200, 0), })
+                    },
+                },
+            },
+            ReplayFrames = new List<ReplayFrame>
+            {
+                new OsuReplayFrame(1000, new Vector2(256, 192), OsuAction.LeftButton),
+                new OsuReplayFrame(1001, new Vector2(256, 192)),
+            }
+        });
+    }
+}

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

@@ -17,6 +17,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Events;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
@@ -54,7 +55,7 @@ namespace osu.Game.Rulesets.Osu.Edit
                    .Concat(DistanceSnapProvider.CreateTernaryButtons())
                    .Concat(new[]
                    {
-                       new TernaryButton(rectangularGridSnapToggle, "Grid Snap", () => new SpriteIcon { Icon = FontAwesome.Solid.Th })
+                       new TernaryButton(rectangularGridSnapToggle, "Grid Snap", () => new SpriteIcon { Icon = OsuIcon.EditorGridSnap })
                    });
 
         private BindableList<HitObject> selectedHitObjects;

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

@@ -0,0 +1,162 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    public class OsuModDepth : ModWithVisibilityAdjustment, IUpdatableByPlayfield, IApplicableToDrawableRuleset<OsuHitObject>
+    {
+        public override string Name => "Depth";
+        public override string Acronym => "DP";
+        public override IconUsage? Icon => FontAwesome.Solid.Cube;
+        public override ModType Type => ModType.Fun;
+        public override LocalisableString Description => "3D. Almost.";
+        public override double ScoreMultiplier => 1;
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModMagnetised), typeof(OsuModRepel), typeof(OsuModFreezeFrame), typeof(ModWithVisibilityAdjustment) }).ToArray();
+
+        private static readonly Vector3 camera_position = new Vector3(OsuPlayfield.BASE_SIZE.X * 0.5f, OsuPlayfield.BASE_SIZE.Y * 0.5f, -200);
+        private readonly float sliderMinDepth = depthForScale(1.5f); // Depth at which slider's scale will be 1.5f
+
+        [SettingSource("Maximum depth", "How far away objects appear.", 0)]
+        public BindableFloat MaxDepth { get; } = new BindableFloat(100)
+        {
+            Precision = 10,
+            MinValue = 50,
+            MaxValue = 200
+        };
+
+        [SettingSource("Show Approach Circles", "Whether approach circles should be visible.", 1)]
+        public BindableBool ShowApproachCircles { get; } = new BindableBool(true);
+
+        protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyTransform(hitObject, state);
+
+        protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyTransform(hitObject, state);
+
+        public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
+        {
+            // Hide judgment displays and follow points as they won't make any sense.
+            // Judgements can potentially be turned on in a future where they display at a position relative to their drawable counterpart.
+            drawableRuleset.Playfield.DisplayJudgements.Value = false;
+            (drawableRuleset.Playfield as OsuPlayfield)?.FollowPoints.Hide();
+        }
+
+        private void applyTransform(DrawableHitObject drawable, ArmedState state)
+        {
+            switch (drawable)
+            {
+                case DrawableHitCircle circle:
+                    if (!ShowApproachCircles.Value)
+                    {
+                        var hitObject = (OsuHitObject)drawable.HitObject;
+                        double appearTime = hitObject.StartTime - hitObject.TimePreempt;
+
+                        using (circle.BeginAbsoluteSequence(appearTime))
+                            circle.ApproachCircle.Hide();
+                    }
+
+                    break;
+            }
+        }
+
+        public void Update(Playfield playfield)
+        {
+            double time = playfield.Time.Current;
+
+            foreach (var drawable in playfield.HitObjectContainer.AliveObjects)
+            {
+                switch (drawable)
+                {
+                    case DrawableHitCircle circle:
+                        processHitObject(time, circle);
+                        break;
+
+                    case DrawableSlider slider:
+                        processSlider(time, slider);
+                        break;
+                }
+            }
+        }
+
+        private void processHitObject(double time, DrawableOsuHitObject drawable)
+        {
+            var hitObject = drawable.HitObject;
+
+            // Circles are always moving at the constant speed. They'll fade out before reaching the camera even at extreme conditions (AR 11, max depth).
+            double speed = MaxDepth.Value / hitObject.TimePreempt;
+            double appearTime = hitObject.StartTime - hitObject.TimePreempt;
+            float z = MaxDepth.Value - (float)((Math.Max(time, appearTime) - appearTime) * speed);
+
+            float scale = scaleForDepth(z);
+            drawable.Position = toPlayfieldPosition(scale, hitObject.StackedPosition);
+            drawable.Scale = new Vector2(scale);
+        }
+
+        private void processSlider(double time, DrawableSlider drawableSlider)
+        {
+            var hitObject = drawableSlider.HitObject;
+
+            double baseSpeed = MaxDepth.Value / hitObject.TimePreempt;
+            double appearTime = hitObject.StartTime - hitObject.TimePreempt;
+
+            // Allow slider to move at a constant speed if its scale at the end time will be lower than 1.5f
+            float zEnd = MaxDepth.Value - (float)((Math.Max(hitObject.StartTime + hitObject.Duration, appearTime) - appearTime) * baseSpeed);
+
+            if (zEnd > sliderMinDepth)
+            {
+                processHitObject(time, drawableSlider);
+                return;
+            }
+
+            double offsetAfterStartTime = hitObject.Duration + 500;
+            double slowSpeed = Math.Min(-sliderMinDepth / offsetAfterStartTime, baseSpeed);
+
+            double decelerationTime = hitObject.TimePreempt * 0.2;
+            float decelerationDistance = (float)(decelerationTime * (baseSpeed + slowSpeed) * 0.5);
+
+            float z;
+
+            if (time < hitObject.StartTime - decelerationTime)
+            {
+                float fullDistance = decelerationDistance + (float)(baseSpeed * (hitObject.TimePreempt - decelerationTime));
+                z = fullDistance - (float)((Math.Max(time, appearTime) - appearTime) * baseSpeed);
+            }
+            else if (time < hitObject.StartTime)
+            {
+                double timeOffset = time - (hitObject.StartTime - decelerationTime);
+                double deceleration = (slowSpeed - baseSpeed) / decelerationTime;
+                z = decelerationDistance - (float)(baseSpeed * timeOffset + deceleration * timeOffset * timeOffset * 0.5);
+            }
+            else
+            {
+                double endTime = hitObject.StartTime + offsetAfterStartTime;
+                z = -(float)((Math.Min(time, endTime) - hitObject.StartTime) * slowSpeed);
+            }
+
+            float scale = scaleForDepth(z);
+            drawableSlider.Position = toPlayfieldPosition(scale, hitObject.StackedPosition);
+            drawableSlider.Scale = new Vector2(scale);
+        }
+
+        private static float scaleForDepth(float depth) => -camera_position.Z / Math.Max(1f, depth - camera_position.Z);
+
+        private static float depthForScale(float scale) => -camera_position.Z / scale + camera_position.Z;
+
+        private static Vector2 toPlayfieldPosition(float scale, Vector2 positionAtZeroDepth)
+        {
+            return (positionAtZeroDepth - camera_position.Xy) * scale + camera_position.Xy;
+        }
+    }
+}

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

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override LocalisableString Description => "Burn the notes into your memory.";
 
         //Alters the transforms of the approach circles, breaking the effects of these mods.
-        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModApproachDifferent), typeof(OsuModTransform) }).ToArray();
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModApproachDifferent), typeof(OsuModTransform), typeof(OsuModDepth) }).ToArray();
 
         public override ModType Type => ModType.Fun;
 

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

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override LocalisableString Description => @"Play with no approach circles and fading circles/sliders.";
         public override double ScoreMultiplier => UsesDefaultConfiguration ? 1.06 : 1;
 
-        public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles), typeof(OsuModSpinIn) };
+        public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles), typeof(OsuModSpinIn), typeof(OsuModDepth) };
 
         public const double FADE_IN_DURATION_MULTIPLIER = 0.4;
         public const double FADE_OUT_DURATION_MULTIPLIER = 0.3;

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

@@ -27,7 +27,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "No need to chase the circles – your cursor is a magnet!";
         public override double ScoreMultiplier => 0.5;
-        public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay), typeof(OsuModRelax), typeof(OsuModRepel), typeof(OsuModBubbles) };
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay), typeof(OsuModRelax), typeof(OsuModRepel), typeof(OsuModBubbles), typeof(OsuModDepth) };
 
         [SettingSource("Attraction strength", "How strong the pull is.", 0)]
         public BindableFloat AttractionStrength { get; } = new BindableFloat(0.5f)

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

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         protected virtual float EndScale => 1;
 
-        public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles), typeof(OsuModSpinIn), typeof(OsuModObjectScaleTween) };
+        public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles), typeof(OsuModSpinIn), typeof(OsuModObjectScaleTween), typeof(OsuModDepth) };
 
         protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {

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

@@ -88,7 +88,7 @@ namespace osu.Game.Rulesets.Osu.Mods
                         if (!slider.HeadCircle.IsHit)
                             handleHitCircle(slider.HeadCircle);
 
-                        requiresHold |= slider.Ball.IsHovered || h.IsHovered;
+                        requiresHold |= slider.SliderInputManager.IsMouseInFollowArea(true);
                         break;
 
                     case DrawableSpinner spinner:

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

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "Hit objects run away!";
         public override double ScoreMultiplier => 1;
-        public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay), typeof(OsuModMagnetised), typeof(OsuModBubbles) };
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay), typeof(OsuModMagnetised), typeof(OsuModBubbles), typeof(OsuModDepth) };
 
         [SettingSource("Repulsion strength", "How strong the repulsion is.", 0)]
         public BindableFloat RepulsionStrength { get; } = new BindableFloat(0.5f)

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

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         // todo: this mod needs to be incompatible with "hidden" due to forcing the circle to remain opaque,
         // further implementation will be required for supporting that.
-        public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles), typeof(OsuModObjectScaleTween), typeof(OsuModHidden) };
+        public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles), typeof(OsuModObjectScaleTween), typeof(OsuModHidden), typeof(OsuModDepth) };
 
         private const int rotate_offset = 360;
         private const float rotate_starting_width = 2;

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

@@ -36,6 +36,9 @@ namespace osu.Game.Rulesets.Osu.Mods
                 {
                     if (e.NewValue || slider.Judged) return;
 
+                    if (slider.Time.Current < slider.HitObject.StartTime)
+                        return;
+
                     var tail = slider.NestedHitObjects.OfType<StrictTrackingDrawableSliderTail>().First();
 
                     if (!tail.Judged)

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

@@ -47,7 +47,8 @@ namespace osu.Game.Rulesets.Osu.Mods
             typeof(OsuModRandom),
             typeof(OsuModSpunOut),
             typeof(OsuModStrictTracking),
-            typeof(OsuModSuddenDeath)
+            typeof(OsuModSuddenDeath),
+            typeof(OsuModDepth)
         }).ToArray();
 
         [SettingSource("Seed", "Use a custom seed instead of a random one", SettingControlType = typeof(SettingsNumberBox))]

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

@@ -20,7 +20,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override LocalisableString Description => "Put your faith in the approach circles...";
         public override double ScoreMultiplier => 1;
 
-        public override Type[] IncompatibleMods => new[] { typeof(IHidesApproachCircles) };
+        public override Type[] IncompatibleMods => new[] { typeof(IHidesApproachCircles), typeof(OsuModDepth) };
 
         protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {

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

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "Everything rotates. EVERYTHING.";
         public override double ScoreMultiplier => 1;
-        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModWiggle), typeof(OsuModMagnetised), typeof(OsuModRepel), typeof(OsuModFreezeFrame) }).ToArray();
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModWiggle), typeof(OsuModMagnetised), typeof(OsuModRepel), typeof(OsuModFreezeFrame), typeof(OsuModDepth) }).ToArray();
 
         private float theta;
 

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

@@ -23,7 +23,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "They just won't stay still...";
         public override double ScoreMultiplier => 1;
-        public override Type[] IncompatibleMods => new[] { typeof(OsuModTransform), typeof(OsuModMagnetised), typeof(OsuModRepel) };
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModTransform), typeof(OsuModMagnetised), typeof(OsuModRepel), typeof(OsuModDepth) };
 
         private const int wiggle_duration = 100; // (ms) Higher = fewer wiggles
 

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

@@ -47,7 +47,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         private const float spinning_sample_initial_frequency = 1.0f;
         private const float spinning_sample_modulated_base_frequency = 0.5f;
 
-        private SkinnableSound maxBonusSample;
+        private PausableSkinnableSound maxBonusSample;
 
         /// <summary>
         /// The amount of bonus score gained from spinning after the required number of spins, for display purposes.
@@ -114,7 +114,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     Looping = true,
                     Frequency = { Value = spinning_sample_initial_frequency }
                 },
-                maxBonusSample = new SkinnableSound
+                maxBonusSample = new PausableSkinnableSound
                 {
                     MinimumSampleVolume = MINIMUM_SAMPLE_VOLUME,
                 }

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

@@ -65,7 +65,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         protected override void Update()
         {
             base.Update();
-            updateTracking(isMouseInFollowArea(Tracking));
+            updateTracking(IsMouseInFollowArea(Tracking));
         }
 
         public void PostProcessHeadJudgement(DrawableSliderHead head)
@@ -73,7 +73,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             if (!head.Judged || !head.Result.IsHit)
                 return;
 
-            if (!isMouseInFollowArea(true))
+            if (!IsMouseInFollowArea(true))
                 return;
 
             Debug.Assert(screenSpaceMousePosition != null);
@@ -129,7 +129,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             // If all ticks were hit so far, enable tracking the full extent.
             // If any ticks were missed, assume tracking would've broken at some point, and should only activate if the cursor is within the slider ball.
             // For the second case, this may be the last chance we have to enable tracking before other objects get judged, otherwise the same would normally happen via Update().
-            updateTracking(allTicksInRange || isMouseInFollowArea(false));
+            updateTracking(allTicksInRange || IsMouseInFollowArea(false));
         }
 
         public void TryJudgeNestedObject(DrawableOsuHitObject nestedObject, double timeOffset)
@@ -174,7 +174,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         /// Whether the mouse is currently in the follow area.
         /// </summary>
         /// <param name="expanded">Whether to test against the maximum area of the follow circle.</param>
-        private bool isMouseInFollowArea(bool expanded)
+        public bool IsMouseInFollowArea(bool expanded)
         {
             if (screenSpaceMousePosition is not Vector2 pos)
                 return false;

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -48,6 +48,8 @@ namespace osu.Game.Rulesets.Osu
 
         public override ScoreProcessor CreateScoreProcessor() => new OsuScoreProcessor();
 
+        public override HealthProcessor CreateHealthProcessor(double drainStartTime) => new OsuHealthProcessor(drainStartTime);
+
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new OsuBeatmapConverter(beatmap, this);
 
         public override IBeatmapProcessor CreateBeatmapProcessor(IBeatmap beatmap) => new OsuBeatmapProcessor(beatmap);
@@ -209,7 +211,8 @@ namespace osu.Game.Rulesets.Osu
                         new ModAdaptiveSpeed(),
                         new OsuModFreezeFrame(),
                         new OsuModBubbles(),
-                        new OsuModSynesthesia()
+                        new OsuModSynesthesia(),
+                        new OsuModDepth()
                     };
 
                 case ModType.System:

osu.Game.Rulesets.Osu/Scoring/OsuHealthProcessor.cs

@@ -0,0 +1,127 @@
+// 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.Game.Beatmaps;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Osu.Scoring
+{
+    public partial class OsuHealthProcessor : DrainingHealthProcessor
+    {
+        private ComboResult currentComboResult = ComboResult.Perfect;
+
+        public OsuHealthProcessor(double drainStartTime, double drainLenience = 0)
+            : base(drainStartTime, drainLenience)
+        {
+        }
+
+        protected override double GetHealthIncreaseFor(JudgementResult result)
+        {
+            if (IsSimulating)
+                return getHealthIncreaseFor(result);
+
+            if (result.HitObject is not IHasComboInformation combo)
+                return getHealthIncreaseFor(result);
+
+            if (combo.NewCombo)
+                currentComboResult = ComboResult.Perfect;
+
+            switch (result.Type)
+            {
+                case HitResult.LargeTickMiss:
+                case HitResult.Ok:
+                    setComboResult(ComboResult.Good);
+                    break;
+
+                case HitResult.Meh:
+                case HitResult.Miss:
+                    setComboResult(ComboResult.None);
+                    break;
+            }
+
+            // The slider tail has a special judgement that can't accurately be described above.
+            if (result.HitObject is SliderTailCircle && !result.IsHit)
+                setComboResult(ComboResult.Good);
+
+            if (combo.LastInCombo && result.Type.IsHit())
+            {
+                switch (currentComboResult)
+                {
+                    case ComboResult.Perfect:
+                        return getHealthIncreaseFor(result) + 0.07;
+
+                    case ComboResult.Good:
+                        return getHealthIncreaseFor(result) + 0.05;
+
+                    default:
+                        return getHealthIncreaseFor(result) + 0.03;
+                }
+            }
+
+            return getHealthIncreaseFor(result);
+
+            void setComboResult(ComboResult comboResult) => currentComboResult = (ComboResult)Math.Min((int)currentComboResult, (int)comboResult);
+        }
+
+        protected override void Reset(bool storeResults)
+        {
+            base.Reset(storeResults);
+            currentComboResult = ComboResult.Perfect;
+        }
+
+        private double getHealthIncreaseFor(JudgementResult result)
+        {
+            switch (result.Type)
+            {
+                case HitResult.SmallTickMiss:
+                    return IBeatmapDifficultyInfo.DifficultyRange(Beatmap.Difficulty.DrainRate, -0.02, -0.075, -0.14);
+
+                case HitResult.LargeTickMiss:
+                    return IBeatmapDifficultyInfo.DifficultyRange(Beatmap.Difficulty.DrainRate, -0.02, -0.075, -0.14);
+
+                case HitResult.Miss:
+                    return IBeatmapDifficultyInfo.DifficultyRange(Beatmap.Difficulty.DrainRate, -0.03, -0.125, -0.2);
+
+                case HitResult.SmallTickHit:
+                    // When classic slider mechanics are enabled, this result comes from the tail.
+                    return 0.02;
+
+                case HitResult.LargeTickHit:
+                    switch (result.HitObject)
+                    {
+                        case SliderTick:
+                            return 0.015;
+
+                        case SliderHeadCircle:
+                        case SliderTailCircle:
+                        case SliderRepeat:
+                            return 0.02;
+                    }
+
+                    break;
+
+                case HitResult.Meh:
+                    return 0.002;
+
+                case HitResult.Ok:
+                    return 0.011;
+
+                case HitResult.Great:
+                    return 0.03;
+
+                case HitResult.SmallBonus:
+                    return 0.0085;
+
+                case HitResult.LargeBonus:
+                    return 0.01;
+            }
+
+            return base.GetHealthIncreaseFor(result);
+        }
+    }
+}

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

@@ -62,7 +62,16 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
         /// </remarks>
         public virtual void PlayAnimation()
         {
-            if (Result.IsMiss())
+            if (Result == HitResult.IgnoreMiss || Result == HitResult.LargeTickMiss)
+            {
+                this.RotateTo(-45);
+                this.ScaleTo(1.8f);
+                this.ScaleTo(1.2f, 100, Easing.In);
+
+                this.MoveTo(Vector2.Zero);
+                this.MoveToOffset(new Vector2(0, 10), 800, Easing.InQuint);
+            }
+            else if (Result.IsMiss())
             {
                 this.ScaleTo(1.6f);
                 this.ScaleTo(1, 100, Easing.In);

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

@@ -160,7 +160,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                         {
                             decimal? legacyVersion = skin.GetConfig<SkinConfiguration.LegacySetting, decimal>(SkinConfiguration.LegacySetting.Version)?.Value;
 
-                            if (legacyVersion >= 2.0m)
+                            if (legacyVersion > 1.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);
                             else

osu.Game.Rulesets.Osu/UI/Cursor/OsuCursor.cs

@@ -70,10 +70,10 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
             };
 
             userCursorScale = config.GetBindable<float>(OsuSetting.GameplayCursorSize);
-            userCursorScale.ValueChanged += _ => calculateCursorScale();
+            userCursorScale.ValueChanged += _ => cursorScale.Value = CalculateCursorScale();
 
             autoCursorScale = config.GetBindable<bool>(OsuSetting.AutoCursorSize);
-            autoCursorScale.ValueChanged += _ => calculateCursorScale();
+            autoCursorScale.ValueChanged += _ => cursorScale.Value = CalculateCursorScale();
 
             cursorScale.BindValueChanged(e => cursorScaleContainer.Scale = new Vector2(e.NewValue), true);
         }
@@ -81,10 +81,10 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
         protected override void LoadComplete()
         {
             base.LoadComplete();
-            calculateCursorScale();
+            cursorScale.Value = CalculateCursorScale();
         }
 
-        private void calculateCursorScale()
+        protected virtual float CalculateCursorScale()
         {
             float scale = userCursorScale.Value;
 
@@ -94,7 +94,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                 scale *= GetScaleForCircleSize(state.Beatmap.Difficulty.CircleSize);
             }
 
-            cursorScale.Value = scale;
+            return scale;
         }
 
         protected override void SkinChanged(ISkinSource skin)

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

@@ -71,6 +71,12 @@ namespace osu.Game.Rulesets.Osu.UI
                 RelativePositionAxes = Axes.Both;
             }
 
+            protected override float CalculateCursorScale()
+            {
+                // Force minimum cursor size so it's easily clickable
+                return Math.Max(1f, base.CalculateCursorScale());
+            }
+
             protected override bool OnHover(HoverEvent e)
             {
                 updateColour();

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

@@ -10,7 +10,7 @@ using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Taiko.Tests.Mods
 {
-    public partial class TestSceneTaikoModPerfect : ModPerfectTestScene
+    public partial class TestSceneTaikoModPerfect : ModFailConditionTestScene
     {
         protected override Ruleset CreatePlayerRuleset() => new TestTaikoRuleset();
 

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

@@ -17,6 +17,7 @@ using osu.Game.Rulesets.Edit;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Timing;
 using osu.Game.Screens.Edit.Timing.RowAttributes;
+using osuTK;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Editing
@@ -69,6 +70,48 @@ namespace osu.Game.Tests.Visual.Editing
             AddUntilStep("Wait for rows to load", () => Child.ChildrenOfType<EffectRowAttribute>().Any());
         }
 
+        [Test]
+        public void TestSelectedRetainedOverUndo()
+        {
+            AddStep("Select first timing point", () =>
+            {
+                InputManager.MoveMouseTo(Child.ChildrenOfType<TimingRowAttribute>().First());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddUntilStep("Selection changed", () => timingScreen.SelectedGroup.Value.Time == 2170);
+            AddUntilStep("Ensure seeked to correct time", () => EditorClock.CurrentTimeAccurate == 2170);
+
+            AddStep("Adjust offset", () =>
+            {
+                InputManager.MoveMouseTo(timingScreen.ChildrenOfType<TimingAdjustButton>().First().ScreenSpaceDrawQuad.Centre + new Vector2(20, 0));
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddUntilStep("wait for offset changed", () =>
+            {
+                return timingScreen.SelectedGroup.Value.ControlPoints.Any(c => c is TimingControlPoint) && timingScreen.SelectedGroup.Value.Time > 2170;
+            });
+
+            AddStep("simulate undo", () =>
+            {
+                var clone = editorBeatmap.ControlPointInfo.DeepClone();
+
+                editorBeatmap.ControlPointInfo.Clear();
+
+                foreach (var group in clone.Groups)
+                {
+                    foreach (var cp in group.ControlPoints)
+                        editorBeatmap.ControlPointInfo.Add(group.Time, cp);
+                }
+            });
+
+            AddUntilStep("selection retained", () =>
+            {
+                return timingScreen.SelectedGroup.Value.ControlPoints.Any(c => c is TimingControlPoint) && timingScreen.SelectedGroup.Value.Time > 2170;
+            });
+        }
+
         [Test]
         public void TestTrackingCurrentTimeWhileRunning()
         {

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

@@ -12,6 +12,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play.PlayerSettings;
+using osu.Game.Tests.Resources;
 using osu.Game.Tests.Visual.Ranking;
 
 namespace osu.Game.Tests.Visual.Gameplay
@@ -44,7 +45,23 @@ namespace osu.Game.Tests.Visual.Gameplay
             {
                 offsetControl.ReferenceScore.Value = new ScoreInfo
                 {
-                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(0, 2)
+                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(0, 2),
+                    BeatmapInfo = Beatmap.Value.BeatmapInfo,
+                };
+            });
+
+            AddAssert("No calibration button", () => !offsetControl.ChildrenOfType<SettingsButton>().Any());
+        }
+
+        [Test]
+        public void TestScoreFromDifferentBeatmap()
+        {
+            AddStep("Set short reference score", () =>
+            {
+                offsetControl.ReferenceScore.Value = new ScoreInfo
+                {
+                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(10),
+                    BeatmapInfo = TestResources.CreateTestBeatmapSetInfo().Beatmaps.First(),
                 };
             });
 
@@ -59,7 +76,8 @@ namespace osu.Game.Tests.Visual.Gameplay
                 offsetControl.ReferenceScore.Value = new ScoreInfo
                 {
                     HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(10),
-                    Mods = new Mod[] { new OsuModRelax() }
+                    Mods = new Mod[] { new OsuModRelax() },
+                    BeatmapInfo = Beatmap.Value.BeatmapInfo,
                 };
             });
 
@@ -77,7 +95,8 @@ namespace osu.Game.Tests.Visual.Gameplay
             {
                 offsetControl.ReferenceScore.Value = new ScoreInfo
                 {
-                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(average_error)
+                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(average_error),
+                    BeatmapInfo = Beatmap.Value.BeatmapInfo,
                 };
             });
 
@@ -105,7 +124,8 @@ namespace osu.Game.Tests.Visual.Gameplay
             {
                 offsetControl.ReferenceScore.Value = new ScoreInfo
                 {
-                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(average_error)
+                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(average_error),
+                    BeatmapInfo = Beatmap.Value.BeatmapInfo,
                 };
             });
 

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

@@ -0,0 +1,35 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Screens.Menu;
+
+namespace osu.Game.Tests.Visual.Menus
+{
+    public partial class TestSceneMainMenu : OsuGameTestScene
+    {
+        [Test]
+        public void TestSystemTitle()
+        {
+            AddStep("set system title", () => Game.ChildrenOfType<SystemTitle>().Single().Current.Value = new APISystemTitle
+            {
+                Image = @"https://assets.ppy.sh/main-menu/project-loved-2@2x.png",
+                Url = @"https://osu.ppy.sh/home/news/2023-12-21-project-loved-december-2023",
+            });
+            AddStep("set another title", () => Game.ChildrenOfType<SystemTitle>().Single().Current.Value = new APISystemTitle
+            {
+                Image = @"https://assets.ppy.sh/main-menu/wf2023-vote@2x.png",
+                Url = @"https://osu.ppy.sh/community/contests/189",
+            });
+            AddStep("set title with nonexistent image", () => Game.ChildrenOfType<SystemTitle>().Single().Current.Value = new APISystemTitle
+            {
+                Image = @"https://test.invalid/@2x", // .invalid TLD reserved by https://datatracker.ietf.org/doc/html/rfc2606#section-2
+                Url = @"https://osu.ppy.sh/community/contests/189",
+            });
+            AddStep("unset system title", () => Game.ChildrenOfType<SystemTitle>().Single().Current.Value = null);
+        }
+    }
+}

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

@@ -1,19 +1,27 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// 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 NUnit.Framework;
+using osu.Framework.Graphics;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Screens.Menu;
 
 namespace osu.Game.Tests.Visual.Menus
 {
-    public partial class TestSceneDisclaimer : ScreenTestScene
+    public partial class TestSceneSupporterDisplay : OsuTestScene
     {
-        [BackgroundDependencyLoader]
+        [Test]
-        private void load()
+        public void TestBasic()
         {
-            AddStep("load disclaimer", () => LoadScreen(new Disclaimer()));
+            AddStep("create display", () =>
+            {
+                Child = new SupporterDisplay
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                };
+            });
 
             AddStep("toggle support", () =>
             {

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

@@ -81,6 +81,21 @@ namespace osu.Game.Tests.Visual.Online
             AddStep("End watching user presence", () => metadataClient.EndWatchingUserPresence());
         }
 
+        [Test]
+        public void TestUserWasPlayingBeforeWatchingUserPresence()
+        {
+            AddStep("User began playing", () => spectatorClient.SendStartPlay(streamingUser.Id, 0));
+            AddStep("Begin watching user presence", () => metadataClient.BeginWatchingUserPresence());
+            AddStep("Add online user", () => metadataClient.UserPresenceUpdated(streamingUser.Id, new UserPresence { Status = UserStatus.Online, Activity = new UserActivity.ChoosingBeatmap() }));
+            AddUntilStep("Panel loaded", () => currentlyOnline.ChildrenOfType<UserGridPanel>().FirstOrDefault()?.User.Id == 2);
+            AddAssert("Spectate button enabled", () => currentlyOnline.ChildrenOfType<PurpleRoundedButton>().First().Enabled.Value, () => Is.True);
+
+            AddStep("User finished playing", () => spectatorClient.SendEndPlay(streamingUser.Id));
+            AddAssert("Spectate button disabled", () => currentlyOnline.ChildrenOfType<PurpleRoundedButton>().First().Enabled.Value, () => Is.False);
+            AddStep("Remove playing user", () => metadataClient.UserPresenceUpdated(streamingUser.Id, null));
+            AddStep("End watching user presence", () => metadataClient.EndWatchingUserPresence());
+        }
+
         internal partial class TestUserLookupCache : UserLookupCache
         {
             private static readonly string[] usernames =

osu.Game.Tests/Visual/Settings/TestSceneAudioOffsetAdjustControl.cs

@@ -0,0 +1,63 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Utils;
+using osu.Game.Configuration;
+using osu.Game.Overlays.Settings.Sections.Audio;
+using osu.Game.Scoring;
+using osu.Game.Tests.Visual.Ranking;
+
+namespace osu.Game.Tests.Visual.Settings
+{
+    public partial class TestSceneAudioOffsetAdjustControl : OsuTestScene
+    {
+        [Resolved]
+        private SessionStatics statics { get; set; } = null!;
+
+        [Cached]
+        private SessionAverageHitErrorTracker tracker = new SessionAverageHitErrorTracker();
+
+        private Container content = null!;
+        protected override Container Content => content;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            base.Content.AddRange(new Drawable[]
+            {
+                tracker,
+                content = new Container
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Width = 400,
+                    AutoSizeAxes = Axes.Y
+                }
+            });
+        }
+
+        [Test]
+        public void TestBehaviour()
+        {
+            AddStep("create control", () => Child = new AudioOffsetAdjustControl
+            {
+                Current = new BindableDouble
+                {
+                    MinValue = -500,
+                    MaxValue = 500
+                }
+            });
+            AddStep("set new score", () => statics.SetValue(Static.LastLocalUserScore, new ScoreInfo
+            {
+                HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(RNG.NextDouble(-100, 100)),
+                BeatmapInfo = Beatmap.Value.BeatmapInfo,
+            }));
+            AddStep("clear history", () => tracker.ClearHistory());
+        }
+    }
+}

osu.Game.Tests/Visual/Settings/TestSceneKeyBindingPanel.cs

@@ -13,7 +13,6 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Localisation;
 using osu.Game.Overlays;
-using osu.Game.Overlays.Settings;
 using osu.Game.Overlays.Settings.Sections.Input;
 using osu.Game.Rulesets.Taiko;
 using osuTK.Input;
@@ -152,7 +151,7 @@ namespace osu.Game.Tests.Visual.Settings
             AddStep("click first row with two bindings", () =>
             {
                 multiBindingRow = panel.ChildrenOfType<KeyBindingRow>().First(row => row.Defaults.Count() > 1);
-                InputManager.MoveMouseTo(multiBindingRow);
+                InputManager.MoveMouseTo(multiBindingRow.ChildrenOfType<OsuSpriteText>().First());
                 InputManager.Click(MouseButton.Left);
             });
 
@@ -256,7 +255,7 @@ namespace osu.Game.Tests.Visual.Settings
             AddStep("click first row with two bindings", () =>
             {
                 multiBindingRow = panel.ChildrenOfType<KeyBindingRow>().First(row => row.Defaults.Count() > 1);
-                InputManager.MoveMouseTo(multiBindingRow);
+                InputManager.MoveMouseTo(multiBindingRow.ChildrenOfType<OsuSpriteText>().First());
                 InputManager.Click(MouseButton.Left);
             });
 
@@ -305,7 +304,6 @@ namespace osu.Game.Tests.Visual.Settings
                 section.ChildrenOfType<ResetButton>().Single().TriggerClick();
             });
             AddStep("move mouse to centre", () => InputManager.MoveMouseTo(panel.ScreenSpaceDrawQuad.Centre));
-            AddUntilStep("wait for collapsed", () => panel.ChildrenOfType<SettingsSidebar>().Single().Expanded.Value, () => Is.False);
             scrollToAndStartBinding("Left (rim)");
             AddStep("attempt to bind M1 to two keys", () => InputManager.Click(MouseButton.Left));
 
@@ -325,7 +323,6 @@ namespace osu.Game.Tests.Visual.Settings
                 section.ChildrenOfType<ResetButton>().Single().TriggerClick();
             });
             AddStep("move mouse to centre", () => InputManager.MoveMouseTo(panel.ScreenSpaceDrawQuad.Centre));
-            AddUntilStep("wait for collapsed", () => panel.ChildrenOfType<SettingsSidebar>().Single().Expanded.Value, () => Is.False);
             scrollToAndStartBinding("Left (rim)");
             AddStep("attempt to bind M1 to two keys", () => InputManager.Click(MouseButton.Left));
 
@@ -345,7 +342,6 @@ namespace osu.Game.Tests.Visual.Settings
                 section.ChildrenOfType<ResetButton>().Single().TriggerClick();
             });
             AddStep("move mouse to centre", () => InputManager.MoveMouseTo(panel.ScreenSpaceDrawQuad.Centre));
-            AddUntilStep("wait for collapsed", () => panel.ChildrenOfType<SettingsSidebar>().Single().Expanded.Value, () => Is.False);
             scrollToAndStartBinding("Left (centre)");
             AddStep("clear binding", () =>
             {
@@ -377,7 +373,6 @@ namespace osu.Game.Tests.Visual.Settings
                 section.ChildrenOfType<ResetButton>().Single().TriggerClick();
             });
             AddStep("move mouse to centre", () => InputManager.MoveMouseTo(panel.ScreenSpaceDrawQuad.Centre));
-            AddUntilStep("wait for collapsed", () => panel.ChildrenOfType<SettingsSidebar>().Single().Expanded.Value, () => Is.False);
             scrollToAndStartBinding("Left (centre)");
             AddStep("clear binding", () =>
             {

osu.Game.Tests/Visual/Settings/TestSceneSettingsPanel.cs

@@ -41,6 +41,7 @@ namespace osu.Game.Tests.Visual.Settings
         public void TestBasic()
         {
             AddStep("do nothing", () => { });
+            AddToggleStep("toggle visibility", visible => settings.State.Value = visible ? Visibility.Visible : Visibility.Hidden);
         }
 
         [Test]
@@ -110,7 +111,7 @@ namespace osu.Game.Tests.Visual.Settings
 
             AddStep("Press back", () => settings
                                         .ChildrenOfType<KeyBindingPanel>().FirstOrDefault()?
-                                        .ChildrenOfType<SettingsSubPanel.BackButton>().FirstOrDefault()?.TriggerClick());
+                                        .ChildrenOfType<SettingsSidebar.BackButton>().FirstOrDefault()?.TriggerClick());
 
             AddUntilStep("top-level textbox focused", () => settings.SectionsContainer.ChildrenOfType<SettingsSearchTextBox>().FirstOrDefault()?.HasFocus == true);
         }

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

@@ -454,6 +454,23 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddStep("Un-filter", () => carousel.Filter(new FilterCriteria(), false));
         }
 
+        [Test]
+        public void TestRewind()
+        {
+            const int local_set_count = 3;
+            const int random_select_count = local_set_count * 3;
+            loadBeatmaps(setCount: local_set_count);
+
+            for (int i = 0; i < random_select_count; i++)
+                nextRandom();
+
+            for (int i = 0; i < random_select_count; i++)
+            {
+                prevRandom();
+                AddAssert("correct random last selected", () => selectedSets.Peek(), () => Is.EqualTo(carousel.SelectedBeatmapSet));
+            }
+        }
+
         [Test]
         public void TestRewindToDeletedBeatmap()
         {

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

@@ -3,6 +3,7 @@
 
 #nullable disable
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using JetBrains.Annotations;
@@ -14,6 +15,7 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Extensions;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Resources.Localisation.Web;
 using osu.Game.Rulesets;
@@ -194,6 +196,36 @@ namespace osu.Game.Tests.Visual.SongSelect
             });
         }
 
+        [TestCase]
+        public void TestLengthUpdates()
+        {
+            IBeatmap beatmap = createTestBeatmap(new OsuRuleset().RulesetInfo);
+            double drain = beatmap.CalculateDrainLength();
+            beatmap.BeatmapInfo.Length = drain;
+
+            OsuModDoubleTime doubleTime = null;
+
+            selectBeatmap(beatmap);
+            checkDisplayedLength(drain);
+
+            AddStep("select DT", () => SelectedMods.Value = new[] { doubleTime = new OsuModDoubleTime() });
+            checkDisplayedLength(Math.Round(drain / 1.5f));
+
+            AddStep("change DT rate", () => doubleTime.SpeedChange.Value = 2);
+            checkDisplayedLength(Math.Round(drain / 2));
+        }
+
+        private void checkDisplayedLength(double drain)
+        {
+            var displayedLength = drain.ToFormattedDuration();
+
+            AddUntilStep($"check map drain ({displayedLength})", () =>
+            {
+                var label = infoWedge.DisplayedContent.ChildrenOfType<BeatmapInfoWedge.WedgeInfoText.InfoLabel>().Single(l => l.Statistic.Name == BeatmapsetsStrings.ShowStatsTotalLength(displayedLength));
+                return label.Statistic.Content == displayedLength.ToString();
+            });
+        }
+
         private void setRuleset(RulesetInfo rulesetInfo)
         {
             Container containerBefore = null;

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

@@ -9,6 +9,7 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Testing;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Dialog;
 
@@ -19,11 +20,15 @@ namespace osu.Game.Tests.Visual.UserInterface
     {
         private DialogOverlay overlay;
 
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("create dialog overlay", () => Child = overlay = new DialogOverlay());
+        }
+
         [Test]
         public void TestBasic()
         {
-            AddStep("create dialog overlay", () => Child = overlay = new DialogOverlay());
-
             TestPopupDialog firstDialog = null;
             TestPopupDialog secondDialog = null;
 
@@ -84,7 +89,31 @@ namespace osu.Game.Tests.Visual.UserInterface
             }));
 
             AddAssert("second dialog displayed", () => overlay.CurrentDialog == secondDialog);
-            AddAssert("first dialog is not part of hierarchy", () => firstDialog.Parent == null);
+            AddUntilStep("first dialog is not part of hierarchy", () => firstDialog.Parent == null);
+        }
+
+        [Test]
+        public void TestTooMuchText()
+        {
+            AddStep("dialog #1", () => overlay.Push(new TestPopupDialog
+            {
+                Icon = FontAwesome.Regular.TrashAlt,
+                HeaderText = @"Confirm deletion ofConfirm deletion ofConfirm deletion ofConfirm deletion ofConfirm deletion ofConfirm deletion of",
+                BodyText = @"Ayase Rie - Yuima-ru*World TVver.Ayase Rie - Yuima-ru*World TVver.Ayase Rie - Yuima-ru*World TVver.Ayase Rie - Yuima-ru*World TVver.Ayase Rie - Yuima-ru*World TVver.Ayase Rie - Yuima-ru*World TVver.Ayase Rie - Yuima-ru*World TVver.Ayase Rie - Yuima-ru*World TVver.Ayase Rie - Yuima-ru*World TVver. ",
+                Buttons = new PopupDialogButton[]
+                {
+                    new PopupDialogOkButton
+                    {
+                        Text = @"I never want to see this again.",
+                        Action = () => Console.WriteLine(@"OK"),
+                    },
+                    new PopupDialogCancelButton
+                    {
+                        Text = @"Firetruck, I still want quick ranks!",
+                        Action = () => Console.WriteLine(@"Cancel"),
+                    },
+                },
+            }));
         }
 
         [Test]
@@ -92,7 +121,7 @@ namespace osu.Game.Tests.Visual.UserInterface
         {
             PopupDialog dialog = null;
 
-            AddStep("create dialog overlay", () => overlay = new SlowLoadingDialogOverlay());
+            AddStep("create slow loading dialog overlay", () => overlay = new SlowLoadingDialogOverlay());
 
             AddStep("start loading overlay", () => LoadComponentAsync(overlay, Add));
 
@@ -128,8 +157,6 @@ namespace osu.Game.Tests.Visual.UserInterface
         [Test]
         public void TestDismissBeforePush()
         {
-            AddStep("create dialog overlay", () => Child = overlay = new DialogOverlay());
-
             TestPopupDialog testDialog = null;
             AddStep("dismissed dialog push", () =>
             {
@@ -146,8 +173,6 @@ namespace osu.Game.Tests.Visual.UserInterface
         [Test]
         public void TestDismissBeforePushViaButtonPress()
         {
-            AddStep("create dialog overlay", () => Child = overlay = new DialogOverlay());
-
             TestPopupDialog testDialog = null;
             AddStep("dismissed dialog push", () =>
             {
@@ -163,7 +188,7 @@ namespace osu.Game.Tests.Visual.UserInterface
             });
 
             AddAssert("no dialog pushed", () => overlay.CurrentDialog == null);
-            AddAssert("dialog is not part of hierarchy", () => testDialog.Parent == null);
+            AddUntilStep("dialog is not part of hierarchy", () => testDialog.Parent == null);
         }
 
         private partial class TestPopupDialog : PopupDialog

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

@@ -154,7 +154,7 @@ namespace osu.Game.Tests.Visual.UserInterface
             public TestTitle()
             {
                 Title = "title";
-                Icon = HexaconsIcons.Devtools;
+                Icon = OsuIcon.ChangelogB;
             }
         }
     }

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

@@ -1,10 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using NUnit.Framework;
-using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Testing;
 using osu.Game.Overlays.Dialog;
@@ -15,24 +12,25 @@ namespace osu.Game.Tests.Visual.UserInterface
 {
     public partial class TestScenePopupDialog : OsuManualInputManagerTestScene
     {
-        private TestPopupDialog dialog;
+        private TestPopupDialog dialog = null!;
 
         [SetUpSteps]
         public void SetUpSteps()
         {
             AddStep("new popup", () =>
             {
-                Add(dialog = new TestPopupDialog
+                Child = dialog = new TestPopupDialog
                 {
-                    RelativeSizeAxes = Axes.Both,
                     State = { Value = Framework.Graphics.Containers.Visibility.Visible },
-                });
+                };
             });
         }
 
         [Test]
         public void TestDangerousButton([Values(false, true)] bool atEdge)
         {
+            AddStep("finish transforms", () => dialog.FinishTransforms(true));
+
             if (atEdge)
             {
                 AddStep("move mouse to button edge", () =>

osu.Game/Audio/PreviewTrack.cs

@@ -96,10 +96,14 @@ namespace osu.Game.Audio
 
             hasStarted = false;
 
+            // This pre-check is important, fixes a BASS deadlock in some scenarios.
+            if (!Track.HasCompleted)
+            {
                 Track.Stop();
 
                 // Ensure the track is reset immediately on stopping, so the next time it is started it has a correct time value.
                 Track.Seek(0);
+            }
 
             Stopped?.Invoke();
         }

osu.Game/Configuration/OsuConfigManager.cs

@@ -96,6 +96,7 @@ namespace osu.Game.Configuration
 
             SetDefault(OsuSetting.MenuVoice, true);
             SetDefault(OsuSetting.MenuMusic, true);
+            SetDefault(OsuSetting.MenuTips, true);
 
             SetDefault(OsuSetting.AudioOffset, 0, -500.0, 500.0, 1);
 
@@ -350,6 +351,7 @@ namespace osu.Game.Configuration
         VolumeInactive,
         MenuMusic,
         MenuVoice,
+        MenuTips,
         CursorRotation,
         MenuParallax,
         Prefer24HourTime,

osu.Game/Configuration/SessionAverageHitErrorTracker.cs

@@ -0,0 +1,54 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+
+namespace osu.Game.Configuration
+{
+    /// <summary>
+    /// Tracks the local user's average hit error during the ongoing play session.
+    /// </summary>
+    [Cached]
+    public partial class SessionAverageHitErrorTracker : Component
+    {
+        public IBindableList<double> AverageHitErrorHistory => averageHitErrorHistory;
+        private readonly BindableList<double> averageHitErrorHistory = new BindableList<double>();
+
+        private readonly Bindable<ScoreInfo?> latestScore = new Bindable<ScoreInfo?>();
+
+        [BackgroundDependencyLoader]
+        private void load(SessionStatics statics)
+        {
+            statics.BindWith(Static.LastLocalUserScore, latestScore);
+            latestScore.BindValueChanged(score => calculateAverageHitError(score.NewValue), true);
+        }
+
+        private void calculateAverageHitError(ScoreInfo? newScore)
+        {
+            if (newScore == null)
+                return;
+
+            if (newScore.Mods.Any(m => !m.UserPlayable || m is IHasNoTimedInputs))
+                return;
+
+            if (newScore.HitEvents.Count < 10)
+                return;
+
+            if (newScore.HitEvents.CalculateAverageHitError() is not double averageError)
+                return;
+
+            // keep a sane maximum number of entries.
+            if (averageHitErrorHistory.Count >= 50)
+                averageHitErrorHistory.RemoveAt(0);
+            averageHitErrorHistory.Add(averageError);
+        }
+
+        public void ClearHistory() => averageHitErrorHistory.Clear();
+    }
+}

osu.Game/Configuration/SessionStatics.cs

@@ -9,6 +9,7 @@ using osu.Game.Input;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
+using osu.Game.Scoring;
 
 namespace osu.Game.Configuration
 {
@@ -27,6 +28,7 @@ namespace osu.Game.Configuration
             SetDefault(Static.LastModSelectPanelSamplePlaybackTime, (double?)null);
             SetDefault<APISeasonalBackgrounds>(Static.SeasonalBackgrounds, null);
             SetDefault(Static.TouchInputActive, RuntimeInfo.IsMobile);
+            SetDefault<ScoreInfo>(Static.LastLocalUserScore, null);
         }
 
         /// <summary>
@@ -73,5 +75,10 @@ namespace osu.Game.Configuration
         /// Used in touchscreen detection scenarios (<see cref="TouchInputInterceptor"/>).
         /// </summary>
         TouchInputActive,
+
+        /// <summary>
+        /// Stores the local user's last score (can be completed or aborted).
+        /// </summary>
+        LastLocalUserScore,
     }
 }

osu.Game/Database/StandardisedScoreMigrationTools.cs

@@ -312,8 +312,12 @@ namespace osu.Game.Database
 
             double legacyAccScore = maximumLegacyAccuracyScore * score.Accuracy;
             // We can not separate the ComboScore from the BonusScore, so we keep the bonus in the ratio.
-            double comboProportion =
+            // Note that `maximumLegacyComboScore + maximumLegacyBonusScore` can actually be 0
-                ((double)score.LegacyTotalScore - legacyAccScore) / (maximumLegacyComboScore + maximumLegacyBonusScore);
+            // when playing a beatmap with no bonus objects, with mods that have a 0.0x multiplier on stable (relax/autopilot).
+            // In such cases, just assume 0.
+            double comboProportion = maximumLegacyComboScore + maximumLegacyBonusScore > 0
+                ? ((double)score.LegacyTotalScore - legacyAccScore) / (maximumLegacyComboScore + maximumLegacyBonusScore)
+                : 0;
 
             // We assume the bonus proportion only makes up the rest of the score that exceeds maximumLegacyBaseScore.
             long maximumLegacyBaseScore = maximumLegacyAccuracyScore + maximumLegacyComboScore;
@@ -321,6 +325,8 @@ namespace osu.Game.Database
 
             double modMultiplier = score.Mods.Select(m => m.ScoreMultiplier).Aggregate(1.0, (c, n) => c * n);
 
+            long convertedTotalScore;
+
             switch (score.Ruleset.OnlineID)
             {
                 case 0:
@@ -417,32 +423,42 @@ namespace osu.Game.Database
 
                     double newComboScoreProportion = estimatedComboPortionInStandardisedScore / maximumAchievableComboPortionInStandardisedScore;
 
-                    return (long)Math.Round((
+                    convertedTotalScore = (long)Math.Round((
                         500000 * newComboScoreProportion * score.Accuracy
                         + 500000 * Math.Pow(score.Accuracy, 5)
                         + bonusProportion) * modMultiplier);
+                    break;
 
                 case 1:
-                    return (long)Math.Round((
+                    convertedTotalScore = (long)Math.Round((
                         250000 * comboProportion
                         + 750000 * Math.Pow(score.Accuracy, 3.6)
                         + bonusProportion) * modMultiplier);
+                    break;
 
                 case 2:
-                    return (long)Math.Round((
+                    convertedTotalScore = (long)Math.Round((
                         600000 * comboProportion
                         + 400000 * score.Accuracy
                         + bonusProportion) * modMultiplier);
+                    break;
 
                 case 3:
-                    return (long)Math.Round((
+                    convertedTotalScore = (long)Math.Round((
                         850000 * comboProportion
                         + 150000 * Math.Pow(score.Accuracy, 2 + 2 * score.Accuracy)
                         + bonusProportion) * modMultiplier);
+                    break;
 
                 default:
-                    return score.TotalScore;
+                    convertedTotalScore = score.TotalScore;
+                    break;
             }
+
+            if (convertedTotalScore < 0)
+                throw new InvalidOperationException($"Total score conversion operation returned invalid total of {convertedTotalScore}");
+
+            return convertedTotalScore;
         }
 
         public static double ComputeAccuracy(ScoreInfo scoreInfo)

osu.Game/Graphics/Containers/ExpandingButtonContainer.cs

@@ -1,21 +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.Graphics.Containers
-{
-    /// <summary>
-    /// An <see cref="ExpandingContainer"/> with a long hover expansion delay.
-    /// </summary>
-    /// <remarks>
-    /// Mostly used for buttons with explanatory labels, in which the label would display after a "long hover".
-    /// </remarks>
-    public partial class ExpandingButtonContainer : ExpandingContainer
-    {
-        protected ExpandingButtonContainer(float contractedWidth, float expandedWidth)
-            : base(contractedWidth, expandedWidth)
-        {
-        }
-
-        protected override double HoverExpansionDelay => 400;
-    }
-}

osu.Game/Graphics/Containers/ExpandingContainer.cs

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -26,6 +24,8 @@ namespace osu.Game.Graphics.Containers
         /// </summary>
         protected virtual double HoverExpansionDelay => 0;
 
+        protected virtual bool ExpandOnHover => true;
+
         protected override Container<Drawable> Content => FillFlow;
 
         protected FillFlowContainer FillFlow { get; }
@@ -53,7 +53,7 @@ namespace osu.Game.Graphics.Containers
             };
         }
 
-        private ScheduledDelegate hoverExpandEvent;
+        private ScheduledDelegate? hoverExpandEvent;
 
         protected override void LoadComplete()
         {
@@ -93,6 +93,9 @@ namespace osu.Game.Graphics.Containers
 
         private void updateHoverExpansion()
         {
+            if (!ExpandOnHover)
+                return;
+
             hoverExpandEvent?.Cancel();
 
             if (IsHovered && !Expanded.Value)

osu.Game/Graphics/HexaconsIcons.cs

@@ -1,131 +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.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.Textures;
-using osu.Framework.Text;
-
-namespace osu.Game.Graphics
-{
-    public static class HexaconsIcons
-    {
-        public const string FONT_NAME = "Icons/Hexacons";
-
-        public static IconUsage BeatmapPacks => get(HexaconsMapping.beatmap_packs);
-        public static IconUsage Beatmap => get(HexaconsMapping.beatmap);
-        public static IconUsage Calendar => get(HexaconsMapping.calendar);
-        public static IconUsage Chart => get(HexaconsMapping.chart);
-        public static IconUsage Community => get(HexaconsMapping.community);
-        public static IconUsage Contests => get(HexaconsMapping.contests);
-        public static IconUsage Devtools => get(HexaconsMapping.devtools);
-        public static IconUsage Download => get(HexaconsMapping.download);
-        public static IconUsage Editor => get(HexaconsMapping.editor);
-        public static IconUsage FeaturedArtist => get(HexaconsMapping.featured_artist);
-        public static IconUsage Home => get(HexaconsMapping.home);
-        public static IconUsage Messaging => get(HexaconsMapping.messaging);
-        public static IconUsage Music => get(HexaconsMapping.music);
-        public static IconUsage News => get(HexaconsMapping.news);
-        public static IconUsage Notification => get(HexaconsMapping.notification);
-        public static IconUsage Profile => get(HexaconsMapping.profile);
-        public static IconUsage Rankings => get(HexaconsMapping.rankings);
-        public static IconUsage Search => get(HexaconsMapping.search);
-        public static IconUsage Settings => get(HexaconsMapping.settings);
-        public static IconUsage Social => get(HexaconsMapping.social);
-        public static IconUsage Store => get(HexaconsMapping.store);
-        public static IconUsage Tournament => get(HexaconsMapping.tournament);
-        public static IconUsage Wiki => get(HexaconsMapping.wiki);
-
-        private static IconUsage get(HexaconsMapping icon) => new IconUsage((char)icon, FONT_NAME);
-
-        // Basically just converting to something we can use in a `char` lookup for FontStore/GlyphStore compatibility.
-        // Names should match filenames in resources.
-        private enum HexaconsMapping
-        {
-            beatmap_packs,
-            beatmap,
-            calendar,
-            chart,
-            community,
-            contests,
-            devtools,
-            download,
-            editor,
-            featured_artist,
-            home,
-            messaging,
-            music,
-            news,
-            notification,
-            profile,
-            rankings,
-            search,
-            settings,
-            social,
-            store,
-            tournament,
-            wiki,
-        }
-
-        public class HexaconsStore : ITextureStore, ITexturedGlyphLookupStore
-        {
-            private readonly TextureStore textures;
-
-            public HexaconsStore(TextureStore textures)
-            {
-                this.textures = textures;
-            }
-
-            public void Dispose()
-            {
-                textures.Dispose();
-            }
-
-            public ITexturedCharacterGlyph? Get(string? fontName, char character)
-            {
-                if (fontName == FONT_NAME)
-                    return new Glyph(textures.Get($"{fontName}/{((HexaconsMapping)character).ToString().Replace("_", "-")}"));
-
-                return null;
-            }
-
-            public Task<ITexturedCharacterGlyph?> GetAsync(string fontName, char character) => Task.Run(() => Get(fontName, character));
-
-            public Texture? Get(string name, WrapMode wrapModeS, WrapMode wrapModeT) => null;
-
-            public Texture Get(string name) => throw new NotImplementedException();
-
-            public Task<Texture> GetAsync(string name, CancellationToken cancellationToken = default) => throw new NotImplementedException();
-
-            public Stream GetStream(string name) => throw new NotImplementedException();
-
-            public IEnumerable<string> GetAvailableResources() => throw new NotImplementedException();
-
-            public Task<Texture?> GetAsync(string name, WrapMode wrapModeS, WrapMode wrapModeT, CancellationToken cancellationToken = default) => throw new NotImplementedException();
-
-            public class Glyph : ITexturedCharacterGlyph
-            {
-                public float XOffset => default;
-                public float YOffset => default;
-                public float XAdvance => default;
-                public float Baseline => default;
-                public char Character => default;
-
-                public float GetKerning<T>(T lastGlyph) where T : ICharacterGlyph => throw new NotImplementedException();
-
-                public Texture Texture { get; }
-                public float Width => Texture.Width;
-                public float Height => Texture.Height;
-
-                public Glyph(Texture texture)
-                {
-                    Texture = texture;
-                }
-            }
-        }
-    }
-}

osu.Game/Graphics/OsuIcon.cs

@@ -1,96 +1,444 @@
 // 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.ComponentModel;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using osu.Framework.Extensions;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Text;
 
 namespace osu.Game.Graphics
 {
     public static class OsuIcon
     {
-        public static IconUsage Get(int icon) => new IconUsage((char)icon, "osuFont");
+        #region Legacy spritesheet-based icons
+
+        private static IconUsage get(int icon) => new IconUsage((char)icon, @"osuFont");
 
         // ruleset icons in circles
-        public static IconUsage RulesetOsu => Get(0xe000);
+        public static IconUsage RulesetOsu => get(0xe000);
-        public static IconUsage RulesetMania => Get(0xe001);
+        public static IconUsage RulesetMania => get(0xe001);
-        public static IconUsage RulesetCatch => Get(0xe002);
+        public static IconUsage RulesetCatch => get(0xe002);
-        public static IconUsage RulesetTaiko => Get(0xe003);
+        public static IconUsage RulesetTaiko => get(0xe003);
 
         // ruleset icons without circles
-        public static IconUsage FilledCircle => Get(0xe004);
+        public static IconUsage FilledCircle => get(0xe004);
-        public static IconUsage CrossCircle => Get(0xe005);
+        public static IconUsage Logo => get(0xe006);
-        public static IconUsage Logo => Get(0xe006);
+        public static IconUsage ChevronDownCircle => get(0xe007);
-        public static IconUsage ChevronDownCircle => Get(0xe007);
+        public static IconUsage EditCircle => get(0xe033);
-        public static IconUsage EditCircle => Get(0xe033);
+        public static IconUsage LeftCircle => get(0xe034);
-        public static IconUsage LeftCircle => Get(0xe034);
+        public static IconUsage RightCircle => get(0xe035);
-        public static IconUsage RightCircle => Get(0xe035);
+        public static IconUsage Charts => get(0xe036);
-        public static IconUsage Charts => Get(0xe036);
+        public static IconUsage Solo => get(0xe037);
-        public static IconUsage Solo => Get(0xe037);
+        public static IconUsage Multi => get(0xe038);
-        public static IconUsage Multi => Get(0xe038);
+        public static IconUsage Gear => get(0xe039);
-        public static IconUsage Gear => Get(0xe039);
 
         // misc icons
-        public static IconUsage Bat => Get(0xe008);
+        public static IconUsage Bat => get(0xe008);
-        public static IconUsage Bubble => Get(0xe009);
+        public static IconUsage Bubble => get(0xe009);
-        public static IconUsage BubblePop => Get(0xe02e);
+        public static IconUsage BubblePop => get(0xe02e);
-        public static IconUsage Dice => Get(0xe011);
+        public static IconUsage Dice => get(0xe011);
-        public static IconUsage Heart => Get(0xe02f);
+        public static IconUsage HeartBreak => get(0xe030);
-        public static IconUsage HeartBreak => Get(0xe030);
+        public static IconUsage Hot => get(0xe031);
-        public static IconUsage Hot => Get(0xe031);
+        public static IconUsage ListSearch => get(0xe032);
-        public static IconUsage ListSearch => Get(0xe032);
 
         //osu! playstyles
-        public static IconUsage PlayStyleTablet => Get(0xe02a);
+        public static IconUsage PlayStyleTablet => get(0xe02a);
-        public static IconUsage PlayStyleMouse => Get(0xe029);
+        public static IconUsage PlayStyleMouse => get(0xe029);
-        public static IconUsage PlayStyleKeyboard => Get(0xe02b);
+        public static IconUsage PlayStyleKeyboard => get(0xe02b);
-        public static IconUsage PlayStyleTouch => Get(0xe02c);
+        public static IconUsage PlayStyleTouch => get(0xe02c);
 
         // osu! difficulties
-        public static IconUsage EasyOsu => Get(0xe015);
+        public static IconUsage EasyOsu => get(0xe015);
-        public static IconUsage NormalOsu => Get(0xe016);
+        public static IconUsage NormalOsu => get(0xe016);
-        public static IconUsage HardOsu => Get(0xe017);
+        public static IconUsage HardOsu => get(0xe017);
-        public static IconUsage InsaneOsu => Get(0xe018);
+        public static IconUsage InsaneOsu => get(0xe018);
-        public static IconUsage ExpertOsu => Get(0xe019);
+        public static IconUsage ExpertOsu => get(0xe019);
 
         // taiko difficulties
-        public static IconUsage EasyTaiko => Get(0xe01a);
+        public static IconUsage EasyTaiko => get(0xe01a);
-        public static IconUsage NormalTaiko => Get(0xe01b);
+        public static IconUsage NormalTaiko => get(0xe01b);
-        public static IconUsage HardTaiko => Get(0xe01c);
+        public static IconUsage HardTaiko => get(0xe01c);
-        public static IconUsage InsaneTaiko => Get(0xe01d);
+        public static IconUsage InsaneTaiko => get(0xe01d);
-        public static IconUsage ExpertTaiko => Get(0xe01e);
+        public static IconUsage ExpertTaiko => get(0xe01e);
 
         // fruits difficulties
-        public static IconUsage EasyFruits => Get(0xe01f);
+        public static IconUsage EasyFruits => get(0xe01f);
-        public static IconUsage NormalFruits => Get(0xe020);
+        public static IconUsage NormalFruits => get(0xe020);
-        public static IconUsage HardFruits => Get(0xe021);
+        public static IconUsage HardFruits => get(0xe021);
-        public static IconUsage InsaneFruits => Get(0xe022);
+        public static IconUsage InsaneFruits => get(0xe022);
-        public static IconUsage ExpertFruits => Get(0xe023);
+        public static IconUsage ExpertFruits => get(0xe023);
 
         // mania difficulties
-        public static IconUsage EasyMania => Get(0xe024);
+        public static IconUsage EasyMania => get(0xe024);
-        public static IconUsage NormalMania => Get(0xe025);
+        public static IconUsage NormalMania => get(0xe025);
-        public static IconUsage HardMania => Get(0xe026);
+        public static IconUsage HardMania => get(0xe026);
-        public static IconUsage InsaneMania => Get(0xe027);
+        public static IconUsage InsaneMania => get(0xe027);
-        public static IconUsage ExpertMania => Get(0xe028);
+        public static IconUsage ExpertMania => get(0xe028);
 
         // mod icons
-        public static IconUsage ModPerfect => Get(0xe049);
+        public static IconUsage ModPerfect => get(0xe049);
-        public static IconUsage ModAutopilot => Get(0xe03a);
+        public static IconUsage ModAutopilot => get(0xe03a);
-        public static IconUsage ModAuto => Get(0xe03b);
+        public static IconUsage ModAuto => get(0xe03b);
-        public static IconUsage ModCinema => Get(0xe03c);
+        public static IconUsage ModCinema => get(0xe03c);
-        public static IconUsage ModDoubleTime => Get(0xe03d);
+        public static IconUsage ModDoubleTime => get(0xe03d);
-        public static IconUsage ModEasy => Get(0xe03e);
+        public static IconUsage ModEasy => get(0xe03e);
-        public static IconUsage ModFlashlight => Get(0xe03f);
+        public static IconUsage ModFlashlight => get(0xe03f);
-        public static IconUsage ModHalftime => Get(0xe040);
+        public static IconUsage ModHalftime => get(0xe040);
-        public static IconUsage ModHardRock => Get(0xe041);
+        public static IconUsage ModHardRock => get(0xe041);
-        public static IconUsage ModHidden => Get(0xe042);
+        public static IconUsage ModHidden => get(0xe042);
-        public static IconUsage ModNightcore => Get(0xe043);
+        public static IconUsage ModNightcore => get(0xe043);
-        public static IconUsage ModNoFail => Get(0xe044);
+        public static IconUsage ModNoFail => get(0xe044);
-        public static IconUsage ModRelax => Get(0xe045);
+        public static IconUsage ModRelax => get(0xe045);
-        public static IconUsage ModSpunOut => Get(0xe046);
+        public static IconUsage ModSpunOut => get(0xe046);
-        public static IconUsage ModSuddenDeath => Get(0xe047);
+        public static IconUsage ModSuddenDeath => get(0xe047);
-        public static IconUsage ModTarget => Get(0xe048);
+        public static IconUsage ModTarget => get(0xe048);
 
         // Use "Icons/BeatmapDetails/mod-icon" instead
         // public static IconUsage ModBg => Get(0xe04a);
+
+        #endregion
+
+        #region New single-file-based icons
+
+        public const string FONT_NAME = @"Icons";
+
+        public static IconUsage Audio => get(OsuIconMapping.Audio);
+        public static IconUsage Beatmap => get(OsuIconMapping.Beatmap);
+        public static IconUsage Calendar => get(OsuIconMapping.Calendar);
+        public static IconUsage ChangelogA => get(OsuIconMapping.ChangelogA);
+        public static IconUsage ChangelogB => get(OsuIconMapping.ChangelogB);
+        public static IconUsage Chat => get(OsuIconMapping.Chat);
+        public static IconUsage CheckCircle => get(OsuIconMapping.CheckCircle);
+        public static IconUsage CollapseA => get(OsuIconMapping.CollapseA);
+        public static IconUsage Collections => get(OsuIconMapping.Collections);
+        public static IconUsage Cross => get(OsuIconMapping.Cross);
+        public static IconUsage CrossCircle => get(OsuIconMapping.CrossCircle);
+        public static IconUsage Crown => get(OsuIconMapping.Crown);
+        public static IconUsage Debug => get(OsuIconMapping.Debug);
+        public static IconUsage Delete => get(OsuIconMapping.Delete);
+        public static IconUsage Details => get(OsuIconMapping.Details);
+        public static IconUsage Discord => get(OsuIconMapping.Discord);
+        public static IconUsage EllipsisHorizontal => get(OsuIconMapping.EllipsisHorizontal);
+        public static IconUsage EllipsisVertical => get(OsuIconMapping.EllipsisVertical);
+        public static IconUsage ExpandA => get(OsuIconMapping.ExpandA);
+        public static IconUsage ExpandB => get(OsuIconMapping.ExpandB);
+        public static IconUsage FeaturedArtist => get(OsuIconMapping.FeaturedArtist);
+        public static IconUsage FeaturedArtistCircle => get(OsuIconMapping.FeaturedArtistCircle);
+        public static IconUsage GameplayA => get(OsuIconMapping.GameplayA);
+        public static IconUsage GameplayB => get(OsuIconMapping.GameplayB);
+        public static IconUsage GameplayC => get(OsuIconMapping.GameplayC);
+        public static IconUsage Global => get(OsuIconMapping.Global);
+        public static IconUsage Graphics => get(OsuIconMapping.Graphics);
+        public static IconUsage Heart => get(OsuIconMapping.Heart);
+        public static IconUsage Home => get(OsuIconMapping.Home);
+        public static IconUsage Input => get(OsuIconMapping.Input);
+        public static IconUsage Maintenance => get(OsuIconMapping.Maintenance);
+        public static IconUsage Megaphone => get(OsuIconMapping.Megaphone);
+        public static IconUsage Music => get(OsuIconMapping.Music);
+        public static IconUsage News => get(OsuIconMapping.News);
+        public static IconUsage Next => get(OsuIconMapping.Next);
+        public static IconUsage NextCircle => get(OsuIconMapping.NextCircle);
+        public static IconUsage Notification => get(OsuIconMapping.Notification);
+        public static IconUsage Online => get(OsuIconMapping.Online);
+        public static IconUsage Play => get(OsuIconMapping.Play);
+        public static IconUsage Player => get(OsuIconMapping.Player);
+        public static IconUsage PlayerFollow => get(OsuIconMapping.PlayerFollow);
+        public static IconUsage Prev => get(OsuIconMapping.Prev);
+        public static IconUsage PrevCircle => get(OsuIconMapping.PrevCircle);
+        public static IconUsage Ranking => get(OsuIconMapping.Ranking);
+        public static IconUsage Rulesets => get(OsuIconMapping.Rulesets);
+        public static IconUsage Search => get(OsuIconMapping.Search);
+        public static IconUsage Settings => get(OsuIconMapping.Settings);
+        public static IconUsage SkinA => get(OsuIconMapping.SkinA);
+        public static IconUsage SkinB => get(OsuIconMapping.SkinB);
+        public static IconUsage Star => get(OsuIconMapping.Star);
+        public static IconUsage Storyboard => get(OsuIconMapping.Storyboard);
+        public static IconUsage Team => get(OsuIconMapping.Team);
+        public static IconUsage ThumbsUp => get(OsuIconMapping.ThumbsUp);
+        public static IconUsage Tournament => get(OsuIconMapping.Tournament);
+        public static IconUsage Twitter => get(OsuIconMapping.Twitter);
+        public static IconUsage UserInterface => get(OsuIconMapping.UserInterface);
+        public static IconUsage Wiki => get(OsuIconMapping.Wiki);
+        public static IconUsage EditorAddControlPoint => get(OsuIconMapping.EditorAddControlPoint);
+        public static IconUsage EditorConvertToStream => get(OsuIconMapping.EditorConvertToStream);
+        public static IconUsage EditorDistanceSnap => get(OsuIconMapping.EditorDistanceSnap);
+        public static IconUsage EditorFinish => get(OsuIconMapping.EditorFinish);
+        public static IconUsage EditorGridSnap => get(OsuIconMapping.EditorGridSnap);
+        public static IconUsage EditorNewComboA => get(OsuIconMapping.EditorNewComboA);
+        public static IconUsage EditorNewComboB => get(OsuIconMapping.EditorNewComboB);
+        public static IconUsage EditorSelect => get(OsuIconMapping.EditorSelect);
+        public static IconUsage EditorSound => get(OsuIconMapping.EditorSound);
+        public static IconUsage EditorWhistle => get(OsuIconMapping.EditorWhistle);
+
+        private static IconUsage get(OsuIconMapping glyph) => new IconUsage((char)glyph, FONT_NAME);
+
+        private enum OsuIconMapping
+        {
+            [Description(@"audio")]
+            Audio,
+
+            [Description(@"beatmap")]
+            Beatmap,
+
+            [Description(@"calendar")]
+            Calendar,
+
+            [Description(@"changelog-a")]
+            ChangelogA,
+
+            [Description(@"changelog-b")]
+            ChangelogB,
+
+            [Description(@"chat")]
+            Chat,
+
+            [Description(@"check-circle")]
+            CheckCircle,
+
+            [Description(@"collapse-a")]
+            CollapseA,
+
+            [Description(@"collections")]
+            Collections,
+
+            [Description(@"cross")]
+            Cross,
+
+            [Description(@"cross-circle")]
+            CrossCircle,
+
+            [Description(@"crown")]
+            Crown,
+
+            [Description(@"debug")]
+            Debug,
+
+            [Description(@"delete")]
+            Delete,
+
+            [Description(@"details")]
+            Details,
+
+            [Description(@"discord")]
+            Discord,
+
+            [Description(@"ellipsis-horizontal")]
+            EllipsisHorizontal,
+
+            [Description(@"ellipsis-vertical")]
+            EllipsisVertical,
+
+            [Description(@"expand-a")]
+            ExpandA,
+
+            [Description(@"expand-b")]
+            ExpandB,
+
+            [Description(@"featured-artist")]
+            FeaturedArtist,
+
+            [Description(@"featured-artist-circle")]
+            FeaturedArtistCircle,
+
+            [Description(@"gameplay-a")]
+            GameplayA,
+
+            [Description(@"gameplay-b")]
+            GameplayB,
+
+            [Description(@"gameplay-c")]
+            GameplayC,
+
+            [Description(@"global")]
+            Global,
+
+            [Description(@"graphics")]
+            Graphics,
+
+            [Description(@"heart")]
+            Heart,
+
+            [Description(@"home")]
+            Home,
+
+            [Description(@"input")]
+            Input,
+
+            [Description(@"maintenance")]
+            Maintenance,
+
+            [Description(@"megaphone")]
+            Megaphone,
+
+            [Description(@"music")]
+            Music,
+
+            [Description(@"news")]
+            News,
+
+            [Description(@"next")]
+            Next,
+
+            [Description(@"next-circle")]
+            NextCircle,
+
+            [Description(@"notification")]
+            Notification,
+
+            [Description(@"online")]
+            Online,
+
+            [Description(@"play")]
+            Play,
+
+            [Description(@"player")]
+            Player,
+
+            [Description(@"player-follow")]
+            PlayerFollow,
+
+            [Description(@"prev")]
+            Prev,
+
+            [Description(@"prev-circle")]
+            PrevCircle,
+
+            [Description(@"ranking")]
+            Ranking,
+
+            [Description(@"rulesets")]
+            Rulesets,
+
+            [Description(@"search")]
+            Search,
+
+            [Description(@"settings")]
+            Settings,
+
+            [Description(@"skin-a")]
+            SkinA,
+
+            [Description(@"skin-b")]
+            SkinB,
+
+            [Description(@"star")]
+            Star,
+
+            [Description(@"storyboard")]
+            Storyboard,
+
+            [Description(@"team")]
+            Team,
+
+            [Description(@"thumbs-up")]
+            ThumbsUp,
+
+            [Description(@"tournament")]
+            Tournament,
+
+            [Description(@"twitter")]
+            Twitter,
+
+            [Description(@"user-interface")]
+            UserInterface,
+
+            [Description(@"wiki")]
+            Wiki,
+
+            [Description(@"Editor/add-control-point")]
+            EditorAddControlPoint = 1000,
+
+            [Description(@"Editor/convert-to-stream")]
+            EditorConvertToStream,
+
+            [Description(@"Editor/distance-snap")]
+            EditorDistanceSnap,
+
+            [Description(@"Editor/finish")]
+            EditorFinish,
+
+            [Description(@"Editor/grid-snap")]
+            EditorGridSnap,
+
+            [Description(@"Editor/new-combo-a")]
+            EditorNewComboA,
+
+            [Description(@"Editor/new-combo-b")]
+            EditorNewComboB,
+
+            [Description(@"Editor/select")]
+            EditorSelect,
+
+            [Description(@"Editor/sound")]
+            EditorSound,
+
+            [Description(@"Editor/whistle")]
+            EditorWhistle,
+        }
+
+        public class OsuIconStore : ITextureStore, ITexturedGlyphLookupStore
+        {
+            private readonly TextureStore textures;
+
+            public OsuIconStore(TextureStore textures)
+            {
+                this.textures = textures;
+            }
+
+            public ITexturedCharacterGlyph? Get(string? fontName, char character)
+            {
+                if (fontName == FONT_NAME)
+                    return new Glyph(textures.Get($@"{fontName}/{((OsuIconMapping)character).GetDescription()}"));
+
+                return null;
+            }
+
+            public Task<ITexturedCharacterGlyph?> GetAsync(string fontName, char character) => Task.Run(() => Get(fontName, character));
+
+            public Texture? Get(string name, WrapMode wrapModeS, WrapMode wrapModeT) => null;
+
+            public Texture Get(string name) => throw new NotImplementedException();
+
+            public Task<Texture> GetAsync(string name, CancellationToken cancellationToken = default) => throw new NotImplementedException();
+
+            public Stream GetStream(string name) => throw new NotImplementedException();
+
+            public IEnumerable<string> GetAvailableResources() => throw new NotImplementedException();
+
+            public Task<Texture?> GetAsync(string name, WrapMode wrapModeS, WrapMode wrapModeT, CancellationToken cancellationToken = default) => throw new NotImplementedException();
+
+            public class Glyph : ITexturedCharacterGlyph
+            {
+                public float XOffset => default;
+                public float YOffset => default;
+                public float XAdvance => default;
+                public float Baseline => default;
+                public char Character => default;
+
+                public float GetKerning<T>(T lastGlyph) where T : ICharacterGlyph => throw new NotImplementedException();
+
+                public Texture Texture { get; }
+                public float Width => Texture.Width;
+                public float Height => Texture.Height;
+
+                public Glyph(Texture texture)
+                {
+                    Texture = texture;
+                }
+            }
+
+            public void Dispose()
+            {
+                textures.Dispose();
+            }
+        }
+
+        #endregion
     }
 }

osu.Game/Graphics/UserInterface/DialogButton.cs

@@ -25,7 +25,7 @@ namespace osu.Game.Graphics.UserInterface
         private const float idle_width = 0.8f;
         private const float hover_width = 0.9f;
 
-        private const float hover_duration = 500;
+        private const float hover_duration = 300;
         private const float click_duration = 200;
 
         public event Action<SelectionState>? StateChanged;
@@ -54,7 +54,7 @@ namespace osu.Game.Graphics.UserInterface
         private readonly Box rightGlow;
         private readonly Box background;
         private readonly SpriteText spriteText;
-        private Vector2 hoverSpacing => new Vector2(3f, 0f);
+        private Vector2 hoverSpacing => new Vector2(1.4f, 0f);
 
         public DialogButton(HoverSampleSet sampleSet = HoverSampleSet.Button)
             : base(sampleSet)
@@ -279,15 +279,15 @@ namespace osu.Game.Graphics.UserInterface
 
             if (newState == SelectionState.Selected)
             {
-                spriteText.TransformSpacingTo(hoverSpacing, hover_duration, Easing.OutElastic);
+                spriteText.TransformSpacingTo(hoverSpacing, hover_duration, Easing.OutQuint);
-                ColourContainer.ResizeWidthTo(hover_width, hover_duration, Easing.OutElastic);
+                ColourContainer.ResizeWidthTo(hover_width, hover_duration, Easing.OutQuint);
                 glowContainer.FadeIn(hover_duration, Easing.OutQuint);
             }
             else
             {
-                ColourContainer.ResizeWidthTo(idle_width, hover_duration, Easing.OutElastic);
+                ColourContainer.ResizeWidthTo(idle_width, hover_duration / 2, Easing.OutQuint);
-                spriteText.TransformSpacingTo(Vector2.Zero, hover_duration, Easing.OutElastic);
+                spriteText.TransformSpacingTo(Vector2.Zero, hover_duration / 2, Easing.OutQuint);
-                glowContainer.FadeOut(hover_duration, Easing.OutQuint);
+                glowContainer.FadeOut(hover_duration / 2, Easing.OutQuint);
             }
         }
 

osu.Game/Input/Bindings/GlobalActionContainer.cs

@@ -160,6 +160,8 @@ namespace osu.Game.Input.Bindings
             new KeyBinding(InputKey.Enter, GlobalAction.ToggleChatFocus),
             new KeyBinding(InputKey.F1, GlobalAction.SaveReplay),
             new KeyBinding(InputKey.F2, GlobalAction.ExportReplay),
+            new KeyBinding(InputKey.Plus, GlobalAction.IncreaseOffset),
+            new KeyBinding(InputKey.Minus, GlobalAction.DecreaseOffset),
         };
 
         private static IEnumerable<KeyBinding> replayKeyBindings => new[]
@@ -404,6 +406,12 @@ namespace osu.Game.Input.Bindings
 
         [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.EditorToggleRotateControl))]
         EditorToggleRotateControl,
+
+        [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.IncreaseOffset))]
+        IncreaseOffset,
+
+        [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.DecreaseOffset))]
+        DecreaseOffset
     }
 
     public enum GlobalActionCategory

osu.Game/Localisation/ContextMenuStrings.cs

@@ -20,9 +20,14 @@ namespace osu.Game.Localisation
         public static LocalisableString ViewBeatmap => new TranslatableString(getKey(@"view_beatmap"), @"View beatmap");
 
         /// <summary>
-        /// "Invite player"
+        /// "Invite to room"
         /// </summary>
-        public static LocalisableString InvitePlayer => new TranslatableString(getKey(@"invite_player"), @"Invite player");
+        public static LocalisableString InvitePlayer => new TranslatableString(getKey(@"invite_player"), @"Invite to room");
+
+        /// <summary>
+        /// "Spectate"
+        /// </summary>
+        public static LocalisableString SpectatePlayer => new TranslatableString(getKey(@"spectate_player"), @"Spectate");
 
         private static string getKey(string key) => $@"{prefix}:{key}";
     }

osu.Game/Localisation/GlobalActionKeyBindingStrings.cs

@@ -344,6 +344,16 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString ExportReplay => new TranslatableString(getKey(@"export_replay"), @"Export replay");
 
+        /// <summary>
+        /// "Increase offset"
+        /// </summary>
+        public static LocalisableString IncreaseOffset => new TranslatableString(getKey(@"increase_offset"), @"Increase offset");
+
+        /// <summary>
+        /// "Decrease offset"
+        /// </summary>
+        public static LocalisableString DecreaseOffset => new TranslatableString(getKey(@"decrease_offset"), @"Decrease offset");
+
         /// <summary>
         /// "Toggle rotate control"
         /// </summary>

osu.Game/Localisation/NamedOverlayComponentStrings.cs

@@ -20,12 +20,12 @@ namespace osu.Game.Localisation
         public static LocalisableString ChangelogDescription => new TranslatableString(getKey(@"changelog_description"), @"track recent dev updates in the osu! ecosystem");
 
         /// <summary>
-        /// "view your friends and other information"
+        /// "view your friends and spectate other players"
         /// </summary>
-        public static LocalisableString DashboardDescription => new TranslatableString(getKey(@"dashboard_description"), @"view your friends and other information");
+        public static LocalisableString DashboardDescription => new TranslatableString(getKey(@"dashboard_description"), @"view your friends and spectate other players");
 
         /// <summary>
-        /// "find out who's the best right now"
+        /// "find out who&#39;s the best right now"
         /// </summary>
         public static LocalisableString RankingsDescription => new TranslatableString(getKey(@"rankings_description"), @"find out who's the best right now");
 
@@ -39,6 +39,6 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString WikiDescription => new TranslatableString(getKey(@"wiki_description"), @"knowledge base");
 
-        private static string getKey(string key) => $"{prefix}:{key}";
+        private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }

osu.Game/Localisation/UserInterfaceStrings.cs

@@ -24,6 +24,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString MenuCursorSize => new TranslatableString(getKey(@"menu_cursor_size"), @"Menu cursor size");
 
+        /// <summary>
+        /// "Menu tips"
+        /// </summary>
+        public static LocalisableString ShowMenuTips => new TranslatableString(getKey(@"show_menu_tips"), @"Menu tips");
+
         /// <summary>
         /// "Parallax"
         /// </summary>
@@ -154,6 +159,6 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString TrueRandom => new TranslatableString(getKey(@"true_random"), @"True Random");
 
-        private static string getKey(string key) => $"{prefix}:{key}";
+        private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }

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

@@ -0,0 +1,16 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Game.Online.API.Requests.Responses;
+
+namespace osu.Game.Online.API.Requests
+{
+    public class GetSystemTitleRequest : OsuJsonWebRequest<APISystemTitle>
+    {
+        public GetSystemTitleRequest()
+            : base($@"https://assets.ppy.sh/lazer-status.json?{DateTimeOffset.UtcNow.ToUnixTimeSeconds() / 1800}")
+        {
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+// 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 Newtonsoft.Json;
+
+namespace osu.Game.Online.API.Requests.Responses
+{
+    public class APISystemTitle : IEquatable<APISystemTitle>
+    {
+        [JsonProperty(@"image")]
+        public string Image { get; set; } = string.Empty;
+
+        [JsonProperty(@"url")]
+        public string Url { get; set; } = string.Empty;
+
+        public bool Equals(APISystemTitle? other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+
+            return Image == other.Image && Url == other.Url;
+        }
+
+        public override bool Equals(object? obj) => obj is APISystemTitle other && Equals(other);
+
+        // ReSharper disable NonReadonlyMemberInGetHashCode
+        public override int GetHashCode() => HashCode.Combine(Image, Url);
+    }
+}

osu.Game/OsuGame.cs

@@ -995,7 +995,10 @@ namespace osu.Game
             }, topMostOverlayContent.Add);
 
             if (!args?.Any(a => a == @"--no-version-overlay") ?? true)
-                loadComponentSingleFile(versionManager = new VersionManager { Depth = int.MinValue }, ScreenContainer.Add);
+            {
+                dependencies.Cache(versionManager = new VersionManager { Depth = int.MinValue });
+                loadComponentSingleFile(versionManager, ScreenContainer.Add);
+            }
 
             loadComponentSingleFile(osuLogo, _ =>
             {

osu.Game/OsuGameBase.cs

@@ -200,6 +200,8 @@ namespace osu.Game
 
         private RulesetConfigCache rulesetConfigCache;
 
+        private SessionAverageHitErrorTracker hitErrorTracker;
+
         protected SpectatorClient SpectatorClient { get; private set; }
 
         protected MultiplayerClient MultiplayerClient { get; private set; }
@@ -349,6 +351,7 @@ namespace osu.Game
                 dependencies.CacheAs(powerStatus);
 
             dependencies.Cache(SessionStatics = new SessionStatics());
+            dependencies.Cache(hitErrorTracker = new SessionAverageHitErrorTracker());
             dependencies.Cache(Colours = new OsuColour());
 
             RegisterImportHandler(BeatmapManager);
@@ -408,6 +411,7 @@ namespace osu.Game
             });
 
             base.Content.Add(new TouchInputInterceptor());
+            base.Content.Add(hitErrorTracker);
 
             KeyBindingStore = new RealmKeyBindingStore(realm, keyCombinationProvider);
             KeyBindingStore.Register(globalBindings, RulesetStore.AvailableRulesets);
@@ -478,7 +482,7 @@ namespace osu.Game
             AddFont(Resources, @"Fonts/Venera/Venera-Bold");
             AddFont(Resources, @"Fonts/Venera/Venera-Black");
 
-            Fonts.AddStore(new HexaconsIcons.HexaconsStore(Textures));
+            Fonts.AddStore(new OsuIcon.OsuIconStore(Textures));
         }
 
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent) =>
@@ -527,14 +531,21 @@ namespace osu.Game
             {
                 ManualResetEventSlim readyToRun = new ManualResetEventSlim();
 
+                bool success = false;
+
                 Scheduler.Add(() =>
+                {
+                    try
                     {
                         realmBlocker = realm.BlockAllOperations("migration");
+                        success = true;
+                    }
+                    catch { }
 
                     readyToRun.Set();
                 }, false);
 
-                if (!readyToRun.Wait(30000))
+                if (!readyToRun.Wait(30000) || !success)
                     throw new TimeoutException("Attempting to block for migration took too long.");
 
                 bool? cleanupSucceded = (Storage as OsuStorage)?.Migrate(Host.GetStorage(path));

osu.Game/Overlays/BeatmapListing/BeatmapListingHeader.cs

@@ -24,7 +24,7 @@ namespace osu.Game.Overlays.BeatmapListing
             {
                 Title = PageTitleStrings.MainBeatmapsetsControllerIndex;
                 Description = NamedOverlayComponentStrings.BeatmapListingDescription;
-                Icon = HexaconsIcons.Beatmap;
+                Icon = OsuIcon.Beatmap;
             }
         }
     }

osu.Game/Overlays/BeatmapSet/BeatmapSetHeader.cs

@@ -60,7 +60,7 @@ namespace osu.Game.Overlays.BeatmapSet
             public BeatmapHeaderTitle()
             {
                 Title = PageTitleStrings.MainBeatmapsetsControllerShow;
-                Icon = HexaconsIcons.Beatmap;
+                Icon = OsuIcon.Beatmap;
             }
         }
     }

osu.Game/Overlays/Changelog/ChangelogHeader.cs

@@ -124,7 +124,7 @@ namespace osu.Game.Overlays.Changelog
             {
                 Title = PageTitleStrings.MainChangelogControllerDefault;
                 Description = NamedOverlayComponentStrings.ChangelogDescription;
-                Icon = HexaconsIcons.Devtools;
+                Icon = OsuIcon.ChangelogB;
             }
         }
     }

osu.Game/Overlays/Chat/ChatOverlayTopBar.cs

@@ -46,7 +46,7 @@ namespace osu.Game.Overlays.Chat
                             {
                                 Anchor = Anchor.Centre,
                                 Origin = Anchor.Centre,
-                                Icon = HexaconsIcons.Messaging,
+                                Icon = OsuIcon.Chat,
                                 Size = new Vector2(24),
                             },
                             // Placeholder text

osu.Game/Overlays/ChatOverlay.cs

@@ -31,7 +31,7 @@ namespace osu.Game.Overlays
 {
     public partial class ChatOverlay : OsuFocusedOverlayContainer, INamedOverlayComponent, IKeyBindingHandler<PlatformAction>
     {
-        public IconUsage Icon => HexaconsIcons.Messaging;
+        public IconUsage Icon => OsuIcon.Chat;
         public LocalisableString Title => ChatStrings.HeaderTitle;
         public LocalisableString Description => ChatStrings.HeaderDescription;
 

osu.Game/Overlays/Dashboard/CurrentlyOnlineDisplay.cs

@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Diagnostics;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions;
@@ -130,9 +131,6 @@ namespace osu.Game.Overlays.Dashboard
                     {
                         int userId = kvp.Key;
 
-                        if (userId == api.LocalUser.Value.Id)
-                            continue;
-
                         users.GetUserAsync(userId).ContinueWith(task =>
                         {
                             APIUser user = task.GetResultSafely();
@@ -218,6 +216,7 @@ namespace osu.Game.Overlays.Dashboard
             {
                 panel.Anchor = Anchor.TopCentre;
                 panel.Origin = Anchor.TopCentre;
+                panel.CanSpectate.Value = playingUsers.Contains(user.Id);
             });
 
         public partial class OnlineUserPanel : CompositeDrawable, IFilterable

osu.Game/Overlays/Dashboard/DashboardOverlayHeader.cs

@@ -19,7 +19,7 @@ namespace osu.Game.Overlays.Dashboard
             {
                 Title = PageTitleStrings.MainHomeControllerIndex;
                 Description = NamedOverlayComponentStrings.DashboardDescription;
-                Icon = HexaconsIcons.Social;
+                Icon = OsuIcon.Global;
             }
         }
     }

osu.Game/Overlays/Dialog/PopupDialog.cs

@@ -14,6 +14,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Graphics.Backgrounds;
 using osu.Game.Graphics.Containers;
 using osuTK;
@@ -25,11 +26,10 @@ namespace osu.Game.Overlays.Dialog
     public abstract partial class PopupDialog : VisibilityContainer
     {
         public const float ENTER_DURATION = 500;
-        public const float EXIT_DURATION = 200;
+        public const float EXIT_DURATION = 500;
 
         private readonly Vector2 ringSize = new Vector2(100f);
         private readonly Vector2 ringMinifiedSize = new Vector2(20f);
-        private readonly Vector2 buttonsEnterSpacing = new Vector2(0f, 50f);
 
         private readonly Box flashLayer;
         private Sample flashSample = null!;
@@ -108,13 +108,20 @@ namespace osu.Game.Overlays.Dialog
 
         protected PopupDialog()
         {
-            RelativeSizeAxes = Axes.Both;
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
 
             Children = new Drawable[]
             {
                 content = new Container
                 {
-                    RelativeSizeAxes = Axes.Both,
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
                     Alpha = 0f,
                     Children = new Drawable[]
                     {
@@ -122,11 +129,13 @@ namespace osu.Game.Overlays.Dialog
                         {
                             RelativeSizeAxes = Axes.Both,
                             Masking = true,
+                            CornerRadius = 20,
+                            CornerExponent = 2.5f,
                             EdgeEffect = new EdgeEffectParameters
                             {
                                 Type = EdgeEffectType.Shadow,
-                                Colour = Color4.Black.Opacity(0.5f),
+                                Colour = Color4.Black.Opacity(0.2f),
-                                Radius = 8,
+                                Radius = 14,
                             },
                             Children = new Drawable[]
                             {
@@ -142,23 +151,29 @@ namespace osu.Game.Overlays.Dialog
                                     ColourDark = Color4Extensions.FromHex(@"1e171e"),
                                     TriangleScale = 4,
                                 },
+                                flashLayer = new Box
+                                {
+                                    Alpha = 0,
+                                    RelativeSizeAxes = Axes.Both,
+                                    Blending = BlendingParameters.Additive,
+                                    Colour = Color4Extensions.FromHex(@"221a21"),
+                                },
                             },
                         },
                         new FillFlowContainer
                         {
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.BottomCentre,
                             RelativeSizeAxes = Axes.X,
                             AutoSizeAxes = Axes.Y,
                             Direction = FillDirection.Vertical,
                             Spacing = new Vector2(0f, 10f),
-                            Padding = new MarginPadding { Bottom = 10 },
+                            Padding = new MarginPadding { Vertical = 60 },
                             Children = new Drawable[]
                             {
                                 new Container
                                 {
                                     Origin = Anchor.TopCentre,
                                     Anchor = Anchor.TopCentre,
+                                    Padding = new MarginPadding { Bottom = 30 },
                                     Size = ringSize,
                                     Children = new Drawable[]
                                     {
@@ -181,6 +196,7 @@ namespace osu.Game.Overlays.Dialog
                                                     Origin = Anchor.Centre,
                                                     Anchor = Anchor.Centre,
                                                     Icon = FontAwesome.Solid.TimesCircle,
+                                                    Y = -2,
                                                     Size = new Vector2(50),
                                                 },
                                             },
@@ -194,6 +210,7 @@ namespace osu.Game.Overlays.Dialog
                                     RelativeSizeAxes = Axes.X,
                                     AutoSizeAxes = Axes.Y,
                                     TextAnchor = Anchor.TopCentre,
+                                    Padding = new MarginPadding { Horizontal = 5 },
                                 },
                                 body = new OsuTextFlowContainer(t => t.Font = t.Font.With(size: 18))
                                 {
@@ -202,24 +219,18 @@ namespace osu.Game.Overlays.Dialog
                                     TextAnchor = Anchor.TopCentre,
                                     RelativeSizeAxes = Axes.X,
                                     AutoSizeAxes = Axes.Y,
-                                    Padding = new MarginPadding(5),
+                                    Padding = new MarginPadding { Horizontal = 5 },
-                                },
-                            },
                                 },
                                 buttonsContainer = new FillFlowContainer<PopupDialogButton>
                                 {
-                            Anchor = Anchor.Centre,
+                                    Anchor = Anchor.TopCentre,
                                     Origin = Anchor.TopCentre,
                                     RelativeSizeAxes = Axes.X,
                                     AutoSizeAxes = Axes.Y,
                                     Direction = FillDirection.Vertical,
+                                    Padding = new MarginPadding { Top = 30 },
+                                },
                             },
-                        flashLayer = new Box
-                        {
-                            Alpha = 0,
-                            RelativeSizeAxes = Axes.Both,
-                            Blending = BlendingParameters.Additive,
-                            Colour = Color4Extensions.FromHex(@"221a21"),
                         },
                     },
                 },
@@ -231,7 +242,7 @@ namespace osu.Game.Overlays.Dialog
         }
 
         [BackgroundDependencyLoader]
-        private void load(AudioManager audio)
+        private void load(AudioManager audio, OsuColour colours)
         {
             flashSample = audio.Samples.Get(@"UI/default-select-disabled");
         }
@@ -288,15 +299,15 @@ namespace osu.Game.Overlays.Dialog
             // Reset various animations but only if the dialog animation fully completed
             if (content.Alpha == 0)
             {
-                buttonsContainer.TransformSpacingTo(buttonsEnterSpacing);
+                content.ScaleTo(0.7f);
-                buttonsContainer.MoveToY(buttonsEnterSpacing.Y);
                 ring.ResizeTo(ringMinifiedSize);
             }
 
-            content.FadeIn(ENTER_DURATION, Easing.OutQuint);
+            content
-            ring.ResizeTo(ringSize, ENTER_DURATION, Easing.OutQuint);
+                .ScaleTo(1, 750, Easing.OutElasticHalf)
-            buttonsContainer.TransformSpacingTo(Vector2.Zero, ENTER_DURATION, Easing.OutQuint);
+                .FadeIn(ENTER_DURATION, Easing.OutQuint);
-            buttonsContainer.MoveToY(0, ENTER_DURATION, Easing.OutQuint);
+
+            ring.ResizeTo(ringSize, ENTER_DURATION * 1.5f, Easing.OutQuint);
         }
 
         protected override void PopOut()
@@ -306,7 +317,9 @@ namespace osu.Game.Overlays.Dialog
                 // This is presumed to always be a sane default "cancel" action.
                 buttonsContainer.Last().TriggerClick();
 
-            content.FadeOut(EXIT_DURATION, Easing.InSine);
+            content
+                .ScaleTo(0.7f, EXIT_DURATION, Easing.Out)
+                .FadeOut(EXIT_DURATION, Easing.OutQuint);
         }
 
         private void pressButtonAtIndex(int index)

osu.Game/Overlays/DialogOverlay.cs

@@ -29,16 +29,18 @@ namespace osu.Game.Overlays
 
         public DialogOverlay()
         {
-            RelativeSizeAxes = Axes.Both;
+            AutoSizeAxes = Axes.Y;
 
             Child = dialogContainer = new Container
             {
-                RelativeSizeAxes = Axes.Both,
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
             };
 
-            Width = 0.4f;
+            Width = 500;
-            Anchor = Anchor.BottomCentre;
+
-            Origin = Anchor.BottomCentre;
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
         }
 
         [BackgroundDependencyLoader]

osu.Game/Overlays/Mods/Input/ClassicModHotkeyHandler.cs

@@ -20,7 +20,7 @@ namespace osu.Game.Overlays.Mods.Input
         {
             [Key.Q] = new[] { typeof(ModEasy) },
             [Key.W] = new[] { typeof(ModNoFail) },
-            [Key.E] = new[] { typeof(ModHalfTime) },
+            [Key.E] = new[] { typeof(ModHalfTime), typeof(ModDaycore) },
             [Key.A] = new[] { typeof(ModHardRock) },
             [Key.S] = new[] { typeof(ModSuddenDeath), typeof(ModPerfect) },
             [Key.D] = new[] { typeof(ModDoubleTime), typeof(ModNightcore) },

osu.Game/Overlays/News/NewsHeader.cs

@@ -69,7 +69,7 @@ namespace osu.Game.Overlays.News
             {
                 Title = PageTitleStrings.MainNewsControllerDefault;
                 Description = NamedOverlayComponentStrings.NewsDescription;
-                Icon = HexaconsIcons.News;
+                Icon = OsuIcon.News;
             }
         }
     }

osu.Game/Overlays/NotificationOverlay.cs

@@ -29,7 +29,7 @@ namespace osu.Game.Overlays
 {
     public partial class NotificationOverlay : OsuFocusedOverlayContainer, INamedOverlayComponent, INotificationOverlay
     {
-        public IconUsage Icon => HexaconsIcons.Notification;
+        public IconUsage Icon => OsuIcon.Notification;
         public LocalisableString Title => NotificationsStrings.HeaderTitle;
         public LocalisableString Description => NotificationsStrings.HeaderDescription;
 
@@ -227,7 +227,7 @@ namespace osu.Game.Overlays
         protected override void PopIn()
         {
             this.MoveToX(0, TRANSITION_LENGTH, Easing.OutQuint);
-            mainContent.FadeTo(1, TRANSITION_LENGTH, Easing.OutQuint);
+            mainContent.FadeTo(1, TRANSITION_LENGTH / 2, Easing.OutQuint);
             mainContent.FadeEdgeEffectTo(WaveContainer.SHADOW_OPACITY, WaveContainer.APPEAR_DURATION, Easing.Out);
 
             toastTray.FlushAllToasts();
@@ -240,7 +240,7 @@ namespace osu.Game.Overlays
             markAllRead();
 
             this.MoveToX(WIDTH, TRANSITION_LENGTH, Easing.OutQuint);
-            mainContent.FadeTo(0, TRANSITION_LENGTH, Easing.OutQuint);
+            mainContent.FadeTo(0, TRANSITION_LENGTH / 2, Easing.OutQuint);
             mainContent.FadeEdgeEffectTo(0, WaveContainer.DISAPPEAR_DURATION, Easing.In);
         }
 

osu.Game/Overlays/NowPlayingOverlay.cs

@@ -29,7 +29,7 @@ namespace osu.Game.Overlays
 {
     public partial class NowPlayingOverlay : OsuFocusedOverlayContainer, INamedOverlayComponent
     {
-        public IconUsage Icon => HexaconsIcons.Music;
+        public IconUsage Icon => OsuIcon.Music;
         public LocalisableString Title => NowPlayingStrings.HeaderTitle;
         public LocalisableString Description => NowPlayingStrings.HeaderDescription;
 

osu.Game/Overlays/Profile/Header/TopHeaderContainer.cs

@@ -232,6 +232,14 @@ namespace osu.Game.Overlays.Profile.Header
             bool expanded = coverToggle.CoverExpanded.Value;
 
             cover.ResizeHeightTo(expanded ? 250 : 0, transition_duration, Easing.OutQuint);
+
+            // Without this a very tiny slither of the cover will be visible even with a size of zero.
+            // Integer masking woes, no doubt.
+            if (expanded)
+                cover.FadeIn(transition_duration, Easing.OutQuint);
+            else
+                cover.FadeOut(transition_duration, Easing.InQuint);
+
             avatar.ResizeTo(new Vector2(expanded ? 120 : content_height), transition_duration, Easing.OutQuint);
             avatar.TransformTo(nameof(avatar.CornerRadius), expanded ? 40f : 20f, transition_duration, Easing.OutQuint);
             flow.TransformTo(nameof(flow.Spacing), new Vector2(expanded ? 20f : 10f), transition_duration, Easing.OutQuint);

osu.Game/Overlays/Profile/ProfileHeader.cs

@@ -87,7 +87,7 @@ namespace osu.Game.Overlays.Profile
             public ProfileHeaderTitle()
             {
                 Title = PageTitleStrings.MainUsersControllerDefault;
-                Icon = HexaconsIcons.Profile;
+                Icon = OsuIcon.Player;
             }
         }
     }

osu.Game/Overlays/Rankings/RankingsOverlayHeader.cs

@@ -36,7 +36,7 @@ namespace osu.Game.Overlays.Rankings
             {
                 Title = PageTitleStrings.MainRankingControllerDefault;
                 Description = NamedOverlayComponentStrings.RankingsDescription;
-                Icon = HexaconsIcons.Rankings;
+                Icon = OsuIcon.Ranking;
             }
         }
     }

osu.Game/Overlays/Settings/Sections/Audio/AudioOffsetAdjustControl.cs

@@ -0,0 +1,160 @@
+// 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.Specialized;
+using System.Diagnostics;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Configuration;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Localisation;
+using osuTK;
+
+namespace osu.Game.Overlays.Settings.Sections.Audio
+{
+    public partial class AudioOffsetAdjustControl : SettingsItem<double>
+    {
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            LabelText = AudioSettingsStrings.AudioOffset;
+        }
+
+        protected override Drawable CreateControl() => new AudioOffsetPreview();
+
+        private partial class AudioOffsetPreview : CompositeDrawable, IHasCurrentValue<double>
+        {
+            public Bindable<double> Current
+            {
+                get => current.Current;
+                set => current.Current = value;
+            }
+
+            private readonly BindableNumberWithCurrent<double> current = new BindableNumberWithCurrent<double>();
+
+            private readonly IBindableList<double> averageHitErrorHistory = new BindableList<double>();
+
+            private readonly Bindable<double?> suggestedOffset = new Bindable<double?>();
+
+            private Container<Box> notchContainer = null!;
+            private TextFlowContainer hintText = null!;
+            private RoundedButton applySuggestion = null!;
+
+            [BackgroundDependencyLoader]
+            private void load(SessionAverageHitErrorTracker hitErrorTracker)
+            {
+                averageHitErrorHistory.BindTo(hitErrorTracker.AverageHitErrorHistory);
+
+                RelativeSizeAxes = Axes.X;
+                AutoSizeAxes = Axes.Y;
+                InternalChild = new FillFlowContainer
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Spacing = new Vector2(10),
+                    Direction = FillDirection.Vertical,
+                    Children = new Drawable[]
+                    {
+                        new TimeSlider
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            Current = { BindTarget = Current },
+                            KeyboardStep = 1,
+                        },
+                        notchContainer = new Container<Box>
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            Height = 10,
+                            Padding = new MarginPadding { Horizontal = Nub.DEFAULT_EXPANDED_SIZE / 2 },
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                        },
+                        hintText = new OsuTextFlowContainer(t => t.Font = OsuFont.Default.With(size: 16))
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                        },
+                        applySuggestion = new RoundedButton
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            Text = "Apply suggested offset",
+                            Action = () =>
+                            {
+                                if (suggestedOffset.Value.HasValue)
+                                    current.Value = suggestedOffset.Value.Value;
+                                hitErrorTracker.ClearHistory();
+                            }
+                        }
+                    }
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                averageHitErrorHistory.BindCollectionChanged(updateDisplay, true);
+                suggestedOffset.BindValueChanged(_ => updateHintText(), true);
+            }
+
+            private void updateDisplay(object? _, NotifyCollectionChangedEventArgs e)
+            {
+                switch (e.Action)
+                {
+                    case NotifyCollectionChangedAction.Add:
+                        foreach (double average in e.NewItems!)
+                        {
+                            notchContainer.ForEach(n => n.Alpha *= 0.95f);
+                            notchContainer.Add(new Box
+                            {
+                                RelativeSizeAxes = Axes.Y,
+                                Width = 2,
+                                RelativePositionAxes = Axes.X,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                X = getXPositionForAverage(average)
+                            });
+                        }
+
+                        break;
+
+                    case NotifyCollectionChangedAction.Remove:
+                        foreach (double average in e.OldItems!)
+                        {
+                            var notch = notchContainer.FirstOrDefault(n => n.X == getXPositionForAverage(average));
+                            Debug.Assert(notch != null);
+                            notchContainer.Remove(notch, true);
+                        }
+
+                        break;
+
+                    case NotifyCollectionChangedAction.Reset:
+                        notchContainer.Clear();
+                        break;
+                }
+
+                suggestedOffset.Value = averageHitErrorHistory.Any() ? -averageHitErrorHistory.Average() : null;
+            }
+
+            private float getXPositionForAverage(double average) => (float)(Math.Clamp(-average, current.MinValue, current.MaxValue) / (2 * current.MaxValue));
+
+            private void updateHintText()
+            {
+                hintText.Text = suggestedOffset.Value == null
+                    ? @"Play a few beatmaps to receive a suggested offset!"
+                    : $@"Based on the last {averageHitErrorHistory.Count} play(s), the suggested offset is {suggestedOffset.Value:N0} ms.";
+                applySuggestion.Enabled.Value = suggestedOffset.Value != null;
+            }
+        }
+    }
+}

osu.Game/Overlays/Settings/Sections/Audio/OffsetSettings.cs

@@ -7,7 +7,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
-using osu.Game.Graphics.UserInterface;
 using osu.Game.Localisation;
 
 namespace osu.Game.Overlays.Settings.Sections.Audio
@@ -16,23 +15,17 @@ namespace osu.Game.Overlays.Settings.Sections.Audio
     {
         protected override LocalisableString Header => AudioSettingsStrings.OffsetHeader;
 
-        public override IEnumerable<LocalisableString> FilterTerms => base.FilterTerms.Concat(new LocalisableString[] { "universal", "uo", "timing", "delay", "latency" });
+        public override IEnumerable<LocalisableString> FilterTerms => base.FilterTerms.Concat(new LocalisableString[] { "universal", "uo", "timing", "delay", "latency", "wizard" });
 
         [BackgroundDependencyLoader]
         private void load(OsuConfigManager config)
         {
             Children = new Drawable[]
             {
-                new SettingsSlider<double, TimeSlider>
+                new AudioOffsetAdjustControl
                 {
-                    LabelText = AudioSettingsStrings.AudioOffset,
                     Current = config.GetBindable<double>(OsuSetting.AudioOffset),
-                    KeyboardStep = 1f
                 },
-                new SettingsButton
-                {
-                    Text = AudioSettingsStrings.OffsetWizard
-                }
             };
         }
     }

osu.Game/Overlays/Settings/Sections/AudioSection.cs

@@ -6,6 +6,7 @@ using System.Linq;
 using osu.Framework.Localisation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
+using osu.Game.Graphics;
 using osu.Game.Localisation;
 using osu.Game.Overlays.Settings.Sections.Audio;
 
@@ -17,7 +18,7 @@ namespace osu.Game.Overlays.Settings.Sections
 
         public override Drawable CreateIcon() => new SpriteIcon
         {
-            Icon = FontAwesome.Solid.VolumeUp
+            Icon = OsuIcon.Audio
         };
 
         public override IEnumerable<LocalisableString> FilterTerms => base.FilterTerms.Concat(new LocalisableString[] { "sound" });

osu.Game/Overlays/Settings/Sections/DebugSection.cs

@@ -5,6 +5,7 @@ using osu.Framework.Development;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Localisation;
 using osu.Game.Overlays.Settings.Sections.DebugSettings;
 
@@ -16,7 +17,7 @@ namespace osu.Game.Overlays.Settings.Sections
 
         public override Drawable CreateIcon() => new SpriteIcon
         {
-            Icon = FontAwesome.Solid.Bug
+            Icon = OsuIcon.Debug
         };
 
         public DebugSection()

osu.Game/Overlays/Settings/Sections/GameplaySection.cs

@@ -4,6 +4,7 @@
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Localisation;
 using osu.Game.Overlays.Settings.Sections.Gameplay;
 
@@ -15,7 +16,7 @@ namespace osu.Game.Overlays.Settings.Sections
 
         public override Drawable CreateIcon() => new SpriteIcon
         {
-            Icon = FontAwesome.Regular.DotCircle
+            Icon = OsuIcon.GameplayC
         };
 
         public GameplaySection()

osu.Game/Overlays/Settings/Sections/GeneralSection.cs

@@ -23,7 +23,7 @@ namespace osu.Game.Overlays.Settings.Sections
 
         public override Drawable CreateIcon() => new SpriteIcon
         {
-            Icon = FontAwesome.Solid.Cog
+            Icon = OsuIcon.Settings
         };
 
         [BackgroundDependencyLoader]

osu.Game/Overlays/Settings/Sections/GraphicsSection.cs

@@ -4,6 +4,7 @@
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Localisation;
 using osu.Game.Overlays.Settings.Sections.Graphics;
 
@@ -15,7 +16,7 @@ namespace osu.Game.Overlays.Settings.Sections
 
         public override Drawable CreateIcon() => new SpriteIcon
         {
-            Icon = FontAwesome.Solid.Laptop
+            Icon = OsuIcon.Graphics
         };
 
         public GraphicsSection()

osu.Game/Overlays/Settings/Sections/InputSection.cs

@@ -7,6 +7,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Handlers;
 using osu.Framework.Localisation;
 using osu.Framework.Platform;
+using osu.Game.Graphics;
 using osu.Game.Localisation;
 using osu.Game.Overlays.Settings.Sections.Input;
 
@@ -20,7 +21,7 @@ namespace osu.Game.Overlays.Settings.Sections
 
         public override Drawable CreateIcon() => new SpriteIcon
         {
-            Icon = FontAwesome.Solid.Keyboard
+            Icon = OsuIcon.Input
         };
 
         public InputSection(KeyBindingPanel keyConfig)

osu.Game/Overlays/Settings/Sections/MaintenanceSection.cs

@@ -4,6 +4,7 @@
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Localisation;
 using osu.Game.Overlays.Settings.Sections.Maintenance;
 
@@ -15,7 +16,7 @@ namespace osu.Game.Overlays.Settings.Sections
 
         public override Drawable CreateIcon() => new SpriteIcon
         {
-            Icon = FontAwesome.Solid.Wrench
+            Icon = OsuIcon.Maintenance
         };
 
         public MaintenanceSection()

osu.Game/Overlays/Settings/Sections/OnlineSection.cs

@@ -4,6 +4,7 @@
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Localisation;
 using osu.Game.Overlays.Settings.Sections.Online;
 
@@ -15,7 +16,7 @@ namespace osu.Game.Overlays.Settings.Sections
 
         public override Drawable CreateIcon() => new SpriteIcon
         {
-            Icon = FontAwesome.Solid.GlobeAsia
+            Icon = OsuIcon.Online
         };
 
         public OnlineSection()

osu.Game/Overlays/Settings/Sections/RulesetSection.cs

@@ -7,6 +7,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Framework.Logging;
+using osu.Game.Graphics;
 using osu.Game.Localisation;
 using osu.Game.Rulesets;
 
@@ -18,7 +19,7 @@ namespace osu.Game.Overlays.Settings.Sections
 
         public override Drawable CreateIcon() => new SpriteIcon
         {
-            Icon = FontAwesome.Solid.Chess
+            Icon = OsuIcon.Rulesets
         };
 
         [BackgroundDependencyLoader]

osu.Game/Overlays/Settings/Sections/SkinSection.cs

@@ -14,6 +14,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Framework.Logging;
 using osu.Game.Database;
+using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Localisation;
 using osu.Game.Overlays.SkinEditor;
@@ -31,7 +32,7 @@ namespace osu.Game.Overlays.Settings.Sections
 
         public override Drawable CreateIcon() => new SpriteIcon
         {
-            Icon = FontAwesome.Solid.PaintBrush
+            Icon = OsuIcon.SkinB
         };
 
         private static readonly Live<SkinInfo> random_skin_info = new SkinInfo

osu.Game/Overlays/Settings/Sections/UserInterface/MainMenuSettings.cs

@@ -29,6 +29,11 @@ namespace osu.Game.Overlays.Settings.Sections.UserInterface
 
             Children = new Drawable[]
             {
+                new SettingsCheckbox
+                {
+                    LabelText = UserInterfaceStrings.ShowMenuTips,
+                    Current = config.GetBindable<bool>(OsuSetting.MenuTips)
+                },
                 new SettingsCheckbox
                 {
                     LabelText = UserInterfaceStrings.InterfaceVoices,

osu.Game/Overlays/Settings/Sections/UserInterfaceSection.cs

@@ -4,6 +4,7 @@
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Localisation;
 using osu.Game.Overlays.Settings.Sections.UserInterface;
 
@@ -15,7 +16,7 @@ namespace osu.Game.Overlays.Settings.Sections
 
         public override Drawable CreateIcon() => new SpriteIcon
         {
-            Icon = FontAwesome.Solid.LayerGroup
+            Icon = OsuIcon.UserInterface
         };
 
         public UserInterfaceSection()

osu.Game/Overlays/Settings/SettingsSidebar.cs

@@ -1,21 +1,36 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osuTK;
 
 namespace osu.Game.Overlays.Settings
 {
-    public partial class SettingsSidebar : ExpandingButtonContainer
+    public partial class SettingsSidebar : ExpandingContainer
     {
-        public const float DEFAULT_WIDTH = 70;
+        public const float CONTRACTED_WIDTH = 70;
-        public const int EXPANDED_WIDTH = 200;
+        public const int EXPANDED_WIDTH = 170;
 
-        public SettingsSidebar()
+        public Action? BackButtonAction;
-            : base(DEFAULT_WIDTH, EXPANDED_WIDTH)
+
+        protected override bool ExpandOnHover => false;
+
+        private readonly bool showBackButton;
+
+        public SettingsSidebar(bool showBackButton)
+            : base(CONTRACTED_WIDTH, EXPANDED_WIDTH)
         {
+            this.showBackButton = showBackButton;
+            Expanded.Value = true;
         }
 
         [BackgroundDependencyLoader]
@@ -27,6 +42,71 @@ namespace osu.Game.Overlays.Settings
                 RelativeSizeAxes = Axes.Both,
                 Depth = float.MaxValue
             });
+
+            if (showBackButton)
+            {
+                AddInternal(new BackButton
+                {
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.BottomCentre,
+                    Action = () => BackButtonAction?.Invoke(),
+                });
+            }
+        }
+
+        public partial class BackButton : SidebarButton
+        {
+            private Drawable content = null!;
+
+            public BackButton()
+                : base(HoverSampleSet.Default)
+            {
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                Size = new Vector2(SettingsSidebar.EXPANDED_WIDTH);
+
+                Padding = new MarginPadding(40);
+
+                AddRange(new[]
+                {
+                    content = new FillFlowContainer
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Direction = FillDirection.Vertical,
+                        AutoSizeAxes = Axes.Both,
+                        Spacing = new Vector2(5),
+                        Children = new Drawable[]
+                        {
+                            new SpriteIcon
+                            {
+                                Anchor = Anchor.TopCentre,
+                                Origin = Anchor.TopCentre,
+                                Size = new Vector2(30),
+                                Shadow = true,
+                                Icon = FontAwesome.Solid.ChevronLeft
+                            },
+                            new OsuSpriteText
+                            {
+                                Anchor = Anchor.TopCentre,
+                                Origin = Anchor.TopCentre,
+                                Font = OsuFont.GetFont(size: 16, weight: FontWeight.Regular),
+                                Text = @"back",
+                            },
+                        }
+                    }
+                });
+            }
+
+            protected override void UpdateState()
+            {
+                base.UpdateState();
+
+                content.FadeColour(IsHovered ? ColourProvider.Light1 : ColourProvider.Light3, FADE_DURATION, Easing.OutQuint);
+            }
         }
     }
 }

osu.Game/Overlays/Settings/SidebarButton.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
+using osu.Framework.Graphics;
 using osu.Framework.Input.Events;
 using osu.Game.Graphics.UserInterface;
 
@@ -23,6 +24,7 @@ namespace osu.Game.Overlays.Settings
         private void load()
         {
             BackgroundColour = ColourProvider.Background5;
+            Hover.Colour = ColourProvider.Light4;
         }
 
         protected override void LoadComplete()
@@ -40,6 +42,9 @@ namespace osu.Game.Overlays.Settings
 
         protected override void OnHoverLost(HoverLostEvent e) => UpdateState();
 
-        protected abstract void UpdateState();
+        protected virtual void UpdateState()
+        {
+            Hover.FadeTo(IsHovered ? 0.1f : 0, FADE_DURATION, Easing.OutQuint);
+        }
     }
 }

osu.Game/Overlays/Settings/SidebarIconButton.cs

@@ -60,26 +60,28 @@ namespace osu.Game.Overlays.Settings
             RelativeSizeAxes = Axes.X;
             Height = 46;
 
+            Padding = new MarginPadding(5);
+
             AddRange(new Drawable[]
             {
                 textIconContent = new Container
                 {
-                    Width = SettingsSidebar.DEFAULT_WIDTH,
+                    RelativeSizeAxes = Axes.Both,
-                    RelativeSizeAxes = Axes.Y,
                     Colour = OsuColour.Gray(0.6f),
                     Children = new Drawable[]
                     {
-                        headerText = new OsuSpriteText
-                        {
-                            Position = new Vector2(SettingsSidebar.DEFAULT_WIDTH + 10, 0),
-                            Anchor = Anchor.CentreLeft,
-                            Origin = Anchor.CentreLeft,
-                        },
                         iconContainer = new ConstrainedIconContainer
                         {
-                            Anchor = Anchor.Centre,
+                            Anchor = Anchor.CentreLeft,
-                            Origin = Anchor.Centre,
+                            Origin = Anchor.CentreLeft,
                             Size = new Vector2(20),
+                            Margin = new MarginPadding { Left = 25 }
+                        },
+                        headerText = new OsuSpriteText
+                        {
+                            Position = new Vector2(60, 0),
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
                         },
                     }
                 },
@@ -113,6 +115,8 @@ namespace osu.Game.Overlays.Settings
 
         protected override void UpdateState()
         {
+            base.UpdateState();
+
             if (Selected)
             {
                 textIconContent.FadeColour(ColourProvider.Content1, FADE_DURATION, Easing.OutQuint);