Merge pull request #9195 from peppy/fix-multi-chat-history

Fix chat history not being loaded for multiplayer matches

.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>

CodeAnalysis/BannedSymbols.txt

@@ -4,3 +4,5 @@ M:System.ValueType.Equals(System.Object)~System.Boolean;Don't use object.Equals(
 M:System.Nullable`1.Equals(System.Object)~System.Boolean;Use == instead.
 T:System.IComparable;Don't use non-generic IComparable. Use generic version instead.
 M:osu.Framework.Graphics.Sprites.SpriteText.#ctor;Use OsuSpriteText.
+T:Microsoft.EntityFrameworkCore.Internal.EnumerableExtensions;Don't use internal extension methods.
+T:Microsoft.EntityFrameworkCore.Internal.TypeExtensions;Don't use internal extension methods.

Directory.Build.props

@@ -16,9 +16,9 @@
     <EmbeddedResource Include="Resources\**\*.*" />
   </ItemGroup>
   <ItemGroup Label="Code Analysis">
-    <PackageReference Include="Microsoft.CodeAnalysis.BannedApiAnalyzers" Version="2.9.8" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.CodeAnalysis.BannedApiAnalyzers" Version="3.0.0" PrivateAssets="All" />
     <AdditionalFiles Include="$(MSBuildThisFileDirectory)CodeAnalysis\BannedSymbols.txt" />
-    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.8" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="3.0.0" PrivateAssets="All" />
   </ItemGroup>
   <PropertyGroup Label="Code Analysis">
     <CodeAnalysisRuleSet>$(MSBuildThisFileDirectory)CodeAnalysis\osu.ruleset</CodeAnalysisRuleSet>

README.md

@@ -15,6 +15,8 @@ Rhythm is just a *click* away. The future of [osu!](https://osu.ppy.sh) and the
 
 This project is under heavy development, but is in a stable state. Users are encouraged to try it out and keep it installed alongside the stable *osu!* client. It will continue to evolve to the point of eventually replacing the existing stable client as an update.
 
+**IMPORTANT:** Gameplay mechanics (and other features which you may have come to know and love) are in a constant state of flux. Game balance and final quality-of-life passses come at the end of development, preceeded by experimentation and changes which may potentially **reduce playability or usability**. This is done in order to allow us to move forward as developers and designers more efficiently. If this offends you, please consider sticking to the stable releases of osu! (found on the website). We are not yet open to heated discussion over game mechanics and will not be using github as a forum for such discussions just yet.
+
 We are accepting bug reports (please report with as much detail as possible and follow the existing issue templates). Feature requests are also welcome, but understand that our focus is on completing the game to feature parity before adding new features. A few resources are available as starting points to getting involved and understanding the project:
 
 - Detailed release changelogs are available on the [official osu! site](https://osu.ppy.sh/home/changelog/lazer).

fastlane/Fastfile

@@ -97,7 +97,7 @@ platform :ios do
     changelog.gsub!('$BUILD_ID', options[:build])
 
     pilot(
-      wait_processing_interval: 1800,
+      wait_processing_interval: 900,
       changelog: changelog,
       groups: ['osu! supporters', 'public'],
       distribute_external: true,

global.json

@@ -5,6 +5,6 @@
     "version": "3.1.100"
   },
   "msbuild-sdks": {
-    "Microsoft.Build.Traversal": "2.0.24"
+    "Microsoft.Build.Traversal": "2.0.34"
   }
 }

osu.Android.props

@@ -51,7 +51,7 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.315.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.319.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.602.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.601.0" />
   </ItemGroup>
 </Project>

osu.Android/OsuGameAndroid.cs

@@ -18,7 +18,8 @@ namespace osu.Android
 
                 try
                 {
-                    string versionName = packageInfo.VersionCode.ToString();
+                    // todo: needs checking before play store redeploy.
+                    string versionName = packageInfo.VersionName;
                     // undo play store version garbling
                     return new Version(int.Parse(versionName.Substring(0, 4)), int.Parse(versionName.Substring(4, 4)), int.Parse(versionName.Substring(8, 1)));
                 }

osu.Desktop/OsuGameDesktop.cs

@@ -6,15 +6,14 @@ using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
+using Microsoft.Win32;
 using osu.Desktop.Overlays;
 using osu.Framework.Platform;
 using osu.Game;
 using osuTK.Input;
-using Microsoft.Win32;
 using osu.Desktop.Updater;
 using osu.Framework;
 using osu.Framework.Logging;
-using osu.Framework.Platform.Windows;
 using osu.Framework.Screens;
 using osu.Game.Screens.Menu;
 using osu.Game.Updater;
@@ -37,7 +36,11 @@ namespace osu.Desktop
             try
             {
                 if (Host is DesktopGameHost desktopHost)
-                    return new StableStorage(desktopHost);
+                {
+                    string stablePath = getStableInstallPath();
+                    if (!string.IsNullOrEmpty(stablePath))
+                        return new DesktopStorage(stablePath, desktopHost);
+                }
             }
             catch (Exception)
             {
@@ -47,6 +50,35 @@ namespace osu.Desktop
             return null;
         }
 
+        private string getStableInstallPath()
+        {
+            static bool checkExists(string p) => Directory.Exists(Path.Combine(p, "Songs"));
+
+            string stableInstallPath;
+
+            try
+            {
+                using (RegistryKey key = Registry.ClassesRoot.OpenSubKey("osu"))
+                    stableInstallPath = key?.OpenSubKey(@"shell\open\command")?.GetValue(string.Empty).ToString().Split('"')[1].Replace("osu!.exe", "");
+
+                if (checkExists(stableInstallPath))
+                    return stableInstallPath;
+            }
+            catch
+            {
+            }
+
+            stableInstallPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), @"osu!");
+            if (checkExists(stableInstallPath))
+                return stableInstallPath;
+
+            stableInstallPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".osu");
+            if (checkExists(stableInstallPath))
+                return stableInstallPath;
+
+            return null;
+        }
+
         protected override UpdateManager CreateUpdateManager()
         {
             switch (RuntimeInfo.OS)
@@ -111,45 +143,5 @@ namespace osu.Desktop
 
             Task.Factory.StartNew(() => Import(filePaths), TaskCreationOptions.LongRunning);
         }
-
-        /// <summary>
-        /// A method of accessing an osu-stable install in a controlled fashion.
-        /// </summary>
-        private class StableStorage : WindowsStorage
-        {
-            protected override string LocateBasePath()
-            {
-                static bool checkExists(string p) => Directory.Exists(Path.Combine(p, "Songs"));
-
-                string stableInstallPath;
-
-                try
-                {
-                    using (RegistryKey key = Registry.ClassesRoot.OpenSubKey("osu"))
-                        stableInstallPath = key?.OpenSubKey(@"shell\open\command")?.GetValue(string.Empty).ToString().Split('"')[1].Replace("osu!.exe", "");
-
-                    if (checkExists(stableInstallPath))
-                        return stableInstallPath;
-                }
-                catch
-                {
-                }
-
-                stableInstallPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), @"osu!");
-                if (checkExists(stableInstallPath))
-                    return stableInstallPath;
-
-                stableInstallPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".osu");
-                if (checkExists(stableInstallPath))
-                    return stableInstallPath;
-
-                return null;
-            }
-
-            public StableStorage(DesktopGameHost host)
-                : base(string.Empty, host)
-            {
-            }
-        }
     }
 }

osu.Desktop/Program.cs

@@ -33,13 +33,11 @@ namespace osu.Desktop
                     if (args.Length > 0 && args[0].Contains('.')) // easy way to check for a file import in args
                     {
                         var importer = new ArchiveImportIPCChannel(host);
-                        // Restore the cwd so relative paths given at the command line work correctly
-                        Directory.SetCurrentDirectory(cwd);
 
                         foreach (var file in args)
                         {
                             Console.WriteLine(@"Importing {0}", file);
-                            if (!importer.ImportAsync(Path.GetFullPath(file)).Wait(3000))
+                            if (!importer.ImportAsync(Path.GetFullPath(file, cwd)).Wait(3000))
                                 throw new TimeoutException(@"IPC took too long to send");
                         }
 

osu.Desktop/Updater/SquirrelUpdateManager.cs

@@ -43,7 +43,7 @@ namespace osu.Desktop.Updater
 
         private async void checkForUpdateAsync(bool useDeltaPatching = true, UpdateProgressNotification notification = null)
         {
-            //should we schedule a retry on completion of this check?
+            // should we schedule a retry on completion of this check?
             bool scheduleRecheck = true;
 
             try
@@ -52,7 +52,7 @@ namespace osu.Desktop.Updater
 
                 var info = await updateManager.CheckForUpdate(!useDeltaPatching);
                 if (info.ReleasesToApply.Count == 0)
-                    //no updates available. bail and retry later.
+                    // no updates available. bail and retry later.
                     return;
 
                 if (notification == null)
@@ -81,8 +81,8 @@ namespace osu.Desktop.Updater
                     {
                         logger.Add(@"delta patching failed; will attempt full download!");
 
-                        //could fail if deltas are unavailable for full update path (https://github.com/Squirrel/Squirrel.Windows/issues/959)
-                        //try again without deltas.
+                        // could fail if deltas are unavailable for full update path (https://github.com/Squirrel/Squirrel.Windows/issues/959)
+                        // try again without deltas.
                         checkForUpdateAsync(false, notification);
                         scheduleRecheck = false;
                     }
@@ -101,7 +101,7 @@ namespace osu.Desktop.Updater
             {
                 if (scheduleRecheck)
                 {
-                    //check again in 30 minutes.
+                    // check again in 30 minutes.
                     Scheduler.AddDelayed(() => checkForUpdateAsync(), 60000 * 30);
                 }
             }

osu.Game.Benchmarks/BenchmarkBeatmapParsing.cs

@@ -8,7 +8,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.IO;
 using osu.Game.IO.Archives;
-using osu.Game.Resources;
+using osu.Game.Tests.Resources;
 
 namespace osu.Game.Benchmarks
 {
@@ -18,8 +18,8 @@ namespace osu.Game.Benchmarks
 
         public override void SetUp()
         {
-            using (var resources = new DllResourceStore(OsuResources.ResourceAssembly))
-            using (var archive = resources.GetStream("Beatmaps/241526 Soleily - Renatus.osz"))
+            using (var resources = new DllResourceStore(typeof(TestResources).Assembly))
+            using (var archive = resources.GetStream("Resources/Archives/241526 Soleily - Renatus.osz"))
             using (var reader = new ZipArchiveReader(archive))
                 reader.GetStream("Soleily - Renatus (Gamu) [Insane].osu").CopyTo(beatmapStream);
         }

osu.Game.Benchmarks/osu.Game.Benchmarks.csproj

@@ -7,12 +7,13 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.12.0" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.12.1" />
     <PackageReference Include="nunit" Version="3.12.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.15.1" />
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\osu.Game.Tests\osu.Game.Tests.csproj" />
     <ProjectReference Include="..\osu.Game\osu.Game.csproj" />
   </ItemGroup>
 

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

@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Catch.Tests
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Catch";
 
-        [TestCase(4.2058561036909863d, "diffcalc-test")]
+        [TestCase(4.050601681491468d, "diffcalc-test")]
         public void Test(double expected, string name)
             => base.Test(expected, name);
 

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

@@ -0,0 +1,36 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.IO.Stores;
+using osu.Game.Rulesets.Catch.Skinning;
+using osu.Game.Skinning;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    [TestFixture]
+    public class CatchSkinColourDecodingTest
+    {
+        [Test]
+        public void TestCatchSkinColourDecoding()
+        {
+            var store = new NamespacedResourceStore<byte[]>(new DllResourceStore(GetType().Assembly), "Resources/special-skin");
+            var rawSkin = new TestLegacySkin(new SkinInfo { Name = "special-skin" }, store);
+            var skin = new CatchLegacySkinTransformer(rawSkin);
+
+            Assert.AreEqual(new Color4(232, 185, 35, 255), skin.GetConfig<CatchSkinColour, Color4>(CatchSkinColour.HyperDash)?.Value);
+            Assert.AreEqual(new Color4(232, 74, 35, 255), skin.GetConfig<CatchSkinColour, Color4>(CatchSkinColour.HyperDashAfterImage)?.Value);
+            Assert.AreEqual(new Color4(0, 255, 255, 255), skin.GetConfig<CatchSkinColour, Color4>(CatchSkinColour.HyperDashFruit)?.Value);
+        }
+
+        private class TestLegacySkin : LegacySkin
+        {
+            public TestLegacySkin(SkinInfo skin, IResourceStore<byte[]> storage)
+                // Bypass LegacySkinResourceStore to avoid returning null for retrieving files due to bad skin info (SkinInfo.Files = null).
+                : base(skin, storage, null, "skin.ini")
+            {
+            }
+        }
+    }
+}

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

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

osu.Game.Rulesets.Catch.Tests/Resources/special-skin/skin.ini

@@ -0,0 +1,4 @@
+[CatchTheBeat]
+HyperDash: 232,185,35
+HyperDashFruit: 0,255,255
+HyperDashAfterImage: 232,74,35

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

@@ -1,13 +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;
-using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
-using osu.Game.Rulesets.Catch.Objects.Drawables;
-using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Catch.Tests
@@ -15,17 +11,6 @@ namespace osu.Game.Rulesets.Catch.Tests
     [TestFixture]
     public class TestSceneBananaShower : PlayerTestScene
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[]
-        {
-            typeof(BananaShower),
-            typeof(Banana),
-            typeof(DrawableBananaShower),
-            typeof(DrawableBanana),
-
-            typeof(CatchRuleset),
-            typeof(DrawableCatchRuleset),
-        };
-
         public TestSceneBananaShower()
             : base(new CatchRuleset())
         {

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

@@ -4,26 +4,18 @@
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Game.Rulesets.Catch.UI;
-using osu.Game.Tests.Visual;
-using System;
-using System.Collections.Generic;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
-    public class TestSceneCatcher : SkinnableTestScene
+    public class TestSceneCatcher : CatchSkinnableTestScene
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[]
-        {
-            typeof(CatcherArea),
-            typeof(CatcherSprite)
-        };
-
         [BackgroundDependencyLoader]
         private void load()
         {
-            SetContents(() => new Catcher
+            SetContents(() => new Catcher(new Container())
             {
                 RelativePositionAxes = Axes.None,
                 Anchor = Anchor.Centre,

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

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

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

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
@@ -22,15 +21,6 @@ namespace osu.Game.Rulesets.Catch.Tests
 {
     public class TestSceneDrawableHitObjects : OsuTestScene
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[]
-        {
-            typeof(Catcher),
-            typeof(DrawableCatchRuleset),
-            typeof(DrawableFruit),
-            typeof(DrawableJuiceStream),
-            typeof(DrawableBanana)
-        };
-
         private DrawableCatchRuleset drawableRuleset;
         private double playfieldTime => drawableRuleset.Playfield.Time.Current;
 

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

@@ -1,9 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using NUnit.Framework;
 using osu.Game.Rulesets.Catch.Mods;
 
@@ -11,8 +8,6 @@ namespace osu.Game.Rulesets.Catch.Tests
 {
     public class TestSceneDrawableHitObjectsHidden : TestSceneDrawableHitObjects
     {
-        public override IReadOnlyList<Type> RequiredTypes => base.RequiredTypes.Concat(new[] { typeof(CatchModHidden) }).ToList();
-
         [SetUp]
         public void SetUp() => Schedule(() =>
         {

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

@@ -2,36 +2,17 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
-using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
-using osu.Game.Tests.Visual;
 using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
-    public class TestSceneFruitObjects : SkinnableTestScene
+    public class TestSceneFruitObjects : CatchSkinnableTestScene
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[]
-        {
-            typeof(CatchHitObject),
-            typeof(Fruit),
-            typeof(FruitPiece),
-            typeof(Droplet),
-            typeof(Banana),
-            typeof(BananaShower),
-            typeof(DrawableCatchHitObject),
-            typeof(DrawableFruit),
-            typeof(DrawableDroplet),
-            typeof(DrawableBanana),
-            typeof(DrawableBananaShower),
-            typeof(Pulp),
-        };
-
         protected override void LoadComplete()
         {
             base.LoadComplete();

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

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
@@ -18,11 +17,6 @@ namespace osu.Game.Rulesets.Catch.Tests
     [TestFixture]
     public class TestSceneHyperDash : PlayerTestScene
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[]
-        {
-            typeof(CatcherArea),
-        };
-
         public TestSceneHyperDash()
             : base(new CatchRuleset())
         {

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

@@ -0,0 +1,206 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Rulesets.Catch.Skinning;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Skinning;
+using osu.Game.Tests.Visual;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    public class TestSceneHyperDashColouring : OsuTestScene
+    {
+        [Resolved]
+        private SkinManager skins { get; set; }
+
+        [Test]
+        public void TestDefaultCatcherColour()
+        {
+            var skin = new TestSkin();
+
+            checkHyperDashCatcherColour(skin, Catcher.DEFAULT_HYPER_DASH_COLOUR);
+        }
+
+        [Test]
+        public void TestCustomCatcherColour()
+        {
+            var skin = new TestSkin
+            {
+                HyperDashColour = Color4.Goldenrod
+            };
+
+            checkHyperDashCatcherColour(skin, skin.HyperDashColour);
+        }
+
+        [Test]
+        public void TestCustomEndGlowColour()
+        {
+            var skin = new TestSkin
+            {
+                HyperDashAfterImageColour = Color4.Lime
+            };
+
+            checkHyperDashCatcherColour(skin, Catcher.DEFAULT_HYPER_DASH_COLOUR, skin.HyperDashAfterImageColour);
+        }
+
+        [Test]
+        public void TestCustomEndGlowColourPriority()
+        {
+            var skin = new TestSkin
+            {
+                HyperDashColour = Color4.Goldenrod,
+                HyperDashAfterImageColour = Color4.Lime
+            };
+
+            checkHyperDashCatcherColour(skin, skin.HyperDashColour, skin.HyperDashAfterImageColour);
+        }
+
+        [Test]
+        public void TestDefaultFruitColour()
+        {
+            var skin = new TestSkin();
+
+            checkHyperDashFruitColour(skin, Catcher.DEFAULT_HYPER_DASH_COLOUR);
+        }
+
+        [Test]
+        public void TestCustomFruitColour()
+        {
+            var skin = new TestSkin
+            {
+                HyperDashFruitColour = Color4.Cyan
+            };
+
+            checkHyperDashFruitColour(skin, skin.HyperDashFruitColour);
+        }
+
+        [Test]
+        public void TestCustomFruitColourPriority()
+        {
+            var skin = new TestSkin
+            {
+                HyperDashColour = Color4.Goldenrod,
+                HyperDashFruitColour = Color4.Cyan
+            };
+
+            checkHyperDashFruitColour(skin, skin.HyperDashFruitColour);
+        }
+
+        [Test]
+        public void TestFruitColourFallback()
+        {
+            var skin = new TestSkin
+            {
+                HyperDashColour = Color4.Goldenrod
+            };
+
+            checkHyperDashFruitColour(skin, skin.HyperDashColour);
+        }
+
+        private void checkHyperDashCatcherColour(ISkin skin, Color4 expectedCatcherColour, Color4? expectedEndGlowColour = null)
+        {
+            CatcherArea catcherArea = null;
+            CatcherTrailDisplay trails = null;
+
+            AddStep("create hyper-dashing catcher", () =>
+            {
+                Child = setupSkinHierarchy(catcherArea = new CatcherArea
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Scale = new Vector2(4f),
+                }, skin);
+
+                trails = catcherArea.OfType<CatcherTrailDisplay>().Single();
+                catcherArea.MovableCatcher.SetHyperDashState(2);
+            });
+
+            AddUntilStep("catcher colour is correct", () => catcherArea.MovableCatcher.Colour == expectedCatcherColour);
+
+            AddAssert("catcher trails colours are correct", () => trails.HyperDashTrailsColour == expectedCatcherColour);
+            AddAssert("catcher end-glow colours are correct", () => trails.EndGlowSpritesColour == (expectedEndGlowColour ?? expectedCatcherColour));
+
+            AddStep("finish hyper-dashing", () =>
+            {
+                catcherArea.MovableCatcher.SetHyperDashState(1);
+                catcherArea.MovableCatcher.FinishTransforms();
+            });
+
+            AddAssert("catcher colour returned to white", () => catcherArea.MovableCatcher.Colour == Color4.White);
+        }
+
+        private void checkHyperDashFruitColour(ISkin skin, Color4 expectedColour)
+        {
+            DrawableFruit drawableFruit = null;
+
+            AddStep("create hyper-dash fruit", () =>
+            {
+                var fruit = new Fruit { HyperDashTarget = new Banana() };
+                fruit.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+                Child = setupSkinHierarchy(drawableFruit = new DrawableFruit(fruit)
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Scale = new Vector2(4f),
+                }, skin);
+            });
+
+            AddAssert("hyper-dash colour is correct", () => checkLegacyFruitHyperDashColour(drawableFruit, expectedColour));
+        }
+
+        private Drawable setupSkinHierarchy(Drawable child, ISkin skin)
+        {
+            var legacySkinProvider = new SkinProvidingContainer(skins.GetSkin(DefaultLegacySkin.Info));
+            var testSkinProvider = new SkinProvidingContainer(skin);
+            var legacySkinTransformer = new SkinProvidingContainer(new CatchLegacySkinTransformer(testSkinProvider));
+
+            return legacySkinProvider
+                .WithChild(testSkinProvider
+                    .WithChild(legacySkinTransformer
+                        .WithChild(child)));
+        }
+
+        private bool checkLegacyFruitHyperDashColour(DrawableFruit fruit, Color4 expectedColour) =>
+            fruit.ChildrenOfType<SkinnableDrawable>().First().Drawable.ChildrenOfType<Sprite>().Any(c => c.Colour == expectedColour);
+
+        private class TestSkin : LegacySkin
+        {
+            public Color4 HyperDashColour
+            {
+                get => Configuration.CustomColours[CatchSkinColour.HyperDash.ToString()];
+                set => Configuration.CustomColours[CatchSkinColour.HyperDash.ToString()] = value;
+            }
+
+            public Color4 HyperDashAfterImageColour
+            {
+                get => Configuration.CustomColours[CatchSkinColour.HyperDashAfterImage.ToString()];
+                set => Configuration.CustomColours[CatchSkinColour.HyperDashAfterImage.ToString()] = value;
+            }
+
+            public Color4 HyperDashFruitColour
+            {
+                get => Configuration.CustomColours[CatchSkinColour.HyperDashFruit.ToString()];
+                set => Configuration.CustomColours[CatchSkinColour.HyperDashFruit.ToString()] = value;
+            }
+
+            public TestSkin()
+                : base(new SkinInfo(), null, null, string.Empty)
+            {
+            }
+        }
+    }
+}

osu.Game.Rulesets.Catch.Tests/osu.Game.Rulesets.Catch.Tests.csproj

@@ -2,7 +2,7 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.6.1" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.15.1" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapConverter.cs

@@ -28,7 +28,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
 
             switch (obj)
             {
-                case IHasCurve curveData:
+                case IHasPathWithRepeats curveData:
                     return new JuiceStream
                     {
                         StartTime = obj.StartTime,
@@ -42,7 +42,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                         LegacyLastTickOffset = (obj as IHasLegacyLastTickOffset)?.LegacyLastTickOffset ?? 0
                     }.Yield();
 
-                case IHasEndTime endTime:
+                case IHasDuration endTime:
                     return new BananaShower
                     {
                         StartTime = obj.StartTime,

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -48,7 +48,7 @@ namespace osu.Game.Rulesets.Catch
             new KeyBinding(InputKey.Shift, CatchAction.Dash),
         };
 
-        public override IEnumerable<Mod> ConvertLegacyMods(LegacyMods mods)
+        public override IEnumerable<Mod> ConvertFromLegacyMods(LegacyMods mods)
         {
             if (mods.HasFlag(LegacyMods.Nightcore))
                 yield return new CatchModNightcore();
@@ -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/Difficulty/CatchDifficultyCalculator.cs

@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 {
     public class CatchDifficultyCalculator : DifficultyCalculator
     {
-        private const double star_scaling_factor = 0.145;
+        private const double star_scaling_factor = 0.153;
 
         protected override int SectionLength => 750;
 
@@ -71,11 +71,10 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
         protected override Skill[] CreateSkills(IBeatmap beatmap)
         {
-            using (var catcher = new Catcher(beatmap.BeatmapInfo.BaseDifficulty))
-            {
-                halfCatcherWidth = catcher.CatchWidth * 0.5f;
-                halfCatcherWidth *= 0.8f; // We're only using 80% of the catcher's width to simulate imperfect gameplay.
-            }
+            halfCatcherWidth = Catcher.CalculateCatchWidth(beatmap.BeatmapInfo.BaseDifficulty) * 0.5f;
+
+            // For circle sizes above 5.5, reduce the catcher width further to simulate imperfect gameplay.
+            halfCatcherWidth *= 1 - (Math.Max(0, beatmap.BeatmapInfo.BaseDifficulty.CircleSize - 5.5f) * 0.0625f);
 
             return new Skill[]
             {

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

@@ -4,12 +4,12 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Extensions;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
-using osu.Game.Scoring.Legacy;
 
 namespace osu.Game.Rulesets.Catch.Difficulty
 {
@@ -34,11 +34,11 @@ namespace osu.Game.Rulesets.Catch.Difficulty
         {
             mods = Score.Mods;
 
-            fruitsHit = Score?.GetCount300() ?? Score.Statistics[HitResult.Perfect];
-            ticksHit = Score?.GetCount100() ?? 0;
-            tinyTicksHit = Score?.GetCount50() ?? 0;
-            tinyTicksMissed = Score?.GetCountKatu() ?? 0;
-            misses = Score.Statistics[HitResult.Miss];
+            fruitsHit = Score.Statistics.GetOrDefault(HitResult.Perfect);
+            ticksHit = Score.Statistics.GetOrDefault(HitResult.LargeTickHit);
+            tinyTicksHit = Score.Statistics.GetOrDefault(HitResult.SmallTickHit);
+            tinyTicksMissed = Score.Statistics.GetOrDefault(HitResult.SmallTickMiss);
+            misses = Score.Statistics.GetOrDefault(HitResult.Miss);
 
             // Don't count scores made with supposedly unranked mods
             if (mods.Any(m => !m.Ranked))
@@ -52,8 +52,8 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
             // Longer maps are worth more
             double lengthBonus =
-                0.95 + 0.4 * Math.Min(1.0, numTotalHits / 3000.0) +
-                (numTotalHits > 3000 ? Math.Log10(numTotalHits / 3000.0) * 0.5 : 0.0);
+                0.95 + 0.3 * Math.Min(1.0, numTotalHits / 2500.0) +
+                (numTotalHits > 2500 ? Math.Log10(numTotalHits / 2500.0) * 0.475 : 0.0);
 
             // Longer maps are worth more
             value *= lengthBonus;
@@ -63,19 +63,28 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
             // Combo scaling
             if (Attributes.MaxCombo > 0)
-                value *= Math.Min(Math.Pow(Attributes.MaxCombo, 0.8) / Math.Pow(Attributes.MaxCombo, 0.8), 1.0);
+                value *= Math.Min(Math.Pow(Score.MaxCombo, 0.8) / Math.Pow(Attributes.MaxCombo, 0.8), 1.0);
 
+            double approachRate = Attributes.ApproachRate;
             double approachRateFactor = 1.0;
-            if (Attributes.ApproachRate > 9.0)
-                approachRateFactor += 0.1 * (Attributes.ApproachRate - 9.0); // 10% for each AR above 9
-            else if (Attributes.ApproachRate < 8.0)
-                approachRateFactor += 0.025 * (8.0 - Attributes.ApproachRate); // 2.5% for each AR below 8
+            if (approachRate > 9.0)
+                approachRateFactor += 0.1 * (approachRate - 9.0); // 10% for each AR above 9
+            if (approachRate > 10.0)
+                approachRateFactor += 0.1 * (approachRate - 10.0); // Additional 10% at AR 11, 30% total
+            else if (approachRate < 8.0)
+                approachRateFactor += 0.025 * (8.0 - approachRate); // 2.5% for each AR below 8
 
             value *= approachRateFactor;
 
             if (mods.Any(m => m is ModHidden))
-                // Hiddens gives nothing on max approach rate, and more the lower it is
+            {
                 value *= 1.05 + 0.075 * (10.0 - Math.Min(10.0, Attributes.ApproachRate)); // 7.5% for each AR below 10
+                // Hiddens gives almost nothing on max approach rate, and more the lower it is
+                if (approachRate <= 10.0)
+                    value *= 1.05 + 0.075 * (10.0 - approachRate); // 7.5% for each AR below 10
+                else if (approachRate > 10.0)
+                    value *= 1.01 + 0.04 * (11.0 - Math.Min(11.0, approachRate)); // 5% at AR 10, 1% at AR 11
+            }
 
             if (mods.Any(m => m is ModFlashlight))
                 // Apply length bonus again if flashlight is on simply because it becomes a lot harder on longer maps.
@@ -91,7 +100,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty
             return value;
         }
 
-        private float accuracy() => totalHits() == 0 ? 0 : Math.Clamp((float)totalSuccessfulHits() / totalHits(), 0, 1);
+        private double accuracy() => totalHits() == 0 ? 0 : Math.Clamp((double)totalSuccessfulHits() / totalHits(), 0, 1);
         private int totalHits() => tinyTicksHit + ticksHit + fruitsHit + misses + tinyTicksMissed;
         private int totalSuccessfulHits() => tinyTicksHit + ticksHit + fruitsHit;
         private int totalComboHits() => misses + ticksHit + fruitsHit;

osu.Game.Rulesets.Catch/Difficulty/Preprocessing/CatchDifficultyHitObject.cs

@@ -21,10 +21,12 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Preprocessing
         public readonly float LastNormalizedPosition;
 
         /// <summary>
-        /// Milliseconds elapsed since the start time of the previous <see cref="CatchDifficultyHitObject"/>, with a minimum of 25ms.
+        /// Milliseconds elapsed since the start time of the previous <see cref="CatchDifficultyHitObject"/>, with a minimum of 40ms.
         /// </summary>
         public readonly double StrainTime;
 
+        public readonly double ClockRate;
+
         public CatchDifficultyHitObject(HitObject hitObject, HitObject lastObject, double clockRate, float halfCatcherWidth)
             : base(hitObject, lastObject, clockRate)
         {
@@ -34,8 +36,9 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Preprocessing
             NormalizedPosition = BaseObject.X * CatchPlayfield.BASE_WIDTH * scalingFactor;
             LastNormalizedPosition = LastObject.X * CatchPlayfield.BASE_WIDTH * scalingFactor;
 
-            // Every strain interval is hard capped at the equivalent of 600 BPM streaming speed as a safety measure
-            StrainTime = Math.Max(25, DeltaTime);
+            // Every strain interval is hard capped at the equivalent of 375 BPM streaming speed as a safety measure
+            StrainTime = Math.Max(40, DeltaTime);
+            ClockRate = clockRate;
         }
     }
 }

osu.Game.Rulesets.Catch/Difficulty/Skills/Movement.cs

@@ -13,9 +13,9 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
     {
         private const float absolute_player_positioning_error = 16f;
         private const float normalized_hitobject_radius = 41.0f;
-        private const double direction_change_bonus = 12.5;
+        private const double direction_change_bonus = 21.0;
 
-        protected override double SkillMultiplier => 850;
+        protected override double SkillMultiplier => 900;
         protected override double StrainDecayBase => 0.2;
 
         protected override double DecayWeight => 0.94;
@@ -24,6 +24,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
 
         private float? lastPlayerPosition;
         private float lastDistanceMoved;
+        private double lastStrainTime;
 
         public Movement(float halfCatcherWidth)
         {
@@ -45,47 +46,47 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
 
             float distanceMoved = playerPosition - lastPlayerPosition.Value;
 
-            double distanceAddition = Math.Pow(Math.Abs(distanceMoved), 1.3) / 500;
-            double sqrtStrain = Math.Sqrt(catchCurrent.StrainTime);
+            double weightedStrainTime = catchCurrent.StrainTime + 13 + (3 / catchCurrent.ClockRate);
 
-            double bonus = 0;
+            double distanceAddition = (Math.Pow(Math.Abs(distanceMoved), 1.3) / 510);
+            double sqrtStrain = Math.Sqrt(weightedStrainTime);
 
-            // Direction changes give an extra point!
+            double edgeDashBonus = 0;
+
+            // Direction change bonus.
             if (Math.Abs(distanceMoved) > 0.1)
             {
                 if (Math.Abs(lastDistanceMoved) > 0.1 && Math.Sign(distanceMoved) != Math.Sign(lastDistanceMoved))
                 {
-                    double bonusFactor = Math.Min(absolute_player_positioning_error, Math.Abs(distanceMoved)) / absolute_player_positioning_error;
+                    double bonusFactor = Math.Min(50, Math.Abs(distanceMoved)) / 50;
+                    double antiflowFactor = Math.Max(Math.Min(70, Math.Abs(lastDistanceMoved)) / 70, 0.38);
 
-                    distanceAddition += direction_change_bonus / sqrtStrain * bonusFactor;
-
-                    // Bonus for tougher direction switches and "almost" hyperdashes at this point
-                    if (catchCurrent.LastObject.DistanceToHyperDash <= 10 / CatchPlayfield.BASE_WIDTH)
-                        bonus = 0.3 * bonusFactor;
+                    distanceAddition += direction_change_bonus / Math.Sqrt(lastStrainTime + 16) * bonusFactor * antiflowFactor * Math.Max(1 - Math.Pow(weightedStrainTime / 1000, 3), 0);
                 }
 
                 // Base bonus for every movement, giving some weight to streams.
-                distanceAddition += 7.5 * Math.Min(Math.Abs(distanceMoved), normalized_hitobject_radius * 2) / (normalized_hitobject_radius * 6) / sqrtStrain;
+                distanceAddition += 12.5 * Math.Min(Math.Abs(distanceMoved), normalized_hitobject_radius * 2) / (normalized_hitobject_radius * 6) / sqrtStrain;
             }
 
-            // Bonus for "almost" hyperdashes at corner points
-            if (catchCurrent.LastObject.DistanceToHyperDash <= 10.0f / CatchPlayfield.BASE_WIDTH)
+            // Bonus for edge dashes.
+            if (catchCurrent.LastObject.DistanceToHyperDash <= 20.0f / CatchPlayfield.BASE_WIDTH)
             {
                 if (!catchCurrent.LastObject.HyperDash)
-                    bonus += 1.0;
+                    edgeDashBonus += 5.7;
                 else
                 {
                     // After a hyperdash we ARE in the correct position. Always!
                     playerPosition = catchCurrent.NormalizedPosition;
                 }
 
-                distanceAddition *= 1.0 + bonus * ((10 - catchCurrent.LastObject.DistanceToHyperDash * CatchPlayfield.BASE_WIDTH) / 10);
+                distanceAddition *= 1.0 + edgeDashBonus * ((20 - catchCurrent.LastObject.DistanceToHyperDash * CatchPlayfield.BASE_WIDTH) / 20) * Math.Pow((Math.Min(catchCurrent.StrainTime * catchCurrent.ClockRate, 265) / 265), 1.5); // Edge Dashes are easier at lower ms values
             }
 
             lastPlayerPosition = playerPosition;
             lastDistanceMoved = distanceMoved;
+            lastStrainTime = catchCurrent.StrainTime;
 
-            return distanceAddition / catchCurrent.StrainTime;
+            return distanceAddition / weightedStrainTime;
         }
     }
 }

osu.Game.Rulesets.Catch/Mods/CatchModDifficultyAdjust.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.Linq;
 using osu.Framework.Bindables;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
@@ -30,6 +31,22 @@ namespace osu.Game.Rulesets.Catch.Mods
             Value = 5,
         };
 
+        public override string SettingDescription
+        {
+            get
+            {
+                string circleSize = CircleSize.IsDefault ? string.Empty : $"CS {CircleSize.Value:N1}";
+                string approachRate = ApproachRate.IsDefault ? string.Empty : $"AR {ApproachRate.Value:N1}";
+
+                return string.Join(", ", new[]
+                {
+                    circleSize,
+                    base.SettingDescription,
+                    approachRate
+                }.Where(s => !string.IsNullOrEmpty(s)));
+            }
+        }
+
         protected override void TransferSettings(BeatmapDifficulty difficulty)
         {
             base.TransferSettings(difficulty);

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

@@ -9,17 +9,26 @@ using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play;
 using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Mods
 {
-    public class CatchModRelax : ModRelax, IApplicableToDrawableRuleset<CatchHitObject>
+    public class CatchModRelax : ModRelax, IApplicableToDrawableRuleset<CatchHitObject>, IApplicableToPlayer
     {
         public override string Description => @"Use the mouse to control the catcher.";
 
+        private DrawableRuleset<CatchHitObject> drawableRuleset;
+
         public void ApplyToDrawableRuleset(DrawableRuleset<CatchHitObject> drawableRuleset)
         {
-            drawableRuleset.Cursor.Add(new MouseInputHelper((CatchPlayfield)drawableRuleset.Playfield));
+            this.drawableRuleset = drawableRuleset;
+        }
+
+        public void ApplyToPlayer(Player player)
+        {
+            if (!drawableRuleset.HasReplayLoaded.Value)
+                drawableRuleset.Cursor.Add(new MouseInputHelper((CatchPlayfield)drawableRuleset.Playfield));
         }
 
         private class MouseInputHelper : Drawable, IKeyBindingHandler<CatchAction>, IRequireHighFrequencyMousePosition
@@ -34,7 +43,7 @@ namespace osu.Game.Rulesets.Catch.Mods
                 RelativeSizeAxes = Axes.Both;
             }
 
-            //disable keyboard controls
+            // disable keyboard controls
             public bool OnPressed(CatchAction action) => true;
 
             public void OnReleased(CatchAction action)

osu.Game.Rulesets.Catch/Objects/BananaShower.cs

@@ -1,12 +1,13 @@
 // 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.Threading;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Rulesets.Catch.Objects
 {
-    public class BananaShower : CatchHitObject, IHasEndTime
+    public class BananaShower : CatchHitObject, IHasDuration
     {
         public override FruitVisualRepresentation VisualRepresentation => FruitVisualRepresentation.Banana;
 
@@ -14,13 +15,13 @@ namespace osu.Game.Rulesets.Catch.Objects
 
         public override Judgement CreateJudgement() => new IgnoreJudgement();
 
-        protected override void CreateNestedHitObjects()
+        protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
         {
-            base.CreateNestedHitObjects();
-            createBananas();
+            base.CreateNestedHitObjects(cancellationToken);
+            createBananas(cancellationToken);
         }
 
-        private void createBananas()
+        private void createBananas(CancellationToken cancellationToken)
         {
             double spacing = Duration;
             while (spacing > 100)
@@ -31,6 +32,8 @@ namespace osu.Game.Rulesets.Catch.Objects
 
             for (double i = StartTime; i <= EndTime; i += spacing)
             {
+                cancellationToken.ThrowIfCancellationRequested();
+
                 AddNested(new Banana
                 {
                     Samples = Samples,

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

@@ -70,6 +70,8 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
 
         public float DisplayRadius => DrawSize.X / 2 * Scale.X * HitObject.Scale;
 
+        protected override float SamplePlaybackPosition => HitObject.X;
+
         protected DrawableCatchHitObject(CatchHitObject hitObject)
             : base(hitObject)
         {

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

@@ -7,6 +7,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Objects.Drawables;
 using osuTK.Graphics;
 
@@ -67,7 +68,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
                     RelativeSizeAxes = Axes.Both,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    BorderColour = Color4.Red,
+                    BorderColour = Catcher.DEFAULT_HYPER_DASH_COLOUR,
                     BorderThickness = 12f * RADIUS_ADJUST,
                     Children = new Drawable[]
                     {
@@ -77,7 +78,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
                             Alpha = 0.3f,
                             Blending = BlendingParameters.Additive,
                             RelativeSizeAxes = Axes.Both,
-                            Colour = Color4.Red,
+                            Colour = Catcher.DEFAULT_HYPER_DASH_COLOUR,
                         }
                     }
                 });

osu.Game.Rulesets.Catch/Objects/JuiceStream.cs

@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
@@ -13,7 +14,7 @@ using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Rulesets.Catch.Objects
 {
-    public class JuiceStream : CatchHitObject, IHasCurve
+    public class JuiceStream : CatchHitObject, IHasPathWithRepeats
     {
         /// <summary>
         /// Positional distance that results in a duration of one second, before any speed adjustments.
@@ -45,9 +46,9 @@ namespace osu.Game.Rulesets.Catch.Objects
             TickDistance = scoringDistance / difficulty.SliderTickRate;
         }
 
-        protected override void CreateNestedHitObjects()
+        protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
         {
-            base.CreateNestedHitObjects();
+            base.CreateNestedHitObjects(cancellationToken);
 
             var dropletSamples = Samples.Select(s => new HitSampleInfo
             {
@@ -58,7 +59,7 @@ namespace osu.Game.Rulesets.Catch.Objects
 
             SliderEventDescriptor? lastEvent = null;
 
-            foreach (var e in SliderEventGenerator.Generate(StartTime, SpanDuration, Velocity, TickDistance, Path.Distance, this.SpanCount(), LegacyLastTickOffset))
+            foreach (var e in SliderEventGenerator.Generate(StartTime, SpanDuration, Velocity, TickDistance, Path.Distance, this.SpanCount(), LegacyLastTickOffset, cancellationToken))
             {
                 // generate tiny droplets since the last point
                 if (lastEvent != null)
@@ -73,6 +74,8 @@ namespace osu.Game.Rulesets.Catch.Objects
 
                         for (double t = timeBetweenTiny; t < sinceLastTick; t += timeBetweenTiny)
                         {
+                            cancellationToken.ThrowIfCancellationRequested();
+
                             AddNested(new TinyDroplet
                             {
                                 StartTime = t + lastEvent.Value.Time,
@@ -112,15 +115,15 @@ namespace osu.Game.Rulesets.Catch.Objects
             }
         }
 
-        public double EndTime
+        public float EndX => X + this.CurvePositionAt(1).X / CatchPlayfield.BASE_WIDTH;
+
+        public double Duration
         {
-            get => StartTime + this.SpanCount() * Path.Distance / Velocity;
+            get => this.SpanCount() * Path.Distance / Velocity;
             set => throw new System.NotSupportedException($"Adjust via {nameof(RepeatCount)} instead"); // can be implemented if/when needed.
         }
 
-        public float EndX => X + this.CurvePositionAt(1).X / CatchPlayfield.BASE_WIDTH;
-
-        public double Duration => EndTime - StartTime;
+        public double EndTime => StartTime + Duration;
 
         private readonly SliderPath path = new SliderPath();
 

osu.Game.Rulesets.Catch/Replays/CatchAutoGenerator.cs

@@ -55,7 +55,7 @@ namespace osu.Game.Rulesets.Catch.Replays
 
                 if (lastPosition - catcher_width_half < h.X && lastPosition + catcher_width_half > h.X)
                 {
-                    //we are already in the correct range.
+                    // we are already in the correct range.
                     lastTime = h.StartTime;
                     addFrame(h.StartTime, lastPosition);
                     return;
@@ -72,14 +72,14 @@ namespace osu.Game.Rulesets.Catch.Replays
                 }
                 else if (dashRequired)
                 {
-                    //we do a movement in two parts - the dash part then the normal part...
+                    // we do a movement in two parts - the dash part then the normal part...
                     double timeAtNormalSpeed = positionChange / movement_speed;
                     double timeWeNeedToSave = timeAtNormalSpeed - timeAvailable;
                     double timeAtDashSpeed = timeWeNeedToSave / 2;
 
                     float midPosition = (float)Interpolation.Lerp(lastPosition, h.X, (float)timeAtDashSpeed / timeAvailable);
 
-                    //dash movement
+                    // dash movement
                     addFrame(h.StartTime - timeAvailable + 1, lastPosition, true);
                     addFrame(h.StartTime - timeAvailable + timeAtDashSpeed, midPosition);
                     addFrame(h.StartTime, h.X);

osu.Game.Rulesets.Catch/Replays/CatchReplayFrame.cs

@@ -39,7 +39,7 @@ namespace osu.Game.Rulesets.Catch.Replays
             }
         }
 
-        public void ConvertFrom(LegacyReplayFrame currentFrame, IBeatmap beatmap, ReplayFrame lastFrame = null)
+        public void FromLegacy(LegacyReplayFrame currentFrame, IBeatmap beatmap, ReplayFrame lastFrame = null)
         {
             Position = currentFrame.Position.X / CatchPlayfield.BASE_WIDTH;
             Dashing = currentFrame.ButtonState == ReplayButtonState.Left1;
@@ -56,5 +56,14 @@ namespace osu.Game.Rulesets.Catch.Replays
                     Actions.Add(CatchAction.MoveLeft);
             }
         }
+
+        public LegacyReplayFrame ToLegacy(IBeatmap beatmap)
+        {
+            ReplayButtonState state = ReplayButtonState.None;
+
+            if (Actions.Contains(CatchAction.Dash)) state |= ReplayButtonState.Left1;
+
+            return new LegacyReplayFrame(Time, Position * CatchPlayfield.BASE_WIDTH, null, state);
+        }
     }
 }

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

@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Catch.Skinning
     {
         private readonly ISkin source;
 
-        public CatchLegacySkinTransformer(ISkinSource source)
+        public CatchLegacySkinTransformer(ISkin source)
         {
             this.source = source;
         }
@@ -65,6 +65,15 @@ namespace osu.Game.Rulesets.Catch.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)
+        {
+            switch (lookup)
+            {
+                case CatchSkinColour colour:
+                    return source.GetConfig<SkinCustomColourLookup, TValue>(new SkinCustomColourLookup(colour));
+            }
+
+            return source.GetConfig<TLookup, TValue>(lookup);
+        }
     }
 }

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

@@ -0,0 +1,23 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Game.Rulesets.Catch.Skinning
+{
+    public enum CatchSkinColour
+    {
+        /// <summary>
+        /// The colour to be used for the catcher while in hyper-dashing state.
+        /// </summary>
+        HyperDash,
+
+        /// <summary>
+        /// The colour to be used for fruits that grant the catcher the ability to hyper-dash.
+        /// </summary>
+        HyperDashFruit,
+
+        /// <summary>
+        /// The colour to be used for the "exploding" catcher sprite on beginning of hyper-dashing.
+        /// </summary>
+        HyperDashAfterImage,
+    }
+}

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

@@ -7,6 +7,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Skinning;
 using osuTK;
@@ -55,14 +56,16 @@ namespace osu.Game.Rulesets.Catch.Skinning
             {
                 var hyperDash = new Sprite
                 {
-                    Texture = skin.GetTexture(lookupName),
-                    Colour = Color4.Red,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     Blending = BlendingParameters.Additive,
                     Depth = 1,
                     Alpha = 0.7f,
-                    Scale = new Vector2(1.2f)
+                    Scale = new Vector2(1.2f),
+                    Texture = skin.GetTexture(lookupName),
+                    Colour = skin.GetConfig<CatchSkinColour, Color4>(CatchSkinColour.HyperDashFruit)?.Value ??
+                             skin.GetConfig<CatchSkinColour, Color4>(CatchSkinColour.HyperDash)?.Value ??
+                             Catcher.DEFAULT_HYPER_DASH_COLOUR,
                 };
 
                 AddInternal(hyperDash);

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

@@ -0,0 +1,26 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Catch.Replays;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.UI
+{
+    public class CatchReplayRecorder : ReplayRecorder<CatchAction>
+    {
+        private readonly CatchPlayfield playfield;
+
+        public CatchReplayRecorder(Replay target, CatchPlayfield playfield)
+            : base(target)
+        {
+            this.playfield = playfield;
+        }
+
+        protected override ReplayFrame HandleFrame(Vector2 mousePosition, List<CatchAction> actions, ReplayFrame previousFrame)
+            => new CatchReplayFrame(Time.Current, playfield.CatcherArea.MovableCatcher.X, actions.Contains(CatchAction.Dash), previousFrame as CatchReplayFrame);
+    }
+}

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

@@ -3,24 +3,37 @@
 
 using System;
 using System.Linq;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Rulesets.Catch.Skinning;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Skinning;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
-    public class Catcher : Container, IKeyBindingHandler<CatchAction>
+    public class Catcher : SkinReloadableDrawable, IKeyBindingHandler<CatchAction>
     {
+        /// <summary>
+        /// The default colour used to tint hyper-dash fruit, along with the moving catcher, its trail
+        /// and end glow/after-image during a hyper-dash.
+        /// </summary>
+        public static readonly Color4 DEFAULT_HYPER_DASH_COLOUR = Color4.Red;
+
+        /// <summary>
+        /// The duration between transitioning to hyper-dash state.
+        /// </summary>
+        public const double HYPER_DASH_TRANSITION_DURATION = 180;
+
         /// <summary>
         /// Whether we are hyper-dashing or not.
         /// </summary>
@@ -33,44 +46,42 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public Container ExplodingFruitTarget;
 
-        public Container AdditiveTarget;
+        [NotNull]
+        private readonly Container trailsTarget;
+
+        private CatcherTrailDisplay trails;
 
         public CatcherAnimationState CurrentState { get; private set; }
 
         /// <summary>
-        /// Width of the area that can be used to attempt catches during gameplay.
+        /// The width of the catcher which can receive fruit. Equivalent to "catchMargin" in osu-stable.
         /// </summary>
-        internal float CatchWidth => CatcherArea.CATCHER_SIZE * Math.Abs(Scale.X);
+        private const float allowed_catch_range = 0.8f;
 
-        protected bool Dashing
+        /// <summary>
+        /// The drawable catcher for <see cref="CurrentState"/>.
+        /// </summary>
+        internal Drawable CurrentDrawableCatcher => currentCatcher.Drawable;
+
+        private bool dashing;
+
+        public bool Dashing
         {
             get => dashing;
-            set
+            protected set
             {
                 if (value == dashing) return;
 
                 dashing = value;
 
-                Trail |= dashing;
+                updateTrailVisibility();
             }
         }
 
         /// <summary>
-        /// Activate or deactivate the trail. Will be automatically deactivated when conditions to keep the trail displayed are no longer met.
+        /// Width of the area that can be used to attempt catches during gameplay.
         /// </summary>
-        protected bool Trail
-        {
-            get => trail;
-            set
-            {
-                if (value == trail || AdditiveTarget == null) return;
-
-                trail = value;
-
-                if (Trail)
-                    beginTrail();
-            }
-        }
+        private readonly float catchWidth;
 
         private Container<DrawableHitObject> caughtFruit;
 
@@ -80,18 +91,19 @@ namespace osu.Game.Rulesets.Catch.UI
 
         private CatcherSprite currentCatcher;
 
+        private Color4 hyperDashColour = DEFAULT_HYPER_DASH_COLOUR;
+        private Color4 hyperDashEndGlowColour = DEFAULT_HYPER_DASH_COLOUR;
+
         private int currentDirection;
 
-        private bool dashing;
-
-        private bool trail;
-
         private double hyperDashModifier = 1;
         private int hyperDashDirection;
         private float hyperDashTargetPosition;
 
-        public Catcher(BeatmapDifficulty difficulty = null)
+        public Catcher([NotNull] Container trailsTarget, BeatmapDifficulty difficulty = null)
         {
+            this.trailsTarget = trailsTarget;
+
             RelativePositionAxes = Axes.X;
             X = 0.5f;
 
@@ -99,13 +111,15 @@ namespace osu.Game.Rulesets.Catch.UI
 
             Size = new Vector2(CatcherArea.CATCHER_SIZE);
             if (difficulty != null)
-                Scale = new Vector2(1.0f - 0.7f * (difficulty.CircleSize - 5) / 5);
+                Scale = calculateScale(difficulty);
+
+            catchWidth = CalculateCatchWidth(Scale);
         }
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            Children = new Drawable[]
+            InternalChildren = new Drawable[]
             {
                 caughtFruit = new Container<DrawableHitObject>
                 {
@@ -129,9 +143,31 @@ namespace osu.Game.Rulesets.Catch.UI
                 }
             };
 
+            trailsTarget.Add(trails = new CatcherTrailDisplay(this));
+
             updateCatcher();
         }
 
+        /// <summary>
+        /// Calculates the scale of the catcher based off the provided beatmap difficulty.
+        /// </summary>
+        private static Vector2 calculateScale(BeatmapDifficulty difficulty)
+            => new Vector2(1.0f - 0.7f * (difficulty.CircleSize - 5) / 5);
+
+        /// <summary>
+        /// Calculates the width of the area used for attempting catches in gameplay.
+        /// </summary>
+        /// <param name="scale">The scale of the catcher.</param>
+        internal static float CalculateCatchWidth(Vector2 scale)
+            => CatcherArea.CATCHER_SIZE * Math.Abs(scale.X) * allowed_catch_range;
+
+        /// <summary>
+        /// Calculates the width of the area used for attempting catches in gameplay.
+        /// </summary>
+        /// <param name="difficulty">The beatmap difficulty.</param>
+        internal static float CalculateCatchWidth(BeatmapDifficulty difficulty)
+            => CalculateCatchWidth(calculateScale(difficulty));
+
         /// <summary>
         /// Add a caught fruit to the catcher's stack.
         /// </summary>
@@ -141,14 +177,14 @@ namespace osu.Game.Rulesets.Catch.UI
             var ourRadius = fruit.DisplayRadius;
             float theirRadius = 0;
 
-            const float allowance = 6;
+            const float allowance = 10;
 
             while (caughtFruit.Any(f =>
                 f.LifetimeEnd == double.MaxValue &&
                 Vector2Extensions.Distance(f.Position, fruit.Position) < (ourRadius + (theirRadius = f.DrawSize.X / 2 * f.Scale.X)) / (allowance / 2)))
             {
                 var diff = (ourRadius + theirRadius) / allowance;
-                fruit.X += (RNG.NextSingle() - 0.5f) * 2 * diff;
+                fruit.X += (RNG.NextSingle() - 0.5f) * diff * 2;
                 fruit.Y -= RNG.NextSingle() * diff;
             }
 
@@ -156,7 +192,7 @@ namespace osu.Game.Rulesets.Catch.UI
 
             caughtFruit.Add(fruit);
 
-            Add(new HitExplosion(fruit)
+            AddInternal(new HitExplosion(fruit)
             {
                 X = fruit.X,
                 Scale = new Vector2(fruit.HitObject.Scale)
@@ -170,7 +206,7 @@ namespace osu.Game.Rulesets.Catch.UI
         /// <returns>Whether the catch is possible.</returns>
         public bool AttemptCatch(CatchHitObject fruit)
         {
-            var halfCatchWidth = CatchWidth * 0.5f;
+            var halfCatchWidth = catchWidth * 0.5f;
 
             // this stuff wil disappear once we move fruit to non-relative coordinate space in the future.
             var catchObjectPosition = fruit.X * CatchPlayfield.BASE_WIDTH;
@@ -211,8 +247,6 @@ namespace osu.Game.Rulesets.Catch.UI
         /// <param name="targetPosition">When this catcher crosses this position, this catcher ends hyper-dashing.</param>
         public void SetHyperDashState(double modifier = 1, float targetPosition = -1)
         {
-            const float hyper_dash_transition_length = 180;
-
             var wasHyperDashing = HyperDashing;
 
             if (modifier <= 1 || X == targetPosition)
@@ -221,11 +255,7 @@ namespace osu.Game.Rulesets.Catch.UI
                 hyperDashDirection = 0;
 
                 if (wasHyperDashing)
-                {
-                    this.FadeColour(Color4.White, hyper_dash_transition_length, Easing.OutQuint);
-                    this.FadeTo(1, hyper_dash_transition_length, Easing.OutQuint);
-                    Trail &= Dashing;
-                }
+                    runHyperDashStateTransition(false);
             }
             else
             {
@@ -235,20 +265,32 @@ namespace osu.Game.Rulesets.Catch.UI
 
                 if (!wasHyperDashing)
                 {
-                    this.FadeColour(Color4.OrangeRed, hyper_dash_transition_length, Easing.OutQuint);
-                    this.FadeTo(0.2f, hyper_dash_transition_length, Easing.OutQuint);
-                    Trail = true;
-
-                    var hyperDashEndGlow = createAdditiveSprite();
-
-                    hyperDashEndGlow.MoveToOffset(new Vector2(0, -10), 1200, Easing.In);
-                    hyperDashEndGlow.ScaleTo(hyperDashEndGlow.Scale * 0.95f).ScaleTo(hyperDashEndGlow.Scale * 1.2f, 1200, Easing.In);
-                    hyperDashEndGlow.FadeOut(1200);
-                    hyperDashEndGlow.Expire(true);
+                    trails.DisplayEndGlow();
+                    runHyperDashStateTransition(true);
                 }
             }
         }
 
+        private void runHyperDashStateTransition(bool hyperDashing)
+        {
+            trails.HyperDashTrailsColour = hyperDashColour;
+            trails.EndGlowSpritesColour = hyperDashEndGlowColour;
+            updateTrailVisibility();
+
+            if (hyperDashing)
+            {
+                this.FadeColour(hyperDashColour, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
+                this.FadeTo(0.2f, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
+            }
+            else
+            {
+                this.FadeColour(Color4.White, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
+                this.FadeTo(1f, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
+            }
+        }
+
+        private void updateTrailVisibility() => trails.DisplayTrail = Dashing || HyperDashing;
+
         public bool OnPressed(CatchAction action)
         {
             switch (action)
@@ -337,6 +379,21 @@ namespace osu.Game.Rulesets.Catch.UI
             });
         }
 
+        protected override void SkinChanged(ISkinSource skin, bool allowFallback)
+        {
+            base.SkinChanged(skin, allowFallback);
+
+            hyperDashColour =
+                skin.GetConfig<CatchSkinColour, Color4>(CatchSkinColour.HyperDash)?.Value ??
+                DEFAULT_HYPER_DASH_COLOUR;
+
+            hyperDashEndGlowColour =
+                skin.GetConfig<CatchSkinColour, Color4>(CatchSkinColour.HyperDashAfterImage)?.Value ??
+                hyperDashColour;
+
+            runHyperDashStateTransition(HyperDashing);
+        }
+
         protected override void Update()
         {
             base.Update();
@@ -379,23 +436,7 @@ namespace osu.Game.Rulesets.Catch.UI
             }
 
             currentCatcher.Show();
-            (currentCatcher.Drawable as IAnimation)?.GotoFrame(0);
-        }
-
-        private void beginTrail()
-        {
-            if (!dashing && !HyperDashing)
-            {
-                Trail = false;
-                return;
-            }
-
-            var additive = createAdditiveSprite();
-
-            additive.FadeTo(0.4f).FadeOut(800, Easing.OutQuint);
-            additive.Expire(true);
-
-            Scheduler.AddDelayed(beginTrail, HyperDashing ? 25 : 50);
+            (currentCatcher.Drawable as IFramedAnimation)?.GotoFrame(0);
         }
 
         private void updateState(CatcherAnimationState state)
@@ -407,25 +448,6 @@ namespace osu.Game.Rulesets.Catch.UI
             updateCatcher();
         }
 
-        private CatcherTrailSprite createAdditiveSprite()
-        {
-            var tex = (currentCatcher.Drawable as TextureAnimation)?.CurrentFrame ?? ((Sprite)currentCatcher.Drawable).Texture;
-
-            var sprite = new CatcherTrailSprite(tex)
-            {
-                Anchor = Anchor,
-                Scale = Scale,
-                Colour = HyperDashing ? Color4.Red : Color4.White,
-                Blending = BlendingParameters.Additive,
-                RelativePositionAxes = RelativePositionAxes,
-                Position = Position
-            };
-
-            AdditiveTarget?.Add(sprite);
-
-            return sprite;
-        }
-
         private void removeFromPlateWithTransform(DrawableHitObject fruit, Action<DrawableHitObject> action)
         {
             if (ExplodingFruitTarget != null)

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

@@ -33,10 +33,7 @@ namespace osu.Game.Rulesets.Catch.UI
         {
             RelativeSizeAxes = Axes.X;
             Height = CATCHER_SIZE;
-            Child = MovableCatcher = new Catcher(difficulty)
-            {
-                AdditiveTarget = this,
-            };
+            Child = MovableCatcher = new Catcher(this, difficulty);
         }
 
         public static float GetCatcherSize(BeatmapDifficulty difficulty)

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

@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public CatcherSprite(CatcherAnimationState state)
             : base(new CatchSkinComponent(componentFromState(state)), _ =>
-                new DefaultCatcherSprite(state), confineMode: ConfineMode.ScaleDownToFit)
+                new DefaultCatcherSprite(state), confineMode: ConfineMode.ScaleToFit)
         {
             RelativeSizeAxes = Axes.None;
             Size = new Vector2(CatcherArea.CATCHER_SIZE);

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

@@ -0,0 +1,135 @@
+// 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 JetBrains.Annotations;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Animations;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.UI
+{
+    /// <summary>
+    /// Represents a component responsible for displaying
+    /// the appropriate catcher trails when requested to.
+    /// </summary>
+    public class CatcherTrailDisplay : CompositeDrawable
+    {
+        private readonly Catcher catcher;
+
+        private readonly Container<CatcherTrailSprite> dashTrails;
+        private readonly Container<CatcherTrailSprite> hyperDashTrails;
+        private readonly Container<CatcherTrailSprite> endGlowSprites;
+
+        private Color4 hyperDashTrailsColour;
+
+        public Color4 HyperDashTrailsColour
+        {
+            get => hyperDashTrailsColour;
+            set
+            {
+                if (hyperDashTrailsColour == value)
+                    return;
+
+                hyperDashTrailsColour = value;
+                hyperDashTrails.FadeColour(hyperDashTrailsColour, Catcher.HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
+            }
+        }
+
+        private Color4 endGlowSpritesColour;
+
+        public Color4 EndGlowSpritesColour
+        {
+            get => endGlowSpritesColour;
+            set
+            {
+                if (endGlowSpritesColour == value)
+                    return;
+
+                endGlowSpritesColour = value;
+                endGlowSprites.FadeColour(endGlowSpritesColour, Catcher.HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
+            }
+        }
+
+        private bool trail;
+
+        /// <summary>
+        /// Whether to start displaying trails following the catcher.
+        /// </summary>
+        public bool DisplayTrail
+        {
+            get => trail;
+            set
+            {
+                if (trail == value)
+                    return;
+
+                trail = value;
+
+                if (trail)
+                    displayTrail();
+            }
+        }
+
+        public CatcherTrailDisplay([NotNull] Catcher catcher)
+        {
+            this.catcher = catcher ?? throw new ArgumentNullException(nameof(catcher));
+
+            RelativeSizeAxes = Axes.Both;
+
+            InternalChildren = new[]
+            {
+                dashTrails = new Container<CatcherTrailSprite> { RelativeSizeAxes = Axes.Both },
+                hyperDashTrails = new Container<CatcherTrailSprite> { RelativeSizeAxes = Axes.Both, Colour = Catcher.DEFAULT_HYPER_DASH_COLOUR },
+                endGlowSprites = new Container<CatcherTrailSprite> { RelativeSizeAxes = Axes.Both, Colour = Catcher.DEFAULT_HYPER_DASH_COLOUR },
+            };
+        }
+
+        /// <summary>
+        /// Displays a single end-glow catcher sprite.
+        /// </summary>
+        public void DisplayEndGlow()
+        {
+            var endGlow = createTrailSprite(endGlowSprites);
+
+            endGlow.MoveToOffset(new Vector2(0, -10), 1200, Easing.In);
+            endGlow.ScaleTo(endGlow.Scale * 0.95f).ScaleTo(endGlow.Scale * 1.2f, 1200, Easing.In);
+            endGlow.FadeOut(1200);
+            endGlow.Expire(true);
+        }
+
+        private void displayTrail()
+        {
+            if (!DisplayTrail)
+                return;
+
+            var sprite = createTrailSprite(catcher.HyperDashing ? hyperDashTrails : dashTrails);
+
+            sprite.FadeTo(0.4f).FadeOut(800, Easing.OutQuint);
+            sprite.Expire(true);
+
+            Scheduler.AddDelayed(displayTrail, catcher.HyperDashing ? 25 : 50);
+        }
+
+        private CatcherTrailSprite createTrailSprite(Container<CatcherTrailSprite> target)
+        {
+            var texture = (catcher.CurrentDrawableCatcher as TextureAnimation)?.CurrentFrame ?? ((Sprite)catcher.CurrentDrawableCatcher).Texture;
+
+            var sprite = new CatcherTrailSprite(texture)
+            {
+                Anchor = catcher.Anchor,
+                Scale = catcher.Scale,
+                Blending = BlendingParameters.Additive,
+                RelativePositionAxes = catcher.RelativePositionAxes,
+                Position = catcher.Position
+            };
+
+            target.Add(sprite);
+
+            return sprite;
+        }
+    }
+}

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

@@ -32,6 +32,8 @@ namespace osu.Game.Rulesets.Catch.UI
 
         protected override ReplayInputHandler CreateReplayInputHandler(Replay replay) => new CatchFramedReplayInputHandler(replay);
 
+        protected override ReplayRecorder CreateReplayRecorder(Replay replay) => new CatchReplayRecorder(replay, (CatchPlayfield)Playfield);
+
         protected override Playfield CreatePlayfield() => new CatchPlayfield(Beatmap.BeatmapInfo.BaseDifficulty, CreateDrawableRepresentation);
 
         public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new CatchPlayfieldAdjustmentContainer();

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

@@ -0,0 +1,50 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using NUnit.Framework;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [TestFixture]
+    public class ManiaColumnTypeTest
+    {
+        [TestCase(new[]
+        {
+            ColumnType.Special
+        }, 1)]
+        [TestCase(new[]
+        {
+            ColumnType.Odd,
+            ColumnType.Even,
+            ColumnType.Even,
+            ColumnType.Odd
+        }, 4)]
+        [TestCase(new[]
+        {
+            ColumnType.Odd,
+            ColumnType.Even,
+            ColumnType.Odd,
+            ColumnType.Special,
+            ColumnType.Odd,
+            ColumnType.Even,
+            ColumnType.Odd
+        }, 7)]
+        public void Test(IEnumerable<ColumnType> expected, int columns)
+        {
+            var definition = new StageDefinition
+            {
+                Columns = columns
+            };
+            var results = getResults(definition);
+            Assert.AreEqual(expected, results);
+        }
+
+        private IEnumerable<ColumnType> getResults(StageDefinition definition)
+        {
+            for (var i = 0; i < definition.Columns; i++)
+                yield return definition.GetTypeOfColumn(i);
+        }
+    }
+}

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

@@ -25,7 +25,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             {
             }
 
-            protected override RulesetKeyBindingContainer CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
+            protected override KeyBindingContainer<ManiaAction> CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
                 => new LocalKeyBindingContainer(ruleset, variant, unique);
 
             private class LocalKeyBindingContainer : RulesetKeyBindingContainer

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

@@ -0,0 +1,51 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Replays;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [TestFixture]
+    public class ManiaLegacyReplayTest
+    {
+        [TestCase(ManiaAction.Key1)]
+        [TestCase(ManiaAction.Key1, ManiaAction.Key2)]
+        [TestCase(ManiaAction.Special1)]
+        [TestCase(ManiaAction.Key8)]
+        public void TestEncodeDecodeSingleStage(params ManiaAction[] actions)
+        {
+            var beatmap = new ManiaBeatmap(new StageDefinition { Columns = 9 });
+
+            var frame = new ManiaReplayFrame(0, actions);
+            var legacyFrame = frame.ToLegacy(beatmap);
+
+            var decodedFrame = new ManiaReplayFrame();
+            decodedFrame.FromLegacy(legacyFrame, beatmap);
+
+            Assert.That(decodedFrame.Actions, Is.EquivalentTo(frame.Actions));
+        }
+
+        [TestCase(ManiaAction.Key1)]
+        [TestCase(ManiaAction.Key1, ManiaAction.Key2)]
+        [TestCase(ManiaAction.Special1)]
+        [TestCase(ManiaAction.Special2)]
+        [TestCase(ManiaAction.Special1, ManiaAction.Special2)]
+        [TestCase(ManiaAction.Special1, ManiaAction.Key5)]
+        [TestCase(ManiaAction.Key8)]
+        public void TestEncodeDecodeDualStage(params ManiaAction[] actions)
+        {
+            var beatmap = new ManiaBeatmap(new StageDefinition { Columns = 5 });
+            beatmap.Stages.Add(new StageDefinition { Columns = 5 });
+
+            var frame = new ManiaReplayFrame(0, actions);
+            var legacyFrame = frame.ToLegacy(beatmap);
+
+            var decodedFrame = new ManiaReplayFrame();
+            decodedFrame.FromLegacy(legacyFrame, beatmap);
+
+            Assert.That(decodedFrame.Actions, Is.EquivalentTo(frame.Actions));
+        }
+    }
+}

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

@@ -7,20 +7,18 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Timing;
-using osu.Game.Rulesets.Mania.Edit;
+using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
-using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {
-    [Cached(Type = typeof(IManiaHitObjectComposer))]
-    public abstract class ManiaPlacementBlueprintTestScene : PlacementBlueprintTestScene, IManiaHitObjectComposer
+    public abstract class ManiaPlacementBlueprintTestScene : PlacementBlueprintTestScene
     {
         private readonly Column column;
 
@@ -41,16 +39,20 @@ namespace osu.Game.Rulesets.Mania.Tests
                 AccentColour = Color4.OrangeRed,
                 Clock = new FramedClock(new StopwatchClock()), // No scroll
             });
+        }
 
-            AddStep("change direction", () => ((ScrollingTestContainer)HitObjectContainer).Flip());
+        protected override SnapResult SnapForBlueprint(PlacementBlueprint blueprint)
+        {
+            var time = column.TimeAtScreenSpacePosition(InputManager.CurrentState.Mouse.Position);
+            var pos = column.ScreenSpacePositionAtTime(time);
+
+            return new SnapResult(pos, time, column);
         }
 
         protected override Container CreateHitObjectContainer() => new ScrollingTestContainer(ScrollingDirection.Down) { RelativeSizeAxes = Axes.Both };
 
         protected override void AddHitObject(DrawableHitObject hitObject) => column.Add((DrawableManiaHitObject)hitObject);
 
-        public Column ColumnAt(Vector2 screenSpacePosition) => column;
-
-        public int TotalColumns => 1;
+        public ManiaPlayfield Playfield => null;
     }
 }

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

@@ -4,25 +4,20 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Timing;
-using osu.Game.Rulesets.Mania.Edit;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Tests.Visual;
-using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {
-    [Cached(Type = typeof(IManiaHitObjectComposer))]
-    public abstract class ManiaSelectionBlueprintTestScene : SelectionBlueprintTestScene, IManiaHitObjectComposer
+    public abstract class ManiaSelectionBlueprintTestScene : SelectionBlueprintTestScene
     {
         [Cached(Type = typeof(IAdjustableClock))]
         private readonly IAdjustableClock clock = new StopwatchClock();
 
-        private readonly Column column;
-
         protected ManiaSelectionBlueprintTestScene()
         {
-            Add(column = new Column(0)
+            Add(new Column(0)
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
@@ -31,8 +26,6 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
         }
 
-        public Column ColumnAt(Vector2 screenSpacePosition) => column;
-
-        public int TotalColumns => 1;
+        public ManiaPlayfield Playfield => null;
     }
 }

osu.Game.Rulesets.Mania.Tests/Resources/special-skin/skin.ini

@@ -0,0 +1,6 @@
+[General]
+Version: 2.4
+
+[Mania]
+Keys: 4
+ColumnLineWidth: 3,1,3,1,1

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

@@ -0,0 +1,40 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.UI;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.Tests.Skinning
+{
+    /// <summary>
+    /// A container to be used in a <see cref="ManiaSkinnableTestScene"/> to provide a resolvable <see cref="Column"/> dependency.
+    /// </summary>
+    public class ColumnTestContainer : Container
+    {
+        protected override Container<Drawable> Content => content;
+
+        private readonly Container content;
+
+        [Cached]
+        private readonly Column column;
+
+        public ColumnTestContainer(int column, ManiaAction action)
+        {
+            this.column = new Column(column)
+            {
+                Action = { Value = action },
+                AccentColour = Color4.Orange,
+                ColumnType = column % 2 == 0 ? ColumnType.Even : ColumnType.Odd
+            };
+
+            InternalChild = content = new ManiaInputManager(new ManiaRuleset().RulesetInfo, 4)
+            {
+                RelativeSizeAxes = Axes.Both
+            };
+        }
+    }
+}

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

@@ -0,0 +1,72 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.UI.Scrolling;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.Tests.Skinning
+{
+    /// <summary>
+    /// A test scene for a mania hitobject.
+    /// </summary>
+    public abstract class ManiaHitObjectTestScene : ManiaSkinnableTestScene
+    {
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            SetContents(() => new FillFlowContainer
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Both,
+                Height = 0.7f,
+                Direction = FillDirection.Horizontal,
+                Children = new Drawable[]
+                {
+                    new ColumnTestContainer(0, ManiaAction.Key1)
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        RelativeSizeAxes = Axes.Y,
+                        Width = 80,
+                        Child = new ScrollingHitObjectContainer
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                        }.With(c =>
+                        {
+                            c.Add(CreateHitObject().With(h =>
+                            {
+                                h.HitObject.StartTime = START_TIME;
+                                h.AccentColour.Value = Color4.Orange;
+                            }));
+                        })
+                    },
+                    new ColumnTestContainer(1, ManiaAction.Key2)
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        RelativeSizeAxes = Axes.Y,
+                        Width = 80,
+                        Child = new ScrollingHitObjectContainer
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                        }.With(c =>
+                        {
+                            c.Add(CreateHitObject().With(h =>
+                            {
+                                h.HitObject.StartTime = START_TIME;
+                                h.AccentColour.Value = Color4.Orange;
+                            }));
+                        })
+                    },
+                }
+            });
+        }
+
+        protected abstract DrawableManiaHitObject CreateHitObject();
+    }
+}

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

@@ -0,0 +1,81 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Rulesets.UI.Scrolling.Algorithms;
+using osu.Game.Tests.Visual;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.Tests.Skinning
+{
+    /// <summary>
+    /// A test scene for skinnable mania components.
+    /// </summary>
+    public abstract class ManiaSkinnableTestScene : SkinnableTestScene
+    {
+        protected const double START_TIME = 1000000000;
+
+        [Cached(Type = typeof(IScrollingInfo))]
+        private readonly TestScrollingInfo scrollingInfo = new TestScrollingInfo();
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new ManiaRuleset();
+
+        protected ManiaSkinnableTestScene()
+        {
+            scrollingInfo.Direction.Value = ScrollingDirection.Down;
+
+            Add(new Box
+            {
+                RelativeSizeAxes = Axes.Both,
+                Colour = Color4.SlateGray.Opacity(0.2f),
+                Depth = 1
+            });
+        }
+
+        [Test]
+        public void TestScrollingDown()
+        {
+            AddStep("change direction to down", () => scrollingInfo.Direction.Value = ScrollingDirection.Down);
+        }
+
+        [Test]
+        public void TestScrollingUp()
+        {
+            AddStep("change direction to up", () => scrollingInfo.Direction.Value = ScrollingDirection.Up);
+        }
+
+        private class TestScrollingInfo : IScrollingInfo
+        {
+            public readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
+
+            IBindable<ScrollingDirection> IScrollingInfo.Direction => Direction;
+            IBindable<double> IScrollingInfo.TimeRange { get; } = new Bindable<double>(1000);
+            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

@@ -0,0 +1,49 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Mania.UI.Components;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Tests.Skinning
+{
+    public class TestSceneColumnBackground : ManiaSkinnableTestScene
+    {
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            SetContents(() => new FillFlowContainer
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Both,
+                Size = new Vector2(0.8f),
+                Direction = FillDirection.Horizontal,
+                Children = new Drawable[]
+                {
+                    new ColumnTestContainer(0, ManiaAction.Key1)
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Width = 0.5f,
+                        Child = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.ColumnBackground, 0), _ => new DefaultColumnBackground())
+                        {
+                            RelativeSizeAxes = Axes.Both
+                        }
+                    },
+                    new ColumnTestContainer(1, ManiaAction.Key2)
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Width = 0.5f,
+                        Child = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.ColumnBackground, 1), _ => new DefaultColumnBackground())
+                        {
+                            RelativeSizeAxes = Axes.Both
+                        }
+                    }
+                }
+            });
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Mania.UI.Components;
+using osu.Game.Rulesets.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Tests.Skinning
+{
+    public class TestSceneColumnHitObjectArea : ManiaSkinnableTestScene
+    {
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            SetContents(() => new FillFlowContainer
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Both,
+                Size = new Vector2(0.8f),
+                Direction = FillDirection.Horizontal,
+                Children = new Drawable[]
+                {
+                    new ColumnTestContainer(0, ManiaAction.Key1)
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Width = 0.5f,
+                        Child = new ColumnHitObjectArea(0, new HitObjectContainer())
+                        {
+                            RelativeSizeAxes = Axes.Both
+                        }
+                    },
+                    new ColumnTestContainer(1, ManiaAction.Key2)
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Width = 0.5f,
+                        Child = new ColumnHitObjectArea(1, new HitObjectContainer())
+                        {
+                            RelativeSizeAxes = Axes.Both
+                        }
+                    }
+                }
+            });
+        }
+    }
+}

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

@@ -2,26 +2,18 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Extensions;
 using osu.Framework.Graphics;
-using osu.Game.Tests.Visual;
-using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Skinning
 {
-    public class TestSceneDrawableJudgement : SkinnableTestScene
+    public class TestSceneDrawableJudgement : ManiaSkinnableTestScene
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[]
-        {
-            typeof(DrawableJudgement),
-            typeof(DrawableManiaJudgement)
-        };
-
         public TestSceneDrawableJudgement()
         {
             foreach (HitResult result in Enum.GetValues(typeof(HitResult)).OfType<HitResult>().Skip(1))

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

@@ -0,0 +1,57 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Skinning;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.Tests.Skinning
+{
+    [TestFixture]
+    public class TestSceneHitExplosion : ManiaSkinnableTestScene
+    {
+        public TestSceneHitExplosion()
+        {
+            int runcount = 0;
+
+            AddRepeatStep("explode", () =>
+            {
+                runcount++;
+
+                if (runcount % 15 > 12)
+                    return;
+
+                CreatedDrawables.OfType<Container>().ForEach(c =>
+                {
+                    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

@@ -0,0 +1,35 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Framework.Bindables;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+
+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);
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Mania.UI.Components;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Tests.Skinning
+{
+    public class TestSceneKeyArea : ManiaSkinnableTestScene
+    {
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            SetContents(() => new FillFlowContainer
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Both,
+                Size = new Vector2(0.8f),
+                Direction = FillDirection.Horizontal,
+                Children = new Drawable[]
+                {
+                    new ColumnTestContainer(0, ManiaAction.Key1)
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Width = 0.5f,
+                        Child = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.KeyArea, 0), _ => new DefaultKeyArea())
+                        {
+                            RelativeSizeAxes = Axes.Both
+                        },
+                    },
+                    new ColumnTestContainer(1, ManiaAction.Key2)
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Width = 0.5f,
+                        Child = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.KeyArea, 1), _ => new DefaultKeyArea())
+                        {
+                            RelativeSizeAxes = Axes.Both
+                        },
+                    },
+                }
+            });
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Mania.Tests.Skinning
+{
+    public class TestSceneNote : ManiaHitObjectTestScene
+    {
+        protected override DrawableManiaHitObject CreateHitObject()
+        {
+            var note = new Note();
+            note.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+            return new DrawableNote(note);
+        }
+    }
+}

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.Tests/Skinning/TestSceneStage.cs

@@ -0,0 +1,27 @@
+// 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.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.UI;
+
+namespace osu.Game.Rulesets.Mania.Tests.Skinning
+{
+    public class TestSceneStage : ManiaSkinnableTestScene
+    {
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            SetContents(() =>
+            {
+                ManiaAction normalAction = ManiaAction.Key1;
+                ManiaAction specialAction = ManiaAction.Special1;
+
+                return new ManiaInputManager(new ManiaRuleset().RulesetInfo, 4)
+                {
+                    Child = new Stage(0, new StageDefinition { Columns = 4 }, ref normalAction, ref specialAction)
+                };
+            });
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Mania.UI.Components;
+using osu.Game.Skinning;
+
+namespace osu.Game.Rulesets.Mania.Tests.Skinning
+{
+    public class TestSceneStageBackground : ManiaSkinnableTestScene
+    {
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            SetContents(() => new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.StageBackground), _ => new DefaultStageBackground())
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Both,
+                Width = 0.5f,
+            });
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Skinning;
+
+namespace osu.Game.Rulesets.Mania.Tests.Skinning
+{
+    public class TestSceneStageForeground : ManiaSkinnableTestScene
+    {
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            SetContents(() => new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.StageForeground), _ => null)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Both,
+                Width = 0.5f,
+            });
+        }
+    }
+}

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

@@ -12,7 +12,6 @@ using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.UI;
-using osu.Game.Rulesets.Mania.UI.Components;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
@@ -24,14 +23,6 @@ namespace osu.Game.Rulesets.Mania.Tests
     [TestFixture]
     public class TestSceneColumn : ManiaInputTestScene
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[]
-        {
-            typeof(Column),
-            typeof(ColumnBackground),
-            typeof(ColumnKeyArea),
-            typeof(ColumnHitObjectArea)
-        };
-
         [Cached(typeof(IReadOnlyList<Mod>))]
         private IReadOnlyList<Mod> mods { get; set; } = Array.Empty<Mod>();
 

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

@@ -1,62 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using System.Collections.Generic;
-using NUnit.Framework;
-using osu.Framework.Graphics;
-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 osuTK;
-using osuTK.Graphics;
-
-namespace osu.Game.Rulesets.Mania.Tests
-{
-    [TestFixture]
-    public class TestSceneHitExplosion : OsuTestScene
-    {
-        private ScrollingTestContainer scrolling;
-
-        public override IReadOnlyList<Type> RequiredTypes => new[]
-        {
-            typeof(DrawableNote),
-            typeof(DrawableManiaHitObject),
-        };
-
-        protected override void LoadComplete()
-        {
-            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, NotePiece.NOTE_HEIGHT),
-            };
-
-            int runcount = 0;
-
-            AddRepeatStep("explode", () =>
-            {
-                runcount++;
-
-                if (runcount % 15 > 12)
-                    return;
-
-                scrolling.AddRange(new Drawable[]
-                {
-                    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,
-                    }
-                });
-            }, 100);
-        }
-    }
-}

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

@@ -27,7 +27,6 @@ namespace osu.Game.Rulesets.Mania.Tests
         private const double time_after_tail = 5250;
 
         private List<JudgementResult> judgementResults;
-        private bool allJudgedFired;
 
         /// <summary>
         ///     -----[           ]-----
@@ -283,20 +282,15 @@ namespace osu.Game.Rulesets.Mania.Tests
                     {
                         if (currentPlayer == p) judgementResults.Add(result);
                     };
-                    p.ScoreProcessor.AllJudged += () =>
-                    {
-                        if (currentPlayer == p) allJudgedFired = true;
-                    };
                 };
 
                 LoadScreen(currentPlayer = p);
-                allJudgedFired = false;
                 judgementResults = new List<JudgementResult>();
             });
 
             AddUntilStep("Beatmap at 0", () => Beatmap.Value.Track.CurrentTime == 0);
             AddUntilStep("Wait until player is loaded", () => currentPlayer.IsCurrentScreen());
-            AddUntilStep("Wait for all judged", () => allJudgedFired);
+            AddUntilStep("Wait for completion", () => currentPlayer.ScoreProcessor.HasCompleted.Value);
         }
 
         private class ScoreAccessibleReplayPlayer : ReplayPlayer

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

@@ -0,0 +1,124 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Input.Events;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Edit;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Screens.Edit;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public class TestSceneManiaBeatSnapGrid : EditorClockTestScene
+    {
+        [Cached(typeof(IScrollingInfo))]
+        private ScrollingTestContainer.TestScrollingInfo scrollingInfo = new ScrollingTestContainer.TestScrollingInfo();
+
+        [Cached(typeof(EditorBeatmap))]
+        private EditorBeatmap editorBeatmap = new EditorBeatmap(new ManiaBeatmap(new StageDefinition()));
+
+        private readonly ManiaBeatSnapGrid beatSnapGrid;
+
+        public TestSceneManiaBeatSnapGrid()
+        {
+            editorBeatmap.ControlPointInfo.Add(0, new TimingControlPoint { BeatLength = 200 });
+            editorBeatmap.ControlPointInfo.Add(10000, new TimingControlPoint { BeatLength = 200 });
+
+            BeatDivisor.Value = 3;
+
+            // Some sane defaults
+            scrollingInfo.Algorithm.Algorithm = ScrollVisualisationMethod.Constant;
+            scrollingInfo.Direction.Value = ScrollingDirection.Up;
+            scrollingInfo.TimeRange.Value = 1000;
+
+            Children = new Drawable[]
+            {
+                Playfield = new ManiaPlayfield(new List<StageDefinition>
+                {
+                    new StageDefinition { Columns = 4 },
+                    new StageDefinition { Columns = 3 }
+                })
+                {
+                    Clock = new FramedClock(new StopwatchClock())
+                },
+                new TestHitObjectComposer(Playfield)
+                {
+                    Child = beatSnapGrid = new ManiaBeatSnapGrid()
+                }
+            };
+        }
+
+        protected override bool OnMouseMove(MouseMoveEvent e)
+        {
+            // We're providing a constant scroll algorithm.
+            float relativePosition = Playfield.Stages[0].HitObjectContainer.ToLocalSpace(e.ScreenSpaceMousePosition).Y / Playfield.Stages[0].HitObjectContainer.DrawHeight;
+            double timeValue = scrollingInfo.TimeRange.Value * relativePosition;
+
+            beatSnapGrid.SelectionTimeRange = (timeValue, timeValue);
+
+            return true;
+        }
+
+        public ManiaPlayfield Playfield { get; }
+    }
+
+    public class TestHitObjectComposer : HitObjectComposer
+    {
+        public override Playfield Playfield { get; }
+        public override IEnumerable<DrawableHitObject> HitObjects => Enumerable.Empty<DrawableHitObject>();
+        public override bool CursorInPlacementArea => false;
+
+        public TestHitObjectComposer(Playfield playfield)
+        {
+            Playfield = playfield;
+        }
+
+        public Drawable Child
+        {
+            set => InternalChild = value;
+        }
+
+        public override SnapResult SnapScreenSpacePositionToValidTime(Vector2 screenSpacePosition)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public override float GetBeatSnapDistanceAt(double referenceTime)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public override float DurationToDistance(double referenceTime, double duration)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public override double DistanceToDuration(double referenceTime, float distance)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public override double GetSnappedDurationFromDistance(double referenceTime, float distance)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public override float GetSnappedDistanceFromDistance(double referenceTime, float distance)
+        {
+            throw new System.NotImplementedException();
+        }
+    }
+}

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

@@ -0,0 +1,218 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Edit;
+using osu.Game.Rulesets.Mania.Edit.Blueprints;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Screens.Edit;
+using osu.Game.Tests.Visual;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public class TestSceneManiaHitObjectComposer : EditorClockTestScene
+    {
+        private TestComposer composer;
+
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            BeatDivisor.Value = 8;
+            Clock.Seek(0);
+
+            Child = composer = new TestComposer { RelativeSizeAxes = Axes.Both };
+        });
+
+        [Test]
+        public void TestDragOffscreenSelectionVerticallyUpScroll()
+        {
+            DrawableHitObject lastObject = null;
+            double originalTime = 0;
+            Vector2 originalPosition = Vector2.Zero;
+
+            setScrollStep(ScrollingDirection.Up);
+
+            AddStep("seek to last object", () =>
+            {
+                lastObject = this.ChildrenOfType<DrawableHitObject>().Single(d => d.HitObject == composer.EditorBeatmap.HitObjects.Last());
+                originalTime = lastObject.HitObject.StartTime;
+                Clock.Seek(composer.EditorBeatmap.HitObjects.Last().StartTime);
+            });
+
+            AddStep("select all objects", () => composer.EditorBeatmap.SelectedHitObjects.AddRange(composer.EditorBeatmap.HitObjects));
+
+            AddStep("click last object", () =>
+            {
+                originalPosition = lastObject.DrawPosition;
+
+                InputManager.MoveMouseTo(lastObject);
+                InputManager.PressButton(MouseButton.Left);
+            });
+
+            AddStep("move mouse downwards", () =>
+            {
+                InputManager.MoveMouseTo(lastObject, new Vector2(0, lastObject.ScreenSpaceDrawQuad.Height * 4));
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            AddAssert("hitobjects not moved columns", () => composer.EditorBeatmap.HitObjects.All(h => ((ManiaHitObject)h).Column == 0));
+            AddAssert("hitobjects moved downwards", () => lastObject.DrawPosition.Y - originalPosition.Y > 0);
+            AddAssert("hitobject has moved time", () => lastObject.HitObject.StartTime == originalTime + 125);
+        }
+
+        [Test]
+        public void TestDragOffscreenSelectionVerticallyDownScroll()
+        {
+            DrawableHitObject lastObject = null;
+            double originalTime = 0;
+            Vector2 originalPosition = Vector2.Zero;
+
+            setScrollStep(ScrollingDirection.Down);
+
+            AddStep("seek to last object", () =>
+            {
+                lastObject = this.ChildrenOfType<DrawableHitObject>().Single(d => d.HitObject == composer.EditorBeatmap.HitObjects.Last());
+                originalTime = lastObject.HitObject.StartTime;
+                Clock.Seek(composer.EditorBeatmap.HitObjects.Last().StartTime);
+            });
+
+            AddStep("select all objects", () => composer.EditorBeatmap.SelectedHitObjects.AddRange(composer.EditorBeatmap.HitObjects));
+
+            AddStep("click last object", () =>
+            {
+                originalPosition = lastObject.DrawPosition;
+
+                InputManager.MoveMouseTo(lastObject);
+                InputManager.PressButton(MouseButton.Left);
+            });
+
+            AddStep("move mouse upwards", () =>
+            {
+                InputManager.MoveMouseTo(lastObject, new Vector2(0, -lastObject.ScreenSpaceDrawQuad.Height * 4));
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            AddAssert("hitobjects not moved columns", () => composer.EditorBeatmap.HitObjects.All(h => ((ManiaHitObject)h).Column == 0));
+            AddAssert("hitobjects moved upwards", () => originalPosition.Y - lastObject.DrawPosition.Y > 0);
+            AddAssert("hitobject has moved time", () => lastObject.HitObject.StartTime == originalTime + 125);
+        }
+
+        [Test]
+        public void TestDragOffscreenSelectionHorizontally()
+        {
+            DrawableHitObject lastObject = null;
+            Vector2 originalPosition = Vector2.Zero;
+
+            setScrollStep(ScrollingDirection.Down);
+
+            AddStep("seek to last object", () =>
+            {
+                lastObject = this.ChildrenOfType<DrawableHitObject>().Single(d => d.HitObject == composer.EditorBeatmap.HitObjects.Last());
+                Clock.Seek(composer.EditorBeatmap.HitObjects.Last().StartTime);
+            });
+
+            AddStep("select all objects", () => composer.EditorBeatmap.SelectedHitObjects.AddRange(composer.EditorBeatmap.HitObjects));
+
+            AddStep("click last object", () =>
+            {
+                originalPosition = lastObject.DrawPosition;
+
+                InputManager.MoveMouseTo(lastObject);
+                InputManager.PressButton(MouseButton.Left);
+            });
+
+            AddStep("move mouse right", () =>
+            {
+                var firstColumn = composer.Composer.Playfield.GetColumn(0);
+                var secondColumn = composer.Composer.Playfield.GetColumn(1);
+
+                InputManager.MoveMouseTo(lastObject, new Vector2(secondColumn.ScreenSpaceDrawQuad.Centre.X - firstColumn.ScreenSpaceDrawQuad.Centre.X + 1, 0));
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            AddAssert("hitobjects moved columns", () => composer.EditorBeatmap.HitObjects.All(h => ((ManiaHitObject)h).Column == 1));
+
+            // Todo: They'll move vertically by the height of a note since there's no snapping and the selection point is the middle of the note.
+            AddAssert("hitobjects not moved vertically", () => lastObject.DrawPosition.Y - originalPosition.Y <= DefaultNotePiece.NOTE_HEIGHT);
+        }
+
+        [Test]
+        public void TestDragHoldNoteSelectionVertically()
+        {
+            setScrollStep(ScrollingDirection.Down);
+
+            AddStep("setup beatmap", () =>
+            {
+                composer.EditorBeatmap.Clear();
+                composer.EditorBeatmap.Add(new HoldNote
+                {
+                    Column = 1,
+                    EndTime = 200
+                });
+            });
+
+            DrawableHoldNote holdNote = null;
+
+            AddStep("grab hold note", () =>
+            {
+                holdNote = this.ChildrenOfType<DrawableHoldNote>().Single();
+                InputManager.MoveMouseTo(holdNote);
+                InputManager.PressButton(MouseButton.Left);
+            });
+
+            AddStep("move drag upwards", () =>
+            {
+                InputManager.MoveMouseTo(holdNote, new Vector2(0, -100));
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            AddAssert("head note positioned correctly", () => Precision.AlmostEquals(holdNote.ScreenSpaceDrawQuad.BottomLeft, holdNote.Head.ScreenSpaceDrawQuad.BottomLeft));
+            AddAssert("tail note positioned correctly", () => Precision.AlmostEquals(holdNote.ScreenSpaceDrawQuad.TopLeft, holdNote.Tail.ScreenSpaceDrawQuad.BottomLeft));
+
+            AddAssert("head blueprint positioned correctly", () => this.ChildrenOfType<HoldNoteNoteSelectionBlueprint>().ElementAt(0).DrawPosition == holdNote.Head.DrawPosition);
+            AddAssert("tail blueprint positioned correctly", () => this.ChildrenOfType<HoldNoteNoteSelectionBlueprint>().ElementAt(1).DrawPosition == holdNote.Tail.DrawPosition);
+        }
+
+        private void setScrollStep(ScrollingDirection direction)
+            => AddStep($"set scroll direction = {direction}", () => ((Bindable<ScrollingDirection>)composer.Composer.ScrollingInfo.Direction).Value = direction);
+
+        private class TestComposer : CompositeDrawable
+        {
+            [Cached(typeof(EditorBeatmap))]
+            [Cached(typeof(IBeatSnapProvider))]
+            public readonly EditorBeatmap EditorBeatmap;
+
+            public readonly ManiaHitObjectComposer Composer;
+
+            public TestComposer()
+            {
+                InternalChildren = new Drawable[]
+                {
+                    EditorBeatmap = new EditorBeatmap(new ManiaBeatmap(new StageDefinition { Columns = 4 }))
+                    {
+                        BeatmapInfo = { Ruleset = new ManiaRuleset().RulesetInfo }
+                    },
+                    Composer = new ManiaHitObjectComposer(new ManiaRuleset())
+                };
+
+                for (int i = 0; i < 10; i++)
+                    EditorBeatmap.Add(new Note { StartTime = 125 * i });
+            }
+        }
+    }
+}

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

@@ -1,17 +1,59 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Testing;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Edit.Blueprints;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Tests.Visual;
+using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {
     public class TestSceneNotePlacementBlueprint : ManiaPlacementBlueprintTestScene
     {
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            this.ChildrenOfType<HitObjectContainer>().ForEach(c => c.Clear());
+
+            ResetPlacement();
+
+            ((ScrollingTestContainer)HitObjectContainer).Direction = ScrollingDirection.Down;
+        });
+
+        [Test]
+        public void TestPlaceBeforeCurrentTimeDownwards()
+        {
+            AddStep("move mouse before current time", () => InputManager.MoveMouseTo(this.ChildrenOfType<Column>().Single().ScreenSpaceDrawQuad.BottomLeft - new Vector2(0, 10)));
+
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+
+            AddAssert("note start time < 0", () => getNote().StartTime < 0);
+        }
+
+        [Test]
+        public void TestPlaceAfterCurrentTimeDownwards()
+        {
+            AddStep("move mouse after current time", () => InputManager.MoveMouseTo(this.ChildrenOfType<Column>().Single()));
+
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+
+            AddAssert("note start time > 0", () => getNote().StartTime > 0);
+        }
+
+        private Note getNote() => this.ChildrenOfType<DrawableNote>().FirstOrDefault()?.HitObject;
+
         protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableNote((Note)hitObject);
         protected override PlacementBlueprint CreateBlueprint() => new NotePlacementBlueprint();
     }

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
-using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
@@ -30,12 +28,6 @@ namespace osu.Game.Rulesets.Mania.Tests
     [TestFixture]
     public class TestSceneNotes : OsuTestScene
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[]
-        {
-            typeof(DrawableNote),
-            typeof(DrawableHoldNote)
-        };
-
         [BackgroundDependencyLoader]
         private void load()
         {
@@ -164,7 +156,7 @@ namespace osu.Game.Rulesets.Mania.Tests
 
                 foreach (var obj in content.OfType<DrawableHitObject>())
                 {
-                    if (!(obj.HitObject is IHasEndTime endTime))
+                    if (!(obj.HitObject is IHasDuration endTime))
                         continue;
 
                     foreach (var nested in obj.NestedHitObjects)

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

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

osu.Game.Rulesets.Mania.Tests/osu.Game.Rulesets.Mania.Tests.csproj

@@ -2,7 +2,7 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.6.1" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.15.1" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

osu.Game.Rulesets.Mania/Beatmaps/ColumnType.cs

@@ -0,0 +1,12 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Game.Rulesets.Mania.Beatmaps
+{
+    public enum ColumnType
+    {
+        Even,
+        Odd,
+        Special
+    }
+}

osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs

@@ -13,7 +13,6 @@ using osu.Game.Rulesets.Mania.Beatmaps.Patterns;
 using osu.Game.Rulesets.Mania.MathUtils;
 using osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy;
 using osuTK;
-using osu.Game.Audio;
 
 namespace osu.Game.Rulesets.Mania.Beatmaps
 {
@@ -47,7 +46,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             {
                 TargetColumns = (int)Math.Max(1, roundedCircleSize);
 
-                if (TargetColumns >= 10)
+                if (TargetColumns > ManiaRuleset.MAX_STAGE_KEYS)
                 {
                     TargetColumns /= 2;
                     Dual = true;
@@ -55,7 +54,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             }
             else
             {
-                float percentSliderOrSpinner = (float)beatmap.HitObjects.Count(h => h is IHasEndTime) / beatmap.HitObjects.Count;
+                float percentSliderOrSpinner = (float)beatmap.HitObjects.Count(h => h is IHasDuration) / beatmap.HitObjects.Count;
                 if (percentSliderOrSpinner < 0.2)
                     TargetColumns = 7;
                 else if (percentSliderOrSpinner < 0.3 || roundedCircleSize >= 5)
@@ -67,7 +66,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             }
         }
 
-        public override bool CanConvert() => Beatmap.HitObjects.All(h => h is IHasXPosition || h is ManiaHitObject);
+        public override bool CanConvert() => Beatmap.HitObjects.All(h => h is IHasXPosition);
 
         protected override Beatmap<ManiaHitObject> ConvertBeatmap(IBeatmap original)
         {
@@ -176,7 +175,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
                     break;
                 }
 
-                case IHasEndTime endTimeData:
+                case IHasDuration endTimeData:
                 {
                     conversion = new EndTimeObjectPatternGenerator(Random, original, beatmap, originalBeatmap);
 
@@ -232,15 +231,15 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
 
                 var pattern = new Pattern();
 
-                if (HitObject is IHasEndTime endTimeData)
+                if (HitObject is IHasDuration endTimeData)
                 {
                     pattern.Add(new HoldNote
                     {
                         StartTime = HitObject.StartTime,
                         Duration = endTimeData.Duration,
                         Column = column,
-                        Head = { Samples = sampleInfoListAt(HitObject.StartTime) },
-                        Tail = { Samples = sampleInfoListAt(endTimeData.EndTime) },
+                        Samples = HitObject.Samples,
+                        NodeSamples = (HitObject as IHasRepeats)?.NodeSamples
                     });
                 }
                 else if (HitObject is IHasXPosition)
@@ -255,22 +254,6 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
 
                 return pattern;
             }
-
-            /// <summary>
-            /// Retrieves the sample info list at a point in time.
-            /// </summary>
-            /// <param name="time">The time to retrieve the sample info list from.</param>
-            /// <returns></returns>
-            private IList<HitSampleInfo> sampleInfoListAt(double time)
-            {
-                if (!(HitObject is IHasCurve curveData))
-                    return HitObject.Samples;
-
-                double segmentTime = (curveData.EndTime - HitObject.StartTime) / curveData.SpanCount();
-
-                int index = (int)(segmentTime == 0 ? 0 : (time - HitObject.StartTime) / segmentTime);
-                return curveData.NodeSamples[index];
-            }
         }
     }
 }

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/DistanceObjectPatternGenerator.cs

@@ -474,7 +474,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// <returns></returns>
         private IList<HitSampleInfo> sampleInfoListAt(double time)
         {
-            if (!(HitObject is IHasCurve curveData))
+            if (!(HitObject is IHasPathWithRepeats curveData))
                 return HitObject.Samples;
 
             double segmentTime = (EndTime - HitObject.StartTime) / spanCount;
@@ -505,16 +505,14 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             }
             else
             {
-                var holdNote = new HoldNote
+                newObject = new HoldNote
                 {
                     StartTime = startTime,
-                    Column = column,
                     Duration = endTime - startTime,
-                    Head = { Samples = sampleInfoListAt(startTime) },
-                    Tail = { Samples = sampleInfoListAt(endTime) }
+                    Column = column,
+                    Samples = HitObject.Samples,
+                    NodeSamples = (HitObject as IHasRepeats)?.NodeSamples
                 };
-
-                newObject = holdNote;
             }
 
             pattern.Add(newObject);

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/EndTimeObjectPatternGenerator.cs

@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         public EndTimeObjectPatternGenerator(FastRandom random, HitObject hitObject, ManiaBeatmap beatmap, IBeatmap originalBeatmap)
             : base(random, hitObject, beatmap, new Pattern(), originalBeatmap)
         {
-            endTime = (HitObject as IHasEndTime)?.EndTime ?? 0;
+            endTime = (HitObject as IHasDuration)?.EndTime ?? 0;
         }
 
         public override IEnumerable<Pattern> Generate()
@@ -64,21 +64,14 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             if (holdNote)
             {
-                var hold = new HoldNote
+                newObject = new HoldNote
                 {
                     StartTime = HitObject.StartTime,
+                    Duration = endTime - HitObject.StartTime,
                     Column = column,
-                    Duration = endTime - HitObject.StartTime
+                    Samples = HitObject.Samples,
+                    NodeSamples = (HitObject as IHasRepeats)?.NodeSamples
                 };
-
-                if (hold.Head.Samples == null)
-                    hold.Head.Samples = new List<HitSampleInfo>();
-
-                hold.Head.Samples.Add(new HitSampleInfo { Name = HitSampleInfo.HIT_NORMAL });
-
-                hold.Tail.Samples = HitObject.Samples;
-
-                newObject = hold;
             }
             else
             {

osu.Game.Rulesets.Mania/Beatmaps/StageDefinition.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.Game.Rulesets.Mania.UI;
 
 namespace osu.Game.Rulesets.Mania.Beatmaps
@@ -21,5 +22,19 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         /// <param name="column">The 0-based column index.</param>
         /// <returns>Whether the column is a special column.</returns>
         public bool IsSpecialColumn(int column) => Columns % 2 == 1 && column == Columns / 2;
+
+        /// <summary>
+        /// Get the type of column given a column index.
+        /// </summary>
+        /// <param name="column">The 0-based column index.</param>
+        /// <returns>The type of the column.</returns>
+        public ColumnType GetTypeOfColumn(int column)
+        {
+            if (IsSpecialColumn(column))
+                return ColumnType.Special;
+
+            int distanceToEdge = Math.Min(column, (Columns - 1) - column);
+            return distanceToEdge % 2 == 0 ? ColumnType.Odd : ColumnType.Even;
+        }
     }
 }

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/Difficulty/ManiaPerformanceCalculator.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Extensions;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
@@ -37,12 +38,12 @@ namespace osu.Game.Rulesets.Mania.Difficulty
         {
             mods = Score.Mods;
             scaledScore = Score.TotalScore;
-            countPerfect = Score.Statistics[HitResult.Perfect];
-            countGreat = Score.Statistics[HitResult.Great];
-            countGood = Score.Statistics[HitResult.Good];
-            countOk = Score.Statistics[HitResult.Ok];
-            countMeh = Score.Statistics[HitResult.Meh];
-            countMiss = Score.Statistics[HitResult.Miss];
+            countPerfect = Score.Statistics.GetOrDefault(HitResult.Perfect);
+            countGreat = Score.Statistics.GetOrDefault(HitResult.Great);
+            countGood = Score.Statistics.GetOrDefault(HitResult.Good);
+            countOk = Score.Statistics.GetOrDefault(HitResult.Ok);
+            countMeh = Score.Statistics.GetOrDefault(HitResult.Meh);
+            countMiss = Score.Statistics.GetOrDefault(HitResult.Miss);
 
             if (mods.Any(m => !m.Ranked))
                 return 0;

osu.Game.Rulesets.Mania/DualStageVariantGenerator.cs

@@ -0,0 +1,64 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Input.Bindings;
+
+namespace osu.Game.Rulesets.Mania
+{
+    public class DualStageVariantGenerator
+    {
+        private readonly int singleStageVariant;
+        private readonly InputKey[] stage1LeftKeys;
+        private readonly InputKey[] stage1RightKeys;
+        private readonly InputKey[] stage2LeftKeys;
+        private readonly InputKey[] stage2RightKeys;
+
+        public DualStageVariantGenerator(int singleStageVariant)
+        {
+            this.singleStageVariant = singleStageVariant;
+
+            // 10K is special because it expands towards the centre of the keyboard (VM/BN), rather than towards the edges of the keyboard.
+            if (singleStageVariant == 10)
+            {
+                stage1LeftKeys = new[] { InputKey.Q, InputKey.W, InputKey.E, InputKey.R, InputKey.V };
+                stage1RightKeys = new[] { InputKey.M, InputKey.I, InputKey.O, InputKey.P, InputKey.BracketLeft };
+
+                stage2LeftKeys = new[] { InputKey.S, InputKey.D, InputKey.F, InputKey.G, InputKey.B };
+                stage2RightKeys = new[] { InputKey.N, InputKey.J, InputKey.K, InputKey.L, InputKey.Semicolon };
+            }
+            else
+            {
+                stage1LeftKeys = new[] { InputKey.Q, InputKey.W, InputKey.E, InputKey.R };
+                stage1RightKeys = new[] { InputKey.I, InputKey.O, InputKey.P, InputKey.BracketLeft };
+
+                stage2LeftKeys = new[] { InputKey.S, InputKey.D, InputKey.F, InputKey.G };
+                stage2RightKeys = new[] { InputKey.J, InputKey.K, InputKey.L, InputKey.Semicolon };
+            }
+        }
+
+        public IEnumerable<KeyBinding> GenerateMappings()
+        {
+            var stage1Bindings = new VariantMappingGenerator
+            {
+                LeftKeys = stage1LeftKeys,
+                RightKeys = stage1RightKeys,
+                SpecialKey = InputKey.V,
+                SpecialAction = ManiaAction.Special1,
+                NormalActionStart = ManiaAction.Key1
+            }.GenerateKeyBindingsFor(singleStageVariant, out var nextNormal);
+
+            var stage2Bindings = new VariantMappingGenerator
+            {
+                LeftKeys = stage2LeftKeys,
+                RightKeys = stage2RightKeys,
+                SpecialKey = InputKey.B,
+                SpecialAction = ManiaAction.Special2,
+                NormalActionStart = nextNormal
+            }.GenerateKeyBindingsFor(singleStageVariant, out _);
+
+            return stage1Bindings.Concat(stage2Bindings);
+        }
+    }
+}

osu.Game.Rulesets.Mania/Edit/Blueprints/Components/EditBodyPiece.cs

@@ -7,12 +7,12 @@ using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints.Components
 {
-    public class EditBodyPiece : BodyPiece
+    public class EditBodyPiece : DefaultBodyPiece
     {
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
-            AccentColour = colours.Yellow;
+            AccentColour.Value = colours.Yellow;
 
             Background.Alpha = 0.5f;
             Foreground.Alpha = 0;

osu.Game.Rulesets.Mania/Edit/Blueprints/Components/EditNotePiece.cs

@@ -12,12 +12,12 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints.Components
     {
         public EditNotePiece()
         {
-            Height = NotePiece.NOTE_HEIGHT;
+            Height = DefaultNotePiece.NOTE_HEIGHT;
 
             CornerRadius = 5;
             Masking = true;
 
-            InternalChild = new NotePiece();
+            InternalChild = new DefaultNotePiece();
         }
 
         [BackgroundDependencyLoader]

osu.Game.Rulesets.Mania/Edit/Blueprints/HoldNotePlacementBlueprint.cs

@@ -2,10 +2,15 @@
 // 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.Input.Events;
+using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.UI.Scrolling;
 using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
@@ -15,6 +20,9 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
         private readonly EditNotePiece headPiece;
         private readonly EditNotePiece tailPiece;
 
+        [Resolved]
+        private IScrollingInfo scrollingInfo { get; set; }
+
         public HoldNotePlacementBlueprint()
             : base(new HoldNote())
         {
@@ -34,8 +42,21 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 
             if (Column != null)
             {
-                headPiece.Y = PositionAt(HitObject.StartTime);
-                tailPiece.Y = PositionAt(HitObject.EndTime);
+                headPiece.Y = Parent.ToLocalSpace(Column.ScreenSpacePositionAtTime(HitObject.StartTime)).Y;
+                tailPiece.Y = Parent.ToLocalSpace(Column.ScreenSpacePositionAtTime(HitObject.EndTime)).Y;
+
+                switch (scrollingInfo.Direction.Value)
+                {
+                    case ScrollingDirection.Down:
+                        headPiece.Y -= headPiece.DrawHeight / 2;
+                        tailPiece.Y -= tailPiece.DrawHeight / 2;
+                        break;
+
+                    case ScrollingDirection.Up:
+                        headPiece.Y += headPiece.DrawHeight / 2;
+                        tailPiece.Y += tailPiece.DrawHeight / 2;
+                        break;
+                }
             }
 
             var topPosition = new Vector2(headPiece.DrawPosition.X, Math.Min(headPiece.DrawPosition.Y, tailPiece.DrawPosition.Y));
@@ -46,25 +67,39 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             bodyPiece.Height = (bottomPosition - topPosition).Y;
         }
 
+        protected override void OnMouseUp(MouseUpEvent e)
+        {
+            if (e.Button != MouseButton.Left)
+                return;
+
+            base.OnMouseUp(e);
+            EndPlacement(true);
+        }
+
         private double originalStartTime;
 
-        public override void UpdatePosition(Vector2 screenSpacePosition)
+        public override void UpdatePosition(SnapResult result)
         {
-            base.UpdatePosition(screenSpacePosition);
+            base.UpdatePosition(result);
 
             if (PlacementActive)
             {
-                var endTime = TimeAt(screenSpacePosition);
-
-                HitObject.StartTime = endTime < originalStartTime ? endTime : originalStartTime;
-                HitObject.Duration = Math.Abs(endTime - originalStartTime);
+                if (result.Time is double endTime)
+                {
+                    HitObject.StartTime = endTime < originalStartTime ? endTime : originalStartTime;
+                    HitObject.Duration = Math.Abs(endTime - originalStartTime);
+                }
             }
             else
             {
-                headPiece.Width = tailPiece.Width = SnappedWidth;
-                headPiece.X = tailPiece.X = SnappedMousePosition.X;
+                if (result.Playfield != null)
+                {
+                    headPiece.Width = tailPiece.Width = result.Playfield.DrawWidth;
+                    headPiece.X = tailPiece.X = ToLocalSpace(result.ScreenSpacePosition).X;
+                }
 
-                originalStartTime = HitObject.StartTime = TimeAt(screenSpacePosition);
+                if (result.Time is double startTime)
+                    originalStartTime = HitObject.StartTime = startTime;
             }
         }
     }

osu.Game.Rulesets.Mania/Edit/Blueprints/HoldNoteSelectionBlueprint.cs

@@ -4,13 +4,13 @@
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
-using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.UI.Scrolling;
 using osuTK;
-using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
@@ -42,11 +42,19 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             {
                 new HoldNoteNoteSelectionBlueprint(DrawableObject, HoldNotePosition.Start),
                 new HoldNoteNoteSelectionBlueprint(DrawableObject, HoldNotePosition.End),
-                new BodyPiece
+                new Container
                 {
-                    AccentColour = Color4.Transparent,
-                    BorderColour = colours.Yellow
-                },
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    BorderThickness = 1,
+                    BorderColour = colours.Yellow,
+                    Child = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Alpha = 0,
+                        AlwaysPresent = true,
+                    }
+                }
             };
         }
 
@@ -68,5 +76,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
         }
 
         public override Quad SelectionQuad => ScreenSpaceDrawQuad;
+
+        public override Vector2 ScreenSpaceSelectionPoint => DrawableObject.Head.ScreenSpaceDrawQuad.Centre;
     }
 }

osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaPlacementBlueprint.cs

@@ -1,42 +1,34 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Input;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.Mania.UI;
-using osu.Game.Rulesets.UI.Scrolling;
-using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
-    public abstract class ManiaPlacementBlueprint<T> : PlacementBlueprint,
-                                                       IRequireHighFrequencyMousePosition // the playfield could be moving behind us
+    public abstract class ManiaPlacementBlueprint<T> : PlacementBlueprint
         where T : ManiaHitObject
     {
         protected new T HitObject => (T)base.HitObject;
 
-        protected Column Column;
+        private Column column;
 
-        /// <summary>
-        /// The current mouse position, snapped to the closest column.
-        /// </summary>
-        protected Vector2 SnappedMousePosition { get; private set; }
+        public Column Column
+        {
+            get => column;
+            set
+            {
+                if (value == column)
+                    return;
 
-        /// <summary>
-        /// The width of the closest column to the current mouse position.
-        /// </summary>
-        protected float SnappedWidth { get; private set; }
-
-        [Resolved]
-        private IManiaHitObjectComposer composer { get; set; }
-
-        [Resolved]
-        private IScrollingInfo scrollingInfo { get; set; }
+                column = value;
+                HitObject.Column = column.Index;
+            }
+        }
 
         protected ManiaPlacementBlueprint(T hitObject)
             : base(hitObject)
@@ -46,112 +38,22 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 
         protected override bool OnMouseDown(MouseDownEvent e)
         {
-            if (Column == null)
-                return base.OnMouseDown(e);
+            if (e.Button != MouseButton.Left)
+                return false;
 
-            HitObject.Column = Column.Index;
-            BeginPlacement(TimeAt(e.ScreenSpaceMousePosition));
+            if (Column == null)
+                return false;
+
+            BeginPlacement(true);
             return true;
         }
 
-        protected override void OnMouseUp(MouseUpEvent e)
+        public override void UpdatePosition(SnapResult result)
         {
-            EndPlacement(true);
-            base.OnMouseUp(e);
-        }
+            base.UpdatePosition(result);
 
-        public override void UpdatePosition(Vector2 screenSpacePosition)
-        {
             if (!PlacementActive)
-                Column = ColumnAt(screenSpacePosition);
-
-            if (Column == null) return;
-
-            SnappedWidth = Column.DrawWidth;
-
-            // Snap to the column
-            var parentPos = Parent.ToLocalSpace(Column.ToScreenSpace(new Vector2(Column.DrawWidth / 2, 0)));
-            SnappedMousePosition = new Vector2(parentPos.X, Parent.ToLocalSpace(screenSpacePosition).Y);
-        }
-
-        protected double TimeAt(Vector2 screenSpacePosition)
-        {
-            if (Column == null)
-                return 0;
-
-            var hitObjectContainer = Column.HitObjectContainer;
-
-            // If we're scrolling downwards, a position of 0 is actually further away from the hit target
-            // so we need to flip the vertical coordinate in the hitobject container's space
-            var hitObjectPos = mouseToHitObjectPosition(Column.HitObjectContainer.ToLocalSpace(screenSpacePosition)).Y;
-            if (scrollingInfo.Direction.Value == ScrollingDirection.Down)
-                hitObjectPos = hitObjectContainer.DrawHeight - hitObjectPos;
-
-            return scrollingInfo.Algorithm.TimeAt(hitObjectPos,
-                EditorClock.CurrentTime,
-                scrollingInfo.TimeRange.Value,
-                hitObjectContainer.DrawHeight);
-        }
-
-        protected float PositionAt(double time)
-        {
-            var pos = scrollingInfo.Algorithm.PositionAt(time,
-                EditorClock.CurrentTime,
-                scrollingInfo.TimeRange.Value,
-                Column.HitObjectContainer.DrawHeight);
-
-            if (scrollingInfo.Direction.Value == ScrollingDirection.Down)
-                pos = Column.HitObjectContainer.DrawHeight - pos;
-
-            return hitObjectToMousePosition(Column.HitObjectContainer.ToSpaceOfOtherDrawable(new Vector2(0, pos), Parent)).Y;
-        }
-
-        protected Column ColumnAt(Vector2 screenSpacePosition)
-            => composer.ColumnAt(screenSpacePosition);
-
-        /// <summary>
-        /// Converts a mouse position to a hitobject position.
-        /// </summary>
-        /// <remarks>
-        /// Blueprints are centred on the mouse position, such that the hitobject position is anchored at the top or bottom of the blueprint depending on the scroll direction.
-        /// </remarks>
-        /// <param name="mousePosition">The mouse position.</param>
-        /// <returns>The resulting hitobject position, acnhored at the top or bottom of the blueprint depending on the scroll direction.</returns>
-        private Vector2 mouseToHitObjectPosition(Vector2 mousePosition)
-        {
-            switch (scrollingInfo.Direction.Value)
-            {
-                case ScrollingDirection.Up:
-                    mousePosition.Y -= NotePiece.NOTE_HEIGHT / 2;
-                    break;
-
-                case ScrollingDirection.Down:
-                    mousePosition.Y += NotePiece.NOTE_HEIGHT / 2;
-                    break;
-            }
-
-            return mousePosition;
-        }
-
-        /// <summary>
-        /// Converts a hitobject position to a mouse position.
-        /// </summary>
-        /// <param name="hitObjectPosition">The hitobject position.</param>
-        /// <returns>The resulting mouse position, anchored at the centre of the hitobject.</returns>
-        private Vector2 hitObjectToMousePosition(Vector2 hitObjectPosition)
-        {
-            switch (scrollingInfo.Direction.Value)
-            {
-                case ScrollingDirection.Up:
-                    hitObjectPosition.Y += NotePiece.NOTE_HEIGHT / 2;
-                    break;
-
-                case ScrollingDirection.Down:
-                    hitObjectPosition.Y -= NotePiece.NOTE_HEIGHT / 2;
-                    break;
-            }
-
-            return hitObjectPosition;
+                Column = result.Playfield as Column;
         }
     }
 }

osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaSelectionBlueprint.cs

@@ -3,8 +3,6 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Input.Events;
-using osu.Framework.Timing;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -13,33 +11,19 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
-    public class ManiaSelectionBlueprint : OverlaySelectionBlueprint
+    public abstract class ManiaSelectionBlueprint : OverlaySelectionBlueprint
     {
-        public Vector2 ScreenSpaceDragPosition { get; private set; }
-        public Vector2 DragPosition { get; private set; }
-
         public new DrawableManiaHitObject DrawableObject => (DrawableManiaHitObject)base.DrawableObject;
 
-        protected IClock EditorClock { get; private set; }
-
         [Resolved]
         private IScrollingInfo scrollingInfo { get; set; }
 
-        [Resolved]
-        private IManiaHitObjectComposer composer { get; set; }
-
-        public ManiaSelectionBlueprint(DrawableHitObject drawableObject)
+        protected ManiaSelectionBlueprint(DrawableHitObject drawableObject)
             : base(drawableObject)
         {
             RelativeSizeAxes = Axes.None;
         }
 
-        [BackgroundDependencyLoader]
-        private void load(IAdjustableClock clock)
-        {
-            EditorClock = clock;
-        }
-
         protected override void Update()
         {
             base.Update();
@@ -47,22 +31,6 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             Position = Parent.ToLocalSpace(DrawableObject.ToScreenSpace(Vector2.Zero));
         }
 
-        protected override bool OnMouseDown(MouseDownEvent e)
-        {
-            ScreenSpaceDragPosition = e.ScreenSpaceMousePosition;
-            DragPosition = DrawableObject.ToLocalSpace(e.ScreenSpaceMousePosition);
-
-            return base.OnMouseDown(e);
-        }
-
-        protected override void OnDrag(DragEvent e)
-        {
-            base.OnDrag(e);
-
-            ScreenSpaceDragPosition = e.ScreenSpaceMousePosition;
-            DragPosition = DrawableObject.ToLocalSpace(e.ScreenSpaceMousePosition);
-        }
-
         public override void Show()
         {
             DrawableObject.AlwaysAlive = true;

osu.Game.Rulesets.Mania/Edit/Blueprints/NotePlacementBlueprint.cs

@@ -2,29 +2,48 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics;
+using osu.Framework.Input.Events;
+using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Mania.Objects;
+using osuTK.Input;
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
     public class NotePlacementBlueprint : ManiaPlacementBlueprint<Note>
     {
+        private readonly EditNotePiece piece;
+
         public NotePlacementBlueprint()
             : base(new Note())
         {
-            Origin = Anchor.Centre;
+            RelativeSizeAxes = Axes.Both;
 
-            AutoSizeAxes = Axes.Y;
-
-            InternalChild = new EditNotePiece { RelativeSizeAxes = Axes.X };
+            InternalChild = piece = new EditNotePiece { Origin = Anchor.Centre };
         }
 
-        protected override void Update()
+        public override void UpdatePosition(SnapResult result)
         {
-            base.Update();
+            base.UpdatePosition(result);
 
-            Width = SnappedWidth;
-            Position = SnappedMousePosition;
+            if (result.Playfield != null)
+            {
+                piece.Width = result.Playfield.DrawWidth;
+                piece.Position = ToLocalSpace(result.ScreenSpacePosition);
+            }
+        }
+
+        protected override bool OnMouseDown(MouseDownEvent e)
+        {
+            if (e.Button != MouseButton.Left)
+                return false;
+
+            base.OnMouseDown(e);
+
+            // Place the note immediately.
+            EndPlacement(true);
+
+            return true;
         }
     }
 }