Merge branch 'master' into arrow-easing

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

@@ -0,0 +1,21 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Game.Rulesets.Catch.Skinning;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    public abstract class CatchSkinnableTestScene : SkinnableTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(CatchRuleset),
+            typeof(CatchLegacySkinTransformer),
+        };
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new CatchRuleset();
+    }
+}

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

@@ -4,21 +4,21 @@
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Game.Rulesets.Catch.UI;
-using osu.Game.Tests.Visual;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
-    public class TestSceneCatcher : SkinnableTestScene
+    public class TestSceneCatcher : CatchSkinnableTestScene
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[]
+        public override IReadOnlyList<Type> RequiredTypes => base.RequiredTypes.Concat(new[]
         {
             typeof(CatcherArea),
             typeof(CatcherSprite)
-        };
+        }).ToList();
 
         [BackgroundDependencyLoader]
         private void load()

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

@@ -17,12 +17,11 @@ using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
-using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
-    public class TestSceneCatcherArea : SkinnableTestScene
+    public class TestSceneCatcherArea : CatchSkinnableTestScene
     {
         private RulesetInfo catchRuleset;
 

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

@@ -3,20 +3,20 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
-using osu.Game.Tests.Visual;
 using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
-    public class TestSceneFruitObjects : SkinnableTestScene
+    public class TestSceneFruitObjects : CatchSkinnableTestScene
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[]
+        public override IReadOnlyList<Type> RequiredTypes => base.RequiredTypes.Concat(new[]
         {
             typeof(CatchHitObject),
             typeof(Fruit),
@@ -30,7 +30,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             typeof(DrawableBanana),
             typeof(DrawableBananaShower),
             typeof(Pulp),
-        };
+        }).ToList();
 
         protected override void LoadComplete()
         {

osu.Game.Rulesets.Mania.Tests/Skinning/ManiaSkinnableTestScene.cs

@@ -1,12 +1,15 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
+using osu.Game.Rulesets.Mania.Skinning;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Rulesets.UI.Scrolling.Algorithms;
 using osu.Game.Tests.Visual;
@@ -24,6 +27,14 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
         [Cached(Type = typeof(IScrollingInfo))]
         private readonly TestScrollingInfo scrollingInfo = new TestScrollingInfo();
 
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(ManiaRuleset),
+            typeof(ManiaLegacySkinTransformer),
+        };
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new ManiaRuleset();
+
         protected ManiaSkinnableTestScene()
         {
             scrollingInfo.Direction.Value = ScrollingDirection.Down;

osu.Game.Rulesets.Mania.Tests/Skinning/TestSceneDrawableJudgement.cs

@@ -10,11 +10,10 @@ using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Mania.Tests.Skinning
 {
-    public class TestSceneDrawableJudgement : SkinnableTestScene
+    public class TestSceneDrawableJudgement : ManiaSkinnableTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {

osu.Game.Rulesets.Mania.Tests/Skinning/TestSceneStage.cs

@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
 
                 return new ManiaInputManager(new ManiaRuleset().RulesetInfo, 4)
                 {
-                    Child = new ManiaStage(0, new StageDefinition { Columns = 4 }, ref normalAction, ref specialAction)
+                    Child = new Stage(0, new StageDefinition { Columns = 4 }, ref normalAction, ref specialAction)
                 };
             });
         }

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

@@ -28,7 +28,9 @@ namespace osu.Game.Rulesets.Mania.Tests
         {
             typeof(Column),
             typeof(ColumnBackground),
-            typeof(ColumnHitObjectArea)
+            typeof(ColumnHitObjectArea),
+            typeof(DefaultKeyArea),
+            typeof(DefaultHitTarget)
         };
 
         [Cached(typeof(IReadOnlyList<Mod>))]

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

@@ -29,7 +29,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         [Cached(typeof(IReadOnlyList<Mod>))]
         private IReadOnlyList<Mod> mods { get; set; } = Array.Empty<Mod>();
 
-        private readonly List<ManiaStage> stages = new List<ManiaStage>();
+        private readonly List<Stage> stages = new List<Stage>();
 
         private FillFlowContainer<ScrollingTestContainer> fill;
 
@@ -81,9 +81,9 @@ namespace osu.Game.Rulesets.Mania.Tests
             AddAssert("check bar anchors", () => barsInStageAreAnchored(stages[1], Anchor.TopCentre));
         }
 
-        private bool notesInStageAreAnchored(ManiaStage stage, Anchor anchor) => stage.Columns.SelectMany(c => c.AllHitObjects).All(o => o.Anchor == anchor);
+        private bool notesInStageAreAnchored(Stage stage, Anchor anchor) => stage.Columns.SelectMany(c => c.AllHitObjects).All(o => o.Anchor == anchor);
 
-        private bool barsInStageAreAnchored(ManiaStage stage, Anchor anchor) => stage.AllHitObjects.Where(obj => obj is DrawableBarLine).All(o => o.Anchor == anchor);
+        private bool barsInStageAreAnchored(Stage stage, Anchor anchor) => stage.AllHitObjects.Where(obj => obj is DrawableBarLine).All(o => o.Anchor == anchor);
 
         private void createNote()
         {
@@ -133,7 +133,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         {
             var specialAction = ManiaAction.Special1;
 
-            var stage = new ManiaStage(0, new StageDefinition { Columns = 2 }, ref action, ref specialAction);
+            var stage = new Stage(0, new StageDefinition { Columns = 2 }, ref action, ref specialAction);
             stages.Add(stage);
 
             return new ScrollingTestContainer(direction)

osu.Game.Rulesets.Mania/Skinning/LegacyColumnBackground.cs

@@ -50,12 +50,18 @@ namespace osu.Game.Rulesets.Mania.Skinning
             Color4 lineColour = GetManiaSkinConfig<Color4>(skin, LegacyManiaSkinConfigurationLookups.ColumnLineColour)?.Value
                                 ?? Color4.White;
 
+            Color4 backgroundColour = GetManiaSkinConfig<Color4>(skin, LegacyManiaSkinConfigurationLookups.ColumnBackgroundColour)?.Value
+                                      ?? Color4.Black;
+
+            Color4 lightColour = GetManiaSkinConfig<Color4>(skin, LegacyManiaSkinConfigurationLookups.ColumnLightColour)?.Value
+                                 ?? Color4.White;
+
             InternalChildren = new Drawable[]
             {
                 new Box
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Colour = Color4.Black
+                    Colour = backgroundColour
                 },
                 new Box
                 {
@@ -82,6 +88,7 @@ namespace osu.Game.Rulesets.Mania.Skinning
                     {
                         Anchor = Anchor.BottomCentre,
                         Origin = Anchor.BottomCentre,
+                        Colour = lightColour,
                         Texture = skin.GetTexture(lightImage),
                         RelativeSizeAxes = Axes.X,
                         Width = 1,

osu.Game.Rulesets.Mania/Skinning/LegacyHitTarget.cs

@@ -10,6 +10,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
 using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Skinning
 {
@@ -33,6 +34,9 @@ namespace osu.Game.Rulesets.Mania.Skinning
             bool showJudgementLine = GetManiaSkinConfig<bool>(skin, LegacyManiaSkinConfigurationLookups.ShowJudgementLine)?.Value
                                      ?? true;
 
+            Color4 lineColour = GetManiaSkinConfig<Color4>(skin, LegacyManiaSkinConfigurationLookups.JudgementLineColour)?.Value
+                                ?? Color4.White;
+
             InternalChild = directionContainer = new Container
             {
                 Origin = Anchor.CentreLeft,
@@ -52,6 +56,7 @@ namespace osu.Game.Rulesets.Mania.Skinning
                         Anchor = Anchor.CentreLeft,
                         RelativeSizeAxes = Axes.X,
                         Height = 1,
+                        Colour = lineColour,
                         Alpha = showJudgementLine ? 0.9f : 0
                     }
                 }

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

@@ -40,7 +40,7 @@ namespace osu.Game.Rulesets.Mania.Skinning
         {
             isLegacySkin = new Lazy<bool>(() => source.GetConfig<LegacySkinConfiguration.LegacySetting, decimal>(LegacySkinConfiguration.LegacySetting.Version) != null);
             hasKeyTexture = new Lazy<bool>(() => source.GetAnimation(
-                source.GetConfig<ManiaSkinConfigurationLookup, string>(
+                GetConfig<ManiaSkinConfigurationLookup, string>(
                     new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.KeyImage, 0))?.Value
                 ?? "mania-key1", true, true) != null);
         }

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

@@ -42,6 +42,7 @@ namespace osu.Game.Rulesets.Mania.UI
             Index = index;
 
             RelativeSizeAxes = Axes.Y;
+            Width = COLUMN_WIDTH;
 
             Drawable background = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.ColumnBackground, Index), _ => new DefaultColumnBackground())
             {
@@ -138,6 +139,6 @@ namespace osu.Game.Rulesets.Mania.UI
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos)
             // This probably shouldn't exist as is, but the columns in the stage are separated by a 1px border
-            => DrawRectangle.Inflate(new Vector2(ManiaStage.COLUMN_SPACING / 2, 0)).Contains(ToLocalSpace(screenSpacePos));
+            => DrawRectangle.Inflate(new Vector2(Stage.COLUMN_SPACING / 2, 0)).Contains(ToLocalSpace(screenSpacePos));
     }
 }

osu.Game.Rulesets.Mania/UI/Components/DefaultKeyArea.cs

@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Mania.UI.Components
             InternalChild = directionContainer = new Container
             {
                 RelativeSizeAxes = Axes.X,
-                Height = ManiaStage.HIT_TARGET_POSITION,
+                Height = Stage.HIT_TARGET_POSITION,
                 Children = new[]
                 {
                     gradient = new Box
@@ -53,9 +53,8 @@ namespace osu.Game.Rulesets.Mania.UI.Components
                     keyIcon = new Container
                     {
                         Name = "Key icon",
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
                         Size = new Vector2(key_icon_size),
+                        Origin = Anchor.Centre,
                         Masking = true,
                         CornerRadius = key_icon_corner_radius,
                         BorderThickness = 2,
@@ -88,11 +87,15 @@ namespace osu.Game.Rulesets.Mania.UI.Components
         {
             if (direction.NewValue == ScrollingDirection.Up)
             {
+                keyIcon.Anchor = Anchor.BottomCentre;
+                keyIcon.Y = -20;
                 directionContainer.Anchor = directionContainer.Origin = Anchor.TopLeft;
                 gradient.Colour = ColourInfo.GradientVertical(Color4.Black, Color4.Black.Opacity(0));
             }
             else
             {
+                keyIcon.Anchor = Anchor.TopCentre;
+                keyIcon.Y = 20;
                 directionContainer.Anchor = directionContainer.Origin = Anchor.BottomLeft;
                 gradient.Colour = ColourInfo.GradientVertical(Color4.Black.Opacity(0), Color4.Black);
             }

osu.Game.Rulesets.Mania/UI/Components/HitObjectArea.cs

@@ -45,7 +45,7 @@ namespace osu.Game.Rulesets.Mania.UI.Components
         {
             float hitPosition = CurrentSkin.GetConfig<ManiaSkinConfigurationLookup, float>(
                                     new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.HitPosition))?.Value
-                                ?? ManiaStage.HIT_TARGET_POSITION;
+                                ?? Stage.HIT_TARGET_POSITION;
 
             Padding = Direction.Value == ScrollingDirection.Up
                 ? new MarginPadding { Top = hitPosition }

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

@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Mania.UI
 {
     public class ManiaPlayfield : ScrollingPlayfield
     {
-        private readonly List<ManiaStage> stages = new List<ManiaStage>();
+        private readonly List<Stage> stages = new List<Stage>();
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => stages.Any(s => s.ReceivePositionalInputAt(screenSpacePos));
 
@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Mania.UI
 
             for (int i = 0; i < stageDefinitions.Count; i++)
             {
-                var newStage = new ManiaStage(firstColumnIndex, stageDefinitions[i], ref normalColumnAction, ref specialColumnAction);
+                var newStage = new Stage(firstColumnIndex, stageDefinitions[i], ref normalColumnAction, ref specialColumnAction);
 
                 playfieldGrid.Content[0][i] = newStage;
 
@@ -90,7 +90,7 @@ namespace osu.Game.Rulesets.Mania.UI
         /// </summary>
         public int TotalColumns => stages.Sum(s => s.Columns.Count);
 
-        private ManiaStage getStageByColumn(int column)
+        private Stage getStageByColumn(int column)
         {
             int sum = 0;
 

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

@@ -25,11 +25,11 @@ namespace osu.Game.Rulesets.Mania.UI
     /// <summary>
     /// A collection of <see cref="Column"/>s.
     /// </summary>
-    public class ManiaStage : ScrollingPlayfield
+    public class Stage : ScrollingPlayfield
     {
         public const float COLUMN_SPACING = 1;
 
-        public const float HIT_TARGET_POSITION = 50;
+        public const float HIT_TARGET_POSITION = 110;
 
         public IReadOnlyList<Column> Columns => columnFlow.Children;
         private readonly FillFlowContainer<Column> columnFlow;
@@ -51,7 +51,7 @@ namespace osu.Game.Rulesets.Mania.UI
 
         private readonly int firstColumnIndex;
 
-        public ManiaStage(int firstColumnIndex, StageDefinition definition, ref ManiaAction normalColumnStartAction, ref ManiaAction specialColumnStartAction)
+        public Stage(int firstColumnIndex, StageDefinition definition, ref ManiaAction normalColumnStartAction, ref ManiaAction specialColumnStartAction)
         {
             this.firstColumnIndex = firstColumnIndex;
 

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

@@ -0,0 +1,21 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Game.Rulesets.Osu.Skinning;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public abstract class OsuSkinnableTestScene : SkinnableTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(OsuRuleset),
+            typeof(OsuLegacySkinTransformer),
+        };
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
+    }
+}

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

@@ -10,17 +10,16 @@ using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
-    public class TestSceneDrawableJudgement : SkinnableTestScene
+    public class TestSceneDrawableJudgement : OsuSkinnableTestScene
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[]
+        public override IReadOnlyList<Type> RequiredTypes => base.RequiredTypes.Concat(new[]
         {
             typeof(DrawableJudgement),
             typeof(DrawableOsuJudgement)
-        };
+        }).ToList();
 
         public TestSceneDrawableJudgement()
         {

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

@@ -3,26 +3,32 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Testing.Input;
 using osu.Game.Configuration;
+using osu.Game.Rulesets.Osu.Skinning;
 using osu.Game.Rulesets.Osu.UI.Cursor;
+using osu.Game.Rulesets.UI;
 using osu.Game.Screens.Play;
-using osu.Game.Tests.Visual;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
     [TestFixture]
-    public class TestSceneGameplayCursor : SkinnableTestScene
+    public class TestSceneGameplayCursor : OsuSkinnableTestScene
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[]
+        public override IReadOnlyList<Type> RequiredTypes => base.RequiredTypes.Concat(new[]
         {
+            typeof(GameplayCursorContainer),
             typeof(OsuCursorContainer),
+            typeof(OsuCursor),
+            typeof(LegacyCursor),
+            typeof(LegacyCursorTrail),
             typeof(CursorTrail)
-        };
+        }).ToList();
 
         [Cached]
         private GameplayBeatmap gameplayBeatmap;

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

@@ -14,12 +14,11 @@ using osu.Game.Rulesets.Mods;
 using System.Linq;
 using NUnit.Framework;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
     [TestFixture]
-    public class TestSceneHitCircle : SkinnableTestScene
+    public class TestSceneHitCircle : OsuSkinnableTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {

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

@@ -22,12 +22,11 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
-using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
     [TestFixture]
-    public class TestSceneSlider : SkinnableTestScene
+    public class TestSceneSlider : OsuSkinnableTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {

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

@@ -0,0 +1,21 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Game.Rulesets.Taiko.Skinning;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Taiko.Tests
+{
+    public abstract class TaikoSkinnableTestScene : SkinnableTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(TaikoRuleset),
+            typeof(TaikoLegacySkinTransformer),
+        };
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new TaikoRuleset();
+    }
+}

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

@@ -3,24 +3,26 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osuTK;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Taiko.Skinning;
 using osu.Game.Rulesets.Taiko.UI;
-using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Taiko.Tests
 {
     [TestFixture]
-    public class TestSceneInputDrum : SkinnableTestScene
+    public class TestSceneInputDrum : TaikoSkinnableTestScene
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[]
+        public override IReadOnlyList<Type> RequiredTypes => base.RequiredTypes.Concat(new[]
         {
             typeof(InputDrum),
-        };
+            typeof(LegacyInputDrum),
+        }).ToList();
 
         [BackgroundDependencyLoader]
         private void load()

osu.Game.Tests/NonVisual/Skinning/LegacySkinTextureFallbackTest.cs

@@ -0,0 +1,109 @@
+// 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.Graphics.Textures;
+using osu.Game.Skinning;
+
+namespace osu.Game.Tests.NonVisual.Skinning
+{
+    [TestFixture]
+    public sealed class LegacySkinTextureFallbackTest
+    {
+        private static object[][] fallbackTestCases =
+        {
+            new object[]
+            {
+                // textures in store
+                new[] { "Gameplay/osu/followpoint@2x", "Gameplay/osu/followpoint" },
+                // requested component
+                "Gameplay/osu/followpoint",
+                // returned texture name & scale
+                "Gameplay/osu/followpoint@2x", 2
+            },
+            new object[]
+            {
+                new[] { "Gameplay/osu/followpoint@2x" },
+                "Gameplay/osu/followpoint",
+                "Gameplay/osu/followpoint@2x", 2
+            },
+            new object[]
+            {
+                new[] { "Gameplay/osu/followpoint" },
+                "Gameplay/osu/followpoint",
+                "Gameplay/osu/followpoint", 1
+            },
+            new object[]
+            {
+                new[] { "Gameplay/osu/followpoint", "followpoint@2x" },
+                "Gameplay/osu/followpoint",
+                "Gameplay/osu/followpoint", 1
+            },
+            new object[]
+            {
+                new[] { "followpoint@2x", "followpoint" },
+                "Gameplay/osu/followpoint",
+                "followpoint@2x", 2
+            },
+            new object[]
+            {
+                new[] { "followpoint@2x" },
+                "Gameplay/osu/followpoint",
+                "followpoint@2x", 2
+            },
+            new object[]
+            {
+                new[] { "followpoint" },
+                "Gameplay/osu/followpoint",
+                "followpoint", 1
+            },
+        };
+
+        [TestCaseSource(nameof(fallbackTestCases))]
+        public void TestFallbackOrder(string[] filesInStore, string requestedComponent, string expectedTexture, float expectedScale)
+        {
+            var textureStore = new TestTextureStore(filesInStore);
+            var legacySkin = new TestLegacySkin(textureStore);
+
+            var texture = legacySkin.GetTexture(requestedComponent);
+
+            Assert.IsNotNull(texture);
+            Assert.AreEqual(textureStore.Textures[expectedTexture], texture);
+            Assert.AreEqual(expectedScale, texture.ScaleAdjust);
+        }
+
+        [Test]
+        public void TestReturnNullOnFallbackFailure()
+        {
+            var textureStore = new TestTextureStore("sliderb", "hit100");
+            var legacySkin = new TestLegacySkin(textureStore);
+
+            var texture = legacySkin.GetTexture("Gameplay/osu/followpoint");
+
+            Assert.IsNull(texture);
+        }
+
+        private class TestLegacySkin : LegacySkin
+        {
+            public TestLegacySkin(TextureStore textureStore)
+                : base(new SkinInfo(), null, null, string.Empty)
+            {
+                Textures = textureStore;
+            }
+        }
+
+        private class TestTextureStore : TextureStore
+        {
+            public readonly Dictionary<string, Texture> Textures;
+
+            public TestTextureStore(params string[] fileNames)
+            {
+                Textures = fileNames.ToDictionary(fileName => fileName, fileName => new Texture(1, 1));
+            }
+
+            public override Texture Get(string name) => Textures.GetValueOrDefault(name);
+        }
+    }
+}

osu.Game.Tournament/Screens/Ladder/LadderDragContainer.cs

@@ -22,6 +22,8 @@ namespace osu.Game.Tournament.Screens.Ladder
 
         protected override bool ComputeIsMaskedAway(RectangleF maskingBounds) => false;
 
+        public override bool UpdateSubTreeMasking(Drawable source, RectangleF maskingBounds) => false;
+
         protected override void OnDrag(DragEvent e)
         {
             this.MoveTo(target += e.Delta, 1000, Easing.OutQuint);

osu.Game/Screens/Menu/MainMenu.cs

@@ -294,7 +294,7 @@ namespace osu.Game.Screens.Menu
                 {
                     new PopupDialogOkButton
                     {
-                        Text = @"Good bye",
+                        Text = @"Goodbye",
                         Action = confirm
                     },
                     new PopupDialogCancelButton

osu.Game/Skinning/LegacyManiaSkinConfiguration.cs

@@ -25,6 +25,8 @@ namespace osu.Game.Skinning
 
         public Dictionary<string, Color4> CustomColours { get; set; } = new Dictionary<string, Color4>();
 
+        public Dictionary<string, string> ImageLookups = new Dictionary<string, string>();
+
         public readonly float[] ColumnLineWidth;
         public readonly float[] ColumnSpacing;
         public readonly float[] ColumnWidth;

osu.Game/Skinning/LegacyManiaSkinConfigurationLookup.cs

@@ -37,6 +37,9 @@ namespace osu.Game.Skinning
         ExplosionImage,
         ExplosionScale,
         ColumnLineColour,
+        JudgementLineColour,
+        ColumnBackgroundColour,
+        ColumnLightColour,
         MinimumColumnWidth
     }
 }

osu.Game/Skinning/LegacyManiaSkinDecoder.cs

@@ -71,12 +71,6 @@ namespace osu.Game.Skinning
             {
                 var pair = SplitKeyVal(line);
 
-                if (pair.Key.StartsWith("Colour"))
-                {
-                    HandleColours(currentConfig, line);
-                    continue;
-                }
-
                 switch (pair.Key)
                 {
                     case "ColumnLineWidth":
@@ -110,6 +104,18 @@ namespace osu.Game.Skinning
                     case "WidthForNoteHeightScale":
                         currentConfig.MinimumColumnWidth = float.Parse(pair.Value, CultureInfo.InvariantCulture) * LegacyManiaSkinConfiguration.POSITION_SCALE_FACTOR;
                         break;
+
+                    case string _ when pair.Key.StartsWith("Colour"):
+                        HandleColours(currentConfig, line);
+                        break;
+
+                    case string _ when pair.Key.StartsWith("NoteImage"):
+                        currentConfig.ImageLookups[pair.Key] = pair.Value;
+                        break;
+
+                    case string _ when pair.Key.StartsWith("KeyImage"):
+                        currentConfig.ImageLookups[pair.Key] = pair.Value;
+                        break;
                 }
             }
 

osu.Game/Skinning/LegacySkin.cs

@@ -88,7 +88,8 @@ namespace osu.Game.Skinning
 
             // todo: this shouldn't really be duplicated here (from ManiaLegacySkinTransformer). we need to come up with a better solution.
             hasKeyTexture = new Lazy<bool>(() => this.GetAnimation(
-                lookupForMania<string>(new LegacyManiaSkinConfigurationLookup(4, LegacyManiaSkinConfigurationLookups.KeyImage, 0))?.Value ?? "mania-key1", true, true) != null);
+                lookupForMania<string>(new LegacyManiaSkinConfigurationLookup(4, LegacyManiaSkinConfigurationLookups.KeyImage, 0))?.Value ?? "mania-key1", true,
+                true) != null);
         }
 
         protected override void Dispose(bool isDisposing)
@@ -205,8 +206,43 @@ namespace osu.Game.Skinning
                 case LegacyManiaSkinConfigurationLookups.ColumnLineColour:
                     return SkinUtils.As<TValue>(getCustomColour(existing, "ColourColumnLine"));
 
+                case LegacyManiaSkinConfigurationLookups.JudgementLineColour:
+                    return SkinUtils.As<TValue>(getCustomColour(existing, "ColourJudgementLine"));
+
+                case LegacyManiaSkinConfigurationLookups.ColumnBackgroundColour:
+                    Debug.Assert(maniaLookup.TargetColumn != null);
+                    return SkinUtils.As<TValue>(getCustomColour(existing, $"Colour{maniaLookup.TargetColumn + 1}"));
+
+                case LegacyManiaSkinConfigurationLookups.ColumnLightColour:
+                    Debug.Assert(maniaLookup.TargetColumn != null);
+                    return SkinUtils.As<TValue>(getCustomColour(existing, $"ColourLight{maniaLookup.TargetColumn + 1}"));
+
                 case LegacyManiaSkinConfigurationLookups.MinimumColumnWidth:
                     return SkinUtils.As<TValue>(new Bindable<float>(existing.MinimumColumnWidth));
+
+                case LegacyManiaSkinConfigurationLookups.NoteImage:
+                    Debug.Assert(maniaLookup.TargetColumn != null);
+                    return SkinUtils.As<TValue>(getManiaImage(existing, $"NoteImage{maniaLookup.TargetColumn}"));
+
+                case LegacyManiaSkinConfigurationLookups.HoldNoteHeadImage:
+                    Debug.Assert(maniaLookup.TargetColumn != null);
+                    return SkinUtils.As<TValue>(getManiaImage(existing, $"NoteImage{maniaLookup.TargetColumn}H"));
+
+                case LegacyManiaSkinConfigurationLookups.HoldNoteTailImage:
+                    Debug.Assert(maniaLookup.TargetColumn != null);
+                    return SkinUtils.As<TValue>(getManiaImage(existing, $"NoteImage{maniaLookup.TargetColumn}T"));
+
+                case LegacyManiaSkinConfigurationLookups.HoldNoteBodyImage:
+                    Debug.Assert(maniaLookup.TargetColumn != null);
+                    return SkinUtils.As<TValue>(getManiaImage(existing, $"NoteImage{maniaLookup.TargetColumn}L"));
+
+                case LegacyManiaSkinConfigurationLookups.KeyImage:
+                    Debug.Assert(maniaLookup.TargetColumn != null);
+                    return SkinUtils.As<TValue>(getManiaImage(existing, $"KeyImage{maniaLookup.TargetColumn}"));
+
+                case LegacyManiaSkinConfigurationLookups.KeyImageDown:
+                    Debug.Assert(maniaLookup.TargetColumn != null);
+                    return SkinUtils.As<TValue>(getManiaImage(existing, $"KeyImage{maniaLookup.TargetColumn}D"));
             }
 
             return null;
@@ -215,6 +251,9 @@ namespace osu.Game.Skinning
         private IBindable<Color4> getCustomColour(IHasCustomColours source, string lookup)
             => source.CustomColours.TryGetValue(lookup, out var col) ? new Bindable<Color4>(col) : null;
 
+        private IBindable<string> getManiaImage(LegacyManiaSkinConfiguration source, string lookup)
+            => source.ImageLookups.TryGetValue(lookup, out var image) ? new Bindable<string>(image) : null;
+
         public override Drawable GetDrawableComponent(ISkinComponent component)
         {
             switch (component)
@@ -243,21 +282,25 @@ namespace osu.Game.Skinning
 
         public override Texture GetTexture(string componentName)
         {
-            componentName = getFallbackName(componentName);
+            foreach (var name in getFallbackNames(componentName))
-
-            float ratio = 2;
-            var texture = Textures?.Get($"{componentName}@2x");
-
-            if (texture == null)
             {
-                ratio = 1;
+                float ratio = 2;
-                texture = Textures?.Get(componentName);
+                var texture = Textures?.Get($"{name}@2x");
+
+                if (texture == null)
+                {
+                    ratio = 1;
+                    texture = Textures?.Get(name);
+                }
+
+                if (texture == null)
+                    continue;
+
+                texture.ScaleAdjust = ratio;
+                return texture;
             }
 
-            if (texture != null)
+            return null;
-                texture.ScaleAdjust = ratio;
-
-            return texture;
         }
 
         public override SampleChannel GetSample(ISampleInfo sampleInfo)
@@ -277,10 +320,14 @@ namespace osu.Game.Skinning
             return null;
         }
 
-        private string getFallbackName(string componentName)
+        private IEnumerable<string> getFallbackNames(string componentName)
         {
+            // May be something like "Gameplay/osu/approachcircle" from lazer, or "Arrows/note1" from a user skin.
+            yield return componentName;
+
+            // Fall back to using the last piece for components coming from lazer (e.g. "Gameplay/osu/approachcircle" -> "approachcircle").
             string lastPiece = componentName.Split('/').Last();
-            return componentName.StartsWith("Gameplay/taiko/") ? "taiko-" + lastPiece : lastPiece;
+            yield return componentName.StartsWith("Gameplay/taiko/") ? "taiko-" + lastPiece : lastPiece;
         }
     }
 }

osu.Game/Skinning/LegacySkinResourceStore.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Extensions;
 using osu.Framework.IO.Stores;
 using osu.Game.Database;
 
@@ -27,7 +28,7 @@ namespace osu.Game.Skinning
 
             foreach (var filename in base.GetFilenames(name))
             {
-                var path = getPathForFile(filename);
+                var path = getPathForFile(filename.ToStandardisedPath());
                 if (path != null)
                     yield return path;
             }

osu.Game/Tests/Visual/SkinnableTestScene.cs

@@ -13,6 +13,7 @@ using osu.Framework.Graphics.Textures;
 using osu.Framework.IO.Stores;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Rulesets;
 using osu.Game.Skinning;
 using osuTK;
 using osuTK.Graphics;
@@ -31,6 +32,9 @@ namespace osu.Game.Tests.Visual
         {
         }
 
+        // Required to be part of the per-ruleset implementation to construct the newer version of the Ruleset.
+        protected abstract Ruleset CreateRulesetForSkinProvider();
+
         [BackgroundDependencyLoader]
         private void load(AudioManager audio, SkinManager skinManager)
         {
@@ -103,7 +107,7 @@ namespace osu.Game.Tests.Visual
                         {
                             new OutlineBox { Alpha = autoSize ? 1 : 0 },
                             mainProvider.WithChild(
-                                new SkinProvidingContainer(Ruleset.Value.CreateInstance().CreateLegacySkinProvider(mainProvider, beatmap))
+                                new SkinProvidingContainer(CreateRulesetForSkinProvider().CreateLegacySkinProvider(mainProvider, beatmap))
                                 {
                                     Child = created,
                                     RelativeSizeAxes = !autoSize ? Axes.Both : Axes.None,