Merge pull request #8970 from peppy/android-version-update

Fix android usage of obsoleted VersionCode

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>

osu.Android.props

@@ -51,7 +51,7 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.403.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.407.1" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.427.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.508.1" />
   </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/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/osu.Game.Benchmarks.csproj

@@ -7,7 +7,7 @@
   </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>

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/TestSceneHyperDashColouring.cs

@@ -0,0 +1,132 @@
+// 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 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 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/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,8 +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 = 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

@@ -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.95f + 0.3f * Math.Min(1.0f, numTotalHits / 2500.0f) +
+                (numTotalHits > 2500 ? (float)Math.Log10(numTotalHits / 2500.0f) * 0.475f : 0.0f);
 
             // 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 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
+            float approachRate = (float)Attributes.ApproachRate;
+            float approachRateFactor = 1.0f;
+            if (approachRate > 9.0f)
+                approachRateFactor += 0.1f * (approachRate - 9.0f); // 10% for each AR above 9
+            if (approachRate > 10.0f)
+                approachRateFactor += 0.1f * (approachRate - 10.0f); // Additional 10% at AR 11, 30% total
+            else if (approachRate < 8.0f)
+                approachRateFactor += 0.025f * (8.0f - 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.0f)
+                    value *= 1.05f + 0.075f * (10.0f - approachRate); // 7.5% for each AR below 10
+                else if (approachRate > 10.0f)
+                    value *= 1.01f + 0.04f * (11.0f - Math.Min(11.0f, 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.

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

@@ -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/Catcher.cs

@@ -21,6 +21,8 @@ namespace osu.Game.Rulesets.Catch.UI
 {
     public class Catcher : Container, IKeyBindingHandler<CatchAction>
     {
+        public static readonly Color4 DEFAULT_HYPER_DASH_COLOUR = Color4.Red;
+
         /// <summary>
         /// Whether we are hyper-dashing or not.
         /// </summary>
@@ -42,11 +44,6 @@ namespace osu.Game.Rulesets.Catch.UI
         /// </summary>
         private const float allowed_catch_range = 0.8f;
 
-        /// <summary>
-        /// Width of the area that can be used to attempt catches during gameplay.
-        /// </summary>
-        internal float CatchWidth => CatcherArea.CATCHER_SIZE * Math.Abs(Scale.X) * allowed_catch_range;
-
         protected bool Dashing
         {
             get => dashing;
@@ -77,6 +74,11 @@ namespace osu.Game.Rulesets.Catch.UI
             }
         }
 
+        /// <summary>
+        /// Width of the area that can be used to attempt catches during gameplay.
+        /// </summary>
+        private readonly float catchWidth;
+
         private Container<DrawableHitObject> caughtFruit;
 
         private CatcherSprite catcherIdle;
@@ -104,7 +106,9 @@ 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]
@@ -137,6 +141,26 @@ namespace osu.Game.Rulesets.Catch.UI
             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>
@@ -175,7 +199,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;

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

@@ -41,8 +41,6 @@ namespace osu.Game.Rulesets.Mania.Tests
                 AccentColour = Color4.OrangeRed,
                 Clock = new FramedClock(new StopwatchClock()), // No scroll
             });
-
-            AddStep("change direction", () => ((ScrollingTestContainer)HitObjectContainer).Flip());
         }
 
         protected override Container CreateHitObjectContainer() => new ScrollingTestContainer(ScrollingDirection.Down) { RelativeSizeAxes = Axes.Both };

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/ManiaSkinnableTestScene.cs

@@ -31,6 +31,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
         {
             typeof(ManiaRuleset),
             typeof(ManiaLegacySkinTransformer),
+            typeof(ManiaSettingsSubsection)
         };
 
         protected override Ruleset CreateRulesetForSkinProvider() => new ManiaRuleset();

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

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

osu.Game.Rulesets.Mania.Tests/Skinning/TestSceneStageBackground.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;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Mania.Skinning;
+using osu.Game.Rulesets.Mania.UI.Components;
+using osu.Game.Skinning;
+
+namespace osu.Game.Rulesets.Mania.Tests.Skinning
+{
+    public class TestSceneStageBackground : ManiaSkinnableTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => base.RequiredTypes.Concat(new[]
+        {
+            typeof(DefaultStageBackground),
+            typeof(LegacyStageBackground),
+        }).ToList();
+
+        [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,33 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Mania.Skinning;
+using osu.Game.Skinning;
+
+namespace osu.Game.Rulesets.Mania.Tests.Skinning
+{
+    public class TestSceneStageForeground : ManiaSkinnableTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => base.RequiredTypes.Concat(new[]
+        {
+            typeof(LegacyStageForeground),
+        }).ToList();
+
+        [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/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/TestSceneManiaHitObjectComposer.cs

@@ -0,0 +1,174 @@
+// 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;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Edit;
+using osu.Game.Rulesets.Mania.Objects;
+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
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(ManiaBlueprintContainer)
+        };
+
+        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;
+            Vector2 originalPosition = Vector2.Zero;
+
+            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 downwards", () =>
+            {
+                InputManager.MoveMouseTo(lastObject, new Vector2(0, 20));
+                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("hitobjects not moved too far", () => lastObject.DrawPosition.Y - originalPosition.Y < 50);
+        }
+
+        [Test]
+        public void TestDragOffscreenSelectionVerticallyDownScroll()
+        {
+            DrawableHitObject lastObject = null;
+            Vector2 originalPosition = Vector2.Zero;
+
+            AddStep("set down scroll", () => ((Bindable<ScrollingDirection>)composer.Composer.ScrollingInfo.Direction).Value = 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 upwards", () =>
+            {
+                InputManager.MoveMouseTo(lastObject, new Vector2(0, -20));
+                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("hitobjects not moved too far", () => originalPosition.Y - lastObject.DrawPosition.Y < 50);
+        }
+
+        [Test]
+        public void TestDragOffscreenSelectionHorizontally()
+        {
+            DrawableHitObject lastObject = null;
+            Vector2 originalPosition = Vector2.Zero;
+
+            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);
+        }
+
+        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 = 100 * 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/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/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;
@@ -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)
         {
@@ -239,8 +238,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
                         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

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

@@ -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/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/HoldNotePlacementBlueprint.cs

@@ -3,6 +3,7 @@
 
 using System;
 using osu.Framework.Graphics;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Mania.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Mania.Objects;
 using osuTK;
@@ -46,6 +47,12 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             bodyPiece.Height = (bottomPosition - topPosition).Y;
         }
 
+        protected override void OnMouseUp(MouseUpEvent e)
+        {
+            base.OnMouseUp(e);
+            EndPlacement(true);
+        }
+
         private double originalStartTime;
 
         public override void UpdatePosition(Vector2 screenSpacePosition)

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

@@ -45,6 +45,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
                 new Container
                 {
                     RelativeSizeAxes = Axes.Both,
+                    Masking = true,
                     BorderThickness = 1,
                     BorderColour = colours.Yellow,
                     Child = new Box
@@ -75,5 +76,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
         }
 
         public override Quad SelectionQuad => ScreenSpaceDrawQuad;
+
+        public override Vector2 SelectionPoint => DrawableObject.Head.ScreenSpaceDrawQuad.Centre;
     }
 }

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

@@ -50,16 +50,10 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
                 return base.OnMouseDown(e);
 
             HitObject.Column = Column.Index;
-            BeginPlacement(TimeAt(e.ScreenSpaceMousePosition));
+            BeginPlacement(TimeAt(e.ScreenSpaceMousePosition), true);
             return true;
         }
 
-        protected override void OnMouseUp(MouseUpEvent e)
-        {
-            EndPlacement(true);
-            base.OnMouseUp(e);
-        }
-
         public override void UpdatePosition(Vector2 screenSpacePosition)
         {
             if (!PlacementActive)

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;
@@ -15,13 +13,8 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
     public 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; }
 
@@ -34,12 +27,6 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             RelativeSizeAxes = Axes.None;
         }
 
-        [BackgroundDependencyLoader]
-        private void load(IAdjustableClock clock)
-        {
-            EditorClock = clock;
-        }
-
         protected override void Update()
         {
             base.Update();
@@ -47,22 +34,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,6 +2,7 @@
 // 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.Mania.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Mania.Objects;
 
@@ -26,5 +27,15 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             Width = SnappedWidth;
             Position = SnappedMousePosition;
         }
+
+        protected override bool OnMouseDown(MouseDownEvent e)
+        {
+            base.OnMouseDown(e);
+
+            // Place the note immediately.
+            EndPlacement(true);
+
+            return true;
+        }
     }
 }

osu.Game.Rulesets.Mania/Edit/ManiaBlueprintContainer.cs

@@ -30,5 +30,7 @@ namespace osu.Game.Rulesets.Mania.Edit
 
             return base.CreateBlueprintFor(hitObject);
         }
+
+        protected override SelectionHandler CreateSelectionHandler() => new ManiaSelectionHandler();
     }
 }

osu.Game.Rulesets.Mania/Edit/ManiaHitObjectComposer.cs

@@ -10,6 +10,7 @@ using osu.Framework.Allocation;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
+using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
 
@@ -37,7 +38,33 @@ namespace osu.Game.Rulesets.Mania.Edit
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
             => dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
-        public int TotalColumns => ((ManiaPlayfield)drawableRuleset.Playfield).TotalColumns;
+        public ManiaPlayfield Playfield => ((ManiaPlayfield)drawableRuleset.Playfield);
+
+        public IScrollingInfo ScrollingInfo => drawableRuleset.ScrollingInfo;
+
+        public int TotalColumns => Playfield.TotalColumns;
+
+        public override (Vector2 position, double time) GetSnappedPosition(Vector2 position, double time)
+        {
+            var hoc = Playfield.GetColumn(0).HitObjectContainer;
+
+            float targetPosition = hoc.ToLocalSpace(ToScreenSpace(position)).Y;
+
+            if (drawableRuleset.ScrollingInfo.Direction.Value == ScrollingDirection.Down)
+            {
+                // We're dealing with screen coordinates in which the position decreases towards the centre of the screen resulting in an increase in start time.
+                // The scrolling algorithm instead assumes a top anchor meaning an increase in time corresponds to an increase in position,
+                // so when scrolling downwards the coordinates need to be flipped.
+                targetPosition = hoc.DrawHeight - targetPosition;
+            }
+
+            double targetTime = drawableRuleset.ScrollingInfo.Algorithm.TimeAt(targetPosition,
+                EditorClock.CurrentTime,
+                drawableRuleset.ScrollingInfo.TimeRange.Value,
+                hoc.DrawHeight);
+
+            return base.GetSnappedPosition(position, targetTime);
+        }
 
         protected override DrawableRuleset<ManiaHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods = null)
         {

osu.Game.Rulesets.Mania/Edit/ManiaSelectionHandler.cs

@@ -4,11 +4,8 @@
 using System;
 using System.Linq;
 using osu.Framework.Allocation;
-using osu.Framework.Timing;
-using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Edit.Blueprints;
 using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Screens.Edit.Compose.Components;
 
@@ -22,85 +19,16 @@ namespace osu.Game.Rulesets.Mania.Edit
         [Resolved]
         private IManiaHitObjectComposer composer { get; set; }
 
-        private IClock editorClock;
-
-        [BackgroundDependencyLoader]
-        private void load(IAdjustableClock clock)
-        {
-            editorClock = clock;
-        }
-
         public override bool HandleMovement(MoveSelectionEvent moveEvent)
         {
             var maniaBlueprint = (ManiaSelectionBlueprint)moveEvent.Blueprint;
             int lastColumn = maniaBlueprint.DrawableObject.HitObject.Column;
 
-            adjustOrigins(maniaBlueprint);
-            performDragMovement(moveEvent);
             performColumnMovement(lastColumn, moveEvent);
 
             return true;
         }
 
-        /// <summary>
-        /// Ensures that the position of hitobjects remains centred to the mouse position.
-        /// E.g. The hitobject position will change if the editor scrolls while a hitobject is dragged.
-        /// </summary>
-        /// <param name="reference">The <see cref="ManiaSelectionBlueprint"/> that received the drag event.</param>
-        private void adjustOrigins(ManiaSelectionBlueprint reference)
-        {
-            var referenceParent = (HitObjectContainer)reference.DrawableObject.Parent;
-
-            float offsetFromReferenceOrigin = reference.DragPosition.Y - reference.DrawableObject.OriginPosition.Y;
-            float targetPosition = referenceParent.ToLocalSpace(reference.ScreenSpaceDragPosition).Y - offsetFromReferenceOrigin;
-
-            // Flip the vertical coordinate space when scrolling downwards
-            if (scrollingInfo.Direction.Value == ScrollingDirection.Down)
-                targetPosition -= referenceParent.DrawHeight;
-
-            float movementDelta = targetPosition - reference.DrawableObject.Position.Y;
-
-            foreach (var b in SelectedBlueprints.OfType<ManiaSelectionBlueprint>())
-                b.DrawableObject.Y += movementDelta;
-        }
-
-        private void performDragMovement(MoveSelectionEvent moveEvent)
-        {
-            float delta = moveEvent.InstantDelta.Y;
-
-            // When scrolling downwards the anchor position is at the bottom of the screen, however the movement event assumes the anchor is at the top of the screen.
-            // This causes the delta to assume a positive hitobject position, and which can be corrected for by subtracting the parent height.
-            if (scrollingInfo.Direction.Value == ScrollingDirection.Down)
-                delta -= moveEvent.Blueprint.Parent.DrawHeight; // todo: probably wrong
-
-            foreach (var selectionBlueprint in SelectedBlueprints)
-            {
-                var b = (OverlaySelectionBlueprint)selectionBlueprint;
-
-                var hitObject = b.DrawableObject;
-                var objectParent = (HitObjectContainer)hitObject.Parent;
-
-                // StartTime could be used to adjust the position if only one movement event was received per frame.
-                // However this is not the case and ScrollingHitObjectContainer performs movement in UpdateAfterChildren() so the position must also be updated to be valid for further movement events
-                hitObject.Y += delta;
-
-                float targetPosition = hitObject.Position.Y;
-
-                // The scrolling algorithm always assumes an anchor at the top of the screen, so the position must be flipped when scrolling downwards to reflect a top anchor
-                if (scrollingInfo.Direction.Value == ScrollingDirection.Down)
-                    targetPosition = -targetPosition;
-
-                objectParent.Remove(hitObject);
-
-                hitObject.HitObject.StartTime = scrollingInfo.Algorithm.TimeAt(targetPosition,
-                    editorClock.CurrentTime,
-                    scrollingInfo.TimeRange.Value,
-                    objectParent.DrawHeight);
-
-                objectParent.Add(hitObject);
-            }
-        }
-
         private void performColumnMovement(int lastColumn, MoveSelectionEvent moveEvent)
         {
             var currentColumn = composer.ColumnAt(moveEvent.ScreenSpacePosition);

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

@@ -1,18 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Graphics;
-using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Objects.Drawables;
-
-namespace osu.Game.Rulesets.Mania.Edit.Masks
-{
-    public abstract class ManiaSelectionBlueprint : OverlaySelectionBlueprint
-    {
-        protected ManiaSelectionBlueprint(DrawableHitObject drawableObject)
-            : base(drawableObject)
-        {
-            RelativeSizeAxes = Axes.None;
-        }
-    }
-}

osu.Game.Rulesets.Mania/ManiaInputManager.cs

@@ -78,5 +78,11 @@ namespace osu.Game.Rulesets.Mania
 
         [Description("Key 18")]
         Key18,
+
+        [Description("Key 19")]
+        Key19,
+
+        [Description("Key 20")]
+        Key20,
     }
 }

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -35,6 +35,11 @@ namespace osu.Game.Rulesets.Mania
 {
     public class ManiaRuleset : Ruleset, ILegacyRuleset
     {
+        /// <summary>
+        /// The maximum number of supported keys in a single stage.
+        /// </summary>
+        public const int MAX_STAGE_KEYS = 10;
+
         public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod> mods = null) => new DrawableManiaRuleset(this, beatmap, mods);
 
         public override ScoreProcessor CreateScoreProcessor() => new ManiaScoreProcessor();
@@ -202,6 +207,7 @@ namespace osu.Game.Rulesets.Mania
                             new ManiaModKey7(),
                             new ManiaModKey8(),
                             new ManiaModKey9(),
+                            new ManiaModKey10(),
                             new ManiaModKey1(),
                             new ManiaModKey2(),
                             new ManiaModKey3()),
@@ -250,9 +256,9 @@ namespace osu.Game.Rulesets.Mania
         {
             get
             {
-                for (int i = 1; i <= 9; i++)
+                for (int i = 1; i <= MAX_STAGE_KEYS; i++)
                     yield return (int)PlayfieldType.Single + i;
-                for (int i = 2; i <= 18; i += 2)
+                for (int i = 2; i <= MAX_STAGE_KEYS * 2; i += 2)
                     yield return (int)PlayfieldType.Dual + i;
             }
         }
@@ -262,73 +268,10 @@ namespace osu.Game.Rulesets.Mania
             switch (getPlayfieldType(variant))
             {
                 case PlayfieldType.Single:
-                    return new VariantMappingGenerator
-                    {
-                        LeftKeys = new[]
-                        {
-                            InputKey.A,
-                            InputKey.S,
-                            InputKey.D,
-                            InputKey.F
-                        },
-                        RightKeys = new[]
-                        {
-                            InputKey.J,
-                            InputKey.K,
-                            InputKey.L,
-                            InputKey.Semicolon
-                        },
-                        SpecialKey = InputKey.Space,
-                        SpecialAction = ManiaAction.Special1,
-                        NormalActionStart = ManiaAction.Key1,
-                    }.GenerateKeyBindingsFor(variant, out _);
+                    return new SingleStageVariantGenerator(variant).GenerateMappings();
 
                 case PlayfieldType.Dual:
-                    int keys = getDualStageKeyCount(variant);
-
-                    var stage1Bindings = new VariantMappingGenerator
-                    {
-                        LeftKeys = new[]
-                        {
-                            InputKey.Q,
-                            InputKey.W,
-                            InputKey.E,
-                            InputKey.R,
-                        },
-                        RightKeys = new[]
-                        {
-                            InputKey.X,
-                            InputKey.C,
-                            InputKey.V,
-                            InputKey.B
-                        },
-                        SpecialKey = InputKey.S,
-                        SpecialAction = ManiaAction.Special1,
-                        NormalActionStart = ManiaAction.Key1
-                    }.GenerateKeyBindingsFor(keys, out var nextNormal);
-
-                    var stage2Bindings = new VariantMappingGenerator
-                    {
-                        LeftKeys = new[]
-                        {
-                            InputKey.Number7,
-                            InputKey.Number8,
-                            InputKey.Number9,
-                            InputKey.Number0
-                        },
-                        RightKeys = new[]
-                        {
-                            InputKey.K,
-                            InputKey.L,
-                            InputKey.Semicolon,
-                            InputKey.Quote
-                        },
-                        SpecialKey = InputKey.I,
-                        SpecialAction = ManiaAction.Special2,
-                        NormalActionStart = nextNormal
-                    }.GenerateKeyBindingsFor(keys, out _);
-
-                    return stage1Bindings.Concat(stage2Bindings);
+                    return new DualStageVariantGenerator(getDualStageKeyCount(variant)).GenerateMappings();
             }
 
             return Array.Empty<KeyBinding>();
@@ -364,59 +307,6 @@ namespace osu.Game.Rulesets.Mania
         {
             return (PlayfieldType)Enum.GetValues(typeof(PlayfieldType)).Cast<int>().OrderByDescending(i => i).First(v => variant >= v);
         }
-
-        private class VariantMappingGenerator
-        {
-            /// <summary>
-            /// All the <see cref="InputKey"/>s available to the left hand.
-            /// </summary>
-            public InputKey[] LeftKeys;
-
-            /// <summary>
-            /// All the <see cref="InputKey"/>s available to the right hand.
-            /// </summary>
-            public InputKey[] RightKeys;
-
-            /// <summary>
-            /// The <see cref="InputKey"/> for the special key.
-            /// </summary>
-            public InputKey SpecialKey;
-
-            /// <summary>
-            /// The <see cref="ManiaAction"/> at which the normal columns should begin.
-            /// </summary>
-            public ManiaAction NormalActionStart;
-
-            /// <summary>
-            /// The <see cref="ManiaAction"/> for the special column.
-            /// </summary>
-            public ManiaAction SpecialAction;
-
-            /// <summary>
-            /// Generates a list of <see cref="KeyBinding"/>s for a specific number of columns.
-            /// </summary>
-            /// <param name="columns">The number of columns that need to be bound.</param>
-            /// <param name="nextNormalAction">The next <see cref="ManiaAction"/> to use for normal columns.</param>
-            /// <returns>The keybindings.</returns>
-            public IEnumerable<KeyBinding> GenerateKeyBindingsFor(int columns, out ManiaAction nextNormalAction)
-            {
-                ManiaAction currentNormalAction = NormalActionStart;
-
-                var bindings = new List<KeyBinding>();
-
-                for (int i = LeftKeys.Length - columns / 2; i < LeftKeys.Length; i++)
-                    bindings.Add(new KeyBinding(LeftKeys[i], currentNormalAction++));
-
-                if (columns % 2 == 1)
-                    bindings.Add(new KeyBinding(SpecialKey, SpecialAction));
-
-                for (int i = 0; i < columns / 2; i++)
-                    bindings.Add(new KeyBinding(RightKeys[i], currentNormalAction++));
-
-                nextNormalAction = currentNormalAction;
-                return bindings;
-            }
-        }
     }
 
     public enum PlayfieldType

osu.Game.Rulesets.Mania/ManiaSkinComponent.cs

@@ -39,6 +39,8 @@ namespace osu.Game.Rulesets.Mania
         HoldNoteHead,
         HoldNoteTail,
         HoldNoteBody,
-        HitExplosion
+        HitExplosion,
+        StageBackground,
+        StageForeground,
     }
 }

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

@@ -0,0 +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.
+
+namespace osu.Game.Rulesets.Mania.Mods
+{
+    public class ManiaModKey10 : ManiaKeyMod
+    {
+        public override int KeyCount => 10;
+        public override string Name => "Ten Keys";
+        public override string Acronym => "10K";
+        public override string Description => @"Play with ten keys.";
+    }
+}

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

@@ -51,7 +51,10 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
             AddRangeInternal(new[]
             {
-                bodyPiece = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.HoldNoteBody, hitObject.Column), _ => new DefaultBodyPiece())
+                bodyPiece = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.HoldNoteBody, hitObject.Column), _ => new DefaultBodyPiece
+                {
+                    RelativeSizeAxes = Axes.Both
+                })
                 {
                     RelativeSizeAxes = Axes.X
                 },
@@ -127,6 +130,11 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             bodyPiece.Anchor = bodyPiece.Origin = e.NewValue == ScrollingDirection.Up ? Anchor.TopLeft : Anchor.BottomLeft;
         }
 
+        public override void PlaySamples()
+        {
+            // Samples are played by the head/tail notes.
+        }
+
         protected override void Update()
         {
             base.Update();

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

@@ -7,16 +7,12 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Rulesets.Mania.UI;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables
 {
     public abstract class DrawableManiaHitObject : DrawableHitObject<ManiaHitObject>
     {
-        /// <summary>
-        /// Whether this <see cref="DrawableManiaHitObject"/> should always remain alive.
-        /// </summary>
-        internal bool AlwaysAlive;
-
         /// <summary>
         /// The <see cref="ManiaAction"/> which causes this <see cref="DrawableManiaHitObject{TObject}"/> to be hit.
         /// </summary>
@@ -24,6 +20,20 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
         protected readonly IBindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
 
+        [Resolved(canBeNull: true)]
+        private ManiaPlayfield playfield { get; set; }
+
+        protected override float SamplePlaybackPosition
+        {
+            get
+            {
+                if (playfield == null)
+                    return base.SamplePlaybackPosition;
+
+                return (float)HitObject.Column / playfield.TotalColumns;
+            }
+        }
+
         protected DrawableManiaHitObject(ManiaHitObject hitObject)
             : base(hitObject)
         {
@@ -39,7 +49,62 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             Direction.BindValueChanged(OnDirectionChanged, true);
         }
 
-        protected override bool ShouldBeAlive => AlwaysAlive || base.ShouldBeAlive;
+        private double computedLifetimeStart;
+
+        public override double LifetimeStart
+        {
+            get => base.LifetimeStart;
+            set
+            {
+                computedLifetimeStart = value;
+
+                if (!AlwaysAlive)
+                    base.LifetimeStart = value;
+            }
+        }
+
+        private double computedLifetimeEnd;
+
+        public override double LifetimeEnd
+        {
+            get => base.LifetimeEnd;
+            set
+            {
+                computedLifetimeEnd = value;
+
+                if (!AlwaysAlive)
+                    base.LifetimeEnd = value;
+            }
+        }
+
+        private bool alwaysAlive;
+
+        /// <summary>
+        /// Whether this <see cref="DrawableManiaHitObject"/> should always remain alive.
+        /// </summary>
+        internal bool AlwaysAlive
+        {
+            get => alwaysAlive;
+            set
+            {
+                if (alwaysAlive == value)
+                    return;
+
+                alwaysAlive = value;
+
+                if (value)
+                {
+                    // Set the base lifetimes directly, to avoid mangling the computed lifetimes
+                    base.LifetimeStart = double.MinValue;
+                    base.LifetimeEnd = double.MaxValue;
+                }
+                else
+                {
+                    LifetimeStart = computedLifetimeStart;
+                    LifetimeEnd = computedLifetimeEnd;
+                }
+            }
+        }
 
         protected virtual void OnDirectionChanged(ValueChangedEvent<ScrollingDirection> e)
         {

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/DefaultBodyPiece.cs

@@ -34,7 +34,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
 
         public DefaultBodyPiece()
         {
-            RelativeSizeAxes = Axes.Both;
             Blending = BlendingParameters.Additive;
 
             AddLayout(subtractionCache);

osu.Game.Rulesets.Mania/Objects/HoldNote.cs

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
+using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
@@ -28,7 +30,9 @@ namespace osu.Game.Rulesets.Mania.Objects
             set
             {
                 duration = value;
-                Tail.StartTime = EndTime;
+
+                if (Tail != null)
+                    Tail.StartTime = EndTime;
             }
         }
 
@@ -38,8 +42,12 @@ namespace osu.Game.Rulesets.Mania.Objects
             set
             {
                 base.StartTime = value;
-                Head.StartTime = value;
-                Tail.StartTime = EndTime;
+
+                if (Head != null)
+                    Head.StartTime = value;
+
+                if (Tail != null)
+                    Tail.StartTime = EndTime;
             }
         }
 
@@ -49,20 +57,26 @@ namespace osu.Game.Rulesets.Mania.Objects
             set
             {
                 base.Column = value;
-                Head.Column = value;
-                Tail.Column = value;
+
+                if (Head != null)
+                    Head.Column = value;
+
+                if (Tail != null)
+                    Tail.Column = value;
             }
         }
 
+        public List<IList<HitSampleInfo>> NodeSamples { get; set; }
+
         /// <summary>
         /// The head note of the hold.
         /// </summary>
-        public readonly Note Head = new Note();
+        public Note Head { get; private set; }
 
         /// <summary>
         /// The tail note of the hold.
         /// </summary>
-        public readonly TailNote Tail = new TailNote();
+        public TailNote Tail { get; private set; }
 
         /// <summary>
         /// The time between ticks of this hold.
@@ -83,8 +97,19 @@ namespace osu.Game.Rulesets.Mania.Objects
 
             createTicks();
 
-            AddNested(Head);
-            AddNested(Tail);
+            AddNested(Head = new Note
+            {
+                StartTime = StartTime,
+                Column = Column,
+                Samples = getNodeSamples(0),
+            });
+
+            AddNested(Tail = new TailNote
+            {
+                StartTime = EndTime,
+                Column = Column,
+                Samples = getNodeSamples((NodeSamples?.Count - 1) ?? 1),
+            });
         }
 
         private void createTicks()
@@ -105,5 +130,8 @@ namespace osu.Game.Rulesets.Mania.Objects
         public override Judgement CreateJudgement() => new IgnoreJudgement();
 
         protected override HitWindows CreateHitWindows() => HitWindows.Empty;
+
+        private IList<HitSampleInfo> getNodeSamples(int nodeIndex) =>
+            nodeIndex < NodeSamples?.Count ? NodeSamples[nodeIndex] : Samples;
     }
 }

osu.Game.Rulesets.Mania/Objects/ManiaHitObject.cs

@@ -5,11 +5,12 @@ using osu.Framework.Bindables;
 using osu.Game.Rulesets.Mania.Objects.Types;
 using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Objects
 {
-    public abstract class ManiaHitObject : HitObject, IHasColumn
+    public abstract class ManiaHitObject : HitObject, IHasColumn, IHasXPosition
     {
         public readonly Bindable<int> ColumnBindable = new Bindable<int>();
 
@@ -20,5 +21,11 @@ namespace osu.Game.Rulesets.Mania.Objects
         }
 
         protected override HitWindows CreateHitWindows() => new ManiaHitWindows();
+
+        #region LegacyBeatmapEncoder
+
+        float IHasXPosition.X => Column;
+
+        #endregion
     }
 }

osu.Game.Rulesets.Mania/Replays/ManiaReplayFrame.cs

@@ -1,8 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
-using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Replays.Legacy;
 using osu.Game.Rulesets.Mania.Beatmaps;
@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Mania.Replays
 
             while (activeColumns > 0)
             {
-                var isSpecial = maniaBeatmap.Stages.First().IsSpecialColumn(counter);
+                bool isSpecial = isColumnAtIndexSpecial(maniaBeatmap, counter);
 
                 if ((activeColumns & 1) > 0)
                     Actions.Add(isSpecial ? specialAction : normalAction);
@@ -58,33 +58,87 @@ namespace osu.Game.Rulesets.Mania.Replays
 
             int keys = 0;
 
-            var specialColumns = new List<int>();
-
-            for (int i = 0; i < maniaBeatmap.TotalColumns; i++)
-            {
-                if (maniaBeatmap.Stages.First().IsSpecialColumn(i))
-                    specialColumns.Add(i);
-            }
-
             foreach (var action in Actions)
             {
                 switch (action)
                 {
                     case ManiaAction.Special1:
-                        keys |= 1 << specialColumns[0];
+                        keys |= 1 << getSpecialColumnIndex(maniaBeatmap, 0);
                         break;
 
                     case ManiaAction.Special2:
-                        keys |= 1 << specialColumns[1];
+                        keys |= 1 << getSpecialColumnIndex(maniaBeatmap, 1);
                         break;
 
                     default:
-                        keys |= 1 << (action - ManiaAction.Key1);
+                        // the index in lazer, which doesn't include special keys.
+                        int nonSpecialKeyIndex = action - ManiaAction.Key1;
+
+                        // the index inclusive of special keys.
+                        int overallIndex = 0;
+
+                        // iterate to find the index including special keys.
+                        for (; overallIndex < maniaBeatmap.TotalColumns; overallIndex++)
+                        {
+                            // skip over special columns.
+                            if (isColumnAtIndexSpecial(maniaBeatmap, overallIndex))
+                                continue;
+                            // found a non-special column to use.
+                            if (nonSpecialKeyIndex == 0)
+                                break;
+                            // found a non-special column but not ours.
+                            nonSpecialKeyIndex--;
+                        }
+
+                        keys |= 1 << overallIndex;
                         break;
                 }
             }
 
             return new LegacyReplayFrame(Time, keys, null, ReplayButtonState.None);
         }
+
+        /// <summary>
+        /// Find the overall index (across all stages) for a specified special key.
+        /// </summary>
+        /// <param name="maniaBeatmap">The beatmap.</param>
+        /// <param name="specialOffset">The special key offset (0 is S1).</param>
+        /// <returns>The overall index for the special column.</returns>
+        private int getSpecialColumnIndex(ManiaBeatmap maniaBeatmap, int specialOffset)
+        {
+            for (int i = 0; i < maniaBeatmap.TotalColumns; i++)
+            {
+                if (isColumnAtIndexSpecial(maniaBeatmap, i))
+                {
+                    if (specialOffset == 0)
+                        return i;
+
+                    specialOffset--;
+                }
+            }
+
+            throw new ArgumentException("Special key index is too high.", nameof(specialOffset));
+        }
+
+        /// <summary>
+        /// Check whether the column at an overall index (across all stages) is a special column.
+        /// </summary>
+        /// <param name="beatmap">The beatmap.</param>
+        /// <param name="index">The overall index to check.</param>
+        private bool isColumnAtIndexSpecial(ManiaBeatmap beatmap, int index)
+        {
+            foreach (var stage in beatmap.Stages)
+            {
+                if (index >= stage.Columns)
+                {
+                    index -= stage.Columns;
+                    continue;
+                }
+
+                return stage.IsSpecialColumn(index);
+            }
+
+            throw new ArgumentException("Column index is too high.", nameof(index));
+        }
     }
 }

osu.Game.Rulesets.Mania/SingleStageVariantGenerator.cs

@@ -0,0 +1,41 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Framework.Input.Bindings;
+
+namespace osu.Game.Rulesets.Mania
+{
+    public class SingleStageVariantGenerator
+    {
+        private readonly int variant;
+        private readonly InputKey[] leftKeys;
+        private readonly InputKey[] rightKeys;
+
+        public SingleStageVariantGenerator(int variant)
+        {
+            this.variant = variant;
+
+            // 10K is special because it expands towards the centre of the keyboard (V/N), rather than towards the edges of the keyboard.
+            if (variant == 10)
+            {
+                leftKeys = new[] { InputKey.A, InputKey.S, InputKey.D, InputKey.F, InputKey.V };
+                rightKeys = new[] { InputKey.N, InputKey.J, InputKey.K, InputKey.L, InputKey.Semicolon };
+            }
+            else
+            {
+                leftKeys = new[] { InputKey.A, InputKey.S, InputKey.D, InputKey.F };
+                rightKeys = new[] { InputKey.J, InputKey.K, InputKey.L, InputKey.Semicolon };
+            }
+        }
+
+        public IEnumerable<KeyBinding> GenerateMappings() => new VariantMappingGenerator
+        {
+            LeftKeys = leftKeys,
+            RightKeys = rightKeys,
+            SpecialKey = InputKey.Space,
+            SpecialAction = ManiaAction.Special1,
+            NormalActionStart = ManiaAction.Key1,
+        }.GenerateKeyBindingsFor(variant, out _);
+    }
+}

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

@@ -67,6 +67,7 @@ namespace osu.Game.Rulesets.Mania.Skinning
                 {
                     RelativeSizeAxes = Axes.Y,
                     Width = leftLineWidth,
+                    Scale = new Vector2(0.740f, 1),
                     Colour = lineColour,
                     Alpha = hasLeftLine ? 1 : 0
                 },
@@ -76,6 +77,7 @@ namespace osu.Game.Rulesets.Mania.Skinning
                     Origin = Anchor.TopRight,
                     RelativeSizeAxes = Axes.Y,
                     Width = rightLineWidth,
+                    Scale = new Vector2(0.740f, 1),
                     Colour = lineColour,
                     Alpha = hasRightLine ? 1 : 0
                 },

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

@@ -0,0 +1,61 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Skinning
+{
+    public class LegacyStageBackground : LegacyManiaElement
+    {
+        private Drawable leftSprite;
+        private Drawable rightSprite;
+
+        public LegacyStageBackground()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(ISkinSource skin)
+        {
+            string leftImage = GetManiaSkinConfig<string>(skin, LegacyManiaSkinConfigurationLookups.LeftStageImage)?.Value
+                               ?? "mania-stage-left";
+
+            string rightImage = GetManiaSkinConfig<string>(skin, LegacyManiaSkinConfigurationLookups.RightStageImage)?.Value
+                                ?? "mania-stage-right";
+
+            InternalChildren = new[]
+            {
+                leftSprite = new Sprite
+                {
+                    Anchor = Anchor.TopLeft,
+                    Origin = Anchor.TopRight,
+                    X = 0.05f,
+                    Texture = skin.GetTexture(leftImage),
+                },
+                rightSprite = new Sprite
+                {
+                    Anchor = Anchor.TopRight,
+                    Origin = Anchor.TopLeft,
+                    X = -0.05f,
+                    Texture = skin.GetTexture(rightImage)
+                }
+            };
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (leftSprite?.Height > 0)
+                leftSprite.Scale = new Vector2(DrawHeight / leftSprite.Height);
+
+            if (rightSprite?.Height > 0)
+                rightSprite.Scale = new Vector2(DrawHeight / rightSprite.Height);
+        }
+    }
+}

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

@@ -0,0 +1,56 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Skinning
+{
+    public class LegacyStageForeground : LegacyManiaElement
+    {
+        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
+
+        private Drawable sprite;
+
+        public LegacyStageForeground()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(ISkinSource skin, IScrollingInfo scrollingInfo)
+        {
+            string bottomImage = GetManiaSkinConfig<string>(skin, LegacyManiaSkinConfigurationLookups.BottomStageImage)?.Value
+                                 ?? "mania-stage-bottom";
+
+            sprite = skin.GetAnimation(bottomImage, true, true)?.With(d =>
+            {
+                if (d == null)
+                    return;
+
+                d.Scale = new Vector2(1.6f);
+            });
+
+            if (sprite != null)
+                InternalChild = sprite;
+
+            direction.BindTo(scrollingInfo.Direction);
+            direction.BindValueChanged(onDirectionChanged, true);
+        }
+
+        private void onDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
+        {
+            if (sprite == null)
+                return;
+
+            if (direction.NewValue == ScrollingDirection.Up)
+                sprite.Anchor = sprite.Origin = Anchor.TopCentre;
+            else
+                sprite.Anchor = sprite.Origin = Anchor.BottomCentre;
+        }
+    }
+}

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

@@ -81,6 +81,12 @@ namespace osu.Game.Rulesets.Mania.Skinning
 
                         case ManiaSkinComponents.HitExplosion:
                             return new LegacyHitExplosion();
+
+                        case ManiaSkinComponents.StageBackground:
+                            return new LegacyStageBackground();
+
+                        case ManiaSkinComponents.StageForeground:
+                            return new LegacyStageForeground();
                     }
 
                     break;

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

@@ -0,0 +1,30 @@
+// 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.Framework.Graphics.Shapes;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.UI.Components
+{
+    public class DefaultStageBackground : CompositeDrawable
+    {
+        public DefaultStageBackground()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChild = new Box
+            {
+                Name = "Background",
+                RelativeSizeAxes = Axes.Both,
+                Colour = Color4.Black
+            };
+        }
+    }
+}

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

@@ -2,7 +2,9 @@
 // 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.Audio.Track;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
@@ -48,6 +50,10 @@ namespace osu.Game.Rulesets.Mania.UI
         protected new ManiaRulesetConfigManager Config => (ManiaRulesetConfigManager)base.Config;
 
         private readonly Bindable<ManiaScrollingDirection> configDirection = new Bindable<ManiaScrollingDirection>();
+        private readonly Bindable<double> configTimeRange = new BindableDouble();
+
+        // Stores the current speed adjustment active in gameplay.
+        private readonly Track speedAdjustmentTrack = new TrackVirtual(0);
 
         public DrawableManiaRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods = null)
             : base(ruleset, beatmap, mods)
@@ -58,6 +64,9 @@ namespace osu.Game.Rulesets.Mania.UI
         [BackgroundDependencyLoader]
         private void load()
         {
+            foreach (var mod in Mods.OfType<IApplicableToTrack>())
+                mod.ApplyToTrack(speedAdjustmentTrack);
+
             bool isForCurrentRuleset = Beatmap.BeatmapInfo.Ruleset.Equals(Ruleset.RulesetInfo);
 
             foreach (var p in ControlPoints)
@@ -76,7 +85,7 @@ namespace osu.Game.Rulesets.Mania.UI
             Config.BindWith(ManiaRulesetSetting.ScrollDirection, configDirection);
             configDirection.BindValueChanged(direction => Direction.Value = (ScrollingDirection)direction.NewValue, true);
 
-            Config.BindWith(ManiaRulesetSetting.ScrollTime, TimeRange);
+            Config.BindWith(ManiaRulesetSetting.ScrollTime, configTimeRange);
         }
 
         protected override void AdjustScrollSpeed(int amount)
@@ -86,10 +95,19 @@ namespace osu.Game.Rulesets.Mania.UI
 
         private double relativeTimeRange
         {
-            get => MAX_TIME_RANGE / TimeRange.Value;
-            set => TimeRange.Value = MAX_TIME_RANGE / value;
+            get => MAX_TIME_RANGE / configTimeRange.Value;
+            set => configTimeRange.Value = MAX_TIME_RANGE / value;
         }
 
+        protected override void Update()
+        {
+            base.Update();
+
+            updateTimeRange();
+        }
+
+        private void updateTimeRange() => TimeRange.Value = configTimeRange.Value * speedAdjustmentTrack.AggregateTempo.Value * speedAdjustmentTrack.AggregateFrequency.Value;
+
         /// <summary>
         /// Retrieves the column that intersects a screen-space position.
         /// </summary>

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

@@ -6,6 +6,7 @@ using osu.Framework.Graphics.Containers;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Allocation;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -14,6 +15,7 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
+    [Cached]
     public class ManiaPlayfield : ScrollingPlayfield
     {
         private readonly List<Stage> stages = new List<Stage>();
@@ -71,7 +73,7 @@ namespace osu.Game.Rulesets.Mania.UI
             {
                 foreach (var column in stage.Columns)
                 {
-                    if (column.ReceivePositionalInputAt(screenSpacePosition))
+                    if (column.ReceivePositionalInputAt(new Vector2(screenSpacePosition.X, column.ScreenSpaceDrawQuad.Centre.Y)))
                     {
                         found = column;
                         break;
@@ -85,6 +87,31 @@ namespace osu.Game.Rulesets.Mania.UI
             return found;
         }
 
+        /// <summary>
+        /// Retrieves a <see cref="Column"/> by index.
+        /// </summary>
+        /// <param name="index">The index of the column.</param>
+        /// <returns>The <see cref="Column"/> corresponding to the given index.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">If <paramref name="index"/> is less than 0 or greater than <see cref="TotalColumns"/>.</exception>
+        public Column GetColumn(int index)
+        {
+            if (index < 0 || index > TotalColumns - 1)
+                throw new ArgumentOutOfRangeException(nameof(index));
+
+            foreach (var stage in stages)
+            {
+                if (index >= stage.Columns.Count)
+                {
+                    index -= stage.Columns.Count;
+                    continue;
+                }
+
+                return stage.Columns[index];
+            }
+
+            throw new ArgumentOutOfRangeException(nameof(index));
+        }
+
         /// <summary>
         /// Retrieves the total amount of columns across all stages in this playfield.
         /// </summary>

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

@@ -6,7 +6,6 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
@@ -72,11 +71,9 @@ namespace osu.Game.Rulesets.Mania.UI
                     AutoSizeAxes = Axes.X,
                     Children = new Drawable[]
                     {
-                        new Box
+                        new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.StageBackground), _ => new DefaultStageBackground())
                         {
-                            Name = "Background",
-                            RelativeSizeAxes = Axes.Both,
-                            Colour = Color4.Black
+                            RelativeSizeAxes = Axes.Both
                         },
                         columnFlow = new FillFlowContainer<Column>
                         {
@@ -103,6 +100,10 @@ namespace osu.Game.Rulesets.Mania.UI
                                 RelativeSizeAxes = Axes.Y,
                             }
                         },
+                        new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.StageForeground), _ => null)
+                        {
+                            RelativeSizeAxes = Axes.Both
+                        },
                         judgements = new JudgementContainer<DrawableManiaJudgement>
                         {
                             Anchor = Anchor.TopCentre,

osu.Game.Rulesets.Mania/VariantMappingGenerator.cs

@@ -0,0 +1,61 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Framework.Input.Bindings;
+
+namespace osu.Game.Rulesets.Mania
+{
+    public class VariantMappingGenerator
+    {
+        /// <summary>
+        /// All the <see cref="InputKey"/>s available to the left hand.
+        /// </summary>
+        public InputKey[] LeftKeys;
+
+        /// <summary>
+        /// All the <see cref="InputKey"/>s available to the right hand.
+        /// </summary>
+        public InputKey[] RightKeys;
+
+        /// <summary>
+        /// The <see cref="InputKey"/> for the special key.
+        /// </summary>
+        public InputKey SpecialKey;
+
+        /// <summary>
+        /// The <see cref="ManiaAction"/> at which the normal columns should begin.
+        /// </summary>
+        public ManiaAction NormalActionStart;
+
+        /// <summary>
+        /// The <see cref="ManiaAction"/> for the special column.
+        /// </summary>
+        public ManiaAction SpecialAction;
+
+        /// <summary>
+        /// Generates a list of <see cref="KeyBinding"/>s for a specific number of columns.
+        /// </summary>
+        /// <param name="columns">The number of columns that need to be bound.</param>
+        /// <param name="nextNormalAction">The next <see cref="ManiaAction"/> to use for normal columns.</param>
+        /// <returns>The keybindings.</returns>
+        public IEnumerable<KeyBinding> GenerateKeyBindingsFor(int columns, out ManiaAction nextNormalAction)
+        {
+            ManiaAction currentNormalAction = NormalActionStart;
+
+            var bindings = new List<KeyBinding>();
+
+            for (int i = LeftKeys.Length - columns / 2; i < LeftKeys.Length; i++)
+                bindings.Add(new KeyBinding(LeftKeys[i], currentNormalAction++));
+
+            if (columns % 2 == 1)
+                bindings.Add(new KeyBinding(SpecialKey, SpecialAction));
+
+            for (int i = 0; i < columns / 2; i++)
+                bindings.Add(new KeyBinding(RightKeys[i], currentNormalAction++));
+
+            nextNormalAction = currentNormalAction;
+            return bindings;
+        }
+    }
+}

osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModHidden.cs

@@ -0,0 +1,106 @@
+// 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.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests.Mods
+{
+    public class TestSceneOsuModHidden : ModTestScene
+    {
+        public TestSceneOsuModHidden()
+            : base(new OsuRuleset())
+        {
+        }
+
+        [Test]
+        public void TestDefaultBeatmapTest() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModHidden(),
+            Autoplay = true,
+            PassCondition = checkSomeHit
+        });
+
+        [Test]
+        public void FirstCircleAfterTwoSpinners() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModHidden(),
+            Autoplay = true,
+            Beatmap = new Beatmap
+            {
+                HitObjects = new List<HitObject>
+                {
+                    new Spinner
+                    {
+                        Position = new Vector2(256, 192),
+                        EndTime = 1000,
+                    },
+                    new Spinner
+                    {
+                        Position = new Vector2(256, 192),
+                        StartTime = 1200,
+                        EndTime = 2200,
+                    },
+                    new HitCircle
+                    {
+                        Position = new Vector2(300, 192),
+                        StartTime = 3200,
+                    },
+                    new HitCircle
+                    {
+                        Position = new Vector2(384, 192),
+                        StartTime = 4200,
+                    }
+                }
+            },
+            PassCondition = checkSomeHit
+        });
+
+        [Test]
+        public void FirstSliderAfterTwoSpinners() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModHidden(),
+            Autoplay = true,
+            Beatmap = new Beatmap
+            {
+                HitObjects = new List<HitObject>
+                {
+                    new Spinner
+                    {
+                        Position = new Vector2(256, 192),
+                        EndTime = 1000,
+                    },
+                    new Spinner
+                    {
+                        Position = new Vector2(256, 192),
+                        StartTime = 1200,
+                        EndTime = 2200,
+                    },
+                    new Slider
+                    {
+                        StartTime = 3200,
+                        Path = new SliderPath(PathType.Linear, new[] { Vector2.Zero, new Vector2(100, 0), })
+                    },
+                    new Slider
+                    {
+                        StartTime = 5200,
+                        Path = new SliderPath(PathType.Linear, new[] { Vector2.Zero, new Vector2(100, 0), })
+                    }
+                }
+            },
+            PassCondition = checkSomeHit
+        });
+
+        private bool checkSomeHit()
+        {
+            return Player.ScoreProcessor.JudgedHits >= 4;
+        }
+    }
+}

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

@@ -0,0 +1,447 @@
+// 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.Extensions.TypeExtensions;
+using osu.Framework.Screens;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Screens.Play;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestSceneOutOfOrderHits : RateAdjustedBeatmapTestScene
+    {
+        private const double early_miss_window = 1000; // time after -1000 to -500 is considered a miss
+        private const double late_miss_window = 500; // time after +500 is considered a miss
+
+        /// <summary>
+        /// Tests clicking a future circle before the first circle's start time, while the first circle HAS NOT been judged.
+        /// </summary>
+        [Test]
+        public void TestClickSecondCircleBeforeFirstCircleTime()
+        {
+            const double time_first_circle = 1500;
+            const double time_second_circle = 1600;
+            Vector2 positionFirstCircle = Vector2.Zero;
+            Vector2 positionSecondCircle = new Vector2(80);
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new TestHitCircle
+                {
+                    StartTime = time_first_circle,
+                    Position = positionFirstCircle
+                },
+                new TestHitCircle
+                {
+                    StartTime = time_second_circle,
+                    Position = positionSecondCircle
+                }
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_first_circle - 100, Position = positionSecondCircle, Actions = { OsuAction.LeftButton } }
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Miss);
+            addJudgementAssert(hitObjects[1], HitResult.Miss);
+            addJudgementOffsetAssert(hitObjects[0], late_miss_window);
+        }
+
+        /// <summary>
+        /// Tests clicking a future circle at the first circle's start time, while the first circle HAS NOT been judged.
+        /// </summary>
+        [Test]
+        public void TestClickSecondCircleAtFirstCircleTime()
+        {
+            const double time_first_circle = 1500;
+            const double time_second_circle = 1600;
+            Vector2 positionFirstCircle = Vector2.Zero;
+            Vector2 positionSecondCircle = new Vector2(80);
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new TestHitCircle
+                {
+                    StartTime = time_first_circle,
+                    Position = positionFirstCircle
+                },
+                new TestHitCircle
+                {
+                    StartTime = time_second_circle,
+                    Position = positionSecondCircle
+                }
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_first_circle, Position = positionSecondCircle, Actions = { OsuAction.LeftButton } }
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Miss);
+            addJudgementAssert(hitObjects[1], HitResult.Great);
+            addJudgementOffsetAssert(hitObjects[0], 0);
+        }
+
+        /// <summary>
+        /// Tests clicking a future circle after the first circle's start time, while the first circle HAS NOT been judged.
+        /// </summary>
+        [Test]
+        public void TestClickSecondCircleAfterFirstCircleTime()
+        {
+            const double time_first_circle = 1500;
+            const double time_second_circle = 1600;
+            Vector2 positionFirstCircle = Vector2.Zero;
+            Vector2 positionSecondCircle = new Vector2(80);
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new TestHitCircle
+                {
+                    StartTime = time_first_circle,
+                    Position = positionFirstCircle
+                },
+                new TestHitCircle
+                {
+                    StartTime = time_second_circle,
+                    Position = positionSecondCircle
+                }
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_first_circle + 100, Position = positionSecondCircle, Actions = { OsuAction.LeftButton } }
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Miss);
+            addJudgementAssert(hitObjects[1], HitResult.Great);
+            addJudgementOffsetAssert(hitObjects[0], 100);
+        }
+
+        /// <summary>
+        /// Tests clicking a future circle before the first circle's start time, while the first circle HAS been judged.
+        /// </summary>
+        [Test]
+        public void TestClickSecondCircleBeforeFirstCircleTimeWithFirstCircleJudged()
+        {
+            const double time_first_circle = 1500;
+            const double time_second_circle = 1600;
+            Vector2 positionFirstCircle = Vector2.Zero;
+            Vector2 positionSecondCircle = new Vector2(80);
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new TestHitCircle
+                {
+                    StartTime = time_first_circle,
+                    Position = positionFirstCircle
+                },
+                new TestHitCircle
+                {
+                    StartTime = time_second_circle,
+                    Position = positionSecondCircle
+                }
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_first_circle - 200, Position = positionFirstCircle, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_first_circle - 100, Position = positionSecondCircle, Actions = { OsuAction.RightButton } }
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Great);
+            addJudgementAssert(hitObjects[1], HitResult.Great);
+            addJudgementOffsetAssert(hitObjects[0], -200); // time_first_circle - 200
+            addJudgementOffsetAssert(hitObjects[0], -200); // time_second_circle - first_circle_time - 100
+        }
+
+        /// <summary>
+        /// Tests clicking a future circle after a slider's start time, but hitting all slider ticks.
+        /// </summary>
+        [Test]
+        public void TestMissSliderHeadAndHitAllSliderTicks()
+        {
+            const double time_slider = 1500;
+            const double time_circle = 1510;
+            Vector2 positionCircle = Vector2.Zero;
+            Vector2 positionSlider = new Vector2(80);
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new TestHitCircle
+                {
+                    StartTime = time_circle,
+                    Position = positionCircle
+                },
+                new TestSlider
+                {
+                    StartTime = time_slider,
+                    Position = positionSlider,
+                    Path = new SliderPath(PathType.Linear, new[]
+                    {
+                        Vector2.Zero,
+                        new Vector2(25, 0),
+                    })
+                }
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_slider, Position = positionCircle, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_slider + 10, Position = positionSlider, Actions = { OsuAction.RightButton } }
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Great);
+            addJudgementAssert(hitObjects[1], HitResult.Great);
+            addJudgementAssert("slider head", () => ((Slider)hitObjects[1]).HeadCircle, HitResult.Miss);
+            addJudgementAssert("slider tick", () => ((Slider)hitObjects[1]).NestedHitObjects[1] as SliderTick, HitResult.Great);
+        }
+
+        /// <summary>
+        /// Tests clicking hitting future slider ticks before a circle.
+        /// </summary>
+        [Test]
+        public void TestHitSliderTicksBeforeCircle()
+        {
+            const double time_slider = 1500;
+            const double time_circle = 1510;
+            Vector2 positionCircle = Vector2.Zero;
+            Vector2 positionSlider = new Vector2(80);
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new TestHitCircle
+                {
+                    StartTime = time_circle,
+                    Position = positionCircle
+                },
+                new TestSlider
+                {
+                    StartTime = time_slider,
+                    Position = positionSlider,
+                    Path = new SliderPath(PathType.Linear, new[]
+                    {
+                        Vector2.Zero,
+                        new Vector2(25, 0),
+                    })
+                }
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_slider, Position = positionSlider, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_circle + late_miss_window - 100, Position = positionCircle, Actions = { OsuAction.RightButton } },
+                new OsuReplayFrame { Time = time_circle + late_miss_window - 90, Position = positionSlider, Actions = { OsuAction.LeftButton } },
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Great);
+            addJudgementAssert(hitObjects[1], HitResult.Great);
+            addJudgementAssert("slider head", () => ((Slider)hitObjects[1]).HeadCircle, HitResult.Great);
+            addJudgementAssert("slider tick", () => ((Slider)hitObjects[1]).NestedHitObjects[1] as SliderTick, HitResult.Great);
+        }
+
+        /// <summary>
+        /// Tests clicking a future circle before a spinner.
+        /// </summary>
+        [Test]
+        public void TestHitCircleBeforeSpinner()
+        {
+            const double time_spinner = 1500;
+            const double time_circle = 1800;
+            Vector2 positionCircle = Vector2.Zero;
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new TestSpinner
+                {
+                    StartTime = time_spinner,
+                    Position = new Vector2(256, 192),
+                    EndTime = time_spinner + 1000,
+                },
+                new TestHitCircle
+                {
+                    StartTime = time_circle,
+                    Position = positionCircle
+                },
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_spinner - 100, Position = positionCircle, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_spinner + 10, Position = new Vector2(236, 192), Actions = { OsuAction.RightButton } },
+                new OsuReplayFrame { Time = time_spinner + 20, Position = new Vector2(256, 172), Actions = { OsuAction.RightButton } },
+                new OsuReplayFrame { Time = time_spinner + 30, Position = new Vector2(276, 192), Actions = { OsuAction.RightButton } },
+                new OsuReplayFrame { Time = time_spinner + 40, Position = new Vector2(256, 212), Actions = { OsuAction.RightButton } },
+                new OsuReplayFrame { Time = time_spinner + 50, Position = new Vector2(236, 192), Actions = { OsuAction.RightButton } },
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Great);
+            addJudgementAssert(hitObjects[1], HitResult.Great);
+        }
+
+        [Test]
+        public void TestHitSliderHeadBeforeHitCircle()
+        {
+            const double time_circle = 1000;
+            const double time_slider = 1200;
+            Vector2 positionCircle = Vector2.Zero;
+            Vector2 positionSlider = new Vector2(80);
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new TestHitCircle
+                {
+                    StartTime = time_circle,
+                    Position = positionCircle
+                },
+                new TestSlider
+                {
+                    StartTime = time_slider,
+                    Position = positionSlider,
+                    Path = new SliderPath(PathType.Linear, new[]
+                    {
+                        Vector2.Zero,
+                        new Vector2(25, 0),
+                    })
+                }
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_circle - 100, Position = positionSlider, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_circle, Position = positionCircle, Actions = { OsuAction.RightButton } },
+                new OsuReplayFrame { Time = time_slider, Position = positionSlider, Actions = { OsuAction.LeftButton } },
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Great);
+            addJudgementAssert(hitObjects[1], HitResult.Great);
+        }
+
+        private void addJudgementAssert(OsuHitObject hitObject, HitResult result)
+        {
+            AddAssert($"({hitObject.GetType().ReadableName()} @ {hitObject.StartTime}) judgement is {result}",
+                () => judgementResults.Single(r => r.HitObject == hitObject).Type == result);
+        }
+
+        private void addJudgementAssert(string name, Func<OsuHitObject> hitObject, HitResult result)
+        {
+            AddAssert($"{name} judgement is {result}",
+                () => judgementResults.Single(r => r.HitObject == hitObject()).Type == result);
+        }
+
+        private void addJudgementOffsetAssert(OsuHitObject hitObject, double offset)
+        {
+            AddAssert($"({hitObject.GetType().ReadableName()} @ {hitObject.StartTime}) judged at {offset}",
+                () => Precision.AlmostEquals(judgementResults.Single(r => r.HitObject == hitObject).TimeOffset, offset, 100));
+        }
+
+        private ScoreAccessibleReplayPlayer currentPlayer;
+        private List<JudgementResult> judgementResults;
+
+        private void performTest(List<OsuHitObject> hitObjects, List<ReplayFrame> frames)
+        {
+            AddStep("load player", () =>
+            {
+                Beatmap.Value = CreateWorkingBeatmap(new Beatmap<OsuHitObject>
+                {
+                    HitObjects = hitObjects,
+                    BeatmapInfo =
+                    {
+                        BaseDifficulty = new BeatmapDifficulty { SliderTickRate = 3 },
+                        Ruleset = new OsuRuleset().RulesetInfo
+                    },
+                });
+
+                Beatmap.Value.Beatmap.ControlPointInfo.Add(0, new DifficultyControlPoint { SpeedMultiplier = 0.1f });
+
+                var p = new ScoreAccessibleReplayPlayer(new Score { Replay = new Replay { Frames = frames } });
+
+                p.OnLoadComplete += _ =>
+                {
+                    p.ScoreProcessor.NewJudgement += result =>
+                    {
+                        if (currentPlayer == p) judgementResults.Add(result);
+                    };
+                };
+
+                LoadScreen(currentPlayer = p);
+                judgementResults = new List<JudgementResult>();
+            });
+
+            AddUntilStep("Beatmap at 0", () => Beatmap.Value.Track.CurrentTime == 0);
+            AddUntilStep("Wait until player is loaded", () => currentPlayer.IsCurrentScreen());
+            AddUntilStep("Wait for completion", () => currentPlayer.ScoreProcessor.HasCompleted.Value);
+        }
+
+        private class TestHitCircle : HitCircle
+        {
+            protected override HitWindows CreateHitWindows() => new TestHitWindows();
+        }
+
+        private class TestSlider : Slider
+        {
+            public TestSlider()
+            {
+                DefaultsApplied += () =>
+                {
+                    HeadCircle.HitWindows = new TestHitWindows();
+                    TailCircle.HitWindows = new TestHitWindows();
+
+                    HeadCircle.HitWindows.SetDifficulty(0);
+                    TailCircle.HitWindows.SetDifficulty(0);
+                };
+            }
+        }
+
+        private class TestSpinner : Spinner
+        {
+            protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
+            {
+                base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
+                SpinsRequired = 1;
+            }
+        }
+
+        private class TestHitWindows : HitWindows
+        {
+            private static readonly DifficultyRange[] ranges =
+            {
+                new DifficultyRange(HitResult.Great, 500, 500, 500),
+                new DifficultyRange(HitResult.Miss, early_miss_window, early_miss_window, early_miss_window),
+            };
+
+            public override bool IsHitResultAllowed(HitResult result) => result == HitResult.Great || result == HitResult.Miss;
+
+            protected override DifficultyRange[] GetRanges() => ranges;
+        }
+
+        private class ScoreAccessibleReplayPlayer : ReplayPlayer
+        {
+            public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
+
+            protected override bool PauseOnFocusLost => false;
+
+            public ScoreAccessibleReplayPlayer(Score score)
+                : base(score, false, false)
+            {
+            }
+        }
+    }
+}

osu.Game.Rulesets.Osu.Tests/TestScenePathControlPointVisualiser.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;
+using System.Collections.Generic;
+using System.Linq;
+using Humanizer;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestScenePathControlPointVisualiser : OsuTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(StringHumanizeExtensions),
+            typeof(PathControlPointPiece),
+            typeof(PathControlPointConnectionPiece)
+        };
+
+        private Slider slider;
+        private PathControlPointVisualiser visualiser;
+
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            slider = new Slider();
+            slider.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+        });
+
+        [Test]
+        public void TestAddOverlappingControlPoints()
+        {
+            createVisualiser(true);
+
+            addControlPointStep(new Vector2(200));
+            addControlPointStep(new Vector2(300));
+            addControlPointStep(new Vector2(300));
+            addControlPointStep(new Vector2(500, 300));
+
+            AddAssert("last connection displayed", () =>
+            {
+                var lastConnection = visualiser.Connections.Last(c => c.ControlPoint.Position.Value == new Vector2(300));
+                return lastConnection.DrawWidth > 50;
+            });
+        }
+
+        private void createVisualiser(bool allowSelection) => AddStep("create visualiser", () => Child = visualiser = new PathControlPointVisualiser(slider, allowSelection)
+        {
+            Anchor = Anchor.Centre,
+            Origin = Anchor.Centre
+        });
+
+        private void addControlPointStep(Vector2 position) => AddStep($"add control point {position}", () => slider.Path.ControlPoints.Add(new PathControlPoint(position)));
+    }
+}

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

@@ -47,7 +47,6 @@ namespace osu.Game.Rulesets.Osu.Tests
         private const double time_slider_end = 4000;
 
         private List<JudgementResult> judgementResults;
-        private bool allJudgedFired;
 
         /// <summary>
         /// Scenario:
@@ -375,20 +374,15 @@ namespace osu.Game.Rulesets.Osu.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.Osu.Tests/TestSceneSliderPlacementBlueprint.cs

@@ -1,18 +1,302 @@
 // 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.Utils;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
+using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
     public class TestSceneSliderPlacementBlueprint : PlacementBlueprintTestScene
     {
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            HitObjectContainer.Clear();
+            ResetPlacement();
+        });
+
+        [Test]
+        public void TestBeginPlacementWithoutFinishing()
+        {
+            addMovementStep(new Vector2(200));
+            addClickStep(MouseButton.Left);
+
+            assertPlaced(false);
+        }
+
+        [Test]
+        public void TestPlaceWithoutMovingMouse()
+        {
+            addMovementStep(new Vector2(200));
+            addClickStep(MouseButton.Left);
+            addClickStep(MouseButton.Right);
+
+            assertPlaced(true);
+            assertLength(0);
+            assertControlPointType(0, PathType.Linear);
+        }
+
+        [Test]
+        public void TestPlaceWithMouseMovement()
+        {
+            addMovementStep(new Vector2(200));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(400, 200));
+            addClickStep(MouseButton.Right);
+
+            assertPlaced(true);
+            assertLength(200);
+            assertControlPointCount(2);
+            assertControlPointType(0, PathType.Linear);
+        }
+
+        [Test]
+        public void TestPlaceNormalControlPoint()
+        {
+            addMovementStep(new Vector2(200));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(300, 200));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(300));
+            addClickStep(MouseButton.Right);
+
+            assertPlaced(true);
+            assertControlPointCount(3);
+            assertControlPointPosition(1, new Vector2(100, 0));
+            assertControlPointType(0, PathType.PerfectCurve);
+        }
+
+        [Test]
+        public void TestPlaceTwoNormalControlPoints()
+        {
+            addMovementStep(new Vector2(200));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(300, 200));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(300));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(400, 300));
+            addClickStep(MouseButton.Right);
+
+            assertPlaced(true);
+            assertControlPointCount(4);
+            assertControlPointPosition(1, new Vector2(100, 0));
+            assertControlPointPosition(2, new Vector2(100, 100));
+            assertControlPointType(0, PathType.Bezier);
+        }
+
+        [Test]
+        public void TestPlaceSegmentControlPoint()
+        {
+            addMovementStep(new Vector2(200));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(300, 200));
+            addClickStep(MouseButton.Left);
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(300));
+            addClickStep(MouseButton.Right);
+
+            assertPlaced(true);
+            assertControlPointCount(3);
+            assertControlPointPosition(1, new Vector2(100, 0));
+            assertControlPointType(0, PathType.Linear);
+            assertControlPointType(1, PathType.Linear);
+        }
+
+        [Test]
+        public void TestMoveToPerfectCurveThenPlaceLinear()
+        {
+            addMovementStep(new Vector2(200));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(300, 200));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(300));
+            addMovementStep(new Vector2(300, 200));
+            addClickStep(MouseButton.Right);
+
+            assertPlaced(true);
+            assertControlPointCount(2);
+            assertControlPointType(0, PathType.Linear);
+            assertLength(100);
+        }
+
+        [Test]
+        public void TestMoveToBezierThenPlacePerfectCurve()
+        {
+            addMovementStep(new Vector2(200));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(300, 200));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(300));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(400, 300));
+            addMovementStep(new Vector2(300));
+            addClickStep(MouseButton.Right);
+
+            assertPlaced(true);
+            assertControlPointCount(3);
+            assertControlPointType(0, PathType.PerfectCurve);
+        }
+
+        [Test]
+        public void TestMoveToFourthOrderBezierThenPlaceThirdOrderBezier()
+        {
+            addMovementStep(new Vector2(200));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(300, 200));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(300));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(400, 300));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(400));
+            addMovementStep(new Vector2(400, 300));
+            addClickStep(MouseButton.Right);
+
+            assertPlaced(true);
+            assertControlPointCount(4);
+            assertControlPointType(0, PathType.Bezier);
+        }
+
+        [Test]
+        public void TestPlaceLinearSegmentThenPlaceLinearSegment()
+        {
+            addMovementStep(new Vector2(200));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(300, 200));
+            addClickStep(MouseButton.Left);
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(300, 300));
+            addClickStep(MouseButton.Right);
+
+            assertPlaced(true);
+            assertControlPointCount(3);
+            assertControlPointPosition(1, new Vector2(100, 0));
+            assertControlPointPosition(2, new Vector2(100));
+            assertControlPointType(0, PathType.Linear);
+            assertControlPointType(1, PathType.Linear);
+        }
+
+        [Test]
+        public void TestPlaceLinearSegmentThenPlacePerfectCurveSegment()
+        {
+            addMovementStep(new Vector2(200));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(300, 200));
+            addClickStep(MouseButton.Left);
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(300, 300));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(400, 300));
+            addClickStep(MouseButton.Right);
+
+            assertPlaced(true);
+            assertControlPointCount(4);
+            assertControlPointPosition(1, new Vector2(100, 0));
+            assertControlPointPosition(2, new Vector2(100));
+            assertControlPointType(0, PathType.Linear);
+            assertControlPointType(1, PathType.PerfectCurve);
+        }
+
+        [Test]
+        public void TestPlacePerfectCurveSegmentThenPlacePerfectCurveSegment()
+        {
+            addMovementStep(new Vector2(200));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(300, 200));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(300, 300));
+            addClickStep(MouseButton.Left);
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(400, 300));
+            addClickStep(MouseButton.Left);
+
+            addMovementStep(new Vector2(400));
+            addClickStep(MouseButton.Right);
+
+            assertPlaced(true);
+            assertControlPointCount(5);
+            assertControlPointPosition(1, new Vector2(100, 0));
+            assertControlPointPosition(2, new Vector2(100));
+            assertControlPointPosition(3, new Vector2(200, 100));
+            assertControlPointPosition(4, new Vector2(200));
+            assertControlPointType(0, PathType.PerfectCurve);
+            assertControlPointType(2, PathType.PerfectCurve);
+        }
+
+        [Test]
+        public void TestBeginPlacementWithoutReleasingMouse()
+        {
+            addMovementStep(new Vector2(200));
+            AddStep("press left button", () => InputManager.PressButton(MouseButton.Left));
+
+            addMovementStep(new Vector2(400, 200));
+            AddStep("release left button", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            addClickStep(MouseButton.Right);
+
+            assertPlaced(true);
+            assertLength(200);
+            assertControlPointCount(2);
+            assertControlPointType(0, PathType.Linear);
+        }
+
+        private void addMovementStep(Vector2 position) => AddStep($"move mouse to {position}", () => InputManager.MoveMouseTo(InputManager.ToScreenSpace(position)));
+
+        private void addClickStep(MouseButton button)
+        {
+            AddStep($"press {button}", () => InputManager.PressButton(button));
+            AddStep($"release {button}", () => InputManager.ReleaseButton(button));
+        }
+
+        private void assertPlaced(bool expected) => AddAssert($"slider {(expected ? "placed" : "not placed")}", () => (getSlider() != null) == expected);
+
+        private void assertLength(double expected) => AddAssert($"slider length is {expected}", () => Precision.AlmostEquals(expected, getSlider().Distance, 1));
+
+        private void assertControlPointCount(int expected) => AddAssert($"has {expected} control points", () => getSlider().Path.ControlPoints.Count == expected);
+
+        private void assertControlPointType(int index, PathType type) => AddAssert($"control point {index} is {type}", () => getSlider().Path.ControlPoints[index].Type.Value == type);
+
+        private void assertControlPointPosition(int index, Vector2 position) =>
+            AddAssert($"control point {index} at {position}", () => Precision.AlmostEquals(position, getSlider().Path.ControlPoints[index].Position.Value, 1));
+
+        private Slider getSlider() => HitObjectContainer.Count > 0 ? (Slider)((DrawableSlider)HitObjectContainer[0]).HitObject : null;
+
         protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableSlider((Slider)hitObject);
         protected override PlacementBlueprint CreateBlueprint() => new SliderPlacementBlueprint();
     }

osu.Game.Rulesets.Osu.Tests/osu.Game.Rulesets.Osu.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.Osu/Beatmaps/OsuBeatmapProcessor.cs

@@ -66,7 +66,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                         double stackThreshold = objectN.TimePreempt * beatmap.BeatmapInfo.StackLeniency;
 
                         if (objectN.StartTime - endTime > stackThreshold)
-                            //We are no longer within stacking range of the next object.
+                            // We are no longer within stacking range of the next object.
                             break;
 
                         if (Vector2Extensions.Distance(stackBaseObject.Position, objectN.Position) < stack_distance
@@ -88,7 +88,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                 }
             }
 
-            //Reverse pass for stack calculation.
+            // Reverse pass for stack calculation.
             int extendedStartIndex = startIndex;
 
             for (int i = extendedEndIndex; i > startIndex; i--)
@@ -124,7 +124,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                         double endTime = objectN.GetEndTime();
 
                         if (objectI.StartTime - endTime > stackThreshold)
-                            //We are no longer within stacking range of the previous object.
+                            // We are no longer within stacking range of the previous object.
                             break;
 
                         // HitObjects before the specified update range haven't been reset yet
@@ -145,20 +145,20 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
 
                             for (int j = n + 1; j <= i; j++)
                             {
-                                //For each object which was declared under this slider, we will offset it to appear *below* the slider end (rather than above).
+                                // For each object which was declared under this slider, we will offset it to appear *below* the slider end (rather than above).
                                 OsuHitObject objectJ = beatmap.HitObjects[j];
                                 if (Vector2Extensions.Distance(objectN.EndPosition, objectJ.Position) < stack_distance)
                                     objectJ.StackHeight -= offset;
                             }
 
-                            //We have hit a slider.  We should restart calculation using this as the new base.
-                            //Breaking here will mean that the slider still has StackCount of 0, so will be handled in the i-outer-loop.
+                            // We have hit a slider.  We should restart calculation using this as the new base.
+                            // Breaking here will mean that the slider still has StackCount of 0, so will be handled in the i-outer-loop.
                             break;
                         }
 
                         if (Vector2Extensions.Distance(objectN.Position, objectI.Position) < stack_distance)
                         {
-                            //Keep processing as if there are no sliders.  If we come across a slider, this gets cancelled out.
+                            // Keep processing as if there are no sliders.  If we come across a slider, this gets cancelled out.
                             //NOTE: Sliders with start positions stacking are a special case that is also handled here.
 
                             objectN.StackHeight = objectI.StackHeight + 1;
@@ -177,7 +177,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                         if (objectN is Spinner) continue;
 
                         if (objectI.StartTime - objectN.StartTime > stackThreshold)
-                            //We are no longer within stacking range of the previous object.
+                            // We are no longer within stacking range of the previous object.
                             break;
 
                         if (Vector2Extensions.Distance(objectN.EndPosition, objectI.Position) < stack_distance)
@@ -221,7 +221,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                     }
                     else if (Vector2Extensions.Distance(beatmap.HitObjects[j].Position, position2) < stack_distance)
                     {
-                        //Case for sliders - bump notes down and right, rather than up and left.
+                        // Case for sliders - bump notes down and right, rather than up and left.
                         sliderStack++;
                         beatmap.HitObjects[j].StackHeight -= sliderStack;
                         startTime = beatmap.HitObjects[j].GetEndTime();

osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/HitCirclePlacementBlueprint.cs

@@ -6,6 +6,7 @@ using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles
 {
@@ -28,16 +29,17 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles
             circlePiece.UpdateFrom(HitObject);
         }
 
-        protected override bool OnClick(ClickEvent e)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
-            EndPlacement(true);
-            return true;
+            if (e.Button == MouseButton.Left)
+            {
+                EndPlacement(true);
+                return true;
+            }
+
+            return base.OnMouseDown(e);
         }
 
-        public override void UpdatePosition(Vector2 screenSpacePosition)
-        {
-            BeginPlacement();
-            HitObject.Position = ToLocalSpace(screenSpacePosition);
-        }
+        public override void UpdatePosition(Vector2 screenSpacePosition) => HitObject.Position = ToLocalSpace(screenSpacePosition);
     }
 }

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointConnectionPiece.cs

@@ -16,22 +16,25 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
     /// </summary>
     public class PathControlPointConnectionPiece : CompositeDrawable
     {
-        public PathControlPoint ControlPoint;
+        public readonly PathControlPoint ControlPoint;
 
         private readonly Path path;
         private readonly Slider slider;
+        private readonly int controlPointIndex;
 
         private IBindable<Vector2> sliderPosition;
         private IBindable<int> pathVersion;
 
-        public PathControlPointConnectionPiece(Slider slider, PathControlPoint controlPoint)
+        public PathControlPointConnectionPiece(Slider slider, int controlPointIndex)
         {
             this.slider = slider;
-            ControlPoint = controlPoint;
+            this.controlPointIndex = controlPointIndex;
 
             Origin = Anchor.Centre;
             AutoSizeAxes = Axes.Both;
 
+            ControlPoint = slider.Path.ControlPoints[controlPointIndex];
+
             InternalChild = path = new SmoothPath
             {
                 Anchor = Anchor.Centre,
@@ -61,13 +64,12 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 
             path.ClearVertices();
 
-            int index = slider.Path.ControlPoints.IndexOf(ControlPoint) + 1;
-
-            if (index == 0 || index == slider.Path.ControlPoints.Count)
+            int nextIndex = controlPointIndex + 1;
+            if (nextIndex == 0 || nextIndex >= slider.Path.ControlPoints.Count)
                 return;
 
             path.AddVertex(Vector2.Zero);
-            path.AddVertex(slider.Path.ControlPoints[index].Position.Value - ControlPoint.Position.Value);
+            path.AddVertex(slider.Path.ControlPoints[nextIndex].Position.Value - ControlPoint.Position.Value);
 
             path.OriginPosition = path.PositionInBoundingBox(Vector2.Zero);
         }

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointPiece.cs

@@ -4,6 +4,7 @@
 using System;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -12,6 +13,7 @@ using osu.Game.Graphics;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit;
 using osuTK;
 using osuTK.Graphics;
 using osuTK.Input;
@@ -26,13 +28,15 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
         public Action<PathControlPointPiece, MouseButtonEvent> RequestSelection;
 
         public readonly BindableBool IsSelected = new BindableBool();
-
         public readonly PathControlPoint ControlPoint;
 
         private readonly Slider slider;
         private readonly Container marker;
         private readonly Drawable markerRing;
 
+        [Resolved(CanBeNull = true)]
+        private IEditorChangeHandler changeHandler { get; set; }
+
         [Resolved(CanBeNull = true)]
         private IDistanceSnapProvider snapProvider { get; set; }
 
@@ -47,6 +51,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
             this.slider = slider;
             ControlPoint = controlPoint;
 
+            controlPoint.Type.BindValueChanged(_ => updateMarkerDisplay());
+
             Origin = Anchor.Centre;
             AutoSizeAxes = Axes.Both;
 
@@ -137,7 +143,19 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 
         protected override bool OnClick(ClickEvent e) => RequestSelection != null;
 
-        protected override bool OnDragStart(DragStartEvent e) => e.Button == MouseButton.Left;
+        protected override bool OnDragStart(DragStartEvent e)
+        {
+            if (RequestSelection == null)
+                return false;
+
+            if (e.Button == MouseButton.Left)
+            {
+                changeHandler?.BeginChange();
+                return true;
+            }
+
+            return false;
+        }
 
         protected override void OnDrag(DragEvent e)
         {
@@ -158,6 +176,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
                 ControlPoint.Position.Value += e.Delta;
         }
 
+        protected override void OnDragEnd(DragEndEvent e) => changeHandler?.EndChange();
+
         /// <summary>
         /// Updates the state of the circular control point marker.
         /// </summary>
@@ -168,8 +188,10 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
             markerRing.Alpha = IsSelected.Value ? 1 : 0;
 
             Color4 colour = ControlPoint.Type.Value != null ? colours.Red : colours.Yellow;
+
             if (IsHovered || IsSelected.Value)
-                colour = Color4.White;
+                colour = colour.Lighten(1);
+
             marker.Colour = colour;
         }
     }

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Specialized;
 using System.Linq;
 using Humanizer;
 using osu.Framework.Bindables;
@@ -24,17 +25,14 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
     public class PathControlPointVisualiser : CompositeDrawable, IKeyBindingHandler<PlatformAction>, IHasContextMenu
     {
         internal readonly Container<PathControlPointPiece> Pieces;
+        internal readonly Container<PathControlPointConnectionPiece> Connections;
 
-        private readonly Container<PathControlPointConnectionPiece> connections;
-
+        private readonly IBindableList<PathControlPoint> controlPoints = new BindableList<PathControlPoint>();
         private readonly Slider slider;
-
         private readonly bool allowSelection;
 
         private InputManager inputManager;
 
-        private IBindableList<PathControlPoint> controlPoints;
-
         public Action<List<PathControlPoint>> RemoveControlPointsRequested;
 
         public PathControlPointVisualiser(Slider slider, bool allowSelection)
@@ -46,7 +44,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 
             InternalChildren = new Drawable[]
             {
-                connections = new Container<PathControlPointConnectionPiece> { RelativeSizeAxes = Axes.Both },
+                Connections = new Container<PathControlPointConnectionPiece> { RelativeSizeAxes = Axes.Both },
                 Pieces = new Container<PathControlPointPiece> { RelativeSizeAxes = Axes.Both }
             };
         }
@@ -57,33 +55,38 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 
             inputManager = GetContainingInputManager();
 
-            controlPoints = slider.Path.ControlPoints.GetBoundCopy();
-            controlPoints.ItemsAdded += addControlPoints;
-            controlPoints.ItemsRemoved += removeControlPoints;
-
-            addControlPoints(controlPoints);
+            controlPoints.CollectionChanged += onControlPointsChanged;
+            controlPoints.BindTo(slider.Path.ControlPoints);
         }
 
-        private void addControlPoints(IEnumerable<PathControlPoint> controlPoints)
+        private void onControlPointsChanged(object sender, NotifyCollectionChangedEventArgs e)
         {
-            foreach (var point in controlPoints)
+            switch (e.Action)
             {
-                Pieces.Add(new PathControlPointPiece(slider, point).With(d =>
-                {
-                    if (allowSelection)
-                        d.RequestSelection = selectPiece;
-                }));
+                case NotifyCollectionChangedAction.Add:
+                    for (int i = 0; i < e.NewItems.Count; i++)
+                    {
+                        var point = (PathControlPoint)e.NewItems[i];
 
-                connections.Add(new PathControlPointConnectionPiece(slider, point));
-            }
-        }
+                        Pieces.Add(new PathControlPointPiece(slider, point).With(d =>
+                        {
+                            if (allowSelection)
+                                d.RequestSelection = selectPiece;
+                        }));
 
-        private void removeControlPoints(IEnumerable<PathControlPoint> controlPoints)
-        {
-            foreach (var point in controlPoints)
-            {
-                Pieces.RemoveAll(p => p.ControlPoint == point);
-                connections.RemoveAll(c => c.ControlPoint == point);
+                        Connections.Add(new PathControlPointConnectionPiece(slider, e.NewStartingIndex + i));
+                    }
+
+                    break;
+
+                case NotifyCollectionChangedAction.Remove:
+                    foreach (var point in e.OldItems.Cast<PathControlPoint>())
+                    {
+                        Pieces.RemoveAll(p => p.ControlPoint == point);
+                        Connections.RemoveAll(c => c.ControlPoint == point);
+                    }
+
+                    break;
             }
         }
 

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs

@@ -1,6 +1,9 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Diagnostics;
+using System.Linq;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Input;
@@ -23,6 +26,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
         private SliderBodyPiece bodyPiece;
         private HitCirclePiece headCirclePiece;
         private HitCirclePiece tailCirclePiece;
+        private PathControlPointVisualiser controlPointVisualiser;
 
         private InputManager inputManager;
 
@@ -51,7 +55,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                 bodyPiece = new SliderBodyPiece(),
                 headCirclePiece = new HitCirclePiece(),
                 tailCirclePiece = new HitCirclePiece(),
-                new PathControlPointVisualiser(HitObject, false)
+                controlPointVisualiser = new PathControlPointVisualiser(HitObject, false)
             };
 
             setState(PlacementState.Initial);
@@ -73,17 +77,16 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                     break;
 
                 case PlacementState.Body:
-                    ensureCursor();
-
-                    // The given screen-space position may have been externally snapped, but the unsnapped position from the input manager
-                    // is used instead since snapping control points doesn't make much sense
-                    cursor.Position.Value = ToLocalSpace(inputManager.CurrentState.Mouse.Position) - HitObject.Position;
+                    updateCursor();
                     break;
             }
         }
 
-        protected override bool OnClick(ClickEvent e)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
+            if (e.Button != MouseButton.Left)
+                return base.OnMouseDown(e);
+
             switch (state)
             {
                 case PlacementState.Initial:
@@ -91,14 +94,21 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                     break;
 
                 case PlacementState.Body:
-                    switch (e.Button)
+                    if (canPlaceNewControlPoint(out var lastPoint))
                     {
-                        case MouseButton.Left:
-                            ensureCursor();
+                        // Place a new point by detatching the current cursor.
+                        updateCursor();
+                        cursor = null;
+                    }
+                    else
+                    {
+                        // Transform the last point into a new segment.
+                        Debug.Assert(lastPoint != null);
 
-                            // Detatch the cursor
-                            cursor = null;
-                            break;
+                        segmentStart = lastPoint;
+                        segmentStart.Type.Value = PathType.Linear;
+
+                        currentSegmentLength = 1;
                     }
 
                     break;
@@ -114,16 +124,6 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             base.OnMouseUp(e);
         }
 
-        protected override bool OnDoubleClick(DoubleClickEvent e)
-        {
-            // Todo: This should all not occur on double click, but rather if the previous control point is hovered.
-            segmentStart = HitObject.Path.ControlPoints[^1];
-            segmentStart.Type.Value = PathType.Linear;
-
-            currentSegmentLength = 1;
-            return true;
-        }
-
         private void beginCurve()
         {
             BeginPlacement(commitStart: true);
@@ -161,17 +161,50 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             }
         }
 
-        private void ensureCursor()
+        private void updateCursor()
         {
-            if (cursor == null)
+            if (canPlaceNewControlPoint(out _))
             {
-                HitObject.Path.ControlPoints.Add(cursor = new PathControlPoint { Position = { Value = Vector2.Zero } });
-                currentSegmentLength++;
+                // The cursor does not overlap a previous control point, so it can be added if not already existing.
+                if (cursor == null)
+                {
+                    HitObject.Path.ControlPoints.Add(cursor = new PathControlPoint { Position = { Value = Vector2.Zero } });
 
+                    // The path type should be adjusted in the progression of updatePathType() (Linear -> PC -> Bezier).
+                    currentSegmentLength++;
+                    updatePathType();
+                }
+
+                // Update the cursor position.
+                cursor.Position.Value = ToLocalSpace(inputManager.CurrentState.Mouse.Position) - HitObject.Position;
+            }
+            else if (cursor != null)
+            {
+                // The cursor overlaps a previous control point, so it's removed.
+                HitObject.Path.ControlPoints.Remove(cursor);
+                cursor = null;
+
+                // The path type should be adjusted in the reverse progression of updatePathType() (Bezier -> PC -> Linear).
+                currentSegmentLength--;
                 updatePathType();
             }
         }
 
+        /// <summary>
+        /// Whether a new control point can be placed at the current mouse position.
+        /// </summary>
+        /// <param name="lastPoint">The last-placed control point. May be null, but is not null if <c>false</c> is returned.</param>
+        /// <returns>Whether a new control point can be placed at the current position.</returns>
+        private bool canPlaceNewControlPoint([CanBeNull] out PathControlPoint lastPoint)
+        {
+            // We cannot rely on the ordering of drawable pieces, so find the respective drawable piece by searching for the last non-cursor control point.
+            var last = HitObject.Path.ControlPoints.LastOrDefault(p => p != cursor);
+            var lastPiece = controlPointVisualiser.Pieces.Single(p => p.ControlPoint == last);
+
+            lastPoint = last;
+            return lastPiece?.IsHovered != true;
+        }
+
         private void updateSlider()
         {
             HitObject.Path.ExpectedDistance.Value = composer?.GetSnappedDistanceFromDistance(HitObject.StartTime, (float)HitObject.Path.CalculatedDistance) ?? (float)HitObject.Path.CalculatedDistance;

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs

@@ -15,6 +15,7 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Compose;
 using osuTK;
 using osuTK.Input;
@@ -34,6 +35,12 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
         [Resolved(CanBeNull = true)]
         private IPlacementHandler placementHandler { get; set; }
 
+        [Resolved(CanBeNull = true)]
+        private EditorBeatmap editorBeatmap { get; set; }
+
+        [Resolved(CanBeNull = true)]
+        private IEditorChangeHandler changeHandler { get; set; }
+
         public SliderSelectionBlueprint(DrawableSlider slider)
             : base(slider)
         {
@@ -88,7 +95,16 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 
         private int? placementControlPointIndex;
 
-        protected override bool OnDragStart(DragStartEvent e) => placementControlPointIndex != null;
+        protected override bool OnDragStart(DragStartEvent e)
+        {
+            if (placementControlPointIndex != null)
+            {
+                changeHandler?.BeginChange();
+                return true;
+            }
+
+            return false;
+        }
 
         protected override void OnDrag(DragEvent e)
         {
@@ -99,7 +115,11 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 
         protected override void OnDragEnd(DragEndEvent e)
         {
-            placementControlPointIndex = null;
+            if (placementControlPointIndex != null)
+            {
+                placementControlPointIndex = null;
+                changeHandler?.EndChange();
+            }
         }
 
         private BindableList<PathControlPoint> controlPoints => HitObject.Path.ControlPoints;
@@ -162,7 +182,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
         private void updatePath()
         {
             HitObject.Path.ExpectedDistance.Value = composer?.GetSnappedDistanceFromDistance(HitObject.StartTime, (float)HitObject.Path.CalculatedDistance) ?? (float)HitObject.Path.CalculatedDistance;
-            UpdateHitObject();
+            editorBeatmap?.UpdateHitObject(HitObject);
         }
 
         public override MenuItem[] ContextMenuItems => new MenuItem[]

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

@@ -23,6 +23,8 @@ namespace osu.Game.Rulesets.Osu.Mods
         private const double fade_in_duration_multiplier = 0.4;
         private const double fade_out_duration_multiplier = 0.3;
 
+        protected override bool IsFirstHideableObject(DrawableHitObject hitObject) => !(hitObject is DrawableSpinner);
+
         public override void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
         {
             static void adjustFadeIn(OsuHitObject h) => h.TimeFadeIn = h.TimePreempt * fade_in_duration_multiplier;

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

@@ -11,11 +11,12 @@ using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play;
 using static osu.Game.Input.Handlers.ReplayInputHandler;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModRelax : ModRelax, IUpdatableByPlayfield, IApplicableToDrawableRuleset<OsuHitObject>
+    public class OsuModRelax : ModRelax, IUpdatableByPlayfield, IApplicableToDrawableRuleset<OsuHitObject>, IApplicableToPlayer
     {
         public override string Description => @"You don't need to click. Give your clicking/tapping fingers a break from the heat of things.";
         public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(OsuModAutopilot)).ToArray();
@@ -33,15 +34,30 @@ namespace osu.Game.Rulesets.Osu.Mods
         private ReplayState<OsuAction> state;
         private double lastStateChangeTime;
 
+        private bool hasReplay;
+
         public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
         {
             // grab the input manager for future use.
             osuInputManager = (OsuInputManager)drawableRuleset.KeyBindingInputManager;
+        }
+
+        public void ApplyToPlayer(Player player)
+        {
+            if (osuInputManager.ReplayInputHandler != null)
+            {
+                hasReplay = true;
+                return;
+            }
+
             osuInputManager.AllowUserPresses = false;
         }
 
         public void Update(Playfield playfield)
         {
+            if (hasReplay)
+                return;
+
             bool requiresHold = false;
             bool requiresHit = false;
 

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

@@ -49,7 +49,7 @@ namespace osu.Game.Rulesets.Osu.Mods
                     Vector2 originalPosition = drawable.Position;
                     Vector2 appearOffset = new Vector2(MathF.Cos(theta), MathF.Sin(theta)) * appearDistance;
 
-                    //the - 1 and + 1 prevents the hit objects to appear in the wrong position.
+                    // the - 1 and + 1 prevents the hit objects to appear in the wrong position.
                     double appearTime = hitObject.StartTime - hitObject.TimePreempt - 1;
                     double moveDuration = hitObject.TimePreempt + 1;
 

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableHitCircle.cs

@@ -120,7 +120,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             var result = HitObject.HitWindows.ResultFor(timeOffset);
 
-            if (result == HitResult.None)
+            if (result == HitResult.None || CheckHittable?.Invoke(this, Time.Current) == false)
             {
                 Shake(Math.Abs(timeOffset) - HitObject.HitWindows.WindowFor(HitResult.Miss));
                 return;

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs

@@ -1,11 +1,14 @@
 // 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.Objects.Drawables;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Graphics.Containers;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -16,6 +19,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         // Must be set to update IsHovered as it's used in relax mdo to detect osu hit objects.
         public override bool HandlePositionalInput => true;
 
+        protected override float SamplePlaybackPosition => HitObject.X / OsuPlayfield.BASE_SIZE.X;
+
+        /// <summary>
+        /// Whether this <see cref="DrawableOsuHitObject"/> can be hit.
+        /// If non-null, judgements will be ignored (resulting in a shake) whilst the function returns false.
+        /// </summary>
+        public Func<DrawableHitObject, double, bool> CheckHittable;
+
         protected DrawableOsuHitObject(OsuHitObject hitObject)
             : base(hitObject)
         {
@@ -54,6 +65,11 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             }
         }
 
+        /// <summary>
+        /// Causes this <see cref="DrawableOsuHitObject"/> to get missed, disregarding all conditions in implementations of <see cref="DrawableHitObject.CheckForResult"/>.
+        /// </summary>
+        public void MissForcefully() => ApplyResult(r => r.Type = HitResult.Miss);
+
         protected override JudgementResult CreateResult(Judgement judgement) => new OsuJudgementResult(HitObject, judgement);
     }
 }

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSlider.cs

@@ -124,8 +124,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 case SliderTailCircle tail:
                     return new DrawableSliderTail(slider, tail);
 
-                case HitCircle head:
-                    return new DrawableSliderHead(slider, head) { OnShake = Shake };
+                case SliderHeadCircle head:
+                    return new DrawableSliderHead(slider, head)
+                    {
+                        OnShake = Shake,
+                        CheckHittable = (d, t) => CheckHittable?.Invoke(d, t) ?? true
+                    };
 
                 case SliderTick tick:
                     return new DrawableSliderTick(tick) { Position = tick.Position - slider.Position };

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderHead.cs

@@ -18,7 +18,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         private readonly Slider slider;
 
-        public DrawableSliderHead(Slider slider, HitCircle h)
+        public DrawableSliderHead(Slider slider, SliderHeadCircle h)
             : base(h)
         {
             this.slider = slider;

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/MainCirclePiece.cs

@@ -81,7 +81,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 
                     using (BeginDelayedSequence(flash_in, true))
                     {
-                        //after the flash, we can hide some elements that were behind it
+                        // after the flash, we can hide some elements that were behind it
                         ring.FadeOut();
                         circle.FadeOut();
                         number.FadeOut();

osu.Game.Rulesets.Osu/Objects/Slider.cs

@@ -155,7 +155,7 @@ namespace osu.Game.Rulesets.Osu.Objects
                         break;
 
                     case SliderEventType.Head:
-                        AddNested(HeadCircle = new SliderCircle
+                        AddNested(HeadCircle = new SliderHeadCircle
                         {
                             StartTime = e.Time,
                             Position = Position,

osu.Game.Rulesets.Osu/Objects/SliderHeadCircle.cs

@@ -0,0 +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.
+
+namespace osu.Game.Rulesets.Osu.Objects
+{
+    public class SliderHeadCircle : HitCircle
+    {
+    }
+}

osu.Game.Rulesets.Osu/UI/OrderedHitPolicy.cs

@@ -0,0 +1,106 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Osu.UI
+{
+    /// <summary>
+    /// Ensures that <see cref="HitObject"/>s are hit in-order. Affectionately known as "note lock".
+    /// If a <see cref="HitObject"/> is hit out of order:
+    /// <list type="number">
+    /// <item><description>The hit is blocked if it occurred earlier than the previous <see cref="HitObject"/>'s start time.</description></item>
+    /// <item><description>The hit causes all previous <see cref="HitObject"/>s to missed otherwise.</description></item>
+    /// </list>
+    /// </summary>
+    public class OrderedHitPolicy
+    {
+        private readonly HitObjectContainer hitObjectContainer;
+
+        public OrderedHitPolicy(HitObjectContainer hitObjectContainer)
+        {
+            this.hitObjectContainer = hitObjectContainer;
+        }
+
+        /// <summary>
+        /// Determines whether a <see cref="DrawableHitObject"/> can be hit at a point in time.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="DrawableHitObject"/> to check.</param>
+        /// <param name="time">The time to check.</param>
+        /// <returns>Whether <paramref name="hitObject"/> can be hit at the given <paramref name="time"/>.</returns>
+        public bool IsHittable(DrawableHitObject hitObject, double time)
+        {
+            DrawableHitObject blockingObject = null;
+
+            foreach (var obj in enumerateHitObjectsUpTo(hitObject.HitObject.StartTime))
+            {
+                if (hitObjectCanBlockFutureHits(obj))
+                    blockingObject = obj;
+            }
+
+            // If there is no previous hitobject, allow the hit.
+            if (blockingObject == null)
+                return true;
+
+            // A hit is allowed if:
+            // 1. The last blocking hitobject has been judged.
+            // 2. The current time is after the last hitobject's start time.
+            // Hits at exactly the same time as the blocking hitobject are allowed for maps that contain simultaneous hitobjects (e.g. /b/372245).
+            return blockingObject.Judged || time >= blockingObject.HitObject.StartTime;
+        }
+
+        /// <summary>
+        /// Handles a <see cref="HitObject"/> being hit to potentially miss all earlier <see cref="HitObject"/>s.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> that was hit.</param>
+        public void HandleHit(DrawableHitObject hitObject)
+        {
+            // Hitobjects which themselves don't block future hitobjects don't cause misses (e.g. slider ticks, spinners).
+            if (!hitObjectCanBlockFutureHits(hitObject))
+                return;
+
+            if (!IsHittable(hitObject, hitObject.HitObject.StartTime + hitObject.Result.TimeOffset))
+                throw new InvalidOperationException($"A {hitObject} was hit before it became hittable!");
+
+            foreach (var obj in enumerateHitObjectsUpTo(hitObject.HitObject.StartTime))
+            {
+                if (obj.Judged)
+                    continue;
+
+                if (hitObjectCanBlockFutureHits(obj))
+                    ((DrawableOsuHitObject)obj).MissForcefully();
+            }
+        }
+
+        /// <summary>
+        /// Whether a <see cref="HitObject"/> blocks hits on future <see cref="HitObject"/>s until its start time is reached.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> to test.</param>
+        private static bool hitObjectCanBlockFutureHits(DrawableHitObject hitObject)
+            => hitObject is DrawableHitCircle;
+
+        private IEnumerable<DrawableHitObject> enumerateHitObjectsUpTo(double targetTime)
+        {
+            foreach (var obj in hitObjectContainer.AliveObjects)
+            {
+                if (obj.HitObject.StartTime >= targetTime)
+                    yield break;
+
+                yield return obj;
+
+                foreach (var nestedObj in obj.NestedHitObjects)
+                {
+                    if (nestedObj.HitObject.StartTime >= targetTime)
+                        break;
+
+                    yield return nestedObj;
+                }
+            }
+        }
+    }
+}

osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs

@@ -20,6 +20,7 @@ namespace osu.Game.Rulesets.Osu.UI
         private readonly ApproachCircleProxyContainer approachCircles;
         private readonly JudgementContainer<DrawableOsuJudgement> judgementLayer;
         private readonly FollowPointRenderer followPoints;
+        private readonly OrderedHitPolicy hitPolicy;
 
         public static readonly Vector2 BASE_SIZE = new Vector2(512, 384);
 
@@ -51,6 +52,8 @@ namespace osu.Game.Rulesets.Osu.UI
                     Depth = -1,
                 },
             };
+
+            hitPolicy = new OrderedHitPolicy(HitObjectContainer);
         }
 
         public override void Add(DrawableHitObject h)
@@ -64,7 +67,10 @@ namespace osu.Game.Rulesets.Osu.UI
 
             base.Add(h);
 
-            followPoints.AddFollowPoints((DrawableOsuHitObject)h);
+            DrawableOsuHitObject osuHitObject = (DrawableOsuHitObject)h;
+            osuHitObject.CheckHittable = hitPolicy.IsHittable;
+
+            followPoints.AddFollowPoints(osuHitObject);
         }
 
         public override bool Remove(DrawableHitObject h)
@@ -79,6 +85,9 @@ namespace osu.Game.Rulesets.Osu.UI
 
         private void onNewResult(DrawableHitObject judgedObject, JudgementResult result)
         {
+            // Hitobjects that block future hits should miss previous hitobjects if they're hit out-of-order.
+            hitPolicy.HandleHit(judgedObject);
+
             if (!judgedObject.DisplayResult || !DisplayJudgements.Value)
                 return;
 

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

@@ -0,0 +1,29 @@
+// 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.Scoring;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Taiko.Tests
+{
+    internal class DrawableTestHit : DrawableTaikoHitObject
+    {
+        private readonly HitResult type;
+
+        public DrawableTestHit(Hit hit, HitResult type = HitResult.Great)
+            : base(hit)
+        {
+            this.type = type;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Result.Type = type;
+        }
+
+        public override bool OnPressed(TaikoAction action) => false;
+    }
+}