Update framework

Fix OSD fade-in not correctly debouncing

.vscode/launch.json

@@ -11,7 +11,11 @@
             ],
             "cwd": "${workspaceRoot}",
             "preLaunchTask": "Build tests (Debug)",
-            "env": {},
+            "linux": {
+                "env": {
+                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Game.Tests/bin/Debug/netcoreapp2.1:${env:LD_LIBRARY_PATH}"
+                }
+            },
             "console": "internalConsole"
         },
         {
@@ -24,7 +28,11 @@
             ],
             "cwd": "${workspaceRoot}",
             "preLaunchTask": "Build tests (Release)",
-            "env": {},
+            "linux": {
+                "env": {
+                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Game.Tests/bin/Release/netcoreapp2.1:${env:LD_LIBRARY_PATH}"
+                }
+            },
             "console": "internalConsole"
         },
         {
@@ -33,11 +41,15 @@
             "request": "launch",
             "program": "dotnet",
             "args": [
-                "${workspaceRoot}/osu.Desktop/bin/Debug/netcoreapp2.1/osu!.dll",
+                "${workspaceRoot}/osu.Desktop/bin/Debug/netcoreapp2.1/osu!.dll"
             ],
             "cwd": "${workspaceRoot}",
             "preLaunchTask": "Build osu! (Debug)",
-            "env": {},
+            "linux": {
+                "env": {
+                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Desktop/bin/Debug/netcoreapp2.1:${env:LD_LIBRARY_PATH}"
+                }
+            },
             "console": "internalConsole"
         },
         {
@@ -46,12 +58,16 @@
             "request": "launch",
             "program": "dotnet",
             "args": [
-                "${workspaceRoot}/osu.Desktop/bin/Release/netcoreapp2.1/osu!.dll",
+                "${workspaceRoot}/osu.Desktop/bin/Release/netcoreapp2.1/osu!.dll"
             ],
             "cwd": "${workspaceRoot}",
             "preLaunchTask": "Build osu! (Release)",
-            "env": {},
+            "linux": {
+                "env": {
+                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Desktop/bin/Release/netcoreapp2.1:${env:LD_LIBRARY_PATH}"
+                }
+            },
             "console": "internalConsole"
         }
     ]
-}
+}

README.md

@@ -1,18 +1,32 @@
 # osu! [![Build status](https://ci.appveyor.com/api/projects/status/u2p01nx7l6og8buh?svg=true)](https://ci.appveyor.com/project/peppy/osu)  [![CodeFactor](https://www.codefactor.io/repository/github/ppy/osu/badge)](https://www.codefactor.io/repository/github/ppy/osu) [![dev chat](https://discordapp.com/api/guilds/188630481301012481/widget.png?style=shield)](https://discord.gg/ppy)
 
-Rhythm is just a *click* away. The future of [osu!](https://osu.ppy.sh) and the beginning of an open era!
+Rhythm is just a *click* away. The future of [osu!](https://osu.ppy.sh) and the beginning of an open era! Commonly known by the codename "osu!lazer". Pew pew.
 
 # Status
 
-This is still heavily under development and is not intended for end-user use. This repository is intended for developer collaboration. You're welcome to try and use it but please do not submit bug reports without a patch. Please do not ask for help building or using this software.
+This project is still heavily under development, but is in a state where users are encouraged to try it out and keep it installed alongside the stable osu! client. It will continue to evolve over the coming months and hopefully bring some new unique features to the table.
+
+We are accepting bug reports (please report with as much detail as possible). Feature requests are welcome as long as you read and understand the contribution guidelines listed below.
 
 # Requirements
 
-- A desktop platform that can compile .NET 4.7.1. We recommend using [Visual Studio Community Edition](https://www.visualstudio.com/) (Windows), [Visual Studio for Mac](https://www.visualstudio.com/vs/visual-studio-mac/) (macOS) or [MonoDevelop](http://www.monodevelop.com/download/) (Linux), all of which are free. [Visual Studio Code](https://code.visualstudio.com/) may also be used but requires further setup steps which are not covered here.
+- A desktop platform with the [.NET Core SDK 2.1](https://www.microsoft.com/net/learn/get-started) or higher installed.
+- When working with the codebase, we recommend using an IDE with intellisense and syntax highlighting, such as [Visual Studio Community Edition](https://www.visualstudio.com/) (Windows), [Visual Studio Code](https://code.visualstudio.com/) (with the C# plugin installed) or [Jetbrains Rider](https://www.jetbrains.com/rider/) (commercial).
 
-# Getting Started
-- Clone the repository including submodules (`git clone --recurse-submodules https://github.com/ppy/osu`)
-- Build in your IDE of choice (recommended IDEs automatically restore nuget packages; if you are using an alternative make sure to `nuget restore`)
+# Building and running
+
+If you are not interested in developing the game, please head over to the [releases](https://github.com/ppy/osu/releases) to download a precompiled build with automatic updating enabled (download and run the install executable for your platform).
+
+Clone the repository including submodules
+
+`git clone --recurse-submodules https://github.com/ppy/osu`
+
+Build and run
+
+- Using Visual Studio 2017, Rider or Visual Studio Code (configurations are included)
+- From command line using `dotnet run --project osu.Desktop --framework netcoreapp2.1`
+
+The above methods should automatically do so, but if you run into issues building you may need to restore nuget packages (commonly via `dotnet restore`).
 
 # Contributing
 

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

@@ -13,11 +13,12 @@ using osu.Game.Tests.Beatmaps;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
-    internal class CatchBeatmapConversionTest : BeatmapConversionTest<ConvertValue>
+    [TestFixture]
+    public class CatchBeatmapConversionTest : BeatmapConversionTest<ConvertValue>
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Catch";
 
-        [TestCase("basic"), Ignore("See: https://github.com/ppy/osu/issues/2232")]
+        [TestCase("basic")]
         [TestCase("spinner")]
         [TestCase("spinner-and-circles")]
         public new void Test(string name)
@@ -44,7 +45,7 @@ namespace osu.Game.Rulesets.Catch.Tests
         protected override Ruleset CreateRuleset() => new CatchRuleset();
     }
 
-    internal struct ConvertValue : IEquatable<ConvertValue>
+    public struct ConvertValue : IEquatable<ConvertValue>
     {
         /// <summary>
         /// A sane value to account for osu!stable using ints everwhere.

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

@@ -55,7 +55,7 @@ namespace osu.Game.Rulesets.Catch.Tests
         private DrawableFruit createDrawable(int index)
         {
             Fruit fruit = index == 5
-                ? new BananaShower.Banana
+                ? new Banana
                 {
                     StartTime = 1000000000000,
                     IndexInBeatmap = index,

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

@@ -26,6 +26,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
             var positionData = obj as IHasXPosition;
             var comboData = obj as IHasCombo;
             var endTime = obj as IHasEndTime;
+            var legacyOffset = obj as IHasLegacyLastTickOffset;
 
             if (curveData != null)
             {
@@ -39,7 +40,8 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                     RepeatSamples = curveData.RepeatSamples,
                     RepeatCount = curveData.RepeatCount,
                     X = (positionData?.X ?? 0) / CatchPlayfield.BASE_WIDTH,
-                    NewCombo = comboData?.NewCombo ?? false
+                    NewCombo = comboData?.NewCombo ?? false,
+                    LegacyLastTickOffset = legacyOffset?.LegacyLastTickOffset ?? 0
                 };
             }
             else if (endTime != null)

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

@@ -15,6 +15,8 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
 {
     public class CatchBeatmapProcessor : BeatmapProcessor
     {
+        public const int RNG_SEED = 1337;
+
         public CatchBeatmapProcessor(IBeatmap beatmap)
             : base(beatmap)
         {
@@ -22,12 +24,12 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
 
         public override void PostProcess()
         {
+            base.PostProcess();
+
             applyPositionOffsets();
 
             initialiseHyperDash((List<CatchHitObject>)Beatmap.HitObjects);
 
-            base.PostProcess();
-
             int index = 0;
             foreach (var obj in Beatmap.HitObjects.OfType<CatchHitObject>())
             {
@@ -37,8 +39,6 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
             }
         }
 
-        public const int RNG_SEED = 1337;
-
         private void applyPositionOffsets()
         {
             var rng = new FastRandom(RNG_SEED);
@@ -49,9 +49,9 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                 switch (obj)
                 {
                     case BananaShower bananaShower:
-                        foreach (var nested in bananaShower.NestedHitObjects)
+                        foreach (var banana in bananaShower.NestedHitObjects.OfType<Banana>())
                         {
-                            ((BananaShower.Banana)nested).X = (float)rng.NextDouble();
+                            banana.X = (float)rng.NextDouble();
                             rng.Next(); // osu!stable retrieved a random banana type
                             rng.Next(); // osu!stable retrieved a random banana rotation
                             rng.Next(); // osu!stable retrieved a random banana colour

osu.Game.Rulesets.Catch/Judgements/CatchBananaJudgement.cs

@@ -0,0 +1,36 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Catch.Judgements
+{
+    public class CatchBananaJudgement : CatchJudgement
+    {
+        public override bool AffectsCombo => false;
+
+        public override bool ShouldExplode => true;
+
+        protected override int NumericResultFor(HitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return 0;
+                case HitResult.Perfect:
+                    return 1100;
+            }
+        }
+
+        protected override float HealthIncreaseFor(HitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return 0;
+                case HitResult.Perfect:
+                    return 8;
+            }
+        }
+    }
+}

osu.Game.Rulesets.Catch/Judgements/CatchDropletJudgement.cs

@@ -0,0 +1,32 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Catch.Judgements
+{
+    public class CatchDropletJudgement : CatchJudgement
+    {
+        protected override int NumericResultFor(HitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return 0;
+                case HitResult.Perfect:
+                    return 30;
+            }
+        }
+
+        protected override float HealthIncreaseFor(HitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return 0;
+                case HitResult.Perfect:
+                    return 7;
+            }
+        }
+    }
+}

osu.Game.Rulesets.Catch/Judgements/CatchJudgement.cs

@@ -2,11 +2,51 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Catch.Judgements
 {
     public class CatchJudgement : Judgement
     {
-        // todo: wangs
+        public override HitResult MaxResult => HitResult.Perfect;
+
+        protected override int NumericResultFor(HitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return 0;
+                case HitResult.Perfect:
+                    return 300;
+            }
+        }
+
+        /// <summary>
+        /// The base health increase for the result achieved.
+        /// </summary>
+        public float HealthIncrease => HealthIncreaseFor(Result);
+
+        /// <summary>
+        /// Whether fruit on the platter should explode or drop.
+        /// Note that this is only checked if the owning object is also <see cref="IHasComboInformation.LastInCombo" />
+        /// </summary>
+        public virtual bool ShouldExplode => IsHit;
+
+        /// <summary>
+        /// Convert a <see cref="HitResult"/> to a base health increase.
+        /// </summary>
+        /// <param name="result">The value to convert.</param>
+        /// <returns>The base health increase.</returns>
+        protected virtual float HealthIncreaseFor(HitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return 0;
+                case HitResult.Perfect:
+                    return 10.2f;
+            }
+        }
     }
 }

osu.Game.Rulesets.Catch/Judgements/CatchTinyDropletJudgement.cs

@@ -0,0 +1,34 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Catch.Judgements
+{
+    public class CatchTinyDropletJudgement : CatchJudgement
+    {
+        public override bool AffectsCombo => false;
+
+        protected override int NumericResultFor(HitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return 0;
+                case HitResult.Perfect:
+                    return 10;
+            }
+        }
+
+        protected override float HealthIncreaseFor(HitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return 0;
+                case HitResult.Perfect:
+                    return 4;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Rulesets.Catch.Objects
+{
+    public class Banana : Fruit
+    {
+        public override FruitVisualRepresentation VisualRepresentation => FruitVisualRepresentation.Banana;
+    }
+}

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

@@ -37,10 +37,5 @@ namespace osu.Game.Rulesets.Catch.Objects
         public double EndTime => StartTime + Duration;
 
         public double Duration { get; set; }
-
-        public class Banana : Fruit
-        {
-            public override FruitVisualRepresentation VisualRepresentation => FruitVisualRepresentation.Banana;
-        }
     }
 }

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableBanana.cs

@@ -0,0 +1,17 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Catch.Judgements;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawable
+{
+    public class DrawableBanana : DrawableFruit
+    {
+        public DrawableBanana(Banana h)
+            : base(h)
+        {
+        }
+
+        protected override CatchJudgement CreateJudgement() => new CatchBananaJudgement();
+    }
+}

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableBananaShower.cs

@@ -5,9 +5,7 @@ using System;
 using System.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {
@@ -24,15 +22,11 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
 
             InternalChild = bananaContainer = new Container { RelativeSizeAxes = Axes.Both };
 
-            foreach (var b in s.NestedHitObjects.Cast<BananaShower.Banana>())
+            foreach (var b in s.NestedHitObjects.Cast<Banana>())
                 AddNested(getVisualRepresentation?.Invoke(b));
         }
 
-        protected override void CheckForJudgements(bool userTriggered, double timeOffset)
-        {
-            if (timeOffset >= 0)
-                AddJudgement(new Judgement { Result = NestedHitObjects.Cast<DrawableCatchHitObject>().Any(n => n.Judgements.Any(j => j.IsHit)) ? HitResult.Perfect : HitResult.Miss });
-        }
+        protected override bool ProvidesJudgement => false;
 
         protected override void AddNested(DrawableHitObject h)
         {

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

@@ -2,14 +2,14 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using OpenTK;
+using OpenTK.Graphics;
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
-using OpenTK;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;
-using OpenTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {
@@ -58,9 +58,15 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
             if (CheckPosition == null) return;
 
             if (timeOffset >= 0)
-                AddJudgement(new Judgement { Result = CheckPosition.Invoke(HitObject) ? HitResult.Perfect : HitResult.Miss });
+            {
+                var judgement = CreateJudgement();
+                judgement.Result = CheckPosition.Invoke(HitObject) ? HitResult.Perfect : HitResult.Miss;
+                AddJudgement(judgement);
+            }
         }
 
+        protected virtual CatchJudgement CreateJudgement() => new CatchJudgement();
+
         protected override void SkinChanged(ISkinSource skin, bool allowFallback)
         {
             base.SkinChanged(skin, allowFallback);

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableDroplet.cs

@@ -6,6 +6,7 @@ using osu.Framework.Graphics;
 using osu.Game.Rulesets.Catch.Objects.Drawable.Pieces;
 using OpenTK;
 using OpenTK.Graphics;
+using osu.Game.Rulesets.Catch.Judgements;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {
@@ -23,6 +24,8 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
             Masking = false;
         }
 
+        protected override CatchJudgement CreateJudgement() => new CatchDropletJudgement();
+
         [BackgroundDependencyLoader]
         private void load()
         {

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableTinyDroplet.cs

@@ -0,0 +1,19 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK;
+using osu.Game.Rulesets.Catch.Judgements;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawable
+{
+    public class DrawableTinyDroplet : DrawableDroplet
+    {
+        public DrawableTinyDroplet(Droplet h)
+            : base(h)
+        {
+            Size = new Vector2((float)CatchHitObject.OBJECT_RADIUS) / 8;
+        }
+
+        protected override CatchJudgement CreateJudgement() => new CatchTinyDropletJudgement();
+    }
+}

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

@@ -77,6 +77,13 @@ namespace osu.Game.Rulesets.Catch.Objects
 
                     double time = spanStartTime + timeProgress * spanDuration;
 
+                    if (LegacyLastTickOffset != null)
+                    {
+                        // If we're the last tick, apply the legacy offset
+                        if (span == this.SpanCount() - 1 && d + tickDistance > length)
+                            time = Math.Max(StartTime + Duration / 2, time - LegacyLastTickOffset.Value);
+                    }
+
                     double tinyTickInterval = time - lastDropletTime;
                     while (tinyTickInterval > 100)
                         tinyTickInterval /= 2;
@@ -152,5 +159,7 @@ namespace osu.Game.Rulesets.Catch.Objects
             get { return Curve.CurveType; }
             set { Curve.CurveType = value; }
         }
+
+        public double? LegacyLastTickOffset { get; set; }
     }
 }

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

@@ -56,7 +56,7 @@ namespace osu.Game.Rulesets.Catch.Replays
                     return;
                 }
 
-                if (h is BananaShower.Banana)
+                if (h is Banana)
                 {
                     // auto bananas unrealistically warp to catch 100% combo.
                     Replay.Frames.Add(new CatchReplayFrame(h.StartTime, h.X));
@@ -105,7 +105,7 @@ namespace osu.Game.Rulesets.Catch.Replays
                 {
                     switch (nestedObj)
                     {
-                        case BananaShower.Banana _:
+                        case Banana _:
                         case TinyDroplet _:
                         case Droplet _:
                         case Fruit _:

osu.Game.Rulesets.Catch/Scoring/CatchScoreProcessor.cs

@@ -1,10 +1,12 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System;
 using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 
@@ -17,28 +19,57 @@ namespace osu.Game.Rulesets.Catch.Scoring
         {
         }
 
+        private float hpDrainRate;
+
         protected override void SimulateAutoplay(Beatmap<CatchHitObject> beatmap)
         {
+            hpDrainRate = beatmap.BeatmapInfo.BaseDifficulty.DrainRate;
+
             foreach (var obj in beatmap.HitObjects)
             {
                 switch (obj)
                 {
                     case JuiceStream stream:
-                        foreach (var _ in stream.NestedHitObjects.Cast<CatchHitObject>())
-                            AddJudgement(new CatchJudgement { Result = HitResult.Perfect });
+                        foreach (var nestedObject in stream.NestedHitObjects)
+                            switch (nestedObject)
+                            {
+                                case TinyDroplet _:
+                                    AddJudgement(new CatchTinyDropletJudgement { Result = HitResult.Perfect });
+                                    break;
+                                case Droplet _:
+                                    AddJudgement(new CatchDropletJudgement { Result = HitResult.Perfect });
+                                    break;
+                                case Fruit _:
+                                    AddJudgement(new CatchJudgement { Result = HitResult.Perfect });
+                                    break;
+                            }
                         break;
                     case BananaShower shower:
                         foreach (var _ in shower.NestedHitObjects.Cast<CatchHitObject>())
-                            AddJudgement(new CatchJudgement { Result = HitResult.Perfect });
-                        AddJudgement(new CatchJudgement { Result = HitResult.Perfect });
+                            AddJudgement(new CatchBananaJudgement { Result = HitResult.Perfect });
                         break;
                     case Fruit _:
                         AddJudgement(new CatchJudgement { Result = HitResult.Perfect });
                         break;
                 }
             }
+        }
 
-            base.SimulateAutoplay(beatmap);
+        private const double harshness = 0.01;
+
+        protected override void OnNewJudgement(Judgement judgement)
+        {
+            base.OnNewJudgement(judgement);
+
+            if (judgement.Result == HitResult.Miss)
+            {
+                if (!judgement.IsBonus)
+                    Health.Value -= hpDrainRate * (harshness * 2);
+                return;
+            }
+
+            if (judgement is CatchJudgement catchJudgement)
+                Health.Value += Math.Max(catchJudgement.HealthIncrease - hpDrainRate, 0) * harshness;
         }
     }
 }

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

@@ -38,14 +38,16 @@ namespace osu.Game.Rulesets.Catch.UI
         {
             switch (h)
             {
+                case Banana banana:
+                    return new DrawableBanana(banana);
                 case Fruit fruit:
                     return new DrawableFruit(fruit);
                 case JuiceStream stream:
                     return new DrawableJuiceStream(stream, GetVisualRepresentation);
-                case BananaShower banana:
-                    return new DrawableBananaShower(banana, GetVisualRepresentation);
+                case BananaShower shower:
+                    return new DrawableBananaShower(shower, GetVisualRepresentation);
                 case TinyDroplet tiny:
-                    return new DrawableDroplet(tiny) { Scale = new Vector2(0.5f) };
+                    return new DrawableTinyDroplet(tiny);
                 case Droplet droplet:
                     return new DrawableDroplet(droplet);
             }

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

@@ -11,6 +11,7 @@ using osu.Framework.Graphics.Textures;
 using osu.Framework.Input.Bindings;
 using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Catch.Replays;
@@ -78,12 +79,11 @@ namespace osu.Game.Rulesets.Catch.UI
 
                 if (!fruit.StaysOnPlate)
                     runAfterLoaded(() => MovableCatcher.Explode(caughtFruit));
-
             }
 
             if (fruit.HitObject.LastInCombo)
             {
-                if (judgement.IsHit)
+                if (((CatchJudgement)judgement).ShouldExplode)
                     runAfterLoaded(() => MovableCatcher.Explode());
                 else
                     MovableCatcher.Drop();

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

@@ -5,6 +5,8 @@ using System;
 using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.MathUtils;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
@@ -12,11 +14,11 @@ using osu.Game.Tests.Beatmaps;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {
-    internal class ManiaBeatmapConversionTest : BeatmapConversionTest<ConvertValue>
+    [TestFixture]
+    public class ManiaBeatmapConversionTest : BeatmapConversionTest<ManiaConvertMapping, ConvertValue>
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Mania";
 
-        [NonParallelizable]
         [TestCase("basic")]
         public new void Test(string name)
         {
@@ -33,10 +35,36 @@ namespace osu.Game.Rulesets.Mania.Tests
             };
         }
 
+        protected override ManiaConvertMapping CreateConvertMapping() => new ManiaConvertMapping(Converter);
+
         protected override Ruleset CreateRuleset() => new ManiaRuleset();
     }
 
-    internal struct ConvertValue : IEquatable<ConvertValue>
+     public class ManiaConvertMapping : ConvertMapping<ConvertValue>, IEquatable<ManiaConvertMapping>
+     {
+         public uint RandomW;
+         public uint RandomX;
+         public uint RandomY;
+         public uint RandomZ;
+
+         public ManiaConvertMapping()
+         {
+         }
+
+         public ManiaConvertMapping(IBeatmapConverter converter)
+         {
+             var maniaConverter = (ManiaBeatmapConverter)converter;
+             RandomW = maniaConverter.Random.W;
+             RandomX = maniaConverter.Random.X;
+             RandomY = maniaConverter.Random.Y;
+             RandomZ = maniaConverter.Random.Z;
+         }
+
+         public bool Equals(ManiaConvertMapping other) => other != null && RandomW == other.RandomW && RandomX == other.RandomX && RandomY == other.RandomY && RandomZ == other.RandomZ;
+         public override bool Equals(ConvertMapping<ConvertValue> other) => base.Equals(other) && Equals(other as ManiaConvertMapping);
+     }
+
+    public struct ConvertValue : IEquatable<ConvertValue>
     {
         /// <summary>
         /// A sane value to account for osu!stable using ints everwhere.

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

@@ -69,7 +69,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 var obj = new Note { Column = i, StartTime = Time.Current + 2000 };
                 obj.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
 
-                columns[i].Add(new DrawableNote(obj, columns[i].Action));
+                columns[i].Add(new DrawableNote(obj));
             }
         }
 
@@ -80,7 +80,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 var obj = new HoldNote { Column = i, StartTime = Time.Current + 2000, Duration = 500 };
                 obj.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
 
-                columns[i].Add(new DrawableHoldNote(obj, columns[i].Action));
+                columns[i].Add(new DrawableHoldNote(obj));
             }
         }
 
@@ -92,7 +92,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 Origin = Anchor.Centre,
                 Height = 0.85f,
                 AccentColour = Color4.OrangeRed,
-                Action = action,
+                Action = { Value = action },
                 VisibleTimeRange = { Value = 2000 }
             };
 

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

@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Configuration;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -63,7 +64,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 AutoSizeAxes = Axes.Both,
                 Child = new NoteContainer(direction, $"note, scrolling {direction.ToString().ToLower()}")
                 {
-                    Child = new DrawableNote(note, ManiaAction.Key1) { AccentColour = Color4.OrangeRed }
+                    Child = new DrawableNote(note) { AccentColour = Color4.OrangeRed }
                 }
             };
         }
@@ -78,7 +79,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 AutoSizeAxes = Axes.Both,
                 Child = new NoteContainer(direction, $"hold note, scrolling {direction.ToString().ToLower()}")
                 {
-                    Child = new DrawableHoldNote(note, ManiaAction.Key1)
+                    Child = new DrawableHoldNote(note)
                     {
                         RelativeSizeAxes = Axes.Both,
                         AccentColour = Color4.OrangeRed,
@@ -136,6 +137,13 @@ namespace osu.Game.Rulesets.Mania.Tests
                 };
             }
 
+            protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+            {
+                var dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+                dependencies.CacheAs<IBindable<ManiaAction>>(new Bindable<ManiaAction>());
+                return dependencies;
+            }
+
             protected override void Update()
             {
                 base.Update();
@@ -145,9 +153,6 @@ namespace osu.Game.Rulesets.Mania.Tests
                     if (!(obj.HitObject is IHasEndTime endTime))
                         continue;
 
-                    if (!obj.HasNestedHitObjects)
-                        continue;
-
                     foreach (var nested in obj.NestedHitObjects)
                     {
                         double finalPosition = (nested.HitObject.StartTime - obj.HitObject.StartTime) / endTime.Duration;

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

@@ -65,7 +65,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                     var obj = new Note { Column = i, StartTime = Time.Current + 2000 };
                     obj.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
 
-                    stage.Add(new DrawableNote(obj, stage.Columns[i].Action));
+                    stage.Add(new DrawableNote(obj));
                 }
             }
         }
@@ -79,7 +79,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                     var obj = new HoldNote { Column = i, StartTime = Time.Current + 2000, Duration = 500 };
                     obj.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
 
-                    stage.Add(new DrawableHoldNote(obj, stage.Columns[i].Action));
+                    stage.Add(new DrawableHoldNote(obj));
                 }
             }
         }

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

@@ -5,6 +5,7 @@ using osu.Game.Rulesets.Mania.Objects;
 using System;
 using System.Linq;
 using System.Collections.Generic;
+using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
@@ -28,8 +29,10 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         public int TargetColumns;
         public readonly bool IsForCurrentRuleset;
 
+        // Internal for testing purposes
+        internal FastRandom Random { get; private set; }
+
         private Pattern lastPattern = new Pattern();
-        private FastRandom random;
 
         private ManiaBeatmap beatmap;
 
@@ -62,7 +65,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             BeatmapDifficulty difficulty = original.BeatmapInfo.BaseDifficulty;
 
             int seed = (int)Math.Round(difficulty.DrainRate + difficulty.CircleSize) * 20 + (int)(difficulty.OverallDifficulty * 41.2) + (int)Math.Round(difficulty.ApproachRate);
-            random = new FastRandom(seed);
+            Random = new FastRandom(seed);
 
             return base.ConvertBeatmap(original);
         }
@@ -100,7 +103,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
 
         private double lastTime;
         private Vector2 lastPosition;
-        private PatternType lastStair;
+        private PatternType lastStair = PatternType.Stair;
         private void recordNote(double time, Vector2 position)
         {
             lastTime = time;
@@ -115,12 +118,15 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         /// <returns>The hit objects generated.</returns>
         private IEnumerable<ManiaHitObject> generateSpecific(HitObject original, IBeatmap originalBeatmap)
         {
-            var generator = new SpecificBeatmapPatternGenerator(random, original, beatmap, lastPattern, originalBeatmap);
+            var generator = new SpecificBeatmapPatternGenerator(Random, original, beatmap, lastPattern, originalBeatmap);
 
-            Pattern newPattern = generator.Generate();
-            lastPattern = newPattern;
+            foreach (var newPattern in generator.Generate())
+            {
+                lastPattern = newPattern;
 
-            return newPattern.HitObjects;
+                foreach (var obj in newPattern.HitObjects)
+                    yield return obj;
+            }
         }
 
         /// <summary>
@@ -138,27 +144,44 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             Patterns.PatternGenerator conversion = null;
 
             if (distanceData != null)
-                conversion = new DistanceObjectPatternGenerator(random, original, beatmap, lastPattern, originalBeatmap);
+            {
+                var generator = new DistanceObjectPatternGenerator(Random, original, beatmap, lastPattern, originalBeatmap);
+                conversion = generator;
+
+                for (double time = original.StartTime; !Precision.DefinitelyBigger(time, generator.EndTime); time += generator.SegmentDuration)
+                {
+                    recordNote(time, positionData?.Position ?? Vector2.Zero);
+                    computeDensity(time);
+                }
+            }
             else if (endTimeData != null)
-                conversion = new EndTimeObjectPatternGenerator(random, original, beatmap, originalBeatmap);
+            {
+                conversion = new EndTimeObjectPatternGenerator(Random, original, beatmap, originalBeatmap);
+
+                recordNote(endTimeData.EndTime, new Vector2(256, 192));
+                computeDensity(endTimeData.EndTime);
+            }
             else if (positionData != null)
             {
                 computeDensity(original.StartTime);
 
-                conversion = new HitObjectPatternGenerator(random, original, beatmap, lastPattern, lastTime, lastPosition, density, lastStair, originalBeatmap);
+                conversion = new HitObjectPatternGenerator(Random, original, beatmap, lastPattern, lastTime, lastPosition, density, lastStair, originalBeatmap);
 
                 recordNote(original.StartTime, positionData.Position);
             }
 
             if (conversion == null)
-                return null;
+                yield break;
 
-            Pattern newPattern = conversion.Generate();
+            foreach (var newPattern in conversion.Generate())
+            {
+                lastPattern = conversion is EndTimeObjectPatternGenerator ? lastPattern : newPattern;
+                lastStair = (conversion as HitObjectPatternGenerator)?.StairType ?? lastStair;
 
-            lastPattern = conversion is EndTimeObjectPatternGenerator ? lastPattern : newPattern;
-            lastStair = (conversion as HitObjectPatternGenerator)?.StairType ?? lastStair;
+                foreach (var obj in newPattern.HitObjects)
+                    yield return obj;
 
-            return newPattern.HitObjects;
+            }
         }
 
         /// <summary>
@@ -171,7 +194,12 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             {
             }
 
-            public override Pattern Generate()
+            public override IEnumerable<Pattern> Generate()
+            {
+                yield return generate();
+            }
+
+            private Pattern generate()
             {
                 var endTimeData = HitObject as IHasEndTime;
                 var positionData = HitObject as IHasXPosition;

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

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.MathUtils;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.MathUtils;
@@ -24,8 +25,9 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// </summary>
         private const float osu_base_scoring_distance = 100;
 
-        private readonly double endTime;
-        private readonly double segmentDuration;
+        public readonly double EndTime;
+        public readonly double SegmentDuration;
+
         private readonly int spanCount;
 
         private PatternType convertType;
@@ -52,53 +54,81 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             // The duration of the osu! hit object
             double osuDuration = distance / osuVelocity;
 
-            endTime = hitObject.StartTime + osuDuration;
-            segmentDuration = (endTime - HitObject.StartTime) / spanCount;
+            EndTime = hitObject.StartTime + osuDuration;
+            SegmentDuration = (EndTime - HitObject.StartTime) / spanCount;
         }
 
-        public override Pattern Generate()
+        public override IEnumerable<Pattern> Generate()
+        {
+            var originalPattern = generate();
+
+            if (originalPattern.HitObjects.Count() == 1)
+            {
+                yield return originalPattern;
+                yield break;
+            }
+
+            // We need to split the intermediate pattern into two new patterns:
+            // 1. A pattern containing all objects that do not end at our EndTime.
+            // 2. A pattern containing all objects that end at our EndTime. This will be used for further pattern generation.
+            var intermediatePattern = new Pattern();
+            var endTimePattern = new Pattern();
+
+            foreach (var obj in originalPattern.HitObjects)
+            {
+                if (!Precision.AlmostEquals(EndTime, (obj as IHasEndTime)?.EndTime ?? obj.StartTime))
+                    intermediatePattern.Add(obj);
+                else
+                    endTimePattern.Add(obj);
+            }
+
+            yield return intermediatePattern;
+            yield return endTimePattern;
+        }
+
+        private Pattern generate()
         {
             if (TotalColumns == 1)
             {
                 var pattern = new Pattern();
-                addToPattern(pattern, 0, HitObject.StartTime, endTime);
+                addToPattern(pattern, 0, HitObject.StartTime, EndTime);
                 return pattern;
             }
 
             if (spanCount > 1)
             {
-                if (segmentDuration <= 90)
+                if (SegmentDuration <= 90)
                     return generateRandomHoldNotes(HitObject.StartTime, 1);
 
-                if (segmentDuration <= 120)
+                if (SegmentDuration <= 120)
                 {
                     convertType |= PatternType.ForceNotStack;
                     return generateRandomNotes(HitObject.StartTime, spanCount + 1);
                 }
 
-                if (segmentDuration <= 160)
+                if (SegmentDuration <= 160)
                     return generateStair(HitObject.StartTime);
 
-                if (segmentDuration <= 200 && ConversionDifficulty > 3)
+                if (SegmentDuration <= 200 && ConversionDifficulty > 3)
                     return generateRandomMultipleNotes(HitObject.StartTime);
 
-                double duration = endTime - HitObject.StartTime;
+                double duration = EndTime - HitObject.StartTime;
                 if (duration >= 4000)
                     return generateNRandomNotes(HitObject.StartTime, 0.23, 0, 0);
 
-                if (segmentDuration > 400 && spanCount < TotalColumns - 1 - RandomStart)
+                if (SegmentDuration > 400 && spanCount < TotalColumns - 1 - RandomStart)
                     return generateTiledHoldNotes(HitObject.StartTime);
 
                 return generateHoldAndNormalNotes(HitObject.StartTime);
             }
 
-            if (segmentDuration <= 110)
+            if (SegmentDuration <= 110)
             {
                 if (PreviousPattern.ColumnWithObjects < TotalColumns)
                     convertType |= PatternType.ForceNotStack;
                 else
                     convertType &= ~PatternType.ForceNotStack;
-                return generateRandomNotes(HitObject.StartTime, segmentDuration < 80 ? 1 : 2);
+                return generateRandomNotes(HitObject.StartTime, SegmentDuration < 80 ? 1 : 2);
             }
 
             if (ConversionDifficulty > 6.5)
@@ -148,7 +178,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             {
                 while (pattern.ColumnHasObject(nextColumn) || PreviousPattern.ColumnHasObject(nextColumn))  //find available column
                     nextColumn = Random.Next(RandomStart, TotalColumns);
-                addToPattern(pattern, nextColumn, startTime, endTime);
+                addToPattern(pattern, nextColumn, startTime, EndTime);
             }
 
             // This is can't be combined with the above loop due to RNG
@@ -156,7 +186,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             {
                 while (pattern.ColumnHasObject(nextColumn))
                     nextColumn = Random.Next(RandomStart, TotalColumns);
-                addToPattern(pattern, nextColumn, startTime, endTime);
+                addToPattern(pattern, nextColumn, startTime, EndTime);
             }
 
             return pattern;
@@ -193,7 +223,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                     nextColumn = Random.Next(RandomStart, TotalColumns);
 
                 lastColumn = nextColumn;
-                startTime += segmentDuration;
+                startTime += SegmentDuration;
             }
 
             return pattern;
@@ -223,7 +253,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             for (int i = 0; i <= spanCount; i++)
             {
                 addToPattern(pattern, column, startTime, startTime);
-                startTime += segmentDuration;
+                startTime += SegmentDuration;
 
                 // Check if we're at the borders of the stage, and invert the pattern if so
                 if (increasing)
@@ -284,7 +314,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                     addToPattern(pattern, nextColumn, startTime, startTime);
 
                 nextColumn = Random.Next(RandomStart, TotalColumns);
-                startTime += segmentDuration;
+                startTime += SegmentDuration;
             }
 
             return pattern;
@@ -372,8 +402,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 while (pattern.ColumnHasObject(nextColumn))
                     nextColumn = Random.Next(RandomStart, TotalColumns);
 
-                addToPattern(pattern, nextColumn, startTime, endTime);
-                startTime += segmentDuration;
+                addToPattern(pattern, nextColumn, startTime, EndTime);
+                startTime += SegmentDuration;
             }
 
             return pattern;
@@ -402,7 +432,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             }
 
             // Create the hold note
-            addToPattern(pattern, holdColumn, startTime, endTime);
+            addToPattern(pattern, holdColumn, startTime, EndTime);
 
             int nextColumn = Random.Next(RandomStart, TotalColumns);
             int noteCount;
@@ -434,7 +464,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 pattern.Add(rowPattern);
                 rowPattern.Clear();
 
-                startTime += segmentDuration;
+                startTime += SegmentDuration;
             }
 
             return pattern;
@@ -452,7 +482,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             if (curveData == null)
                 return HitObject.Samples;
 
-            double segmentTime = (endTime - HitObject.StartTime) / spanCount;
+            double segmentTime = (EndTime - HitObject.StartTime) / spanCount;
 
             int index = (int)(segmentTime == 0 ? 0 : (time - HitObject.StartTime) / segmentTime);
             return curveData.RepeatSamples[index];

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

@@ -24,7 +24,12 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             endTime = endtimeData?.EndTime ?? 0;
         }
 
-        public override Pattern Generate()
+        public override IEnumerable<Pattern> Generate()
+        {
+            yield return generate();
+        }
+
+        private Pattern generate()
         {
             var pattern = new Pattern();
 

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

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using OpenTK;
 using osu.Game.Audio;
@@ -82,127 +83,133 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             {
                 if (HitObject.Samples.Any(s => s.Name == SampleInfo.HIT_FINISH) && TotalColumns != 8)
                     convertType |= PatternType.Mirror;
-                else
+                else if (HitObject.Samples.Any(s => s.Name == SampleInfo.HIT_CLAP))
                     convertType |= PatternType.Gathered;
             }
         }
 
-        public override Pattern Generate()
+        public override IEnumerable<Pattern> Generate()
         {
-            if (TotalColumns == 1)
+            yield return generate();
+        }
+
+        private Pattern generate()
+        {
+            var pattern = new Pattern();
+
+            try
             {
-                var pattern = new Pattern();
-                addToPattern(pattern, 0);
-                return pattern;
-            }
-
-            int lastColumn = PreviousPattern.HitObjects.FirstOrDefault()?.Column ?? 0;
-
-            if ((convertType & PatternType.Reverse) > 0 && PreviousPattern.HitObjects.Any())
-            {
-                // Generate a new pattern by copying the last hit objects in reverse-column order
-                var pattern = new Pattern();
-
-                for (int i = RandomStart; i < TotalColumns; i++)
-                    if (PreviousPattern.ColumnHasObject(i))
-                        addToPattern(pattern, RandomStart + TotalColumns - i - 1);
-
-                return pattern;
-            }
-
-            if ((convertType & PatternType.Cycle) > 0 && PreviousPattern.HitObjects.Count() == 1
-                // If we convert to 7K + 1, let's not overload the special key
-                && (TotalColumns != 8 || lastColumn != 0)
-                // Make sure the last column was not the centre column
-                && (TotalColumns % 2 == 0 || lastColumn != TotalColumns / 2))
-            {
-                // Generate a new pattern by cycling backwards (similar to Reverse but for only one hit object)
-                var pattern = new Pattern();
-
-                int column = RandomStart + TotalColumns - lastColumn - 1;
-                addToPattern(pattern, column);
-
-                return pattern;
-            }
-
-            if ((convertType & PatternType.ForceStack) > 0 && PreviousPattern.HitObjects.Any())
-            {
-                // Generate a new pattern by placing on the already filled columns
-                var pattern = new Pattern();
-
-                for (int i = RandomStart; i < TotalColumns; i++)
-                    if (PreviousPattern.ColumnHasObject(i))
-                        addToPattern(pattern, i);
-
-                return pattern;
-            }
-
-            if ((convertType & PatternType.Stair) > 0 && PreviousPattern.HitObjects.Count() == 1)
-            {
-                // Generate a new pattern by placing on the next column, cycling back to the start if there is no "next"
-                var pattern = new Pattern();
-
-                int targetColumn = lastColumn + 1;
-                if (targetColumn == TotalColumns)
+                if (TotalColumns == 1)
                 {
-                    targetColumn = RandomStart;
-                    StairType = PatternType.ReverseStair;
+                    addToPattern(pattern, 0);
+                    return pattern;
                 }
 
-                addToPattern(pattern, targetColumn);
-                return pattern;
-            }
+                int lastColumn = PreviousPattern.HitObjects.FirstOrDefault()?.Column ?? 0;
 
-            if ((convertType & PatternType.ReverseStair) > 0 && PreviousPattern.HitObjects.Count() == 1)
-            {
-                // Generate a new pattern by placing on the previous column, cycling back to the end if there is no "previous"
-                var pattern = new Pattern();
-
-                int targetColumn = lastColumn - 1;
-                if (targetColumn == RandomStart - 1)
+                if ((convertType & PatternType.Reverse) > 0 && PreviousPattern.HitObjects.Any())
                 {
-                    targetColumn = TotalColumns - 1;
-                    StairType = PatternType.Stair;
+                    // Generate a new pattern by copying the last hit objects in reverse-column order
+                    for (int i = RandomStart; i < TotalColumns; i++)
+                        if (PreviousPattern.ColumnHasObject(i))
+                            addToPattern(pattern, RandomStart + TotalColumns - i - 1);
+
+                    return pattern;
                 }
 
-                addToPattern(pattern, targetColumn);
-                return pattern;
-            }
+                if ((convertType & PatternType.Cycle) > 0 && PreviousPattern.HitObjects.Count() == 1
+                                                          // If we convert to 7K + 1, let's not overload the special key
+                                                          && (TotalColumns != 8 || lastColumn != 0)
+                                                          // Make sure the last column was not the centre column
+                                                          && (TotalColumns % 2 == 0 || lastColumn != TotalColumns / 2))
+                {
+                    // Generate a new pattern by cycling backwards (similar to Reverse but for only one hit object)
+                    int column = RandomStart + TotalColumns - lastColumn - 1;
+                    addToPattern(pattern, column);
 
-            if ((convertType & PatternType.KeepSingle) > 0)
-                return generateRandomNotes(1);
+                    return pattern;
+                }
+
+                if ((convertType & PatternType.ForceStack) > 0 && PreviousPattern.HitObjects.Any())
+                {
+                    // Generate a new pattern by placing on the already filled columns
+                    for (int i = RandomStart; i < TotalColumns; i++)
+                        if (PreviousPattern.ColumnHasObject(i))
+                            addToPattern(pattern, i);
+
+                    return pattern;
+                }
+
+                if (PreviousPattern.HitObjects.Count() == 1)
+                {
+                    if ((convertType & PatternType.Stair) > 0)
+                    {
+                        // Generate a new pattern by placing on the next column, cycling back to the start if there is no "next"
+                        int targetColumn = lastColumn + 1;
+                        if (targetColumn == TotalColumns)
+                            targetColumn = RandomStart;
+
+                        addToPattern(pattern, targetColumn);
+                        return pattern;
+                    }
+
+                    if ((convertType & PatternType.ReverseStair) > 0)
+                    {
+                        // Generate a new pattern by placing on the previous column, cycling back to the end if there is no "previous"
+                        int targetColumn = lastColumn - 1;
+                        if (targetColumn == RandomStart - 1)
+                            targetColumn = TotalColumns - 1;
+
+                        addToPattern(pattern, targetColumn);
+                        return pattern;
+                    }
+                }
+
+                if ((convertType & PatternType.KeepSingle) > 0)
+                    return pattern = generateRandomNotes(1);
+
+                if ((convertType & PatternType.Mirror) > 0)
+                {
+                    if (ConversionDifficulty > 6.5)
+                        return pattern = generateRandomPatternWithMirrored(0.12, 0.38, 0.12);
+                    if (ConversionDifficulty > 4)
+                        return pattern = generateRandomPatternWithMirrored(0.12, 0.17, 0);
+                    return pattern = generateRandomPatternWithMirrored(0.12, 0, 0);
+                }
 
-            if ((convertType & PatternType.Mirror) > 0)
-            {
                 if (ConversionDifficulty > 6.5)
-                    return generateRandomPatternWithMirrored(0.12, 0.38, 0.12);
+                {
+                    if ((convertType & PatternType.LowProbability) > 0)
+                        return pattern = generateRandomPattern(0.78, 0.42, 0, 0);
+                    return pattern = generateRandomPattern(1, 0.62, 0, 0);
+                }
+
                 if (ConversionDifficulty > 4)
-                    return generateRandomPatternWithMirrored(0.12, 0.17, 0);
-                return generateRandomPatternWithMirrored(0.12, 0, 0);
-            }
+                {
+                    if ((convertType & PatternType.LowProbability) > 0)
+                        return pattern = generateRandomPattern(0.35, 0.08, 0, 0);
+                    return pattern = generateRandomPattern(0.52, 0.15, 0, 0);
+                }
 
-            if (ConversionDifficulty > 6.5)
+                if (ConversionDifficulty > 2)
+                {
+                    if ((convertType & PatternType.LowProbability) > 0)
+                        return pattern = generateRandomPattern(0.18, 0, 0, 0);
+                    return pattern = generateRandomPattern(0.45, 0, 0, 0);
+                }
+
+                return pattern = generateRandomPattern(0, 0, 0, 0);
+            }
+            finally
             {
-                if ((convertType & PatternType.LowProbability) > 0)
-                    return generateRandomPattern(0.78, 0.42, 0, 0);
-                return generateRandomPattern(1, 0.62, 0, 0);
+                foreach (var obj in pattern.HitObjects)
+                {
+                    if ((convertType & PatternType.Stair) > 0 && obj.Column == TotalColumns - 1)
+                        StairType = PatternType.ReverseStair;
+                    if ((convertType & PatternType.ReverseStair) > 0 && obj.Column == RandomStart)
+                        StairType = PatternType.Stair;
+                }
             }
-
-            if (ConversionDifficulty > 4)
-            {
-                if ((convertType & PatternType.LowProbability) > 0)
-                    return generateRandomPattern(0.35, 0.08, 0, 0);
-                return generateRandomPattern(0.52, 0.15, 0, 0);
-            }
-
-            if (ConversionDifficulty > 2)
-            {
-                if ((convertType & PatternType.LowProbability) > 0)
-                    return generateRandomPattern(0.18, 0, 0, 0);
-                return generateRandomPattern(0.45, 0, 0, 0);
-            }
-
-            return generateRandomPattern(0, 0, 0, 0);
         }
 
         /// <summary>

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

@@ -103,17 +103,14 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 HitObject lastObject = OriginalBeatmap.HitObjects.LastOrDefault();
                 HitObject firstObject = OriginalBeatmap.HitObjects.FirstOrDefault();
 
-                double drainTime = (lastObject?.StartTime ?? 0) - (firstObject?.StartTime ?? 0);
-                drainTime -= OriginalBeatmap.TotalBreakTime;
+                // Drain time in seconds
+                int drainTime = (int)(((lastObject?.StartTime ?? 0) - (firstObject?.StartTime ?? 0) - OriginalBeatmap.TotalBreakTime) / 1000);
 
                 if (drainTime == 0)
-                    drainTime = 10000000;
-
-                // We need this in seconds
-                drainTime /= 1000;
+                    drainTime = 10000;
 
                 BeatmapDifficulty difficulty = OriginalBeatmap.BeatmapInfo.BaseDifficulty;
-                conversionDifficulty = ((difficulty.DrainRate + MathHelper.Clamp(difficulty.ApproachRate, 4, 7)) / 1.5 + OriginalBeatmap.HitObjects.Count() / drainTime * 9f) / 38f * 5f / 1.15;
+                conversionDifficulty = ((difficulty.DrainRate + MathHelper.Clamp(difficulty.ApproachRate, 4, 7)) / 1.5 + (double)OriginalBeatmap.HitObjects.Count() / drainTime * 9f) / 38f * 5f / 1.15;
                 conversionDifficulty = Math.Min(conversionDifficulty.Value, 12);
 
                 return conversionDifficulty.Value;

osu.Game.Rulesets.Mania/Beatmaps/Patterns/PatternGenerator.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using System.Collections.Generic;
 using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns
@@ -42,9 +43,9 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns
         }
 
         /// <summary>
-        /// Generates the pattern for <see cref="HitObject"/>, filled with hit objects.
+        /// Generates the patterns for <see cref="HitObject"/>, each filled with hit objects.
         /// </summary>
-        /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
-        public abstract Pattern Generate();
+        /// <returns>The <see cref="Pattern"/>s containing the hit objects.</returns>
+        public abstract IEnumerable<Pattern> Generate();
     }
 }

osu.Game.Rulesets.Mania/Judgements/HoldNoteJudgement.cs

@@ -8,6 +8,7 @@ namespace osu.Game.Rulesets.Mania.Judgements
     public class HoldNoteJudgement : ManiaJudgement
     {
         public override bool AffectsCombo => false;
+
         protected override int NumericResultFor(HitResult result) => 0;
     }
 }

osu.Game.Rulesets.Mania/MathUtils/FastRandom.cs

@@ -15,11 +15,15 @@ namespace osu.Game.Rulesets.Mania.MathUtils
         private const uint y = 842502087;
         private const uint z = 3579807591;
         private const uint w = 273326509;
-        private uint _x, _y = y, _z = z, _w = w;
+
+        internal uint X { get; private set; }
+        internal uint Y { get; private set; } = y;
+        internal uint Z { get; private set; } = z;
+        internal uint W { get; private set; } = w;
 
         public FastRandom(int seed)
         {
-            _x = (uint)seed;
+            X = (uint)seed;
         }
 
         public FastRandom()
@@ -33,11 +37,11 @@ namespace osu.Game.Rulesets.Mania.MathUtils
         /// <returns>The random value.</returns>
         public uint NextUInt()
         {
-            uint t = _x ^ _x << 11;
-            _x = _y;
-            _y = _z;
-            _z = _w;
-            return _w = _w ^ _w >> 19 ^ t ^ t >> 8;
+            uint t = X ^ X << 11;
+            X = Y;
+            Y = Z;
+            Z = W;
+            return W = W ^ W >> 19 ^ t ^ t >> 8;
         }
 
         /// <summary>

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

@@ -38,8 +38,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
         private readonly Container<DrawableHoldNoteTick> tickContainer;
 
-        public DrawableHoldNote(HoldNote hitObject, ManiaAction action)
-            : base(hitObject, action)
+        public DrawableHoldNote(HoldNote hitObject)
+            : base(hitObject)
         {
             RelativeSizeAxes = Axes.X;
 
@@ -57,12 +57,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                         HoldStartTime = () => holdStartTime
                     })
                 },
-                head = new DrawableHeadNote(this, action)
+                head = new DrawableHeadNote(this)
                 {
                     Anchor = Anchor.TopCentre,
                     Origin = Anchor.TopCentre
                 },
-                tail = new DrawableTailNote(this, action)
+                tail = new DrawableTailNote(this)
                 {
                     Anchor = Anchor.TopCentre,
                     Origin = Anchor.TopCentre
@@ -118,7 +118,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             if (Time.Current < HitObject.StartTime || Time.Current > HitObject.EndTime)
                 return false;
 
-            if (action != Action)
+            if (action != Action.Value)
                 return false;
 
             // The user has pressed during the body of the hold note, after the head note and its hit windows have passed
@@ -135,7 +135,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             if (!holdStartTime.HasValue)
                 return false;
 
-            if (action != Action)
+            if (action != Action.Value)
                 return false;
 
             holdStartTime = null;
@@ -154,8 +154,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
             private readonly DrawableHoldNote holdNote;
 
-            public DrawableHeadNote(DrawableHoldNote holdNote, ManiaAction action)
-                : base(holdNote.HitObject.Head, action)
+            public DrawableHeadNote(DrawableHoldNote holdNote)
+                : base(holdNote.HitObject.Head)
             {
                 this.holdNote = holdNote;
             }
@@ -191,8 +191,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
             private readonly DrawableHoldNote holdNote;
 
-            public DrawableTailNote(DrawableHoldNote holdNote, ManiaAction action)
-                : base(holdNote.HitObject.Tail, action)
+            public DrawableTailNote(DrawableHoldNote holdNote)
+                : base(holdNote.HitObject.Tail)
             {
                 this.holdNote = holdNote;
             }
@@ -235,7 +235,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 if (!holdNote.holdStartTime.HasValue)
                     return false;
 
-                if (action != Action)
+                if (action != Action.Value)
                     return false;
 
                 UpdateJudgement(true);

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

@@ -1,6 +1,7 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
@@ -10,30 +11,26 @@ using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables
 {
-    public abstract class DrawableManiaHitObject<TObject> : DrawableHitObject<ManiaHitObject>
-        where TObject : ManiaHitObject
+    public abstract class DrawableManiaHitObject : DrawableHitObject<ManiaHitObject>
     {
         /// <summary>
-        /// The key that will trigger input for this hit object.
+        /// The <see cref="ManiaAction"/> which causes this <see cref="DrawableManiaHitObject{TObject}"/> to be hit.
         /// </summary>
-        protected ManiaAction Action { get; }
-
-        public new TObject HitObject;
+        protected readonly IBindable<ManiaAction> Action = new Bindable<ManiaAction>();
 
         protected readonly IBindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
 
-        protected DrawableManiaHitObject(TObject hitObject, ManiaAction? action = null)
+        protected DrawableManiaHitObject(ManiaHitObject hitObject)
             : base(hitObject)
         {
-            HitObject = hitObject;
-
-            if (action != null)
-                Action = action.Value;
         }
 
-        [BackgroundDependencyLoader]
-        private void load(IScrollingInfo scrollingInfo)
+        [BackgroundDependencyLoader(true)]
+        private void load([CanBeNull] IBindable<ManiaAction> action, [NotNull] IScrollingInfo scrollingInfo)
         {
+            if (action != null)
+                Action.BindTo(action);
+
             Direction.BindTo(scrollingInfo.Direction);
             Direction.BindValueChanged(OnDirectionChanged, true);
         }
@@ -42,6 +39,18 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
             Anchor = Origin = direction == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre;
         }
+    }
+
+    public abstract class DrawableManiaHitObject<TObject> : DrawableManiaHitObject
+        where TObject : ManiaHitObject
+    {
+        public new readonly TObject HitObject;
+
+        protected DrawableManiaHitObject(TObject hitObject)
+            : base(hitObject)
+        {
+            HitObject = hitObject;
+        }
 
         protected override void UpdateState(ArmedState state)
         {

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

@@ -20,8 +20,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
     {
         private readonly NotePiece headPiece;
 
-        public DrawableNote(Note hitObject, ManiaAction action)
-            : base(hitObject, action)
+        public DrawableNote(Note hitObject)
+            : base(hitObject)
         {
             RelativeSizeAxes = Axes.X;
             AutoSizeAxes = Axes.Y;
@@ -74,7 +74,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
         public virtual bool OnPressed(ManiaAction action)
         {
-            if (action != Action)
+            if (action != Action.Value)
                 return false;
 
             return UpdateJudgement(true);

osu.Game.Rulesets.Mania/Resources/Testing/Beatmaps/basic-expected-conversion.json

@@ -1,103 +1,132 @@
 {
     "Mappings": [{
-            "StartTime": 500,
-            "Objects": [{
-                    "StartTime": 500,
-                    "EndTime": 2500,
-                    "Column": 0
-                },
-                {
-                    "StartTime": 1500,
-                    "EndTime": 2500,
-                    "Column": 1
-                }
-            ]
-        },
-        {
-            "StartTime": 3000,
-            "Objects": [{
-                "StartTime": 3000,
-                "EndTime": 4000,
-                "Column": 2
-            }]
-        },
-        {
-            "StartTime": 4500,
-            "Objects": [{
-                "StartTime": 4500,
-                "EndTime": 5500,
-                "Column": 4
-            }]
-        },
-        {
-            "StartTime": 6000,
-            "Objects": [{
-                "StartTime": 6000,
-                "EndTime": 6500,
-                "Column": 2
-            }]
-        },
-        {
-            "StartTime": 7000,
-            "Objects": [{
-                "StartTime": 7000,
-                "EndTime": 8000,
-                "Column": 2
-            }]
-        },
-        {
-            "StartTime": 8500,
-            "Objects": [{
-                "StartTime": 8500,
-                "EndTime": 11000,
-                "Column": 0
-            }]
-        },
-        {
-            "StartTime": 11500,
-            "Objects": [{
-                "StartTime": 11500,
-                "EndTime": 12000,
-                "Column": 1
-            }]
-        },
-        {
-            "StartTime": 12500,
-            "Objects": [{
-                "StartTime": 12500,
-                "EndTime": 16500,
-                "Column": 4
-            }]
-        },
-        {
-            "StartTime": 17000,
-            "Objects": [{
-                "StartTime": 17000,
-                "EndTime": 18000,
-                "Column": 2
-            }]
-        },
-        {
-            "StartTime": 18500,
-            "Objects": [{
-                "StartTime": 18500,
-                "EndTime": 19450,
-                "Column": 0
-            }]
-        },
-        {
-            "StartTime": 19875,
-            "Objects": [{
-                    "StartTime": 19875,
-                    "EndTime": 23875,
-                    "Column": 1
-                },
-                {
-                    "StartTime": 19875,
-                    "EndTime": 23875,
-                    "Column": 0
-                }
-            ]
-        }
-    ]
+        "RandomW": 2659373485,
+        "RandomX": 3579807591,
+        "RandomY": 273326509,
+        "RandomZ": 272969173,
+        "StartTime": 500.0,
+        "Objects": [{
+            "StartTime": 500.0,
+            "EndTime": 2500.0,
+            "Column": 0
+        }, {
+            "StartTime": 1500.0,
+            "EndTime": 2500.0,
+            "Column": 1
+        }]
+    }, {
+        "RandomW": 3083803045,
+        "RandomX": 273326509,
+        "RandomY": 272969173,
+        "RandomZ": 2659373485,
+        "StartTime": 3000.0,
+        "Objects": [{
+            "StartTime": 3000.0,
+            "EndTime": 4000.0,
+            "Column": 2
+        }]
+    }, {
+        "RandomW": 4073554232,
+        "RandomX": 272969173,
+        "RandomY": 2659373485,
+        "RandomZ": 3083803045,
+        "StartTime": 4500.0,
+        "Objects": [{
+            "StartTime": 4500.0,
+            "EndTime": 5500.0,
+            "Column": 4
+        }]
+    }, {
+        "RandomW": 3420401969,
+        "RandomX": 2659373485,
+        "RandomY": 3083803045,
+        "RandomZ": 4073554232,
+        "StartTime": 6000.0,
+        "Objects": [{
+            "StartTime": 6000.0,
+            "EndTime": 6500.0,
+            "Column": 2
+        }]
+    }, {
+        "RandomW": 1129881182,
+        "RandomX": 3083803045,
+        "RandomY": 4073554232,
+        "RandomZ": 3420401969,
+        "StartTime": 7000.0,
+        "Objects": [{
+            "StartTime": 7000.0,
+            "EndTime": 8000.0,
+            "Column": 2
+        }]
+    }, {
+        "RandomW": 315568458,
+        "RandomX": 3420401969,
+        "RandomY": 1129881182,
+        "RandomZ": 2358617505,
+        "StartTime": 8500.0,
+        "Objects": [{
+            "StartTime": 8500.0,
+            "EndTime": 11000.0,
+            "Column": 0
+        }]
+    }, {
+        "RandomW": 548134043,
+        "RandomX": 1129881182,
+        "RandomY": 2358617505,
+        "RandomZ": 315568458,
+        "StartTime": 11500.0,
+        "Objects": [{
+            "StartTime": 11500.0,
+            "EndTime": 12000.0,
+            "Column": 1
+        }]
+    }, {
+        "RandomW": 3979422122,
+        "RandomX": 548134043,
+        "RandomY": 2810584254,
+        "RandomZ": 2250186050,
+        "StartTime": 12500.0,
+        "Objects": [{
+            "StartTime": 12500.0,
+            "EndTime": 16500.0,
+            "Column": 4
+        }]
+    }, {
+        "RandomW": 2466283411,
+        "RandomX": 2810584254,
+        "RandomY": 2250186050,
+        "RandomZ": 3979422122,
+        "StartTime": 17000.0,
+        "Objects": [{
+            "StartTime": 17000.0,
+            "EndTime": 18000.0,
+            "Column": 2
+        }]
+    }, {
+        "RandomW": 83157665,
+        "RandomX": 2250186050,
+        "RandomY": 3979422122,
+        "RandomZ": 2466283411,
+        "StartTime": 18500.0,
+        "Objects": [{
+            "StartTime": 18500.0,
+            "EndTime": 19450.0,
+            "Column": 0
+        }]
+    }, {
+        "RandomW": 2383087700,
+        "RandomX": 83157665,
+        "RandomY": 2055150192,
+        "RandomZ": 510071020,
+        "StartTime": 19875.0,
+        "Objects": [{
+            "StartTime": 19875.0,
+            "EndTime": 23875.0,
+            "Column": 1
+        }, {
+            "StartTime": 19875.0,
+            "EndTime": 23875.0,
+            "Column": 0
+        }]
+    }]
 }

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

@@ -7,6 +7,8 @@ using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.UI.Components;
@@ -19,21 +21,7 @@ namespace osu.Game.Rulesets.Mania.UI
         private const float column_width = 45;
         private const float special_column_width = 70;
 
-        private ManiaAction action;
-
-        public ManiaAction Action
-        {
-            get => action;
-            set
-            {
-                if (action == value)
-                    return;
-                action = value;
-
-                background.Action = value;
-                keyArea.Action = value;
-            }
-        }
+        public readonly Bindable<ManiaAction> Action = new Bindable<ManiaAction>();
 
         private readonly ColumnBackground background;
         private readonly ColumnKeyArea keyArea;
@@ -130,6 +118,13 @@ namespace osu.Game.Rulesets.Mania.UI
             }
         }
 
+        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+        {
+            var dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+            dependencies.CacheAs<IBindable<ManiaAction>>(Action);
+            return dependencies;
+        }
+
         /// <summary>
         /// Adds a DrawableHitObject to this Playfield.
         /// </summary>

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

@@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Mania.UI.Components
 {
     public class ColumnBackground : CompositeDrawable, IKeyBindingHandler<ManiaAction>, IHasAccentColour
     {
-        public ManiaAction Action;
+        private readonly IBindable<ManiaAction> action = new Bindable<ManiaAction>();
 
         private Box background;
         private Box backgroundOverlay;
@@ -25,8 +25,10 @@ namespace osu.Game.Rulesets.Mania.UI.Components
         private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
 
         [BackgroundDependencyLoader]
-        private void load(IScrollingInfo scrollingInfo)
+        private void load(IBindable<ManiaAction> action, IScrollingInfo scrollingInfo)
         {
+            this.action.BindTo(action);
+
             InternalChildren = new[]
             {
                 background = new Box
@@ -91,14 +93,14 @@ namespace osu.Game.Rulesets.Mania.UI.Components
 
         public bool OnPressed(ManiaAction action)
         {
-            if (action == Action)
+            if (action == this.action.Value)
                 backgroundOverlay.FadeTo(1, 50, Easing.OutQuint).Then().FadeTo(0.5f, 250, Easing.OutQuint);
             return false;
         }
 
         public bool OnReleased(ManiaAction action)
         {
-            if (action == Action)
+            if (action == this.action.Value)
                 backgroundOverlay.FadeTo(0, 250, Easing.OutQuint);
             return false;
         }

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

@@ -21,15 +21,16 @@ namespace osu.Game.Rulesets.Mania.UI.Components
         private const float key_icon_size = 10;
         private const float key_icon_corner_radius = 3;
 
-        public ManiaAction Action;
-
+        private readonly IBindable<ManiaAction> action = new Bindable<ManiaAction>();
         private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
 
         private Container keyIcon;
 
         [BackgroundDependencyLoader]
-        private void load(IScrollingInfo scrollingInfo)
+        private void load(IBindable<ManiaAction> action, IScrollingInfo scrollingInfo)
         {
+            this.action.BindTo(action);
+
             Drawable gradient;
 
             InternalChildren = new[]
@@ -107,14 +108,14 @@ namespace osu.Game.Rulesets.Mania.UI.Components
 
         public bool OnPressed(ManiaAction action)
         {
-            if (action == Action)
+            if (action == this.action.Value)
                 keyIcon.ScaleTo(1.4f, 50, Easing.OutQuint).Then().ScaleTo(1.3f, 250, Easing.OutQuint);
             return false;
         }
 
         public bool OnReleased(ManiaAction action)
         {
-            if (action == Action)
+            if (action == this.action.Value)
                 keyIcon.ScaleTo(1f, 125, Easing.OutQuint);
             return false;
         }

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

@@ -101,17 +101,15 @@ namespace osu.Game.Rulesets.Mania.UI
 
         protected override DrawableHitObject<ManiaHitObject> GetVisualRepresentation(ManiaHitObject h)
         {
-            ManiaAction action = Playfield.Columns.ElementAt(h.Column).Action;
-
-            var holdNote = h as HoldNote;
-            if (holdNote != null)
-                return new DrawableHoldNote(holdNote, action);
-
-            var note = h as Note;
-            if (note != null)
-                return new DrawableNote(note, action);
-
-            return null;
+            switch (h)
+            {
+                case HoldNote holdNote:
+                    return new DrawableHoldNote(holdNote);
+                case Note note:
+                    return new DrawableNote(note);
+                default:
+                    return null;
+            }
         }
 
         protected override Vector2 PlayfieldArea => new Vector2(1, 0.8f);

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

@@ -127,7 +127,7 @@ namespace osu.Game.Rulesets.Mania.UI
                 var column = new Column(direction)
                 {
                     IsSpecial = isSpecial,
-                    Action = isSpecial ? specialColumnStartAction++ : normalColumnStartAction++
+                    Action = { Value = isSpecial ? specialColumnStartAction++ : normalColumnStartAction++ }
                 };
 
                 AddColumn(column);

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

@@ -8,17 +8,19 @@ using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Tests.Beatmaps;
-using OpenTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
-    internal class OsuBeatmapConversionTest : BeatmapConversionTest<ConvertValue>
+    [TestFixture]
+    public class OsuBeatmapConversionTest : BeatmapConversionTest<ConvertValue>
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Osu";
 
         [TestCase("basic")]
         [TestCase("colinear-perfect-curve")]
+        [TestCase("slider-ticks")]
         public new void Test(string name)
         {
             base.Test(name);
@@ -26,24 +28,30 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         protected override IEnumerable<ConvertValue> CreateConvertValue(HitObject hitObject)
         {
-            var startPosition = (hitObject as IHasPosition)?.Position ?? new Vector2(256, 192);
-            var endPosition = (hitObject as Slider)?.EndPosition ?? startPosition;
-
-            yield return new ConvertValue
+            switch (hitObject)
             {
-                StartTime = hitObject.StartTime,
-                EndTime = (hitObject as IHasEndTime)?.EndTime ?? hitObject.StartTime,
-                StartX = startPosition.X,
-                StartY = startPosition.Y,
-                EndX = endPosition.X,
-                EndY = endPosition.Y
+                case Slider slider:
+                    foreach (var nested in slider.NestedHitObjects)
+                        yield return createConvertValue(nested);
+                    break;
+                default:
+                    yield return createConvertValue(hitObject);
+                    break;
+            }
+
+            ConvertValue createConvertValue(HitObject obj) => new ConvertValue
+            {
+                StartTime = obj.StartTime,
+                EndTime = (obj as IHasEndTime)?.EndTime ?? obj.StartTime,
+                X = (obj as IHasPosition)?.X ?? OsuPlayfield.BASE_SIZE.X / 2,
+                Y = (obj as IHasPosition)?.Y ?? OsuPlayfield.BASE_SIZE.Y / 2,
             };
         }
 
         protected override Ruleset CreateRuleset() => new OsuRuleset();
     }
 
-    internal struct ConvertValue : IEquatable<ConvertValue>
+    public struct ConvertValue : IEquatable<ConvertValue>
     {
         /// <summary>
         /// A sane value to account for osu!stable using ints everwhere.
@@ -52,17 +60,13 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         public double StartTime;
         public double EndTime;
-        public float StartX;
-        public float StartY;
-        public float EndX;
-        public float EndY;
+        public float X;
+        public float Y;
 
         public bool Equals(ConvertValue other)
-            => Precision.AlmostEquals(StartTime, other.StartTime)
+            => Precision.AlmostEquals(StartTime, other.StartTime, conversion_lenience)
                && Precision.AlmostEquals(EndTime, other.EndTime, conversion_lenience)
-               && Precision.AlmostEquals(StartX, other.StartX)
-               && Precision.AlmostEquals(StartY, other.StartY, conversion_lenience)
-               && Precision.AlmostEquals(EndX, other.EndX, conversion_lenience)
-               && Precision.AlmostEquals(EndY, other.EndY, conversion_lenience);
+               && Precision.AlmostEquals(X, other.X, conversion_lenience)
+               && Precision.AlmostEquals(Y, other.Y, conversion_lenience);
     }
 }

osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapConverter.cs

@@ -27,6 +27,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
             var endTimeData = original as IHasEndTime;
             var positionData = original as IHasPosition;
             var comboData = original as IHasCombo;
+            var legacyOffset = original as IHasLegacyLastTickOffset;
 
             if (curveData != null)
             {
@@ -40,7 +41,8 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                     RepeatSamples = curveData.RepeatSamples,
                     RepeatCount = curveData.RepeatCount,
                     Position = positionData?.Position ?? Vector2.Zero,
-                    NewCombo = comboData?.NewCombo ?? false
+                    NewCombo = comboData?.NewCombo ?? false,
+                    LegacyLastTickOffset = legacyOffset?.LegacyLastTickOffset
                 };
             }
             else if (endTimeData != null)

osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapProcessor.cs

@@ -15,10 +15,10 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
         {
         }
 
-        public override void PostProcess()
+        public override void PreProcess()
         {
+            base.PreProcess();
             applyStacking((Beatmap<OsuHitObject>)Beatmap);
-            base.PostProcess();
         }
 
         private void applyStacking(Beatmap<OsuHitObject> beatmap)
@@ -44,7 +44,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                         continue;
 
                     double endTime = (stackBaseObject as IHasEndTime)?.EndTime ?? stackBaseObject.StartTime;
-                    double stackThreshold = objectN.TimePreempt * beatmap.BeatmapInfo?.StackLeniency ?? 0.7f;
+                    double stackThreshold = objectN.TimePreempt * beatmap.BeatmapInfo.StackLeniency;
 
                     if (objectN.StartTime - endTime > stackThreshold)
                         //We are no longer within stacking range of the next object.
@@ -87,7 +87,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                 OsuHitObject objectI = beatmap.HitObjects[i];
                 if (objectI.StackHeight != 0 || objectI is Spinner) continue;
 
-                double stackThreshold = objectI.TimePreempt * beatmap.BeatmapInfo?.StackLeniency ?? 0.7f;
+                double stackThreshold = objectI.TimePreempt * beatmap.BeatmapInfo.StackLeniency;
 
                 /* If this object is a hitcircle, then we enter this "special" case.
                     * It either ends with a stack of hitcircles only, or a stack of hitcircles that are underneath a slider.

osu.Game.Rulesets.Osu/Judgements/OsuJudgement.cs

@@ -1,7 +1,6 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
@@ -12,11 +11,6 @@ namespace osu.Game.Rulesets.Osu.Judgements
     {
         public override HitResult MaxResult => HitResult.Great;
 
-        /// <summary>
-        /// The positional hit offset.
-        /// </summary>
-        public Vector2 PositionOffset;
-
         protected override int NumericResultFor(HitResult result)
         {
             switch (result)

osu.Game.Rulesets.Osu/Judgements/OsuSliderTailJudgement.cs

@@ -8,6 +8,7 @@ namespace osu.Game.Rulesets.Osu.Judgements
     public class OsuSliderTailJudgement : OsuJudgement
     {
         public override bool AffectsCombo => false;
+
         protected override int NumericResultFor(HitResult result) => 0;
     }
 }

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

@@ -93,7 +93,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             AddJudgement(new OsuJudgement
             {
                 Result = result,
-                PositionOffset = Vector2.Zero //todo: set to correct value
             });
         }
 

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

@@ -93,6 +93,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 base.AccentColour = value;
                 Body.AccentColour = AccentColour;
                 Ball.AccentColour = AccentColour;
+
+                foreach (var drawableHitObject in NestedHitObjects)
+                    drawableHitObject.AccentColour = AccentColour;
             }
         }
 
@@ -133,7 +136,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
             if (!userTriggered && Time.Current >= slider.EndTime)
             {
-                var judgementsCount = NestedHitObjects.Count;
+                var judgementsCount = NestedHitObjects.Count();
                 var judgementsHit = NestedHitObjects.Count(h => h.IsHit);
 
                 var hitFraction = (double)judgementsHit / judgementsCount;

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

@@ -54,9 +54,9 @@ namespace osu.Game.Rulesets.Osu.Objects
 
         public virtual bool NewCombo { get; set; }
 
-        public int IndexInCurrentCombo { get; set; }
+        public virtual int IndexInCurrentCombo { get; set; }
 
-        public int ComboIndex { get; set; }
+        public virtual int ComboIndex { get; set; }
 
         public bool LastInCombo { get; set; }
 

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

@@ -1,6 +1,7 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System;
 using OpenTK;
 using osu.Game.Rulesets.Objects.Types;
 using System.Collections.Generic;
@@ -25,6 +26,28 @@ namespace osu.Game.Rulesets.Osu.Objects
         public Vector2 StackedPositionAt(double t) => StackedPosition + this.CurvePositionAt(t);
         public override Vector2 EndPosition => Position + this.CurvePositionAt(1);
 
+        public override int ComboIndex
+        {
+            get => base.ComboIndex;
+            set
+            {
+                base.ComboIndex = value;
+                foreach (var n in NestedHitObjects.OfType<IHasComboInformation>())
+                    n.ComboIndex = value;
+            }
+        }
+
+        public override int IndexInCurrentCombo
+        {
+            get => base.IndexInCurrentCombo;
+            set
+            {
+                base.IndexInCurrentCombo = value;
+                foreach (var n in NestedHitObjects.OfType<IHasComboInformation>())
+                    n.IndexInCurrentCombo = value;
+            }
+        }
+
         public SliderCurve Curve { get; } = new SliderCurve();
 
         public List<Vector2> ControlPoints
@@ -45,6 +68,8 @@ namespace osu.Game.Rulesets.Osu.Objects
             set { Curve.Distance = value; }
         }
 
+        public double? LegacyLastTickOffset { get; set; }
+
         /// <summary>
         /// The position of the cursor at the point of completion of this <see cref="Slider"/> if it was hit
         /// with as few movements as possible. This is set and used by difficulty calculation.
@@ -91,6 +116,9 @@ namespace osu.Game.Rulesets.Osu.Objects
             createSliderEnds();
             createTicks();
             createRepeatPoints();
+
+            if (LegacyLastTickOffset != null)
+                TailCircle.StartTime = Math.Max(StartTime + Duration / 2, TailCircle.StartTime - LegacyLastTickOffset.Value);
         }
 
         private void createSliderEnds()
@@ -141,7 +169,8 @@ namespace osu.Game.Rulesets.Osu.Objects
                     var distanceProgress = d / length;
                     var timeProgress = reversed ? 1 - distanceProgress : distanceProgress;
 
-                    var firstSample = Samples.FirstOrDefault(s => s.Name == SampleInfo.HIT_NORMAL) ?? Samples.FirstOrDefault(); // TODO: remove this when guaranteed sort is present for samples (https://github.com/ppy/osu/issues/1933)
+                    var firstSample = Samples.FirstOrDefault(s => s.Name == SampleInfo.HIT_NORMAL)
+                                      ?? Samples.FirstOrDefault(); // TODO: remove this when guaranteed sort is present for samples (https://github.com/ppy/osu/issues/1933)
                     var sampleList = new List<SampleInfo>();
 
                     if (firstSample != null)

osu.Game.Rulesets.Osu/Replays/OsuAutoGeneratorBase.cs

@@ -6,6 +6,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Osu.Objects;
 using System;
 using System.Collections.Generic;
+using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Replays;
 using osu.Game.Users;
 
@@ -18,7 +19,7 @@ namespace osu.Game.Rulesets.Osu.Replays
         /// <summary>
         /// Constants (for spinners).
         /// </summary>
-        protected static readonly Vector2 SPINNER_CENTRE = new Vector2(256, 192);
+        protected static readonly Vector2 SPINNER_CENTRE = OsuPlayfield.BASE_SIZE / 2;
         protected const float SPIN_RADIUS = 50;
 
         /// <summary>

osu.Game.Rulesets.Osu/Resources/Testing/Beatmaps/basic-expected-conversion.json

@@ -1,124 +1,256 @@
 {
     "Mappings": [{
-            "StartTime": 500,
-            "Objects": [{
-                "StartTime": 500,
-                "EndTime": 2500,
-                "StartX": 96,
-                "StartY": 192,
-                "EndX": 96,
-                "EndY": 192
-            }]
-        },
-        {
-            "StartTime": 3000,
-            "Objects": [{
-                "StartTime": 3000,
-                "EndTime": 4000,
-                "StartX": 256,
-                "StartY": 192,
-                "EndX": 256,
-                "EndY": 192
-            }]
-        },
-        {
-            "StartTime": 4500,
-            "Objects": [{
-                "StartTime": 4500,
-                "EndTime": 5500,
-                "StartX": 256,
-                "StartY": 192,
-                "EndX": 256,
-                "EndY": 192
-            }]
-        },
-        {
-            "StartTime": 6000,
-            "Objects": [{
-                "StartTime": 6000,
-                "EndTime": 6500,
-                "StartX": 256,
-                "StartY": 192,
-                "EndX": 256,
-                "EndY": 192
-            }]
-        },
-        {
-            "StartTime": 7000,
-            "Objects": [{
-                "StartTime": 7000,
-                "EndTime": 8000,
-                "StartX": 256,
-                "StartY": 128,
-                "EndX": 256,
-                "EndY": 128
-            }]
-        },
-        {
-            "StartTime": 8500,
-            "Objects": [{
-                "StartTime": 8500,
-                "EndTime": 10999,
-                "StartX": 32,
-                "StartY": 192,
-                "EndX": 508.166229,
-                "EndY": 153.299271
-            }]
-        },
-        {
-            "StartTime": 11500,
-            "Objects": [{
-                "StartTime": 11500,
-                "EndTime": 12000,
-                "StartX": 256,
-                "StartY": 192,
-                "EndX": 256,
-                "EndY": 192
-            }]
-        },
-        {
-            "StartTime": 12500,
-            "Objects": [{
-                "StartTime": 12500,
-                "EndTime": 16500,
-                "StartX": 512,
-                "StartY": 320,
-                "EndX": 291.1977,
-                "EndY": 40.799427
-            }]
-        },
-        {
-            "StartTime": 17000,
-            "Objects": [{
-                "StartTime": 17000,
-                "EndTime": 18000,
-                "StartX": 256,
-                "StartY": 256,
-                "EndX": 256,
-                "EndY": 256
-            }]
-        },
-        {
-            "StartTime": 18500,
-            "Objects": [{
-                "StartTime": 18500,
-                "EndTime": 19450,
-                "StartX": 256,
-                "StartY": 192,
-                "EndX": 256,
-                "EndY": 192
-            }]
-        },
-        {
-            "StartTime": 19875,
-            "Objects": [{
-                "StartTime": 19875,
-                "EndTime": 23874,
-                "StartX": 216,
-                "StartY": 231,
-                "EndX": 408.720825,
-                "EndY": 339.810455
-            }]
-        }
-    ]
+        "StartTime": 500.0,
+        "Objects": [{
+            "StartTime": 500.0,
+            "EndTime": 500.0,
+            "X": 96.0,
+            "Y": 192.0
+        }, {
+            "StartTime": 1000.0,
+            "EndTime": 1000.0,
+            "X": 256.0,
+            "Y": 192.0
+        }, {
+            "StartTime": 1500.0,
+            "EndTime": 1500.0,
+            "X": 416.0,
+            "Y": 192.0
+        }, {
+            "StartTime": 2000.0,
+            "EndTime": 2000.0,
+            "X": 256.0,
+            "Y": 192.0
+        }, {
+            "StartTime": 2464.0,
+            "EndTime": 2464.0,
+            "X": 96.0,
+            "Y": 192.0
+        }]
+    }, {
+        "StartTime": 3000.0,
+        "Objects": [{
+            "StartTime": 3000.0,
+            "EndTime": 4000.0,
+            "X": 256.0,
+            "Y": 192.0
+        }]
+    }, {
+        "StartTime": 4500.0,
+        "Objects": [{
+            "StartTime": 4500.0,
+            "EndTime": 5500.0,
+            "X": 256.0,
+            "Y": 192.0
+        }]
+    }, {
+        "StartTime": 6000.0,
+        "Objects": [{
+            "StartTime": 6000.0,
+            "EndTime": 6500.0,
+            "X": 256.0,
+            "Y": 192.0
+        }]
+    }, {
+        "StartTime": 7000.0,
+        "Objects": [{
+            "StartTime": 7000.0,
+            "EndTime": 7000.0,
+            "X": 256.0,
+            "Y": 128.0
+        }, {
+            "StartTime": 7250.0,
+            "EndTime": 7250.0,
+            "X": 336.0,
+            "Y": 128.0
+        }, {
+            "StartTime": 7500.0,
+            "EndTime": 7500.0,
+            "X": 256.0,
+            "Y": 128.0
+        }, {
+            "StartTime": 7750.0,
+            "EndTime": 7750.0,
+            "X": 336.0,
+            "Y": 128.0
+        }, {
+            "StartTime": 7964.0,
+            "EndTime": 7964.0,
+            "X": 256.0,
+            "Y": 128.0
+        }]
+    }, {
+        "StartTime": 8500.0,
+        "Objects": [{
+            "StartTime": 8500.0,
+            "EndTime": 8500.0,
+            "X": 32.0,
+            "Y": 192.0
+        }, {
+            "StartTime": 9000.0,
+            "EndTime": 9000.0,
+            "X": 101.81015,
+            "Y": 326.4915
+        }, {
+            "StartTime": 9500.0,
+            "EndTime": 9500.0,
+            "X": 237.2304,
+            "Y": 276.282928
+        }, {
+            "StartTime": 10000.0,
+            "EndTime": 10000.0,
+            "X": 270.339874,
+            "Y": 121.1423
+        }, {
+            "StartTime": 10500.0,
+            "EndTime": 10500.0,
+            "X": 401.0588,
+            "Y": 49.1515045
+        }, {
+            "StartTime": 10964.0,
+            "EndTime": 10964.0,
+            "X": 508.166229,
+            "Y": 153.299271
+        }]
+    }, {
+        "StartTime": 11500.0,
+        "Objects": [{
+            "StartTime": 11500.0,
+            "EndTime": 12000.0,
+            "X": 256.0,
+            "Y": 192.0
+        }]
+    }, {
+        "StartTime": 12500.0,
+        "Objects": [{
+            "StartTime": 12500.0,
+            "EndTime": 12500.0,
+            "X": 512.0,
+            "Y": 320.0
+        }, {
+            "StartTime": 13000.0,
+            "EndTime": 13000.0,
+            "X": 353.235535,
+            "Y": 300.154449
+        }, {
+            "StartTime": 13500.0,
+            "EndTime": 13500.0,
+            "X": 194.471069,
+            "Y": 280.3089
+        }, {
+            "StartTime": 14000.0,
+            "EndTime": 14000.0,
+            "X": 35.7066345,
+            "Y": 260.463318
+        }, {
+            "StartTime": 14500.0,
+            "EndTime": 14500.0,
+            "X": 118.370323,
+            "Y": 219.009277
+        }, {
+            "StartTime": 15000.0,
+            "EndTime": 15000.0,
+            "X": 271.087128,
+            "Y": 171.285278
+        }, {
+            "StartTime": 15500.0,
+            "EndTime": 15500.0,
+            "X": 423.803925,
+            "Y": 123.561279
+        }, {
+            "StartTime": 16000.0,
+            "EndTime": 16000.0,
+            "X": 446.420532,
+            "Y": 79.60513
+        }, {
+            "StartTime": 16464.0,
+            "EndTime": 16464.0,
+            "X": 291.1977,
+            "Y": 40.799427
+        }]
+    }, {
+        "StartTime": 17000.0,
+        "Objects": [{
+            "StartTime": 17000.0,
+            "EndTime": 17000.0,
+            "X": 256.0,
+            "Y": 256.0
+        }, {
+            "StartTime": 17250.0,
+            "EndTime": 17250.0,
+            "X": 176.0,
+            "Y": 256.0
+        }, {
+            "StartTime": 17500.0,
+            "EndTime": 17500.0,
+            "X": 256.0,
+            "Y": 256.0
+        }, {
+            "StartTime": 17750.0,
+            "EndTime": 17750.0,
+            "X": 176.0,
+            "Y": 256.0
+        }, {
+            "StartTime": 17964.0,
+            "EndTime": 17964.0,
+            "X": 256.0,
+            "Y": 256.0
+        }]
+    }, {
+        "StartTime": 18500.0,
+        "Objects": [{
+            "StartTime": 18500.0,
+            "EndTime": 19450.0,
+            "X": 256.0,
+            "Y": 192.0
+        }]
+    }, {
+        "StartTime": 19875.0,
+        "Objects": [{
+            "StartTime": 19875.0,
+            "EndTime": 19875.0,
+            "X": 216.0,
+            "Y": 231.0
+        }, {
+            "StartTime": 20375.0,
+            "EndTime": 20375.0,
+            "X": 317.446747,
+            "Y": 171.345245
+        }, {
+            "StartTime": 20875.0,
+            "EndTime": 20875.0,
+            "X": 270.3294,
+            "Y": 310.4395
+        }, {
+            "StartTime": 21375.0,
+            "EndTime": 21375.0,
+            "X": 119.121056,
+            "Y": 322.8657
+        }, {
+            "StartTime": 21875.0,
+            "EndTime": 21875.0,
+            "X": 124.28746,
+            "Y": 165.224731
+        }, {
+            "StartTime": 22375.0,
+            "EndTime": 22375.0,
+            "X": 240.4715,
+            "Y": 62.65587
+        }, {
+            "StartTime": 22875.0,
+            "EndTime": 22875.0,
+            "X": 398.054047,
+            "Y": 39.064167
+        }, {
+            "StartTime": 23375.0,
+            "EndTime": 23375.0,
+            "X": 439.749878,
+            "Y": 183.668091
+        }, {
+            "StartTime": 23839.0,
+            "EndTime": 23839.0,
+            "X": 408.720825,
+            "Y": 339.810455
+        }]
+    }]
 }

osu.Game.Rulesets.Osu/Resources/Testing/Beatmaps/colinear-perfect-curve-expected-conversion.json

@@ -1,13 +1,16 @@
 {
-  "Mappings": [{
-    "StartTime": 118858,
-    "Objects": [{
-      "StartTime": 118858,
-      "EndTime": 119088,
-      "StartX": 219,
-      "StartY": 215,
-      "EndX": 239.6507,
-      "EndY": 29.1437378
+    "Mappings": [{
+        "StartTime": 118858.0,
+        "Objects": [{
+            "StartTime": 118858.0,
+            "EndTime": 118858.0,
+            "X": 219.0,
+            "Y": 215.0
+        }, {
+            "StartTime": 119052.0,
+            "EndTime": 119052.0,
+            "X": 239.6507,
+            "Y": 29.1437378
+        }]
     }]
-  }]
 }

osu.Game.Rulesets.Osu/Resources/Testing/Beatmaps/slider-ticks-expected-conversion.json

@@ -0,0 +1,331 @@
+{
+    "Mappings": [{
+        "StartTime": 500.0,
+        "Objects": [{
+            "StartTime": 500.0,
+            "EndTime": 500.0,
+            "X": 96.0,
+            "Y": 192.0
+        }, {
+            "StartTime": 624.0,
+            "EndTime": 624.0,
+            "X": 105.921242,
+            "Y": 192.0
+        }, {
+            "StartTime": 749.0,
+            "EndTime": 749.0,
+            "X": 115.922493,
+            "Y": 192.0
+        }, {
+            "StartTime": 874.0,
+            "EndTime": 874.0,
+            "X": 125.923737,
+            "Y": 192.0
+        }, {
+            "StartTime": 999.0,
+            "EndTime": 999.0,
+            "X": 135.924988,
+            "Y": 192.0
+        }, {
+            "StartTime": 1124.0,
+            "EndTime": 1124.0,
+            "X": 145.926239,
+            "Y": 192.0
+        }, {
+            "StartTime": 1249.0,
+            "EndTime": 1249.0,
+            "X": 155.92749,
+            "Y": 192.0
+        }, {
+            "StartTime": 1374.0,
+            "EndTime": 1374.0,
+            "X": 165.928741,
+            "Y": 192.0
+        }, {
+            "StartTime": 1499.0,
+            "EndTime": 1499.0,
+            "X": 175.93,
+            "Y": 192.0
+        }, {
+            "StartTime": 1624.0,
+            "EndTime": 1624.0,
+            "X": 185.931244,
+            "Y": 192.0
+        }, {
+            "StartTime": 1749.0,
+            "EndTime": 1749.0,
+            "X": 195.9325,
+            "Y": 192.0
+        }, {
+            "StartTime": 1874.0,
+            "EndTime": 1874.0,
+            "X": 205.933746,
+            "Y": 192.0
+        }, {
+            "StartTime": 1999.0,
+            "EndTime": 1999.0,
+            "X": 215.935,
+            "Y": 192.0
+        }, {
+            "StartTime": 2124.0,
+            "EndTime": 2124.0,
+            "X": 225.936234,
+            "Y": 192.0
+        }, {
+            "StartTime": 2249.0,
+            "EndTime": 2249.0,
+            "X": 235.9375,
+            "Y": 192.0
+        }, {
+            "StartTime": 2374.0,
+            "EndTime": 2374.0,
+            "X": 245.938751,
+            "Y": 192.0
+        }, {
+            "StartTime": 2499.0,
+            "EndTime": 2499.0,
+            "X": 255.94,
+            "Y": 192.0
+        }, {
+            "StartTime": 2624.0,
+            "EndTime": 2624.0,
+            "X": 265.941223,
+            "Y": 192.0
+        }, {
+            "StartTime": 2749.0,
+            "EndTime": 2749.0,
+            "X": 275.9425,
+            "Y": 192.0
+        }, {
+            "StartTime": 2874.0,
+            "EndTime": 2874.0,
+            "X": 285.943756,
+            "Y": 192.0
+        }, {
+            "StartTime": 2999.0,
+            "EndTime": 2999.0,
+            "X": 295.945,
+            "Y": 192.0
+        }, {
+            "StartTime": 3124.0,
+            "EndTime": 3124.0,
+            "X": 305.946259,
+            "Y": 192.0
+        }, {
+            "StartTime": 3249.0,
+            "EndTime": 3249.0,
+            "X": 315.9475,
+            "Y": 192.0
+        }, {
+            "StartTime": 3374.0,
+            "EndTime": 3374.0,
+            "X": 325.94873,
+            "Y": 192.0
+        }, {
+            "StartTime": 3499.0,
+            "EndTime": 3499.0,
+            "X": 335.949982,
+            "Y": 192.0
+        }, {
+            "StartTime": 3624.0,
+            "EndTime": 3624.0,
+            "X": 345.951233,
+            "Y": 192.0
+        }, {
+            "StartTime": 3749.0,
+            "EndTime": 3749.0,
+            "X": 355.952484,
+            "Y": 192.0
+        }, {
+            "StartTime": 3874.0,
+            "EndTime": 3874.0,
+            "X": 365.953766,
+            "Y": 192.0
+        }, {
+            "StartTime": 3999.0,
+            "EndTime": 3999.0,
+            "X": 375.955,
+            "Y": 192.0
+        }, {
+            "StartTime": 4124.0,
+            "EndTime": 4124.0,
+            "X": 385.956238,
+            "Y": 192.0
+        }, {
+            "StartTime": 4249.0,
+            "EndTime": 4249.0,
+            "X": 395.9575,
+            "Y": 192.0
+        }, {
+            "StartTime": 4374.0,
+            "EndTime": 4374.0,
+            "X": 405.95874,
+            "Y": 192.0
+        }, {
+            "StartTime": 4499.0,
+            "EndTime": 4499.0,
+            "X": 415.960022,
+            "Y": 192.0
+        }, {
+            "StartTime": 4624.0,
+            "EndTime": 4624.0,
+            "X": 406.038757,
+            "Y": 192.0
+        }, {
+            "StartTime": 4749.0,
+            "EndTime": 4749.0,
+            "X": 396.0375,
+            "Y": 192.0
+        }, {
+            "StartTime": 4874.0,
+            "EndTime": 4874.0,
+            "X": 386.036255,
+            "Y": 192.0
+        }, {
+            "StartTime": 4999.0,
+            "EndTime": 4999.0,
+            "X": 376.035034,
+            "Y": 192.0
+        }, {
+            "StartTime": 5124.0,
+            "EndTime": 5124.0,
+            "X": 366.033752,
+            "Y": 192.0
+        }, {
+            "StartTime": 5249.0,
+            "EndTime": 5249.0,
+            "X": 356.0325,
+            "Y": 192.0
+        }, {
+            "StartTime": 5374.0,
+            "EndTime": 5374.0,
+            "X": 346.03125,
+            "Y": 192.0
+        }, {
+            "StartTime": 5499.0,
+            "EndTime": 5499.0,
+            "X": 336.030029,
+            "Y": 192.0
+        }, {
+            "StartTime": 5624.0,
+            "EndTime": 5624.0,
+            "X": 326.028748,
+            "Y": 192.0
+        }, {
+            "StartTime": 5749.0,
+            "EndTime": 5749.0,
+            "X": 316.0275,
+            "Y": 192.0
+        }, {
+            "StartTime": 5874.0,
+            "EndTime": 5874.0,
+            "X": 306.026245,
+            "Y": 192.0
+        }, {
+            "StartTime": 5999.0,
+            "EndTime": 5999.0,
+            "X": 296.025,
+            "Y": 192.0
+        }, {
+            "StartTime": 6124.0,
+            "EndTime": 6124.0,
+            "X": 286.023773,
+            "Y": 192.0
+        }, {
+            "StartTime": 6249.0,
+            "EndTime": 6249.0,
+            "X": 276.022522,
+            "Y": 192.0
+        }, {
+            "StartTime": 6374.0,
+            "EndTime": 6374.0,
+            "X": 266.02124,
+            "Y": 192.0
+        }, {
+            "StartTime": 6499.0,
+            "EndTime": 6499.0,
+            "X": 256.02,
+            "Y": 192.0
+        }, {
+            "StartTime": 6624.0,
+            "EndTime": 6624.0,
+            "X": 246.018768,
+            "Y": 192.0
+        }, {
+            "StartTime": 6749.0,
+            "EndTime": 6749.0,
+            "X": 236.017517,
+            "Y": 192.0
+        }, {
+            "StartTime": 6874.0,
+            "EndTime": 6874.0,
+            "X": 226.016251,
+            "Y": 192.0
+        }, {
+            "StartTime": 6999.0,
+            "EndTime": 6999.0,
+            "X": 216.014984,
+            "Y": 192.0
+        }, {
+            "StartTime": 7124.0,
+            "EndTime": 7124.0,
+            "X": 206.013733,
+            "Y": 192.0
+        }, {
+            "StartTime": 7249.0,
+            "EndTime": 7249.0,
+            "X": 196.012512,
+            "Y": 192.0
+        }, {
+            "StartTime": 7374.0,
+            "EndTime": 7374.0,
+            "X": 186.011261,
+            "Y": 192.0
+        }, {
+            "StartTime": 7499.0,
+            "EndTime": 7499.0,
+            "X": 176.01,
+            "Y": 192.0
+        }, {
+            "StartTime": 7624.0,
+            "EndTime": 7624.0,
+            "X": 166.008728,
+            "Y": 192.0
+        }, {
+            "StartTime": 7749.0,
+            "EndTime": 7749.0,
+            "X": 156.0075,
+            "Y": 192.0
+        }, {
+            "StartTime": 7874.0,
+            "EndTime": 7874.0,
+            "X": 146.006256,
+            "Y": 192.0
+        }, {
+            "StartTime": 7999.0,
+            "EndTime": 7999.0,
+            "X": 136.005,
+            "Y": 192.0
+        }, {
+            "StartTime": 8124.0,
+            "EndTime": 8124.0,
+            "X": 126.003738,
+            "Y": 192.0
+        }, {
+            "StartTime": 8249.0,
+            "EndTime": 8249.0,
+            "X": 116.002518,
+            "Y": 192.0
+        }, {
+            "StartTime": 8374.0,
+            "EndTime": 8374.0,
+            "X": 106.001259,
+            "Y": 192.0
+        }, {
+            "StartTime": 8463.0,
+            "EndTime": 8463.0,
+            "X": 96.0,
+            "Y": 192.0
+        }]
+    }]
+}

osu.Game.Rulesets.Osu/Resources/Testing/Beatmaps/slider-ticks.osu

@@ -0,0 +1,20 @@
+osu file format v14
+
+[General]
+StackLeniency: 0.7
+
+[Difficulty]
+HPDrainRate:6
+CircleSize:4
+OverallDifficulty:7
+ApproachRate:8.3
+SliderMultiplier:0.400000005960464
+SliderTickRate:4
+
+[TimingPoints]
+500,500,4,2,1,50,1,0
+13426,-100,4,3,1,45,0,0
+14884,-100,4,2,1,50,0,0
+
+[HitObjects]
+96,192,500,6,0,L|416:192,2,320.000004768372

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

@@ -11,7 +11,6 @@ using osu.Game.Rulesets.Osu.Objects.Drawables.Connections;
 using osu.Game.Rulesets.UI;
 using System.Linq;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Osu.Judgements;
 
 namespace osu.Game.Rulesets.Osu.UI
 {
@@ -75,7 +74,7 @@ namespace osu.Game.Rulesets.Osu.UI
             DrawableOsuJudgement explosion = new DrawableOsuJudgement(judgement, judgedObject)
             {
                 Origin = Anchor.Centre,
-                Position = ((OsuHitObject)judgedObject.HitObject).StackedEndPosition + ((OsuJudgement)judgement).PositionOffset
+                Position = ((OsuHitObject)judgedObject.HitObject).StackedEndPosition
             };
 
             judgementLayer.Add(explosion);

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

@@ -12,7 +12,8 @@ using osu.Game.Tests.Beatmaps;
 
 namespace osu.Game.Rulesets.Taiko.Tests
 {
-    internal class TaikoBeatmapConversionTest : BeatmapConversionTest<ConvertValue>
+    [TestFixture]
+    public class TaikoBeatmapConversionTest : BeatmapConversionTest<ConvertValue>
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Taiko";
 
@@ -41,7 +42,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
         protected override Ruleset CreateRuleset() => new TaikoRuleset();
     }
 
-    internal struct ConvertValue : IEquatable<ConvertValue>
+    public struct ConvertValue : IEquatable<ConvertValue>
     {
         /// <summary>
         /// A sane value to account for osu!stable using ints everwhere.

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

@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Taiko.UI
         private void loadBarLines()
         {
             TaikoHitObject lastObject = Beatmap.HitObjects[Beatmap.HitObjects.Count - 1];
-            double lastHitTime = 1 + (lastObject as IHasEndTime)?.EndTime ?? lastObject.StartTime;
+            double lastHitTime = 1 + ((lastObject as IHasEndTime)?.EndTime ?? lastObject.StartTime);
 
             var timingPoints = Beatmap.ControlPointInfo.TimingPoints.ToList();
 

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

@@ -11,6 +11,7 @@ using osu.Game.Audio;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.Beatmaps.Timing;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Skinning;
 
 namespace osu.Game.Tests.Beatmaps.Formats
@@ -211,5 +212,41 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 Assert.IsTrue(hitObjects[1].Samples.Any(s => s.Name == SampleInfo.HIT_CLAP));
             }
         }
+
+        [Test]
+        public void TestDecodeCustomSamples()
+        {
+            var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
+            using (var resStream = Resource.OpenResource("custom-samples.osu"))
+            using (var stream = new StreamReader(resStream))
+            {
+                var hitObjects = decoder.Decode(stream).HitObjects;
+
+                Assert.AreEqual("hitnormal", getTestableSampleInfo(hitObjects[0]).Name);
+                Assert.AreEqual("hitnormal", getTestableSampleInfo(hitObjects[1]).Name);
+                Assert.AreEqual("hitnormal2", getTestableSampleInfo(hitObjects[2]).Name);
+                Assert.AreEqual("hitnormal", getTestableSampleInfo(hitObjects[3]).Name);
+            }
+
+            SampleInfo getTestableSampleInfo(HitObject hitObject) => hitObject.SampleControlPoint.ApplyTo(new SampleInfo { Name = "hitnormal" });
+        }
+
+        [Test]
+        public void TestDecodeCustomHitObjectSamples()
+        {
+            var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
+            using (var resStream = Resource.OpenResource("custom-hitobject-samples.osu"))
+            using (var stream = new StreamReader(resStream))
+            {
+                var hitObjects = decoder.Decode(stream).HitObjects;
+
+                Assert.AreEqual("hit_1.wav", hitObjects[0].Samples[0].LookupNames.First());
+                Assert.AreEqual("hit_2.wav", hitObjects[1].Samples[0].LookupNames.First());
+                Assert.AreEqual("hitnormal2", getTestableSampleInfo(hitObjects[2]).Name);
+                Assert.AreEqual("hit_1.wav", hitObjects[3].Samples[0].LookupNames.First());
+            }
+
+            SampleInfo getTestableSampleInfo(HitObject hitObject) => hitObject.SampleControlPoint.ApplyTo(new SampleInfo { Name = "hitnormal" });
+        }
     }
 }

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

@@ -118,7 +118,11 @@ namespace osu.Game.Tests.Beatmaps.Formats
         public void TestParity(string beatmap)
         {
             var legacy = decode(beatmap, out Beatmap json);
-            json.WithDeepEqual(legacy).IgnoreProperty(r => r.DeclaringType == typeof(HitWindows)).Assert();
+            json.WithDeepEqual(legacy)
+                .IgnoreProperty(r => r.DeclaringType == typeof(HitWindows)
+                                     // Todo: CustomSampleBank shouldn't exist going forward, we need a conversion mechanism
+                                     || r.Name == nameof(LegacyDecoder<Beatmap>.LegacySampleControlPoint.CustomSampleBank))
+                .Assert();
         }
 
         /// <summary>

osu.Game.Tests/Resources/custom-hitobject-samples.osu

@@ -0,0 +1,16 @@
+osu file format v14
+
+[General]
+SampleSet: Normal
+
+[TimingPoints]
+2170,468.75,4,1,0,40,1,0
+2638,-100,4,1,1,40,0,0
+3107,-100,4,1,2,40,0,0
+3576,-100,4,1,0,40,0,0
+
+[HitObjects]
+255,193,2170,1,0,0:0:0:0:hit_1.wav
+256,191,2638,5,0,0:0:0:0:hit_2.wav
+255,193,3107,1,0,0:0:0:0:
+256,191,3576,1,0,0:0:0:0:hit_1.wav

osu.Game.Tests/Resources/custom-samples.osu

@@ -0,0 +1,16 @@
+osu file format v14
+
+[General]
+SampleSet: Normal
+
+[TimingPoints]
+2170,468.75,4,1,0,40,1,0
+2638,-100,4,1,1,40,0,0
+3107,-100,4,1,2,40,0,0
+3576,-100,4,1,0,40,0,0
+
+[HitObjects]
+255,193,2170,1,0,0:0:0:0:
+256,191,2638,5,0,0:0:0:0:
+255,193,3107,1,0,0:0:0:0:
+256,191,3576,1,0,0:0:0:0:

osu.Game.Tests/Visual/TestCaseBeatmapInfoWedge.cs

@@ -65,17 +65,19 @@ namespace osu.Game.Tests.Visual
 
             foreach (var rulesetInfo in rulesets.AvailableRulesets)
             {
-                var ruleset = rulesetInfo.CreateInstance();
+                var instance = rulesetInfo.CreateInstance();
                 var testBeatmap = createTestBeatmap(rulesetInfo);
 
                 beatmaps.Add(testBeatmap);
 
+                AddStep("set ruleset", () => Ruleset.Value = rulesetInfo);
+
                 selectBeatmap(testBeatmap);
 
-                testBeatmapLabels(ruleset);
+                testBeatmapLabels(instance);
 
                 // TODO: adjust cases once more info is shown for other gamemodes
-                switch (ruleset)
+                switch (instance)
                 {
                     case OsuRuleset _:
                         testInfoLabels(5);

osu.Game.Tests/Visual/TestCaseEditorSeekSnapping.cs

@@ -1,8 +1,7 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System;
-using System.Collections.Generic;
+using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
@@ -10,9 +9,6 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Rulesets;
-using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Tests.Beatmaps;
 using OpenTK;
@@ -20,10 +16,9 @@ using OpenTK.Graphics;
 
 namespace osu.Game.Tests.Visual
 {
+    [TestFixture]
     public class TestCaseEditorSeekSnapping : EditorClockTestCase
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(HitObjectComposer) };
-
         public TestCaseEditorSeekSnapping()
         {
             BeatDivisor.Value = 4;
@@ -56,22 +51,13 @@ namespace osu.Game.Tests.Visual
             Beatmap.Value = new TestWorkingBeatmap(testBeatmap);
 
             Child = new TimingPointVisualiser(testBeatmap, 5000) { Clock = Clock };
-
-            testSeekNoSnapping();
-            testSeekSnappingOnBeat();
-            testSeekSnappingInBetweenBeat();
-            testSeekForwardNoSnapping();
-            testSeekForwardSnappingOnBeat();
-            testSeekForwardSnappingFromInBetweenBeat();
-            testSeekBackwardSnappingOnBeat();
-            testSeekBackwardSnappingFromInBetweenBeat();
-            testSeekingWithFloatingPointBeatLength();
         }
 
         /// <summary>
         /// Tests whether time is correctly seeked without snapping.
         /// </summary>
-        private void testSeekNoSnapping()
+        [Test]
+        public void TestSeekNoSnapping()
         {
             reset();
 
@@ -94,7 +80,8 @@ namespace osu.Game.Tests.Visual
         /// Tests whether seeking to exact beat times puts us on the beat time.
         /// These are the white/yellow ticks on the graph.
         /// </summary>
-        private void testSeekSnappingOnBeat()
+        [Test]
+        public void TestSeekSnappingOnBeat()
         {
             reset();
 
@@ -117,9 +104,9 @@ namespace osu.Game.Tests.Visual
         /// <summary>
         /// Tests whether seeking to somewhere in the middle between beats puts us on the expected beats.
         /// For example, snapping between a white/yellow beat should put us on either the yellow or white, depending on which one we're closer too.
-        /// If
         /// </summary>
-        private void testSeekSnappingInBetweenBeat()
+        [Test]
+        public void TestSeekSnappingInBetweenBeat()
         {
             reset();
 
@@ -140,7 +127,8 @@ namespace osu.Game.Tests.Visual
         /// <summary>
         /// Tests that when seeking forward with no beat snapping, beats are never explicitly snapped to, nor the next timing point (if we've skipped it).
         /// </summary>
-        private void testSeekForwardNoSnapping()
+        [Test]
+        public void TestSeekForwardNoSnapping()
         {
             reset();
 
@@ -159,7 +147,8 @@ namespace osu.Game.Tests.Visual
         /// <summary>
         /// Tests that when seeking forward with beat snapping, all beats are snapped to and timing points are never skipped.
         /// </summary>
-        private void testSeekForwardSnappingOnBeat()
+        [Test]
+        public void TestSeekForwardSnappingOnBeat()
         {
             reset();
 
@@ -181,7 +170,8 @@ namespace osu.Game.Tests.Visual
         /// Tests that when seeking forward from in-between two beats, the next beat or timing point is snapped to, and no beats are skipped.
         /// This will also test being extremely close to the next beat/timing point, to ensure rounding is not an issue.
         /// </summary>
-        private void testSeekForwardSnappingFromInBetweenBeat()
+        [Test]
+        public void TestSeekForwardSnappingFromInBetweenBeat()
         {
             reset();
 
@@ -214,21 +204,20 @@ namespace osu.Game.Tests.Visual
         /// <summary>
         /// Tests that when seeking backward with no beat snapping, beats are never explicitly snapped to, nor the next timing point (if we've skipped it).
         /// </summary>
-        private void testSeekBackwardNoSnapping()
+        [Test]
+        public void TestSeekBackwardNoSnapping()
         {
             reset();
 
             AddStep("Seek(450)", () => Clock.Seek(450));
             AddStep("SeekBackward", () => Clock.SeekBackward());
-            AddAssert("Time = 425", () => Clock.CurrentTime == 425);
+            AddAssert("Time = 400", () => Clock.CurrentTime == 400);
             AddStep("SeekBackward", () => Clock.SeekBackward());
-            AddAssert("Time = 375", () => Clock.CurrentTime == 375);
+            AddAssert("Time = 350", () => Clock.CurrentTime == 350);
             AddStep("SeekBackward", () => Clock.SeekBackward());
-            AddAssert("Time = 325", () => Clock.CurrentTime == 325);
+            AddAssert("Time = 150", () => Clock.CurrentTime == 150);
             AddStep("SeekBackward", () => Clock.SeekBackward());
-            AddAssert("Time = 125", () => Clock.CurrentTime == 125);
-            AddStep("SeekBackward", () => Clock.SeekBackward());
-            AddAssert("Time = 25", () => Clock.CurrentTime == 25);
+            AddAssert("Time = 50", () => Clock.CurrentTime == 50);
             AddStep("SeekBackward", () => Clock.SeekBackward());
             AddAssert("Time = 0", () => Clock.CurrentTime == 0);
         }
@@ -236,7 +225,8 @@ namespace osu.Game.Tests.Visual
         /// <summary>
         /// Tests that when seeking backward with beat snapping, all beats are snapped to and timing points are never skipped.
         /// </summary>
-        private void testSeekBackwardSnappingOnBeat()
+        [Test]
+        public void TestSeekBackwardSnappingOnBeat()
         {
             reset();
 
@@ -259,7 +249,8 @@ namespace osu.Game.Tests.Visual
         /// Tests that when seeking backward from in-between two beats, the previous beat or timing point is snapped to, and no beats are skipped.
         /// This will also test being extremely close to the previous beat/timing point, to ensure rounding is not an issue.
         /// </summary>
-        private void testSeekBackwardSnappingFromInBetweenBeat()
+        [Test]
+        public void TestSeekBackwardSnappingFromInBetweenBeat()
         {
             reset();
 
@@ -280,7 +271,8 @@ namespace osu.Game.Tests.Visual
         /// <summary>
         /// Tests that there are no rounding issues when snapping to beats within a timing point with a floating-point beatlength.
         /// </summary>
-        private void testSeekingWithFloatingPointBeatLength()
+        [Test]
+        public void TestSeekingWithFloatingPointBeatLength()
         {
             reset();
 
@@ -288,7 +280,7 @@ namespace osu.Game.Tests.Visual
 
             AddStep("Seek(0)", () => Clock.Seek(0));
 
-            for (int i = 0; i < 20; i++)
+            for (int i = 0; i < 9; i++)
             {
                 AddStep("SeekForward, Snap", () =>
                 {
@@ -298,7 +290,7 @@ namespace osu.Game.Tests.Visual
                 AddAssert("Time > lastTime", () => Clock.CurrentTime > lastTime);
             }
 
-            for (int i = 0; i < 20; i++)
+            for (int i = 0; i < 9; i++)
             {
                 AddStep("SeekBackward, Snap", () =>
                 {
@@ -316,16 +308,6 @@ namespace osu.Game.Tests.Visual
             AddStep("Reset", () => Clock.Seek(0));
         }
 
-        private class TestHitObjectComposer : HitObjectComposer
-        {
-            public TestHitObjectComposer(Ruleset ruleset)
-                : base(ruleset)
-            {
-            }
-
-            protected override IReadOnlyList<ICompositionTool> CompositionTools => new ICompositionTool[0];
-        }
-
         private class TimingPointVisualiser : CompositeDrawable
         {
             private readonly double length;

osu.Game.Tests/Visual/TestCaseLeaderboard.cs

@@ -1,6 +1,8 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System;
+using System.Collections.Generic;
 using System.ComponentModel;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Scoring;
@@ -17,6 +19,12 @@ namespace osu.Game.Tests.Visual
     [Description("PlaySongSelect leaderboard")]
     public class TestCaseLeaderboard : OsuTestCase
     {
+        public override IReadOnlyList<Type> RequiredTypes => new[] {
+            typeof(Placeholder),
+            typeof(MessagePlaceholder),
+            typeof(RetrievalFailurePlaceholder),
+        };
+
         private RulesetStore rulesets;
 
         private readonly FailableLeaderboard leaderboard;

osu.Game.Tests/Visual/TestCaseLoadingAnimation.cs

@@ -0,0 +1,63 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Testing;
+using osu.Game.Graphics.UserInterface;
+using OpenTK.Graphics;
+
+namespace osu.Game.Tests.Visual
+{
+    public class TestCaseLoadingAnimation : GridTestCase
+    {
+        public TestCaseLoadingAnimation()
+            : base(2, 2)
+        {
+            LoadingAnimation loading;
+
+            Cell(0).AddRange(new Drawable[]
+            {
+                new Box
+                {
+                    Colour = Color4.Black,
+                    RelativeSizeAxes = Axes.Both
+                },
+                loading = new LoadingAnimation()
+            });
+
+            loading.Show();
+
+            Cell(1).AddRange(new Drawable[]
+            {
+                new Box
+                {
+                    Colour = Color4.White,
+                    RelativeSizeAxes = Axes.Both
+                },
+                loading = new LoadingAnimation()
+            });
+
+            loading.Show();
+
+            Cell(2).AddRange(new Drawable[]
+            {
+                new Box
+                {
+                    Colour = Color4.Gray,
+                    RelativeSizeAxes = Axes.Both
+                },
+                loading = new LoadingAnimation()
+            });
+
+            loading.Show();
+
+            Cell(3).AddRange(new Drawable[]
+            {
+                loading = new LoadingAnimation()
+            });
+
+            Scheduler.AddDelayed(() => loading.ToggleVisibility(), 200, true);
+        }
+    }
+}

osu.Game.Tests/Visual/TestCaseMods.cs

@@ -77,7 +77,7 @@ namespace osu.Game.Tests.Visual
             foreach (var rulesetInfo in rulesets.AvailableRulesets)
             {
                 Ruleset ruleset = rulesetInfo.CreateInstance();
-                AddStep($"switch to {ruleset.Description}", () => modSelect.Ruleset.Value = rulesetInfo);
+                AddStep($"switch to {ruleset.Description}", () => Ruleset.Value = rulesetInfo);
 
                 switch (ruleset)
                 {

osu.Game.Tests/Visual/TestCaseOnScreenDisplay.cs

@@ -88,7 +88,7 @@ namespace osu.Game.Tests.Visual
 
         private class TestOnScreenDisplay : OnScreenDisplay
         {
-            protected override void Display(Drawable toDisplay) => toDisplay.FadeIn().ResizeHeightTo(110);
+            protected override void DisplayTemporarily(Drawable toDisplay) => toDisplay.FadeIn().ResizeHeightTo(110);
         }
     }
 }

osu.Game.Tests/Visual/TestCaseUserProfile.cs

@@ -53,7 +53,6 @@ namespace osu.Game.Tests.Visual
                 CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c1.jpg",
                 JoinDate = DateTimeOffset.Now.AddDays(-1),
                 LastVisit = DateTimeOffset.Now,
-                Age = 1,
                 ProfileOrder = new[] { "me" },
                 Statistics = new UserStatistics
                 {

osu.Game/Audio/SampleInfo.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using System.Collections.Generic;
 
 namespace osu.Game.Audio
 {
@@ -32,5 +33,21 @@ namespace osu.Game.Audio
         /// The sample volume.
         /// </summary>
         public int Volume;
+
+        /// <summary>
+        /// Retrieve all possible filenames that can be used as a source, returned in order of preference (highest first).
+        /// </summary>
+        public virtual IEnumerable<string> LookupNames
+        {
+            get
+            {
+                if (!string.IsNullOrEmpty(Namespace))
+                    yield return $"{Namespace}/{Bank}-{Name}";
+
+                yield return $"{Bank}-{Name}"; // Without namespace as a fallback even when we have a namespace
+            }
+        }
+
+        public SampleInfo Clone() => (SampleInfo)MemberwiseClone();
     }
 }

osu.Game/Beatmaps/BeatmapInfo.cs

@@ -66,8 +66,8 @@ namespace osu.Game.Beatmaps
 
         // General
         public int AudioLeadIn { get; set; }
-        public bool Countdown { get; set; }
-        public float StackLeniency { get; set; }
+        public bool Countdown { get; set; } = true;
+        public float StackLeniency { get; set; } = 0.7f;
         public bool SpecialStyle { get; set; }
 
         public int RulesetID { get; set; }

osu.Game/Beatmaps/BeatmapManager.cs

@@ -138,7 +138,7 @@ namespace osu.Game.Beatmaps
                 PostNotification?.Invoke(new SimpleNotification
                 {
                     Icon = FontAwesome.fa_superpowers,
-                    Text = "You gotta be a supporter to download for now 'yo"
+                    Text = "You gotta be an osu!supporter to download for now 'yo"
                 });
                 return;
             }

osu.Game/Beatmaps/BeatmapManager_WorkingBeatmap.cs

@@ -69,11 +69,22 @@ namespace osu.Game.Beatmaps
                 }
                 catch
                 {
-                    return new TrackVirtual();
+                    return null;
                 }
             }
 
-            protected override Waveform GetWaveform() => new Waveform(store.GetStream(getPathForFile(Metadata.AudioFile)));
+            protected override Waveform GetWaveform()
+            {
+                try
+                {
+                    var trackData = store.GetStream(getPathForFile(Metadata.AudioFile));
+                    return trackData == null ? null : new Waveform(trackData);
+                }
+                catch
+                {
+                    return null;
+                }
+            }
 
             protected override Storyboard GetStoryboard()
             {

osu.Game/Beatmaps/BeatmapProcessor.cs

@@ -6,23 +6,9 @@ using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Beatmaps
 {
-    public interface IBeatmapProcessor
-    {
-        IBeatmap Beatmap { get; }
-
-        /// <summary>
-        /// Post-processes <see cref="Beatmap"/> to add mode-specific components that aren't added during conversion.
-        /// <para>
-        /// An example of such a usage is for combo colours.
-        /// </para>
-        /// </summary>
-        void PostProcess();
-    }
-
     /// <summary>
-    /// Processes a post-converted Beatmap.
+    /// Provides functionality to alter a <see cref="IBeatmap"/> after it has been converted.
     /// </summary>
-    /// <typeparam name="TObject">The type of HitObject contained in the Beatmap.</typeparam>
     public class BeatmapProcessor : IBeatmapProcessor
     {
         public IBeatmap Beatmap { get; }
@@ -32,13 +18,7 @@ namespace osu.Game.Beatmaps
             Beatmap = beatmap;
         }
 
-        /// <summary>
-        /// Post-processes a Beatmap to add mode-specific components that aren't added during conversion.
-        /// <para>
-        /// An example of such a usage is for combo colours.
-        /// </para>
-        /// </summary>
-        public virtual void PostProcess()
+        public virtual void PreProcess()
         {
             IHasComboInformation lastObj = null;
 
@@ -62,5 +42,9 @@ namespace osu.Game.Beatmaps
                 lastObj = obj;
             }
         }
+
+        public virtual void PostProcess()
+        {
+        }
     }
 }

osu.Game/Beatmaps/BeatmapSetInfo.cs

@@ -13,7 +13,13 @@ namespace osu.Game.Beatmaps
         [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
         public int ID { get; set; }
 
-        public int? OnlineBeatmapSetID { get; set; }
+        private int? onlineBeatmapSetID;
+
+        public int? OnlineBeatmapSetID
+        {
+            get { return onlineBeatmapSetID; }
+            set { onlineBeatmapSetID = value > 0 ? value : null; }
+        }
 
         public BeatmapMetadata Metadata { get; set; }
 

osu.Game/Beatmaps/ControlPoints/ControlPoint.cs

@@ -14,6 +14,15 @@ namespace osu.Game.Beatmaps.ControlPoints
 
         public int CompareTo(ControlPoint other) => Time.CompareTo(other.Time);
 
-        public bool Equals(ControlPoint other) => Time.Equals(other?.Time);
+        /// <summary>
+        /// Whether this <see cref="ControlPoint"/> provides the same parametric changes as another <see cref="ControlPoint"/>.
+        /// Basically an equality check without considering the <see cref="Time"/>.
+        /// </summary>
+        /// <param name="other">The <see cref="ControlPoint"/> to compare to.</param>
+        /// <returns>Whether this <see cref="ControlPoint"/> is equivalent to <paramref name="other"/>.</returns>
+        public virtual bool EquivalentTo(ControlPoint other) => true;
+
+        public bool Equals(ControlPoint other)
+            => EquivalentTo(other) && Time.Equals(other?.Time);
     }
 }

osu.Game/Beatmaps/ControlPoints/DifficultyControlPoint.cs

@@ -17,5 +17,10 @@ namespace osu.Game.Beatmaps.ControlPoints
         }
 
         private double speedMultiplier = 1;
+
+        public override bool EquivalentTo(ControlPoint other)
+            => base.EquivalentTo(other)
+               && other is DifficultyControlPoint difficulty
+               && SpeedMultiplier.Equals(difficulty.SpeedMultiplier);
     }
 }

osu.Game/Beatmaps/ControlPoints/EffectControlPoint.cs

@@ -14,5 +14,11 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// Whether the first bar line of this control point is ignored.
         /// </summary>
         public bool OmitFirstBarLine;
+
+        public override bool EquivalentTo(ControlPoint other)
+            => base.EquivalentTo(other)
+               && other is EffectControlPoint effect
+               && KiaiMode.Equals(effect.KiaiMode)
+               && OmitFirstBarLine.Equals(effect.OmitFirstBarLine);
     }
 }

osu.Game/Beatmaps/ControlPoints/SampleControlPoint.cs

@@ -30,5 +30,25 @@ namespace osu.Game.Beatmaps.ControlPoints
             Name = sampleName,
             Volume = SampleVolume,
         };
+
+        /// <summary>
+        /// Applies <see cref="SampleBank"/> and <see cref="SampleVolume"/> to a <see cref="SampleInfo"/> if necessary, returning the modified <see cref="SampleInfo"/>.
+        /// </summary>
+        /// <param name="sampleInfo">The <see cref="SampleInfo"/>. This will not be modified.</param>
+        /// <returns>The modified <see cref="SampleInfo"/>. This does not share a reference with <paramref name="sampleInfo"/>.</returns>
+        public virtual SampleInfo ApplyTo(SampleInfo sampleInfo)
+        {
+            var newSampleInfo = sampleInfo.Clone();
+            newSampleInfo.Bank = sampleInfo.Bank ?? SampleBank;
+            newSampleInfo.Name = sampleInfo.Name;
+            newSampleInfo.Volume = sampleInfo.Volume > 0 ? sampleInfo.Volume : SampleVolume;
+            return newSampleInfo;
+        }
+
+        public override bool EquivalentTo(ControlPoint other)
+            => base.EquivalentTo(other)
+               && other is SampleControlPoint sample
+               && SampleBank.Equals(sample.SampleBank)
+               && SampleVolume.Equals(sample.SampleVolume);
     }
 }

osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs

@@ -23,5 +23,11 @@ namespace osu.Game.Beatmaps.ControlPoints
         }
 
         private double beatLength = 1000;
+
+        public override bool EquivalentTo(ControlPoint other)
+            => base.EquivalentTo(other)
+               && other is TimingControlPoint timing
+               && TimeSignature.Equals(timing.TimeSignature)
+               && BeatLength.Equals(timing.BeatLength);
     }
 }

osu.Game/Beatmaps/DummyWorkingBeatmap.cs

@@ -45,7 +45,7 @@ namespace osu.Game.Beatmaps
 
         protected override Texture GetBackground() => game?.Textures.Get(@"Backgrounds/bg4");
 
-        protected override Track GetTrack() => new TrackVirtual();
+        protected override Track GetTrack() => new TrackVirtual { Length = 1000 };
 
         private class DummyRulesetInfo : RulesetInfo
         {

osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs

@@ -289,9 +289,9 @@ namespace osu.Game.Beatmaps.Formats
                 if (split.Length >= 4)
                     sampleSet = (LegacySampleBank)int.Parse(split[3]);
 
-                //SampleBank sampleBank = SampleBank.Default;
-                //if (split.Length >= 5)
-                //    sampleBank = (SampleBank)int.Parse(split[4]);
+                int customSampleBank = 0;
+                if (split.Length >= 5)
+                    customSampleBank = int.Parse(split[4]);
 
                 int sampleVolume = defaultSampleVolume;
                 if (split.Length >= 6)
@@ -314,13 +314,9 @@ namespace osu.Game.Beatmaps.Formats
                 if (stringSampleSet == @"none")
                     stringSampleSet = @"normal";
 
-                DifficultyControlPoint difficultyPoint = beatmap.ControlPointInfo.DifficultyPointAt(time);
-                SampleControlPoint samplePoint = beatmap.ControlPointInfo.SamplePointAt(time);
-                EffectControlPoint effectPoint = beatmap.ControlPointInfo.EffectPointAt(time);
-
                 if (timingChange)
                 {
-                    beatmap.ControlPointInfo.TimingPoints.Add(new TimingControlPoint
+                    handleTimingControlPoint(new TimingControlPoint
                     {
                         Time = time,
                         BeatLength = beatLength,
@@ -328,41 +324,68 @@ namespace osu.Game.Beatmaps.Formats
                     });
                 }
 
-                if (speedMultiplier != difficultyPoint.SpeedMultiplier)
+                handleDifficultyControlPoint(new DifficultyControlPoint
                 {
-                    beatmap.ControlPointInfo.DifficultyPoints.RemoveAll(x => x.Time == time);
-                    beatmap.ControlPointInfo.DifficultyPoints.Add(new DifficultyControlPoint
-                    {
-                        Time = time,
-                        SpeedMultiplier = speedMultiplier
-                    });
-                }
+                    Time = time,
+                    SpeedMultiplier = speedMultiplier
+                });
 
-                if (stringSampleSet != samplePoint.SampleBank || sampleVolume != samplePoint.SampleVolume)
+                handleEffectControlPoint(new EffectControlPoint
                 {
-                    beatmap.ControlPointInfo.SamplePoints.Add(new SampleControlPoint
-                    {
-                        Time = time,
-                        SampleBank = stringSampleSet,
-                        SampleVolume = sampleVolume
-                    });
-                }
+                    Time = time,
+                    KiaiMode = kiaiMode,
+                    OmitFirstBarLine = omitFirstBarSignature
+                });
 
-                if (kiaiMode != effectPoint.KiaiMode || omitFirstBarSignature != effectPoint.OmitFirstBarLine)
+                handleSampleControlPoint(new LegacySampleControlPoint
                 {
-                    beatmap.ControlPointInfo.EffectPoints.Add(new EffectControlPoint
-                    {
-                        Time = time,
-                        KiaiMode = kiaiMode,
-                        OmitFirstBarLine = omitFirstBarSignature
-                    });
-                }
+                    Time = time,
+                    SampleBank = stringSampleSet,
+                    SampleVolume = sampleVolume,
+                    CustomSampleBank = customSampleBank
+                });
             }
             catch (FormatException e)
             {
             }
         }
 
+        private void handleTimingControlPoint(TimingControlPoint newPoint)
+        {
+            beatmap.ControlPointInfo.TimingPoints.Add(newPoint);
+        }
+
+        private void handleDifficultyControlPoint(DifficultyControlPoint newPoint)
+        {
+            var existing = beatmap.ControlPointInfo.DifficultyPointAt(newPoint.Time);
+
+            if (newPoint.EquivalentTo(existing))
+                return;
+
+            beatmap.ControlPointInfo.DifficultyPoints.RemoveAll(x => x.Time == newPoint.Time);
+            beatmap.ControlPointInfo.DifficultyPoints.Add(newPoint);
+        }
+
+        private void handleEffectControlPoint(EffectControlPoint newPoint)
+        {
+            var existing = beatmap.ControlPointInfo.EffectPointAt(newPoint.Time);
+
+            if (newPoint.EquivalentTo(existing))
+                return;
+
+            beatmap.ControlPointInfo.EffectPoints.Add(newPoint);
+        }
+
+        private void handleSampleControlPoint(SampleControlPoint newPoint)
+        {
+            var existing = beatmap.ControlPointInfo.SamplePointAt(newPoint.Time);
+
+            if (newPoint.EquivalentTo(existing))
+                return;
+
+            beatmap.ControlPointInfo.SamplePoints.Add(newPoint);
+        }
+
         private void handleHitObject(string line)
         {
             // If the ruleset wasn't specified, assume the osu!standard ruleset.

osu.Game/Beatmaps/Formats/LegacyDecoder.cs

@@ -5,6 +5,8 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using osu.Framework.Logging;
+using osu.Game.Audio;
+using osu.Game.Beatmaps.ControlPoints;
 using OpenTK.Graphics;
 
 namespace osu.Game.Beatmaps.Formats
@@ -167,5 +169,25 @@ namespace osu.Game.Beatmaps.Formats
             Pass = 2,
             Foreground = 3
         }
+
+        internal class LegacySampleControlPoint : SampleControlPoint
+        {
+            public int CustomSampleBank;
+
+            public override SampleInfo ApplyTo(SampleInfo sampleInfo)
+            {
+                var baseInfo = base.ApplyTo(sampleInfo);
+
+                if (CustomSampleBank > 1)
+                    baseInfo.Name += CustomSampleBank;
+
+                return baseInfo;
+            }
+
+            public override bool EquivalentTo(ControlPoint other)
+                => base.EquivalentTo(other)
+                   && other is LegacySampleControlPoint legacy
+                   && CustomSampleBank == legacy.CustomSampleBank;
+        }
     }
 }

osu.Game/Beatmaps/IBeatmapConverter.cs

@@ -7,6 +7,9 @@ using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Beatmaps
 {
+    /// <summary>
+    /// Provides functionality to convert a <see cref="IBeatmap"/> for a <see cref="Ruleset"/>.
+    /// </summary>
     public interface IBeatmapConverter
     {
         /// <summary>

osu.Game/Beatmaps/IBeatmapProcessor.cs

@@ -0,0 +1,40 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Beatmaps
+{
+    /// <summary>
+    /// Provides functionality to alter a <see cref="IBeatmap"/> after it has been converted.
+    /// </summary>
+    public interface IBeatmapProcessor
+    {
+        /// <summary>
+        /// The <see cref="IBeatmap"/> to process. This should already be converted to the applicable <see cref="Ruleset"/>.
+        /// </summary>
+        IBeatmap Beatmap { get; }
+
+        /// <summary>
+        /// Processes the converted <see cref="Beatmap"/> prior to <see cref="HitObject.ApplyDefaults"/> being invoked.
+        /// <para>
+        /// Nested <see cref="HitObject"/>s generated during <see cref="HitObject.ApplyDefaults"/> will not be present by this point,
+        /// and no mods will have been applied to the <see cref="HitObject"/>s.
+        /// </para>
+        /// </summary>
+        /// <remarks>
+        /// This can only be used to add alterations to <see cref="HitObject"/>s generated directly through the conversion process.
+        /// </remarks>
+        void PreProcess();
+
+        /// <summary>
+        /// Processes the converted <see cref="Beatmap"/> after <see cref="HitObject.ApplyDefaults"/> has been invoked.
+        /// <para>
+        /// Nested <see cref="HitObject"/>s generated during <see cref="HitObject.ApplyDefaults"/> will be present by this point,
+        /// and mods will have been applied to all <see cref="HitObject"/>s.
+        /// </para>
+        /// </summary>
+        /// <remarks>
+        /// This should be used to add alterations to <see cref="HitObject"/>s while they are in their most playable state.
+        /// </remarks>
+        void PostProcess();
+    }
+}

osu.Game/Beatmaps/WorkingBeatmap.cs

@@ -19,7 +19,7 @@ using osu.Game.Skinning;
 
 namespace osu.Game.Beatmaps
 {
-    public abstract class WorkingBeatmap : IDisposable
+    public abstract partial class WorkingBeatmap : IDisposable
     {
         public readonly BeatmapInfo BeatmapInfo;
 
@@ -116,6 +116,10 @@ namespace osu.Game.Beatmaps
                     mod.ApplyToDifficulty(converted.BeatmapInfo.BaseDifficulty);
             }
 
+            IBeatmapProcessor processor = rulesetInstance.CreateBeatmapProcessor(converted);
+
+            processor?.PreProcess();
+
             // Compute default values for hitobjects, including creating nested hitobjects in-case they're needed
             foreach (var obj in converted.HitObjects)
                 obj.ApplyDefaults(converted.ControlPointInfo, converted.BeatmapInfo.BaseDifficulty);
@@ -124,8 +128,7 @@ namespace osu.Game.Beatmaps
             foreach (var obj in converted.HitObjects)
                 mod.ApplyToHitObject(obj);
 
-            // Post-process
-            rulesetInstance.CreateBeatmapProcessor(converted)?.PostProcess();
+            processor?.PostProcess();
 
             return converted;
         }
@@ -145,7 +148,7 @@ namespace osu.Game.Beatmaps
         private Track populateTrack()
         {
             // we want to ensure that we always have a track, even if it's a fake one.
-            var t = GetTrack() ?? new TrackVirtual();
+            var t = GetTrack() ?? new VirtualBeatmapTrack(Beatmap);
             applyRateAdjustments(t);
             return t;
         }

osu.Game/Beatmaps/WorkingBeatmap_VirtualBeatmapTrack.cs

@@ -0,0 +1,38 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Linq;
+using osu.Framework.Audio.Track;
+using osu.Game.Rulesets.Objects.Types;
+
+namespace osu.Game.Beatmaps
+{
+    public partial class WorkingBeatmap
+    {
+        /// <summary>
+        /// A type of <see cref="TrackVirtual"/> which provides a valid length based on the <see cref="HitObject"/>s of an <see cref="IBeatmap"/>.
+        /// </summary>
+        protected class VirtualBeatmapTrack : TrackVirtual
+        {
+            private const double excess_length = 1000;
+
+            public VirtualBeatmapTrack(IBeatmap beatmap)
+            {
+                var lastObject = beatmap.HitObjects.LastOrDefault();
+
+                switch (lastObject)
+                {
+                    case null:
+                        Length = excess_length;
+                        break;
+                    case IHasEndTime endTime:
+                        Length = endTime.EndTime + excess_length;
+                        break;
+                    default:
+                        Length = lastObject.StartTime + excess_length;
+                        break;
+                }
+            }
+        }
+    }
+}

osu.Game/Graphics/Containers/OsuFocusedOverlayContainer.cs

@@ -8,16 +8,20 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Input;
 using OpenTK;
 using osu.Framework.Configuration;
+using osu.Framework.Input.Bindings;
 using osu.Game.Audio;
+using osu.Game.Input.Bindings;
 using osu.Game.Overlays;
 
 namespace osu.Game.Graphics.Containers
 {
-    public class OsuFocusedOverlayContainer : FocusedOverlayContainer, IPreviewTrackOwner
+    public class OsuFocusedOverlayContainer : FocusedOverlayContainer, IPreviewTrackOwner, IKeyBindingHandler<GlobalAction>
     {
         private SampleChannel samplePopIn;
         private SampleChannel samplePopOut;
 
+        protected virtual bool PlaySamplesOnStateChange => true;
+
         private PreviewTrackManager previewTrackManager;
 
         protected readonly Bindable<OverlayActivation> OverlayActivationMode = new Bindable<OverlayActivation>(OverlayActivation.All);
@@ -63,18 +67,33 @@ namespace osu.Game.Graphics.Containers
             return base.OnClick(state);
         }
 
+        public virtual bool OnPressed(GlobalAction action)
+        {
+            if (action == GlobalAction.Back)
+            {
+                State = Visibility.Hidden;
+                return true;
+            }
+
+            return false;
+        }
+
+        public bool OnReleased(GlobalAction action) => false;
+
         private void onStateChanged(Visibility visibility)
         {
             switch (visibility)
             {
                 case Visibility.Visible:
                     if (OverlayActivationMode != OverlayActivation.Disabled)
-                        samplePopIn?.Play();
+                    {
+                        if (PlaySamplesOnStateChange) samplePopIn?.Play();
+                    }
                     else
                         State = Visibility.Hidden;
                     break;
                 case Visibility.Hidden:
-                    samplePopOut?.Play();
+                    if (PlaySamplesOnStateChange) samplePopOut?.Play();
                     break;
             }
         }

osu.Game/Graphics/Containers/OsuTextFlowContainer.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics.Sprites;
@@ -16,6 +17,8 @@ namespace osu.Game.Graphics.Containers
 
         protected override SpriteText CreateSpriteText() => new OsuSpriteText();
 
+        public void AddArbitraryDrawable(Drawable drawable) => AddInternal(drawable);
+
         public void AddIcon(FontAwesome icon, Action<SpriteText> creationParameters = null) => AddText(((char)icon).ToString(), creationParameters);
     }
 }

osu.Game/Graphics/Cursor/MenuCursor.cs

@@ -11,9 +11,9 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input;
 using osu.Game.Configuration;
 using System;
-using System.Diagnostics;
 using JetBrains.Annotations;
 using osu.Framework.Graphics.Textures;
+using OpenTK.Input;
 
 namespace osu.Game.Graphics.Cursor
 {
@@ -22,12 +22,13 @@ namespace osu.Game.Graphics.Cursor
         private readonly IBindable<bool> screenshotCursorVisibility = new Bindable<bool>(true);
         public override bool IsPresent => screenshotCursorVisibility.Value && base.IsPresent;
 
-        protected override Drawable CreateCursor() => new Cursor();
+        protected override Drawable CreateCursor() => activeCursor = new Cursor();
+
+        private Cursor activeCursor;
 
         private Bindable<bool> cursorRotate;
-        private bool dragging;
-
-        private bool startRotation;
+        private DragRotationState dragRotationState;
+        private Vector2 positionMouseDown;
 
         [BackgroundDependencyLoader(true)]
         private void load([NotNull] OsuConfigManager config, [CanBeNull] ScreenshotManager screenshotManager)
@@ -40,46 +41,50 @@ namespace osu.Game.Graphics.Cursor
 
         protected override bool OnMouseMove(InputState state)
         {
-            if (cursorRotate && dragging)
+            if (dragRotationState != DragRotationState.NotDragging)
             {
-                Debug.Assert(state.Mouse.PositionMouseDown != null);
-
+                var position = state.Mouse.Position;
+                var distance = Vector2Extensions.Distance(position, positionMouseDown);
                 // don't start rotating until we're moved a minimum distance away from the mouse down location,
                 // else it can have an annoying effect.
-                // ReSharper disable once PossibleInvalidOperationException
-                startRotation |= Vector2Extensions.Distance(state.Mouse.Position, state.Mouse.PositionMouseDown.Value) > 30;
-
-                if (startRotation)
+                if (dragRotationState == DragRotationState.DragStarted && distance > 30)
+                    dragRotationState = DragRotationState.Rotating;
+                // don't rotate when distance is zero to avoid NaN
+                if (dragRotationState == DragRotationState.Rotating && distance > 0)
                 {
-                    Vector2 offset = state.Mouse.Position - state.Mouse.PositionMouseDown.Value;
+                    Vector2 offset = state.Mouse.Position - positionMouseDown;
                     float degrees = (float)MathHelper.RadiansToDegrees(Math.Atan2(-offset.X, offset.Y)) + 24.3f;
 
                     // Always rotate in the direction of least distance
-                    float diff = (degrees - ActiveCursor.Rotation) % 360;
+                    float diff = (degrees - activeCursor.Rotation) % 360;
                     if (diff < -180) diff += 360;
                     if (diff > 180) diff -= 360;
-                    degrees = ActiveCursor.Rotation + diff;
+                    degrees = activeCursor.Rotation + diff;
 
-                    ActiveCursor.RotateTo(degrees, 600, Easing.OutQuint);
+                    activeCursor.RotateTo(degrees, 600, Easing.OutQuint);
                 }
             }
 
             return base.OnMouseMove(state);
         }
 
-        protected override bool OnDragStart(InputState state)
-        {
-            dragging = true;
-            return base.OnDragStart(state);
-        }
-
         protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
         {
-            ActiveCursor.Scale = new Vector2(1);
-            ActiveCursor.ScaleTo(0.90f, 800, Easing.OutQuint);
+            // only trigger animation for main mouse buttons
+            if (args.Button <= MouseButton.Right)
+            {
+                activeCursor.Scale = new Vector2(1);
+                activeCursor.ScaleTo(0.90f, 800, Easing.OutQuint);
 
-            ((Cursor)ActiveCursor).AdditiveLayer.Alpha = 0;
-            ((Cursor)ActiveCursor).AdditiveLayer.FadeInFromZero(800, Easing.OutQuint);
+                activeCursor.AdditiveLayer.Alpha = 0;
+                activeCursor.AdditiveLayer.FadeInFromZero(800, Easing.OutQuint);
+            }
+
+            if (args.Button == MouseButton.Left && cursorRotate)
+            {
+                dragRotationState = DragRotationState.DragStarted;
+                positionMouseDown = state.Mouse.Position;
+            }
             return base.OnMouseDown(state, args);
         }
 
@@ -87,34 +92,29 @@ namespace osu.Game.Graphics.Cursor
         {
             if (!state.Mouse.HasMainButtonPressed)
             {
-                dragging = false;
-                startRotation = false;
-
-                ((Cursor)ActiveCursor).AdditiveLayer.FadeOut(500, Easing.OutQuint);
-                ActiveCursor.RotateTo(0, 600 * (1 + Math.Abs(ActiveCursor.Rotation / 720)), Easing.OutElasticHalf);
-                ActiveCursor.ScaleTo(1, 500, Easing.OutElastic);
+                activeCursor.AdditiveLayer.FadeOutFromOne(500, Easing.OutQuint);
+                activeCursor.ScaleTo(1, 500, Easing.OutElastic);
             }
 
+            if (args.Button == MouseButton.Left)
+            {
+                if (dragRotationState == DragRotationState.Rotating)
+                    activeCursor.RotateTo(0, 600 * (1 + Math.Abs(activeCursor.Rotation / 720)), Easing.OutElasticHalf);
+                dragRotationState = DragRotationState.NotDragging;
+            }
             return base.OnMouseUp(state, args);
         }
 
-        protected override bool OnClick(InputState state)
-        {
-            ((Cursor)ActiveCursor).AdditiveLayer.FadeOutFromOne(500, Easing.OutQuint);
-
-            return base.OnClick(state);
-        }
-
         protected override void PopIn()
         {
-            ActiveCursor.FadeTo(1, 250, Easing.OutQuint);
-            ActiveCursor.ScaleTo(1, 400, Easing.OutQuint);
+            activeCursor.FadeTo(1, 250, Easing.OutQuint);
+            activeCursor.ScaleTo(1, 400, Easing.OutQuint);
         }
 
         protected override void PopOut()
         {
-            ActiveCursor.FadeTo(0, 250, Easing.OutQuint);
-            ActiveCursor.ScaleTo(0.6f, 250, Easing.In);
+            activeCursor.FadeTo(0, 250, Easing.OutQuint);
+            activeCursor.ScaleTo(0.6f, 250, Easing.In);
         }
 
         public class Cursor : Container
@@ -160,5 +160,12 @@ namespace osu.Game.Graphics.Cursor
                 cursorScale.TriggerChange();
             }
         }
+
+        private enum DragRotationState
+        {
+            NotDragging,
+            DragStarted,
+            Rotating,
+        }
     }
 }

osu.Game/Graphics/DrawableDate.cs

@@ -12,14 +12,14 @@ namespace osu.Game.Graphics
 {
     public class DrawableDate : OsuSpriteText, IHasTooltip
     {
-        private readonly DateTimeOffset date;
+        protected readonly DateTimeOffset Date;
 
         public DrawableDate(DateTimeOffset date)
         {
             AutoSizeAxes = Axes.Both;
             Font = "Exo2.0-RegularItalic";
 
-            this.date = date.ToLocalTime();
+            Date = date.ToLocalTime();
         }
 
         [BackgroundDependencyLoader]
@@ -38,7 +38,7 @@ namespace osu.Game.Graphics
         {
             updateTime();
 
-            var diffToNow = DateTimeOffset.Now.Subtract(date);
+            var diffToNow = DateTimeOffset.Now.Subtract(Date);
 
             double timeUntilNextUpdate = 1000;
             if (diffToNow.TotalSeconds > 60)
@@ -58,8 +58,10 @@ namespace osu.Game.Graphics
 
         public override bool HandleMouseInput => true;
 
-        private void updateTime() => Text = date.Humanize();
+        protected virtual string Format() => Date.Humanize();
 
-        public string TooltipText => date.ToString();
+        private void updateTime() => Text = Format();
+
+        public virtual string TooltipText => string.Format($"{Date:MMMM d, yyyy h:mm tt \"UTC\"z}");
     }
 }

osu.Game/Graphics/UserInterface/FocusedTextBox.cs

@@ -2,9 +2,10 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using OpenTK.Graphics;
-using OpenTK.Input;
 using osu.Framework.Input;
 using System;
+using osu.Game.Input.Bindings;
+using OpenTK.Input;
 
 namespace osu.Game.Graphics.UserInterface
 {
@@ -19,6 +20,7 @@ namespace osu.Game.Graphics.UserInterface
         public Action Exit;
 
         private bool focus;
+
         public bool HoldFocus
         {
             get { return focus; }
@@ -26,7 +28,7 @@ namespace osu.Game.Graphics.UserInterface
             {
                 focus = value;
                 if (!focus && HasFocus)
-                    GetContainingInputManager().ChangeFocus(null);
+                    base.KillFocus();
             }
         }
 
@@ -41,18 +43,34 @@ namespace osu.Game.Graphics.UserInterface
 
         protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
         {
-            if (!args.Repeat && args.Key == Key.Escape)
-            {
-                if (Text.Length > 0)
-                    Text = string.Empty;
-                else
-                    Exit?.Invoke();
-                return true;
-            }
+            if (!HasFocus) return false;
+
+            if (args.Key == Key.Escape)
+                return false; // disable the framework-level handling of escape key for confority (we use GlobalAction.Back).
 
             return base.OnKeyDown(state, args);
         }
 
+        public override bool OnPressed(GlobalAction action)
+        {
+            if (action == GlobalAction.Back)
+            {
+                if (Text.Length > 0)
+                {
+                    Text = string.Empty;
+                    return true;
+                }
+            }
+
+            return base.OnPressed(action);
+        }
+
+        protected override void KillFocus()
+        {
+            base.KillFocus();
+            Exit?.Invoke();
+        }
+
         public override bool RequestsFocus => HoldFocus;
     }
 }

osu.Game/Graphics/UserInterface/LoadingAnimation.cs

@@ -4,12 +4,17 @@
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using OpenTK;
+using OpenTK.Graphics;
 
 namespace osu.Game.Graphics.UserInterface
 {
     public class LoadingAnimation : VisibilityContainer
     {
         private readonly SpriteIcon spinner;
+        private readonly SpriteIcon spinnerShadow;
+
+        private const float spin_duration = 600;
+        private const float transition_duration = 200;
 
         public LoadingAnimation()
         {
@@ -20,12 +25,22 @@ namespace osu.Game.Graphics.UserInterface
 
             Children = new Drawable[]
             {
-                spinner = new SpriteIcon
+                spinnerShadow = new SpriteIcon
                 {
-                    Size = new Vector2(20),
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Icon = FontAwesome.fa_spinner
+                    RelativeSizeAxes = Axes.Both,
+                    Position = new Vector2(1, 1),
+                    Colour = Color4.Black,
+                    Alpha = 0.4f,
+                    Icon = FontAwesome.fa_circle_o_notch
+                },
+                spinner = new SpriteIcon
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Icon = FontAwesome.fa_circle_o_notch
                 }
             };
         }
@@ -34,12 +49,11 @@ namespace osu.Game.Graphics.UserInterface
         {
             base.LoadComplete();
 
-            spinner.Spin(2000, RotationDirection.Clockwise);
+            spinner.Spin(spin_duration, RotationDirection.Clockwise);
+            spinnerShadow.Spin(spin_duration, RotationDirection.Clockwise);
         }
 
-        private const float transition_duration = 500;
-
-        protected override void PopIn() => this.FadeIn(transition_duration * 5, Easing.OutQuint);
+        protected override void PopIn() => this.FadeIn(transition_duration * 2, Easing.OutQuint);
 
         protected override void PopOut() => this.FadeOut(transition_duration, Easing.OutQuint);
     }

osu.Game/Graphics/UserInterface/OsuPasswordTextBox.cs

@@ -18,7 +18,7 @@ namespace osu.Game.Graphics.UserInterface
     {
         protected override Drawable GetDrawableCharacter(char c) => new PasswordMaskChar(CalculatedTextSize);
 
-        public override bool AllowClipboardExport => false;
+        protected override bool AllowClipboardExport => false;
 
         private readonly CapsWarning warning;
 

osu.Game/Graphics/UserInterface/OsuTextBox.cs

@@ -9,10 +9,12 @@ using osu.Framework.Input;
 using osu.Game.Graphics.Sprites;
 using OpenTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Input.Bindings;
+using osu.Game.Input.Bindings;
 
 namespace osu.Game.Graphics.UserInterface
 {
-    public class OsuTextBox : TextBox
+    public class OsuTextBox : TextBox, IKeyBindingHandler<GlobalAction>
     {
         protected override Color4 BackgroundUnfocused => Color4.Black.Opacity(0.5f);
         protected override Color4 BackgroundFocused => OsuColour.Gray(0.3f).Opacity(0.8f);
@@ -33,10 +35,7 @@ namespace osu.Game.Graphics.UserInterface
             TextContainer.Height = 0.5f;
             CornerRadius = 5;
 
-            Current.DisabledChanged += disabled =>
-            {
-                Alpha = disabled ? 0.3f : 1;
-            };
+            Current.DisabledChanged += disabled => { Alpha = disabled ? 0.3f : 1; };
         }
 
         [BackgroundDependencyLoader]
@@ -59,5 +58,18 @@ namespace osu.Game.Graphics.UserInterface
         }
 
         protected override Drawable GetDrawableCharacter(char c) => new OsuSpriteText { Text = c.ToString(), TextSize = CalculatedTextSize };
+
+        public virtual bool OnPressed(GlobalAction action)
+        {
+            if (action == GlobalAction.Back)
+            {
+                KillFocus();
+                return true;
+            }
+
+            return false;
+        }
+
+        public bool OnReleased(GlobalAction action) => false;
     }
 }

osu.Game/Graphics/UserInterface/SearchTextBox.cs

@@ -34,8 +34,6 @@ namespace osu.Game.Graphics.UserInterface
 
         protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
         {
-            if (HandlePendingText(state)) return true;
-
             if (!state.Keyboard.ControlPressed && !state.Keyboard.ShiftPressed)
             {
                 switch (args.Key)

osu.Game/Input/Bindings/GlobalActionContainer.cs

@@ -39,13 +39,18 @@ namespace osu.Game.Input.Bindings
             new KeyBinding(InputKey.F4, GlobalAction.ToggleMute),
 
             new KeyBinding(InputKey.Escape, GlobalAction.Back),
-            new KeyBinding(InputKey.MouseButton1, GlobalAction.Back)
+            new KeyBinding(InputKey.MouseButton1, GlobalAction.Back),
+
+            new KeyBinding(InputKey.Space, GlobalAction.Select),
+            new KeyBinding(InputKey.Enter, GlobalAction.Select),
         };
 
         public IEnumerable<KeyBinding> InGameKeyBindings => new[]
         {
             new KeyBinding(InputKey.Space, GlobalAction.SkipCutscene),
-            new KeyBinding(InputKey.Tilde, GlobalAction.QuickRetry)
+            new KeyBinding(InputKey.Tilde, GlobalAction.QuickRetry),
+            new KeyBinding(new[] { InputKey.Control, InputKey.Plus }, GlobalAction.IncreaseScrollSpeed),
+            new KeyBinding(new[] { InputKey.Control, InputKey.Minus }, GlobalAction.DecreaseScrollSpeed),
         };
 
         protected override IEnumerable<Drawable> KeyBindingInputQueue =>
@@ -84,7 +89,16 @@ namespace osu.Game.Input.Bindings
         [Description("Toggle gameplay mouse buttons")]
         ToggleGameplayMouseButtons,
 
-        [Description("Go back")]
-        Back
+        [Description("Back")]
+        Back,
+
+        [Description("Increase scroll speed")]
+        IncreaseScrollSpeed,
+
+        [Description("Decrease scroll speed")]
+        DecreaseScrollSpeed,
+
+        [Description("Select")]
+        Select,
     }
 }

osu.Game/Migrations/20180628011956_RemoveNegativeSetIDs.Designer.cs

@@ -0,0 +1,376 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using osu.Game.Database;
+
+namespace osu.Game.Migrations
+{
+    [DbContext(typeof(OsuDbContext))]
+    [Migration("20180628011956_RemoveNegativeSetIDs")]
+    partial class RemoveNegativeSetIDs
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.1.1-rtm-30846");
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapDifficulty", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<float>("ApproachRate");
+
+                    b.Property<float>("CircleSize");
+
+                    b.Property<float>("DrainRate");
+
+                    b.Property<float>("OverallDifficulty");
+
+                    b.Property<double>("SliderMultiplier");
+
+                    b.Property<double>("SliderTickRate");
+
+                    b.HasKey("ID");
+
+                    b.ToTable("BeatmapDifficulty");
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapInfo", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("AudioLeadIn");
+
+                    b.Property<int>("BaseDifficultyID");
+
+                    b.Property<int>("BeatDivisor");
+
+                    b.Property<int>("BeatmapSetInfoID");
+
+                    b.Property<bool>("Countdown");
+
+                    b.Property<double>("DistanceSpacing");
+
+                    b.Property<int>("GridSize");
+
+                    b.Property<string>("Hash");
+
+                    b.Property<bool>("Hidden");
+
+                    b.Property<bool>("LetterboxInBreaks");
+
+                    b.Property<string>("MD5Hash");
+
+                    b.Property<int?>("MetadataID");
+
+                    b.Property<int?>("OnlineBeatmapID");
+
+                    b.Property<string>("Path");
+
+                    b.Property<int>("RulesetID");
+
+                    b.Property<bool>("SpecialStyle");
+
+                    b.Property<float>("StackLeniency");
+
+                    b.Property<double>("StarDifficulty");
+
+                    b.Property<string>("StoredBookmarks");
+
+                    b.Property<double>("TimelineZoom");
+
+                    b.Property<string>("Version");
+
+                    b.Property<bool>("WidescreenStoryboard");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("BaseDifficultyID");
+
+                    b.HasIndex("BeatmapSetInfoID");
+
+                    b.HasIndex("Hash");
+
+                    b.HasIndex("MD5Hash");
+
+                    b.HasIndex("MetadataID");
+
+                    b.HasIndex("OnlineBeatmapID")
+                        .IsUnique();
+
+                    b.HasIndex("RulesetID");
+
+                    b.ToTable("BeatmapInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapMetadata", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Artist");
+
+                    b.Property<string>("ArtistUnicode");
+
+                    b.Property<string>("AudioFile");
+
+                    b.Property<string>("AuthorString")
+                        .HasColumnName("Author");
+
+                    b.Property<string>("BackgroundFile");
+
+                    b.Property<int>("PreviewTime");
+
+                    b.Property<string>("Source");
+
+                    b.Property<string>("Tags");
+
+                    b.Property<string>("Title");
+
+                    b.Property<string>("TitleUnicode");
+
+                    b.HasKey("ID");
+
+                    b.ToTable("BeatmapMetadata");
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapSetFileInfo", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("BeatmapSetInfoID");
+
+                    b.Property<int>("FileInfoID");
+
+                    b.Property<string>("Filename")
+                        .IsRequired();
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("BeatmapSetInfoID");
+
+                    b.HasIndex("FileInfoID");
+
+                    b.ToTable("BeatmapSetFileInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapSetInfo", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("DeletePending");
+
+                    b.Property<string>("Hash");
+
+                    b.Property<int?>("MetadataID");
+
+                    b.Property<int?>("OnlineBeatmapSetID");
+
+                    b.Property<bool>("Protected");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("DeletePending");
+
+                    b.HasIndex("Hash")
+                        .IsUnique();
+
+                    b.HasIndex("MetadataID");
+
+                    b.HasIndex("OnlineBeatmapSetID")
+                        .IsUnique();
+
+                    b.ToTable("BeatmapSetInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Configuration.DatabasedSetting", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("IntKey")
+                        .HasColumnName("Key");
+
+                    b.Property<int?>("RulesetID");
+
+                    b.Property<string>("StringValue")
+                        .HasColumnName("Value");
+
+                    b.Property<int?>("Variant");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("RulesetID", "Variant");
+
+                    b.ToTable("Settings");
+                });
+
+            modelBuilder.Entity("osu.Game.Input.Bindings.DatabasedKeyBinding", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("IntAction")
+                        .HasColumnName("Action");
+
+                    b.Property<string>("KeysString")
+                        .HasColumnName("Keys");
+
+                    b.Property<int?>("RulesetID");
+
+                    b.Property<int?>("Variant");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("IntAction");
+
+                    b.HasIndex("RulesetID", "Variant");
+
+                    b.ToTable("KeyBinding");
+                });
+
+            modelBuilder.Entity("osu.Game.IO.FileInfo", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Hash");
+
+                    b.Property<int>("ReferenceCount");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Hash")
+                        .IsUnique();
+
+                    b.HasIndex("ReferenceCount");
+
+                    b.ToTable("FileInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Rulesets.RulesetInfo", b =>
+                {
+                    b.Property<int?>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Available");
+
+                    b.Property<string>("InstantiationInfo");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("ShortName");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Available");
+
+                    b.HasIndex("ShortName")
+                        .IsUnique();
+
+                    b.ToTable("RulesetInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Skinning.SkinFileInfo", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("FileInfoID");
+
+                    b.Property<string>("Filename")
+                        .IsRequired();
+
+                    b.Property<int>("SkinInfoID");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("FileInfoID");
+
+                    b.HasIndex("SkinInfoID");
+
+                    b.ToTable("SkinFileInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Skinning.SkinInfo", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Creator");
+
+                    b.Property<bool>("DeletePending");
+
+                    b.Property<string>("Name");
+
+                    b.HasKey("ID");
+
+                    b.ToTable("SkinInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapInfo", b =>
+                {
+                    b.HasOne("osu.Game.Beatmaps.BeatmapDifficulty", "BaseDifficulty")
+                        .WithMany()
+                        .HasForeignKey("BaseDifficultyID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("osu.Game.Beatmaps.BeatmapSetInfo", "BeatmapSet")
+                        .WithMany("Beatmaps")
+                        .HasForeignKey("BeatmapSetInfoID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("osu.Game.Beatmaps.BeatmapMetadata", "Metadata")
+                        .WithMany("Beatmaps")
+                        .HasForeignKey("MetadataID");
+
+                    b.HasOne("osu.Game.Rulesets.RulesetInfo", "Ruleset")
+                        .WithMany()
+                        .HasForeignKey("RulesetID")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapSetFileInfo", b =>
+                {
+                    b.HasOne("osu.Game.Beatmaps.BeatmapSetInfo")
+                        .WithMany("Files")
+                        .HasForeignKey("BeatmapSetInfoID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("osu.Game.IO.FileInfo", "FileInfo")
+                        .WithMany()
+                        .HasForeignKey("FileInfoID")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapSetInfo", b =>
+                {
+                    b.HasOne("osu.Game.Beatmaps.BeatmapMetadata", "Metadata")
+                        .WithMany("BeatmapSets")
+                        .HasForeignKey("MetadataID");
+                });
+
+            modelBuilder.Entity("osu.Game.Skinning.SkinFileInfo", b =>
+                {
+                    b.HasOne("osu.Game.IO.FileInfo", "FileInfo")
+                        .WithMany()
+                        .HasForeignKey("FileInfoID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("osu.Game.Skinning.SkinInfo")
+                        .WithMany("Files")
+                        .HasForeignKey("SkinInfoID")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}