Merge branch 'master' into transformers-per-skin

osu.Game.Rulesets.Catch/CatchSkinComponents.cs

@@ -8,9 +8,7 @@ namespace osu.Game.Rulesets.Catch
         Fruit,
         Banana,
         Droplet,
-        CatcherIdle,
+        Catcher,
-        CatcherFail,
-        CatcherKiai,
         CatchComboCounter
     }
 }

osu.Game.Rulesets.Catch/Difficulty/CatchPerformanceCalculator.cs

@@ -39,10 +39,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty
             tinyTicksMissed = Score.Statistics.GetOrDefault(HitResult.SmallTickMiss);
             misses = Score.Statistics.GetOrDefault(HitResult.Miss);
 
-            // Don't count scores made with supposedly unranked mods
-            if (mods.Any(m => !m.Ranked))
-                return 0;
-
             // We are heavily relying on aim in catch the beat
             double value = Math.Pow(5.0 * Math.Max(1.0, Attributes.StarRating / 0.0049) - 4.0, 2.0) / 100000.0;
 

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

@@ -10,7 +10,6 @@ namespace osu.Game.Rulesets.Catch.Mods
     public class CatchModHardRock : ModHardRock, IApplicableToBeatmap
     {
         public override double ScoreMultiplier => 1.12;
-        public override bool Ranked => true;
 
         public void ApplyToBeatmap(IBeatmap beatmap) => CatchBeatmapProcessor.ApplyPositionOffsets(beatmap, this);
     }

osu.Game.Rulesets.Catch/Skinning/Default/DefaultCatcher.cs

@@ -0,0 +1,54 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Rulesets.Catch.UI;
+
+namespace osu.Game.Rulesets.Catch.Skinning.Default
+{
+    public class DefaultCatcher : CompositeDrawable, ICatcherSprite
+    {
+        public Bindable<CatcherAnimationState> CurrentState { get; } = new Bindable<CatcherAnimationState>();
+
+        public Texture CurrentTexture => sprite.Texture;
+
+        private readonly Sprite sprite;
+
+        private readonly Dictionary<CatcherAnimationState, Texture> textures = new Dictionary<CatcherAnimationState, Texture>();
+
+        public DefaultCatcher()
+        {
+            RelativeSizeAxes = Axes.Both;
+            InternalChild = sprite = new Sprite
+            {
+                Anchor = Anchor.TopCentre,
+                Origin = Anchor.TopCentre,
+                RelativeSizeAxes = Axes.Both,
+                FillMode = FillMode.Fit
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(TextureStore store, Bindable<CatcherAnimationState> currentState)
+        {
+            CurrentState.BindTo(currentState);
+
+            textures[CatcherAnimationState.Idle] = store.Get(@"Gameplay/catch/fruit-catcher-idle");
+            textures[CatcherAnimationState.Fail] = store.Get(@"Gameplay/catch/fruit-catcher-fail");
+            textures[CatcherAnimationState.Kiai] = store.Get(@"Gameplay/catch/fruit-catcher-kiai");
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            CurrentState.BindValueChanged(state => sprite.Texture = textures[state.NewValue], true);
+        }
+    }
+}

osu.Game.Rulesets.Catch/Skinning/ICatcherSprite.cs

@@ -0,0 +1,12 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics.Textures;
+
+namespace osu.Game.Rulesets.Catch.Skinning
+{
+    public interface ICatcherSprite
+    {
+        Texture CurrentTexture { get; }
+    }
+}

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

@@ -65,17 +65,21 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
 
                         return null;
 
-                    case CatchSkinComponents.CatcherIdle:
+                    case CatchSkinComponents.Catcher:
-                        return this.GetAnimation("fruit-catcher-idle", true, true, true) ??
+                        var version = Source.GetConfig<LegacySkinConfiguration.LegacySetting, decimal>(LegacySkinConfiguration.LegacySetting.Version)?.Value ?? 1;
-                               this.GetAnimation("fruit-ryuuta", true, true, true);
 
-                    case CatchSkinComponents.CatcherFail:
+                        if (version < 2.3m)
-                        return this.GetAnimation("fruit-catcher-fail", true, true, true) ??
+                        {
-                               this.GetAnimation("fruit-ryuuta", true, true, true);
+                            if (GetTexture(@"fruit-ryuuta") != null ||
+                                GetTexture(@"fruit-ryuuta-0") != null)
+                                return new LegacyCatcherOld();
+                        }
 
-                    case CatchSkinComponents.CatcherKiai:
+                        if (GetTexture(@"fruit-catcher-idle") != null ||
-                        return this.GetAnimation("fruit-catcher-kiai", true, true, true) ??
+                            GetTexture(@"fruit-catcher-idle-0") != null)
-                               this.GetAnimation("fruit-ryuuta", true, true, true);
+                            return new LegacyCatcherNew();
+
+                        return null;
 
                     case CatchSkinComponents.CatchComboCounter:
                         if (providesComboCounter)

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

@@ -0,0 +1,73 @@
+// 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.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Animations;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Skinning.Legacy
+{
+    public class LegacyCatcherNew : CompositeDrawable, ICatcherSprite
+    {
+        [Resolved]
+        private Bindable<CatcherAnimationState> currentState { get; set; }
+
+        public Texture CurrentTexture => (currentDrawable as TextureAnimation)?.CurrentFrame ?? (currentDrawable as Sprite)?.Texture;
+
+        private readonly Dictionary<CatcherAnimationState, Drawable> drawables = new Dictionary<CatcherAnimationState, Drawable>();
+
+        private Drawable currentDrawable;
+
+        public LegacyCatcherNew()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(ISkinSource skin)
+        {
+            foreach (var state in Enum.GetValues(typeof(CatcherAnimationState)).Cast<CatcherAnimationState>())
+            {
+                AddInternal(drawables[state] = getDrawableFor(state).With(d =>
+                {
+                    d.Anchor = Anchor.TopCentre;
+                    d.Origin = Anchor.TopCentre;
+                    d.RelativeSizeAxes = Axes.Both;
+                    d.Size = Vector2.One;
+                    d.FillMode = FillMode.Fit;
+                    d.Alpha = 0;
+                }));
+            }
+
+            currentDrawable = drawables[CatcherAnimationState.Idle];
+
+            Drawable getDrawableFor(CatcherAnimationState state) =>
+                skin.GetAnimation(@$"fruit-catcher-{state.ToString().ToLowerInvariant()}", true, true, true) ??
+                skin.GetAnimation(@"fruit-catcher-idle", true, true, true);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            currentState.BindValueChanged(state =>
+            {
+                currentDrawable.Alpha = 0;
+                currentDrawable = drawables[state.NewValue];
+                currentDrawable.Alpha = 1;
+
+                (currentDrawable as IFramedAnimation)?.GotoFrame(0);
+            }, true);
+        }
+    }
+}

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

@@ -0,0 +1,37 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Animations;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Skinning.Legacy
+{
+    public class LegacyCatcherOld : CompositeDrawable, ICatcherSprite
+    {
+        public Texture CurrentTexture => (InternalChild as TextureAnimation)?.CurrentFrame ?? (InternalChild as Sprite)?.Texture;
+
+        public LegacyCatcherOld()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(ISkinSource skin)
+        {
+            InternalChild = skin.GetAnimation(@"fruit-ryuuta", true, true, true).With(d =>
+            {
+                d.Anchor = Anchor.TopCentre;
+                d.Origin = Anchor.TopCentre;
+                d.RelativeSizeAxes = Axes.Both;
+                d.Size = Vector2.One;
+                d.FillMode = FillMode.Fit;
+            });
+        }
+    }
+}

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

@@ -7,9 +7,9 @@ using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Animations;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Pooling;
+using osu.Framework.Graphics.Textures;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
@@ -18,6 +18,7 @@ using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.Skinning;
+using osu.Game.Rulesets.Catch.Skinning.Default;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Skinning;
 using osuTK;
@@ -78,17 +79,17 @@ namespace osu.Game.Rulesets.Catch.UI
         /// </summary>
         private readonly Container<CaughtObject> droppedObjectTarget;
 
-        public CatcherAnimationState CurrentState { get; private set; }
+        [Cached]
+        protected readonly Bindable<CatcherAnimationState> CurrentStateBindable = new Bindable<CatcherAnimationState>();
+
+        public CatcherAnimationState CurrentState => CurrentStateBindable.Value;
 
         /// <summary>
         /// The width of the catcher which can receive fruit. Equivalent to "catchMargin" in osu-stable.
         /// </summary>
         public const float ALLOWED_CATCH_RANGE = 0.8f;
 
-        /// <summary>
+        internal Texture CurrentTexture => ((ICatcherSprite)currentCatcher.Drawable).CurrentTexture;
-        /// The drawable catcher for <see cref="CurrentState"/>.
-        /// </summary>
-        internal Drawable CurrentDrawableCatcher => currentCatcher.Drawable;
 
         private bool dashing;
 
@@ -110,11 +111,7 @@ namespace osu.Game.Rulesets.Catch.UI
         /// </summary>
         private readonly float catchWidth;
 
-        private readonly CatcherSprite catcherIdle;
+        private readonly SkinnableDrawable currentCatcher;
-        private readonly CatcherSprite catcherKiai;
-        private readonly CatcherSprite catcherFail;
-
-        private CatcherSprite currentCatcher;
 
         private Color4 hyperDashColour = DEFAULT_HYPER_DASH_COLOUR;
         private Color4 hyperDashEndGlowColour = DEFAULT_HYPER_DASH_COLOUR;
@@ -156,20 +153,12 @@ namespace osu.Game.Rulesets.Catch.UI
                     Anchor = Anchor.TopCentre,
                     Origin = Anchor.BottomCentre,
                 },
-                catcherIdle = new CatcherSprite(CatcherAnimationState.Idle)
+                currentCatcher = new SkinnableDrawable(
+                    new CatchSkinComponent(CatchSkinComponents.Catcher),
+                    _ => new DefaultCatcher())
                 {
                     Anchor = Anchor.TopCentre,
-                    Alpha = 0,
+                    OriginPosition = new Vector2(0.5f, 0.06f) * CatcherArea.CATCHER_SIZE
-                },
-                catcherKiai = new CatcherSprite(CatcherAnimationState.Kiai)
-                {
-                    Anchor = Anchor.TopCentre,
-                    Alpha = 0,
-                },
-                catcherFail = new CatcherSprite(CatcherAnimationState.Fail)
-                {
-                    Anchor = Anchor.TopCentre,
-                    Alpha = 0,
                 },
                 hitExplosionContainer = new HitExplosionContainer
                 {
@@ -184,8 +173,6 @@ namespace osu.Game.Rulesets.Catch.UI
         {
             hitLighting = config.GetBindable<bool>(OsuSetting.HitLighting);
             trails = new CatcherTrailDisplay(this);
-
-            updateCatcher();
         }
 
         protected override void LoadComplete()
@@ -436,36 +423,12 @@ namespace osu.Game.Rulesets.Catch.UI
             }
         }
 
-        private void updateCatcher()
-        {
-            currentCatcher?.Hide();
-
-            switch (CurrentState)
-            {
-                default:
-                    currentCatcher = catcherIdle;
-                    break;
-
-                case CatcherAnimationState.Fail:
-                    currentCatcher = catcherFail;
-                    break;
-
-                case CatcherAnimationState.Kiai:
-                    currentCatcher = catcherKiai;
-                    break;
-            }
-
-            currentCatcher.Show();
-            (currentCatcher.Drawable as IFramedAnimation)?.GotoFrame(0);
-        }
-
         private void updateState(CatcherAnimationState state)
         {
             if (CurrentState == state)
                 return;
 
-            CurrentState = state;
+            CurrentStateBindable.Value = state;
-            updateCatcher();
         }
 
         private void placeCaughtObject(DrawablePalpableCatchHitObject drawableObject, Vector2 position)

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

@@ -1,59 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.Textures;
-using osu.Game.Skinning;
-using osuTK;
-
-namespace osu.Game.Rulesets.Catch.UI
-{
-    public class CatcherSprite : SkinnableDrawable
-    {
-        protected override bool ApplySizeRestrictionsToDefault => true;
-
-        public CatcherSprite(CatcherAnimationState state)
-            : base(new CatchSkinComponent(componentFromState(state)), _ =>
-                new DefaultCatcherSprite(state), confineMode: ConfineMode.ScaleToFit)
-        {
-            RelativeSizeAxes = Axes.None;
-            Size = new Vector2(CatcherArea.CATCHER_SIZE);
-
-            // Sets the origin roughly to the centre of the catcher's plate to allow for correct scaling.
-            OriginPosition = new Vector2(0.5f, 0.06f) * CatcherArea.CATCHER_SIZE;
-        }
-
-        private static CatchSkinComponents componentFromState(CatcherAnimationState state)
-        {
-            switch (state)
-            {
-                case CatcherAnimationState.Fail:
-                    return CatchSkinComponents.CatcherFail;
-
-                case CatcherAnimationState.Kiai:
-                    return CatchSkinComponents.CatcherKiai;
-
-                default:
-                    return CatchSkinComponents.CatcherIdle;
-            }
-        }
-
-        private class DefaultCatcherSprite : Sprite
-        {
-            private readonly CatcherAnimationState state;
-
-            public DefaultCatcherSprite(CatcherAnimationState state)
-            {
-                this.state = state;
-            }
-
-            [BackgroundDependencyLoader]
-            private void load(TextureStore textures)
-            {
-                Texture = textures.Get($"Gameplay/catch/fruit-catcher-{state.ToString().ToLower()}");
-            }
-        }
-    }
-}

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

@@ -4,10 +4,8 @@
 using System;
 using JetBrains.Annotations;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Animations;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Pooling;
-using osu.Framework.Graphics.Sprites;
 using osuTK;
 using osuTK.Graphics;
 
@@ -120,11 +118,9 @@ namespace osu.Game.Rulesets.Catch.UI
 
         private CatcherTrailSprite createTrailSprite(Container<CatcherTrailSprite> target)
         {
-            var texture = (catcher.CurrentDrawableCatcher as TextureAnimation)?.CurrentFrame ?? ((Sprite)catcher.CurrentDrawableCatcher).Texture;
-
             CatcherTrailSprite sprite = trailPool.Get();
 
-            sprite.Texture = texture;
+            sprite.Texture = catcher.CurrentTexture;
             sprite.Anchor = catcher.Anchor;
             sprite.Scale = catcher.Scale;
             sprite.Blending = BlendingParameters.Additive;

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

@@ -44,9 +44,6 @@ namespace osu.Game.Rulesets.Mania.Difficulty
             countMeh = Score.Statistics.GetOrDefault(HitResult.Meh);
             countMiss = Score.Statistics.GetOrDefault(HitResult.Miss);
 
-            if (mods.Any(m => !m.Ranked))
-                return 0;
-
             IEnumerable<Mod> scoreIncreaseMods = Ruleset.GetModsFor(ModType.DifficultyIncrease);
 
             double scoreMultiplier = 1.0;

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

@@ -15,7 +15,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         public abstract int KeyCount { get; }
         public override ModType Type => ModType.Conversion;
         public override double ScoreMultiplier => 1; // TODO: Implement the mania key mod score multiplier
-        public override bool Ranked => true;
 
         public void ApplyToBeatmapConverter(IBeatmapConverter beatmapConverter)
         {

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

@@ -24,8 +24,6 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override ModType Type => ModType.Conversion;
 
-        public override bool Ranked => false;
-
         public void ApplyToDrawableRuleset(DrawableRuleset<ManiaHitObject> drawableRuleset)
         {
             var maniaRuleset = (DrawableManiaRuleset)drawableRuleset;

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

@@ -17,7 +17,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override ModType Type => ModType.Conversion;
         public override string Description => "Notes are flipped horizontally.";
         public override double ScoreMultiplier => 1;
-        public override bool Ranked => true;
 
         public void ApplyToBeatmap(IBeatmap beatmap)
         {

osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs

@@ -41,10 +41,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             countMeh = Score.Statistics.GetOrDefault(HitResult.Meh);
             countMiss = Score.Statistics.GetOrDefault(HitResult.Miss);
 
-            // Don't count scores made with supposedly unranked mods
-            if (mods.Any(m => !m.Ranked))
-                return 0;
-
             // Custom multipliers for NoFail and SpunOut.
             double multiplier = 1.12; // This is being adjusted to keep the final pp value scaled around what it used to be when changing things
 

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

@@ -27,8 +27,6 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override IconUsage? Icon => FontAwesome.Solid.Adjust;
         public override ModType Type => ModType.DifficultyIncrease;
 
-        public override bool Ranked => false;
-
         public override double ScoreMultiplier => 1.12;
         private DrawableOsuBlinds blinds;
 

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

@@ -14,7 +14,6 @@ namespace osu.Game.Rulesets.Osu.Mods
     public class OsuModHardRock : ModHardRock, IApplicableToHitObject
     {
         public override double ScoreMultiplier => 1.06;
-        public override bool Ranked => true;
 
         public void ApplyToHitObject(HitObject hitObject)
         {

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

@@ -22,7 +22,6 @@ namespace osu.Game.Rulesets.Osu.Mods
     public class OsuModRandom : ModRandom, IApplicableToBeatmap
     {
         public override string Description => "It never gets boring!";
-        public override bool Ranked => false;
 
         // The relative distance to the edge of the playfield before objects' positions should start to "turn around" and curve towards the middle.
         // The closer the hit objects draw to the border, the sharper the turn

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

@@ -21,7 +21,6 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override ModType Type => ModType.Automation;
         public override string Description => @"Spinners will be automatically completed.";
         public override double ScoreMultiplier => 0.9;
-        public override bool Ranked => true;
         public override Type[] IncompatibleMods => new[] { typeof(ModAutoplay), typeof(OsuModAutopilot) };
 
         public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)

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

@@ -13,7 +13,5 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override double ScoreMultiplier => 1;
 
         public override ModType Type => ModType.System;
-
-        public override bool Ranked => true;
     }
 }

osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs

@@ -36,10 +36,6 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
             countMeh = Score.Statistics.GetOrDefault(HitResult.Meh);
             countMiss = Score.Statistics.GetOrDefault(HitResult.Miss);
 
-            // Don't count scores made with supposedly unranked mods
-            if (mods.Any(m => !m.Ranked))
-                return 0;
-
             // Custom multipliers for NoFail and SpunOut.
             double multiplier = 1.1; // This is being adjusted to keep the final pp value scaled around what it used to be when changing things
 

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

@@ -9,7 +9,6 @@ namespace osu.Game.Rulesets.Taiko.Mods
     public class TaikoModHardRock : ModHardRock
     {
         public override double ScoreMultiplier => 1.06;
-        public override bool Ranked => true;
 
         /// <summary>
         /// Multiplier factor added to the scrolling speed.

osu.Game.Tests/Skins/TestSceneBeatmapSkinLookupDisables.cs

@@ -0,0 +1,116 @@
+// 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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.OpenGL.Textures;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Testing;
+using osu.Game.Audio;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Skinning;
+using osu.Game.Tests.Beatmaps;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Tests.Skins
+{
+    [TestFixture]
+    [HeadlessTest]
+    public class TestSceneBeatmapSkinLookupDisables : OsuTestScene
+    {
+        private UserSkinSource userSource;
+        private BeatmapSkinSource beatmapSource;
+        private SkinRequester requester;
+
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            Add(new SkinProvidingContainer(userSource = new UserSkinSource())
+                .WithChild(new BeatmapSkinProvidingContainer(beatmapSource = new BeatmapSkinSource())
+                    .WithChild(requester = new SkinRequester())));
+        });
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestDrawableLookup(bool allowBeatmapLookups)
+        {
+            AddStep($"Set beatmap skin enabled to {allowBeatmapLookups}", () => config.SetValue(OsuSetting.BeatmapSkins, allowBeatmapLookups));
+
+            string expected = allowBeatmapLookups ? "beatmap" : "user";
+
+            AddAssert($"Check lookup is from {expected}", () => requester.GetDrawableComponent(new TestSkinComponent())?.Name == expected);
+        }
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestProviderLookup(bool allowBeatmapLookups)
+        {
+            AddStep($"Set beatmap skin enabled to {allowBeatmapLookups}", () => config.SetValue(OsuSetting.BeatmapSkins, allowBeatmapLookups));
+
+            ISkin expected() => allowBeatmapLookups ? (ISkin)beatmapSource : userSource;
+
+            AddAssert("Check lookup is from correct source", () => requester.FindProvider(s => s.GetDrawableComponent(new TestSkinComponent()) != null) == expected());
+        }
+
+        public class UserSkinSource : LegacySkin
+        {
+            public UserSkinSource()
+                : base(new SkinInfo(), null, null, string.Empty)
+            {
+            }
+
+            public override Drawable GetDrawableComponent(ISkinComponent component)
+            {
+                return new Container { Name = "user" };
+            }
+        }
+
+        public class BeatmapSkinSource : LegacyBeatmapSkin
+        {
+            public BeatmapSkinSource()
+                : base(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo, null, null)
+            {
+            }
+
+            public override Drawable GetDrawableComponent(ISkinComponent component)
+            {
+                return new Container { Name = "beatmap" };
+            }
+        }
+
+        public class SkinRequester : Drawable, ISkin
+        {
+            private ISkinSource skin;
+
+            [BackgroundDependencyLoader]
+            private void load(ISkinSource skin)
+            {
+                this.skin = skin;
+            }
+
+            public Drawable GetDrawableComponent(ISkinComponent component) => skin.GetDrawableComponent(component);
+
+            public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => skin.GetTexture(componentName, wrapModeS, wrapModeT);
+
+            public ISample GetSample(ISampleInfo sampleInfo) => skin.GetSample(sampleInfo);
+
+            public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => skin.GetConfig<TLookup, TValue>(lookup);
+
+            public ISkin FindProvider(Func<ISkin, bool> lookupFunction) => skin.FindProvider(lookupFunction);
+        }
+
+        private class TestSkinComponent : ISkinComponent
+        {
+            public string LookupName => string.Empty;
+        }
+    }
+}

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

@@ -143,6 +143,25 @@ Line after image";
             });
         }
 
+        [Test]
+        public void TestTableWithImageContent()
+        {
+            AddStep("Add Table", () =>
+            {
+                markdownContainer.DocumentUrl = "https://dev.ppy.sh";
+                markdownContainer.Text = @"
+| Image | Name | Effect |
+| :-: | :-: | :-- |
+| ![](/wiki/Skinning/Interface/img/hit300.png ""300"") | 300 | A possible score when tapping a hit circle precisely on time, completing a Slider and keeping the cursor over every tick, or completing a Spinner with the Spinner Metre full. A score of 300 appears in an blue score by default. Scoring nothing except 300s in a beatmap will award the player with the SS or SSH grade. |
+| ![](/wiki/Skinning/Interface/img/hit300g.png ""Geki"") | (激) Geki | A term from Ouendan, called Elite Beat! in EBA. Appears when playing the last element in a combo in which the player has scored only 300s. Getting a Geki will give a sizable boost to the Life Bar. By default, it is blue. |
+| ![](/wiki/Skinning/Interface/img/hit100.png ""100"") | 100 | A possible score one can get when tapping a Hit Object slightly late or early, completing a Slider and missing a number of ticks, or completing a Spinner with the Spinner Meter almost full. A score of 100 appears in a green score by default. When very skilled players test a beatmap and they get a lot of 100s, this may mean that the beatmap does not have correct timing. |
+| ![](/wiki/Skinning/Interface/img/hit300k.png ""300 Katu"") ![](/wiki/Skinning/Interface/img/hit100k.png ""100 Katu"") | (喝) Katu or Katsu | A term from Ouendan, called Beat! in EBA. Appears when playing the last element in a combo in which the player has scored at least one 100, but no 50s or misses. Getting a Katu will give a small boost to the Life Bar. By default, it is coloured green or blue depending on whether the Katu itself is a 100 or a 300. |
+| ![](/wiki/Skinning/Interface/img/hit50.png ""50"") | 50 | A possible score one can get when tapping a hit circle rather early or late but not early or late enough to cause a miss, completing a Slider and missing a lot of ticks, or completing a Spinner with the Spinner Metre close to full. A score of 50 appears in a orange score by default. Scoring a 50 in a combo will prevent the appearance of a Katu or a Geki at the combo's end. |
+| ![](/wiki/Skinning/Interface/img/hit0.png ""Miss"") | Miss | A possible score one can get when not tapping a hit circle or too early (based on OD and AR, it may *shake* instead), not tapping or holding the Slider at least once, or completing a Spinner with low Spinner Metre fill. Scoring a Miss will reset the current combo to 0 and will prevent the appearance of a Katu or a Geki at the combo's end. |
+";
+            });
+        }
+
         private class TestMarkdownContainer : WikiMarkdownContainer
         {
             public LinkInline Link;

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

@@ -2,11 +2,14 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Testing;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterfaceV2;
+using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Tests.Visual.UserInterface
@@ -21,6 +24,45 @@ namespace osu.Game.Tests.Visual.UserInterface
         [TestCase(true)]
         public void TestNonPadded(bool hasDescription) => createPaddedComponent(hasDescription, false);
 
+        [Test]
+        public void TestFixedWidth()
+        {
+            const float label_width = 200;
+
+            AddStep("create components", () => Child = new FillFlowContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(0, 10),
+                Children = new Drawable[]
+                {
+                    new NonPaddedLabelledDrawable
+                    {
+                        Label = "short",
+                        FixedLabelWidth = label_width
+                    },
+                    new NonPaddedLabelledDrawable
+                    {
+                        Label = "very very very very very very very very very very very long",
+                        FixedLabelWidth = label_width
+                    },
+                    new PaddedLabelledDrawable
+                    {
+                        Label = "short",
+                        FixedLabelWidth = label_width
+                    },
+                    new PaddedLabelledDrawable
+                    {
+                        Label = "very very very very very very very very very very very long",
+                        FixedLabelWidth = label_width
+                    }
+                }
+            });
+
+            AddStep("unset label width", () => this.ChildrenOfType<LabelledDrawable<Drawable>>().ForEach(d => d.FixedLabelWidth = null));
+            AddStep("reset label width", () => this.ChildrenOfType<LabelledDrawable<Drawable>>().ForEach(d => d.FixedLabelWidth = label_width));
+        }
+
         private void createPaddedComponent(bool hasDescription = false, bool padded = true)
         {
             AddStep("create component", () =>

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

@@ -0,0 +1,20 @@
+// 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 Markdig.Syntax.Inlines;
+using osu.Framework.Graphics.Containers.Markdown;
+using osu.Framework.Graphics.Cursor;
+
+namespace osu.Game.Graphics.Containers.Markdown
+{
+    public class OsuMarkdownImage : MarkdownImage, IHasTooltip
+    {
+        public string TooltipText { get; }
+
+        public OsuMarkdownImage(LinkInline linkInline)
+            : base(linkInline.Url)
+        {
+            TooltipText = linkInline.Title;
+        }
+    }
+}

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

@@ -17,6 +17,8 @@ namespace osu.Game.Graphics.Containers.Markdown
         protected override void AddLinkText(string text, LinkInline linkInline)
             => AddDrawable(new OsuMarkdownLinkText(text, linkInline));
 
+        protected override void AddImage(LinkInline linkInline) => AddDrawable(new OsuMarkdownImage(linkInline));
+
         // TODO : Change font to monospace
         protected override void AddCodeInLine(CodeInline codeInline) => AddDrawable(new OsuMarkdownInlineCode
         {

osu.Game/Graphics/UserInterfaceV2/LabelledDrawable.cs

@@ -14,6 +14,27 @@ namespace osu.Game.Graphics.UserInterfaceV2
     public abstract class LabelledDrawable<T> : CompositeDrawable
         where T : Drawable
     {
+        private float? fixedLabelWidth;
+
+        /// <summary>
+        /// The fixed width of the label of this <see cref="LabelledDrawable{T}"/>.
+        /// If <c>null</c>, the label portion will auto-size to its content.
+        /// Can be used in layout scenarios where several labels must match in length for the components to be aligned properly.
+        /// </summary>
+        public float? FixedLabelWidth
+        {
+            get => fixedLabelWidth;
+            set
+            {
+                if (fixedLabelWidth == value)
+                    return;
+
+                fixedLabelWidth = value;
+
+                updateLabelWidth();
+            }
+        }
+
         protected const float CONTENT_PADDING_VERTICAL = 10;
         protected const float CONTENT_PADDING_HORIZONTAL = 15;
         protected const float CORNER_RADIUS = 15;
@@ -23,6 +44,7 @@ namespace osu.Game.Graphics.UserInterfaceV2
         /// </summary>
         protected readonly T Component;
 
+        private readonly GridContainer grid;
         private readonly OsuTextFlowContainer labelText;
         private readonly OsuTextFlowContainer descriptionText;
 
@@ -56,7 +78,7 @@ namespace osu.Game.Graphics.UserInterfaceV2
                     Spacing = new Vector2(0, 12),
                     Children = new Drawable[]
                     {
-                        new GridContainer
+                        grid = new GridContainer
                         {
                             RelativeSizeAxes = Axes.X,
                             AutoSizeAxes = Axes.Y,
@@ -69,7 +91,13 @@ namespace osu.Game.Graphics.UserInterfaceV2
                                         Anchor = Anchor.CentreLeft,
                                         Origin = Anchor.CentreLeft,
                                         AutoSizeAxes = Axes.Both,
-                                        Padding = new MarginPadding { Right = 20 }
+                                        Padding = new MarginPadding
+                                        {
+                                            Right = 20,
+                                            // ensure that the label is always vertically padded even if the component itself isn't.
+                                            // this may become an issue if the label is taller than the component.
+                                            Vertical = padded ? 0 : CONTENT_PADDING_VERTICAL
+                                        }
                                     },
                                     new Container
                                     {
@@ -87,7 +115,6 @@ namespace osu.Game.Graphics.UserInterfaceV2
                                 },
                             },
                             RowDimensions = new[] { new Dimension(GridSizeMode.AutoSize) },
-                            ColumnDimensions = new[] { new Dimension(GridSizeMode.AutoSize) }
                         },
                         descriptionText = new OsuTextFlowContainer(s => s.Font = OsuFont.GetFont(size: 12, weight: FontWeight.Bold, italics: true))
                         {
@@ -99,6 +126,24 @@ namespace osu.Game.Graphics.UserInterfaceV2
                     }
                 }
             };
+
+            updateLabelWidth();
+        }
+
+        private void updateLabelWidth()
+        {
+            if (fixedLabelWidth == null)
+            {
+                grid.ColumnDimensions = new[] { new Dimension(GridSizeMode.AutoSize) };
+                labelText.RelativeSizeAxes = Axes.None;
+                labelText.AutoSizeAxes = Axes.Both;
+            }
+            else
+            {
+                grid.ColumnDimensions = new[] { new Dimension(GridSizeMode.Absolute, fixedLabelWidth.Value) };
+                labelText.AutoSizeAxes = Axes.Y;
+                labelText.RelativeSizeAxes = Axes.X;
+            }
         }
 
         [BackgroundDependencyLoader]

osu.Game/Overlays/BeatmapSet/Info.cs

@@ -36,7 +36,7 @@ namespace osu.Game.Overlays.BeatmapSet
         public Info()
         {
             MetadataSection source, tags, genre, language;
-            OsuSpriteText unrankedPlaceholder;
+            OsuSpriteText notRankedPlaceholder;
 
             RelativeSizeAxes = Axes.X;
             Height = base_height;
@@ -102,12 +102,12 @@ namespace osu.Game.Overlays.BeatmapSet
                                     RelativeSizeAxes = Axes.Both,
                                     Padding = new MarginPadding { Top = 20, Horizontal = 15 },
                                 },
-                                unrankedPlaceholder = new OsuSpriteText
+                                notRankedPlaceholder = new OsuSpriteText
                                 {
                                     Anchor = Anchor.Centre,
                                     Origin = Anchor.Centre,
                                     Alpha = 0,
-                                    Text = "Unranked beatmap",
+                                    Text = "This beatmap is not ranked",
                                     Font = OsuFont.GetFont(size: 12)
                                 },
                             },
@@ -124,7 +124,7 @@ namespace osu.Game.Overlays.BeatmapSet
                 language.Text = b.NewValue?.OnlineInfo?.Language?.Name ?? string.Empty;
                 var setHasLeaderboard = b.NewValue?.OnlineInfo?.Status > 0;
                 successRate.Alpha = setHasLeaderboard ? 1 : 0;
-                unrankedPlaceholder.Alpha = setHasLeaderboard ? 0 : 1;
+                notRankedPlaceholder.Alpha = setHasLeaderboard ? 0 : 1;
                 Height = setHasLeaderboard ? 270 : base_height;
             };
         }

osu.Game/Overlays/BeatmapSet/LeaderboardModSelector.cs

@@ -52,7 +52,7 @@ namespace osu.Game.Overlays.BeatmapSet
                 return;
 
             modsContainer.Add(new ModButton(new ModNoMod()));
-            modsContainer.AddRange(ruleset.NewValue.CreateInstance().GetAllMods().Where(m => m.Ranked).Select(m => new ModButton(m)));
+            modsContainer.AddRange(ruleset.NewValue.CreateInstance().GetAllMods().Where(m => m.UserPlayable).Select(m => new ModButton(m)));
 
             modsContainer.ForEach(button => button.OnSelectionChanged = selectionChanged);
         }

osu.Game/Overlays/Wiki/Markdown/WikiMarkdownImage.cs

@@ -2,19 +2,15 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using Markdig.Syntax.Inlines;
-using osu.Framework.Graphics.Containers.Markdown;
+using osu.Game.Graphics.Containers.Markdown;
-using osu.Framework.Graphics.Cursor;
 
 namespace osu.Game.Overlays.Wiki.Markdown
 {
-    public class WikiMarkdownImage : MarkdownImage, IHasTooltip
+    public class WikiMarkdownImage : OsuMarkdownImage
     {
-        public string TooltipText { get; }
-
         public WikiMarkdownImage(LinkInline linkInline)
-            : base(linkInline.Url)
+            : base(linkInline)
         {
-            TooltipText = linkInline.Title;
         }
 
         protected override ImageContainer CreateImageContainer(string url)

osu.Game/Rulesets/Mods/Mod.cs

@@ -108,10 +108,14 @@ namespace osu.Game.Rulesets.Mods
         public virtual bool HasImplementation => this is IApplicableMod;
 
         /// <summary>
-        /// Returns if this mod is ranked.
+        /// Whether this mod is playable by an end user.
+        /// Should be <c>false</c> for cases where the user is not interacting with the game (so it can be excluded from mutliplayer selection, for example).
         /// </summary>
         [JsonIgnore]
-        public virtual bool Ranked => false;
+        public virtual bool UserPlayable => true;
+
+        [Obsolete("Going forward, the concept of \"ranked\" doesn't exist. The only exceptions are automation mods, which should now override and set UserPlayable to true.")] // Can be removed 20211009
+        public virtual bool IsRanked => false;
 
         /// <summary>
         /// Whether this mod requires configuration to apply changes to the game.

osu.Game/Rulesets/Mods/ModAutoplay.cs

@@ -24,6 +24,8 @@ namespace osu.Game.Rulesets.Mods
 
         public bool RestartOnFail => false;
 
+        public override bool UserPlayable => false;
+
         public override Type[] IncompatibleMods => new[] { typeof(ModRelax), typeof(ModFailCondition), typeof(ModNoFail) };
 
         public override bool HasImplementation => GetType().GenericTypeArguments.Length == 0;

osu.Game/Rulesets/Mods/ModClassic.cs

@@ -17,8 +17,6 @@ namespace osu.Game.Rulesets.Mods
 
         public override string Description => "Feeling nostalgic?";
 
-        public override bool Ranked => false;
-
         public override ModType Type => ModType.Conversion;
     }
 }

osu.Game/Rulesets/Mods/ModDoubleTime.cs

@@ -17,7 +17,6 @@ namespace osu.Game.Rulesets.Mods
         public override IconUsage? Icon => OsuIcon.ModDoubletime;
         public override ModType Type => ModType.DifficultyIncrease;
         public override string Description => "Zoooooooooom...";
-        public override bool Ranked => true;
 
         public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(ModHalfTime)).ToArray();
 

osu.Game/Rulesets/Mods/ModEasy.cs

@@ -15,7 +15,6 @@ namespace osu.Game.Rulesets.Mods
         public override IconUsage? Icon => OsuIcon.ModEasy;
         public override ModType Type => ModType.DifficultyReduction;
         public override double ScoreMultiplier => 0.5;
-        public override bool Ranked => true;
         public override Type[] IncompatibleMods => new[] { typeof(ModHardRock), typeof(ModDifficultyAdjust) };
 
         public virtual void ReadFromDifficulty(BeatmapDifficulty difficulty)

osu.Game/Rulesets/Mods/ModFlashlight.cs

@@ -31,7 +31,6 @@ namespace osu.Game.Rulesets.Mods
         public override IconUsage? Icon => OsuIcon.ModFlashlight;
         public override ModType Type => ModType.DifficultyIncrease;
         public override string Description => "Restricted view area.";
-        public override bool Ranked => true;
 
         internal ModFlashlight()
         {

osu.Game/Rulesets/Mods/ModHalfTime.cs

@@ -17,7 +17,6 @@ namespace osu.Game.Rulesets.Mods
         public override IconUsage? Icon => OsuIcon.ModHalftime;
         public override ModType Type => ModType.DifficultyReduction;
         public override string Description => "Less zoom...";
-        public override bool Ranked => true;
 
         public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(ModDoubleTime)).ToArray();
 

osu.Game/Rulesets/Mods/ModHidden.cs

@@ -14,7 +14,6 @@ namespace osu.Game.Rulesets.Mods
         public override string Acronym => "HD";
         public override IconUsage? Icon => OsuIcon.ModHidden;
         public override ModType Type => ModType.DifficultyIncrease;
-        public override bool Ranked => true;
 
         public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor)
         {

osu.Game/Rulesets/Mods/ModNoFail.cs

@@ -15,7 +15,6 @@ namespace osu.Game.Rulesets.Mods
         public override ModType Type => ModType.DifficultyReduction;
         public override string Description => "You can't fail, no matter what.";
         public override double ScoreMultiplier => 0.5;
-        public override bool Ranked => true;
         public override Type[] IncompatibleMods => new[] { typeof(ModRelax), typeof(ModFailCondition), typeof(ModAutoplay) };
     }
 }

osu.Game/Rulesets/Mods/ModPerfect.cs

@@ -16,7 +16,6 @@ namespace osu.Game.Rulesets.Mods
         public override string Acronym => "PF";
         public override IconUsage? Icon => OsuIcon.ModPerfect;
         public override ModType Type => ModType.DifficultyIncrease;
-        public override bool Ranked => true;
         public override double ScoreMultiplier => 1;
         public override string Description => "SS or quit.";
 

osu.Game/Rulesets/Mods/ModSuddenDeath.cs

@@ -18,7 +18,6 @@ namespace osu.Game.Rulesets.Mods
         public override ModType Type => ModType.DifficultyIncrease;
         public override string Description => "Miss and fail.";
         public override double ScoreMultiplier => 1;
-        public override bool Ranked => true;
 
         public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(ModPerfect)).ToArray();
 

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

@@ -25,6 +25,7 @@ namespace osu.Game.Screens.Edit.Setup
                 comboColours = new LabelledColourPalette
                 {
                     Label = "Hitcircle / Slider Combos",
+                    FixedLabelWidth = LABEL_WIDTH,
                     ColourNamePrefix = "Combo"
                 }
             };

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

@@ -28,6 +28,7 @@ namespace osu.Game.Screens.Edit.Setup
                 circleSizeSlider = new LabelledSliderBar<float>
                 {
                     Label = "Object Size",
+                    FixedLabelWidth = LABEL_WIDTH,
                     Description = "The size of all hit objects",
                     Current = new BindableFloat(Beatmap.BeatmapInfo.BaseDifficulty.CircleSize)
                     {
@@ -40,6 +41,7 @@ namespace osu.Game.Screens.Edit.Setup
                 healthDrainSlider = new LabelledSliderBar<float>
                 {
                     Label = "Health Drain",
+                    FixedLabelWidth = LABEL_WIDTH,
                     Description = "The rate of passive health drain throughout playable time",
                     Current = new BindableFloat(Beatmap.BeatmapInfo.BaseDifficulty.DrainRate)
                     {
@@ -52,6 +54,7 @@ namespace osu.Game.Screens.Edit.Setup
                 approachRateSlider = new LabelledSliderBar<float>
                 {
                     Label = "Approach Rate",
+                    FixedLabelWidth = LABEL_WIDTH,
                     Description = "The speed at which objects are presented to the player",
                     Current = new BindableFloat(Beatmap.BeatmapInfo.BaseDifficulty.ApproachRate)
                     {
@@ -64,6 +67,7 @@ namespace osu.Game.Screens.Edit.Setup
                 overallDifficultySlider = new LabelledSliderBar<float>
                 {
                     Label = "Overall Difficulty",
+                    FixedLabelWidth = LABEL_WIDTH,
                     Description = "The harshness of hit windows and difficulty of special objects (ie. spinners)",
                     Current = new BindableFloat(Beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty)
                     {

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

@@ -27,24 +27,28 @@ namespace osu.Game.Screens.Edit.Setup
                 artistTextBox = new LabelledTextBox
                 {
                     Label = "Artist",
+                    FixedLabelWidth = LABEL_WIDTH,
                     Current = { Value = Beatmap.Metadata.Artist },
                     TabbableContentContainer = this
                 },
                 titleTextBox = new LabelledTextBox
                 {
                     Label = "Title",
+                    FixedLabelWidth = LABEL_WIDTH,
                     Current = { Value = Beatmap.Metadata.Title },
                     TabbableContentContainer = this
                 },
                 creatorTextBox = new LabelledTextBox
                 {
                     Label = "Creator",
+                    FixedLabelWidth = LABEL_WIDTH,
                     Current = { Value = Beatmap.Metadata.AuthorString },
                     TabbableContentContainer = this
                 },
                 difficultyTextBox = new LabelledTextBox
                 {
                     Label = "Difficulty Name",
+                    FixedLabelWidth = LABEL_WIDTH,
                     Current = { Value = Beatmap.BeatmapInfo.Version },
                     TabbableContentContainer = this
                 },

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

@@ -54,6 +54,7 @@ namespace osu.Game.Screens.Edit.Setup
                         backgroundTextBox = new FileChooserLabelledTextBox(".jpg", ".jpeg", ".png")
                         {
                             Label = "Background",
+                            FixedLabelWidth = LABEL_WIDTH,
                             PlaceholderText = "Click to select a background image",
                             Current = { Value = working.Value.Metadata.BackgroundFile },
                             Target = backgroundFileChooserContainer,
@@ -72,6 +73,7 @@ namespace osu.Game.Screens.Edit.Setup
                         audioTrackTextBox = new FileChooserLabelledTextBox(".mp3", ".ogg")
                         {
                             Label = "Audio Track",
+                            FixedLabelWidth = LABEL_WIDTH,
                             PlaceholderText = "Click to select a track",
                             Current = { Value = working.Value.Metadata.AudioFile },
                             Target = audioTrackFileChooserContainer,

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

@@ -7,6 +7,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Localisation;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterfaceV2;
 using osuTK;
 
 namespace osu.Game.Screens.Edit.Setup
@@ -15,6 +16,11 @@ namespace osu.Game.Screens.Edit.Setup
     {
         private readonly FillFlowContainer flow;
 
+        /// <summary>
+        /// Used to align some of the child <see cref="LabelledDrawable{T}"/>s together to achieve a grid-like look.
+        /// </summary>
+        protected const float LABEL_WIDTH = 160;
+
         [Resolved]
         protected OsuColour Colours { get; private set; }
 

osu.Game/Screens/OnlinePlay/DrawableRoomPlaylistItem.cs

@@ -202,7 +202,6 @@ namespace osu.Game.Screens.OnlinePlay
                                                 Child = modDisplay = new ModDisplay
                                                 {
                                                     Scale = new Vector2(0.4f),
-                                                    DisplayUnrankedText = false,
                                                     ExpansionMode = ExpansionMode.AlwaysExpanded
                                                 }
                                             }

osu.Game/Screens/OnlinePlay/FooterButtonFreeMods.cs

@@ -31,7 +31,6 @@ namespace osu.Game.Screens.OnlinePlay
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
-                DisplayUnrankedText = false,
                 Scale = new Vector2(0.8f),
                 ExpansionMode = ExpansionMode.AlwaysContracted,
             });

osu.Game/Screens/OnlinePlay/FreeModSelectOverlay.cs

@@ -25,7 +25,7 @@ namespace osu.Game.Screens.OnlinePlay
         public new Func<Mod, bool> IsValidMod
         {
             get => base.IsValidMod;
-            set => base.IsValidMod = m => m.HasImplementation && !(m is ModAutoplay) && value(m);
+            set => base.IsValidMod = m => m.HasImplementation && m.UserPlayable && value(m);
         }
 
         public FreeModSelectOverlay()

osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs

@@ -185,7 +185,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
                                                                                     {
                                                                                         Anchor = Anchor.CentreLeft,
                                                                                         Origin = Anchor.CentreLeft,
-                                                                                        DisplayUnrankedText = false,
                                                                                         Current = UserMods,
                                                                                         Scale = new Vector2(0.8f),
                                                                                     },

osu.Game/Screens/OnlinePlay/Multiplayer/Participants/ParticipantPanel.cs

@@ -139,7 +139,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Participants
                                 {
                                     Scale = new Vector2(0.5f),
                                     ExpansionMode = ExpansionMode.AlwaysContracted,
-                                    DisplayUnrankedText = false,
                                 }
                             },
                             userStateDisplay = new StateDisplay

osu.Game/Screens/OnlinePlay/OnlinePlaySongSelect.cs

@@ -161,7 +161,7 @@ namespace osu.Game.Screens.OnlinePlay
         /// </summary>
         /// <param name="mod">The <see cref="Mod"/> to check.</param>
         /// <returns>Whether <paramref name="mod"/> is a valid mod for online play.</returns>
-        protected virtual bool IsValidMod(Mod mod) => mod.HasImplementation && !ModUtils.FlattenMod(mod).Any(m => m is ModAutoplay);
+        protected virtual bool IsValidMod(Mod mod) => mod.HasImplementation && ModUtils.FlattenMod(mod).All(m => m.UserPlayable);
 
         /// <summary>
         /// Checks whether a given <see cref="Mod"/> is valid for per-player free-mod selection.

osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs

@@ -175,7 +175,6 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
                                                                                     {
                                                                                         Anchor = Anchor.CentreLeft,
                                                                                         Origin = Anchor.CentreLeft,
-                                                                                        DisplayUnrankedText = false,
                                                                                         Current = UserMods,
                                                                                         Scale = new Vector2(0.8f),
                                                                                     },

osu.Game/Screens/Play/HUD/ModDisplay.cs

@@ -3,18 +3,15 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.UserInterface;
-using osu.Game.Graphics.Sprites;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics.Containers;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
 using osuTK;
-using osu.Game.Graphics.Containers;
-using osu.Framework.Input.Events;
-using osu.Game.Graphics;
 
 namespace osu.Game.Screens.Play.HUD
 {
@@ -22,8 +19,6 @@ namespace osu.Game.Screens.Play.HUD
     {
         private const int fade_duration = 1000;
 
-        public bool DisplayUnrankedText = true;
-
         public ExpansionMode ExpansionMode = ExpansionMode.ExpandOnHover;
 
         private readonly Bindable<IReadOnlyList<Mod>> current = new Bindable<IReadOnlyList<Mod>>();
@@ -42,7 +37,6 @@ namespace osu.Game.Screens.Play.HUD
         }
 
         private readonly FillFlowContainer<ModIcon> iconsContainer;
-        private readonly OsuSpriteText unrankedText;
 
         public ModDisplay()
         {
@@ -63,13 +57,6 @@ namespace osu.Game.Screens.Play.HUD
                         AutoSizeAxes = Axes.Both,
                         Direction = FillDirection.Horizontal,
                     },
-                    unrankedText = new OsuSpriteText
-                    {
-                        Anchor = Anchor.TopCentre,
-                        Origin = Anchor.TopCentre,
-                        Text = @"/ UNRANKED /",
-                        Font = OsuFont.Numeric.With(size: 12)
-                    }
                 },
             };
         }
@@ -102,11 +89,6 @@ namespace osu.Game.Screens.Play.HUD
 
         private void appearTransform()
         {
-            if (DisplayUnrankedText && Current.Value.Any(m => !m.Ranked))
-                unrankedText.FadeInFromZero(fade_duration, Easing.OutQuint);
-            else
-                unrankedText.Hide();
-
             expand();
 
             using (iconsContainer.BeginDelayedSequence(1200))

osu.Game/Screens/Play/SubmittingPlayer.cs

@@ -10,7 +10,6 @@ using osu.Framework.Logging;
 using osu.Framework.Screens;
 using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
-using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
 
 namespace osu.Game.Screens.Play
@@ -44,9 +43,9 @@ namespace osu.Game.Screens.Play
             // Token request construction should happen post-load to allow derived classes to potentially prepare DI backings that are used to create the request.
             var tcs = new TaskCompletionSource<bool>();
 
-            if (Mods.Value.Any(m => m is ModAutoplay))
+            if (Mods.Value.Any(m => !m.UserPlayable))
             {
-                handleTokenFailure(new InvalidOperationException("Autoplay loaded."));
+                handleTokenFailure(new InvalidOperationException("Non-user playable mod selected."));
                 return false;
             }
 

osu.Game/Screens/Ranking/Contracted/ContractedPanelMiddleContent.cs

@@ -137,7 +137,6 @@ namespace osu.Game.Screens.Ranking.Contracted
                                             Origin = Anchor.TopCentre,
                                             AutoSizeAxes = Axes.Both,
                                             ExpansionMode = ExpansionMode.AlwaysExpanded,
-                                            DisplayUnrankedText = false,
                                             Current = { Value = score.Mods },
                                             Scale = new Vector2(0.5f),
                                         }

osu.Game/Screens/Ranking/Expanded/ExpandedPanelMiddleContent.cs

@@ -242,7 +242,6 @@ namespace osu.Game.Screens.Ranking.Expanded
                 {
                     Anchor = Anchor.CentreLeft,
                     Origin = Anchor.CentreLeft,
-                    DisplayUnrankedText = false,
                     ExpansionMode = ExpansionMode.AlwaysExpanded,
                     Scale = new Vector2(0.5f),
                     Current = { Value = score.Mods }

osu.Game/Screens/Ranking/ResultsScreen.cs

@@ -18,7 +18,6 @@ using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Input.Bindings;
 using osu.Game.Online.API;
-using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Ranking.Expanded.Accuracy;
@@ -154,7 +153,7 @@ namespace osu.Game.Screens.Ranking
             if (Score != null)
             {
                 // only show flair / animation when arriving after watching a play that isn't autoplay.
-                bool shouldFlair = player != null && !Score.Mods.Any(m => m is ModAutoplay);
+                bool shouldFlair = player != null && Score.Mods.All(m => m.UserPlayable);
 
                 ScorePanelList.AddScore(Score, shouldFlair);
 
@@ -318,7 +317,7 @@ namespace osu.Game.Screens.Ranking
                 ScorePanelList.HandleInput = false;
 
                 // Dim background.
-                ApplyToBackground(b => b.FadeTo(0.1f, 150));
+                ApplyToBackground(b => b.FadeColour(OsuColour.Gray(0.1f), 150));
 
                 detachedPanel = expandedPanel;
             }
@@ -342,7 +341,7 @@ namespace osu.Game.Screens.Ranking
                 ScorePanelList.HandleInput = true;
 
                 // Un-dim background.
-                ApplyToBackground(b => b.FadeTo(0.5f, 150));
+                ApplyToBackground(b => b.FadeColour(OsuColour.Gray(0.5f), 150));
 
                 detachedPanel = null;
             }

osu.Game/Screens/Ranking/ScorePanelList.cs

@@ -8,9 +8,11 @@ using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics.Containers;
 using osu.Game.Scoring;
 using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Screens.Ranking
 {
@@ -263,6 +265,26 @@ namespace osu.Game.Screens.Ranking
             container.Attach();
         }
 
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            var expandedPanelIndex = flow.GetPanelIndex(expandedPanel.Score);
+
+            switch (e.Key)
+            {
+                case Key.Left:
+                    if (expandedPanelIndex > 0)
+                        SelectedScore.Value = flow.Children[expandedPanelIndex - 1].Panel.Score;
+                    return true;
+
+                case Key.Right:
+                    if (expandedPanelIndex < flow.Count - 1)
+                        SelectedScore.Value = flow.Children[expandedPanelIndex + 1].Panel.Score;
+                    return true;
+            }
+
+            return base.OnKeyDown(e);
+        }
+
         private class Flow : FillFlowContainer<ScorePanelTrackingContainer>
         {
             public override IEnumerable<Drawable> FlowingChildren => applySorting(AliveInternalChildren);

osu.Game/Screens/Select/FooterButtonMods.cs

@@ -37,7 +37,6 @@ namespace osu.Game.Screens.Select
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
-                DisplayUnrankedText = false,
                 Scale = new Vector2(0.8f),
                 ExpansionMode = ExpansionMode.AlwaysContracted,
             });

osu.Game/Skinning/SkinManager.cs

@@ -50,6 +50,8 @@ namespace osu.Game.Skinning
 
         private readonly Skin defaultLegacySkin;
 
+        private readonly Skin defaultSkin;
+
         public SkinManager(Storage storage, DatabaseContextFactory contextFactory, GameHost host, IResourceStore<byte[]> resources, AudioManager audio)
             : base(storage, contextFactory, new SkinStore(contextFactory, storage), host)
         {
@@ -58,10 +60,11 @@ namespace osu.Game.Skinning
             this.resources = resources;
 
             defaultLegacySkin = new DefaultLegacySkin(this);
+            defaultSkin = new DefaultSkin(this);
 
             CurrentSkinInfo.ValueChanged += skin => CurrentSkin.Value = GetSkin(skin.NewValue);
 
-            CurrentSkin.Value = new DefaultSkin(this);
+            CurrentSkin.Value = defaultSkin;
             CurrentSkin.ValueChanged += skin =>
             {
                 if (skin.NewValue.SkinInfo != CurrentSkinInfo.Value)
@@ -226,24 +229,26 @@ namespace osu.Game.Skinning
             if (CurrentSkin.Value is LegacySkin && lookupFunction(defaultLegacySkin))
                 return defaultLegacySkin;
 
+            if (lookupFunction(defaultSkin))
+                return defaultSkin;
+
             return null;
         }
 
-        private T lookupWithFallback<T>(Func<ISkin, T> func)
+        private T lookupWithFallback<T>(Func<ISkin, T> lookupFunction)
             where T : class
         {
-            var selectedSkin = func(CurrentSkin.Value);
+            if (lookupFunction(CurrentSkin.Value) is T skinSourced)
-
+                return skinSourced;
-            if (selectedSkin != null)
-                return selectedSkin;
 
             // TODO: we also want to return a DefaultLegacySkin here if the current *beatmap* is providing any skinned elements.
             // When attempting to address this, we may want to move the full DefaultLegacySkin fallback logic to within Player itself (to better allow
             // for beatmap skin visibility).
-            if (CurrentSkin.Value is LegacySkin)
+            if (CurrentSkin.Value is LegacySkin && lookupFunction(defaultLegacySkin) is T legacySourced)
-                return func(defaultLegacySkin);
+                return legacySourced;
 
-            return null;
+            // Finally fall back to the (non-legacy) default.
+            return lookupFunction(defaultSkin);
         }
 
         #region IResourceStorageProvider

osu.Game/Skinning/SkinProvidingContainer.cs

@@ -30,6 +30,8 @@ namespace osu.Game.Skinning
         [CanBeNull]
         private ISkinSource fallbackSource;
 
+        private readonly NoFallbackProxy noFallbackLookupProxy;
+
         protected virtual bool AllowDrawableLookup(ISkinComponent component) => true;
 
         protected virtual bool AllowTextureLookup(string componentName) => true;
@@ -56,28 +58,29 @@ namespace osu.Game.Skinning
         protected SkinProvidingContainer()
         {
             RelativeSizeAxes = Axes.Both;
+
+            noFallbackLookupProxy = new NoFallbackProxy(this);
+
+            if (skin is ISkinSource source)
+                source.SourceChanged += TriggerSourceChanged;
         }
 
         public ISkin FindProvider(Func<ISkin, bool> lookupFunction)
         {
             foreach (var skin in SkinSources)
             {
-                if (skin is ISkinSource source)
+                // a proxy must be used here to correctly pass through the "Allow" checks without implicitly falling back to the fallbackSource.
-                {
+                if (lookupFunction(noFallbackLookupProxy))
-                    if (source.FindProvider(lookupFunction) is ISkin found)
+                    return skin;
-                        return found;
-                }
-                else if (skin != null)
-                {
-                    if (lookupFunction(skin))
-                        return skin;
-                }
             }
 
             return fallbackSource?.FindProvider(lookupFunction);
         }
 
         public Drawable GetDrawableComponent(ISkinComponent component)
+            => GetDrawableComponent(component, true);
+
+        public Drawable GetDrawableComponent(ISkinComponent component, bool fallback)
         {
             if (AllowDrawableLookup(component))
             {
@@ -89,10 +92,16 @@ namespace osu.Game.Skinning
                 }
             }
 
+            if (!fallback)
+                return null;
+
             return fallbackSource?.GetDrawableComponent(component);
         }
 
         public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT)
+            => GetTexture(componentName, wrapModeS, wrapModeT, true);
+
+        public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT, bool fallback)
         {
             if (AllowTextureLookup(componentName))
             {
@@ -104,10 +113,16 @@ namespace osu.Game.Skinning
                 }
             }
 
+            if (!fallback)
+                return null;
+
             return fallbackSource?.GetTexture(componentName, wrapModeS, wrapModeT);
         }
 
         public ISample GetSample(ISampleInfo sampleInfo)
+            => GetSample(sampleInfo, true);
+
+        public ISample GetSample(ISampleInfo sampleInfo, bool fallback)
         {
             if (AllowSampleLookup(sampleInfo))
             {
@@ -119,18 +134,36 @@ namespace osu.Game.Skinning
                 }
             }
 
+            if (!fallback)
+                return null;
+
             return fallbackSource?.GetSample(sampleInfo);
         }
 
         public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup)
+            => GetConfig<TLookup, TValue>(lookup, true);
+
+        public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup, bool fallback)
         {
             if (lookup is GlobalSkinColours || lookup is SkinCustomColourLookup)
                 return lookupWithFallback<TLookup, TValue>(lookup, AllowColourLookup);
 
             return lookupWithFallback<TLookup, TValue>(lookup, AllowConfigurationLookup);
+            if (skin != null)
+            {
+                if (lookup is GlobalSkinColours || lookup is SkinCustomColourLookup)
+                    return lookupWithFallback<TLookup, TValue>(lookup, AllowColourLookup, fallback);
+
+                return lookupWithFallback<TLookup, TValue>(lookup, AllowConfigurationLookup, fallback);
+            }
+
+            if (!fallback)
+                return null;
+
+            return fallbackSource?.GetConfig<TLookup, TValue>(lookup);
         }
 
-        private IBindable<TValue> lookupWithFallback<TLookup, TValue>(TLookup lookup, bool canUseSkinLookup)
+        private IBindable<TValue> lookupWithFallback<TLookup, TValue>(TLookup lookup, bool canUseSkinLookup, bool canUseFallback)
         {
             if (canUseSkinLookup)
             {
@@ -142,6 +175,9 @@ namespace osu.Game.Skinning
                 }
             }
 
+            if (!canUseFallback)
+                return null;
+
             return fallbackSource?.GetConfig<TLookup, TValue>(lookup);
         }
 
@@ -169,6 +205,41 @@ namespace osu.Game.Skinning
 
             if (fallbackSource != null)
                 fallbackSource.SourceChanged -= OnSourceChanged;
+                fallbackSource.SourceChanged -= TriggerSourceChanged;
+
+            if (skin is ISkinSource source)
+                source.SourceChanged -= TriggerSourceChanged;
+        }
+
+        private class NoFallbackProxy : ISkinSource
+        {
+            private readonly SkinProvidingContainer provider;
+
+            public NoFallbackProxy(SkinProvidingContainer provider)
+            {
+                this.provider = provider;
+            }
+
+            public Drawable GetDrawableComponent(ISkinComponent component)
+                => provider.GetDrawableComponent(component, false);
+
+            public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT)
+                => provider.GetTexture(componentName, wrapModeS, wrapModeT, false);
+
+            public ISample GetSample(ISampleInfo sampleInfo)
+                => provider.GetSample(sampleInfo, false);
+
+            public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup)
+                => provider.GetConfig<TLookup, TValue>(lookup, false);
+
+            public event Action SourceChanged
+            {
+                add => provider.SourceChanged += value;
+                remove => provider.SourceChanged -= value;
+            }
+
+            public ISkin FindProvider(Func<ISkin, bool> lookupFunction) =>
+                provider.FindProvider(lookupFunction);
         }
     }
 }