Merge pull request #8597 from smoogipoo/better-mania-scrollspeed

Implement more familiar scroll speed options in mania

.idea/.idea.osu.Desktop/.idea/projectSettingsUpdater.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="RiderProjectSettingsUpdater">
-    <option name="vcsConfiguration" value="1" />
+    <option name="vcsConfiguration" value="2" />
   </component>
 </project>

osu.Android.props

@@ -51,7 +51,7 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.331.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.401.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.403.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.403.0" />
   </ItemGroup>
 </Project>

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -143,7 +143,7 @@ namespace osu.Game.Rulesets.Catch
 
         public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new CatchDifficultyCalculator(this, beatmap);
 
-        public override ISkin CreateLegacySkinProvider(ISkinSource source) => new CatchLegacySkinTransformer(source);
+        public override ISkin CreateLegacySkinProvider(ISkinSource source, IBeatmap beatmap) => new CatchLegacySkinTransformer(source);
 
         public override PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, ScoreInfo score) => new CatchPerformanceCalculator(this, beatmap, score);
 

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

@@ -384,7 +384,7 @@ namespace osu.Game.Rulesets.Catch.UI
             }
 
             currentCatcher.Show();
-            (currentCatcher.Drawable as IAnimation)?.GotoFrame(0);
+            (currentCatcher.Drawable as IFramedAnimation)?.GotoFrame(0);
         }
 
         private void beginTrail()

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

@@ -4,7 +4,6 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Timing;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 using osuTK.Graphics;
@@ -37,10 +36,13 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
                         Child = new ScrollingHitObjectContainer
                         {
                             RelativeSizeAxes = Axes.Both,
-                            Clock = new FramedClock(new StopwatchClock()),
                         }.With(c =>
                         {
-                            c.Add(CreateHitObject().With(h => h.AccentColour.Value = Color4.Orange));
+                            c.Add(CreateHitObject().With(h =>
+                            {
+                                h.HitObject.StartTime = START_TIME;
+                                h.AccentColour.Value = Color4.Orange;
+                            }));
                         })
                     },
                     new ColumnTestContainer(1, ManiaAction.Key2)
@@ -52,10 +54,13 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
                         Child = new ScrollingHitObjectContainer
                         {
                             RelativeSizeAxes = Axes.Both,
-                            Clock = new FramedClock(new StopwatchClock()),
                         }.With(c =>
                         {
-                            c.Add(CreateHitObject().With(h => h.AccentColour.Value = Color4.Orange));
+                            c.Add(CreateHitObject().With(h =>
+                            {
+                                h.HitObject.StartTime = START_TIME;
+                                h.AccentColour.Value = Color4.Orange;
+                            }));
                         })
                     },
                 }

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

@@ -19,6 +19,8 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
     /// </summary>
     public abstract class ManiaSkinnableTestScene : SkinnableTestScene
     {
+        protected const double START_TIME = 1000000000;
+
         [Cached(Type = typeof(IScrollingInfo))]
         private readonly TestScrollingInfo scrollingInfo = new TestScrollingInfo();
 
@@ -52,7 +54,26 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
 
             IBindable<ScrollingDirection> IScrollingInfo.Direction => Direction;
             IBindable<double> IScrollingInfo.TimeRange { get; } = new Bindable<double>(1000);
-            IScrollAlgorithm IScrollingInfo.Algorithm { get; } = new ConstantScrollAlgorithm();
+            IScrollAlgorithm IScrollingInfo.Algorithm { get; } = new ZeroScrollAlgorithm();
+        }
+
+        private class ZeroScrollAlgorithm : IScrollAlgorithm
+        {
+            public double GetDisplayStartTime(double originTime, float offset, double timeRange, float scrollLength)
+                => double.MinValue;
+
+            public float GetLength(double startTime, double endTime, double timeRange, float scrollLength)
+                => scrollLength;
+
+            public float PositionAt(double time, double currentTime, double timeRange, float scrollLength)
+                => (float)((time - START_TIME) / timeRange) * scrollLength;
+
+            public double TimeAt(float position, double currentTime, double timeRange, float scrollLength)
+                => 0;
+
+            public void Reset()
+            {
+            }
         }
     }
 }

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

@@ -28,7 +28,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
                     {
                         RelativeSizeAxes = Axes.Both,
                         Width = 0.5f,
-                        Child = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.ColumnBackground), _ => new DefaultColumnBackground())
+                        Child = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.ColumnBackground, 0), _ => new DefaultColumnBackground())
                         {
                             RelativeSizeAxes = Axes.Both
                         }
@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
                     {
                         RelativeSizeAxes = Axes.Both,
                         Width = 0.5f,
-                        Child = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.ColumnBackground), _ => new DefaultColumnBackground())
+                        Child = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.ColumnBackground, 0), _ => new DefaultColumnBackground())
                         {
                             RelativeSizeAxes = Axes.Both
                         }

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

@@ -28,7 +28,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
                     {
                         RelativeSizeAxes = Axes.Both,
                         Width = 0.5f,
-                        Child = new ColumnHitObjectArea(new HitObjectContainer())
+                        Child = new ColumnHitObjectArea(0, new HitObjectContainer())
                         {
                             RelativeSizeAxes = Axes.Both
                         }
@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
                     {
                         RelativeSizeAxes = Axes.Both,
                         Width = 0.5f,
-                        Child = new ColumnHitObjectArea(new HitObjectContainer())
+                        Child = new ColumnHitObjectArea(1, new HitObjectContainer())
                         {
                             RelativeSizeAxes = Axes.Both
                         }

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

@@ -3,42 +3,32 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.Mania.UI;
-using osu.Game.Rulesets.UI.Scrolling;
-using osu.Game.Tests.Visual;
+using osu.Game.Skinning;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Skinning
 {
     [TestFixture]
-    public class TestSceneHitExplosion : OsuTestScene
+    public class TestSceneHitExplosion : ManiaSkinnableTestScene
     {
-        private ScrollingTestContainer scrolling;
-
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
             typeof(DrawableNote),
             typeof(DrawableManiaHitObject),
         };
 
-        protected override void LoadComplete()
+        public TestSceneHitExplosion()
         {
-            base.LoadComplete();
-
-            Child = scrolling = new ScrollingTestContainer(ScrollingDirection.Down)
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                RelativePositionAxes = Axes.Y,
-                Y = -0.25f,
-                Size = new Vector2(Column.COLUMN_WIDTH, DefaultNotePiece.NOTE_HEIGHT),
-            };
-
             int runcount = 0;
 
             AddRepeatStep("explode", () =>
@@ -48,15 +38,29 @@ namespace osu.Game.Rulesets.Mania.Tests
                 if (runcount % 15 > 12)
                     return;
 
-                scrolling.AddRange(new Drawable[]
+                CreatedDrawables.OfType<Container>().ForEach(c =>
                 {
-                    new HitExplosion((runcount / 15) % 2 == 0 ? new Color4(94, 0, 57, 255) : new Color4(6, 84, 0, 255), runcount % 6 != 0)
-                    {
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                    }
+                    c.Add(new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.HitExplosion, 0),
+                        _ => new DefaultHitExplosion((runcount / 15) % 2 == 0 ? new Color4(94, 0, 57, 255) : new Color4(6, 84, 0, 255), runcount % 6 != 0)
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                        }));
                 });
             }, 100);
         }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            SetContents(() => new ColumnTestContainer(0, ManiaAction.Key1)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativePositionAxes = Axes.Y,
+                Y = -0.25f,
+                Size = new Vector2(Column.COLUMN_WIDTH, DefaultNotePiece.NOTE_HEIGHT),
+            });
+        }
     }
 }

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

@@ -1,6 +1,9 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Linq;
+using osu.Framework.Bindables;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Mania.Objects;
@@ -10,15 +13,23 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
 {
     public class TestSceneHoldNote : ManiaHitObjectTestScene
     {
+        public TestSceneHoldNote()
+        {
+            AddToggleStep("toggle hitting", v =>
+            {
+                foreach (var holdNote in CreatedDrawables.SelectMany(d => d.ChildrenOfType<DrawableHoldNote>()))
+                {
+                    ((Bindable<bool>)holdNote.IsHitting).Value = v;
+                }
+            });
+        }
+
         protected override DrawableManiaHitObject CreateHitObject()
         {
             var note = new HoldNote { Duration = 1000 };
             note.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
 
-            return new DrawableHoldNote(note)
-            {
-                Height = 200,
-            };
+            return new DrawableHoldNote(note);
         }
     }
 }

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

@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
                     {
                         RelativeSizeAxes = Axes.Both,
                         Width = 0.5f,
-                        Child = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.KeyArea), _ => new DefaultKeyArea())
+                        Child = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.KeyArea, 0), _ => new DefaultKeyArea())
                         {
                             RelativeSizeAxes = Axes.Both
                         },
@@ -46,7 +46,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
                     {
                         RelativeSizeAxes = Axes.Both,
                         Width = 0.5f,
-                        Child = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.KeyArea), _ => new DefaultKeyArea())
+                        Child = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.KeyArea, 1), _ => new DefaultKeyArea())
                         {
                             RelativeSizeAxes = Axes.Both
                         },

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

@@ -0,0 +1,52 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.UI;
+
+namespace osu.Game.Rulesets.Mania.Tests.Skinning
+{
+    public class TestScenePlayfield : ManiaSkinnableTestScene
+    {
+        private List<StageDefinition> stageDefinitions = new List<StageDefinition>();
+
+        [Test]
+        public void TestSingleStage()
+        {
+            AddStep("create stage", () =>
+            {
+                stageDefinitions = new List<StageDefinition>
+                {
+                    new StageDefinition { Columns = 2 }
+                };
+
+                SetContents(() => new ManiaPlayfield(stageDefinitions));
+            });
+        }
+
+        [Test]
+        public void TestDualStages()
+        {
+            AddStep("create stage", () =>
+            {
+                stageDefinitions = new List<StageDefinition>
+                {
+                    new StageDefinition { Columns = 2 },
+                    new StageDefinition { Columns = 2 }
+                };
+
+                SetContents(() => new ManiaPlayfield(stageDefinitions));
+            });
+        }
+
+        protected override IBeatmap CreateBeatmapForSkinProvider()
+        {
+            var maniaBeatmap = (ManiaBeatmap)base.CreateBeatmapForSkinProvider();
+            maniaBeatmap.Stages = stageDefinitions;
+            return maniaBeatmap;
+        }
+    }
+}

osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using osu.Framework.Configuration.Tracking;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Configuration;
@@ -19,13 +20,14 @@ namespace osu.Game.Rulesets.Mania.Configuration
         {
             base.InitialiseDefaults();
 
-            Set(ManiaRulesetSetting.ScrollTime, 1500.0, 50.0, 5000.0, 50.0);
+            Set(ManiaRulesetSetting.ScrollTime, 1500.0, DrawableManiaRuleset.MIN_TIME_RANGE, DrawableManiaRuleset.MAX_TIME_RANGE, 1);
             Set(ManiaRulesetSetting.ScrollDirection, ManiaScrollingDirection.Down);
         }
 
         public override TrackedSettings CreateTrackedSettings() => new TrackedSettings
         {
-            new TrackedSetting<double>(ManiaRulesetSetting.ScrollTime, v => new SettingDescription(v, "Scroll Time", $"{v}ms"))
+            new TrackedSetting<double>(ManiaRulesetSetting.ScrollTime,
+                v => new SettingDescription(v, "Scroll Speed", $"{(int)Math.Round(DrawableManiaRuleset.MAX_TIME_RANGE / v)} ({v}ms)"))
         };
     }
 

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -47,7 +47,7 @@ namespace osu.Game.Rulesets.Mania
 
         public override HitObjectComposer CreateHitObjectComposer() => new ManiaHitObjectComposer(this);
 
-        public override ISkin CreateLegacySkinProvider(ISkinSource source) => new ManiaLegacySkinTransformer(source);
+        public override ISkin CreateLegacySkinProvider(ISkinSource source, IBeatmap beatmap) => new ManiaLegacySkinTransformer(source, beatmap);
 
         public override IEnumerable<Mod> ConvertFromLegacyMods(LegacyMods mods)
         {

osu.Game.Rulesets.Mania/ManiaSkinComponent.cs

@@ -1,15 +1,28 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Mania
 {
     public class ManiaSkinComponent : GameplaySkinComponent<ManiaSkinComponents>
     {
-        public ManiaSkinComponent(ManiaSkinComponents component)
+        /// <summary>
+        /// The intended <see cref="Column"/> index for this component.
+        /// May be null if the component does not exist in a <see cref="Column"/>.
+        /// </summary>
+        public readonly int? TargetColumn;
+
+        /// <summary>
+        /// Creates a new <see cref="ManiaSkinComponent"/>.
+        /// </summary>
+        /// <param name="component">The component.</param>
+        /// <param name="targetColumn">The intended <see cref="Column"/> index for this component. May be null if the component does not exist in a <see cref="Column"/>.</param>
+        public ManiaSkinComponent(ManiaSkinComponents component, int? targetColumn = null)
             : base(component)
         {
+            TargetColumn = targetColumn;
         }
 
         protected override string RulesetPrefix => ManiaRuleset.SHORT_NAME;
@@ -26,5 +39,6 @@ namespace osu.Game.Rulesets.Mania
         HoldNoteHead,
         HoldNoteTail,
         HoldNoteBody,
+        HitExplosion
     }
 }

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

@@ -51,7 +51,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
             AddRangeInternal(new[]
             {
-                bodyPiece = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.HoldNoteBody), _ => new DefaultBodyPiece())
+                bodyPiece = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.HoldNoteBody, hitObject.Column), _ => new DefaultBodyPiece())
                 {
                     RelativeSizeAxes = Axes.X
                 },

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

@@ -27,7 +27,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             RelativeSizeAxes = Axes.X;
             AutoSizeAxes = Axes.Y;
 
-            AddInternal(headPiece = new SkinnableDrawable(new ManiaSkinComponent(Component), _ => new DefaultNotePiece())
+            AddInternal(headPiece = new SkinnableDrawable(new ManiaSkinComponent(Component, hitObject.Column), _ => new DefaultNotePiece())
             {
                 RelativeSizeAxes = Axes.X,
                 AutoSizeAxes = Axes.Y

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

@@ -6,7 +6,6 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
-using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
@@ -21,12 +20,6 @@ namespace osu.Game.Rulesets.Mania.Skinning
 
         private Drawable sprite;
 
-        [Resolved(CanBeNull = true)]
-        private ManiaStage stage { get; set; }
-
-        [Resolved]
-        private Column column { get; set; }
-
         public LegacyBodyPiece()
         {
             RelativeSizeAxes = Axes.Both;
@@ -69,6 +62,7 @@ namespace osu.Game.Rulesets.Mania.Skinning
             if (!(sprite is TextureAnimation animation))
                 return;
 
+            animation.GotoFrame(0);
             animation.IsPlaying = isHitting.NewValue;
         }
 

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

@@ -18,12 +18,14 @@ namespace osu.Game.Rulesets.Mania.Skinning
     public class LegacyColumnBackground : LegacyManiaColumnElement, IKeyBindingHandler<ManiaAction>
     {
         private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
+        private readonly bool isLastColumn;
 
         private Container lightContainer;
         private Sprite light;
 
-        public LegacyColumnBackground()
+        public LegacyColumnBackground(bool isLastColumn)
         {
+            this.isLastColumn = isLastColumn;
             RelativeSizeAxes = Axes.Both;
         }
 
@@ -40,12 +42,14 @@ namespace osu.Game.Rulesets.Mania.Skinning
 
             bool hasLeftLine = leftLineWidth > 0;
             bool hasRightLine = rightLineWidth > 0 && skin.GetConfig<LegacySkinConfiguration.LegacySetting, decimal>(LegacySkinConfiguration.LegacySetting.Version)?.Value >= 2.4m
-                                || Stage == null || Column.Index == Stage.Columns.Count - 1;
+                                || isLastColumn;
 
-            float lightPosition = skin.GetConfig<LegacyManiaSkinConfigurationLookup, float>(
-                                      new LegacyManiaSkinConfigurationLookup(Stage?.Columns.Count ?? 4, LegacyManiaSkinConfigurationLookups.LightPosition))?.Value
+            float lightPosition = GetManiaSkinConfig<float>(skin, LegacyManiaSkinConfigurationLookups.LightPosition)?.Value
                                   ?? 0;
 
+            Color4 lineColour = GetManiaSkinConfig<Color4>(skin, LegacyManiaSkinConfigurationLookups.ColumnLineColour)?.Value
+                                ?? Color4.White;
+
             InternalChildren = new Drawable[]
             {
                 new Box
@@ -57,6 +61,7 @@ namespace osu.Game.Rulesets.Mania.Skinning
                 {
                     RelativeSizeAxes = Axes.Y,
                     Width = leftLineWidth,
+                    Colour = lineColour,
                     Alpha = hasLeftLine ? 1 : 0
                 },
                 new Box
@@ -65,6 +70,7 @@ namespace osu.Game.Rulesets.Mania.Skinning
                     Origin = Anchor.TopRight,
                     RelativeSizeAxes = Axes.Y,
                     Width = rightLineWidth,
+                    Colour = lineColour,
                     Alpha = hasRightLine ? 1 : 0
                 },
                 lightContainer = new Container

osu.Game.Rulesets.Mania/Skinning/LegacyHitExplosion.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 osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Animations;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Skinning
+{
+    public class LegacyHitExplosion : LegacyManiaColumnElement
+    {
+        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
+
+        private Drawable explosion;
+
+        public LegacyHitExplosion()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(ISkinSource skin, IScrollingInfo scrollingInfo)
+        {
+            string imageName = GetManiaSkinConfig<string>(skin, LegacyManiaSkinConfigurationLookups.ExplosionImage)?.Value
+                               ?? "lightingN";
+
+            float explosionScale = GetManiaSkinConfig<float>(skin, LegacyManiaSkinConfigurationLookups.ExplosionScale)?.Value
+                                   ?? 1;
+
+            // Create a temporary animation to retrieve the number of frames, in an effort to calculate the intended frame length.
+            // This animation is discarded and re-queried with the appropriate frame length afterwards.
+            var tmp = skin.GetAnimation(imageName, true, false);
+            double frameLength = 0;
+            if (tmp is IFramedAnimation tmpAnimation && tmpAnimation.FrameCount > 0)
+                frameLength = Math.Max(1000 / 60.0, 170.0 / tmpAnimation.FrameCount);
+
+            explosion = skin.GetAnimation(imageName, true, false, startAtCurrentTime: true, frameLength: frameLength).With(d =>
+            {
+                if (d == null)
+                    return;
+
+                d.Origin = Anchor.Centre;
+                d.Blending = BlendingParameters.Additive;
+                d.Scale = new Vector2(explosionScale);
+            });
+
+            if (explosion != null)
+                InternalChild = explosion;
+
+            direction.BindTo(scrollingInfo.Direction);
+            direction.BindValueChanged(onDirectionChanged, true);
+        }
+
+        private void onDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
+        {
+            if (explosion != null)
+                explosion.Anchor = direction.NewValue == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            explosion?.FadeInFromZero(80)
+                     .Then().FadeOut(120);
+        }
+    }
+}

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

@@ -10,6 +10,7 @@ namespace osu.Game.Rulesets.Mania.Skinning
     {
         protected override Texture GetTexture(ISkinSource skin)
         {
+            // TODO: Should fallback to the head from default legacy skin instead of note.
             return GetTextureFromLookup(skin, LegacyManiaSkinConfigurationLookups.HoldNoteHeadImage)
                    ?? GetTextureFromLookup(skin, LegacyManiaSkinConfigurationLookups.NoteImage);
         }

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

@@ -20,8 +20,10 @@ namespace osu.Game.Rulesets.Mania.Skinning
 
         protected override Texture GetTexture(ISkinSource skin)
         {
+            // TODO: Should fallback to the head from default legacy skin instead of note.
             return GetTextureFromLookup(skin, LegacyManiaSkinConfigurationLookups.HoldNoteTailImage)
-                   ?? GetTextureFromLookup(skin, LegacyManiaSkinConfigurationLookups.HoldNoteHeadImage);
+                   ?? GetTextureFromLookup(skin, LegacyManiaSkinConfigurationLookups.HoldNoteHeadImage)
+                   ?? GetTextureFromLookup(skin, LegacyManiaSkinConfigurationLookups.NoteImage);
         }
     }
 }

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

@@ -22,9 +22,6 @@ namespace osu.Game.Rulesets.Mania.Skinning
         private Sprite upSprite;
         private Sprite downSprite;
 
-        [Resolved(CanBeNull = true)]
-        private ManiaStage stage { get; set; }
-
         [Resolved]
         private Column column { get; set; }
 

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

@@ -1,11 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using JetBrains.Annotations;
-using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Mania.Skinning
@@ -15,10 +12,6 @@ namespace osu.Game.Rulesets.Mania.Skinning
     /// </summary>
     public class LegacyManiaElement : CompositeDrawable
     {
-        [Resolved(CanBeNull = true)]
-        [CanBeNull]
-        protected ManiaStage Stage { get; private set; }
-
         /// <summary>
         /// Retrieve a per-column-count skin configuration.
         /// </summary>
@@ -26,7 +19,7 @@ namespace osu.Game.Rulesets.Mania.Skinning
         /// <param name="lookup">The value to retrieve.</param>
         /// <param name="index">If not null, denotes the index of the column to which the entry applies.</param>
         protected virtual IBindable<T> GetManiaSkinConfig<T>(ISkin skin, LegacyManiaSkinConfigurationLookups lookup, int? index = null)
-            => skin.GetConfig<LegacyManiaSkinConfigurationLookup, T>(
-                new LegacyManiaSkinConfigurationLookup(Stage?.Columns.Count ?? 4, lookup, index));
+            => skin.GetConfig<ManiaSkinConfigurationLookup, T>(
+                new ManiaSkinConfigurationLookup(lookup, index));
     }
 }

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

@@ -8,6 +8,8 @@ using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Audio;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Mania.Skinning
@@ -15,6 +17,7 @@ namespace osu.Game.Rulesets.Mania.Skinning
     public class ManiaLegacySkinTransformer : ISkin
     {
         private readonly ISkin source;
+        private readonly ManiaBeatmap beatmap;
 
         private Lazy<bool> isLegacySkin;
 
@@ -24,9 +27,10 @@ namespace osu.Game.Rulesets.Mania.Skinning
         /// </summary>
         private Lazy<bool> hasKeyTexture;
 
-        public ManiaLegacySkinTransformer(ISkinSource source)
+        public ManiaLegacySkinTransformer(ISkinSource source, IBeatmap beatmap)
         {
             this.source = source;
+            this.beatmap = (ManiaBeatmap)beatmap;
 
             source.SourceChanged += sourceChanged;
             sourceChanged();
@@ -36,8 +40,8 @@ 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<LegacyManiaSkinConfigurationLookup, string>(
-                    new LegacyManiaSkinConfigurationLookup(4, LegacyManiaSkinConfigurationLookups.KeyImage, 0))?.Value
+                source.GetConfig<ManiaSkinConfigurationLookup, string>(
+                    new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.KeyImage, 0))?.Value
                 ?? "mania-key1", true, true) != null);
         }
 
@@ -55,7 +59,7 @@ namespace osu.Game.Rulesets.Mania.Skinning
                     switch (maniaComponent.Component)
                     {
                         case ManiaSkinComponents.ColumnBackground:
-                            return new LegacyColumnBackground();
+                            return new LegacyColumnBackground(maniaComponent.TargetColumn == beatmap.TotalColumns - 1);
 
                         case ManiaSkinComponents.HitTarget:
                             return new LegacyHitTarget();
@@ -74,6 +78,9 @@ namespace osu.Game.Rulesets.Mania.Skinning
 
                         case ManiaSkinComponents.HoldNoteBody:
                             return new LegacyBodyPiece();
+
+                        case ManiaSkinComponents.HitExplosion:
+                            return new LegacyHitExplosion();
                     }
 
                     break;
@@ -112,7 +119,12 @@ namespace osu.Game.Rulesets.Mania.Skinning
 
         public SampleChannel GetSample(ISampleInfo sample) => source.GetSample(sample);
 
-        public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) =>
-            source.GetConfig<TLookup, TValue>(lookup);
+        public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup)
+        {
+            if (lookup is ManiaSkinConfigurationLookup maniaLookup)
+                return source.GetConfig<LegacyManiaSkinConfigurationLookup, TValue>(new LegacyManiaSkinConfigurationLookup(beatmap.TotalColumns, maniaLookup.Lookup, maniaLookup.TargetColumn));
+
+            return source.GetConfig<TLookup, TValue>(lookup);
+        }
     }
 }

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

@@ -0,0 +1,33 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Skinning;
+
+namespace osu.Game.Rulesets.Mania.Skinning
+{
+    public class ManiaSkinConfigurationLookup
+    {
+        /// <summary>
+        /// The configuration lookup value.
+        /// </summary>
+        public readonly LegacyManiaSkinConfigurationLookups Lookup;
+
+        /// <summary>
+        /// The intended <see cref="Column"/> index for the configuration.
+        /// May be null if the configuration does not apply to a <see cref="Column"/>.
+        /// </summary>
+        public readonly int? TargetColumn;
+
+        /// <summary>
+        /// Creates a new <see cref="ManiaSkinConfigurationLookup"/>.
+        /// </summary>
+        /// <param name="lookup">The lookup value.</param>
+        /// <param name="targetColumn">The intended <see cref="Column"/> index for the configuration. May be null if the configuration does not apply to a <see cref="Column"/>.</param>
+        public ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups lookup, int? targetColumn = null)
+        {
+            Lookup = lookup;
+            TargetColumn = targetColumn;
+        }
+    }
+}

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

@@ -43,7 +43,7 @@ namespace osu.Game.Rulesets.Mania.UI
 
             RelativeSizeAxes = Axes.Y;
 
-            Drawable background = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.ColumnBackground), _ => new DefaultColumnBackground())
+            Drawable background = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.ColumnBackground, Index), _ => new DefaultColumnBackground())
             {
                 RelativeSizeAxes = Axes.Both
             };
@@ -52,8 +52,8 @@ namespace osu.Game.Rulesets.Mania.UI
             {
                 // For input purposes, the background is added at the highest depth, but is then proxied back below all other elements
                 background.CreateProxy(),
-                hitObjectArea = new ColumnHitObjectArea(HitObjectContainer) { RelativeSizeAxes = Axes.Both },
-                new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.KeyArea), _ => new DefaultKeyArea())
+                hitObjectArea = new ColumnHitObjectArea(Index, HitObjectContainer) { RelativeSizeAxes = Axes.Both },
+                new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.KeyArea, Index), _ => new DefaultKeyArea())
                 {
                     RelativeSizeAxes = Axes.Both
                 },
@@ -105,11 +105,15 @@ namespace osu.Game.Rulesets.Mania.UI
             if (!result.IsHit || !judgedObject.DisplayResult || !DisplayJudgements.Value)
                 return;
 
-            hitObjectArea.Explosions.Add(new HitExplosion(judgedObject.AccentColour.Value, judgedObject is DrawableHoldNoteTick)
+            var explosion = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.HitExplosion, Index), _ =>
+                new DefaultHitExplosion(judgedObject.AccentColour.Value, judgedObject is DrawableHoldNoteTick))
             {
-                Anchor = Direction.Value == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre,
-                Origin = Anchor.Centre
-            });
+                RelativeSizeAxes = Axes.Both
+            };
+
+            hitObjectArea.Explosions.Add(explosion);
+
+            explosion.Delay(200).Expire(true);
         }
 
         public bool OnPressed(ManiaAction action)

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

@@ -3,7 +3,6 @@
 
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
@@ -12,20 +11,20 @@ namespace osu.Game.Rulesets.Mania.UI.Components
 {
     public class ColumnHitObjectArea : HitObjectArea
     {
-        public readonly Container<HitExplosion> Explosions;
+        public readonly Container Explosions;
         private readonly Drawable hitTarget;
 
-        public ColumnHitObjectArea(HitObjectContainer hitObjectContainer)
+        public ColumnHitObjectArea(int columnIndex, HitObjectContainer hitObjectContainer)
             : base(hitObjectContainer)
         {
             AddRangeInternal(new[]
             {
-                hitTarget = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.HitTarget), _ => new DefaultHitTarget())
+                hitTarget = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.HitTarget, columnIndex), _ => new DefaultHitTarget())
                 {
                     RelativeSizeAxes = Axes.X,
                     Depth = 1
                 },
-                Explosions = new Container<HitExplosion>
+                Explosions = new Container
                 {
                     RelativeSizeAxes = Axes.Both,
                     Depth = -1,
@@ -38,15 +37,9 @@ namespace osu.Game.Rulesets.Mania.UI.Components
             base.UpdateHitPosition();
 
             if (Direction.Value == ScrollingDirection.Up)
-            {
                 hitTarget.Anchor = hitTarget.Origin = Anchor.TopLeft;
-                Explosions.Padding = new MarginPadding { Top = DefaultNotePiece.NOTE_HEIGHT / 2 };
-            }
             else
-            {
                 hitTarget.Anchor = hitTarget.Origin = Anchor.BottomLeft;
-                Explosions.Padding = new MarginPadding { Bottom = DefaultNotePiece.NOTE_HEIGHT / 2 };
-            }
         }
     }
 }

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

@@ -4,6 +4,7 @@
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Game.Rulesets.Mania.Skinning;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
@@ -14,9 +15,6 @@ namespace osu.Game.Rulesets.Mania.UI.Components
     {
         protected readonly IBindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
 
-        [Resolved(CanBeNull = true)]
-        private ManiaStage stage { get; set; }
-
         public HitObjectArea(HitObjectContainer hitObjectContainer)
         {
             InternalChildren = new[]
@@ -45,8 +43,8 @@ namespace osu.Game.Rulesets.Mania.UI.Components
 
         protected virtual void UpdateHitPosition()
         {
-            float hitPosition = CurrentSkin.GetConfig<LegacyManiaSkinConfigurationLookup, float>(
-                                    new LegacyManiaSkinConfigurationLookup(stage?.Columns.Count ?? 4, LegacyManiaSkinConfigurationLookups.HitPosition))?.Value
+            float hitPosition = CurrentSkin.GetConfig<ManiaSkinConfigurationLookup, float>(
+                                    new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.HitPosition))?.Value
                                 ?? ManiaStage.HIT_TARGET_POSITION;
 
             Padding = Direction.Value == ScrollingDirection.Up

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

@@ -1,26 +1,33 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Utils;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.UI.Scrolling;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
-    public class HitExplosion : CompositeDrawable
+    public class DefaultHitExplosion : CompositeDrawable
     {
         public override bool RemoveWhenNotAlive => true;
 
+        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
+
         private readonly CircularContainer largeFaint;
         private readonly CircularContainer mainGlow1;
 
-        public HitExplosion(Color4 objectColour, bool isSmall = false)
+        public DefaultHitExplosion(Color4 objectColour, bool isSmall = false)
         {
+            Origin = Anchor.Centre;
+
             RelativeSizeAxes = Axes.X;
             Height = DefaultNotePiece.NOTE_HEIGHT;
 
@@ -109,6 +116,13 @@ namespace osu.Game.Rulesets.Mania.UI
             };
         }
 
+        [BackgroundDependencyLoader]
+        private void load(IScrollingInfo scrollingInfo)
+        {
+            direction.BindTo(scrollingInfo.Direction);
+            direction.BindValueChanged(onDirectionChanged, true);
+        }
+
         protected override void LoadComplete()
         {
             const double duration = 200;
@@ -122,7 +136,20 @@ namespace osu.Game.Rulesets.Mania.UI
             mainGlow1.ScaleTo(1.4f, duration, Easing.OutQuint);
 
             this.FadeOut(duration, Easing.Out);
-            Expire(true);
+        }
+
+        private void onDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
+        {
+            if (direction.NewValue == ScrollingDirection.Up)
+            {
+                Anchor = Anchor.TopCentre;
+                Y = DefaultNotePiece.NOTE_HEIGHT / 2;
+            }
+            else
+            {
+                Anchor = Anchor.BottomCentre;
+                Y = -DefaultNotePiece.NOTE_HEIGHT / 2;
+            }
         }
     }
 }

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

@@ -5,8 +5,10 @@ using System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
 using osu.Framework.Input;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Input.Handlers;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Mania.Beatmaps;
@@ -25,6 +27,16 @@ namespace osu.Game.Rulesets.Mania.UI
 {
     public class DrawableManiaRuleset : DrawableScrollingRuleset<ManiaHitObject>
     {
+        /// <summary>
+        /// The minimum time range. This occurs at a <see cref="relativeTimeRange"/> of 40.
+        /// </summary>
+        public const double MIN_TIME_RANGE = 150;
+
+        /// <summary>
+        /// The maximum time range. This occurs at a <see cref="relativeTimeRange"/> of 1.
+        /// </summary>
+        public const double MAX_TIME_RANGE = 6000;
+
         protected new ManiaPlayfield Playfield => (ManiaPlayfield)base.Playfield;
 
         public new ManiaBeatmap Beatmap => (ManiaBeatmap)base.Beatmap;
@@ -46,6 +58,18 @@ namespace osu.Game.Rulesets.Mania.UI
         [BackgroundDependencyLoader]
         private void load()
         {
+            bool isForCurrentRuleset = Beatmap.BeatmapInfo.Ruleset.Equals(Ruleset.RulesetInfo);
+
+            foreach (var p in ControlPoints)
+            {
+                // Mania doesn't care about global velocity
+                p.Velocity = 1;
+
+                // For non-mania beatmap, speed changes should only happen through timing points
+                if (!isForCurrentRuleset)
+                    p.DifficultyPoint = new DifficultyControlPoint();
+            }
+
             BarLines.ForEach(Playfield.Add);
 
             Config.BindWith(ManiaRulesetSetting.ScrollDirection, configDirection);
@@ -54,6 +78,17 @@ namespace osu.Game.Rulesets.Mania.UI
             Config.BindWith(ManiaRulesetSetting.ScrollTime, TimeRange);
         }
 
+        protected override void AdjustScrollSpeed(int amount)
+        {
+            this.TransformTo(nameof(relativeTimeRange), relativeTimeRange + amount, 200, Easing.OutQuint);
+        }
+
+        private double relativeTimeRange
+        {
+            get => MAX_TIME_RANGE / TimeRange.Value;
+            set => TimeRange.Value = MAX_TIME_RANGE / value;
+        }
+
         /// <summary>
         /// Retrieves the column that intersects a screen-space position.
         /// </summary>

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

@@ -3,7 +3,6 @@
 
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.UI;
-using osuTK;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
@@ -13,8 +12,6 @@ namespace osu.Game.Rulesets.Mania.UI
         {
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
-
-            Size = new Vector2(1, 0.8f);
         }
     }
 }

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

@@ -11,6 +11,7 @@ using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.Skinning;
 using osu.Game.Rulesets.Mania.UI.Components;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
@@ -24,7 +25,6 @@ namespace osu.Game.Rulesets.Mania.UI
     /// <summary>
     /// A collection of <see cref="Column"/>s.
     /// </summary>
-    [Cached]
     public class ManiaStage : ScrollingPlayfield
     {
         public const float COLUMN_SPACING = 1;
@@ -72,30 +72,19 @@ namespace osu.Game.Rulesets.Mania.UI
                     AutoSizeAxes = Axes.X,
                     Children = new Drawable[]
                     {
-                        new Container
+                        new Box
                         {
-                            Name = "Columns mask",
+                            Name = "Background",
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = Color4.Black
+                        },
+                        columnFlow = new FillFlowContainer<Column>
+                        {
+                            Name = "Columns",
                             RelativeSizeAxes = Axes.Y,
                             AutoSizeAxes = Axes.X,
-                            Masking = true,
-                            CornerRadius = 5,
-                            Children = new Drawable[]
-                            {
-                                new Box
-                                {
-                                    Name = "Background",
-                                    RelativeSizeAxes = Axes.Both,
-                                    Colour = Color4.Black
-                                },
-                                columnFlow = new FillFlowContainer<Column>
-                                {
-                                    Name = "Columns",
-                                    RelativeSizeAxes = Axes.Y,
-                                    AutoSizeAxes = Axes.X,
-                                    Direction = FillDirection.Horizontal,
-                                    Padding = new MarginPadding { Left = COLUMN_SPACING, Right = COLUMN_SPACING },
-                                },
-                            }
+                            Direction = FillDirection.Horizontal,
+                            Padding = new MarginPadding { Left = COLUMN_SPACING, Right = COLUMN_SPACING },
                         },
                         new Container
                         {
@@ -157,15 +146,15 @@ namespace osu.Game.Rulesets.Mania.UI
             {
                 if (col.Index > 0)
                 {
-                    float spacing = currentSkin.GetConfig<LegacyManiaSkinConfigurationLookup, float>(
-                                                   new LegacyManiaSkinConfigurationLookup(Columns.Count, LegacyManiaSkinConfigurationLookups.ColumnSpacing, col.Index - 1))
+                    float spacing = currentSkin.GetConfig<ManiaSkinConfigurationLookup, float>(
+                                                   new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.ColumnSpacing, col.Index - 1))
                                                ?.Value ?? COLUMN_SPACING;
 
                     col.Margin = new MarginPadding { Left = spacing };
                 }
 
-                float? width = currentSkin.GetConfig<LegacyManiaSkinConfigurationLookup, float>(
-                                              new LegacyManiaSkinConfigurationLookup(Columns.Count, LegacyManiaSkinConfigurationLookups.ColumnWidth, col.Index))
+                float? width = currentSkin.GetConfig<ManiaSkinConfigurationLookup, float>(
+                                              new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.ColumnWidth, col.Index))
                                           ?.Value;
 
                 if (width == null)

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -179,7 +179,7 @@ namespace osu.Game.Rulesets.Osu
 
         public override RulesetSettingsSubsection CreateSettings() => new OsuSettingsSubsection(this);
 
-        public override ISkin CreateLegacySkinProvider(ISkinSource source) => new OsuLegacySkinTransformer(source);
+        public override ISkin CreateLegacySkinProvider(ISkinSource source, IBeatmap beatmap) => new OsuLegacySkinTransformer(source);
 
         public int LegacyID => 0;
 

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

@@ -18,6 +18,8 @@ namespace osu.Game.Rulesets.Osu.Skinning
         public LegacySliderBall(Drawable animationContent)
         {
             this.animationContent = animationContent;
+
+            AutoSizeAxes = Axes.Both;
         }
 
         [BackgroundDependencyLoader]

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

@@ -62,17 +62,7 @@ namespace osu.Game.Rulesets.Osu.Skinning
                     // Math.Max((150 / Velocity) * GameBase.SIXTY_FRAME_TIME, GameBase.SIXTY_FRAME_TIME);
 
                     if (sliderBallContent != null)
-                    {
-                        var size = sliderBallContent.Size;
-
-                        sliderBallContent.RelativeSizeAxes = Axes.Both;
-                        sliderBallContent.Size = Vector2.One;
-
-                        return new LegacySliderBall(sliderBallContent)
-                        {
-                            Size = size
-                        };
-                    }
+                        return new LegacySliderBall(sliderBallContent);
 
                     return null;
 

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

@@ -4,31 +4,28 @@
 using System;
 using System.Collections.Generic;
 using NUnit.Framework;
+using osu.Framework.Allocation;
 using osuTK;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Audio;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Rulesets.Taiko.Audio;
 using osu.Game.Rulesets.Taiko.UI;
 using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Taiko.Tests
 {
     [TestFixture]
-    public class TestSceneInputDrum : OsuTestScene
+    public class TestSceneInputDrum : SkinnableTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
             typeof(InputDrum),
-            typeof(DrumSampleMapping),
-            typeof(HitSampleInfo),
-            typeof(SampleControlPoint)
         };
 
-        public TestSceneInputDrum()
+        [BackgroundDependencyLoader]
+        private void load()
         {
-            Add(new TaikoInputManager(new RulesetInfo { ID = 1 })
+            SetContents(() => new TaikoInputManager(new RulesetInfo { ID = 1 })
             {
                 RelativeSizeAxes = Axes.Both,
                 Child = new Container

osu.Game.Rulesets.Taiko/Skinning/LegacyInputDrum.cs

@@ -0,0 +1,144 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Bindings;
+using osu.Game.Rulesets.Taiko.Audio;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Taiko.Skinning
+{
+    /// <summary>
+    /// A component of the playfield that captures input and displays input as a drum.
+    /// </summary>
+    internal class LegacyInputDrum : Container
+    {
+        public LegacyInputDrum()
+        {
+            AutoSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(ISkinSource skin)
+        {
+            Children = new Drawable[]
+            {
+                new Sprite
+                {
+                    Texture = skin.GetTexture("taiko-bar-left")
+                },
+                new LegacyHalfDrum(false)
+                {
+                    Name = "Left Half",
+                    RelativeSizeAxes = Axes.Both,
+                    Width = 0.5f,
+                    RimAction = TaikoAction.LeftRim,
+                    CentreAction = TaikoAction.LeftCentre
+                },
+                new LegacyHalfDrum(true)
+                {
+                    Name = "Right Half",
+                    Anchor = Anchor.TopRight,
+                    RelativeSizeAxes = Axes.Both,
+                    Width = 0.5f,
+                    Scale = new Vector2(-1, 1),
+                    RimAction = TaikoAction.RightRim,
+                    CentreAction = TaikoAction.RightCentre
+                }
+            };
+        }
+
+        /// <summary>
+        /// A half-drum. Contains one centre and one rim hit.
+        /// </summary>
+        private class LegacyHalfDrum : Container, IKeyBindingHandler<TaikoAction>
+        {
+            /// <summary>
+            /// The key to be used for the rim of the half-drum.
+            /// </summary>
+            public TaikoAction RimAction;
+
+            /// <summary>
+            /// The key to be used for the centre of the half-drum.
+            /// </summary>
+            public TaikoAction CentreAction;
+
+            private readonly Sprite rimHit;
+            private readonly Sprite centreHit;
+
+            [Resolved]
+            private DrumSampleMapping sampleMappings { get; set; }
+
+            public LegacyHalfDrum(bool flipped)
+            {
+                Masking = true;
+
+                Children = new Drawable[]
+                {
+                    rimHit = new Sprite
+                    {
+                        Anchor = flipped ? Anchor.CentreRight : Anchor.CentreLeft,
+                        Origin = flipped ? Anchor.CentreLeft : Anchor.CentreRight,
+                        Scale = new Vector2(-1, 1),
+                        Alpha = 0,
+                    },
+                    centreHit = new Sprite
+                    {
+                        Anchor = flipped ? Anchor.CentreRight : Anchor.CentreLeft,
+                        Origin = flipped ? Anchor.CentreRight : Anchor.CentreLeft,
+                        Alpha = 0,
+                    }
+                };
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(ISkinSource skin)
+            {
+                rimHit.Texture = skin.GetTexture(@"taiko-drum-outer");
+                centreHit.Texture = skin.GetTexture(@"taiko-drum-inner");
+            }
+
+            public bool OnPressed(TaikoAction action)
+            {
+                Drawable target = null;
+                var drumSample = sampleMappings.SampleAt(Time.Current);
+
+                if (action == CentreAction)
+                {
+                    target = centreHit;
+                    drumSample.Centre?.Play();
+                }
+                else if (action == RimAction)
+                {
+                    target = rimHit;
+                    drumSample.Rim?.Play();
+                }
+
+                if (target != null)
+                {
+                    const float alpha_amount = 1;
+
+                    const float down_time = 80;
+                    const float up_time = 50;
+
+                    target.Animate(
+                        t => t.FadeTo(Math.Min(target.Alpha + alpha_amount, 1), down_time)
+                    ).Then(
+                        t => t.FadeOut(up_time)
+                    );
+                }
+
+                return false;
+            }
+
+            public void OnReleased(TaikoAction action)
+            {
+            }
+        }
+    }
+}

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

@@ -20,7 +20,22 @@ namespace osu.Game.Rulesets.Taiko.Skinning
             this.source = source;
         }
 
-        public Drawable GetDrawableComponent(ISkinComponent component) => source.GetDrawableComponent(component);
+        public Drawable GetDrawableComponent(ISkinComponent component)
+        {
+            if (!(component is TaikoSkinComponent taikoComponent))
+                return null;
+
+            switch (taikoComponent.Component)
+            {
+                case TaikoSkinComponents.InputDrum:
+                    if (GetTexture("taiko-bar-left") != null)
+                        return new LegacyInputDrum();
+
+                    return null;
+            }
+
+            return source.GetDrawableComponent(component);
+        }
 
         public Texture GetTexture(string componentName) => source.GetTexture(componentName);
 

osu.Game.Rulesets.Taiko/TaikoRuleset.cs

@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Taiko
 
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new TaikoBeatmapConverter(beatmap, this);
 
-        public override ISkin CreateLegacySkinProvider(ISkinSource source) => new TaikoLegacySkinTransformer(source);
+        public override ISkin CreateLegacySkinProvider(ISkinSource source, IBeatmap beatmap) => new TaikoLegacySkinTransformer(source);
 
         public const string SHORT_NAME = "taiko";
 

osu.Game.Rulesets.Taiko/TaikoSkinComponents.cs

@@ -5,5 +5,6 @@ namespace osu.Game.Rulesets.Taiko
 {
     public enum TaikoSkinComponents
     {
+        InputDrum,
     }
 }

osu.Game.Rulesets.Taiko/UI/InputDrum.cs

@@ -12,6 +12,7 @@ using osu.Framework.Input.Bindings;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Taiko.Audio;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Taiko.UI
 {
@@ -22,11 +23,12 @@ namespace osu.Game.Rulesets.Taiko.UI
     {
         private const float middle_split = 0.025f;
 
-        private readonly ControlPointInfo controlPoints;
+        [Cached]
+        private DrumSampleMapping sampleMapping;
 
         public InputDrum(ControlPointInfo controlPoints)
         {
-            this.controlPoints = controlPoints;
+            sampleMapping = new DrumSampleMapping(controlPoints);
 
             RelativeSizeAxes = Axes.Both;
             FillMode = FillMode.Fit;
@@ -35,35 +37,37 @@ namespace osu.Game.Rulesets.Taiko.UI
         [BackgroundDependencyLoader]
         private void load()
         {
-            var sampleMappings = new DrumSampleMapping(controlPoints);
-
-            Children = new Drawable[]
+            Child = new SkinnableDrawable(new TaikoSkinComponent(TaikoSkinComponents.InputDrum), _ => new Container
             {
-                new TaikoHalfDrum(false, sampleMappings)
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
                 {
-                    Name = "Left Half",
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.CentreRight,
-                    RelativeSizeAxes = Axes.Both,
-                    RelativePositionAxes = Axes.X,
-                    X = -middle_split / 2,
-                    RimAction = TaikoAction.LeftRim,
-                    CentreAction = TaikoAction.LeftCentre
-                },
-                new TaikoHalfDrum(true, sampleMappings)
-                {
-                    Name = "Right Half",
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.CentreLeft,
-                    RelativeSizeAxes = Axes.Both,
-                    RelativePositionAxes = Axes.X,
-                    X = middle_split / 2,
-                    RimAction = TaikoAction.RightRim,
-                    CentreAction = TaikoAction.RightCentre
+                    new TaikoHalfDrum(false)
+                    {
+                        Name = "Left Half",
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.CentreRight,
+                        RelativeSizeAxes = Axes.Both,
+                        RelativePositionAxes = Axes.X,
+                        X = -middle_split / 2,
+                        RimAction = TaikoAction.LeftRim,
+                        CentreAction = TaikoAction.LeftCentre
+                    },
+                    new TaikoHalfDrum(true)
+                    {
+                        Name = "Right Half",
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.CentreLeft,
+                        RelativeSizeAxes = Axes.Both,
+                        RelativePositionAxes = Axes.X,
+                        X = middle_split / 2,
+                        RimAction = TaikoAction.RightRim,
+                        CentreAction = TaikoAction.RightCentre
+                    }
                 }
-            };
+            });
 
-            AddRangeInternal(sampleMappings.Sounds);
+            AddRangeInternal(sampleMapping.Sounds);
         }
 
         /// <summary>
@@ -86,12 +90,11 @@ namespace osu.Game.Rulesets.Taiko.UI
             private readonly Sprite centre;
             private readonly Sprite centreHit;
 
-            private readonly DrumSampleMapping sampleMappings;
+            [Resolved]
+            private DrumSampleMapping sampleMappings { get; set; }
 
-            public TaikoHalfDrum(bool flipped, DrumSampleMapping sampleMappings)
+            public TaikoHalfDrum(bool flipped)
             {
-                this.sampleMappings = sampleMappings;
-
                 Masking = true;
 
                 Children = new Drawable[]

osu.Game.Tests/Beatmaps/Formats/OsuJsonDecoderTest.cs

@@ -127,6 +127,31 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 .Assert();
         }
 
+        [Test]
+        public void TestGetJsonDecoder()
+        {
+            Decoder<Beatmap> decoder;
+
+            using (var stream = TestResources.OpenResource(normal))
+            using (var sr = new LineBufferedReader(stream))
+            {
+                var legacyDecoded = new LegacyBeatmapDecoder { ApplyOffsets = false }.Decode(sr);
+
+                using (var memStream = new MemoryStream())
+                using (var memWriter = new StreamWriter(memStream))
+                using (var memReader = new LineBufferedReader(memStream))
+                {
+                    memWriter.Write(legacyDecoded.Serialize());
+                    memWriter.Flush();
+
+                    memStream.Position = 0;
+                    decoder = Decoder.GetDecoder<Beatmap>(memReader);
+                }
+            }
+
+            Assert.IsInstanceOf(typeof(JsonBeatmapDecoder), decoder);
+        }
+
         /// <summary>
         /// Reads a .osu file first with a <see cref="LegacyBeatmapDecoder"/>, serializes the resulting <see cref="Beatmap"/> to JSON
         /// and then deserializes the result back into a <see cref="Beatmap"/> through an <see cref="JsonBeatmapDecoder"/>.

osu.Game.Tests/Resources/mania-skin-colours.ini

@@ -0,0 +1,3 @@
+[Mania]
+Keys: 4
+ColourBarline: 50,50,50,50

osu.Game.Tests/Skins/LegacyManiaSkinDecoderTest.cs

@@ -5,6 +5,7 @@ using NUnit.Framework;
 using osu.Game.IO;
 using osu.Game.Skinning;
 using osu.Game.Tests.Resources;
+using osuTK.Graphics;
 
 namespace osu.Game.Tests.Skins
 {
@@ -83,5 +84,20 @@ namespace osu.Game.Tests.Skins
                 Assert.That(configs[0].HitPosition, Is.EqualTo(16));
             }
         }
+
+        [Test]
+        public void TestParseColours()
+        {
+            var decoder = new LegacyManiaSkinDecoder();
+
+            using (var resStream = TestResources.OpenResource("mania-skin-colours.ini"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                var configs = decoder.Decode(stream);
+
+                Assert.That(configs.Count, Is.EqualTo(1));
+                Assert.That(configs[0].CustomColours, Contains.Key("ColourBarline").And.ContainValue(new Color4(50, 50, 50, 50)));
+            }
+        }
     }
 }

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

@@ -22,7 +22,6 @@ namespace osu.Game.Tests.Visual.Menus
         {
             typeof(StartupScreen),
             typeof(IntroScreen),
-            typeof(OsuScreen),
             typeof(IntroTestScene),
         };
 

osu.Game.Tournament/Components/TourneyVideo.cs

@@ -16,7 +16,7 @@ namespace osu.Game.Tournament.Components
     {
         private readonly string filename;
         private readonly bool drawFallbackGradient;
-        private VideoSprite video;
+        private Video video;
 
         private ManualClock manualClock;
 
@@ -33,7 +33,7 @@ namespace osu.Game.Tournament.Components
 
             if (stream != null)
             {
-                InternalChild = video = new VideoSprite(stream, false)
+                InternalChild = video = new Video(stream, false)
                 {
                     RelativeSizeAxes = Axes.Both,
                     FillMode = FillMode.Fit,

osu.Game/Beatmaps/Formats/Decoder.cs

@@ -63,7 +63,7 @@ namespace osu.Game.Beatmaps.Formats
             if (line == null)
                 throw new IOException("Unknown file format (null)");
 
-            var decoder = typedDecoders.Select(d => line.StartsWith(d.Key, StringComparison.InvariantCulture) ? d.Value : null).FirstOrDefault();
+            var decoder = typedDecoders.Where(d => line.StartsWith(d.Key, StringComparison.InvariantCulture)).Select(d => d.Value).FirstOrDefault();
 
             // it's important the magic does NOT get consumed here, since sometimes it's part of the structure
             // (see JsonBeatmapDecoder - the magic string is the opening brace)

osu.Game/Beatmaps/Formats/LegacyDecoder.cs

@@ -73,7 +73,7 @@ namespace osu.Game.Beatmaps.Formats
             switch (section)
             {
                 case Section.Colours:
-                    handleColours(output, line);
+                    HandleColours(output, line);
                     return;
             }
         }
@@ -87,7 +87,7 @@ namespace osu.Game.Beatmaps.Formats
             return line;
         }
 
-        private void handleColours(T output, string line)
+        protected void HandleColours<TModel>(TModel output, string line)
         {
             var pair = SplitKeyVal(line);
 

osu.Game/Extensions/DrawableExtensions.cs

@@ -0,0 +1,32 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Threading;
+
+namespace osu.Game.Extensions
+{
+    public static class DrawableExtensions
+    {
+        /// <summary>
+        /// Helper method that is used while <see cref="IKeyBindingHandler"/> doesn't support repetitions of <see cref="IKeyBindingHandler{T}.OnPressed"/>.
+        /// Simulates repetitions by continually invoking a delegate according to the default key repeat rate.
+        /// </summary>
+        /// <remarks>
+        /// The returned delegate can be cancelled to stop repeat events from firing (usually in <see cref="IKeyBindingHandler{T}.OnReleased"/>).
+        /// </remarks>
+        /// <param name="handler">The <see cref="IKeyBindingHandler{T}"/> which is handling the repeat.</param>
+        /// <param name="scheduler">The <see cref="Scheduler"/> to schedule repetitions on.</param>
+        /// <param name="action">The <see cref="Action"/> to be invoked once immediately and with every repetition.</param>
+        /// <returns>A <see cref="ScheduledDelegate"/> which can be cancelled to stop the repeat events from firing.</returns>
+        public static ScheduledDelegate BeginKeyRepeat(this IKeyBindingHandler handler, Scheduler scheduler, Action action)
+        {
+            action();
+
+            ScheduledDelegate repeatDelegate = new ScheduledDelegate(action, handler.Time.Current + 250, 70);
+            scheduler.Add(repeatDelegate);
+            return repeatDelegate;
+        }
+    }
+}

osu.Game/Rulesets/Ruleset.cs

@@ -102,7 +102,7 @@ namespace osu.Game.Rulesets
 
         public ModAutoplay GetAutoplayMod() => GetAllMods().OfType<ModAutoplay>().First();
 
-        public virtual ISkin CreateLegacySkinProvider(ISkinSource source) => null;
+        public virtual ISkin CreateLegacySkinProvider(ISkinSource source, IBeatmap beatmap) => null;
 
         protected Ruleset()
         {

osu.Game/Rulesets/UI/Scrolling/DrawableScrollingRuleset.cs

@@ -9,9 +9,11 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Lists;
+using osu.Framework.Threading;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Configuration;
+using osu.Game.Extensions;
 using osu.Game.Input.Bindings;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
@@ -74,11 +76,9 @@ namespace osu.Game.Rulesets.UI.Scrolling
         protected virtual bool RelativeScaleBeatLengths => false;
 
         /// <summary>
-        /// Provides the default <see cref="MultiplierControlPoint"/>s that adjust the scrolling rate of <see cref="HitObject"/>s
-        /// inside this <see cref="DrawableRuleset{TObject}"/>.
+        /// The <see cref="MultiplierControlPoint"/>s that adjust the scrolling rate of <see cref="HitObject"/>s inside this <see cref="DrawableRuleset{TObject}"/>.
         /// </summary>
-        /// <returns></returns>
-        private readonly SortedList<MultiplierControlPoint> controlPoints = new SortedList<MultiplierControlPoint>(Comparer<MultiplierControlPoint>.Default);
+        protected readonly SortedList<MultiplierControlPoint> ControlPoints = new SortedList<MultiplierControlPoint>(Comparer<MultiplierControlPoint>.Default);
 
         protected IScrollingInfo ScrollingInfo => scrollingInfo;
 
@@ -95,11 +95,11 @@ namespace osu.Game.Rulesets.UI.Scrolling
             switch (VisualisationMethod)
             {
                 case ScrollVisualisationMethod.Sequential:
-                    scrollingInfo.Algorithm = new SequentialScrollAlgorithm(controlPoints);
+                    scrollingInfo.Algorithm = new SequentialScrollAlgorithm(ControlPoints);
                     break;
 
                 case ScrollVisualisationMethod.Overlapping:
-                    scrollingInfo.Algorithm = new OverlappingScrollAlgorithm(controlPoints);
+                    scrollingInfo.Algorithm = new OverlappingScrollAlgorithm(ControlPoints);
                     break;
 
                 case ScrollVisualisationMethod.Constant:
@@ -168,29 +168,10 @@ namespace osu.Game.Rulesets.UI.Scrolling
                             // Collapse sections with the same start time
                             .GroupBy(s => s.StartTime).Select(g => g.Last()).OrderBy(s => s.StartTime);
 
-            controlPoints.AddRange(timingChanges);
+            ControlPoints.AddRange(timingChanges);
 
-            if (controlPoints.Count == 0)
-                controlPoints.Add(new MultiplierControlPoint { Velocity = Beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier });
-        }
-
-        public bool OnPressed(GlobalAction action)
-        {
-            if (!UserScrollSpeedAdjustment)
-                return false;
-
-            switch (action)
-            {
-                case GlobalAction.IncreaseScrollSpeed:
-                    this.TransformBindableTo(TimeRange, TimeRange.Value - time_span_step, 200, Easing.OutQuint);
-                    return true;
-
-                case GlobalAction.DecreaseScrollSpeed:
-                    this.TransformBindableTo(TimeRange, TimeRange.Value + time_span_step, 200, Easing.OutQuint);
-                    return true;
-            }
-
-            return false;
+            if (ControlPoints.Count == 0)
+                ControlPoints.Add(new MultiplierControlPoint { Velocity = Beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier });
         }
 
         protected override void LoadComplete()
@@ -201,8 +182,43 @@ namespace osu.Game.Rulesets.UI.Scrolling
                 throw new ArgumentException($"{nameof(Playfield)} must be a {nameof(ScrollingPlayfield)} when using {nameof(DrawableScrollingRuleset<TObject>)}.");
         }
 
+        /// <summary>
+        /// Adjusts the scroll speed of <see cref="HitObject"/>s.
+        /// </summary>
+        /// <param name="amount">The amount to adjust by. Greater than 0 if the scroll speed should be increased, less than 0 if it should be decreased.</param>
+        protected virtual void AdjustScrollSpeed(int amount) => this.TransformBindableTo(TimeRange, TimeRange.Value - amount * time_span_step, 200, Easing.OutQuint);
+
+        public bool OnPressed(GlobalAction action)
+        {
+            if (!UserScrollSpeedAdjustment)
+                return false;
+
+            switch (action)
+            {
+                case GlobalAction.IncreaseScrollSpeed:
+                    scheduleScrollSpeedAdjustment(1);
+                    return true;
+
+                case GlobalAction.DecreaseScrollSpeed:
+                    scheduleScrollSpeedAdjustment(-1);
+                    return true;
+            }
+
+            return false;
+        }
+
+        private ScheduledDelegate scheduledScrollSpeedAdjustment;
+
         public void OnReleased(GlobalAction action)
         {
+            scheduledScrollSpeedAdjustment?.Cancel();
+            scheduledScrollSpeedAdjustment = null;
+        }
+
+        private void scheduleScrollSpeedAdjustment(int amount)
+        {
+            scheduledScrollSpeedAdjustment?.Cancel();
+            scheduledScrollSpeedAdjustment = this.BeginKeyRepeat(Scheduler, () => AdjustScrollSpeed(amount));
         }
 
         private class LocalScrollingInfo : IScrollingInfo

osu.Game/Screens/Edit/Compose/ComposeScreen.cs

@@ -25,7 +25,7 @@ namespace osu.Game.Screens.Edit.Compose
 
             // the beatmapSkinProvider is used as the fallback source here to allow the ruleset-specific skin implementation
             // full access to all skin sources.
-            var rulesetSkinProvider = new SkinProvidingContainer(ruleset.CreateLegacySkinProvider(beatmapSkinProvider));
+            var rulesetSkinProvider = new SkinProvidingContainer(ruleset.CreateLegacySkinProvider(beatmapSkinProvider, EditorBeatmap.PlayableBeatmap));
 
             // load the skinning hierarchy first.
             // this is intentionally done in two stages to ensure things are in a loaded state before exposing the ruleset to skin sources.

osu.Game/Screens/Menu/IntroTriangles.cs

@@ -270,10 +270,9 @@ namespace osu.Game.Screens.Menu
                 [BackgroundDependencyLoader]
                 private void load()
                 {
-                    InternalChild = new VideoSprite(videoStream, false)
+                    InternalChild = new Video(videoStream, false)
                     {
                         RelativeSizeAxes = Axes.Both,
-                        Clock = new FramedOffsetClock(Clock) { Offset = -logo_1 }
                     };
                 }
             }

osu.Game/Screens/Play/Player.cs

@@ -176,7 +176,7 @@ namespace osu.Game.Screens.Play
             dependencies.CacheAs(gameplayBeatmap);
 
             addUnderlayComponents(GameplayClockContainer);
-            addGameplayComponents(GameplayClockContainer, Beatmap.Value);
+            addGameplayComponents(GameplayClockContainer, Beatmap.Value, playableBeatmap);
             addOverlayComponents(GameplayClockContainer, Beatmap.Value);
 
             DrawableRuleset.HasReplayLoaded.BindValueChanged(_ => updatePauseOnFocusLostState(), true);
@@ -214,13 +214,13 @@ namespace osu.Game.Screens.Play
             target.Add(DimmableStoryboard = new DimmableStoryboard(Beatmap.Value.Storyboard) { RelativeSizeAxes = Axes.Both });
         }
 
-        private void addGameplayComponents(Container target, WorkingBeatmap working)
+        private void addGameplayComponents(Container target, WorkingBeatmap working, IBeatmap playableBeatmap)
         {
             var beatmapSkinProvider = new BeatmapSkinProvidingContainer(working.Skin);
 
             // the beatmapSkinProvider is used as the fallback source here to allow the ruleset-specific skin implementation
             // full access to all skin sources.
-            var rulesetSkinProvider = new SkinProvidingContainer(ruleset.CreateLegacySkinProvider(beatmapSkinProvider));
+            var rulesetSkinProvider = new SkinProvidingContainer(ruleset.CreateLegacySkinProvider(beatmapSkinProvider, playableBeatmap));
 
             // load the skinning hierarchy first.
             // this is intentionally done in two stages to ensure things are in a loaded state before exposing the ruleset to skin sources.

osu.Game/Skinning/IAnimationTimeReference.cs

@@ -9,6 +9,10 @@ namespace osu.Game.Skinning
     /// <summary>
     /// Denotes an object which provides a reference time to start animations from.
     /// </summary>
+    /// <remarks>
+    /// This should not be used to start an animation immediately at the current time.
+    /// To do so, use <see cref="LegacySkinExtensions.GetAnimation"/> with <code>startAtCurrentTime = true</code> instead.
+    /// </remarks>
     [Cached]
     public interface IAnimationTimeReference
     {

osu.Game/Skinning/LegacyManiaSkinConfiguration.cs

@@ -2,19 +2,35 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
+using osu.Game.Beatmaps.Formats;
+using osuTK.Graphics;
 
 namespace osu.Game.Skinning
 {
-    public class LegacyManiaSkinConfiguration
+    public class LegacyManiaSkinConfiguration : IHasCustomColours
     {
+        /// <summary>
+        /// Conversion factor from converting legacy positioning values (based in x480 dimensions) to x768.
+        /// </summary>
+        public const float POSITION_SCALE_FACTOR = 1.6f;
+
+        /// <summary>
+        /// Size of a legacy column in the default skin, used for determining relative scale factors.
+        /// </summary>
+        public const float DEFAULT_COLUMN_SIZE = 30 * POSITION_SCALE_FACTOR;
+
         public readonly int Keys;
 
+        public Dictionary<string, Color4> CustomColours { get; set; } = new Dictionary<string, Color4>();
+
         public readonly float[] ColumnLineWidth;
         public readonly float[] ColumnSpacing;
         public readonly float[] ColumnWidth;
+        public readonly float[] ExplosionWidth;
 
-        public float HitPosition = 124.8f; // (480 - 402) * 1.6f
-        public float LightPosition = 107.2f; // (480 - 413) * 1.6f
+        public float HitPosition = (480 - 402) * POSITION_SCALE_FACTOR;
+        public float LightPosition = (480 - 413) * POSITION_SCALE_FACTOR;
         public bool ShowJudgementLine = true;
 
         public LegacyManiaSkinConfiguration(int keys)
@@ -24,9 +40,10 @@ namespace osu.Game.Skinning
             ColumnLineWidth = new float[keys + 1];
             ColumnSpacing = new float[keys - 1];
             ColumnWidth = new float[keys];
+            ExplosionWidth = new float[keys];
 
             ColumnLineWidth.AsSpan().Fill(2);
-            ColumnWidth.AsSpan().Fill(48);
+            ColumnWidth.AsSpan().Fill(DEFAULT_COLUMN_SIZE);
         }
     }
 }

osu.Game/Skinning/LegacyManiaSkinConfigurationLookup.cs

@@ -34,5 +34,8 @@ namespace osu.Game.Skinning
         HoldNoteHeadImage,
         HoldNoteTailImage,
         HoldNoteBodyImage,
+        ExplosionImage,
+        ExplosionScale,
+        ColumnLineColour
     }
 }

osu.Game/Skinning/LegacyManiaSkinDecoder.cs

@@ -11,8 +11,6 @@ namespace osu.Game.Skinning
 {
     public class LegacyManiaSkinDecoder : LegacyDecoder<List<LegacyManiaSkinConfiguration>>
     {
-        private const float size_scale_factor = 1.6f;
-
         public LegacyManiaSkinDecoder()
             : base(1)
         {
@@ -73,6 +71,12 @@ namespace osu.Game.Skinning
             {
                 var pair = SplitKeyVal(line);
 
+                if (pair.Key.StartsWith("Colour"))
+                {
+                    HandleColours(currentConfig, line);
+                    continue;
+                }
+
                 switch (pair.Key)
                 {
                     case "ColumnLineWidth":
@@ -88,16 +92,20 @@ namespace osu.Game.Skinning
                         break;
 
                     case "HitPosition":
-                        currentConfig.HitPosition = (480 - float.Parse(pair.Value, CultureInfo.InvariantCulture)) * size_scale_factor;
+                        currentConfig.HitPosition = (480 - float.Parse(pair.Value, CultureInfo.InvariantCulture)) * LegacyManiaSkinConfiguration.POSITION_SCALE_FACTOR;
                         break;
 
                     case "LightPosition":
-                        currentConfig.LightPosition = (480 - float.Parse(pair.Value, CultureInfo.InvariantCulture)) * size_scale_factor;
+                        currentConfig.LightPosition = (480 - float.Parse(pair.Value, CultureInfo.InvariantCulture)) * LegacyManiaSkinConfiguration.POSITION_SCALE_FACTOR;
                         break;
 
                     case "JudgementLine":
                         currentConfig.ShowJudgementLine = pair.Value == "1";
                         break;
+
+                    case "LightingNWidth":
+                        parseArrayValue(pair.Value, currentConfig.ExplosionWidth);
+                        break;
                 }
             }
         }
@@ -111,7 +119,7 @@ namespace osu.Game.Skinning
                 if (i >= output.Length)
                     break;
 
-                output[i] = float.Parse(values[i], CultureInfo.InvariantCulture) * size_scale_factor;
+                output[i] = float.Parse(values[i], CultureInfo.InvariantCulture) * LegacyManiaSkinConfiguration.POSITION_SCALE_FACTOR;
             }
         }
     }

osu.Game/Skinning/LegacySkin.cs

@@ -14,6 +14,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.IO.Stores;
 using osu.Game.Audio;
+using osu.Game.Beatmaps.Formats;
 using osu.Game.IO;
 using osu.Game.Rulesets.Scoring;
 using osuTK.Graphics;
@@ -112,7 +113,7 @@ namespace osu.Game.Skinning
                             break;
 
                         default:
-                            return SkinUtils.As<TValue>(getCustomColour(colour.ToString()));
+                            return SkinUtils.As<TValue>(getCustomColour(Configuration, colour.ToString()));
                     }
 
                     break;
@@ -130,7 +131,7 @@ namespace osu.Game.Skinning
                     break;
 
                 case SkinCustomColourLookup customColour:
-                    return SkinUtils.As<TValue>(getCustomColour(customColour.Lookup.ToString()));
+                    return SkinUtils.As<TValue>(getCustomColour(Configuration, customColour.Lookup.ToString()));
 
                 case LegacyManiaSkinConfigurationLookup maniaLookup:
                     if (!AllowManiaSkin)
@@ -192,12 +193,27 @@ namespace osu.Game.Skinning
 
                 case LegacyManiaSkinConfigurationLookups.ShowJudgementLine:
                     return SkinUtils.As<TValue>(new Bindable<bool>(existing.ShowJudgementLine));
+
+                case LegacyManiaSkinConfigurationLookups.ExplosionScale:
+                    Debug.Assert(maniaLookup.TargetColumn != null);
+
+                    if (GetConfig<LegacySkinConfiguration.LegacySetting, decimal>(LegacySkinConfiguration.LegacySetting.Version)?.Value < 2.5m)
+                        return SkinUtils.As<TValue>(new Bindable<float>(1));
+
+                    if (existing.ExplosionWidth[maniaLookup.TargetColumn.Value] != 0)
+                        return SkinUtils.As<TValue>(new Bindable<float>(existing.ExplosionWidth[maniaLookup.TargetColumn.Value] / LegacyManiaSkinConfiguration.DEFAULT_COLUMN_SIZE));
+
+                    return SkinUtils.As<TValue>(new Bindable<float>(existing.ColumnWidth[maniaLookup.TargetColumn.Value] / LegacyManiaSkinConfiguration.DEFAULT_COLUMN_SIZE));
+
+                case LegacyManiaSkinConfigurationLookups.ColumnLineColour:
+                    return SkinUtils.As<TValue>(getCustomColour(existing, "ColourColumnLine"));
             }
 
             return null;
         }
 
-        private IBindable<Color4> getCustomColour(string lookup) => Configuration.CustomColours.TryGetValue(lookup, out var col) ? new Bindable<Color4>(col) : null;
+        private IBindable<Color4> getCustomColour(IHasCustomColours source, string lookup)
+            => source.CustomColours.TryGetValue(lookup, out var col) ? new Bindable<Color4>(col) : null;
 
         public override Drawable GetDrawableComponent(ISkinComponent component)
         {

osu.Game/Skinning/LegacySkinExtensions.cs

@@ -8,13 +8,13 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Timing;
 
 namespace osu.Game.Skinning
 {
     public static class LegacySkinExtensions
     {
-        public static Drawable GetAnimation(this ISkin source, string componentName, bool animatable, bool looping, bool applyConfigFrameRate = false, string animationSeparator = "-")
+        public static Drawable GetAnimation(this ISkin source, string componentName, bool animatable, bool looping, bool applyConfigFrameRate = false, string animationSeparator = "-",
+                                            bool startAtCurrentTime = false, double? frameLength = null)
         {
             Texture texture;
 
@@ -24,10 +24,10 @@ namespace osu.Game.Skinning
 
                 if (textures.Length > 0)
                 {
-                    var animation = new SkinnableTextureAnimation
+                    var animation = new SkinnableTextureAnimation(startAtCurrentTime)
                     {
-                        DefaultFrameLength = getFrameLength(source, applyConfigFrameRate, textures),
-                        Repeat = looping,
+                        DefaultFrameLength = frameLength ?? getFrameLength(source, applyConfigFrameRate, textures),
+                        Loop = looping,
                     };
 
                     foreach (var t in textures)
@@ -60,8 +60,8 @@ namespace osu.Game.Skinning
             [Resolved(canBeNull: true)]
             private IAnimationTimeReference timeReference { get; set; }
 
-            public SkinnableTextureAnimation()
-                : base(false)
+            public SkinnableTextureAnimation(bool startAtCurrentTime = true)
+                : base(startAtCurrentTime)
             {
             }
 
@@ -70,7 +70,10 @@ namespace osu.Game.Skinning
                 base.LoadComplete();
 
                 if (timeReference != null)
-                    Clock = new FramedOffsetClock(timeReference.Clock) { Offset = -timeReference.AnimationStartTime };
+                {
+                    Clock = timeReference.Clock;
+                    PlaybackPosition = timeReference.AnimationStartTime - timeReference.Clock.CurrentTime;
+                }
             }
         }
 

osu.Game/Storyboards/Drawables/DrawableStoryboardAnimation.cs

@@ -108,7 +108,7 @@ namespace osu.Game.Storyboards.Drawables
             Animation = animation;
             Origin = animation.Origin;
             Position = animation.InitialPosition;
-            Repeat = animation.LoopType == AnimationLoopType.LoopForever;
+            Loop = animation.LoopType == AnimationLoopType.LoopForever;
 
             LifetimeStart = animation.StartTime;
             LifetimeEnd = animation.EndTime;

osu.Game/Storyboards/Drawables/DrawableStoryboardVideo.cs

@@ -8,7 +8,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Graphics.Video;
-using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 
 namespace osu.Game.Storyboards.Drawables
@@ -16,7 +15,7 @@ namespace osu.Game.Storyboards.Drawables
     public class DrawableStoryboardVideo : CompositeDrawable
     {
         public readonly StoryboardVideo Video;
-        private VideoSprite videoSprite;
+        private Video video;
 
         public override bool RemoveWhenNotAlive => false;
 
@@ -40,14 +39,14 @@ namespace osu.Game.Storyboards.Drawables
             if (stream == null)
                 return;
 
-            InternalChild = videoSprite = new VideoSprite(stream, false)
+            InternalChild = video = new Video(stream, false)
             {
                 RelativeSizeAxes = Axes.Both,
                 FillMode = FillMode.Fill,
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
                 Alpha = 0,
-                Clock = new FramedOffsetClock(Clock) { Offset = -Video.StartTime }
+                PlaybackPosition = Video.StartTime
             };
         }
 
@@ -55,10 +54,10 @@ namespace osu.Game.Storyboards.Drawables
         {
             base.LoadComplete();
 
-            if (videoSprite == null) return;
+            if (video == null) return;
 
-            using (videoSprite.BeginAbsoluteSequence(0))
-                videoSprite.FadeIn(500);
+            using (video.BeginAbsoluteSequence(0))
+                video.FadeIn(500);
         }
     }
 }

osu.Game/Tests/Visual/SkinnableTestScene.cs

@@ -11,6 +11,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.IO.Stores;
+using osu.Game.Beatmaps;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Skinning;
 using osuTK;
@@ -47,16 +48,18 @@ namespace osu.Game.Tests.Visual
         {
             createdDrawables.Clear();
 
-            Cell(0).Child = createProvider(null, creationFunction);
-            Cell(1).Child = createProvider(metricsSkin, creationFunction);
-            Cell(2).Child = createProvider(defaultSkin, creationFunction);
-            Cell(3).Child = createProvider(specialSkin, creationFunction);
-            Cell(4).Child = createProvider(oldSkin, creationFunction);
+            var beatmap = CreateBeatmapForSkinProvider();
+
+            Cell(0).Child = createProvider(null, creationFunction, beatmap);
+            Cell(1).Child = createProvider(metricsSkin, creationFunction, beatmap);
+            Cell(2).Child = createProvider(defaultSkin, creationFunction, beatmap);
+            Cell(3).Child = createProvider(specialSkin, creationFunction, beatmap);
+            Cell(4).Child = createProvider(oldSkin, creationFunction, beatmap);
         }
 
         protected IEnumerable<Drawable> CreatedDrawables => createdDrawables;
 
-        private Drawable createProvider(Skin skin, Func<Drawable> creationFunction)
+        private Drawable createProvider(Skin skin, Func<Drawable> creationFunction, IBeatmap beatmap)
         {
             var created = creationFunction();
             createdDrawables.Add(created);
@@ -100,7 +103,7 @@ namespace osu.Game.Tests.Visual
                         {
                             new OutlineBox { Alpha = autoSize ? 1 : 0 },
                             mainProvider.WithChild(
-                                new SkinProvidingContainer(Ruleset.Value.CreateInstance().CreateLegacySkinProvider(mainProvider))
+                                new SkinProvidingContainer(Ruleset.Value.CreateInstance().CreateLegacySkinProvider(mainProvider, beatmap))
                                 {
                                     Child = created,
                                     RelativeSizeAxes = !autoSize ? Axes.Both : Axes.None,
@@ -113,6 +116,8 @@ namespace osu.Game.Tests.Visual
             };
         }
 
+        protected virtual IBeatmap CreateBeatmapForSkinProvider() => CreateWorkingBeatmap(Ruleset.Value).GetPlayableBeatmap(Ruleset.Value);
+
         private class OutlineBox : CompositeDrawable
         {
             public OutlineBox()

osu.Game/Users/User.cs

@@ -173,8 +173,27 @@ namespace osu.Game.Users
             public int Available;
         }
 
+        private UserStatistics statistics;
+
         [JsonProperty(@"statistics")]
-        public UserStatistics Statistics;
+        public UserStatistics Statistics
+        {
+            get => statistics ??= new UserStatistics();
+            set
+            {
+                if (statistics != null)
+                    // we may already have rank history populated
+                    value.RankHistory = statistics.RankHistory;
+
+                statistics = value;
+            }
+        }
+
+        [JsonProperty(@"rankHistory")]
+        private RankHistoryData rankHistory
+        {
+            set => statistics.RankHistory = value;
+        }
 
         public class RankHistoryData
         {
@@ -185,12 +204,6 @@ namespace osu.Game.Users
             public int[] Data;
         }
 
-        [JsonProperty(@"rankHistory")]
-        private RankHistoryData rankHistory
-        {
-            set => Statistics.RankHistory = value;
-        }
-
         [JsonProperty("badges")]
         public Badge[] Badges;
 

osu.Game/osu.Game.csproj

@@ -22,8 +22,8 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.6" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.331.0" />
-    <PackageReference Include="ppy.osu.Framework" Version="2020.401.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2020.403.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.403.0" />
     <PackageReference Include="Sentry" Version="2.1.1" />
     <PackageReference Include="SharpCompress" Version="0.24.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />

osu.iOS.props

@@ -70,8 +70,8 @@
     <Reference Include="System.Net.Http" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.331.0" />
-    <PackageReference Include="ppy.osu.Framework.iOS" Version="2020.401.0" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2020.403.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.403.0" />
   </ItemGroup>
   <!-- Xamarin.iOS does not automatically handle transitive dependencies from NuGet packages. -->
   <ItemGroup Label="Transitive Dependencies">
@@ -79,7 +79,7 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.6" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
-    <PackageReference Include="ppy.osu.Framework" Version="2020.401.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2020.403.0" />
     <PackageReference Include="SharpCompress" Version="0.24.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="SharpRaven" Version="2.4.0" />