Merge branch 'master' into lounge-redesign

.config/dotnet-tools.json

@@ -27,7 +27,7 @@
       ]
     },
     "ppy.localisationanalyser.tools": {
-      "version": "2021.608.0",
+      "version": "2021.705.0",
       "commands": [
         "localisation"
       ]

README.md

@@ -11,7 +11,7 @@
 
 A free-to-win rhythm game. Rhythm is just a *click* away!
 
-The future of [osu!](https://osu.ppy.sh) and the beginning of an open era! Commonly known by the codename *osu!lazer*. Pew pew.
+The future of [osu!](https://osu.ppy.sh) and the beginning of an open era! Currently known by and released under the codename "*lazer*". As in sharper than cutting-edge.
 
 ## Status
 
@@ -23,7 +23,7 @@ We are accepting bug reports (please report with as much detail as possible and
 
 - Detailed release changelogs are available on the [official osu! site](https://osu.ppy.sh/home/changelog/lazer).
 - You can learn more about our approach to [project management](https://github.com/ppy/osu/wiki/Project-management).
-- Read peppy's [latest blog post](https://blog.ppy.sh/a-definitive-lazer-faq/) exploring where lazer is currently and the roadmap going forward.
+- Read peppy's [latest blog post](https://blog.ppy.sh/a-definitive-lazer-faq/) exploring where the project is currently and the roadmap going forward.
 
 ## Running osu!
 

osu.Android.props

@@ -51,8 +51,8 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.701.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.702.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.706.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.707.0" />
   </ItemGroup>
   <ItemGroup Label="Transitive Dependencies">
     <!-- Realm needs to be directly referenced in all Xamarin projects, as it will not pull in its transitive dependencies otherwise. -->

osu.Game.Rulesets.Catch/Edit/Blueprints/CatchPlacementBlueprint.cs

@@ -6,6 +6,7 @@ using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Edit.Blueprints
 {
@@ -23,5 +24,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
             : base(new THitObject())
         {
         }
+
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
     }
 }

osu.Game.Rulesets.Catch/Edit/Blueprints/CatchSelectionBlueprint.cs

@@ -13,6 +13,8 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
     public abstract class CatchSelectionBlueprint<THitObject> : HitObjectSelectionBlueprint<THitObject>
         where THitObject : CatchHitObject
     {
+        protected override bool AlwaysShowWhenSelected => true;
+
         public override Vector2 ScreenSpaceSelectionPoint
         {
             get

osu.Game.Rulesets.Catch/Edit/Blueprints/Components/FruitOutline.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -18,7 +19,6 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints.Components
         {
             Anchor = Anchor.BottomLeft;
             Origin = Anchor.Centre;
-            Size = new Vector2(2 * CatchHitObject.OBJECT_RADIUS);
             InternalChild = new BorderPiece();
         }
 
@@ -28,10 +28,10 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints.Components
             Colour = osuColour.Yellow;
         }
 
-        public void UpdateFrom(ScrollingHitObjectContainer hitObjectContainer, CatchHitObject hitObject)
+        public void UpdateFrom(ScrollingHitObjectContainer hitObjectContainer, CatchHitObject hitObject, [CanBeNull] CatchHitObject parent = null)
         {
-            X = hitObject.EffectiveX;
-            Y = hitObjectContainer.PositionAtTime(hitObject.StartTime);
+            X = hitObject.EffectiveX - (parent?.OriginalX ?? 0);
+            Y = hitObjectContainer.PositionAtTime(hitObject.StartTime, parent?.StartTime ?? hitObjectContainer.Time.Current);
             Scale = new Vector2(hitObject.Scale);
         }
     }

osu.Game.Rulesets.Catch/Edit/Blueprints/Components/NestedOutlineContainer.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 System.Linq;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.UI.Scrolling;
+
+namespace osu.Game.Rulesets.Catch.Edit.Blueprints.Components
+{
+    public class NestedOutlineContainer : CompositeDrawable
+    {
+        private readonly List<CatchHitObject> nestedHitObjects = new List<CatchHitObject>();
+
+        public NestedOutlineContainer()
+        {
+            Anchor = Anchor.BottomLeft;
+        }
+
+        public void UpdatePositionFrom(ScrollingHitObjectContainer hitObjectContainer, CatchHitObject parentHitObject)
+        {
+            X = parentHitObject.OriginalX;
+            Y = hitObjectContainer.PositionAtTime(parentHitObject.StartTime);
+        }
+
+        public void UpdateNestedObjectsFrom(ScrollingHitObjectContainer hitObjectContainer, CatchHitObject parentHitObject)
+        {
+            nestedHitObjects.Clear();
+            nestedHitObjects.AddRange(parentHitObject.NestedHitObjects
+                                                     .OfType<CatchHitObject>()
+                                                     .Where(h => !(h is TinyDroplet)));
+
+            while (nestedHitObjects.Count < InternalChildren.Count)
+                RemoveInternal(InternalChildren[^1]);
+
+            while (InternalChildren.Count < nestedHitObjects.Count)
+                AddInternal(new FruitOutline());
+
+            for (int i = 0; i < nestedHitObjects.Count; i++)
+            {
+                var hitObject = nestedHitObjects[i];
+                var outline = (FruitOutline)InternalChildren[i];
+                outline.UpdateFrom(hitObjectContainer, hitObject, parentHitObject);
+                outline.Scale *= hitObject is Droplet ? 0.5f : 1;
+            }
+        }
+
+        protected override bool ComputeIsMaskedAway(RectangleF maskingBounds) => false;
+    }
+}

osu.Game.Rulesets.Catch/Edit/Blueprints/Components/ScrollingPath.cs

@@ -0,0 +1,83 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Lines;
+using osu.Framework.Graphics.Primitives;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.UI.Scrolling;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Edit.Blueprints.Components
+{
+    public class ScrollingPath : CompositeDrawable
+    {
+        private readonly Path drawablePath;
+
+        private readonly List<(double Distance, float X)> vertices = new List<(double, float)>();
+
+        public ScrollingPath()
+        {
+            Anchor = Anchor.BottomLeft;
+
+            InternalChildren = new Drawable[]
+            {
+                drawablePath = new SmoothPath
+                {
+                    PathRadius = 2,
+                    Alpha = 0.5f
+                },
+            };
+        }
+
+        public void UpdatePositionFrom(ScrollingHitObjectContainer hitObjectContainer, CatchHitObject hitObject)
+        {
+            X = hitObject.OriginalX;
+            Y = hitObjectContainer.PositionAtTime(hitObject.StartTime);
+        }
+
+        public void UpdatePathFrom(ScrollingHitObjectContainer hitObjectContainer, JuiceStream hitObject)
+        {
+            double distanceToYFactor = -hitObjectContainer.LengthAtTime(hitObject.StartTime, hitObject.StartTime + 1 / hitObject.Velocity);
+
+            computeDistanceXs(hitObject);
+            drawablePath.Vertices = vertices
+                                    .Select(v => new Vector2(v.X, (float)(v.Distance * distanceToYFactor)))
+                                    .ToArray();
+            drawablePath.OriginPosition = drawablePath.PositionInBoundingBox(Vector2.Zero);
+        }
+
+        private void computeDistanceXs(JuiceStream hitObject)
+        {
+            vertices.Clear();
+
+            var sliderVertices = new List<Vector2>();
+            hitObject.Path.GetPathToProgress(sliderVertices, 0, 1);
+
+            if (sliderVertices.Count == 0)
+                return;
+
+            double distance = 0;
+            Vector2 lastPosition = Vector2.Zero;
+
+            for (int repeat = 0; repeat < hitObject.RepeatCount + 1; repeat++)
+            {
+                foreach (var position in sliderVertices)
+                {
+                    distance += Vector2.Distance(lastPosition, position);
+                    lastPosition = position;
+
+                    vertices.Add((distance, position.X));
+                }
+
+                sliderVertices.Reverse();
+            }
+        }
+
+        // Because this has 0x0 size, the contents are otherwise masked away if the start position is outside the screen.
+        protected override bool ComputeIsMaskedAway(RectangleF maskingBounds) => false;
+    }
+}

osu.Game.Rulesets.Catch/Edit/Blueprints/JuiceStreamSelectionBlueprint.cs

@@ -3,7 +3,10 @@
 
 using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Caching;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Primitives;
+using osu.Game.Rulesets.Catch.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Objects;
 using osuTK;
@@ -17,9 +20,20 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
         private float minNestedX;
         private float maxNestedX;
 
+        private readonly ScrollingPath scrollingPath;
+
+        private readonly NestedOutlineContainer nestedOutlineContainer;
+
+        private readonly Cached pathCache = new Cached();
+
         public JuiceStreamSelectionBlueprint(JuiceStream hitObject)
             : base(hitObject)
         {
+            InternalChildren = new Drawable[]
+            {
+                scrollingPath = new ScrollingPath(),
+                nestedOutlineContainer = new NestedOutlineContainer()
+            };
         }
 
         [BackgroundDependencyLoader]
@@ -29,7 +43,28 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
             computeObjectBounds();
         }
 
-        private void onDefaultsApplied(HitObject _) => computeObjectBounds();
+        protected override void Update()
+        {
+            base.Update();
+
+            if (!IsSelected) return;
+
+            scrollingPath.UpdatePositionFrom(HitObjectContainer, HitObject);
+            nestedOutlineContainer.UpdatePositionFrom(HitObjectContainer, HitObject);
+
+            if (pathCache.IsValid) return;
+
+            scrollingPath.UpdatePathFrom(HitObjectContainer, HitObject);
+            nestedOutlineContainer.UpdateNestedObjectsFrom(HitObjectContainer, HitObject);
+
+            pathCache.Validate();
+        }
+
+        private void onDefaultsApplied(HitObject _)
+        {
+            computeObjectBounds();
+            pathCache.Invalidate();
+        }
 
         private void computeObjectBounds()
         {

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

@@ -2,6 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Edit;
@@ -20,6 +22,16 @@ namespace osu.Game.Rulesets.Catch.Edit
         {
         }
 
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            LayerBelowRuleset.Add(new PlayfieldBorder
+            {
+                RelativeSizeAxes = Axes.Both,
+                PlayfieldBorderStyle = { Value = PlayfieldBorderStyle.Corners }
+            });
+        }
+
         protected override DrawableRuleset<CatchHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods = null) =>
             new DrawableCatchEditorRuleset(ruleset, beatmap, mods);
 

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

@@ -1,9 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
@@ -24,15 +27,20 @@ namespace osu.Game.Rulesets.Catch.Edit
             var blueprint = moveEvent.Blueprint;
             Vector2 originalPosition = HitObjectContainer.ToLocalSpace(blueprint.ScreenSpaceSelectionPoint);
             Vector2 targetPosition = HitObjectContainer.ToLocalSpace(blueprint.ScreenSpaceSelectionPoint + moveEvent.ScreenSpaceDelta);
+
             float deltaX = targetPosition.X - originalPosition.X;
+            deltaX = limitMovement(deltaX, EditorBeatmap.SelectedHitObjects);
+
+            if (deltaX == 0)
+            {
+                // Even if there is no positional change, there may be a time change.
+                return true;
+            }
 
             EditorBeatmap.PerformOnSelection(h =>
             {
                 if (!(h is CatchHitObject hitObject)) return;
 
-                if (hitObject is BananaShower) return;
-
-                // TODO: confine in bounds
                 hitObject.OriginalX += deltaX;
 
                 // Move the nested hit objects to give an instant result before nested objects are recreated.
@@ -42,5 +50,67 @@ namespace osu.Game.Rulesets.Catch.Edit
 
             return true;
         }
+
+        /// <summary>
+        /// Limit positional movement of the objects by the constraint that moved objects should stay in bounds.
+        /// </summary>
+        /// <param name="deltaX">The positional movement.</param>
+        /// <param name="movingObjects">The objects to be moved.</param>
+        /// <returns>The positional movement with the restriction applied.</returns>
+        private float limitMovement(float deltaX, IEnumerable<HitObject> movingObjects)
+        {
+            float minX = float.PositiveInfinity;
+            float maxX = float.NegativeInfinity;
+
+            foreach (float x in movingObjects.SelectMany(getOriginalPositions))
+            {
+                minX = Math.Min(minX, x);
+                maxX = Math.Max(maxX, x);
+            }
+
+            // To make an object with position `x` stay in bounds after `deltaX` movement, `0 <= x + deltaX <= WIDTH` should be satisfied.
+            // Subtracting `x`, we get `-x <= deltaX <= WIDTH - x`.
+            // We only need to apply the inequality to extreme values of `x`.
+            float lowerBound = -minX;
+            float upperBound = CatchPlayfield.WIDTH - maxX;
+            // The inequality may be unsatisfiable if the objects were already out of bounds.
+            // In that case, don't move objects at all.
+            if (lowerBound > upperBound)
+                return 0;
+
+            return Math.Clamp(deltaX, lowerBound, upperBound);
+        }
+
+        /// <summary>
+        /// Enumerate X positions that should be contained in-bounds after move offset is applied.
+        /// </summary>
+        private IEnumerable<float> getOriginalPositions(HitObject hitObject)
+        {
+            switch (hitObject)
+            {
+                case Fruit fruit:
+                    yield return fruit.OriginalX;
+
+                    break;
+
+                case JuiceStream juiceStream:
+                    foreach (var nested in juiceStream.NestedHitObjects.OfType<CatchHitObject>())
+                    {
+                        // Even if `OriginalX` is outside the playfield, tiny droplets can be moved inside the playfield after the random offset application.
+                        if (!(nested is TinyDroplet))
+                            yield return nested.OriginalX;
+                    }
+
+                    break;
+
+                case BananaShower _:
+                    // A banana shower occupies the whole screen width.
+                    // If the selection contains a banana shower, the selection cannot be moved horizontally.
+                    yield return 0;
+                    yield return CatchPlayfield.WIDTH;
+
+                    break;
+            }
+        }
     }
 }

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

@@ -12,37 +12,29 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
     public class CatchModDifficultyAdjust : ModDifficultyAdjust, IApplicableToBeatmapProcessor
     {
-        [SettingSource("Circle Size", "Override a beatmap's set CS.", FIRST_SETTING_ORDER - 1)]
-        public BindableNumber<float> CircleSize { get; } = new BindableFloatWithLimitExtension
+        [SettingSource("Circle Size", "Override a beatmap's set CS.", FIRST_SETTING_ORDER - 1, SettingControlType = typeof(DifficultyAdjustSettingsControl))]
+        public DifficultyBindable CircleSize { get; } = new DifficultyBindable
         {
             Precision = 0.1f,
             MinValue = 1,
             MaxValue = 10,
-            Default = 5,
-            Value = 5,
+            ExtendedMaxValue = 11,
+            ReadCurrentFromDifficulty = diff => diff.CircleSize,
         };
 
-        [SettingSource("Approach Rate", "Override a beatmap's set AR.", LAST_SETTING_ORDER + 1)]
-        public BindableNumber<float> ApproachRate { get; } = new BindableFloatWithLimitExtension
+        [SettingSource("Approach Rate", "Override a beatmap's set AR.", LAST_SETTING_ORDER + 1, SettingControlType = typeof(DifficultyAdjustSettingsControl))]
+        public DifficultyBindable ApproachRate { get; } = new DifficultyBindable
         {
             Precision = 0.1f,
             MinValue = 1,
             MaxValue = 10,
-            Default = 5,
-            Value = 5,
+            ExtendedMaxValue = 11,
+            ReadCurrentFromDifficulty = diff => diff.ApproachRate,
         };
 
         [SettingSource("Spicy Patterns", "Adjust the patterns as if Hard Rock is enabled.")]
         public BindableBool HardRockOffsets { get; } = new BindableBool();
 
-        protected override void ApplyLimits(bool extended)
-        {
-            base.ApplyLimits(extended);
-
-            CircleSize.MaxValue = extended ? 11 : 10;
-            ApproachRate.MaxValue = extended ? 11 : 10;
-        }
-
         public override string SettingDescription
         {
             get
@@ -61,20 +53,12 @@ namespace osu.Game.Rulesets.Catch.Mods
             }
         }
 
-        protected override void TransferSettings(BeatmapDifficulty difficulty)
-        {
-            base.TransferSettings(difficulty);
-
-            TransferSetting(CircleSize, difficulty.CircleSize);
-            TransferSetting(ApproachRate, difficulty.ApproachRate);
-        }
-
         protected override void ApplySettings(BeatmapDifficulty difficulty)
         {
             base.ApplySettings(difficulty);
 
-            ApplySetting(CircleSize, cs => difficulty.CircleSize = cs);
-            ApplySetting(ApproachRate, ar => difficulty.ApproachRate = ar);
+            if (CircleSize.Value != null) difficulty.CircleSize = CircleSize.Value.Value;
+            if (ApproachRate.Value != null) difficulty.ApproachRate = ApproachRate.Value.Value;
         }
 
         public void ApplyToBeatmapProcessor(IBeatmapProcessor beatmapProcessor)

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

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Linq;
-using osu.Framework.Bindables;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Mods;
@@ -11,34 +10,26 @@ namespace osu.Game.Rulesets.Osu.Mods
 {
     public class OsuModDifficultyAdjust : ModDifficultyAdjust
     {
-        [SettingSource("Circle Size", "Override a beatmap's set CS.", FIRST_SETTING_ORDER - 1)]
-        public BindableNumber<float> CircleSize { get; } = new BindableFloatWithLimitExtension
+        [SettingSource("Circle Size", "Override a beatmap's set CS.", FIRST_SETTING_ORDER - 1, SettingControlType = typeof(DifficultyAdjustSettingsControl))]
+        public DifficultyBindable CircleSize { get; } = new DifficultyBindable
         {
             Precision = 0.1f,
             MinValue = 0,
             MaxValue = 10,
-            Default = 5,
-            Value = 5,
+            ExtendedMaxValue = 11,
+            ReadCurrentFromDifficulty = diff => diff.CircleSize,
         };
 
-        [SettingSource("Approach Rate", "Override a beatmap's set AR.", LAST_SETTING_ORDER + 1)]
-        public BindableNumber<float> ApproachRate { get; } = new BindableFloatWithLimitExtension
+        [SettingSource("Approach Rate", "Override a beatmap's set AR.", LAST_SETTING_ORDER + 1, SettingControlType = typeof(DifficultyAdjustSettingsControl))]
+        public DifficultyBindable ApproachRate { get; } = new DifficultyBindable
         {
             Precision = 0.1f,
             MinValue = 0,
             MaxValue = 10,
-            Default = 5,
-            Value = 5,
+            ExtendedMaxValue = 11,
+            ReadCurrentFromDifficulty = diff => diff.ApproachRate,
         };
 
-        protected override void ApplyLimits(bool extended)
-        {
-            base.ApplyLimits(extended);
-
-            CircleSize.MaxValue = extended ? 11 : 10;
-            ApproachRate.MaxValue = extended ? 11 : 10;
-        }
-
         public override string SettingDescription
         {
             get
@@ -55,20 +46,12 @@ namespace osu.Game.Rulesets.Osu.Mods
             }
         }
 
-        protected override void TransferSettings(BeatmapDifficulty difficulty)
-        {
-            base.TransferSettings(difficulty);
-
-            TransferSetting(CircleSize, difficulty.CircleSize);
-            TransferSetting(ApproachRate, difficulty.ApproachRate);
-        }
-
         protected override void ApplySettings(BeatmapDifficulty difficulty)
         {
             base.ApplySettings(difficulty);
 
-            ApplySetting(CircleSize, cs => difficulty.CircleSize = cs);
-            ApplySetting(ApproachRate, ar => difficulty.ApproachRate = ar);
+            if (CircleSize.Value != null) difficulty.CircleSize = CircleSize.Value.Value;
+            if (ApproachRate.Value != null) difficulty.ApproachRate = ApproachRate.Value.Value;
         }
     }
 }

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

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Linq;
-using osu.Framework.Bindables;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Mods;
@@ -11,14 +10,13 @@ namespace osu.Game.Rulesets.Taiko.Mods
 {
     public class TaikoModDifficultyAdjust : ModDifficultyAdjust
     {
-        [SettingSource("Scroll Speed", "Adjust a beatmap's set scroll speed", LAST_SETTING_ORDER + 1)]
-        public BindableNumber<float> ScrollSpeed { get; } = new BindableFloat
+        [SettingSource("Scroll Speed", "Adjust a beatmap's set scroll speed", LAST_SETTING_ORDER + 1, SettingControlType = typeof(DifficultyAdjustSettingsControl))]
+        public DifficultyBindable ScrollSpeed { get; } = new DifficultyBindable
         {
             Precision = 0.05f,
             MinValue = 0.25f,
             MaxValue = 4,
-            Default = 1,
-            Value = 1,
+            ReadCurrentFromDifficulty = _ => 1,
         };
 
         public override string SettingDescription
@@ -39,7 +37,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
         {
             base.ApplySettings(difficulty);
 
-            ApplySetting(ScrollSpeed, scroll => difficulty.SliderMultiplier *= scroll);
+            if (ScrollSpeed.Value != null) difficulty.SliderMultiplier *= ScrollSpeed.Value.Value;
         }
     }
 }

osu.Game.Tests/Mods/ModDifficultyAdjustTest.cs

@@ -0,0 +1,165 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Online.API;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Tests.Mods
+{
+    [TestFixture]
+    public class ModDifficultyAdjustTest
+    {
+        private TestModDifficultyAdjust testMod;
+
+        [SetUp]
+        public void Setup()
+        {
+            testMod = new TestModDifficultyAdjust();
+        }
+
+        [Test]
+        public void TestUnchangedSettingsFollowAppliedDifficulty()
+        {
+            var result = applyDifficulty(new BeatmapDifficulty
+            {
+                DrainRate = 10,
+                OverallDifficulty = 10
+            });
+
+            Assert.That(result.DrainRate, Is.EqualTo(10));
+            Assert.That(result.OverallDifficulty, Is.EqualTo(10));
+
+            result = applyDifficulty(new BeatmapDifficulty
+            {
+                DrainRate = 1,
+                OverallDifficulty = 1
+            });
+
+            Assert.That(result.DrainRate, Is.EqualTo(1));
+            Assert.That(result.OverallDifficulty, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void TestChangedSettingsOverrideAppliedDifficulty()
+        {
+            testMod.OverallDifficulty.Value = 4;
+
+            var result = applyDifficulty(new BeatmapDifficulty
+            {
+                DrainRate = 10,
+                OverallDifficulty = 10
+            });
+
+            Assert.That(result.DrainRate, Is.EqualTo(10));
+            Assert.That(result.OverallDifficulty, Is.EqualTo(4));
+
+            result = applyDifficulty(new BeatmapDifficulty
+            {
+                DrainRate = 1,
+                OverallDifficulty = 1
+            });
+
+            Assert.That(result.DrainRate, Is.EqualTo(1));
+            Assert.That(result.OverallDifficulty, Is.EqualTo(4));
+        }
+
+        [Test]
+        public void TestChangedSettingsRetainedWhenSameValueIsApplied()
+        {
+            testMod.OverallDifficulty.Value = 4;
+
+            // Apply and de-apply the same value as the mod.
+            applyDifficulty(new BeatmapDifficulty { OverallDifficulty = 4 });
+            var result = applyDifficulty(new BeatmapDifficulty { OverallDifficulty = 10 });
+
+            Assert.That(result.OverallDifficulty, Is.EqualTo(4));
+        }
+
+        [Test]
+        public void TestChangedSettingSerialisedWhenSameValueIsApplied()
+        {
+            applyDifficulty(new BeatmapDifficulty { OverallDifficulty = 4 });
+            testMod.OverallDifficulty.Value = 4;
+
+            var result = (TestModDifficultyAdjust)new APIMod(testMod).ToMod(new TestRuleset());
+
+            Assert.That(result.OverallDifficulty.Value, Is.EqualTo(4));
+        }
+
+        [Test]
+        public void TestChangedSettingsRevertedToDefault()
+        {
+            applyDifficulty(new BeatmapDifficulty
+            {
+                DrainRate = 10,
+                OverallDifficulty = 10
+            });
+
+            testMod.OverallDifficulty.Value = 4;
+            testMod.ResetSettingsToDefaults();
+
+            Assert.That(testMod.DrainRate.Value, Is.Null);
+            Assert.That(testMod.OverallDifficulty.Value, Is.Null);
+
+            var applied = applyDifficulty(new BeatmapDifficulty
+            {
+                DrainRate = 10,
+                OverallDifficulty = 10
+            });
+
+            Assert.That(applied.OverallDifficulty, Is.EqualTo(10));
+        }
+
+        /// <summary>
+        /// Applies a <see cref="BeatmapDifficulty"/> to the mod and returns a new <see cref="BeatmapDifficulty"/>
+        /// representing the result if the mod were applied to a fresh <see cref="BeatmapDifficulty"/> instance.
+        /// </summary>
+        private BeatmapDifficulty applyDifficulty(BeatmapDifficulty difficulty)
+        {
+            // ensure that ReadFromDifficulty doesn't pollute the values.
+            var newDifficulty = difficulty.Clone();
+
+            testMod.ReadFromDifficulty(difficulty);
+
+            testMod.ApplyToDifficulty(newDifficulty);
+            return newDifficulty;
+        }
+
+        private class TestModDifficultyAdjust : ModDifficultyAdjust
+        {
+        }
+
+        private class TestRuleset : Ruleset
+        {
+            public override IEnumerable<Mod> GetModsFor(ModType type)
+            {
+                if (type == ModType.DifficultyIncrease)
+                    yield return new TestModDifficultyAdjust();
+            }
+
+            public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod> mods = null)
+            {
+                throw new System.NotImplementedException();
+            }
+
+            public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap)
+            {
+                throw new System.NotImplementedException();
+            }
+
+            public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap)
+            {
+                throw new System.NotImplementedException();
+            }
+
+            public override string Description => string.Empty;
+            public override string ShortName => string.Empty;
+        }
+    }
+}

osu.Game.Tests/NonVisual/CustomDataDirectoryTest.cs

@@ -184,6 +184,9 @@ namespace osu.Game.Tests.NonVisual
                     Assert.DoesNotThrow(() => osu.Migrate(customPath2));
                     Assert.That(File.Exists(Path.Combine(customPath2, database_filename)));
 
+                    // some files may have been left behind for whatever reason, but that's not what we're testing here.
+                    customPath = prepareCustomPath();
+
                     Assert.DoesNotThrow(() => osu.Migrate(customPath));
                     Assert.That(File.Exists(Path.Combine(customPath, database_filename)));
                 }

osu.Game.Tests/Resources/Shaders/sh_TestFragment.fs

@@ -0,0 +1,11 @@
+#include "sh_Utils.h"
+
+varying mediump vec2 v_TexCoord;
+varying mediump vec4 v_TexRect;
+
+void main(void)
+{
+    float hueValue = v_TexCoord.x / (v_TexRect[2] - v_TexRect[0]);
+    gl_FragColor = hsv2rgb(vec4(hueValue, 1, 1, 1));
+}
+

osu.Game.Tests/Resources/Shaders/sh_TestVertex.vs

@@ -0,0 +1,31 @@
+#include "sh_Utils.h"
+
+attribute highp vec2 m_Position;
+attribute lowp vec4 m_Colour;
+attribute mediump vec2 m_TexCoord;
+attribute mediump vec4 m_TexRect;
+attribute mediump vec2 m_BlendRange;
+
+varying highp vec2 v_MaskingPosition;
+varying lowp vec4 v_Colour;
+varying mediump vec2 v_TexCoord;
+varying mediump vec4 v_TexRect;
+varying mediump vec2 v_BlendRange;
+
+uniform highp mat4 g_ProjMatrix;
+uniform highp mat3 g_ToMaskingSpace;
+
+void main(void)
+{
+    // Transform from screen space to masking space.
+    highp vec3 maskingPos = g_ToMaskingSpace * vec3(m_Position, 1.0);
+    v_MaskingPosition = maskingPos.xy / maskingPos.z;
+
+    v_Colour = m_Colour;
+    v_TexCoord = m_TexCoord;
+    v_TexRect = m_TexRect;
+    v_BlendRange = m_BlendRange;
+
+    gl_Position = gProjMatrix * vec4(m_Position, 1.0, 1.0);
+}
+

osu.Game.Tests/Rulesets/TestSceneDrawableRulesetDependencies.cs

@@ -13,8 +13,10 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.OpenGL.Textures;
+using osu.Framework.Graphics.Shaders;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Textures;
+using osu.Framework.IO.Stores;
 using osu.Framework.Testing;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.UI;
@@ -31,12 +33,14 @@ namespace osu.Game.Tests.Rulesets
             DrawableWithDependencies drawable = null;
             TestTextureStore textureStore = null;
             TestSampleStore sampleStore = null;
+            TestShaderManager shaderManager = null;
 
             AddStep("add dependencies", () =>
             {
                 Child = drawable = new DrawableWithDependencies();
                 textureStore = drawable.ParentTextureStore;
                 sampleStore = drawable.ParentSampleStore;
+                shaderManager = drawable.ParentShaderManager;
             });
 
             AddStep("clear children", Clear);
@@ -52,12 +56,14 @@ namespace osu.Game.Tests.Rulesets
 
             AddAssert("parent texture store not disposed", () => !textureStore.IsDisposed);
             AddAssert("parent sample store not disposed", () => !sampleStore.IsDisposed);
+            AddAssert("parent shader manager not disposed", () => !shaderManager.IsDisposed);
         }
 
         private class DrawableWithDependencies : CompositeDrawable
         {
             public TestTextureStore ParentTextureStore { get; private set; }
             public TestSampleStore ParentSampleStore { get; private set; }
+            public TestShaderManager ParentShaderManager { get; private set; }
 
             public DrawableWithDependencies()
             {
@@ -70,6 +76,7 @@ namespace osu.Game.Tests.Rulesets
 
                 dependencies.CacheAs<TextureStore>(ParentTextureStore = new TestTextureStore());
                 dependencies.CacheAs<ISampleStore>(ParentSampleStore = new TestSampleStore());
+                dependencies.CacheAs<ShaderManager>(ParentShaderManager = new TestShaderManager());
 
                 return new DrawableRulesetDependencies(new OsuRuleset(), dependencies);
             }
@@ -135,5 +142,23 @@ namespace osu.Game.Tests.Rulesets
 
             public int PlaybackConcurrency { get; set; }
         }
+
+        private class TestShaderManager : ShaderManager
+        {
+            public TestShaderManager()
+                : base(new ResourceStore<byte[]>())
+            {
+            }
+
+            public override byte[] LoadRaw(string name) => null;
+
+            public bool IsDisposed { get; private set; }
+
+            protected override void Dispose(bool disposing)
+            {
+                base.Dispose(disposing);
+                IsDisposed = true;
+            }
+        }
     }
 }

osu.Game.Tests/Skins/TestSceneSkinProvidingContainer.cs

@@ -0,0 +1,94 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.OpenGL.Textures;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Testing;
+using osu.Game.Audio;
+using osu.Game.Skinning;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Tests.Skins
+{
+    [HeadlessTest]
+    public class TestSceneSkinProvidingContainer : OsuTestScene
+    {
+        /// <summary>
+        /// Ensures that the first inserted skin after resetting (via source change)
+        /// is always prioritised over others when providing the same resource.
+        /// </summary>
+        [Test]
+        public void TestPriorityPreservation()
+        {
+            TestSkinProvidingContainer provider = null;
+            TestSkin mostPrioritisedSource = null;
+
+            AddStep("setup sources", () =>
+            {
+                var sources = new List<TestSkin>();
+                for (int i = 0; i < 10; i++)
+                    sources.Add(new TestSkin());
+
+                mostPrioritisedSource = sources.First();
+
+                Child = provider = new TestSkinProvidingContainer(sources);
+            });
+
+            AddAssert("texture provided by expected skin", () =>
+            {
+                return provider.FindProvider(s => s.GetTexture(TestSkin.TEXTURE_NAME) != null) == mostPrioritisedSource;
+            });
+
+            AddStep("trigger source change", () => provider.TriggerSourceChanged());
+
+            AddAssert("texture still provided by expected skin", () =>
+            {
+                return provider.FindProvider(s => s.GetTexture(TestSkin.TEXTURE_NAME) != null) == mostPrioritisedSource;
+            });
+        }
+
+        private class TestSkinProvidingContainer : SkinProvidingContainer
+        {
+            private readonly IEnumerable<ISkin> sources;
+
+            public TestSkinProvidingContainer(IEnumerable<ISkin> sources)
+            {
+                this.sources = sources;
+            }
+
+            public new void TriggerSourceChanged() => base.TriggerSourceChanged();
+
+            protected override void OnSourceChanged()
+            {
+                ResetSources();
+                sources.ForEach(AddSource);
+            }
+        }
+
+        private class TestSkin : ISkin
+        {
+            public const string TEXTURE_NAME = "virtual-texture";
+
+            public Drawable GetDrawableComponent(ISkinComponent component) => throw new System.NotImplementedException();
+
+            public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT)
+            {
+                if (componentName == TEXTURE_NAME)
+                    return Texture.WhitePixel;
+
+                return null;
+            }
+
+            public ISample GetSample(ISampleInfo sampleInfo) => throw new System.NotImplementedException();
+
+            public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => throw new System.NotImplementedException();
+        }
+    }
+}

osu.Game.Tests/Testing/TestSceneRulesetDependencies.cs

@@ -7,6 +7,7 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Configuration.Tracking;
+using osu.Framework.Graphics.Shaders;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.IO.Stores;
 using osu.Framework.Testing;
@@ -45,6 +46,14 @@ namespace osu.Game.Tests.Testing
                 Dependencies.Get<ISampleStore>().Get(@"test-sample") != null);
         }
 
+        [Test]
+        public void TestRetrieveShader()
+        {
+            AddAssert("ruleset shaders retrieved", () =>
+                Dependencies.Get<ShaderManager>().LoadRaw(@"sh_TestVertex.vs") != null &&
+                Dependencies.Get<ShaderManager>().LoadRaw(@"sh_TestFragment.fs") != null);
+        }
+
         [Test]
         public void TestResolveConfigManager()
         {

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

@@ -11,7 +11,6 @@ using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.Break;
 using osu.Game.Screens.Ranking;
-using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
@@ -36,18 +35,6 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("rewind", () => Player.GameplayClockContainer.Seek(-80000));
             AddUntilStep("key counter reset", () => Player.HUDOverlay.KeyCounter.Children.All(kc => kc.CountPresses == 0));
 
-            double? time = null;
-
-            AddStep("store time", () => time = Player.GameplayClockContainer.GameplayClock.CurrentTime);
-
-            // test seek via keyboard
-            AddStep("seek with right arrow key", () => InputManager.Key(Key.Right));
-            AddAssert("time seeked forward", () => Player.GameplayClockContainer.GameplayClock.CurrentTime > time + 2000);
-
-            AddStep("store time", () => time = Player.GameplayClockContainer.GameplayClock.CurrentTime);
-            AddStep("seek with left arrow key", () => InputManager.Key(Key.Left));
-            AddAssert("time seeked backward", () => Player.GameplayClockContainer.GameplayClock.CurrentTime < time);
-
             seekToBreak(0);
             seekToBreak(1);
 

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

@@ -87,7 +87,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             showOverlay();
 
             AddStep("Up arrow", () => InputManager.Key(Key.Up));
-            AddAssert("Last button selected", () => pauseOverlay.Buttons.Last().Selected.Value);
+            AddAssert("Last button selected", () => pauseOverlay.Buttons.Last().State == SelectionState.Selected);
         }
 
         /// <summary>
@@ -99,7 +99,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             showOverlay();
 
             AddStep("Down arrow", () => InputManager.Key(Key.Down));
-            AddAssert("First button selected", () => getButton(0).Selected.Value);
+            AddAssert("First button selected", () => getButton(0).State == SelectionState.Selected);
         }
 
         /// <summary>
@@ -111,11 +111,11 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("Show overlay", () => failOverlay.Show());
 
             AddStep("Up arrow", () => InputManager.Key(Key.Up));
-            AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected.Value);
+            AddAssert("Last button selected", () => failOverlay.Buttons.Last().State == SelectionState.Selected);
             AddStep("Up arrow", () => InputManager.Key(Key.Up));
-            AddAssert("First button selected", () => failOverlay.Buttons.First().Selected.Value);
+            AddAssert("First button selected", () => failOverlay.Buttons.First().State == SelectionState.Selected);
             AddStep("Up arrow", () => InputManager.Key(Key.Up));
-            AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected.Value);
+            AddAssert("Last button selected", () => failOverlay.Buttons.Last().State == SelectionState.Selected);
         }
 
         /// <summary>
@@ -127,11 +127,11 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("Show overlay", () => failOverlay.Show());
 
             AddStep("Down arrow", () => InputManager.Key(Key.Down));
-            AddAssert("First button selected", () => failOverlay.Buttons.First().Selected.Value);
+            AddAssert("First button selected", () => failOverlay.Buttons.First().State == SelectionState.Selected);
             AddStep("Down arrow", () => InputManager.Key(Key.Down));
-            AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected.Value);
+            AddAssert("Last button selected", () => failOverlay.Buttons.Last().State == SelectionState.Selected);
             AddStep("Down arrow", () => InputManager.Key(Key.Down));
-            AddAssert("First button selected", () => failOverlay.Buttons.First().Selected.Value);
+            AddAssert("First button selected", () => failOverlay.Buttons.First().State == SelectionState.Selected);
         }
 
         /// <summary>
@@ -145,7 +145,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("Hover first button", () => InputManager.MoveMouseTo(failOverlay.Buttons.First()));
             AddStep("Hide overlay", () => failOverlay.Hide());
 
-            AddAssert("Overlay state is reset", () => !failOverlay.Buttons.Any(b => b.Selected.Value));
+            AddAssert("Overlay state is reset", () => failOverlay.Buttons.All(b => b.State == SelectionState.NotSelected));
         }
 
         /// <summary>
@@ -162,11 +162,11 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("Hide overlay", () => pauseOverlay.Hide());
             showOverlay();
 
-            AddAssert("First button not selected", () => !getButton(0).Selected.Value);
+            AddAssert("First button not selected", () => getButton(0).State == SelectionState.NotSelected);
 
             AddStep("Move slightly", () => InputManager.MoveMouseTo(InputManager.CurrentState.Mouse.Position + new Vector2(1)));
 
-            AddAssert("First button selected", () => getButton(0).Selected.Value);
+            AddAssert("First button selected", () => getButton(0).State == SelectionState.Selected);
         }
 
         /// <summary>
@@ -179,8 +179,8 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddStep("Down arrow", () => InputManager.Key(Key.Down));
             AddStep("Hover second button", () => InputManager.MoveMouseTo(getButton(1)));
-            AddAssert("First button not selected", () => !getButton(0).Selected.Value);
-            AddAssert("Second button selected", () => getButton(1).Selected.Value);
+            AddAssert("First button not selected", () => getButton(0).State == SelectionState.NotSelected);
+            AddAssert("Second button selected", () => getButton(1).State == SelectionState.Selected);
         }
 
         /// <summary>
@@ -196,8 +196,8 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddStep("Hover second button", () => InputManager.MoveMouseTo(getButton(1)));
             AddStep("Up arrow", () => InputManager.Key(Key.Up));
-            AddAssert("Second button not selected", () => !getButton(1).Selected.Value);
-            AddAssert("First button selected", () => getButton(0).Selected.Value);
+            AddAssert("Second button not selected", () => getButton(1).State == SelectionState.NotSelected);
+            AddAssert("First button selected", () => getButton(0).State == SelectionState.Selected);
         }
 
         /// <summary>
@@ -211,7 +211,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("Hover second button", () => InputManager.MoveMouseTo(getButton(1)));
             AddStep("Unhover second button", () => InputManager.MoveMouseTo(Vector2.Zero));
             AddStep("Down arrow", () => InputManager.Key(Key.Down));
-            AddAssert("First button selected", () => getButton(0).Selected.Value); // Initial state condition
+            AddAssert("First button selected", () => getButton(0).State == SelectionState.Selected); // Initial state condition
         }
 
         /// <summary>
@@ -282,7 +282,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             showOverlay();
 
             AddAssert("No button selected",
-                () => pauseOverlay.Buttons.All(button => !button.Selected.Value));
+                () => pauseOverlay.Buttons.All(button => button.State == SelectionState.NotSelected));
         }
 
         private void showOverlay() => AddStep("Show overlay", () => pauseOverlay.Show());

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

@@ -1,38 +1,58 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Screens;
+using osu.Game.Beatmaps;
 using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
 using osu.Game.Online.Solo;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Ranking;
+using osu.Game.Tests.Beatmaps;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
-    public class TestScenePlayerScoreSubmission : OsuPlayerTestScene
+    public class TestScenePlayerScoreSubmission : PlayerTestScene
     {
         protected override bool AllowFail => allowFail;
 
         private bool allowFail;
 
+        private Func<RulesetInfo, IBeatmap> createCustomBeatmap;
+        private Func<Ruleset> createCustomRuleset;
+
         private DummyAPIAccess dummyAPI => (DummyAPIAccess)API;
 
         protected override bool HasCustomSteps => true;
 
         protected override TestPlayer CreatePlayer(Ruleset ruleset) => new TestPlayer(false);
 
+        protected override Ruleset CreatePlayerRuleset() => createCustomRuleset?.Invoke() ?? new OsuRuleset();
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => createCustomBeatmap?.Invoke(ruleset) ?? createTestBeatmap(ruleset);
+
+        private IBeatmap createTestBeatmap(RulesetInfo ruleset)
+        {
+            var beatmap = (TestBeatmap)base.CreateBeatmap(ruleset);
+
+            beatmap.HitObjects = beatmap.HitObjects.Take(10).ToList();
+
+            return beatmap;
+        }
+
         [Test]
         public void TestNoSubmissionOnResultsWithNoToken()
         {
             prepareTokenResponse(false);
 
-            CreateTest(() => allowFail = false);
+            createPlayerTest();
 
             AddUntilStep("wait for token request", () => Player.TokenCreationRequested);
 
@@ -52,7 +72,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             prepareTokenResponse(true);
 
-            CreateTest(() => allowFail = false);
+            createPlayerTest();
 
             AddUntilStep("wait for token request", () => Player.TokenCreationRequested);
 
@@ -71,7 +91,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             prepareTokenResponse(false);
 
-            CreateTest(() => allowFail = false);
+            createPlayerTest();
 
             AddUntilStep("wait for token request", () => Player.TokenCreationRequested);
 
@@ -88,7 +108,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             prepareTokenResponse(true);
 
-            CreateTest(() => allowFail = true);
+            createPlayerTest(true);
 
             AddUntilStep("wait for token request", () => Player.TokenCreationRequested);
 
@@ -103,7 +123,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             prepareTokenResponse(true);
 
-            CreateTest(() => allowFail = true);
+            createPlayerTest(true);
 
             AddUntilStep("wait for token request", () => Player.TokenCreationRequested);
 
@@ -120,7 +140,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             prepareTokenResponse(true);
 
-            CreateTest(() => allowFail = false);
+            createPlayerTest();
 
             AddUntilStep("wait for token request", () => Player.TokenCreationRequested);
 
@@ -133,7 +153,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             prepareTokenResponse(true);
 
-            CreateTest(() => allowFail = false);
+            createPlayerTest();
 
             AddUntilStep("wait for token request", () => Player.TokenCreationRequested);
 
@@ -143,18 +163,49 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("ensure failing submission", () => Player.SubmittedScore?.ScoreInfo.Passed == false);
         }
 
-        private void addFakeHit()
+        [Test]
+        public void TestNoSubmissionOnLocalBeatmap()
         {
-            AddUntilStep("wait for first result", () => Player.Results.Count > 0);
+            prepareTokenResponse(true);
 
-            AddStep("force successfuly hit", () =>
+            createPlayerTest(false, r =>
             {
-                Player.ScoreProcessor.RevertResult(Player.Results.First());
-                Player.ScoreProcessor.ApplyResult(new OsuJudgementResult(Beatmap.Value.Beatmap.HitObjects.First(), new OsuJudgement())
-                {
-                    Type = HitResult.Great,
-                });
+                var beatmap = createTestBeatmap(r);
+                beatmap.BeatmapInfo.OnlineBeatmapID = null;
+                return beatmap;
             });
+
+            AddUntilStep("wait for token request", () => Player.TokenCreationRequested);
+
+            addFakeHit();
+
+            AddStep("exit", () => Player.Exit());
+            AddAssert("ensure no submission", () => Player.SubmittedScore == null);
+        }
+
+        [Test]
+        public void TestNoSubmissionOnCustomRuleset()
+        {
+            prepareTokenResponse(true);
+
+            createPlayerTest(false, createRuleset: () => new OsuRuleset { RulesetInfo = { ID = 10 } });
+
+            AddUntilStep("wait for token request", () => Player.TokenCreationRequested);
+
+            addFakeHit();
+
+            AddStep("exit", () => Player.Exit());
+            AddAssert("ensure no submission", () => Player.SubmittedScore == null);
+        }
+
+        private void createPlayerTest(bool allowFail = false, Func<RulesetInfo, IBeatmap> createBeatmap = null, Func<Ruleset> createRuleset = null)
+        {
+            CreateTest(() => AddStep("set up requirements", () =>
+            {
+                this.allowFail = allowFail;
+                createCustomBeatmap = createBeatmap;
+                createCustomRuleset = createRuleset;
+            }));
         }
 
         private void prepareTokenResponse(bool validToken)
@@ -177,5 +228,19 @@ namespace osu.Game.Tests.Visual.Gameplay
                 };
             });
         }
+
+        private void addFakeHit()
+        {
+            AddUntilStep("wait for first result", () => Player.Results.Count > 0);
+
+            AddStep("force successfuly hit", () =>
+            {
+                Player.ScoreProcessor.RevertResult(Player.Results.First());
+                Player.ScoreProcessor.ApplyResult(new OsuJudgementResult(Beatmap.Value.Beatmap.HitObjects.First(), new OsuJudgement())
+                {
+                    Type = HitResult.Great,
+                });
+            });
+        }
     }
 }

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

@@ -0,0 +1,87 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneReplayPlayer : RateAdjustedBeatmapTestScene
+    {
+        protected TestReplayPlayer Player;
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("Initialise player", () => Player = CreatePlayer(new OsuRuleset()));
+            AddStep("Load player", () => LoadScreen(Player));
+            AddUntilStep("player loaded", () => Player.IsLoaded);
+        }
+
+        [Test]
+        public void TestPause()
+        {
+            double? lastTime = null;
+
+            AddUntilStep("wait for first hit", () => Player.ScoreProcessor.TotalScore.Value > 0);
+
+            AddStep("Pause playback", () => InputManager.Key(Key.Space));
+
+            AddUntilStep("Time stopped progressing", () =>
+            {
+                double current = Player.GameplayClockContainer.CurrentTime;
+                bool changed = lastTime != current;
+                lastTime = current;
+
+                return !changed;
+            });
+
+            AddWaitStep("wait some", 10);
+
+            AddAssert("Time still stopped", () => lastTime == Player.GameplayClockContainer.CurrentTime);
+        }
+
+        [Test]
+        public void TestSeekBackwards()
+        {
+            double? lastTime = null;
+
+            AddUntilStep("wait for first hit", () => Player.ScoreProcessor.TotalScore.Value > 0);
+
+            AddStep("Seek backwards", () =>
+            {
+                lastTime = Player.GameplayClockContainer.CurrentTime;
+                InputManager.Key(Key.Left);
+            });
+
+            AddAssert("Jumped backwards", () => Player.GameplayClockContainer.CurrentTime - lastTime < 0);
+        }
+
+        [Test]
+        public void TestSeekForwards()
+        {
+            double? lastTime = null;
+
+            AddUntilStep("wait for first hit", () => Player.ScoreProcessor.TotalScore.Value > 0);
+
+            AddStep("Seek forwards", () =>
+            {
+                lastTime = Player.GameplayClockContainer.CurrentTime;
+                InputManager.Key(Key.Right);
+            });
+
+            AddAssert("Jumped forwards", () => Player.GameplayClockContainer.CurrentTime - lastTime > 500);
+        }
+
+        protected TestReplayPlayer CreatePlayer(Ruleset ruleset)
+        {
+            Beatmap.Value = CreateWorkingBeatmap(ruleset.RulesetInfo);
+            SelectedMods.Value = new[] { ruleset.GetAutoplayMod() };
+
+            return new TestReplayPlayer(false);
+        }
+    }
+}

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

@@ -168,7 +168,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             public void Disable()
             {
                 allow = false;
-                OnSourceChanged();
+                TriggerSourceChanged();
             }
 
             public SwitchableSkinProvidingContainer(ISkin skin)

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

@@ -122,10 +122,10 @@ namespace osu.Game.Tests.Visual.Multiplayer
         public void TestToggleWhenIdle(MultiplayerUserState initialState)
         {
             addClickSpectateButtonStep();
-            AddAssert("user is spectating", () => Client.Room?.Users[0].State == MultiplayerUserState.Spectating);
+            AddUntilStep("user is spectating", () => Client.Room?.Users[0].State == MultiplayerUserState.Spectating);
 
             addClickSpectateButtonStep();
-            AddAssert("user is idle", () => Client.Room?.Users[0].State == MultiplayerUserState.Idle);
+            AddUntilStep("user is idle", () => Client.Room?.Users[0].State == MultiplayerUserState.Idle);
         }
 
         [TestCase(MultiplayerRoomState.Closed)]
@@ -174,9 +174,9 @@ namespace osu.Game.Tests.Visual.Multiplayer
         });
 
         private void assertSpectateButtonEnablement(bool shouldBeEnabled)
-            => AddAssert($"spectate button {(shouldBeEnabled ? "is" : "is not")} enabled", () => spectateButton.ChildrenOfType<OsuButton>().Single().Enabled.Value == shouldBeEnabled);
+            => AddUntilStep($"spectate button {(shouldBeEnabled ? "is" : "is not")} enabled", () => spectateButton.ChildrenOfType<OsuButton>().Single().Enabled.Value == shouldBeEnabled);
 
         private void assertReadyButtonEnablement(bool shouldBeEnabled)
-            => AddAssert($"ready button {(shouldBeEnabled ? "is" : "is not")} enabled", () => readyButton.ChildrenOfType<OsuButton>().Single().Enabled.Value == shouldBeEnabled);
+            => AddUntilStep($"ready button {(shouldBeEnabled ? "is" : "is not")} enabled", () => readyButton.ChildrenOfType<OsuButton>().Single().Enabled.Value == shouldBeEnabled);
     }
 }

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

@@ -58,8 +58,7 @@ namespace osu.Game.Tests.Visual.Navigation
         [Test]
         public void TestPerformAtSongSelectFromPlayerLoader()
         {
-            AddStep("import beatmap", () => ImportBeatmapTest.LoadQuickOszIntoOsu(Game).Wait());
-            PushAndConfirm(() => new TestPlaySongSelect());
+            importAndWaitForSongSelect();
 
             AddStep("Press enter", () => InputManager.Key(Key.Enter));
             AddUntilStep("Wait for new screen", () => Game.ScreenStack.CurrentScreen is PlayerLoader);
@@ -72,8 +71,7 @@ namespace osu.Game.Tests.Visual.Navigation
         [Test]
         public void TestPerformAtMenuFromPlayerLoader()
         {
-            AddStep("import beatmap", () => ImportBeatmapTest.LoadQuickOszIntoOsu(Game).Wait());
-            PushAndConfirm(() => new TestPlaySongSelect());
+            importAndWaitForSongSelect();
 
             AddStep("Press enter", () => InputManager.Key(Key.Enter));
             AddUntilStep("Wait for new screen", () => Game.ScreenStack.CurrentScreen is PlayerLoader);
@@ -172,6 +170,13 @@ namespace osu.Game.Tests.Visual.Navigation
             }
         }
 
+        private void importAndWaitForSongSelect()
+        {
+            AddStep("import beatmap", () => ImportBeatmapTest.LoadQuickOszIntoOsu(Game).Wait());
+            PushAndConfirm(() => new TestPlaySongSelect());
+            AddUntilStep("beatmap updated", () => Game.Beatmap.Value.BeatmapSetInfo.OnlineBeatmapSetID == 241526);
+        }
+
         public class DialogBlockingScreen : OsuScreen
         {
             [Resolved]

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

@@ -12,7 +12,7 @@ namespace osu.Game.Tests.Visual.Settings
         [BackgroundDependencyLoader]
         private void load()
         {
-            Add(new DirectorySelector { RelativeSizeAxes = Axes.Both });
+            Add(new OsuDirectorySelector { RelativeSizeAxes = Axes.Both });
         }
     }
 }

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

@@ -12,13 +12,13 @@ namespace osu.Game.Tests.Visual.Settings
         [Test]
         public void TestAllFiles()
         {
-            AddStep("create", () => Child = new FileSelector { RelativeSizeAxes = Axes.Both });
+            AddStep("create", () => Child = new OsuFileSelector { RelativeSizeAxes = Axes.Both });
         }
 
         [Test]
         public void TestJpgFilesOnly()
         {
-            AddStep("create", () => Child = new FileSelector(validFileExtensions: new[] { ".jpg" }) { RelativeSizeAxes = Axes.Both });
+            AddStep("create", () => Child = new OsuFileSelector(validFileExtensions: new[] { ".jpg" }) { RelativeSizeAxes = Axes.Both });
         }
     }
 }

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

@@ -0,0 +1,208 @@
+// 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.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Overlays.Settings;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneModDifficultyAdjustSettings : OsuManualInputManagerTestScene
+    {
+        private OsuModDifficultyAdjust modDifficultyAdjust;
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("create control", () =>
+            {
+                modDifficultyAdjust = new OsuModDifficultyAdjust();
+
+                Child = new Container
+                {
+                    Size = new Vector2(300),
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            Colour = Color4.Black,
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                        new FillFlowContainer
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            ChildrenEnumerable = modDifficultyAdjust.CreateSettingsControls(),
+                        },
+                    }
+                };
+            });
+        }
+
+        [Test]
+        public void TestFollowsBeatmapDefaultsVisually()
+        {
+            setBeatmapWithDifficultyParameters(5);
+
+            checkSliderAtValue("Circle Size", 5);
+            checkBindableAtValue("Circle Size", null);
+
+            setBeatmapWithDifficultyParameters(8);
+
+            checkSliderAtValue("Circle Size", 8);
+            checkBindableAtValue("Circle Size", null);
+        }
+
+        [Test]
+        public void TestOutOfRangeValueStillApplied()
+        {
+            AddStep("set override cs to 11", () => modDifficultyAdjust.CircleSize.Value = 11);
+
+            checkSliderAtValue("Circle Size", 11);
+            checkBindableAtValue("Circle Size", 11);
+
+            // this is a no-op, just showing that it won't reset the value during deserialisation.
+            setExtendedLimits(false);
+
+            checkSliderAtValue("Circle Size", 11);
+            checkBindableAtValue("Circle Size", 11);
+
+            // setting extended limits will reset the serialisation exception.
+            // this should be fine as the goal is to allow, at most, the value of extended limits.
+            setExtendedLimits(true);
+
+            checkSliderAtValue("Circle Size", 11);
+            checkBindableAtValue("Circle Size", 11);
+        }
+
+        [Test]
+        public void TestExtendedLimits()
+        {
+            setSliderValue("Circle Size", 99);
+
+            checkSliderAtValue("Circle Size", 10);
+            checkBindableAtValue("Circle Size", 10);
+
+            setExtendedLimits(true);
+
+            checkSliderAtValue("Circle Size", 10);
+            checkBindableAtValue("Circle Size", 10);
+
+            setSliderValue("Circle Size", 99);
+
+            checkSliderAtValue("Circle Size", 11);
+            checkBindableAtValue("Circle Size", 11);
+
+            setExtendedLimits(false);
+
+            checkSliderAtValue("Circle Size", 10);
+            checkBindableAtValue("Circle Size", 10);
+        }
+
+        [Test]
+        public void TestUserOverrideMaintainedOnBeatmapChange()
+        {
+            setSliderValue("Circle Size", 9);
+
+            setBeatmapWithDifficultyParameters(2);
+
+            checkSliderAtValue("Circle Size", 9);
+            checkBindableAtValue("Circle Size", 9);
+        }
+
+        [Test]
+        public void TestResetToDefault()
+        {
+            setBeatmapWithDifficultyParameters(2);
+
+            setSliderValue("Circle Size", 9);
+            checkSliderAtValue("Circle Size", 9);
+            checkBindableAtValue("Circle Size", 9);
+
+            resetToDefault("Circle Size");
+            checkSliderAtValue("Circle Size", 2);
+            checkBindableAtValue("Circle Size", null);
+        }
+
+        [Test]
+        public void TestUserOverrideMaintainedOnMatchingBeatmapValue()
+        {
+            setBeatmapWithDifficultyParameters(3);
+
+            checkSliderAtValue("Circle Size", 3);
+            checkBindableAtValue("Circle Size", null);
+
+            // need to initially change it away from the current beatmap value to trigger an override.
+            setSliderValue("Circle Size", 4);
+            setSliderValue("Circle Size", 3);
+
+            checkSliderAtValue("Circle Size", 3);
+            checkBindableAtValue("Circle Size", 3);
+
+            setBeatmapWithDifficultyParameters(4);
+
+            checkSliderAtValue("Circle Size", 3);
+            checkBindableAtValue("Circle Size", 3);
+        }
+
+        private void resetToDefault(string name)
+        {
+            AddStep($"Reset {name} to default", () =>
+                this.ChildrenOfType<DifficultyAdjustSettingsControl>().First(c => c.LabelText == name)
+                    .Current.SetDefault());
+        }
+
+        private void setExtendedLimits(bool status) =>
+            AddStep($"Set extended limits {status}", () => modDifficultyAdjust.ExtendedLimits.Value = status);
+
+        private void setSliderValue(string name, float value)
+        {
+            AddStep($"Set {name} slider to {value}", () =>
+                this.ChildrenOfType<DifficultyAdjustSettingsControl>().First(c => c.LabelText == name)
+                    .ChildrenOfType<SettingsSlider<float>>().First().Current.Value = value);
+        }
+
+        private void checkBindableAtValue(string name, float? expectedValue)
+        {
+            AddAssert($"Bindable {name} is {(expectedValue?.ToString() ?? "null")}", () =>
+                this.ChildrenOfType<DifficultyAdjustSettingsControl>().First(c => c.LabelText == name)
+                    .Current.Value == expectedValue);
+        }
+
+        private void checkSliderAtValue(string name, float expectedValue)
+        {
+            AddAssert($"Slider {name} at {expectedValue}", () =>
+                this.ChildrenOfType<DifficultyAdjustSettingsControl>().First(c => c.LabelText == name)
+                    .ChildrenOfType<SettingsSlider<float>>().First().Current.Value == expectedValue);
+        }
+
+        private void setBeatmapWithDifficultyParameters(float value)
+        {
+            AddStep($"set beatmap with all {value}", () => Beatmap.Value = CreateWorkingBeatmap(new Beatmap
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    BaseDifficulty = new BeatmapDifficulty
+                    {
+                        OverallDifficulty = value,
+                        CircleSize = value,
+                        DrainRate = value,
+                        ApproachRate = value,
+                    }
+                }
+            }));
+        }
+    }
+}

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

@@ -12,6 +12,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays.Mods;
+using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Mania.Mods;
@@ -50,6 +51,38 @@ namespace osu.Game.Tests.Visual.UserInterface
             AddStep("show", () => modSelect.Show());
         }
 
+        /// <summary>
+        /// Ensure that two mod overlays are not cross polluting via central settings instances.
+        /// </summary>
+        [Test]
+        public void TestSettingsNotCrossPolluting()
+        {
+            Bindable<IReadOnlyList<Mod>> selectedMods2 = null;
+
+            AddStep("select diff adjust", () => SelectedMods.Value = new Mod[] { new OsuModDifficultyAdjust() });
+
+            AddStep("set setting", () => modSelect.ChildrenOfType<SettingsSlider<float>>().First().Current.Value = 8);
+
+            AddAssert("ensure setting is propagated", () => SelectedMods.Value.OfType<OsuModDifficultyAdjust>().Single().CircleSize.Value == 8);
+
+            AddStep("create second bindable", () => selectedMods2 = new Bindable<IReadOnlyList<Mod>>(new Mod[] { new OsuModDifficultyAdjust() }));
+
+            AddStep("create second overlay", () =>
+            {
+                Add(modSelect = new TestModSelectOverlay().With(d =>
+                {
+                    d.Origin = Anchor.TopCentre;
+                    d.Anchor = Anchor.TopCentre;
+                    d.SelectedMods.BindTarget = selectedMods2;
+                }));
+            });
+
+            AddStep("show", () => modSelect.Show());
+
+            AddAssert("ensure first is unchanged", () => SelectedMods.Value.OfType<OsuModDifficultyAdjust>().Single().CircleSize.Value == 8);
+            AddAssert("ensure second is default", () => selectedMods2.Value.OfType<OsuModDifficultyAdjust>().Single().CircleSize.Value == null);
+        }
+
         [Test]
         public void TestSettingsResetOnDeselection()
         {

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

@@ -0,0 +1,32 @@
+// 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.Graphics;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Volume;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneVolumeOverlay : OsuTestScene
+    {
+        private VolumeOverlay volume;
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            AddRange(new Drawable[]
+            {
+                volume = new VolumeOverlay(),
+                new VolumeControlReceptor
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    ActionRequested = action => volume.Adjust(action),
+                    ScrollActionRequested = (action, amount, isPrecise) => volume.Adjust(action, amount, isPrecise),
+                },
+            });
+
+            AddStep("show controls", () => volume.Show());
+        }
+    }
+}

osu.Game.Tournament/Screens/Setup/StablePathSelectScreen.cs

@@ -30,7 +30,7 @@ namespace osu.Game.Tournament.Screens.Setup
         [Resolved]
         private MatchIPCInfo ipc { get; set; }
 
-        private DirectorySelector directorySelector;
+        private OsuDirectorySelector directorySelector;
         private DialogOverlay overlay;
 
         [BackgroundDependencyLoader(true)]
@@ -79,7 +79,7 @@ namespace osu.Game.Tournament.Screens.Setup
                                 },
                                 new Drawable[]
                                 {
-                                    directorySelector = new DirectorySelector(initialPath)
+                                    directorySelector = new OsuDirectorySelector(initialPath)
                                     {
                                         RelativeSizeAxes = Axes.Both,
                                     }

osu.Game/.editorconfig

@@ -0,0 +1,2 @@
+[*.cs]
+dotnet_diagnostic.OLOC001.prefix_namespace = osu.Game.Resources.Localisation

osu.Game/Graphics/Containers/OsuClickableContainer.cs

@@ -18,7 +18,7 @@ namespace osu.Game.Graphics.Containers
 
         protected override Container<Drawable> Content => content;
 
-        protected virtual HoverClickSounds CreateHoverClickSounds(HoverSampleSet sampleSet) => new HoverClickSounds(sampleSet);
+        protected virtual HoverSounds CreateHoverSounds(HoverSampleSet sampleSet) => new HoverClickSounds(sampleSet);
 
         public OsuClickableContainer(HoverSampleSet sampleSet = HoverSampleSet.Default)
         {
@@ -39,7 +39,7 @@ namespace osu.Game.Graphics.Containers
             InternalChildren = new Drawable[]
             {
                 content,
-                CreateHoverClickSounds(sampleSet)
+                CreateHoverSounds(sampleSet)
             };
         }
     }

osu.Game/Graphics/Containers/SelectionCycleFillFlowContainer.cs

@@ -0,0 +1,87 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Diagnostics;
+using osu.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
+
+namespace osu.Game.Graphics.Containers
+{
+    /// <summary>
+    /// A FillFlowContainer that provides functionality to cycle selection between children
+    /// The selection wraps around when overflowing past the first or last child.
+    /// </summary>
+    public class SelectionCycleFillFlowContainer<T> : FillFlowContainer<T> where T : Drawable, IStateful<SelectionState>
+    {
+        public T Selected => (selectedIndex >= 0 && selectedIndex < Count) ? this[selectedIndex.Value] : null;
+
+        private int? selectedIndex;
+
+        public void SelectNext()
+        {
+            if (!selectedIndex.HasValue || selectedIndex == Count - 1)
+                setSelected(0);
+            else
+                setSelected(selectedIndex.Value + 1);
+        }
+
+        public void SelectPrevious()
+        {
+            if (!selectedIndex.HasValue || selectedIndex == 0)
+                setSelected(Count - 1);
+            else
+                setSelected(selectedIndex.Value - 1);
+        }
+
+        public void Deselect() => setSelected(null);
+
+        public void Select(T item)
+        {
+            var newIndex = IndexOf(item);
+
+            if (newIndex < 0)
+                setSelected(null);
+            else
+                setSelected(IndexOf(item));
+        }
+
+        public override void Add(T drawable)
+        {
+            base.Add(drawable);
+
+            Debug.Assert(drawable != null);
+
+            drawable.StateChanged += state => selectionChanged(drawable, state);
+        }
+
+        public override bool Remove(T drawable)
+            => throw new NotSupportedException($"Cannot remove drawables from {nameof(SelectionCycleFillFlowContainer<T>)}");
+
+        private void setSelected(int? value)
+        {
+            if (selectedIndex == value)
+                return;
+
+            // Deselect the previously-selected button
+            if (selectedIndex.HasValue)
+                this[selectedIndex.Value].State = SelectionState.NotSelected;
+
+            selectedIndex = value;
+
+            // Select the newly-selected button
+            if (selectedIndex.HasValue)
+                this[selectedIndex.Value].State = SelectionState.Selected;
+        }
+
+        private void selectionChanged(T drawable, SelectionState state)
+        {
+            if (state == SelectionState.NotSelected)
+                Deselect();
+            else
+                Select(drawable);
+        }
+    }
+}

osu.Game/Graphics/UserInterface/DialogButton.cs

@@ -1,25 +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.Framework.Bindables;
-using osuTK;
-using osuTK.Graphics;
+using System;
+using osu.Framework;
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Graphics.Backgrounds;
-using osu.Game.Graphics.Sprites;
-using osu.Framework.Extensions.Color4Extensions;
-using osu.Framework.Graphics.Effects;
-using osu.Game.Graphics.Containers;
 using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
+using osu.Game.Graphics.Backgrounds;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Graphics.UserInterface
 {
-    public class DialogButton : OsuClickableContainer
+    public class DialogButton : OsuClickableContainer, IStateful<SelectionState>
     {
         private const float idle_width = 0.8f;
         private const float hover_width = 0.9f;
@@ -27,7 +28,22 @@ namespace osu.Game.Graphics.UserInterface
         private const float hover_duration = 500;
         private const float click_duration = 200;
 
-        public readonly BindableBool Selected = new BindableBool();
+        public event Action<SelectionState> StateChanged;
+
+        private SelectionState state;
+
+        public SelectionState State
+        {
+            get => state;
+            set
+            {
+                if (state == value)
+                    return;
+
+                state = value;
+                StateChanged?.Invoke(value);
+            }
+        }
 
         private readonly Container backgroundContainer;
         private readonly Container colourContainer;
@@ -153,7 +169,7 @@ namespace osu.Game.Graphics.UserInterface
 
             updateGlow();
 
-            Selected.ValueChanged += selectionChanged;
+            StateChanged += selectionChanged;
         }
 
         private Color4 buttonColour;
@@ -221,7 +237,7 @@ namespace osu.Game.Graphics.UserInterface
                            .OnComplete(_ =>
                            {
                                clickAnimating = false;
-                               Selected.TriggerChange();
+                               StateChanged?.Invoke(State);
                            });
 
             return base.OnClick(e);
@@ -235,7 +251,7 @@ namespace osu.Game.Graphics.UserInterface
 
         protected override void OnMouseUp(MouseUpEvent e)
         {
-            if (Selected.Value)
+            if (State == SelectionState.Selected)
                 colourContainer.ResizeWidthTo(hover_width, click_duration, Easing.In);
             base.OnMouseUp(e);
         }
@@ -243,7 +259,7 @@ namespace osu.Game.Graphics.UserInterface
         protected override bool OnHover(HoverEvent e)
         {
             base.OnHover(e);
-            Selected.Value = true;
+            State = SelectionState.Selected;
 
             return true;
         }
@@ -251,15 +267,15 @@ namespace osu.Game.Graphics.UserInterface
         protected override void OnHoverLost(HoverLostEvent e)
         {
             base.OnHoverLost(e);
-            Selected.Value = false;
+            State = SelectionState.NotSelected;
         }
 
-        private void selectionChanged(ValueChangedEvent<bool> args)
+        private void selectionChanged(SelectionState newState)
         {
             if (clickAnimating)
                 return;
 
-            if (args.NewValue)
+            if (newState == SelectionState.Selected)
             {
                 spriteText.TransformSpacingTo(hoverSpacing, hover_duration, Easing.OutElastic);
                 colourContainer.ResizeWidthTo(hover_width, hover_duration, Easing.OutElastic);

osu.Game/Graphics/UserInterfaceV2/DirectorySelector.cs

@@ -1,297 +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.Linq;
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Input.Events;
-using osu.Framework.Platform;
-using osu.Game.Graphics.Containers;
-using osu.Game.Graphics.Sprites;
-using osuTK;
-using osuTK.Graphics;
-
-namespace osu.Game.Graphics.UserInterfaceV2
-{
-    public class DirectorySelector : CompositeDrawable
-    {
-        private FillFlowContainer directoryFlow;
-
-        [Resolved]
-        private GameHost host { get; set; }
-
-        [Cached]
-        public readonly Bindable<DirectoryInfo> CurrentPath = new Bindable<DirectoryInfo>();
-
-        public DirectorySelector(string initialPath = null)
-        {
-            CurrentPath.Value = new DirectoryInfo(initialPath ?? Environment.GetFolderPath(Environment.SpecialFolder.UserProfile));
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            Padding = new MarginPadding(10);
-
-            InternalChild = new GridContainer
-            {
-                RelativeSizeAxes = Axes.Both,
-                RowDimensions = new[]
-                {
-                    new Dimension(GridSizeMode.Absolute, 50),
-                    new Dimension(),
-                },
-                Content = new[]
-                {
-                    new Drawable[]
-                    {
-                        new CurrentDirectoryDisplay
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                        },
-                    },
-                    new Drawable[]
-                    {
-                        new OsuScrollContainer
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            Child = directoryFlow = new FillFlowContainer
-                            {
-                                AutoSizeAxes = Axes.Y,
-                                RelativeSizeAxes = Axes.X,
-                                Direction = FillDirection.Vertical,
-                                Spacing = new Vector2(2),
-                            }
-                        }
-                    }
-                }
-            };
-
-            CurrentPath.BindValueChanged(updateDisplay, true);
-        }
-
-        private void updateDisplay(ValueChangedEvent<DirectoryInfo> directory)
-        {
-            directoryFlow.Clear();
-
-            try
-            {
-                if (directory.NewValue == null)
-                {
-                    var drives = DriveInfo.GetDrives();
-
-                    foreach (var drive in drives)
-                        directoryFlow.Add(new DirectoryPiece(drive.RootDirectory));
-                }
-                else
-                {
-                    directoryFlow.Add(new ParentDirectoryPiece(CurrentPath.Value.Parent));
-
-                    directoryFlow.AddRange(GetEntriesForPath(CurrentPath.Value));
-                }
-            }
-            catch (Exception)
-            {
-                CurrentPath.Value = directory.OldValue;
-                this.FlashColour(Color4.Red, 300);
-            }
-        }
-
-        protected virtual IEnumerable<DisplayPiece> GetEntriesForPath(DirectoryInfo path)
-        {
-            foreach (var dir in path.GetDirectories().OrderBy(d => d.Name))
-            {
-                if ((dir.Attributes & FileAttributes.Hidden) == 0)
-                    yield return new DirectoryPiece(dir);
-            }
-        }
-
-        private class CurrentDirectoryDisplay : CompositeDrawable
-        {
-            [Resolved]
-            private Bindable<DirectoryInfo> currentDirectory { get; set; }
-
-            private FillFlowContainer flow;
-
-            [BackgroundDependencyLoader]
-            private void load()
-            {
-                InternalChildren = new Drawable[]
-                {
-                    flow = new FillFlowContainer
-                    {
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        RelativeSizeAxes = Axes.X,
-                        Spacing = new Vector2(5),
-                        Height = DisplayPiece.HEIGHT,
-                        Direction = FillDirection.Horizontal,
-                    },
-                };
-
-                currentDirectory.BindValueChanged(updateDisplay, true);
-            }
-
-            private void updateDisplay(ValueChangedEvent<DirectoryInfo> dir)
-            {
-                flow.Clear();
-
-                List<DirectoryPiece> pathPieces = new List<DirectoryPiece>();
-
-                DirectoryInfo ptr = dir.NewValue;
-
-                while (ptr != null)
-                {
-                    pathPieces.Insert(0, new CurrentDisplayPiece(ptr));
-                    ptr = ptr.Parent;
-                }
-
-                flow.ChildrenEnumerable = new Drawable[]
-                {
-                    new OsuSpriteText { Text = "Current Directory: ", Font = OsuFont.Default.With(size: DisplayPiece.HEIGHT), },
-                    new ComputerPiece(),
-                }.Concat(pathPieces);
-            }
-
-            private class ComputerPiece : CurrentDisplayPiece
-            {
-                protected override IconUsage? Icon => null;
-
-                public ComputerPiece()
-                    : base(null, "Computer")
-                {
-                }
-            }
-
-            private class CurrentDisplayPiece : DirectoryPiece
-            {
-                public CurrentDisplayPiece(DirectoryInfo directory, string displayName = null)
-                    : base(directory, displayName)
-                {
-                }
-
-                [BackgroundDependencyLoader]
-                private void load()
-                {
-                    Flow.Add(new SpriteIcon
-                    {
-                        Anchor = Anchor.CentreLeft,
-                        Origin = Anchor.CentreLeft,
-                        Icon = FontAwesome.Solid.ChevronRight,
-                        Size = new Vector2(FONT_SIZE / 2)
-                    });
-                }
-
-                protected override IconUsage? Icon => Directory.Name.Contains(Path.DirectorySeparatorChar) ? base.Icon : null;
-            }
-        }
-
-        private class ParentDirectoryPiece : DirectoryPiece
-        {
-            protected override IconUsage? Icon => FontAwesome.Solid.Folder;
-
-            public ParentDirectoryPiece(DirectoryInfo directory)
-                : base(directory, "..")
-            {
-            }
-        }
-
-        protected class DirectoryPiece : DisplayPiece
-        {
-            protected readonly DirectoryInfo Directory;
-
-            [Resolved]
-            private Bindable<DirectoryInfo> currentDirectory { get; set; }
-
-            public DirectoryPiece(DirectoryInfo directory, string displayName = null)
-                : base(displayName)
-            {
-                Directory = directory;
-            }
-
-            protected override bool OnClick(ClickEvent e)
-            {
-                currentDirectory.Value = Directory;
-                return true;
-            }
-
-            protected override string FallbackName => Directory.Name;
-
-            protected override IconUsage? Icon => Directory.Name.Contains(Path.DirectorySeparatorChar)
-                ? FontAwesome.Solid.Database
-                : FontAwesome.Regular.Folder;
-        }
-
-        protected abstract class DisplayPiece : CompositeDrawable
-        {
-            public const float HEIGHT = 20;
-
-            protected const float FONT_SIZE = 16;
-
-            private readonly string displayName;
-
-            protected FillFlowContainer Flow;
-
-            protected DisplayPiece(string displayName = null)
-            {
-                this.displayName = displayName;
-            }
-
-            [BackgroundDependencyLoader]
-            private void load(OsuColour colours)
-            {
-                AutoSizeAxes = Axes.Both;
-
-                Masking = true;
-                CornerRadius = 5;
-
-                InternalChildren = new Drawable[]
-                {
-                    new Box
-                    {
-                        Colour = colours.GreySeafoamDarker,
-                        RelativeSizeAxes = Axes.Both,
-                    },
-                    Flow = new FillFlowContainer
-                    {
-                        AutoSizeAxes = Axes.X,
-                        Height = 20,
-                        Margin = new MarginPadding { Vertical = 2, Horizontal = 5 },
-                        Direction = FillDirection.Horizontal,
-                        Spacing = new Vector2(5),
-                    }
-                };
-
-                if (Icon.HasValue)
-                {
-                    Flow.Add(new SpriteIcon
-                    {
-                        Anchor = Anchor.CentreLeft,
-                        Origin = Anchor.CentreLeft,
-                        Icon = Icon.Value,
-                        Size = new Vector2(FONT_SIZE)
-                    });
-                }
-
-                Flow.Add(new OsuSpriteText
-                {
-                    Anchor = Anchor.CentreLeft,
-                    Origin = Anchor.CentreLeft,
-                    Text = displayName ?? FallbackName,
-                    Font = OsuFont.Default.With(size: FONT_SIZE)
-                });
-            }
-
-            protected abstract string FallbackName { get; }
-
-            protected abstract IconUsage? Icon { get; }
-        }
-    }
-}

osu.Game/Graphics/UserInterfaceV2/FileSelector.cs

@@ -1,94 +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.Linq;
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Input.Events;
-
-namespace osu.Game.Graphics.UserInterfaceV2
-{
-    public class FileSelector : DirectorySelector
-    {
-        private readonly string[] validFileExtensions;
-
-        [Cached]
-        public readonly Bindable<FileInfo> CurrentFile = new Bindable<FileInfo>();
-
-        public FileSelector(string initialPath = null, string[] validFileExtensions = null)
-            : base(initialPath)
-        {
-            this.validFileExtensions = validFileExtensions ?? Array.Empty<string>();
-        }
-
-        protected override IEnumerable<DisplayPiece> GetEntriesForPath(DirectoryInfo path)
-        {
-            foreach (var dir in base.GetEntriesForPath(path))
-                yield return dir;
-
-            IEnumerable<FileInfo> files = path.GetFiles();
-
-            if (validFileExtensions.Length > 0)
-                files = files.Where(f => validFileExtensions.Contains(f.Extension));
-
-            foreach (var file in files.OrderBy(d => d.Name))
-            {
-                if ((file.Attributes & FileAttributes.Hidden) == 0)
-                    yield return new FilePiece(file);
-            }
-        }
-
-        protected class FilePiece : DisplayPiece
-        {
-            private readonly FileInfo file;
-
-            [Resolved]
-            private Bindable<FileInfo> currentFile { get; set; }
-
-            public FilePiece(FileInfo file)
-            {
-                this.file = file;
-            }
-
-            protected override bool OnClick(ClickEvent e)
-            {
-                currentFile.Value = file;
-                return true;
-            }
-
-            protected override string FallbackName => file.Name;
-
-            protected override IconUsage? Icon
-            {
-                get
-                {
-                    switch (file.Extension)
-                    {
-                        case ".ogg":
-                        case ".mp3":
-                        case ".wav":
-                            return FontAwesome.Regular.FileAudio;
-
-                        case ".jpg":
-                        case ".jpeg":
-                        case ".png":
-                            return FontAwesome.Regular.FileImage;
-
-                        case ".mp4":
-                        case ".avi":
-                        case ".mov":
-                        case ".flv":
-                            return FontAwesome.Regular.FileVideo;
-
-                        default:
-                            return FontAwesome.Regular.File;
-                    }
-                }
-            }
-        }
-    }
-}

osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelector.cs

@@ -0,0 +1,38 @@
+// 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.IO;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Graphics.Containers;
+
+namespace osu.Game.Graphics.UserInterfaceV2
+{
+    public class OsuDirectorySelector : DirectorySelector
+    {
+        public const float ITEM_HEIGHT = 20;
+
+        public OsuDirectorySelector(string initialPath = null)
+            : base(initialPath)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Padding = new MarginPadding(10);
+        }
+
+        protected override ScrollContainer<Drawable> CreateScrollContainer() => new OsuScrollContainer();
+
+        protected override DirectorySelectorBreadcrumbDisplay CreateBreadcrumb() => new OsuDirectorySelectorBreadcrumbDisplay();
+
+        protected override DirectorySelectorDirectory CreateParentDirectoryItem(DirectoryInfo directory) => new OsuDirectorySelectorParentDirectory(directory);
+
+        protected override DirectorySelectorDirectory CreateDirectoryItem(DirectoryInfo directory, string displayName = null) => new OsuDirectorySelectorDirectory(directory, displayName);
+
+        protected override void NotifySelectionError() => this.FlashColour(Colour4.Red, 300);
+    }
+}

osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelectorBreadcrumbDisplay.cs

@@ -0,0 +1,64 @@
+// 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.IO;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Graphics.Sprites;
+using osuTK;
+
+namespace osu.Game.Graphics.UserInterfaceV2
+{
+    internal class OsuDirectorySelectorBreadcrumbDisplay : DirectorySelectorBreadcrumbDisplay
+    {
+        protected override Drawable CreateCaption() => new OsuSpriteText
+        {
+            Text = "Current Directory: ",
+            Font = OsuFont.Default.With(size: OsuDirectorySelector.ITEM_HEIGHT),
+        };
+
+        protected override DirectorySelectorDirectory CreateRootDirectoryItem() => new OsuBreadcrumbDisplayComputer();
+
+        protected override DirectorySelectorDirectory CreateDirectoryItem(DirectoryInfo directory, string displayName = null) => new OsuBreadcrumbDisplayDirectory(directory, displayName);
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Height = 50;
+        }
+
+        private class OsuBreadcrumbDisplayComputer : OsuBreadcrumbDisplayDirectory
+        {
+            protected override IconUsage? Icon => null;
+
+            public OsuBreadcrumbDisplayComputer()
+                : base(null, "Computer")
+            {
+            }
+        }
+
+        private class OsuBreadcrumbDisplayDirectory : OsuDirectorySelectorDirectory
+        {
+            public OsuBreadcrumbDisplayDirectory(DirectoryInfo directory, string displayName = null)
+                : base(directory, displayName)
+            {
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                Flow.Add(new SpriteIcon
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    Icon = FontAwesome.Solid.ChevronRight,
+                    Size = new Vector2(FONT_SIZE / 2)
+                });
+            }
+
+            protected override IconUsage? Icon => Directory.Name.Contains(Path.DirectorySeparatorChar) ? base.Icon : null;
+        }
+    }
+}

osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelectorDirectory.cs

@@ -0,0 +1,58 @@
+// 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.IO;
+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.Framework.Graphics.UserInterface;
+using osu.Game.Graphics.Sprites;
+
+namespace osu.Game.Graphics.UserInterfaceV2
+{
+    internal class OsuDirectorySelectorDirectory : DirectorySelectorDirectory
+    {
+        public OsuDirectorySelectorDirectory(DirectoryInfo directory, string displayName = null)
+            : base(directory, displayName)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Flow.AutoSizeAxes = Axes.X;
+            Flow.Height = OsuDirectorySelector.ITEM_HEIGHT;
+
+            AddInternal(new Background
+            {
+                Depth = 1
+            });
+        }
+
+        protected override SpriteText CreateSpriteText() => new OsuSpriteText();
+
+        protected override IconUsage? Icon => Directory.Name.Contains(Path.DirectorySeparatorChar)
+            ? FontAwesome.Solid.Database
+            : FontAwesome.Regular.Folder;
+
+        internal class Background : CompositeDrawable
+        {
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                RelativeSizeAxes = Axes.Both;
+
+                Masking = true;
+                CornerRadius = 5;
+
+                InternalChild = new Box
+                {
+                    Colour = colours.GreySeafoamDarker,
+                    RelativeSizeAxes = Axes.Both,
+                };
+            }
+        }
+    }
+}

osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelectorParentDirectory.cs

@@ -0,0 +1,18 @@
+// 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.IO;
+using osu.Framework.Graphics.Sprites;
+
+namespace osu.Game.Graphics.UserInterfaceV2
+{
+    internal class OsuDirectorySelectorParentDirectory : OsuDirectorySelectorDirectory
+    {
+        protected override IconUsage? Icon => FontAwesome.Solid.Folder;
+
+        public OsuDirectorySelectorParentDirectory(DirectoryInfo directory)
+            : base(directory, "..")
+        {
+        }
+    }
+}

osu.Game/Graphics/UserInterfaceV2/OsuFileSelector.cs

@@ -0,0 +1,90 @@
+// 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.IO;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+
+namespace osu.Game.Graphics.UserInterfaceV2
+{
+    public class OsuFileSelector : FileSelector
+    {
+        public OsuFileSelector(string initialPath = null, string[] validFileExtensions = null)
+            : base(initialPath, validFileExtensions)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Padding = new MarginPadding(10);
+        }
+
+        protected override ScrollContainer<Drawable> CreateScrollContainer() => new OsuScrollContainer();
+
+        protected override DirectorySelectorBreadcrumbDisplay CreateBreadcrumb() => new OsuDirectorySelectorBreadcrumbDisplay();
+
+        protected override DirectorySelectorDirectory CreateParentDirectoryItem(DirectoryInfo directory) => new OsuDirectorySelectorParentDirectory(directory);
+
+        protected override DirectorySelectorDirectory CreateDirectoryItem(DirectoryInfo directory, string displayName = null) => new OsuDirectorySelectorDirectory(directory, displayName);
+
+        protected override DirectoryListingFile CreateFileItem(FileInfo file) => new OsuDirectoryListingFile(file);
+
+        protected override void NotifySelectionError() => this.FlashColour(Colour4.Red, 300);
+
+        protected class OsuDirectoryListingFile : DirectoryListingFile
+        {
+            public OsuDirectoryListingFile(FileInfo file)
+                : base(file)
+            {
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                Flow.AutoSizeAxes = Axes.X;
+                Flow.Height = OsuDirectorySelector.ITEM_HEIGHT;
+
+                AddInternal(new OsuDirectorySelectorDirectory.Background
+                {
+                    Depth = 1
+                });
+            }
+
+            protected override IconUsage? Icon
+            {
+                get
+                {
+                    switch (File.Extension)
+                    {
+                        case @".ogg":
+                        case @".mp3":
+                        case @".wav":
+                            return FontAwesome.Regular.FileAudio;
+
+                        case @".jpg":
+                        case @".jpeg":
+                        case @".png":
+                            return FontAwesome.Regular.FileImage;
+
+                        case @".mp4":
+                        case @".avi":
+                        case @".mov":
+                        case @".flv":
+                            return FontAwesome.Regular.FileVideo;
+
+                        default:
+                            return FontAwesome.Regular.File;
+                    }
+                }
+            }
+
+            protected override SpriteText CreateSpriteText() => new OsuSpriteText();
+        }
+    }
+}

osu.Game/IO/OsuStorage.cs

@@ -102,8 +102,15 @@ namespace osu.Game.IO
 
         protected override void ChangeTargetStorage(Storage newStorage)
         {
+            var lastStorage = UnderlyingStorage;
             base.ChangeTargetStorage(newStorage);
-            Logger.Storage = UnderlyingStorage.GetStorageForDirectory("logs");
+
+            if (lastStorage != null)
+            {
+                // for now we assume that if there was a previous storage, this is a migration operation.
+                // the logger shouldn't be set during initialisation as it can cause cross-talk in tests (due to being static).
+                Logger.Storage = UnderlyingStorage.GetStorageForDirectory("logs");
+            }
         }
 
         public override void Migrate(Storage newStorage)

osu.Game/Input/Bindings/GlobalActionContainer.cs

@@ -87,6 +87,8 @@ namespace osu.Game.Input.Bindings
             new KeyBinding(new[] { InputKey.Shift, InputKey.Tab }, GlobalAction.ToggleInGameInterface),
             new KeyBinding(InputKey.MouseMiddle, GlobalAction.PauseGameplay),
             new KeyBinding(InputKey.Space, GlobalAction.TogglePauseReplay),
+            new KeyBinding(InputKey.Left, GlobalAction.SeekReplayBackward),
+            new KeyBinding(InputKey.Right, GlobalAction.SeekReplayForward),
             new KeyBinding(InputKey.Control, GlobalAction.HoldForHUD),
         };
 
@@ -103,6 +105,9 @@ namespace osu.Game.Input.Bindings
             new KeyBinding(new[] { InputKey.Alt, InputKey.Up }, GlobalAction.IncreaseVolume),
             new KeyBinding(new[] { InputKey.Alt, InputKey.Down }, GlobalAction.DecreaseVolume),
 
+            new KeyBinding(new[] { InputKey.Alt, InputKey.Left }, GlobalAction.PreviousVolumeMeter),
+            new KeyBinding(new[] { InputKey.Alt, InputKey.Right }, GlobalAction.NextVolumeMeter),
+
             new KeyBinding(new[] { InputKey.Control, InputKey.F4 }, GlobalAction.ToggleMute),
 
             new KeyBinding(InputKey.TrackPrevious, GlobalAction.MusicPrev),
@@ -263,5 +268,17 @@ namespace osu.Game.Input.Bindings
 
         [Description("Toggle skin editor")]
         ToggleSkinEditor,
+
+        [Description("Previous volume meter")]
+        PreviousVolumeMeter,
+
+        [Description("Next volume meter")]
+        NextVolumeMeter,
+
+        [Description("Seek replay forward")]
+        SeekReplayForward,
+
+        [Description("Seek replay backward")]
+        SeekReplayBackward,
     }
 }

osu.Game/Localisation/ButtonSystem.ja.resx

@@ -1,38 +0,0 @@
-<root>
-    <resheader name="resmimetype">
-        <value>text/microsoft-resx</value>
-    </resheader>
-    <resheader name="version">
-        <value>1.3</value>
-    </resheader>
-    <resheader name="reader">
-        <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-    </resheader>
-    <resheader name="writer">
-        <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-    </resheader>
-    <data name="solo" xml:space="preserve">
-        <value>ソロ</value>
-    </data>
-    <data name="playlists" xml:space="preserve">
-        <value>プレイリスト</value>
-    </data>
-    <data name="play" xml:space="preserve">
-        <value>遊ぶ</value>
-    </data>
-    <data name="multi" xml:space="preserve">
-        <value>マルチ</value>
-    </data>
-    <data name="edit" xml:space="preserve">
-        <value>エディット</value>
-    </data>
-    <data name="browse" xml:space="preserve">
-        <value>ブラウズ</value>
-    </data>
-    <data name="exit" xml:space="preserve">
-        <value>閉じる</value>
-    </data>
-    <data name="settings" xml:space="preserve">
-        <value>設定</value>
-    </data>
-</root>

osu.Game/Localisation/ButtonSystem.resx

@@ -1,88 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <data name="solo" xml:space="preserve">
-    <value>solo</value>
-  </data>
-  <data name="multi" xml:space="preserve">
-    <value>multi</value>
-  </data>
-  <data name="playlists" xml:space="preserve">
-    <value>playlists</value>
-  </data>
-  <data name="play" xml:space="preserve">
-    <value>play</value>
-  </data>
-  <data name="edit" xml:space="preserve">
-    <value>edit</value>
-  </data>
-  <data name="browse" xml:space="preserve">
-    <value>browse</value>
-  </data>
-  <data name="settings" xml:space="preserve">
-    <value>settings</value>
-  </data>
-  <data name="back" xml:space="preserve">
-    <value>back</value>
-  </data>
-  <data name="exit" xml:space="preserve">
-    <value>exit</value>
-  </data>
-</root>

osu.Game/Localisation/ButtonSystemStrings.cs

@@ -7,7 +7,7 @@ namespace osu.Game.Localisation
 {
     public static class ButtonSystemStrings
     {
-        private const string prefix = @"osu.Game.Localisation.ButtonSystem";
+        private const string prefix = @"osu.Game.Resources.Localisation.ButtonSystem";
 
         /// <summary>
         /// "solo"
@@ -56,4 +56,4 @@ namespace osu.Game.Localisation
 
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
-}
+}

osu.Game/Localisation/Chat.resx

@@ -1,67 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <data name="header_title" xml:space="preserve">
-    <value>chat</value>
-  </data>
-  <data name="header_description" xml:space="preserve">
-    <value>join the real-time discussion</value>
-  </data>
-</root>

osu.Game/Localisation/ChatStrings.cs

@@ -7,7 +7,7 @@ namespace osu.Game.Localisation
 {
     public static class ChatStrings
     {
-        private const string prefix = @"osu.Game.Localisation.Chat";
+        private const string prefix = @"osu.Game.Resources.Localisation.Chat";
 
         /// <summary>
         /// "chat"

osu.Game/Localisation/Common.resx

@@ -1,64 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <data name="cancel" xml:space="preserve">
-    <value>Cancel</value>
-  </data>
-</root>

osu.Game/Localisation/CommonStrings.cs

@@ -7,7 +7,7 @@ namespace osu.Game.Localisation
 {
     public static class CommonStrings
     {
-        private const string prefix = @"osu.Game.Localisation.Common";
+        private const string prefix = @"osu.Game.Resources.Localisation.Common";
 
         /// <summary>
         /// "Cancel"

osu.Game/Localisation/Notifications.resx

@@ -1,67 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <data name="header_title" xml:space="preserve">
-    <value>notifications</value>
-  </data>
-  <data name="header_description" xml:space="preserve">
-    <value>waiting for 'ya</value>
-  </data>
-</root>

osu.Game/Localisation/NotificationsStrings.cs

@@ -7,7 +7,7 @@ namespace osu.Game.Localisation
 {
     public static class NotificationsStrings
     {
-        private const string prefix = @"osu.Game.Localisation.Notifications";
+        private const string prefix = @"osu.Game.Resources.Localisation.Notifications";
 
         /// <summary>
         /// "notifications"

osu.Game/Localisation/NowPlaying.resx

@@ -1,67 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <data name="header_title" xml:space="preserve">
-    <value>now playing</value>
-  </data>
-  <data name="header_description" xml:space="preserve">
-    <value>manage the currently playing track</value>
-  </data>
-</root>

osu.Game/Localisation/NowPlayingStrings.cs

@@ -7,7 +7,7 @@ namespace osu.Game.Localisation
 {
     public static class NowPlayingStrings
     {
-        private const string prefix = @"osu.Game.Localisation.NowPlaying";
+        private const string prefix = @"osu.Game.Resources.Localisation.NowPlaying";
 
         /// <summary>
         /// "now playing"

osu.Game/Localisation/Settings.resx

@@ -1,67 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <data name="header_title" xml:space="preserve">
-    <value>settings</value>
-  </data>
-  <data name="header_description" xml:space="preserve">
-    <value>change the way osu! behaves</value>
-  </data>
-</root>

osu.Game/Localisation/SettingsStrings.cs

@@ -7,7 +7,7 @@ namespace osu.Game.Localisation
 {
     public static class SettingsStrings
     {
-        private const string prefix = @"osu.Game.Localisation.Settings";
+        private const string prefix = @"osu.Game.Resources.Localisation.Settings";
 
         /// <summary>
         /// "settings"

osu.Game/Online/Chat/DrawableLinkCompiler.cs

@@ -28,7 +28,7 @@ namespace osu.Game.Online.Chat
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => Parts.Any(d => d.ReceivePositionalInputAt(screenSpacePos));
 
-        protected override HoverClickSounds CreateHoverClickSounds(HoverSampleSet sampleSet) => new LinkHoverSounds(sampleSet, Parts);
+        protected override HoverSounds CreateHoverSounds(HoverSampleSet sampleSet) => new LinkHoverSounds(sampleSet, Parts);
 
         public DrawableLinkCompiler(IEnumerable<Drawable> parts)
         {

osu.Game/Overlays/Mods/ModSelectOverlay.cs

@@ -429,7 +429,7 @@ namespace osu.Game.Overlays.Mods
                 if (!Stacked)
                     modEnumeration = ModUtils.FlattenMods(modEnumeration);
 
-                section.Mods = modEnumeration.Select(getValidModOrNull).Where(m => m != null);
+                section.Mods = modEnumeration.Select(getValidModOrNull).Where(m => m != null).Select(m => m.CreateCopy());
             }
 
             updateSelectedButtons();

osu.Game/Overlays/Profile/Header/Components/ExpandDetailsButton.cs

@@ -2,11 +2,14 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics.UserInterface;
 using osuTK;
 
 namespace osu.Game.Overlays.Profile.Header.Components
@@ -18,18 +21,29 @@ namespace osu.Game.Overlays.Profile.Header.Components
         public override LocalisableString TooltipText => DetailsVisible.Value ? "collapse" : "expand";
 
         private SpriteIcon icon;
+        private Sample sampleOpen;
+        private Sample sampleClose;
+
+        protected override HoverSounds CreateHoverSounds(HoverSampleSet sampleSet) => new HoverSounds();
 
         public ExpandDetailsButton()
         {
-            Action = () => DetailsVisible.Toggle();
+            Action = () =>
+            {
+                DetailsVisible.Toggle();
+                (DetailsVisible.Value ? sampleOpen : sampleClose)?.Play();
+            };
         }
 
         [BackgroundDependencyLoader]
-        private void load(OverlayColourProvider colourProvider)
+        private void load(OverlayColourProvider colourProvider, AudioManager audio)
         {
             IdleColour = colourProvider.Background2;
             HoverColour = colourProvider.Background2.Lighten(0.2f);
 
+            sampleOpen = audio.Samples.Get(@"UI/dropdown-open");
+            sampleClose = audio.Samples.Get(@"UI/dropdown-close");
+
             Child = icon = new SpriteIcon
             {
                 Anchor = Anchor.Centre,

osu.Game/Overlays/Rankings/CountryFilter.cs

@@ -1,4 +1,4 @@
-// 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;
@@ -17,7 +17,7 @@ namespace osu.Game.Overlays.Rankings
     public class CountryFilter : CompositeDrawable, IHasCurrentValue<Country>
     {
         private const int duration = 200;
-        private const int height = 50;
+        private const int height = 70;
 
         private readonly BindableWithCurrent<Country> current = new BindableWithCurrent<Country>();
 

osu.Game/Overlays/Rankings/CountryPill.cs

@@ -42,7 +42,7 @@ namespace osu.Game.Overlays.Rankings
 
             InternalChild = content = new CircularContainer
             {
-                Height = 25,
+                Height = 30,
                 AutoSizeDuration = duration,
                 AutoSizeEasing = Easing.OutQuint,
                 Masking = true,
@@ -58,9 +58,9 @@ namespace osu.Game.Overlays.Rankings
                         Origin = Anchor.Centre,
                         RelativeSizeAxes = Axes.Y,
                         AutoSizeAxes = Axes.X,
-                        Margin = new MarginPadding { Horizontal = 10 },
+                        Margin = new MarginPadding { Horizontal = 15 },
                         Direction = FillDirection.Horizontal,
-                        Spacing = new Vector2(8, 0),
+                        Spacing = new Vector2(15, 0),
                         Children = new Drawable[]
                         {
                             new FillFlowContainer
@@ -70,14 +70,14 @@ namespace osu.Game.Overlays.Rankings
                                 Anchor = Anchor.Centre,
                                 Origin = Anchor.Centre,
                                 Direction = FillDirection.Horizontal,
-                                Spacing = new Vector2(3, 0),
+                                Spacing = new Vector2(5, 0),
                                 Children = new Drawable[]
                                 {
                                     flag = new UpdateableFlag
                                     {
                                         Anchor = Anchor.Centre,
                                         Origin = Anchor.Centre,
-                                        Size = new Vector2(22, 15)
+                                        Size = new Vector2(30, 20)
                                     },
                                     countryName = new OsuSpriteText
                                     {
@@ -148,7 +148,7 @@ namespace osu.Game.Overlays.Rankings
                 AutoSizeAxes = Axes.Both;
                 Add(icon = new SpriteIcon
                 {
-                    Size = new Vector2(8),
+                    Size = new Vector2(10),
                     Icon = FontAwesome.Solid.Times
                 });
             }

osu.Game/Overlays/Rankings/SpotlightSelector.cs

@@ -15,6 +15,7 @@ using System;
 using System.Collections.Generic;
 using osu.Framework.Graphics.UserInterface;
 using osu.Game.Online.API.Requests;
+using osu.Framework.Extensions.Color4Extensions;
 
 namespace osu.Game.Overlays.Rankings
 {
@@ -46,6 +47,7 @@ namespace osu.Game.Overlays.Rankings
         {
             RelativeSizeAxes = Axes.X;
             AutoSizeAxes = Axes.Y;
+
             InternalChildren = new Drawable[]
             {
                 background = new Box
@@ -139,7 +141,7 @@ namespace osu.Game.Overlays.Rankings
             {
                 AutoSizeAxes = Axes.Both;
                 Direction = FillDirection.Vertical;
-                Margin = new MarginPadding { Vertical = 10 };
+                Padding = new MarginPadding { Vertical = 15 };
                 Children = new Drawable[]
                 {
                     new OsuSpriteText
@@ -150,11 +152,11 @@ namespace osu.Game.Overlays.Rankings
                     new Container
                     {
                         AutoSizeAxes = Axes.X,
-                        Height = 20,
+                        Height = 25,
                         Child = valueText = new OsuSpriteText
                         {
-                            Anchor = Anchor.BottomLeft,
-                            Origin = Anchor.BottomLeft,
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
                             Font = OsuFont.GetFont(size: 20, weight: FontWeight.Light),
                         }
                     }
@@ -174,11 +176,34 @@ namespace osu.Game.Overlays.Rankings
 
             protected override DropdownMenu CreateMenu() => menu = base.CreateMenu().With(m => m.MaxHeight = 400);
 
+            protected override DropdownHeader CreateHeader() => new SpotlightsDropdownHeader();
+
             [BackgroundDependencyLoader]
             private void load(OverlayColourProvider colourProvider)
             {
+                // osu-web adds a 0.6 opacity container on top of the 0.5 base one when hovering, 0.8 on a single container here matches the resulting colour
+                AccentColour = colourProvider.Background6.Opacity(0.8f);
                 menu.BackgroundColour = colourProvider.Background5;
-                AccentColour = colourProvider.Background6;
+                Padding = new MarginPadding { Vertical = 20 };
+            }
+
+            private class SpotlightsDropdownHeader : OsuDropdownHeader
+            {
+                public SpotlightsDropdownHeader()
+                {
+                    AutoSizeAxes = Axes.Y;
+                    Text.Font = OsuFont.GetFont(size: 15);
+                    Text.Padding = new MarginPadding { Vertical = 1.5f }; // osu-web line-height difference compensation
+                    Foreground.Padding = new MarginPadding { Horizontal = 10, Vertical = 15 };
+                    Margin = Icon.Margin = new MarginPadding(0);
+                }
+
+                [BackgroundDependencyLoader]
+                private void load(OverlayColourProvider colourProvider)
+                {
+                    BackgroundColour = colourProvider.Background6.Opacity(0.5f);
+                    BackgroundColourHover = colourProvider.Background5;
+                }
             }
         }
     }

osu.Game/Overlays/Rankings/Tables/CountriesTable.cs

@@ -1,15 +1,14 @@
-// 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.Graphics;
 using osu.Framework.Graphics.Containers;
 using System;
 using osu.Game.Users;
-using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
 using System.Collections.Generic;
 using osu.Framework.Allocation;
-using osu.Game.Graphics.Containers;
 
 namespace osu.Game.Overlays.Rankings.Tables
 {
@@ -62,35 +61,20 @@ namespace osu.Game.Overlays.Rankings.Tables
             }
         };
 
-        private class CountryName : OsuHoverContainer
+        private class CountryName : LinkFlowContainer
         {
-            protected override IEnumerable<Drawable> EffectTargets => new[] { text };
-
             [Resolved(canBeNull: true)]
             private RankingsOverlay rankings { get; set; }
 
-            private readonly OsuSpriteText text;
-            private readonly Country country;
-
             public CountryName(Country country)
+                : base(t => t.Font = OsuFont.GetFont(size: 12))
             {
-                this.country = country;
+                AutoSizeAxes = Axes.X;
+                RelativeSizeAxes = Axes.Y;
+                TextAnchor = Anchor.CentreLeft;
 
-                AutoSizeAxes = Axes.Both;
-                Add(text = new OsuSpriteText
-                {
-                    Font = OsuFont.GetFont(size: 12),
-                    Text = country.FullName ?? string.Empty,
-                });
-            }
-
-            [BackgroundDependencyLoader]
-            private void load(OverlayColourProvider colourProvider)
-            {
-                IdleColour = colourProvider.Light2;
-                HoverColour = colourProvider.Content2;
-
-                Action = () => rankings?.ShowCountry(country);
+                if (!string.IsNullOrEmpty(country.FullName))
+                    AddLink(country.FullName, () => rankings?.ShowCountry(country));
             }
         }
     }

osu.Game/Overlays/Rankings/Tables/RankingsTable.cs

@@ -1,4 +1,4 @@
-// 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.Graphics;
@@ -20,7 +20,8 @@ namespace osu.Game.Overlays.Rankings.Tables
     {
         protected const int TEXT_SIZE = 12;
         private const float horizontal_inset = 20;
-        private const float row_height = 25;
+        private const float row_height = 32;
+        private const float row_spacing = 3;
         private const int items_per_page = 50;
 
         private readonly int page;
@@ -35,7 +36,7 @@ namespace osu.Game.Overlays.Rankings.Tables
             AutoSizeAxes = Axes.Y;
 
             Padding = new MarginPadding { Horizontal = horizontal_inset };
-            RowSize = new Dimension(GridSizeMode.Absolute, row_height);
+            RowSize = new Dimension(GridSizeMode.Absolute, row_height + row_spacing);
         }
 
         [BackgroundDependencyLoader]
@@ -47,10 +48,11 @@ namespace osu.Game.Overlays.Rankings.Tables
             {
                 RelativeSizeAxes = Axes.Both,
                 Depth = 1f,
-                Margin = new MarginPadding { Top = row_height }
+                Margin = new MarginPadding { Top = row_height + row_spacing },
+                Spacing = new Vector2(0, row_spacing),
             });
 
-            rankings.ForEach(_ => backgroundFlow.Add(new TableRowBackground()));
+            rankings.ForEach(_ => backgroundFlow.Add(new TableRowBackground { Height = row_height }));
 
             Columns = mainHeaders.Concat(CreateAdditionalHeaders()).ToArray();
             Content = rankings.Select((s, i) => createContent((page - 1) * items_per_page + i, s)).ToArray().ToRectangular();
@@ -68,13 +70,19 @@ namespace osu.Game.Overlays.Rankings.Tables
 
         protected abstract Drawable[] CreateAdditionalContent(TModel item);
 
-        protected override Drawable CreateHeader(int index, TableColumn column) => new HeaderText(column?.Header ?? string.Empty, HighlightedColumn());
+        protected virtual string HighlightedColumn => @"Performance";
+
+        protected override Drawable CreateHeader(int index, TableColumn column)
+        {
+            var title = column?.Header ?? string.Empty;
+            return new HeaderText(title, title == HighlightedColumn);
+        }
 
         protected abstract Country GetCountry(TModel item);
 
         protected abstract Drawable CreateFlagContent(TModel item);
 
-        private OsuSpriteText createIndexDrawable(int index) => new OsuSpriteText
+        private OsuSpriteText createIndexDrawable(int index) => new RowText
         {
             Text = $"#{index + 1}",
             Font = OsuFont.GetFont(size: TEXT_SIZE, weight: FontWeight.SemiBold)
@@ -84,37 +92,36 @@ namespace osu.Game.Overlays.Rankings.Tables
         {
             AutoSizeAxes = Axes.Both,
             Direction = FillDirection.Horizontal,
-            Spacing = new Vector2(7, 0),
+            Spacing = new Vector2(10, 0),
+            Margin = new MarginPadding { Bottom = row_spacing },
             Children = new[]
             {
                 new UpdateableFlag(GetCountry(item))
                 {
-                    Size = new Vector2(20, 13),
+                    Size = new Vector2(30, 20),
                     ShowPlaceholderOnNull = false,
                 },
                 CreateFlagContent(item)
             }
         };
 
-        protected virtual string HighlightedColumn() => @"Performance";
-
-        private class HeaderText : OsuSpriteText
+        protected class HeaderText : OsuSpriteText
         {
-            private readonly string highlighted;
+            private readonly bool isHighlighted;
 
-            public HeaderText(string text, string highlighted)
+            public HeaderText(string text, bool isHighlighted)
             {
-                this.highlighted = highlighted;
+                this.isHighlighted = isHighlighted;
 
                 Text = text;
                 Font = OsuFont.GetFont(size: 12);
-                Margin = new MarginPadding { Horizontal = 10 };
+                Margin = new MarginPadding { Vertical = 5, Horizontal = 10 };
             }
 
             [BackgroundDependencyLoader]
             private void load(OverlayColourProvider colourProvider)
             {
-                if (Text != highlighted)
+                if (!isHighlighted)
                     Colour = colourProvider.Foreground1;
             }
         }
@@ -124,7 +131,7 @@ namespace osu.Game.Overlays.Rankings.Tables
             public RowText()
             {
                 Font = OsuFont.GetFont(size: TEXT_SIZE);
-                Margin = new MarginPadding { Horizontal = 10 };
+                Margin = new MarginPadding { Horizontal = 10, Bottom = row_spacing };
             }
         }
 

osu.Game/Overlays/Rankings/Tables/ScoresTable.cs

@@ -33,6 +33,6 @@ namespace osu.Game.Overlays.Rankings.Tables
             }
         };
 
-        protected override string HighlightedColumn() => @"Ranked Score";
+        protected override string HighlightedColumn => @"Ranked Score";
     }
 }

osu.Game/Overlays/Rankings/Tables/TableRowBackground.cs

@@ -1,4 +1,4 @@
-// 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;
@@ -22,10 +22,10 @@ namespace osu.Game.Overlays.Rankings.Tables
         public TableRowBackground()
         {
             RelativeSizeAxes = Axes.X;
-            Height = 25;
 
-            CornerRadius = 3;
+            CornerRadius = 4;
             Masking = true;
+            MaskingSmoothness = 0.5f;
 
             InternalChild = background = new Box
             {

osu.Game/Overlays/Rankings/Tables/UserBasedTable.cs

@@ -19,22 +19,32 @@ namespace osu.Game.Overlays.Rankings.Tables
         {
         }
 
+        protected virtual IEnumerable<string> GradeColumns => new List<string> { "SS", "S", "A" };
+
         protected override TableColumn[] CreateAdditionalHeaders() => new[]
+            {
+                new TableColumn("Accuracy", Anchor.Centre, new Dimension(GridSizeMode.AutoSize)),
+                new TableColumn("Play Count", Anchor.Centre, new Dimension(GridSizeMode.AutoSize)),
+            }.Concat(CreateUniqueHeaders())
+             .Concat(GradeColumns.Select(grade => new TableColumn(grade, Anchor.Centre, new Dimension(GridSizeMode.AutoSize))))
+             .ToArray();
+
+        protected override Drawable CreateHeader(int index, TableColumn column)
         {
-            new TableColumn("Accuracy", Anchor.Centre, new Dimension(GridSizeMode.AutoSize)),
-            new TableColumn("Play Count", Anchor.Centre, new Dimension(GridSizeMode.AutoSize)),
-        }.Concat(CreateUniqueHeaders()).Concat(new[]
-        {
-            new TableColumn("SS", Anchor.Centre, new Dimension(GridSizeMode.AutoSize)),
-            new TableColumn("S", Anchor.Centre, new Dimension(GridSizeMode.AutoSize)),
-            new TableColumn("A", Anchor.Centre, new Dimension(GridSizeMode.AutoSize)),
-        }).ToArray();
+            var title = column?.Header ?? string.Empty;
+            return new UserTableHeaderText(title, HighlightedColumn == title, GradeColumns.Contains(title));
+        }
 
         protected sealed override Country GetCountry(UserStatistics item) => item.User.Country;
 
         protected sealed override Drawable CreateFlagContent(UserStatistics item)
         {
-            var username = new LinkFlowContainer(t => t.Font = OsuFont.GetFont(size: TEXT_SIZE, italics: true)) { AutoSizeAxes = Axes.Both };
+            var username = new LinkFlowContainer(t => t.Font = OsuFont.GetFont(size: TEXT_SIZE, italics: true))
+            {
+                AutoSizeAxes = Axes.X,
+                RelativeSizeAxes = Axes.Y,
+                TextAnchor = Anchor.CentreLeft
+            };
             username.AddUserLink(item.User);
             return username;
         }
@@ -53,5 +63,19 @@ namespace osu.Game.Overlays.Rankings.Tables
         protected abstract TableColumn[] CreateUniqueHeaders();
 
         protected abstract Drawable[] CreateUniqueContent(UserStatistics item);
+
+        private class UserTableHeaderText : HeaderText
+        {
+            public UserTableHeaderText(string text, bool isHighlighted, bool isGrade)
+                : base(text, isHighlighted)
+            {
+                Margin = new MarginPadding
+                {
+                    // Grade columns have extra horizontal padding for readibility
+                    Horizontal = isGrade ? 20 : 10,
+                    Vertical = 5
+                };
+            }
+        }
     }
 }

osu.Game/Overlays/Settings/Sections/Maintenance/DirectorySelectScreen.cs

@@ -21,7 +21,7 @@ namespace osu.Game.Overlays.Settings.Sections.Maintenance
     {
         private TriangleButton selectionButton;
 
-        private DirectorySelector directorySelector;
+        private OsuDirectorySelector directorySelector;
 
         /// <summary>
         /// Text to display in the header to inform the user of what they are selecting.
@@ -91,7 +91,7 @@ namespace osu.Game.Overlays.Settings.Sections.Maintenance
                             },
                             new Drawable[]
                             {
-                                directorySelector = new DirectorySelector
+                                directorySelector = new OsuDirectorySelector
                                 {
                                     RelativeSizeAxes = Axes.Both,
                                 }

osu.Game/Overlays/Settings/SettingsItem.cs

@@ -101,10 +101,10 @@ namespace osu.Game.Overlays.Settings
 
         public event Action SettingChanged;
 
+        private readonly RestoreDefaultValueButton<T> restoreDefaultButton;
+
         protected SettingsItem()
         {
-            RestoreDefaultValueButton<T> restoreDefaultButton;
-
             RelativeSizeAxes = Axes.X;
             AutoSizeAxes = Axes.Y;
             Padding = new MarginPadding { Right = SettingsPanel.CONTENT_MARGINS };
@@ -126,14 +126,19 @@ namespace osu.Game.Overlays.Settings
 
             // all bindable logic is in constructor intentionally to support "CreateSettingsControls" being used in a context it is
             // never loaded, but requires bindable storage.
-            if (controlWithCurrent != null)
-            {
-                controlWithCurrent.Current.ValueChanged += _ => SettingChanged?.Invoke();
-                controlWithCurrent.Current.DisabledChanged += _ => updateDisabled();
+            if (controlWithCurrent == null)
+                throw new ArgumentException(@$"Control created via {nameof(CreateControl)} must implement {nameof(IHasCurrentValue<T>)}");
 
-                if (ShowsDefaultIndicator)
-                    restoreDefaultButton.Current = controlWithCurrent.Current;
-            }
+            controlWithCurrent.Current.ValueChanged += _ => SettingChanged?.Invoke();
+            controlWithCurrent.Current.DisabledChanged += _ => updateDisabled();
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            if (ShowsDefaultIndicator)
+                restoreDefaultButton.Current = controlWithCurrent.Current;
         }
 
         private void updateDisabled()

osu.Game/Overlays/Volume/VolumeControlReceptor.cs

@@ -30,6 +30,8 @@ namespace osu.Game.Overlays.Volume
                     return true;
 
                 case GlobalAction.ToggleMute:
+                case GlobalAction.NextVolumeMeter:
+                case GlobalAction.PreviousVolumeMeter:
                     ActionRequested?.Invoke(action);
                     return true;
             }

osu.Game/Overlays/Volume/VolumeMeter.cs

@@ -3,10 +3,12 @@
 
 using System;
 using System.Globalization;
+using osu.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -19,13 +21,14 @@ using osu.Framework.Threading;
 using osu.Framework.Utils;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Input.Bindings;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Overlays.Volume
 {
-    public class VolumeMeter : Container, IKeyBindingHandler<GlobalAction>
+    public class VolumeMeter : Container, IKeyBindingHandler<GlobalAction>, IStateful<SelectionState>
     {
         private CircularProgress volumeCircle;
         private CircularProgress volumeCircleGlow;
@@ -38,9 +41,33 @@ namespace osu.Game.Overlays.Volume
         private OsuSpriteText text;
         private BufferedContainer maxGlow;
 
-        private Sample sample;
+        private Container selectedGlowContainer;
+
+        private Sample hoverSample;
+        private Sample notchSample;
         private double sampleLastPlaybackTime;
 
+        public event Action<SelectionState> StateChanged;
+
+        private SelectionState state;
+
+        public SelectionState State
+        {
+            get => state;
+            set
+            {
+                if (state == value)
+                    return;
+
+                state = value;
+                StateChanged?.Invoke(value);
+
+                updateSelectedState();
+            }
+        }
+
+        private const float transition_length = 500;
+
         public VolumeMeter(string name, float circleSize, Color4 meterColour)
         {
             this.circleSize = circleSize;
@@ -53,7 +80,8 @@ namespace osu.Game.Overlays.Volume
         [BackgroundDependencyLoader]
         private void load(OsuColour colours, AudioManager audio)
         {
-            sample = audio.Samples.Get(@"UI/notch-tick");
+            hoverSample = audio.Samples.Get($"UI/{HoverSampleSet.Button.GetDescription()}-hover");
+            notchSample = audio.Samples.Get(@"UI/notch-tick");
             sampleLastPlaybackTime = Time.Current;
 
             Color4 backgroundColour = colours.Gray1;
@@ -75,7 +103,6 @@ namespace osu.Game.Overlays.Volume
                     {
                         new BufferedContainer
                         {
-                            Alpha = 0.9f,
                             RelativeSizeAxes = Axes.Both,
                             Children = new Drawable[]
                             {
@@ -147,6 +174,24 @@ namespace osu.Game.Overlays.Volume
                                 },
                             },
                         },
+                        selectedGlowContainer = new CircularContainer
+                        {
+                            Masking = true,
+                            RelativeSizeAxes = Axes.Both,
+                            Alpha = 0,
+                            Child = new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Alpha = 0,
+                                AlwaysPresent = true,
+                            },
+                            EdgeEffect = new EdgeEffectParameters
+                            {
+                                Type = EdgeEffectType.Glow,
+                                Colour = meterColour.Opacity(0.1f),
+                                Radius = 10,
+                            }
+                        },
                         maxGlow = (text = new OsuSpriteText
                         {
                             Anchor = Anchor.Centre,
@@ -171,7 +216,6 @@ namespace osu.Game.Overlays.Volume
                     {
                         new Box
                         {
-                            Alpha = 0.9f,
                             RelativeSizeAxes = Axes.Both,
                             Colour = backgroundColour,
                         },
@@ -233,7 +277,7 @@ namespace osu.Game.Overlays.Volume
             if (Time.Current - sampleLastPlaybackTime <= tick_debounce_time)
                 return;
 
-            var channel = sample.GetChannel();
+            var channel = notchSample.GetChannel();
 
             channel.Frequency.Value = 0.99f + RNG.NextDouble(0.02f) + displayVolume * 0.1f;
 
@@ -305,17 +349,14 @@ namespace osu.Game.Overlays.Volume
             return true;
         }
 
-        private const float transition_length = 500;
-
-        protected override bool OnHover(HoverEvent e)
+        protected override bool OnMouseMove(MouseMoveEvent e)
         {
-            this.ScaleTo(1.04f, transition_length, Easing.OutExpo);
-            return false;
+            State = SelectionState.Selected;
+            return base.OnMouseMove(e);
         }
 
         protected override void OnHoverLost(HoverLostEvent e)
         {
-            this.ScaleTo(1f, transition_length, Easing.OutExpo);
         }
 
         public bool OnPressed(GlobalAction action)
@@ -326,10 +367,12 @@ namespace osu.Game.Overlays.Volume
             switch (action)
             {
                 case GlobalAction.SelectPrevious:
+                    State = SelectionState.Selected;
                     adjust(1, false);
                     return true;
 
                 case GlobalAction.SelectNext:
+                    State = SelectionState.Selected;
                     adjust(-1, false);
                     return true;
             }
@@ -340,5 +383,22 @@ namespace osu.Game.Overlays.Volume
         public void OnReleased(GlobalAction action)
         {
         }
+
+        private void updateSelectedState()
+        {
+            switch (state)
+            {
+                case SelectionState.Selected:
+                    this.ScaleTo(1.04f, transition_length, Easing.OutExpo);
+                    selectedGlowContainer.FadeIn(transition_length, Easing.OutExpo);
+                    hoverSample?.Play();
+                    break;
+
+                case SelectionState.NotSelected:
+                    this.ScaleTo(1f, transition_length, Easing.OutExpo);
+                    selectedGlowContainer.FadeOut(transition_length, Easing.OutExpo);
+                    break;
+            }
+        }
     }
 }

osu.Game/Overlays/VolumeOverlay.cs

@@ -12,6 +12,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
 using osu.Framework.Threading;
 using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
 using osu.Game.Input.Bindings;
 using osu.Game.Overlays.Volume;
 using osuTK;
@@ -32,6 +33,8 @@ namespace osu.Game.Overlays
 
         public Bindable<bool> IsMuted { get; } = new Bindable<bool>();
 
+        private SelectionCycleFillFlowContainer<VolumeMeter> volumeMeters;
+
         [BackgroundDependencyLoader]
         private void load(AudioManager audio, OsuColour colours)
         {
@@ -53,7 +56,7 @@ namespace osu.Game.Overlays
                     Margin = new MarginPadding(10),
                     Current = { BindTarget = IsMuted }
                 },
-                new FillFlowContainer
+                volumeMeters = new SelectionCycleFillFlowContainer<VolumeMeter>
                 {
                     Direction = FillDirection.Vertical,
                     AutoSizeAxes = Axes.Both,
@@ -61,7 +64,7 @@ namespace osu.Game.Overlays
                     Origin = Anchor.CentreLeft,
                     Spacing = new Vector2(0, offset),
                     Margin = new MarginPadding { Left = offset },
-                    Children = new Drawable[]
+                    Children = new[]
                     {
                         volumeMeterEffect = new VolumeMeter("EFFECTS", 125, colours.BlueDarker),
                         volumeMeterMaster = new VolumeMeter("MASTER", 150, colours.PinkDarker),
@@ -87,9 +90,9 @@ namespace osu.Game.Overlays
         {
             base.LoadComplete();
 
-            volumeMeterMaster.Bindable.ValueChanged += _ => Show();
-            volumeMeterEffect.Bindable.ValueChanged += _ => Show();
-            volumeMeterMusic.Bindable.ValueChanged += _ => Show();
+            foreach (var volumeMeter in volumeMeters)
+                volumeMeter.Bindable.ValueChanged += _ => Show();
+
             muteButton.Current.ValueChanged += _ => Show();
         }
 
@@ -102,23 +105,27 @@ namespace osu.Game.Overlays
                 case GlobalAction.DecreaseVolume:
                     if (State.Value == Visibility.Hidden)
                         Show();
-                    else if (volumeMeterMusic.IsHovered)
-                        volumeMeterMusic.Decrease(amount, isPrecise);
-                    else if (volumeMeterEffect.IsHovered)
-                        volumeMeterEffect.Decrease(amount, isPrecise);
                     else
-                        volumeMeterMaster.Decrease(amount, isPrecise);
+                        volumeMeters.Selected?.Decrease(amount, isPrecise);
                     return true;
 
                 case GlobalAction.IncreaseVolume:
                     if (State.Value == Visibility.Hidden)
                         Show();
-                    else if (volumeMeterMusic.IsHovered)
-                        volumeMeterMusic.Increase(amount, isPrecise);
-                    else if (volumeMeterEffect.IsHovered)
-                        volumeMeterEffect.Increase(amount, isPrecise);
                     else
-                        volumeMeterMaster.Increase(amount, isPrecise);
+                        volumeMeters.Selected?.Increase(amount, isPrecise);
+                    return true;
+
+                case GlobalAction.NextVolumeMeter:
+                    if (State.Value == Visibility.Visible)
+                        volumeMeters.SelectNext();
+                    Show();
+                    return true;
+
+                case GlobalAction.PreviousVolumeMeter:
+                    if (State.Value == Visibility.Visible)
+                        volumeMeters.SelectPrevious();
+                    Show();
                     return true;
 
                 case GlobalAction.ToggleMute:
@@ -134,6 +141,10 @@ namespace osu.Game.Overlays
 
         public override void Show()
         {
+            // Focus on the master meter as a default if previously hidden
+            if (State.Value == Visibility.Hidden)
+                volumeMeters.Select(volumeMeterMaster);
+
             if (State.Value == Visibility.Visible)
                 schedulePopOut();
 

osu.Game/Rulesets/Mods/DifficultyAdjustSettingsControl.cs

@@ -0,0 +1,112 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Beatmaps;
+using osu.Game.Overlays.Settings;
+
+namespace osu.Game.Rulesets.Mods
+{
+    public class DifficultyAdjustSettingsControl : SettingsItem<float?>
+    {
+        [Resolved]
+        private IBindable<WorkingBeatmap> beatmap { get; set; }
+
+        /// <summary>
+        /// Used to track the display value on the setting slider.
+        /// </summary>
+        /// <remarks>
+        /// When the mod is overriding a default, this will match the value of <see cref="Current"/>.
+        /// When there is no override (ie. <see cref="Current"/> is null), this value will match the beatmap provided default via <see cref="updateCurrentFromSlider"/>.
+        /// </remarks>
+        private readonly BindableNumber<float> sliderDisplayCurrent = new BindableNumber<float>();
+
+        protected override Drawable CreateControl() => new SliderControl(sliderDisplayCurrent);
+
+        /// <summary>
+        /// Guards against beatmap values displayed on slider bars being transferred to user override.
+        /// </summary>
+        private bool isInternalChange;
+
+        private DifficultyBindable difficultyBindable;
+
+        public override Bindable<float?> Current
+        {
+            get => base.Current;
+            set
+            {
+                // Intercept and extract the internal number bindable from DifficultyBindable.
+                // This will provide bounds and precision specifications for the slider bar.
+                difficultyBindable = ((DifficultyBindable)value).GetBoundCopy();
+                sliderDisplayCurrent.BindTo(difficultyBindable.CurrentNumber);
+
+                base.Current = difficultyBindable;
+            }
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Current.BindValueChanged(current => updateCurrentFromSlider());
+            beatmap.BindValueChanged(b => updateCurrentFromSlider(), true);
+
+            sliderDisplayCurrent.BindValueChanged(number =>
+            {
+                // this handles the transfer of the slider value to the main bindable.
+                // as such, should be skipped if the slider is being updated via updateFromDifficulty().
+                if (!isInternalChange)
+                    Current.Value = number.NewValue;
+            });
+        }
+
+        private void updateCurrentFromSlider()
+        {
+            if (Current.Value != null)
+            {
+                // a user override has been added or updated.
+                sliderDisplayCurrent.Value = Current.Value.Value;
+                return;
+            }
+
+            var difficulty = beatmap.Value.BeatmapInfo.BaseDifficulty;
+
+            if (difficulty == null)
+                return;
+
+            // generally should always be implemented, else the slider will have a zero default.
+            if (difficultyBindable.ReadCurrentFromDifficulty == null)
+                return;
+
+            isInternalChange = true;
+            sliderDisplayCurrent.Value = difficultyBindable.ReadCurrentFromDifficulty(difficulty);
+            isInternalChange = false;
+        }
+
+        private class SliderControl : CompositeDrawable, IHasCurrentValue<float?>
+        {
+            // This is required as SettingsItem relies heavily on this bindable for internal use.
+            // The actual update flow is done via the bindable provided in the constructor.
+            public Bindable<float?> Current { get; set; } = new Bindable<float?>();
+
+            public SliderControl(BindableNumber<float> currentNumber)
+            {
+                InternalChildren = new Drawable[]
+                {
+                    new SettingsSlider<float>
+                    {
+                        ShowsDefaultIndicator = false,
+                        Current = currentNumber,
+                    }
+                };
+
+                AutoSizeAxes = Axes.Y;
+                RelativeSizeAxes = Axes.X;
+            }
+        }
+    }
+}

osu.Game/Rulesets/Mods/DifficultyBindable.cs

@@ -0,0 +1,107 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Bindables;
+using osu.Game.Beatmaps;
+
+namespace osu.Game.Rulesets.Mods
+{
+    public class DifficultyBindable : Bindable<float?>
+    {
+        /// <summary>
+        /// Whether the extended limits should be applied to this bindable.
+        /// </summary>
+        public readonly BindableBool ExtendedLimits = new BindableBool();
+
+        /// <summary>
+        /// An internal numeric bindable to hold and propagate min/max/precision.
+        /// The value of this bindable should not be set.
+        /// </summary>
+        internal readonly BindableFloat CurrentNumber = new BindableFloat
+        {
+            MinValue = 0,
+            MaxValue = 10,
+        };
+
+        /// <summary>
+        /// A function that can extract the current value of this setting from a beatmap difficulty for display purposes.
+        /// </summary>
+        public Func<BeatmapDifficulty, float> ReadCurrentFromDifficulty;
+
+        public float Precision
+        {
+            set => CurrentNumber.Precision = value;
+        }
+
+        public float MinValue
+        {
+            set => CurrentNumber.MinValue = value;
+        }
+
+        private float maxValue;
+
+        public float MaxValue
+        {
+            set
+            {
+                if (value == maxValue)
+                    return;
+
+                maxValue = value;
+                updateMaxValue();
+            }
+        }
+
+        private float? extendedMaxValue;
+
+        /// <summary>
+        /// The maximum value to be used when extended limits are applied.
+        /// </summary>
+        public float? ExtendedMaxValue
+        {
+            set
+            {
+                if (value == extendedMaxValue)
+                    return;
+
+                extendedMaxValue = value;
+                updateMaxValue();
+            }
+        }
+
+        public DifficultyBindable()
+        {
+            ExtendedLimits.BindValueChanged(_ => updateMaxValue());
+        }
+
+        public override float? Value
+        {
+            get => base.Value;
+            set
+            {
+                // Ensure that in the case serialisation runs in the wrong order (and limit extensions aren't applied yet) the deserialised value is still propagated.
+                if (value != null)
+                    CurrentNumber.MaxValue = MathF.Max(CurrentNumber.MaxValue, value.Value);
+
+                base.Value = value;
+            }
+        }
+
+        private void updateMaxValue()
+        {
+            CurrentNumber.MaxValue = ExtendedLimits.Value && extendedMaxValue != null ? extendedMaxValue.Value : maxValue;
+        }
+
+        public new DifficultyBindable GetBoundCopy() => new DifficultyBindable
+        {
+            BindTarget = this,
+            CurrentNumber = { BindTarget = CurrentNumber },
+            ExtendedLimits = { BindTarget = ExtendedLimits },
+            ReadCurrentFromDifficulty = ReadCurrentFromDifficulty,
+            // the following is only safe as long as these values are effectively constants.
+            MaxValue = maxValue,
+            ExtendedMaxValue = extendedMaxValue
+        };
+    }
+}

osu.Game/Rulesets/Mods/ModDifficultyAdjust.cs

@@ -1,13 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Game.Beatmaps;
+using System;
+using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
-using System;
-using System.Collections.Generic;
+using osu.Game.Beatmaps;
 using osu.Game.Configuration;
-using System.Linq;
 
 namespace osu.Game.Rulesets.Mods
 {
@@ -33,24 +32,24 @@ namespace osu.Game.Rulesets.Mods
 
         protected const int LAST_SETTING_ORDER = 2;
 
-        [SettingSource("HP Drain", "Override a beatmap's set HP.", FIRST_SETTING_ORDER)]
-        public BindableNumber<float> DrainRate { get; } = new BindableFloatWithLimitExtension
+        [SettingSource("HP Drain", "Override a beatmap's set HP.", FIRST_SETTING_ORDER, SettingControlType = typeof(DifficultyAdjustSettingsControl))]
+        public DifficultyBindable DrainRate { get; } = new DifficultyBindable
         {
             Precision = 0.1f,
             MinValue = 0,
             MaxValue = 10,
-            Default = 5,
-            Value = 5,
+            ExtendedMaxValue = 11,
+            ReadCurrentFromDifficulty = diff => diff.DrainRate,
         };
 
-        [SettingSource("Accuracy", "Override a beatmap's set OD.", LAST_SETTING_ORDER)]
-        public BindableNumber<float> OverallDifficulty { get; } = new BindableFloatWithLimitExtension
+        [SettingSource("Accuracy", "Override a beatmap's set OD.", LAST_SETTING_ORDER, SettingControlType = typeof(DifficultyAdjustSettingsControl))]
+        public DifficultyBindable OverallDifficulty { get; } = new DifficultyBindable
         {
             Precision = 0.1f,
             MinValue = 0,
             MaxValue = 10,
-            Default = 5,
-            Value = 5,
+            ExtendedMaxValue = 11,
+            ReadCurrentFromDifficulty = diff => diff.OverallDifficulty,
         };
 
         [SettingSource("Extended Limits", "Adjust difficulty beyond sane limits.")]
@@ -58,17 +57,11 @@ namespace osu.Game.Rulesets.Mods
 
         protected ModDifficultyAdjust()
         {
-            ExtendedLimits.BindValueChanged(extend => ApplyLimits(extend.NewValue));
-        }
-
-        /// <summary>
-        /// Changes the difficulty adjustment limits. Occurs when the value of <see cref="ExtendedLimits"/> is changed.
-        /// </summary>
-        /// <param name="extended">Whether limits should extend beyond sane ranges.</param>
-        protected virtual void ApplyLimits(bool extended)
-        {
-            DrainRate.MaxValue = extended ? 11 : 10;
-            OverallDifficulty.MaxValue = extended ? 11 : 10;
+            foreach (var (_, property) in this.GetOrderedSettingsSourceProperties())
+            {
+                if (property.GetValue(this) is DifficultyBindable diffAdjustBindable)
+                    diffAdjustBindable.ExtendedLimits.BindTo(ExtendedLimits);
+            }
         }
 
         public override string SettingDescription
@@ -86,146 +79,20 @@ namespace osu.Game.Rulesets.Mods
             }
         }
 
-        private BeatmapDifficulty difficulty;
-
         public void ReadFromDifficulty(BeatmapDifficulty difficulty)
         {
-            if (this.difficulty == null || this.difficulty.ID != difficulty.ID)
-            {
-                TransferSettings(difficulty);
-                this.difficulty = difficulty;
-            }
         }
 
         public void ApplyToDifficulty(BeatmapDifficulty difficulty) => ApplySettings(difficulty);
 
-        /// <summary>
-        /// Transfer initial settings from the beatmap to settings.
-        /// </summary>
-        /// <param name="difficulty">The beatmap's initial values.</param>
-        protected virtual void TransferSettings(BeatmapDifficulty difficulty)
-        {
-            TransferSetting(DrainRate, difficulty.DrainRate);
-            TransferSetting(OverallDifficulty, difficulty.OverallDifficulty);
-        }
-
-        private readonly Dictionary<IBindable, bool> userChangedSettings = new Dictionary<IBindable, bool>();
-
-        /// <summary>
-        /// Transfer a setting from <see cref="BeatmapDifficulty"/> to a configuration bindable.
-        /// Only performs the transfer if the user is not currently overriding.
-        /// </summary>
-        protected void TransferSetting<T>(BindableNumber<T> bindable, T beatmapDefault)
-            where T : struct, IComparable<T>, IConvertible, IEquatable<T>
-        {
-            bindable.UnbindEvents();
-
-            userChangedSettings.TryAdd(bindable, false);
-
-            bindable.Default = beatmapDefault;
-
-            // users generally choose a difficulty setting and want it to stick across multiple beatmap changes.
-            // we only want to value transfer if the user hasn't changed the value previously.
-            if (!userChangedSettings[bindable])
-                bindable.Value = beatmapDefault;
-
-            bindable.ValueChanged += _ => userChangedSettings[bindable] = !bindable.IsDefault;
-        }
-
-        internal override void CopyAdjustedSetting(IBindable target, object source)
-        {
-            // if the value is non-bindable, it's presumably coming from an external source (like the API) - therefore presume it is not default.
-            // if the value is bindable, defer to the source's IsDefault to be able to tell.
-            userChangedSettings[target] = !(source is IBindable bindableSource) || !bindableSource.IsDefault;
-            base.CopyAdjustedSetting(target, source);
-        }
-
-        /// <summary>
-        /// Applies a setting from a configuration bindable using <paramref name="applyFunc"/>, if it has been changed by the user.
-        /// </summary>
-        protected void ApplySetting<T>(BindableNumber<T> setting, Action<T> applyFunc)
-            where T : struct, IComparable<T>, IConvertible, IEquatable<T>
-        {
-            if (userChangedSettings.TryGetValue(setting, out bool userChangedSetting) && userChangedSetting)
-                applyFunc.Invoke(setting.Value);
-        }
-
         /// <summary>
         /// Apply all custom settings to the provided beatmap.
         /// </summary>
         /// <param name="difficulty">The beatmap to have settings applied.</param>
         protected virtual void ApplySettings(BeatmapDifficulty difficulty)
         {
-            ApplySetting(DrainRate, dr => difficulty.DrainRate = dr);
-            ApplySetting(OverallDifficulty, od => difficulty.OverallDifficulty = od);
-        }
-
-        public override void ResetSettingsToDefaults()
-        {
-            base.ResetSettingsToDefaults();
-
-            if (difficulty != null)
-            {
-                // base implementation potentially overwrite modified defaults that came from a beatmap selection.
-                TransferSettings(difficulty);
-            }
-        }
-
-        /// <summary>
-        /// A <see cref="BindableDouble"/> that extends its min/max values to support any assigned value.
-        /// </summary>
-        protected class BindableDoubleWithLimitExtension : BindableDouble
-        {
-            public override double Value
-            {
-                get => base.Value;
-                set
-                {
-                    if (value < MinValue)
-                        MinValue = value;
-                    if (value > MaxValue)
-                        MaxValue = value;
-                    base.Value = value;
-                }
-            }
-        }
-
-        /// <summary>
-        /// A <see cref="BindableFloat"/> that extends its min/max values to support any assigned value.
-        /// </summary>
-        protected class BindableFloatWithLimitExtension : BindableFloat
-        {
-            public override float Value
-            {
-                get => base.Value;
-                set
-                {
-                    if (value < MinValue)
-                        MinValue = value;
-                    if (value > MaxValue)
-                        MaxValue = value;
-                    base.Value = value;
-                }
-            }
-        }
-
-        /// <summary>
-        /// A <see cref="BindableInt"/> that extends its min/max values to support any assigned value.
-        /// </summary>
-        protected class BindableIntWithLimitExtension : BindableInt
-        {
-            public override int Value
-            {
-                get => base.Value;
-                set
-                {
-                    if (value < MinValue)
-                        MinValue = value;
-                    if (value > MaxValue)
-                        MaxValue = value;
-                    base.Value = value;
-                }
-            }
+            if (DrainRate.Value != null) difficulty.DrainRate = DrainRate.Value.Value;
+            if (OverallDifficulty.Value != null) difficulty.OverallDifficulty = OverallDifficulty.Value.Value;
         }
     }
 }

osu.Game/Rulesets/UI/DrawableRulesetDependencies.cs

@@ -10,6 +10,7 @@ using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.OpenGL.Textures;
+using osu.Framework.Graphics.Shaders;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.IO.Stores;
 using osu.Framework.Platform;
@@ -34,6 +35,11 @@ namespace osu.Game.Rulesets.UI
         /// </remarks>
         public ISampleStore SampleStore { get; }
 
+        /// <summary>
+        /// The shader manager to be used for the ruleset.
+        /// </summary>
+        public ShaderManager ShaderManager { get; }
+
         /// <summary>
         /// The ruleset config manager.
         /// </summary>
@@ -52,6 +58,9 @@ namespace osu.Game.Rulesets.UI
                 SampleStore = parent.Get<AudioManager>().GetSampleStore(new NamespacedResourceStore<byte[]>(resources, @"Samples"));
                 SampleStore.PlaybackConcurrency = OsuGameBase.SAMPLE_CONCURRENCY;
                 CacheAs(SampleStore = new FallbackSampleStore(SampleStore, parent.Get<ISampleStore>()));
+
+                ShaderManager = new ShaderManager(new NamespacedResourceStore<byte[]>(resources, @"Shaders"));
+                CacheAs(ShaderManager = new FallbackShaderManager(ShaderManager, parent.Get<ShaderManager>()));
             }
 
             RulesetConfigManager = parent.Get<RulesetConfigCache>().GetConfigFor(ruleset);
@@ -84,6 +93,7 @@ namespace osu.Game.Rulesets.UI
 
             SampleStore?.Dispose();
             TextureStore?.Dispose();
+            ShaderManager?.Dispose();
             RulesetConfigManager = null;
         }
 
@@ -172,5 +182,26 @@ namespace osu.Game.Rulesets.UI
                 primary?.Dispose();
             }
         }
+
+        private class FallbackShaderManager : ShaderManager
+        {
+            private readonly ShaderManager primary;
+            private readonly ShaderManager fallback;
+
+            public FallbackShaderManager(ShaderManager primary, ShaderManager fallback)
+                : base(new ResourceStore<byte[]>())
+            {
+                this.primary = primary;
+                this.fallback = fallback;
+            }
+
+            public override byte[] LoadRaw(string name) => primary.LoadRaw(name) ?? fallback.LoadRaw(name);
+
+            protected override void Dispose(bool disposing)
+            {
+                base.Dispose(disposing);
+                primary?.Dispose();
+            }
+        }
     }
 }

osu.Game/Screens/Edit/Setup/FileChooserLabelledTextBox.cs

@@ -56,9 +56,9 @@ namespace osu.Game.Screens.Edit.Setup
 
         public void DisplayFileChooser()
         {
-            FileSelector fileSelector;
+            OsuFileSelector fileSelector;
 
-            Target.Child = fileSelector = new FileSelector(currentFile.Value?.DirectoryName, handledExtensions)
+            Target.Child = fileSelector = new OsuFileSelector(currentFile.Value?.DirectoryName, handledExtensions)
             {
                 RelativeSizeAxes = Axes.X,
                 Height = 400,

osu.Game/Screens/Import/FileImportScreen.cs

@@ -23,7 +23,7 @@ namespace osu.Game.Screens.Import
     {
         public override bool HideOverlaysOnEnter => true;
 
-        private FileSelector fileSelector;
+        private OsuFileSelector fileSelector;
         private Container contentContainer;
         private TextFlowContainer currentFileText;
 
@@ -57,7 +57,7 @@ namespace osu.Game.Screens.Import
                         Colour = colours.GreySeafoamDark,
                         RelativeSizeAxes = Axes.Both,
                     },
-                    fileSelector = new FileSelector(validFileExtensions: game.HandledExtensions.ToArray())
+                    fileSelector = new OsuFileSelector(validFileExtensions: game.HandledExtensions.ToArray())
                     {
                         RelativeSizeAxes = Axes.Both,
                         Width = 0.65f

osu.Game/Screens/Play/GameplayMenuOverlay.cs

@@ -2,23 +2,24 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
+using Humanizer;
+using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Graphics.Sprites;
-using osuTK;
-using osuTK.Graphics;
-using osu.Game.Graphics;
-using osu.Framework.Allocation;
-using osu.Game.Graphics.UserInterface;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
-using System.Collections.Generic;
-using System.Linq;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Input.Bindings;
-using Humanizer;
-using osu.Framework.Graphics.Effects;
+using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Screens.Play
 {
@@ -46,13 +47,13 @@ namespace osu.Game.Screens.Play
         /// <summary>
         /// Action that is invoked when <see cref="GlobalAction.Select"/> is triggered.
         /// </summary>
-        protected virtual Action SelectAction => () => InternalButtons.Children.FirstOrDefault(f => f.Selected.Value)?.Click();
+        protected virtual Action SelectAction => () => InternalButtons.Selected?.Click();
 
         public abstract string Header { get; }
 
         public abstract string Description { get; }
 
-        protected ButtonContainer InternalButtons;
+        protected SelectionCycleFillFlowContainer<DialogButton> InternalButtons;
         public IReadOnlyList<DialogButton> Buttons => InternalButtons;
 
         private FillFlowContainer retryCounterContainer;
@@ -116,7 +117,7 @@ namespace osu.Game.Screens.Play
                                 }
                             }
                         },
-                        InternalButtons = new ButtonContainer
+                        InternalButtons = new SelectionCycleFillFlowContainer<DialogButton>
                         {
                             Origin = Anchor.TopCentre,
                             Anchor = Anchor.TopCentre,
@@ -183,8 +184,6 @@ namespace osu.Game.Screens.Play
                 }
             };
 
-            button.Selected.ValueChanged += selected => buttonSelectionChanged(button, selected.NewValue);
-
             InternalButtons.Add(button);
         }
 
@@ -216,14 +215,6 @@ namespace osu.Game.Screens.Play
         {
         }
 
-        private void buttonSelectionChanged(DialogButton button, bool isSelected)
-        {
-            if (!isSelected)
-                InternalButtons.Deselect();
-            else
-                InternalButtons.Select(button);
-        }
-
         private void updateRetryCount()
         {
             // "You've retried 1,065 times in this session"
@@ -255,46 +246,6 @@ namespace osu.Game.Screens.Play
             };
         }
 
-        protected class ButtonContainer : FillFlowContainer<DialogButton>
-        {
-            private int selectedIndex = -1;
-
-            private void setSelected(int value)
-            {
-                if (selectedIndex == value)
-                    return;
-
-                // Deselect the previously-selected button
-                if (selectedIndex != -1)
-                    this[selectedIndex].Selected.Value = false;
-
-                selectedIndex = value;
-
-                // Select the newly-selected button
-                if (selectedIndex != -1)
-                    this[selectedIndex].Selected.Value = true;
-            }
-
-            public void SelectNext()
-            {
-                if (selectedIndex == -1 || selectedIndex == Count - 1)
-                    setSelected(0);
-                else
-                    setSelected(selectedIndex + 1);
-            }
-
-            public void SelectPrevious()
-            {
-                if (selectedIndex == -1 || selectedIndex == 0)
-                    setSelected(Count - 1);
-                else
-                    setSelected(selectedIndex - 1);
-            }
-
-            public void Deselect() => setSelected(-1);
-            public void Select(DialogButton button) => setSelected(IndexOf(button));
-        }
-
         private class Button : DialogButton
         {
             // required to ensure keyboard navigation always starts from an extremity (unless the cursor is moved)
@@ -302,7 +253,7 @@ namespace osu.Game.Screens.Play
 
             protected override bool OnMouseMove(MouseMoveEvent e)
             {
-                Selected.Value = true;
+                State = SelectionState.Selected;
                 return base.OnMouseMove(e);
             }
         }

osu.Game/Screens/Play/ReplayPlayer.cs

@@ -3,11 +3,15 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using osu.Framework.Input.Bindings;
+using osu.Framework.Threading;
 using osu.Game.Beatmaps;
+using osu.Game.Extensions;
 using osu.Game.Input.Bindings;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Scoring;
 using osu.Game.Screens.Ranking;
 
@@ -43,10 +47,24 @@ namespace osu.Game.Screens.Play
 
         protected override ResultsScreen CreateResults(ScoreInfo score) => new SoloResultsScreen(score, false);
 
+        private ScheduledDelegate keyboardSeekDelegate;
+
         public bool OnPressed(GlobalAction action)
         {
+            const double keyboard_seek_amount = 5000;
+
             switch (action)
             {
+                case GlobalAction.SeekReplayBackward:
+                    keyboardSeekDelegate?.Cancel();
+                    keyboardSeekDelegate = this.BeginKeyRepeat(Scheduler, () => keyboardSeek(-1));
+                    return true;
+
+                case GlobalAction.SeekReplayForward:
+                    keyboardSeekDelegate?.Cancel();
+                    keyboardSeekDelegate = this.BeginKeyRepeat(Scheduler, () => keyboardSeek(1));
+                    return true;
+
                 case GlobalAction.TogglePauseReplay:
                     if (GameplayClockContainer.IsPaused.Value)
                         GameplayClockContainer.Start();
@@ -56,10 +74,24 @@ namespace osu.Game.Screens.Play
             }
 
             return false;
+
+            void keyboardSeek(int direction)
+            {
+                double target = Math.Clamp(GameplayClockContainer.CurrentTime + direction * keyboard_seek_amount, 0, GameplayBeatmap.HitObjects.Last().GetEndTime());
+
+                Seek(target);
+            }
         }
 
         public void OnReleased(GlobalAction action)
         {
+            switch (action)
+            {
+                case GlobalAction.SeekReplayBackward:
+                case GlobalAction.SeekReplayForward:
+                    keyboardSeekDelegate?.Cancel();
+                    break;
+            }
         }
     }
 }

osu.Game/Screens/Play/SoloPlayer.cs

@@ -6,6 +6,7 @@ using System.Diagnostics;
 using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
 using osu.Game.Online.Solo;
+using osu.Game.Rulesets;
 using osu.Game.Scoring;
 
 namespace osu.Game.Screens.Play
@@ -27,7 +28,7 @@ namespace osu.Game.Screens.Play
             if (!(Beatmap.Value.BeatmapInfo.OnlineBeatmapID is int beatmapId))
                 return null;
 
-            if (!(Ruleset.Value.ID is int rulesetId))
+            if (!(Ruleset.Value.ID is int rulesetId) || Ruleset.Value.ID > ILegacyRuleset.MAX_LEGACY_RULESET_ID)
                 return null;
 
             return new CreateSoloScoreRequest(beatmapId, rulesetId, Game.VersionHash);

osu.Game/Screens/Play/SongProgressBar.cs

@@ -57,8 +57,6 @@ namespace osu.Game.Screens.Play
             set => CurrentNumber.Value = value;
         }
 
-        protected override bool AllowKeyboardInputWhenNotHovered => true;
-
         public SongProgressBar(float barHeight, float handleBarHeight, Vector2 handleSize)
         {
             CurrentNumber.MinValue = 0;

osu.Game/Skinning/BeatmapSkinProvidingContainer.cs

@@ -83,9 +83,9 @@ namespace osu.Game.Skinning
         [BackgroundDependencyLoader]
         private void load()
         {
-            beatmapSkins.BindValueChanged(_ => OnSourceChanged());
-            beatmapColours.BindValueChanged(_ => OnSourceChanged());
-            beatmapHitsounds.BindValueChanged(_ => OnSourceChanged());
+            beatmapSkins.BindValueChanged(_ => TriggerSourceChanged());
+            beatmapColours.BindValueChanged(_ => TriggerSourceChanged());
+            beatmapHitsounds.BindValueChanged(_ => TriggerSourceChanged());
         }
     }
 }

osu.Game/Skinning/RulesetSkinProvidingContainer.cs

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
@@ -46,57 +48,51 @@ namespace osu.Game.Skinning
             };
         }
 
-        private ISkinSource parentSource;
-
         private ResourceStoreBackedSkin rulesetResourcesSkin;
 
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
-            parentSource = parent.Get<ISkinSource>();
-            parentSource.SourceChanged += OnSourceChanged;
-
             if (Ruleset.CreateResourceStore() is IResourceStore<byte[]> resources)
                 rulesetResourcesSkin = new ResourceStoreBackedSkin(resources, parent.Get<GameHost>(), parent.Get<AudioManager>());
 
-            // ensure sources are populated and ready for use before childrens' asynchronous load flow.
-            UpdateSkinSources();
-
             return base.CreateChildDependencies(parent);
         }
 
         protected override void OnSourceChanged()
         {
-            UpdateSkinSources();
-            base.OnSourceChanged();
-        }
+            ResetSources();
 
-        protected virtual void UpdateSkinSources()
-        {
-            SkinSources.Clear();
+            // Populate a local list first so we can adjust the returned order as we go.
+            var sources = new List<ISkin>();
 
-            foreach (var skin in parentSource.AllSources)
+            Debug.Assert(ParentSource != null);
+
+            foreach (var skin in ParentSource.AllSources)
             {
                 switch (skin)
                 {
                     case LegacySkin legacySkin:
-                        SkinSources.Add(GetLegacyRulesetTransformedSkin(legacySkin));
+                        sources.Add(GetLegacyRulesetTransformedSkin(legacySkin));
                         break;
 
                     default:
-                        SkinSources.Add(skin);
+                        sources.Add(skin);
                         break;
                 }
             }
 
-            int lastDefaultSkinIndex = SkinSources.IndexOf(SkinSources.OfType<DefaultSkin>().LastOrDefault());
+            int lastDefaultSkinIndex = sources.IndexOf(sources.OfType<DefaultSkin>().LastOrDefault());
 
             // Ruleset resources should be given the ability to override game-wide defaults
             // This is achieved by placing them before the last instance of DefaultSkin.
             // Note that DefaultSkin may not be present in some test scenes.
             if (lastDefaultSkinIndex >= 0)
-                SkinSources.Insert(lastDefaultSkinIndex, rulesetResourcesSkin);
+                sources.Insert(lastDefaultSkinIndex, rulesetResourcesSkin);
             else
-                SkinSources.Add(rulesetResourcesSkin);
+                sources.Add(rulesetResourcesSkin);
+
+            foreach (var skin in sources)
+                AddSource(skin);
         }
 
         protected ISkin GetLegacyRulesetTransformedSkin(ISkin legacySkin)
@@ -115,9 +111,6 @@ namespace osu.Game.Skinning
         {
             base.Dispose(isDisposing);
 
-            if (parentSource != null)
-                parentSource.SourceChanged -= OnSourceChanged;
-
             rulesetResourcesSkin?.Dispose();
         }
     }

osu.Game/Skinning/SkinProvidingContainer.cs

@@ -3,8 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Collections.Specialized;
-using System.Linq;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Audio.Sample;
@@ -24,19 +22,8 @@ namespace osu.Game.Skinning
     {
         public event Action SourceChanged;
 
-        /// <summary>
-        /// Skins which should be exposed by this container, in order of lookup precedence.
-        /// </summary>
-        protected readonly BindableList<ISkin> SkinSources = new BindableList<ISkin>();
-
-        /// <summary>
-        /// A dictionary mapping each <see cref="ISkin"/> from the <see cref="SkinSources"/>
-        /// to one that performs the "allow lookup" checks before proceeding with a lookup.
-        /// </summary>
-        private readonly Dictionary<ISkin, DisableableSkinSource> disableableSkinSources = new Dictionary<ISkin, DisableableSkinSource>();
-
         [CanBeNull]
-        private ISkinSource fallbackSource;
+        protected ISkinSource ParentSource { get; private set; }
 
         /// <summary>
         /// Whether falling back to parent <see cref="ISkinSource"/>s is allowed in this container.
@@ -53,6 +40,11 @@ namespace osu.Game.Skinning
 
         protected virtual bool AllowColourLookup => true;
 
+        /// <summary>
+        /// A dictionary mapping each <see cref="ISkin"/> source to a wrapper which handles lookup allowances.
+        /// </summary>
+        private readonly List<(ISkin skin, DisableableSkinSource wrapped)> skinSources = new List<(ISkin, DisableableSkinSource)>();
+
         /// <summary>
         /// Constructs a new <see cref="SkinProvidingContainer"/> initialised with a single skin source.
         /// </summary>
@@ -60,87 +52,56 @@ namespace osu.Game.Skinning
             : this()
         {
             if (skin != null)
-                SkinSources.Add(skin);
+                AddSource(skin);
         }
 
         /// <summary>
         /// Constructs a new <see cref="SkinProvidingContainer"/> with no sources.
-        /// Implementations can add or change sources through the <see cref="SkinSources"/> list.
         /// </summary>
         protected SkinProvidingContainer()
         {
             RelativeSizeAxes = Axes.Both;
+        }
 
-            SkinSources.BindCollectionChanged(((_, args) =>
-            {
-                switch (args.Action)
-                {
-                    case NotifyCollectionChangedAction.Add:
-                        foreach (var skin in args.NewItems.Cast<ISkin>())
-                        {
-                            disableableSkinSources.Add(skin, new DisableableSkinSource(skin, this));
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+        {
+            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
-                            if (skin is ISkinSource source)
-                                source.SourceChanged += OnSourceChanged;
-                        }
+            ParentSource = dependencies.Get<ISkinSource>();
+            if (ParentSource != null)
+                ParentSource.SourceChanged += TriggerSourceChanged;
 
-                        break;
+            dependencies.CacheAs<ISkinSource>(this);
 
-                    case NotifyCollectionChangedAction.Reset:
-                    case NotifyCollectionChangedAction.Remove:
-                        foreach (var skin in args.OldItems.Cast<ISkin>())
-                        {
-                            disableableSkinSources.Remove(skin);
+            TriggerSourceChanged();
 
-                            if (skin is ISkinSource source)
-                                source.SourceChanged -= OnSourceChanged;
-                        }
-
-                        break;
-
-                    case NotifyCollectionChangedAction.Replace:
-                        foreach (var skin in args.OldItems.Cast<ISkin>())
-                        {
-                            disableableSkinSources.Remove(skin);
-
-                            if (skin is ISkinSource source)
-                                source.SourceChanged -= OnSourceChanged;
-                        }
-
-                        foreach (var skin in args.NewItems.Cast<ISkin>())
-                        {
-                            disableableSkinSources.Add(skin, new DisableableSkinSource(skin, this));
-
-                            if (skin is ISkinSource source)
-                                source.SourceChanged += OnSourceChanged;
-                        }
-
-                        break;
-                }
-            }), true);
+            return dependencies;
         }
 
         public ISkin FindProvider(Func<ISkin, bool> lookupFunction)
         {
-            foreach (var skin in SkinSources)
+            foreach (var (skin, lookupWrapper) in skinSources)
             {
-                if (lookupFunction(disableableSkinSources[skin]))
+                if (lookupFunction(lookupWrapper))
                     return skin;
             }
 
-            return fallbackSource?.FindProvider(lookupFunction);
+            if (!AllowFallingBackToParent)
+                return null;
+
+            return ParentSource?.FindProvider(lookupFunction);
         }
 
         public IEnumerable<ISkin> AllSources
         {
             get
             {
-                foreach (var skin in SkinSources)
-                    yield return skin;
+                foreach (var i in skinSources)
+                    yield return i.skin;
 
-                if (fallbackSource != null)
+                if (AllowFallingBackToParent && ParentSource != null)
                 {
-                    foreach (var skin in fallbackSource.AllSources)
+                    foreach (var skin in ParentSource.AllSources)
                         yield return skin;
                 }
             }
@@ -148,68 +109,110 @@ namespace osu.Game.Skinning
 
         public Drawable GetDrawableComponent(ISkinComponent component)
         {
-            foreach (var skin in SkinSources)
+            foreach (var (_, lookupWrapper) in skinSources)
             {
                 Drawable sourceDrawable;
-                if ((sourceDrawable = disableableSkinSources[skin]?.GetDrawableComponent(component)) != null)
+                if ((sourceDrawable = lookupWrapper.GetDrawableComponent(component)) != null)
                     return sourceDrawable;
             }
 
-            return fallbackSource?.GetDrawableComponent(component);
+            if (!AllowFallingBackToParent)
+                return null;
+
+            return ParentSource?.GetDrawableComponent(component);
         }
 
         public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT)
         {
-            foreach (var skin in SkinSources)
+            foreach (var (_, lookupWrapper) in skinSources)
             {
                 Texture sourceTexture;
-                if ((sourceTexture = disableableSkinSources[skin]?.GetTexture(componentName, wrapModeS, wrapModeT)) != null)
+                if ((sourceTexture = lookupWrapper.GetTexture(componentName, wrapModeS, wrapModeT)) != null)
                     return sourceTexture;
             }
 
-            return fallbackSource?.GetTexture(componentName, wrapModeS, wrapModeT);
+            if (!AllowFallingBackToParent)
+                return null;
+
+            return ParentSource?.GetTexture(componentName, wrapModeS, wrapModeT);
         }
 
         public ISample GetSample(ISampleInfo sampleInfo)
         {
-            foreach (var skin in SkinSources)
+            foreach (var (_, lookupWrapper) in skinSources)
             {
                 ISample sourceSample;
-                if ((sourceSample = disableableSkinSources[skin]?.GetSample(sampleInfo)) != null)
+                if ((sourceSample = lookupWrapper.GetSample(sampleInfo)) != null)
                     return sourceSample;
             }
 
-            return fallbackSource?.GetSample(sampleInfo);
+            if (!AllowFallingBackToParent)
+                return null;
+
+            return ParentSource?.GetSample(sampleInfo);
         }
 
         public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup)
         {
-            foreach (var skin in SkinSources)
+            foreach (var (_, lookupWrapper) in skinSources)
             {
                 IBindable<TValue> bindable;
-                if ((bindable = disableableSkinSources[skin]?.GetConfig<TLookup, TValue>(lookup)) != null)
+                if ((bindable = lookupWrapper.GetConfig<TLookup, TValue>(lookup)) != null)
                     return bindable;
             }
 
-            return fallbackSource?.GetConfig<TLookup, TValue>(lookup);
+            if (!AllowFallingBackToParent)
+                return null;
+
+            return ParentSource?.GetConfig<TLookup, TValue>(lookup);
         }
 
-        protected virtual void OnSourceChanged() => SourceChanged?.Invoke();
-
-        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+        /// <summary>
+        /// Add a new skin to this provider. Will be added to the end of the lookup order precedence.
+        /// </summary>
+        /// <param name="skin">The skin to add.</param>
+        protected void AddSource(ISkin skin)
         {
-            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
+            skinSources.Add((skin, new DisableableSkinSource(skin, this)));
 
-            if (AllowFallingBackToParent)
-            {
-                fallbackSource = dependencies.Get<ISkinSource>();
-                if (fallbackSource != null)
-                    fallbackSource.SourceChanged += OnSourceChanged;
-            }
+            if (skin is ISkinSource source)
+                source.SourceChanged += TriggerSourceChanged;
+        }
 
-            dependencies.CacheAs<ISkinSource>(this);
+        /// <summary>
+        /// Remove a skin from this provider.
+        /// </summary>
+        /// <param name="skin">The skin to remove.</param>
+        protected void RemoveSource(ISkin skin)
+        {
+            if (skinSources.RemoveAll(s => s.skin == skin) == 0)
+                return;
 
-            return dependencies;
+            if (skin is ISkinSource source)
+                source.SourceChanged -= TriggerSourceChanged;
+        }
+
+        /// <summary>
+        /// Clears all skin sources.
+        /// </summary>
+        protected void ResetSources()
+        {
+            foreach (var i in skinSources.ToArray())
+                RemoveSource(i.skin);
+        }
+
+        /// <summary>
+        /// Invoked when any source has changed (either <see cref="ParentSource"/> or a source registered via <see cref="AddSource"/>).
+        /// This is also invoked once initially during <see cref="CreateChildDependencies"/> to ensure sources are ready for children consumption.
+        /// </summary>
+        protected virtual void OnSourceChanged() { }
+
+        protected void TriggerSourceChanged()
+        {
+            // Expose to implementations, giving them a chance to react before notifying external consumers.
+            OnSourceChanged();
+
+            SourceChanged?.Invoke();
         }
 
         protected override void Dispose(bool isDisposing)
@@ -219,11 +222,14 @@ namespace osu.Game.Skinning
 
             base.Dispose(isDisposing);
 
-            if (fallbackSource != null)
-                fallbackSource.SourceChanged -= OnSourceChanged;
+            if (ParentSource != null)
+                ParentSource.SourceChanged -= TriggerSourceChanged;
 
-            foreach (var source in SkinSources.OfType<ISkinSource>())
-                source.SourceChanged -= OnSourceChanged;
+            foreach (var i in skinSources)
+            {
+                if (i.skin is ISkinSource source)
+                    source.SourceChanged -= TriggerSourceChanged;
+            }
         }
 
         private class DisableableSkinSource : ISkin

osu.Game/Tests/CleanRunHeadlessGameHost.cs

@@ -25,8 +25,11 @@ namespace osu.Game.Tests
 
         protected override void SetupForRun()
         {
-            base.SetupForRun();
             Storage.DeleteDirectory(string.Empty);
+
+            // base call needs to be run *after* storage is emptied, as it updates the (static) logger's storage and may start writing
+            // log entries from another source if a unit test host is shared over multiple tests, causing a file access denied exception.
+            base.SetupForRun();
         }
     }
 }

osu.Game/Tests/Visual/PlayerTestScene.cs

@@ -57,7 +57,9 @@ namespace osu.Game.Tests.Visual
 
         protected void LoadPlayer()
         {
-            var ruleset = Ruleset.Value.CreateInstance();
+            var ruleset = CreatePlayerRuleset();
+            Ruleset.Value = ruleset.RulesetInfo;
+
             var beatmap = CreateBeatmap(ruleset.RulesetInfo);
 
             Beatmap.Value = CreateWorkingBeatmap(beatmap);

osu.Game/osu.Game.csproj

@@ -31,13 +31,13 @@
     <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="5.0.0" />
     <PackageReference Include="Microsoft.NETCore.Targets" Version="3.1.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
-    <PackageReference Include="ppy.LocalisationAnalyser" Version="2021.614.0">
+    <PackageReference Include="ppy.LocalisationAnalyser" Version="2021.706.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Realm" Version="10.2.1" />
-    <PackageReference Include="ppy.osu.Framework" Version="2021.702.0" />
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.701.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2021.707.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.706.0" />
     <PackageReference Include="Sentry" Version="3.6.0" />
     <PackageReference Include="SharpCompress" Version="0.28.3" />
     <PackageReference Include="NUnit" Version="3.13.2" />

osu.iOS.props

@@ -70,8 +70,8 @@
     <Reference Include="System.Net.Http" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="ppy.osu.Framework.iOS" Version="2021.702.0" />
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.701.0" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2021.707.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.706.0" />
   </ItemGroup>
   <!-- See https://github.com/dotnet/runtime/issues/35988 (can be removed after Xamarin uses net5.0 / net6.0) -->
   <PropertyGroup>
@@ -93,7 +93,7 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.6" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
-    <PackageReference Include="ppy.osu.Framework" Version="2021.702.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2021.707.0" />
     <PackageReference Include="SharpCompress" Version="0.28.3" />
     <PackageReference Include="NUnit" Version="3.13.2" />
     <PackageReference Include="SharpRaven" Version="2.4.0" />