Merge remote-tracking branch 'origin/fix-drawable-load-regression' into release

Make arrow keys change settings at the lowest possible intervals

.vscode/launch.json

@@ -41,7 +41,7 @@
             "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)",
@@ -58,7 +58,7 @@
             "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)",
@@ -70,4 +70,4 @@
             "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
 

appveyor.yml

@@ -2,6 +2,9 @@ clone_depth: 1
 version: '{branch}-{build}'
 image: Visual Studio 2017
 configuration: Debug
+cache:
+  - C:\ProgramData\chocolatey\bin -> appveyor.yml
+  - C:\ProgramData\chocolatey\lib -> appveyor.yml
 install:
   - cmd: git submodule update --init --recursive --depth=5
   - cmd: choco install resharper-clt -y
@@ -18,4 +21,4 @@ build:
   verbosity: minimal
 after_build:
   - cmd: inspectcode --o="inspectcodereport.xml" --projects:osu.Game* --caches-home="inspectcode" osu.sln > NUL
-  - cmd: NVika parsereport "inspectcodereport.xml" --treatwarningsaserrors
+  - cmd: NVika parsereport "inspectcodereport.xml" --treatwarningsaserrors

osu.Desktop/OsuGameDesktop.cs

@@ -12,6 +12,7 @@ using osu.Framework.Platform;
 using osu.Game;
 using OpenTK.Input;
 using Microsoft.Win32;
+using osu.Desktop.Updater;
 using osu.Framework.Platform.Windows;
 
 namespace osu.Desktop
@@ -38,6 +39,52 @@ namespace osu.Desktop
             }
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            if (!noVersionOverlay)
+            {
+                LoadComponentAsync(new VersionManager { Depth = int.MinValue }, v =>
+                {
+                    Add(v);
+                    v.State = Visibility.Visible;
+                });
+
+#if NET_FRAMEWORK
+                Add(new SquirrelUpdateManager());
+#else
+                Add(new SimpleUpdateManager());
+#endif
+            }
+        }
+
+        public override void SetHost(GameHost host)
+        {
+            base.SetHost(host);
+            var desktopWindow = host.Window as DesktopGameWindow;
+            if (desktopWindow != null)
+            {
+                desktopWindow.CursorState |= CursorState.Hidden;
+
+                desktopWindow.SetIconFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(GetType(), "lazer.ico"));
+                desktopWindow.Title = Name;
+
+                desktopWindow.FileDrop += fileDrop;
+            }
+        }
+
+        private void fileDrop(object sender, FileDropEventArgs e)
+        {
+            var filePaths = new[] { e.FileName };
+
+            var firstExtension = Path.GetExtension(filePaths.First());
+
+            if (filePaths.Any(f => Path.GetExtension(f) != firstExtension)) return;
+
+            Task.Factory.StartNew(() => Import(filePaths), TaskCreationOptions.LongRunning);
+        }
+
         /// <summary>
         /// A method of accessing an osu-stable install in a controlled fashion.
         /// </summary>
@@ -77,45 +124,5 @@ namespace osu.Desktop
             {
             }
         }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            if (!noVersionOverlay)
-            {
-                LoadComponentAsync(new VersionManager { Depth = int.MinValue }, v =>
-                {
-                    Add(v);
-                    v.State = Visibility.Visible;
-                });
-            }
-        }
-
-        public override void SetHost(GameHost host)
-        {
-            base.SetHost(host);
-            var desktopWindow = host.Window as DesktopGameWindow;
-            if (desktopWindow != null)
-            {
-                desktopWindow.CursorState |= CursorState.Hidden;
-
-                desktopWindow.SetIconFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(GetType(), "lazer.ico"));
-                desktopWindow.Title = Name;
-
-                desktopWindow.FileDrop += fileDrop;
-            }
-        }
-
-        private void fileDrop(object sender, FileDropEventArgs e)
-        {
-            var filePaths = new[] { e.FileName };
-
-            var firstExtension = Path.GetExtension(filePaths.First());
-
-            if (filePaths.Any(f => Path.GetExtension(f) != firstExtension)) return;
-
-            Task.Factory.StartNew(() => Import(filePaths), TaskCreationOptions.LongRunning);
-        }
     }
 }

osu.Desktop/Overlays/VersionManager.cs

@@ -91,10 +91,6 @@ namespace osu.Desktop.Overlays
                     }
                 }
             };
-
-#if NET_FRAMEWORK
-            Add(new SquirrelUpdateManager());
-#endif
         }
 
         protected override void LoadComplete()
@@ -115,6 +111,8 @@ namespace osu.Desktop.Overlays
 
         private class UpdateCompleteNotification : SimpleNotification
         {
+            public override bool IsImportant => true;
+
             public UpdateCompleteNotification(string version, Action<string> openUrl = null)
             {
                 Text = $"You are now running osu!lazer {version}.\nClick to see what's new!";

osu.Desktop/Program.cs

@@ -7,6 +7,7 @@ using System.Linq;
 using osu.Framework;
 using osu.Framework.Platform;
 using osu.Game.IPC;
+
 #if NET_FRAMEWORK
 using System.Runtime;
 #endif
@@ -18,10 +19,7 @@ namespace osu.Desktop
         [STAThread]
         public static int Main(string[] args)
         {
-            // required to initialise native SQLite libraries on some platforms.
-
-            if (!RuntimeInfo.IsMono)
-                useMulticoreJit();
+            useMultiCoreJit();
 
             // Back up the cwd before DesktopGameHost changes it
             var cwd = Environment.CurrentDirectory;
@@ -54,7 +52,7 @@ namespace osu.Desktop
             }
         }
 
-        private static void useMulticoreJit()
+        private static void useMultiCoreJit()
         {
 #if NET_FRAMEWORK
             var directory = Directory.CreateDirectory(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Profiles"));

osu.Desktop/Updater/SimpleUpdateManager.cs

@@ -0,0 +1,103 @@
+// 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.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using osu.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.IO.Network;
+using osu.Framework.Platform;
+using osu.Game;
+using osu.Game.Graphics;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Notifications;
+
+namespace osu.Desktop.Updater
+{
+    /// <summary>
+    /// An update manager that shows notifications if a newer release is detected.
+    /// Installation is left up to the user.
+    /// </summary>
+    internal class SimpleUpdateManager : CompositeDrawable
+    {
+        private NotificationOverlay notificationOverlay;
+        private string version;
+        private GameHost host;
+
+        [BackgroundDependencyLoader]
+        private void load(NotificationOverlay notification, OsuGameBase game, GameHost host)
+        {
+            notificationOverlay = notification;
+
+            this.host = host;
+            version = game.Version;
+
+            if (game.IsDeployedBuild)
+                Schedule(() => Task.Run(() => checkForUpdateAsync()));
+        }
+
+        private async void checkForUpdateAsync()
+        {
+            var releases = new JsonWebRequest<GitHubRelease>("https://api.github.com/repos/ppy/osu/releases/latest");
+            await releases.PerformAsync();
+
+            var latest = releases.ResponseObject;
+
+            if (latest.TagName != version)
+            {
+                notificationOverlay.Post(new SimpleNotification
+                {
+                    Text = $"A newer release of osu! has been found ({version} → {latest.TagName}).\n\n"
+                           + "Click here to download the new version, which can be installed over the top of your existing installation",
+                    Icon = FontAwesome.fa_upload,
+                    Activated = () =>
+                    {
+                        host.OpenUrlExternally(getBestUrl(latest));
+                        return true;
+                    }
+                });
+            }
+        }
+
+        private string getBestUrl(GitHubRelease release)
+        {
+            GitHubAsset bestAsset = null;
+
+            switch (RuntimeInfo.OS)
+            {
+                case RuntimeInfo.Platform.Windows:
+                    bestAsset = release.Assets?.FirstOrDefault(f => f.Name.EndsWith(".exe"));
+                    break;
+                case RuntimeInfo.Platform.MacOsx:
+                    bestAsset = release.Assets?.FirstOrDefault(f => f.Name.EndsWith(".app.zip"));
+                    break;
+            }
+
+            return bestAsset?.BrowserDownloadUrl ?? release.HtmlUrl;
+        }
+
+        public class GitHubRelease
+        {
+            [JsonProperty("html_url")]
+            public string HtmlUrl { get; set; }
+
+            [JsonProperty("tag_name")]
+            public string TagName { get; set; }
+
+            [JsonProperty("assets")]
+            public List<GitHubAsset> Assets { get; set; }
+        }
+
+        public class GitHubAsset
+        {
+            [JsonProperty("name")]
+            public string Name { get; set; }
+
+            [JsonProperty("browser_download_url")]
+            public string BrowserDownloadUrl { get; set; }
+        }
+    }
+}

osu.Desktop/Updater/SquirrelUpdateManager.cs

@@ -3,6 +3,7 @@
 
 #if NET_FRAMEWORK
 using System;
+using System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
@@ -16,7 +17,7 @@ using OpenTK;
 using OpenTK.Graphics;
 using Squirrel;
 
-namespace osu.Desktop.Overlays
+namespace osu.Desktop.Updater
 {
     public class SquirrelUpdateManager : Component
     {
@@ -35,7 +36,7 @@ namespace osu.Desktop.Overlays
             notificationOverlay = notification;
 
             if (game.IsDeployedBuild)
-                Schedule(() => checkForUpdateAsync());
+                Schedule(() => Task.Run(() => checkForUpdateAsync()));
         }
 
         private async void checkForUpdateAsync(bool useDeltaPatching = true, UpdateProgressNotification notification = null)

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

@@ -55,7 +55,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             {
             }
 
-            public void ToggleHyperDash(bool status) => MovableCatcher.SetHyperdashState(status ? 2 : 1);
+            public void ToggleHyperDash(bool status) => MovableCatcher.SetHyperDashState(status ? 2 : 1);
         }
     }
 }

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

@@ -8,9 +8,9 @@ using osu.Game.Rulesets.Catch.Objects;
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
-    public class TestCaseHyperdash : Game.Tests.Visual.TestCasePlayer
+    public class TestCaseHyperDash : Game.Tests.Visual.TestCasePlayer
     {
-        public TestCaseHyperdash()
+        public TestCaseHyperDash()
             : base(new CatchRuleset())
         {
         }

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

@@ -61,12 +61,12 @@ namespace osu.Game.Rulesets.Catch.Difficulty
                 return new CatchDifficultyAttributes(mods, 0);
 
             // this is the same as osu!, so there's potential to share the implementation... maybe
-            double preEmpt = BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450) / timeRate;
+            double preempt = BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450) / timeRate;
             double starRating = Math.Sqrt(calculateDifficulty(difficultyHitObjects, timeRate)) * star_scaling_factor;
 
             return new CatchDifficultyAttributes(mods, starRating)
             {
-                ApproachRate = preEmpt > 1200.0 ? -(preEmpt - 1800.0) / 120.0 : -(preEmpt - 1200.0) / 150.0 + 5.0,
+                ApproachRate = preempt > 1200.0 ? -(preempt - 1800.0) / 120.0 : -(preempt - 1200.0) / 150.0 + 5.0,
                 MaxCombo = difficultyHitObjects.Count
             };
         }

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

@@ -255,11 +255,11 @@ namespace osu.Game.Rulesets.Catch.UI
                     double positionDifference = target.X * CatchPlayfield.BASE_WIDTH - catcherPosition;
                     double velocity = positionDifference / Math.Max(1.0, timeDifference - 1000.0 / 60.0);
 
-                    SetHyperdashState(Math.Abs(velocity), target.X);
+                    SetHyperDashState(Math.Abs(velocity), target.X);
                 }
                 else
                 {
-                    SetHyperdashState();
+                    SetHyperDashState();
                 }
 
                 return validCatch;
@@ -270,18 +270,18 @@ namespace osu.Game.Rulesets.Catch.UI
             private float hyperDashTargetPosition;
 
             /// <summary>
-            /// Whether we are hypderdashing or not.
+            /// Whether we are hyper-dashing or not.
             /// </summary>
             public bool HyperDashing => hyperDashModifier != 1;
 
             /// <summary>
-            /// Set hyperdash state.
+            /// Set hyper-dash state.
             /// </summary>
-            /// <param name="modifier">The speed multiplier. If this is less or equals to 1, this catcher will be non-hyperdashing state.</param>
-            /// <param name="targetPosition">When this catcher crosses this position, this catcher ends hyperdashing.</param>
-            public void SetHyperdashState(double modifier = 1, float targetPosition = -1)
+            /// <param name="modifier">The speed multiplier. If this is less or equals to 1, this catcher will be non-hyper-dashing state.</param>
+            /// <param name="targetPosition">When this catcher crosses this position, this catcher ends hyper-dashing.</param>
+            public void SetHyperDashState(double modifier = 1, float targetPosition = -1)
             {
-                const float hyperdash_transition_length = 180;
+                const float hyper_dash_transition_length = 180;
 
                 bool previouslyHyperDashing = HyperDashing;
                 if (modifier <= 1 || X == targetPosition)
@@ -291,8 +291,8 @@ namespace osu.Game.Rulesets.Catch.UI
 
                     if (previouslyHyperDashing)
                     {
-                        this.FadeColour(Color4.White, hyperdash_transition_length, Easing.OutQuint);
-                        this.FadeTo(1, hyperdash_transition_length, Easing.OutQuint);
+                        this.FadeColour(Color4.White, hyper_dash_transition_length, Easing.OutQuint);
+                        this.FadeTo(1, hyper_dash_transition_length, Easing.OutQuint);
                     }
                 }
                 else
@@ -303,8 +303,8 @@ namespace osu.Game.Rulesets.Catch.UI
 
                     if (!previouslyHyperDashing)
                     {
-                        this.FadeColour(Color4.OrangeRed, hyperdash_transition_length, Easing.OutQuint);
-                        this.FadeTo(0.2f, hyperdash_transition_length, Easing.OutQuint);
+                        this.FadeColour(Color4.OrangeRed, hyper_dash_transition_length, Easing.OutQuint);
+                        this.FadeTo(0.2f, hyper_dash_transition_length, Easing.OutQuint);
                         Trail = true;
                     }
                 }
@@ -370,7 +370,7 @@ namespace osu.Game.Rulesets.Catch.UI
                     hyperDashDirection < 0 && hyperDashTargetPosition > X)
                 {
                     X = hyperDashTargetPosition;
-                    SetHyperdashState();
+                    SetHyperDashState();
                 }
             }
 

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;
@@ -13,11 +15,10 @@ using osu.Game.Tests.Beatmaps;
 namespace osu.Game.Rulesets.Mania.Tests
 {
     [TestFixture]
-    public class ManiaBeatmapConversionTest : BeatmapConversionTest<ConvertValue>
+    public class ManiaBeatmapConversionTest : BeatmapConversionTest<ManiaConvertMapping, ConvertValue>
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Mania";
 
-        [NonParallelizable]
         [TestCase("basic")]
         public new void Test(string name)
         {
@@ -34,9 +35,35 @@ namespace osu.Game.Rulesets.Mania.Tests
             };
         }
 
+        protected override ManiaConvertMapping CreateConvertMapping() => new ManiaConvertMapping(Converter);
+
         protected override Ruleset CreateRuleset() => new ManiaRuleset();
     }
 
+     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>

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

@@ -21,9 +21,9 @@ namespace osu.Game.Rulesets.Mania.Tests
             this.direction = direction;
         }
 
-        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
-            var dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
             dependencies.CacheAs<IScrollingInfo>(new ScrollingInfo { Direction = { Value = direction }});
             return dependencies;
         }

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

@@ -137,9 +137,9 @@ namespace osu.Game.Rulesets.Mania.Tests
                 };
             }
 
-            protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+            protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
             {
-                var dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+                var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
                 dependencies.CacheAs<IBindable<ManiaAction>>(new Bindable<ManiaAction>());
                 return dependencies;
             }

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

@@ -19,12 +19,15 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         public EndTimeObjectPatternGenerator(FastRandom random, HitObject hitObject, ManiaBeatmap beatmap, IBeatmap originalBeatmap)
             : base(random, hitObject, beatmap, new Pattern(), originalBeatmap)
         {
-            var endtimeData = HitObject as IHasEndTime;
-
-            endTime = endtimeData?.EndTime ?? 0;
+            endTime = (HitObject as IHasEndTime)?.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/ManiaSettingsSubsection.cs

@@ -19,14 +19,14 @@ namespace osu.Game.Rulesets.Mania
         }
 
         [BackgroundDependencyLoader]
-        private void load(ManiaConfigManager config)
+        private void load()
         {
             Children = new Drawable[]
             {
                 new SettingsEnumDropdown<ManiaScrollingDirection>
                 {
                     LabelText = "Scrolling direction",
-                    Bindable = config.GetBindable<ManiaScrollingDirection>(ManiaSetting.ScrollDirection)
+                    Bindable = ((ManiaConfigManager)Config).GetBindable<ManiaScrollingDirection>(ManiaSetting.ScrollDirection)
                 }
             };
         }

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

@@ -118,9 +118,9 @@ namespace osu.Game.Rulesets.Mania.UI
             }
         }
 
-        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
-            var dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
             dependencies.CacheAs<IBindable<ManiaAction>>(Action);
             return dependencies;
         }

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

@@ -70,19 +70,19 @@ namespace osu.Game.Rulesets.Mania.UI
         }
 
         [BackgroundDependencyLoader]
-        private void load(ManiaConfigManager config)
+        private void load()
         {
             BarLines.ForEach(Playfield.Add);
 
-            config.BindWith(ManiaSetting.ScrollDirection, configDirection);
+            ((ManiaConfigManager)Config).BindWith(ManiaSetting.ScrollDirection, configDirection);
             configDirection.BindValueChanged(d => scrollingInfo.Direction.Value = (ScrollingDirection)d, true);
         }
 
         private DependencyContainer dependencies;
 
-        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
-            dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+            dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
             dependencies.CacheAs<IScrollingInfo>(scrollingInfo = new ScrollingInfo());
             return dependencies;
         }

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

@@ -54,7 +54,7 @@ namespace osu.Game.Rulesets.Osu.Tests
     public struct ConvertValue : IEquatable<ConvertValue>
     {
         /// <summary>
-        /// A sane value to account for osu!stable using ints everwhere.
+        /// A sane value to account for osu!stable using <see cref="int"/>s everywhere.
         /// </summary>
         private const double conversion_lenience = 2;
 

osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs

@@ -61,19 +61,19 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             double speedRating = Math.Sqrt(skills[1].DifficultyValue()) * difficulty_multiplier;
             double starRating = aimRating + speedRating + Math.Abs(aimRating - speedRating) / 2;
 
-            // Todo: These int casts are temporary to achieve 1:1 results with osu!stable, and should be remoevd in the future
+            // Todo: These int casts are temporary to achieve 1:1 results with osu!stable, and should be removed in the future
             double hitWindowGreat = (int)(beatmap.HitObjects.First().HitWindows.Great / 2) / timeRate;
-            double preEmpt = (int)BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450) / timeRate;
+            double preempt = (int)BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450) / timeRate;
 
             int maxCombo = beatmap.HitObjects.Count();
-            // Add the ticks + tail of the slider. 1 is subtracted because the "headcircle" would be counted twice (once for the slider itself in the line above)
+            // Add the ticks + tail of the slider. 1 is subtracted because the head circle would be counted twice (once for the slider itself in the line above)
             maxCombo += beatmap.HitObjects.OfType<Slider>().Sum(s => s.NestedHitObjects.Count - 1);
 
             return new OsuDifficultyAttributes(mods, starRating)
             {
                 AimStrain = aimRating,
                 SpeedStrain = speedRating,
-                ApproachRate = preEmpt > 1200 ? (1800 - preEmpt) / 120 : (1200 - preEmpt) / 150 + 5,
+                ApproachRate = preempt > 1200 ? (1800 - preempt) / 120 : (1200 - preempt) / 150 + 5,
                 OverallDifficulty = (80 - hitWindowGreat) / 6,
                 MaxCombo = maxCombo
             };

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

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public override void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
         {
-            void adjustFadeIn(OsuHitObject h) => h.TimeFadein = h.TimePreempt * fade_in_duration_multiplier;
+            void adjustFadeIn(OsuHitObject h) => h.TimeFadeIn = h.TimePreempt * fade_in_duration_multiplier;
 
             foreach (var d in drawables.OfType<DrawableOsuHitObject>())
             {
@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
             var h = d.HitObject;
 
-            var fadeOutStartTime = h.StartTime - h.TimePreempt + h.TimeFadein;
+            var fadeOutStartTime = h.StartTime - h.TimePreempt + h.TimeFadeIn;
             var fadeOutDuration = h.TimePreempt * fade_out_duration_multiplier;
 
             // new duration from completed fade in to end (before fading out)

osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPointRenderer.cs

@@ -96,12 +96,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
 
                         using (fp.BeginAbsoluteSequence(fadeInTime))
                         {
-                            fp.FadeIn(currHitObject.TimeFadein);
-                            fp.ScaleTo(1, currHitObject.TimeFadein, Easing.Out);
+                            fp.FadeIn(currHitObject.TimeFadeIn);
+                            fp.ScaleTo(1, currHitObject.TimeFadeIn, Easing.Out);
 
-                            fp.MoveTo(pointEndPosition, currHitObject.TimeFadein, Easing.Out);
+                            fp.MoveTo(pointEndPosition, currHitObject.TimeFadeIn, Easing.Out);
 
-                            fp.Delay(fadeOutTime - fadeInTime).FadeOut(currHitObject.TimeFadein);
+                            fp.Delay(fadeOutTime - fadeInTime).FadeOut(currHitObject.TimeFadeIn);
                         }
 
                         fp.Expire(true);

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

@@ -100,7 +100,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
             base.UpdatePreemptState();
 
-            ApproachCircle.FadeIn(Math.Min(HitObject.TimeFadein * 2, HitObject.TimePreempt));
+            ApproachCircle.FadeIn(Math.Min(HitObject.TimeFadeIn * 2, HitObject.TimePreempt));
             ApproachCircle.ScaleTo(1.1f, HitObject.TimePreempt);
         }
 

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

@@ -45,7 +45,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 AccentColour = skin.GetValue<SkinConfiguration, Color4>(s => s.ComboColours.Count > 0 ? s.ComboColours[combo.ComboIndex % s.ComboColours.Count] : (Color4?)null) ?? Color4.White;
         }
 
-        protected virtual void UpdatePreemptState() => this.FadeIn(HitObject.TimeFadein);
+        protected virtual void UpdatePreemptState() => this.FadeIn(HitObject.TimeFadeIn);
 
         protected virtual void UpdateCurrentState(ArmedState state)
         {

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

@@ -167,7 +167,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
             Disc.Tracking = OsuActionInputManager.PressedActions.Any(x => x == OsuAction.LeftButton || x == OsuAction.RightButton);
             if (!spmCounter.IsPresent && Disc.Tracking)
-                spmCounter.FadeIn(HitObject.TimeFadein);
+                spmCounter.FadeIn(HitObject.TimeFadeIn);
 
             base.Update();
         }

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

@@ -212,7 +212,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             var spanProgress = slider.ProgressAt(completionProgress);
 
             double start = 0;
-            double end = SnakingIn ? MathHelper.Clamp((Time.Current - (slider.StartTime - slider.TimePreempt)) / slider.TimeFadein, 0, 1) : 1;
+            double end = SnakingIn ? MathHelper.Clamp((Time.Current - (slider.StartTime - slider.TimePreempt)) / slider.TimeFadeIn, 0, 1) : 1;
 
             if (span >= slider.SpanCount() - 1)
             {

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

@@ -18,7 +18,7 @@ namespace osu.Game.Rulesets.Osu.Objects
         public event Action<Vector2> PositionChanged;
 
         public double TimePreempt = 600;
-        public double TimeFadein = 400;
+        public double TimeFadeIn = 400;
 
         private Vector2 position;
 
@@ -65,7 +65,7 @@ namespace osu.Game.Rulesets.Osu.Objects
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
 
             TimePreempt = (float)BeatmapDifficulty.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450);
-            TimeFadein = (float)BeatmapDifficulty.DifficultyRange(difficulty.ApproachRate, 1200, 800, 300);
+            TimeFadeIn = (float)BeatmapDifficulty.DifficultyRange(difficulty.ApproachRate, 1200, 800, 300);
 
             Scale = (1.0f - 0.7f * (difficulty.CircleSize - 5) / 5) / 2;
         }

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

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Osu.Objects
                 // This is so on repeats ticks don't appear too late to be visually processed by the player.
                 offset = 200;
             else
-                offset = TimeFadein * 0.66f;
+                offset = TimeFadeIn * 0.66f;
 
             TimePreempt = (StartTime - SpanStartTime) / 2 + offset;
         }

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -31,8 +31,8 @@ namespace osu.Game.Rulesets.Osu
 
         public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0) => new[]
         {
-            new KeyBinding(InputKey.Z, OsuAction.LeftButton),
-            new KeyBinding(InputKey.X, OsuAction.RightButton),
+            new KeyBinding(InputKey.A, OsuAction.LeftButton),
+            new KeyBinding(InputKey.S, OsuAction.RightButton),
             new KeyBinding(InputKey.MouseLeft, OsuAction.LeftButton),
             new KeyBinding(InputKey.MouseRight, OsuAction.RightButton),
         };

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

@@ -222,10 +222,10 @@ namespace osu.Game.Tests.Beatmaps.Formats
             {
                 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);
+                Assert.AreEqual("normal-hitnormal", getTestableSampleInfo(hitObjects[0]).LookupNames.First());
+                Assert.AreEqual("normal-hitnormal", getTestableSampleInfo(hitObjects[1]).LookupNames.First());
+                Assert.AreEqual("normal-hitnormal2", getTestableSampleInfo(hitObjects[2]).LookupNames.First());
+                Assert.AreEqual("normal-hitnormal", getTestableSampleInfo(hitObjects[3]).LookupNames.First());
             }
 
             SampleInfo getTestableSampleInfo(HitObject hitObject) => hitObject.SampleControlPoint.ApplyTo(new SampleInfo { Name = "hitnormal" });
@@ -242,7 +242,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
 
                 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("normal-hitnormal2", getTestableSampleInfo(hitObjects[2]).LookupNames.First());
                 Assert.AreEqual("hit_1.wav", hitObjects[3].Samples[0].LookupNames.First());
             }
 

osu.Game.Tests/Visual/TestCaseBeatmapInfoWedge.cs

@@ -110,8 +110,8 @@ namespace osu.Game.Tests.Visual
 
         private void testInfoLabels(int expectedCount)
         {
-            AddAssert("check infolabels exists", () => infoWedge.Info.InfoLabelContainer.Children.Any());
-            AddAssert("check infolabels count", () => infoWedge.Info.InfoLabelContainer.Children.Count == expectedCount);
+            AddAssert("check info labels exists", () => infoWedge.Info.InfoLabelContainer.Children.Any());
+            AddAssert("check info labels count", () => infoWedge.Info.InfoLabelContainer.Children.Count == expectedCount);
         }
 
         private void testNullBeatmap()
@@ -121,7 +121,7 @@ namespace osu.Game.Tests.Visual
             AddAssert("check default title", () => infoWedge.Info.TitleLabel.Text == Beatmap.Default.BeatmapInfo.Metadata.Title);
             AddAssert("check default artist", () => infoWedge.Info.ArtistLabel.Text == Beatmap.Default.BeatmapInfo.Metadata.Artist);
             AddAssert("check empty author", () => !infoWedge.Info.MapperContainer.Children.Any());
-            AddAssert("check no infolabels", () => !infoWedge.Info.InfoLabelContainer.Children.Any());
+            AddAssert("check no info labels", () => !infoWedge.Info.InfoLabelContainer.Children.Any());
         }
 
         private void selectBeatmap(IBeatmap b)

osu.Game.Tests/Visual/TestCaseButtonSystem.cs

@@ -1,6 +1,9 @@
 // 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.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
@@ -13,6 +16,13 @@ namespace osu.Game.Tests.Visual
     [TestFixture]
     public class TestCaseButtonSystem : OsuTestCase
     {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(ButtonSystem),
+            typeof(ButtonArea),
+            typeof(Button)
+        };
+
         public TestCaseButtonSystem()
         {
             OsuLogo logo;
@@ -30,6 +40,9 @@ namespace osu.Game.Tests.Visual
             };
 
             buttons.SetOsuLogo(logo);
+
+            foreach (var s in Enum.GetValues(typeof(ButtonSystemState)).OfType<ButtonSystemState>().Skip(1))
+                AddStep($"State to {s}", () => buttons.State = s);
         }
     }
 }

osu.Game.Tests/Visual/TestCaseDisclaimer.cs

@@ -0,0 +1,28 @@
+// 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.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Screens.Menu;
+using OpenTK.Graphics;
+
+namespace osu.Game.Tests.Visual
+{
+    public class TestCaseDisclaimer : OsuTestCase
+    {
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Children = new Drawable[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Color4.Black,
+                },
+                new Disclaimer()
+            };
+        }
+    }
+}

osu.Game.Tests/Visual/TestCaseMods.cs

@@ -114,7 +114,7 @@ namespace osu.Game.Tests.Visual
             testMultiplierTextColour(noFailMod, modSelect.LowMultiplierColour);
             testMultiplierTextColour(hiddenMod, modSelect.HighMultiplierColour);
 
-            testUnimplmentedMod(autoPilotMod);
+            testUnimplementedMod(autoPilotMod);
         }
 
         private void testManiaMods(ManiaRuleset ruleset)
@@ -154,7 +154,7 @@ namespace osu.Game.Tests.Visual
                 checkNotSelected(mod);
         }
 
-        private void testUnimplmentedMod(Mod mod)
+        private void testUnimplementedMod(Mod mod)
         {
             selectNext(mod);
             checkNotSelected(mod);

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

@@ -6,7 +6,6 @@ using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Timing;
 using osu.Game.Screens;
 using osu.Game.Screens.Menu;
 using OpenTK.Graphics;
@@ -23,19 +22,15 @@ namespace osu.Game.Tests.Visual
 
         public TestCaseOsuGame()
         {
-            var rateAdjustClock = new StopwatchClock(true);
-            var framedClock = new FramedClock(rateAdjustClock);
-            framedClock.ProcessFrame();
-
-            Add(new Box
+            Children = new Drawable[]
             {
-                RelativeSizeAxes = Axes.Both,
-                Colour = Color4.Black,
-            });
-
-            Add(new Loader());
-
-            AddSliderStep("Playback speed", 0.0, 2.0, 1, v => rateAdjustClock.Rate = v);
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Color4.Black,
+                },
+                new Loader()
+            };
         }
     }
 }

osu.Game.Tests/Visual/TestCasePreviewTrackManager.cs

@@ -14,9 +14,9 @@ namespace osu.Game.Tests.Visual
     {
         private readonly PreviewTrackManager trackManager = new TestPreviewTrackManager();
 
-        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
-            var dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
             dependencies.CacheAs(trackManager);
             dependencies.CacheAs<IPreviewTrackOwner>(this);
             return dependencies;
@@ -101,9 +101,9 @@ namespace osu.Game.Tests.Visual
                 AddInternal(track);
             }
 
-            protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+            protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
             {
-                var dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+                var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
                 dependencies.CacheAs<IPreviewTrackOwner>(this);
                 return dependencies;
             }

osu.Game.Tests/Visual/TestCaseToolbar.cs

@@ -16,8 +16,8 @@ namespace osu.Game.Tests.Visual
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
             typeof(ToolbarButton),
-            typeof(ToolbarModeSelector),
-            typeof(ToolbarModeButton),
+            typeof(ToolbarRulesetSelector),
+            typeof(ToolbarRulesetButton),
             typeof(ToolbarNotificationButton),
         };
 

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

@@ -29,6 +29,11 @@ namespace osu.Game.Audio
         /// </summary>
         public string Name;
 
+        /// <summary>
+        /// An optional suffix to provide priority lookup. Falls back to non-suffixed <see cref="Name"/>.
+        /// </summary>
+        public string Suffix;
+
         /// <summary>
         /// The sample volume.
         /// </summary>
@@ -42,9 +47,16 @@ namespace osu.Game.Audio
             get
             {
                 if (!string.IsNullOrEmpty(Namespace))
+                {
+                    if (!string.IsNullOrEmpty(Suffix))
+                        yield return $"{Namespace}/{Bank}-{Name}{Suffix}";
                     yield return $"{Namespace}/{Bank}-{Name}";
+                }
 
-                yield return $"{Bank}-{Name}"; // Without namespace as a fallback even when we have a namespace
+                // check non-namespace as a fallback even when we have a namespace
+                if (!string.IsNullOrEmpty(Suffix))
+                    yield return $"{Bank}-{Name}{Suffix}";
+                yield return $"{Bank}-{Name}";
             }
         }
 

osu.Game/Beatmaps/BeatmapManager.cs

@@ -45,6 +45,11 @@ namespace osu.Game.Beatmaps
         /// </summary>
         public event Action<DownloadBeatmapSetRequest> BeatmapDownloadBegan;
 
+        /// <summary>
+        /// Fired when a beatmap load is requested (into the interactive game UI).
+        /// </summary>
+        public Action<BeatmapSetInfo> PresentBeatmap;
+
         /// <summary>
         /// A default representation of a WorkingBeatmap to use when no beatmap is available.
         /// </summary>
@@ -92,7 +97,7 @@ namespace osu.Game.Beatmaps
                 // by setting the model here, we can update the noline set id below.
                 b.BeatmapSet = model;
 
-                fetchAndPopulateOnlineIDs(b);
+                fetchAndPopulateOnlineIDs(b, model.Beatmaps);
             }
 
             // check if a set already exists with the same online id, delete if it does.
@@ -163,12 +168,20 @@ namespace osu.Game.Beatmaps
 
                 Task.Factory.StartNew(() =>
                 {
+                    BeatmapSetInfo importedBeatmap;
+
                     // This gets scheduled back to the update thread, but we want the import to run in the background.
                     using (var stream = new MemoryStream(data))
                     using (var archive = new ZipArchiveReader(stream, beatmapSetInfo.ToString()))
-                        Import(archive);
+                        importedBeatmap = Import(archive);
 
+                    downloadNotification.CompletionClickAction = () =>
+                    {
+                        PresentBeatmap?.Invoke(importedBeatmap);
+                        return true;
+                    };
                     downloadNotification.State = ProgressNotificationState.Completed;
+
                     currentDownloads.Remove(request);
                 }, TaskCreationOptions.LongRunning);
             };
@@ -339,6 +352,8 @@ namespace osu.Game.Beatmaps
         {
             var beatmapInfos = new List<BeatmapInfo>();
 
+            bool invalidateOnlineIDs = false;
+
             foreach (var name in reader.Filenames.Where(f => f.EndsWith(".osu")))
             {
                 using (var raw = reader.GetStream(name))
@@ -355,9 +370,18 @@ namespace osu.Game.Beatmaps
                     beatmap.BeatmapInfo.Hash = ms.ComputeSHA2Hash();
                     beatmap.BeatmapInfo.MD5Hash = ms.ComputeMD5Hash();
 
-                    // check that no existing beatmap exists that is imported with the same online beatmap ID. if so, give it precedence.
-                    if (beatmap.BeatmapInfo.OnlineBeatmapID.HasValue && QueryBeatmap(b => b.OnlineBeatmapID.Value == beatmap.BeatmapInfo.OnlineBeatmapID.Value) != null)
-                        beatmap.BeatmapInfo.OnlineBeatmapID = null;
+                    if (beatmap.BeatmapInfo.OnlineBeatmapID.HasValue)
+                    {
+                        var ourId = beatmap.BeatmapInfo.OnlineBeatmapID;
+
+                        // check that no existing beatmap in database exists that is imported with the same online beatmap ID. if so, give it precedence.
+                        if (QueryBeatmap(b => b.OnlineBeatmapID.Value == ourId) != null)
+                            beatmap.BeatmapInfo.OnlineBeatmapID = null;
+
+                        // check that no other beatmap in this imported set has a conflicting online beatmap ID. If so, presume *all* are incorrect.
+                        if (beatmapInfos.Any(b => b.OnlineBeatmapID == ourId))
+                            invalidateOnlineIDs = true;
+                    }
 
                     RulesetInfo ruleset = rulesets.GetRuleset(beatmap.BeatmapInfo.RulesetID);
 
@@ -375,6 +399,9 @@ namespace osu.Game.Beatmaps
                 }
             }
 
+            if (invalidateOnlineIDs)
+                beatmapInfos.ForEach(b => b.OnlineBeatmapID = null);
+
             return beatmapInfos;
         }
 
@@ -382,9 +409,10 @@ namespace osu.Game.Beatmaps
         /// Query the API to populate mising OnlineBeatmapID / OnlineBeatmapSetID properties.
         /// </summary>
         /// <param name="beatmap">The beatmap to populate.</param>
+        /// <param name="otherBeatmaps">The other beatmaps contained within this set.</param>
         /// <param name="force">Whether to re-query if the provided beatmap already has populated values.</param>
         /// <returns>True if population was successful.</returns>
-        private bool fetchAndPopulateOnlineIDs(BeatmapInfo beatmap, bool force = false)
+        private bool fetchAndPopulateOnlineIDs(BeatmapInfo beatmap, IEnumerable<BeatmapInfo> otherBeatmaps, bool force = false)
         {
             if (!force && beatmap.OnlineBeatmapID != null && beatmap.BeatmapSet.OnlineBeatmapSetID != null)
                 return true;
@@ -404,6 +432,12 @@ namespace osu.Game.Beatmaps
 
                 Logger.Log($"Successfully mapped to {res.OnlineBeatmapSetID} / {res.OnlineBeatmapID}.", LoggingTarget.Database);
 
+                if (otherBeatmaps.Any(b => b.OnlineBeatmapID == res.OnlineBeatmapID))
+                {
+                    Logger.Log("Another beatmap in the same set already mapped to this ID. We'll skip adding it this time.", LoggingTarget.Database);
+                    return false;
+                }
+
                 beatmap.BeatmapSet.OnlineBeatmapSetID = res.OnlineBeatmapSetID;
                 beatmap.OnlineBeatmapID = res.OnlineBeatmapID;
                 return true;

osu.Game/Beatmaps/BeatmapMetadata.cs

@@ -14,7 +14,6 @@ namespace osu.Game.Beatmaps
     public class BeatmapMetadata : IEquatable<BeatmapMetadata>
     {
         [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
-        [JsonIgnore]
         public int ID { get; set; }
 
         public string Title { get; set; }

osu.Game/Beatmaps/Drawables/DifficultyColouredContainer.cs

@@ -9,14 +9,14 @@ using OpenTK.Graphics;
 
 namespace osu.Game.Beatmaps.Drawables
 {
-    public class DifficultyColouredContainer : Container, IHasAccentColour
+    public abstract class DifficultyColouredContainer : Container, IHasAccentColour
     {
         public Color4 AccentColour { get; set; }
 
         private readonly BeatmapInfo beatmap;
         private OsuColour palette;
 
-        public DifficultyColouredContainer(BeatmapInfo beatmap)
+        protected DifficultyColouredContainer(BeatmapInfo beatmap)
         {
             this.beatmap = beatmap;
         }

osu.Game/Beatmaps/Drawables/DifficultyIcon.cs

@@ -3,10 +3,14 @@
 
 using System;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using OpenTK;
+using OpenTK.Graphics;
 
 namespace osu.Game.Beatmaps.Drawables
 {
@@ -14,7 +18,8 @@ namespace osu.Game.Beatmaps.Drawables
     {
         private readonly BeatmapInfo beatmap;
 
-        public DifficultyIcon(BeatmapInfo beatmap) : base(beatmap)
+        public DifficultyIcon(BeatmapInfo beatmap)
+            : base(beatmap)
         {
             if (beatmap == null)
                 throw new ArgumentNullException(nameof(beatmap));
@@ -28,16 +33,29 @@ namespace osu.Game.Beatmaps.Drawables
         {
             Children = new Drawable[]
             {
-                new SpriteIcon
+                new CircularContainer
                 {
+                    RelativeSizeAxes = Axes.Both,
+                    Scale = new Vector2(0.84f),
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    RelativeSizeAxes = Axes.Both,
-                    Colour = AccentColour,
-                    Icon = FontAwesome.fa_circle
+                    Masking = true,
+                    EdgeEffect = new EdgeEffectParameters
+                    {
+                        Colour = Color4.Black.Opacity(0.08f),
+                        Type = EdgeEffectType.Shadow,
+                        Radius = 5,
+                    },
+                    Child = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = AccentColour,
+                    },
                 },
                 new ConstrainedIconContainer
                 {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.Both,
                     // the null coalesce here is only present to make unit tests work (ruleset dlls aren't copied correctly for testing at the moment)
                     Icon = beatmap.Ruleset?.CreateInstance().CreateIcon() ?? new SpriteIcon { Icon = FontAwesome.fa_question_circle_o }

osu.Game/Beatmaps/Formats/LegacyDecoder.cs

@@ -179,7 +179,7 @@ namespace osu.Game.Beatmaps.Formats
                 var baseInfo = base.ApplyTo(sampleInfo);
 
                 if (CustomSampleBank > 1)
-                    baseInfo.Name += CustomSampleBank;
+                    baseInfo.Suffix = CustomSampleBank.ToString();
 
                 return baseInfo;
             }

osu.Game/Database/ArchiveModelManager.cs

@@ -116,7 +116,7 @@ namespace osu.Game.Database
         /// <param name="paths">One or more archive locations on disk.</param>
         public void Import(params string[] paths)
         {
-            var notification = new ProgressNotification
+            var notification = new ImportNotification
             {
                 Text = "Import is initialising...",
                 Progress = 0,
@@ -407,5 +407,10 @@ namespace osu.Game.Database
                 return new LegacyFilesystemReader(path);
             throw new InvalidFormatException($"{path} is not a valid archive");
         }
+
+        private class ImportNotification : ProgressNotification
+        {
+            public override bool IsImportant => true;
+        }
     }
 }

osu.Game/Graphics/Containers/OsuFocusedOverlayContainer.cs

@@ -22,13 +22,16 @@ namespace osu.Game.Graphics.Containers
 
         protected virtual bool PlaySamplesOnStateChange => true;
 
+        protected override bool BlockPassThroughKeyboard => true;
+
         private PreviewTrackManager previewTrackManager;
 
+
         protected readonly Bindable<OverlayActivation> OverlayActivationMode = new Bindable<OverlayActivation>(OverlayActivation.All);
 
-        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
-            var dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
             dependencies.CacheAs<IPreviewTrackOwner>(this);
             return dependencies;
         }
@@ -67,12 +70,15 @@ namespace osu.Game.Graphics.Containers
             return base.OnClick(state);
         }
 
-        public bool OnPressed(GlobalAction action)
+        public virtual bool OnPressed(GlobalAction action)
         {
-            if (action == GlobalAction.Back)
+            switch (action)
             {
-                State = Visibility.Hidden;
-                return true;
+                case GlobalAction.Back:
+                    State = Visibility.Hidden;
+                    return true;
+                case GlobalAction.Select:
+                    return true;
             }
 
             return false;

osu.Game/Graphics/Cursor/MenuCursor.cs

@@ -22,7 +22,9 @@ 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 DragRotationState dragRotationState;
@@ -54,12 +56,12 @@ namespace osu.Game.Graphics.Cursor
                     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);
                 }
             }
 
@@ -68,11 +70,15 @@ namespace osu.Game.Graphics.Cursor
 
         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)
             {
@@ -86,36 +92,29 @@ namespace osu.Game.Graphics.Cursor
         {
             if (!state.Mouse.HasMainButtonPressed)
             {
-                ((Cursor)ActiveCursor).AdditiveLayer.FadeOut(500, Easing.OutQuint);
-                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);
+                    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

osu.Game/Graphics/Cursor/OsuTooltipContainer.cs

@@ -21,6 +21,8 @@ namespace osu.Game.Graphics.Cursor
         {
         }
 
+        protected override double AppearDelay => (1 - CurrentTooltip.Alpha) * base.AppearDelay; // reduce appear delay if the tooltip is already partly visible.
+
         public class OsuTooltip : Tooltip
         {
             private readonly Box background;

osu.Game/Input/Bindings/GlobalActionContainer.cs

@@ -39,7 +39,10 @@ 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[]
@@ -86,7 +89,7 @@ namespace osu.Game.Input.Bindings
         [Description("Toggle gameplay mouse buttons")]
         ToggleGameplayMouseButtons,
 
-        [Description("Go back")]
+        [Description("Back")]
         Back,
 
         [Description("Increase scroll speed")]
@@ -94,5 +97,8 @@ namespace osu.Game.Input.Bindings
 
         [Description("Decrease scroll speed")]
         DecreaseScrollSpeed,
+
+        [Description("Select")]
+        Select,
     }
 }

osu.Game/Migrations/20180621044111_UpdateTaikoDefaultBindings.cs

@@ -8,7 +8,6 @@ namespace osu.Game.Migrations
         protected override void Up(MigrationBuilder migrationBuilder)
         {
             migrationBuilder.Sql("DELETE FROM KeyBinding WHERE RulesetID = 1");
-            Logger.Log("osu!taiko bindings have been reset due to new defaults", LoggingTarget.Runtime, LogLevel.Important);
         }
 
         protected override void Down(MigrationBuilder migrationBuilder)

osu.Game/Online/API/Requests/Responses/APIScore.cs

@@ -63,7 +63,14 @@ namespace osu.Game.Online.API.Requests.Responses
         [JsonProperty(@"beatmapset")]
         private BeatmapMetadata metadata
         {
-            set => Beatmap.Metadata = value;
+            set
+            {
+                // extract the set ID to its correct place.
+                Beatmap.BeatmapSet = new BeatmapSetInfo { OnlineBeatmapSetID = value.ID };
+                value.ID = 0;
+
+                Beatmap.Metadata = value;
+            }
         }
 
         [JsonProperty(@"statistics")]

osu.Game/OsuGame.cs

@@ -19,10 +19,12 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework.Audio;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Platform;
 using osu.Framework.Threading;
+using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Overlays.Notifications;
@@ -33,6 +35,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Skinning;
 using OpenTK.Graphics;
 using osu.Game.Overlays.Volume;
+using osu.Game.Screens.Select;
 
 namespace osu.Game
 {
@@ -122,8 +125,8 @@ namespace osu.Game
 
         private DependencyContainer dependencies;
 
-        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent) =>
-            dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent) =>
+            dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
         [BackgroundDependencyLoader]
         private void load(FrameworkConfigManager frameworkConfig)
@@ -178,6 +181,41 @@ namespace osu.Game
         /// <param name="setId">The set to display.</param>
         public void ShowBeatmapSet(int setId) => beatmapSetOverlay.FetchAndShowBeatmapSet(setId);
 
+        /// <summary>
+        /// Present a beatmap at song select.
+        /// </summary>
+        /// <param name="beatmap">The beatmap to select.</param>
+        public void PresentBeatmap(BeatmapSetInfo beatmap)
+        {
+            CloseAllOverlays(false);
+
+            void setBeatmap()
+            {
+                if (Beatmap.Disabled)
+                {
+                    Schedule(setBeatmap);
+                    return;
+                }
+
+                Beatmap.Value = BeatmapManager.GetWorkingBeatmap(beatmap.Beatmaps.First());
+            }
+
+            switch (currentScreen)
+            {
+                case SongSelect _:
+                    break;
+                default:
+                    // navigate to song select if we are not already there.
+                    var menu = (MainMenu)intro.ChildScreen;
+
+                    menu.MakeCurrent();
+                    menu.LoadToSolo();
+                    break;
+            }
+
+            setBeatmap();
+        }
+
         /// <summary>
         /// Show a user's profile as an overlay.
         /// </summary>
@@ -244,6 +282,7 @@ namespace osu.Game
             BeatmapManager.PostNotification = n => notifications?.Post(n);
 
             BeatmapManager.GetStableStorage = GetStorageForStableInstall;
+            BeatmapManager.PresentBeatmap = PresentBeatmap;
 
             AddRange(new Drawable[]
             {
@@ -322,24 +361,6 @@ namespace osu.Game
             dependencies.Cache(notifications);
             dependencies.Cache(dialogOverlay);
 
-            // ensure only one of these overlays are open at once.
-            var singleDisplayOverlays = new OverlayContainer[] { chat, social, direct };
-            overlays.AddRange(singleDisplayOverlays);
-
-            foreach (var overlay in singleDisplayOverlays)
-            {
-                overlay.StateChanged += state =>
-                {
-                    if (state == Visibility.Hidden) return;
-
-                    foreach (var c in singleDisplayOverlays)
-                    {
-                        if (c == overlay) continue;
-                        c.State = Visibility.Hidden;
-                    }
-                };
-            }
-
             var singleDisplaySideOverlays = new OverlayContainer[] { settings, notifications };
             overlays.AddRange(singleDisplaySideOverlays);
 
@@ -348,12 +369,7 @@ namespace osu.Game
                 overlay.StateChanged += state =>
                 {
                     if (state == Visibility.Hidden) return;
-
-                    foreach (var c in singleDisplaySideOverlays)
-                    {
-                        if (c == overlay) continue;
-                        c.State = Visibility.Hidden;
-                    }
+                    singleDisplaySideOverlays.Where(o => o != overlay).ForEach(o => o.Hide());
                 };
             }
 
@@ -366,12 +382,24 @@ namespace osu.Game
                 overlay.StateChanged += state =>
                 {
                     if (state == Visibility.Hidden) return;
+                    informationalOverlays.Where(o => o != overlay).ForEach(o => o.Hide());
+                };
+            }
 
-                    foreach (var c in informationalOverlays)
-                    {
-                        if (c == overlay) continue;
-                        c.State = Visibility.Hidden;
-                    }
+            // ensure only one of these overlays are open at once.
+            var singleDisplayOverlays = new OverlayContainer[] { chat, social, direct };
+            overlays.AddRange(singleDisplayOverlays);
+
+            foreach (var overlay in singleDisplayOverlays)
+            {
+                overlay.StateChanged += state =>
+                {
+                    // informational overlays should be dismissed on a show or hide of a full overlay.
+                    informationalOverlays.ForEach(o => o.Hide());
+
+                    if (state == Visibility.Hidden) return;
+
+                    singleDisplayOverlays.Where(o => o != overlay).ForEach(o => o.Hide());
                 };
             }
 

osu.Game/OsuGameBase.cs

@@ -20,6 +20,7 @@ using osu.Game.Graphics.Cursor;
 using osu.Game.Online.API;
 using osu.Framework.Graphics.Performance;
 using osu.Framework.Graphics.Textures;
+using osu.Framework.Input;
 using osu.Framework.Logging;
 using osu.Game.Audio;
 using osu.Game.Database;
@@ -30,6 +31,7 @@ using osu.Game.IO;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;
+using OpenTK.Input;
 using DebugUtils = osu.Game.Utils.DebugUtils;
 
 namespace osu.Game
@@ -93,11 +95,13 @@ namespace osu.Game
 
         private DependencyContainer dependencies;
 
-        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent) =>
-            dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent) =>
+            dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
         private DatabaseContextFactory contextFactory;
 
+        protected override UserInputManager CreateUserInputManager() => new OsuUserInputManager();
+
         [BackgroundDependencyLoader]
         private void load()
         {
@@ -267,5 +271,31 @@ namespace osu.Game
                 return copy;
             }
         }
+
+        private class OsuUserInputManager : UserInputManager
+        {
+            protected override MouseButtonEventManager CreateButtonManagerFor(MouseButton button)
+            {
+                switch (button)
+                {
+                    case MouseButton.Right:
+                        return new RightMouseManager(button);
+                }
+
+                return base.CreateButtonManagerFor(button);
+            }
+
+            private class RightMouseManager : MouseButtonEventManager
+            {
+                public RightMouseManager(MouseButton button)
+                    : base(button)
+                {
+                }
+
+                public override bool EnableDrag => true; // allow right-mouse dragging for absolute scroll in scroll containers.
+                public override bool EnableClick => false;
+                public override bool ChangeFocusOnClick => false;
+            }
+        }
     }
 }

osu.Game/Overlays/Dialog/PopupDialog.cs

@@ -13,6 +13,7 @@ using osu.Game.Graphics;
 using osu.Game.Graphics.Backgrounds;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Input.Bindings;
 using OpenTK;
 using OpenTK.Graphics;
 using OpenTK.Input;
@@ -192,16 +193,22 @@ namespace osu.Game.Overlays.Dialog
             };
         }
 
+        public override bool OnPressed(GlobalAction action)
+        {
+            switch (action)
+            {
+                case GlobalAction.Select:
+                    Buttons.OfType<PopupDialogOkButton>().FirstOrDefault()?.TriggerOnClick();
+                    return true;
+            }
+
+            return base.OnPressed(action);
+        }
+
         protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
         {
             if (args.Repeat) return false;
 
-            if (args.Key == Key.Enter || args.Key == Key.KeypadEnter)
-            {
-                Buttons.OfType<PopupDialogOkButton>().FirstOrDefault()?.TriggerOnClick();
-                return true;
-            }
-
             // press button at number if 1-9 on number row or keypad are pressed
             var k = args.Key;
             if (k >= Key.Number1 && k <= Key.Number9)

osu.Game/Overlays/KeyBinding/KeyBindingRow.cs

@@ -102,6 +102,7 @@ namespace osu.Game.Overlays.KeyBinding
                     RelativeSizeAxes = Axes.X,
                     AutoSizeAxes = Axes.Y,
                     Margin = new MarginPadding(padding),
+                    Padding = new MarginPadding { Top = height },
                     Alpha = 0,
                     Colour = colours.YellowDark
                 }
@@ -267,7 +268,7 @@ namespace osu.Game.Overlays.KeyBinding
                 GetContainingInputManager().ChangeFocus(null);
 
             pressAKey.FadeOut(300, Easing.OutQuint);
-            pressAKey.Padding = new MarginPadding { Top = height, Bottom = -pressAKey.DrawHeight };
+            pressAKey.BypassAutoSizeAxes |= Axes.Y;
         }
 
         protected override void OnFocus(InputState state)
@@ -276,7 +277,7 @@ namespace osu.Game.Overlays.KeyBinding
             AutoSizeEasing = Easing.OutQuint;
 
             pressAKey.FadeIn(300, Easing.OutQuint);
-            pressAKey.Padding = new MarginPadding { Top = height };
+            pressAKey.BypassAutoSizeAxes &= ~Axes.Y;
 
             updateBindTarget();
             base.OnFocus(state);

osu.Game/Overlays/Mods/ModSelectOverlay.cs

@@ -44,6 +44,8 @@ namespace osu.Game.Overlays.Mods
 
         private void rulesetChanged(RulesetInfo newRuleset)
         {
+            if (newRuleset == null) return;
+
             var instance = newRuleset.CreateInstance();
 
             foreach (ModSection section in ModSectionsContainer.Children)
@@ -173,7 +175,10 @@ namespace osu.Game.Overlays.Mods
             refreshSelectedMods();
         }
 
-        private void refreshSelectedMods() => SelectedMods.Value = ModSectionsContainer.Children.SelectMany(s => s.SelectedMods).ToArray();
+        private void refreshSelectedMods()
+        {
+            SelectedMods.Value = ModSectionsContainer.Children.SelectMany(s => s.SelectedMods).ToArray();
+        }
 
         public ModSelectOverlay()
         {

osu.Game/Overlays/NotificationOverlay.cs

@@ -128,7 +128,8 @@ namespace osu.Game.Overlays
             var section = sections.Children.FirstOrDefault(s => s.AcceptTypes.Any(accept => accept.IsAssignableFrom(ourType)));
             section?.Add(notification, notification.DisplayOnTop ? -runningDepth : runningDepth);
 
-            State = Visibility.Visible;
+            if (notification.IsImportant)
+                State = Visibility.Visible;
 
             updateCounts();
         });

osu.Game/Overlays/Notifications/Notification.cs

@@ -23,6 +23,11 @@ namespace osu.Game.Overlays.Notifications
         /// </summary>
         public event Action Closed;
 
+        /// <summary>
+        /// Whether this notification should forcefully display itself.
+        /// </summary>
+        public virtual bool IsImportant => false;
+
         /// <summary>
         /// Run on user activating the notification. Return true to close.
         /// </summary>

osu.Game/Overlays/OnScreenDisplay.cs

@@ -14,6 +14,8 @@ using osu.Game.Graphics;
 using OpenTK;
 using OpenTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics.Transforms;
+using osu.Framework.Threading;
 using osu.Game.Configuration;
 using osu.Game.Graphics.Sprites;
 
@@ -135,7 +137,7 @@ namespace osu.Game.Overlays
         /// <exception cref="InvalidOperationException">If <paramref name="configManager"/> is already being tracked from the same <paramref name="source"/>.</exception>
         public void BeginTracking(object source, ITrackableConfigManager configManager)
         {
-            if (configManager == null)　throw new ArgumentNullException(nameof(configManager));
+            if (configManager == null) throw new ArgumentNullException(nameof(configManager));
 
             if (trackedConfigManagers.ContainsKey((source, configManager)))
                 throw new InvalidOperationException($"{nameof(configManager)} is already registered.");
@@ -159,7 +161,7 @@ namespace osu.Game.Overlays
         /// <exception cref="InvalidOperationException">If <paramref name="configManager"/> is not being tracked from the same <see cref="source"/>.</exception>
         public void StopTracking(object source, ITrackableConfigManager configManager)
         {
-            if (configManager == null)　throw new ArgumentNullException(nameof(configManager));
+            if (configManager == null) throw new ArgumentNullException(nameof(configManager));
 
             if (!trackedConfigManagers.TryGetValue((source, configManager), out var existing))
                 throw new InvalidOperationException($"{nameof(configManager)} is not registered.");
@@ -181,7 +183,7 @@ namespace osu.Game.Overlays
                 if (string.IsNullOrEmpty(textLine3.Text))
                     textLine3.Text = "NO KEY BOUND";
 
-                Display(box);
+                DisplayTemporarily(box);
 
                 int optionCount = 0;
                 int selectedOption = -1;
@@ -213,15 +215,29 @@ namespace osu.Game.Overlays
             });
         }
 
-        protected virtual void Display(Drawable toDisplay)
+        private TransformSequence<Drawable> fadeIn;
+        private ScheduledDelegate fadeOut;
+
+        protected virtual void DisplayTemporarily(Drawable toDisplay)
         {
-            toDisplay.Animate(
-                b => b.FadeIn(500, Easing.OutQuint),
-                b => b.ResizeHeightTo(height, 500, Easing.OutQuint)
-            ).Then(
-                b => b.FadeOutFromOne(1500, Easing.InQuint),
-                b => b.ResizeHeightTo(height_contracted, 1500, Easing.InQuint)
-            );
+            // avoid starting a new fade-in if one is already active.
+            if (fadeIn == null)
+            {
+                fadeIn = toDisplay.Animate(
+                    b => b.FadeIn(500, Easing.OutQuint),
+                    b => b.ResizeHeightTo(height, 500, Easing.OutQuint)
+                );
+
+                fadeIn.Finally(_ => fadeIn = null);
+            }
+
+            fadeOut?.Cancel();
+            fadeOut = Scheduler.AddDelayed(() =>
+            {
+                toDisplay.Animate(
+                    b => b.FadeOutFromOne(1500, Easing.InQuint),
+                    b => b.ResizeHeightTo(height_contracted, 1500, Easing.InQuint));
+            }, 500);
         }
 
         private class OptionLight : Container

osu.Game/Overlays/Profile/ProfileHeader.cs

@@ -158,6 +158,13 @@ namespace osu.Game.Overlays.Profile
                         }
                     }
                 },
+                new Box // this is a temporary workaround for incorrect masking behaviour of FillMode.Fill used in UserCoverBackground (see https://github.com/ppy/osu-framework/issues/1675)
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = 1,
+                    Y = cover_height,
+                    Colour = OsuColour.Gray(34),
+                },
                 infoTextLeft = new LinkFlowContainer(t => t.TextSize = 14)
                 {
                     X = UserProfileOverlay.CONTENT_X_MARGIN,
@@ -360,11 +367,6 @@ namespace osu.Game.Overlays.Profile
                 Text = text
             };
 
-            if (user.Age != null)
-            {
-                infoTextLeft.AddText($"{user.Age} years old ", boldItalic);
-            }
-
             if (user.Country != null)
             {
                 infoTextLeft.AddText("From ", lightText);

osu.Game/Overlays/Profile/Sections/BeatmapMetadataContainer.cs

@@ -9,6 +9,7 @@ using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
+
 namespace osu.Game.Overlays.Profile.Sections
 {
     /// <summary>
@@ -32,7 +33,10 @@ namespace osu.Game.Overlays.Profile.Sections
         {
             Action = () =>
             {
-                if (beatmap.BeatmapSet?.OnlineBeatmapSetID != null) beatmapSetOverlay?.FetchAndShowBeatmapSet(beatmap.BeatmapSet.OnlineBeatmapSetID.Value);
+                if (beatmap.OnlineBeatmapID != null)
+                    beatmapSetOverlay?.FetchAndShowBeatmap(beatmap.OnlineBeatmapID.Value);
+                else if (beatmap.BeatmapSet?.OnlineBeatmapSetID != null)
+                    beatmapSetOverlay?.FetchAndShowBeatmapSet(beatmap.BeatmapSet.OnlineBeatmapSetID.Value);
             };
 
             Child = new FillFlowContainer

osu.Game/Overlays/Settings/RulesetSettingsSubsection.cs

@@ -3,6 +3,7 @@
 
 using osu.Framework.Allocation;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Configuration;
 
 namespace osu.Game.Overlays.Settings
 {
@@ -14,6 +15,8 @@ namespace osu.Game.Overlays.Settings
     {
         private readonly Ruleset ruleset;
 
+        protected IRulesetConfigManager Config;
+
         protected RulesetSettingsSubsection(Ruleset ruleset)
         {
             this.ruleset = ruleset;
@@ -21,13 +24,13 @@ namespace osu.Game.Overlays.Settings
 
         private DependencyContainer dependencies;
 
-        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
-            dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+            dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
-            var config = dependencies.Get<RulesetConfigCache>().GetConfigFor(ruleset);
-            if (config != null)
-                dependencies.Cache(config);
+            Config = dependencies.Get<RulesetConfigCache>().GetConfigFor(ruleset);
+            if (Config != null)
+                dependencies.Cache(Config);
 
             return dependencies;
         }

osu.Game/Overlays/Settings/Sections/Audio/OffsetSettings.cs

@@ -21,7 +21,7 @@ namespace osu.Game.Overlays.Settings.Sections.Audio
                 {
                     LabelText = "Audio Offset",
                     Bindable = config.GetBindable<double>(OsuSetting.AudioOffset),
-                    KeyboardStep = 100f
+                    KeyboardStep = 1f
                 },
                 new SettingsButton
                 {

osu.Game/Overlays/Settings/Sections/Audio/VolumeSettings.cs

@@ -17,10 +17,10 @@ namespace osu.Game.Overlays.Settings.Sections.Audio
         {
             Children = new Drawable[]
             {
-                new SettingsSlider<double> { LabelText = "Master", Bindable = audio.Volume, KeyboardStep = 0.1f },
-                new SettingsSlider<double> { LabelText = "Master (Window Inactive)", Bindable = config.GetBindable<double>(OsuSetting.VolumeInactive), KeyboardStep = 0.1f },
-                new SettingsSlider<double> { LabelText = "Effect", Bindable = audio.VolumeSample, KeyboardStep = 0.1f },
-                new SettingsSlider<double> { LabelText = "Music", Bindable = audio.VolumeTrack, KeyboardStep = 0.1f },
+                new SettingsSlider<double> { LabelText = "Master", Bindable = audio.Volume, KeyboardStep = 0.01f },
+                new SettingsSlider<double> { LabelText = "Master (Window Inactive)", Bindable = config.GetBindable<double>(OsuSetting.VolumeInactive), KeyboardStep = 0.01f },
+                new SettingsSlider<double> { LabelText = "Effect", Bindable = audio.VolumeSample, KeyboardStep = 0.01f },
+                new SettingsSlider<double> { LabelText = "Music", Bindable = audio.VolumeTrack, KeyboardStep = 0.01f },
             };
         }
     }

osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs

@@ -21,13 +21,13 @@ namespace osu.Game.Overlays.Settings.Sections.Gameplay
                 {
                     LabelText = "Background dim",
                     Bindable = config.GetBindable<double>(OsuSetting.DimLevel),
-                    KeyboardStep = 0.1f
+                    KeyboardStep = 0.01f
                 },
                 new SettingsSlider<double>
                 {
                     LabelText = "Background blur",
                     Bindable = config.GetBindable<double>(OsuSetting.BlurLevel),
-                    KeyboardStep = 0.1f
+                    KeyboardStep = 0.01f
                 },
                 new SettingsCheckbox
                 {

osu.Game/Overlays/Settings/Sections/Gameplay/SongSelectSettings.cs

@@ -31,13 +31,13 @@ namespace osu.Game.Overlays.Settings.Sections.Gameplay
                 {
                     LabelText = "Display beatmaps from",
                     Bindable = config.GetBindable<double>(OsuSetting.DisplayStarsMinimum),
-                    KeyboardStep = 1f
+                    KeyboardStep = 0.1f
                 },
                 new SettingsSlider<double, StarSlider>
                 {
                     LabelText = "up to",
                     Bindable = config.GetBindable<double>(OsuSetting.DisplayStarsMaximum),
-                    KeyboardStep = 1f
+                    KeyboardStep = 0.1f
                 },
                 new SettingsEnumDropdown<RandomSelectAlgorithm>
                 {

osu.Game/Overlays/Settings/Sections/Graphics/LayoutSettings.cs

@@ -50,13 +50,13 @@ namespace osu.Game.Overlays.Settings.Sections.Graphics
                         {
                             LabelText = "Horizontal position",
                             Bindable = config.GetBindable<double>(FrameworkSetting.LetterboxPositionX),
-                            KeyboardStep = 0.1f
+                            KeyboardStep = 0.01f
                         },
                         new SettingsSlider<double>
                         {
                             LabelText = "Vertical position",
                             Bindable = config.GetBindable<double>(FrameworkSetting.LetterboxPositionY),
-                            KeyboardStep = 0.1f
+                            KeyboardStep = 0.01f
                         },
                     }
                 },

osu.Game/Overlays/Settings/Sections/SkinSection.cs

@@ -36,13 +36,13 @@ namespace osu.Game.Overlays.Settings.Sections
                 {
                     LabelText = "Menu cursor size",
                     Bindable = config.GetBindable<double>(OsuSetting.MenuCursorSize),
-                    KeyboardStep = 0.1f
+                    KeyboardStep = 0.01f
                 },
                 new SettingsSlider<double, SizeSlider>
                 {
                     LabelText = "Gameplay cursor size",
                     Bindable = config.GetBindable<double>(OsuSetting.GameplayCursorSize),
-                    KeyboardStep = 0.1f
+                    KeyboardStep = 0.01f
                 },
                 new SettingsCheckbox
                 {

osu.Game/Overlays/Toolbar/Toolbar.cs

@@ -50,7 +50,7 @@ namespace osu.Game.Overlays.Toolbar
                         {
                             Action = () => OnHome?.Invoke()
                         },
-                        new ToolbarModeSelector()
+                        new ToolbarRulesetSelector()
                     }
                 },
                 new FillFlowContainer

osu.Game/Overlays/Toolbar/ToolbarRulesetButton.cs

@@ -7,7 +7,7 @@ using OpenTK.Graphics;
 
 namespace osu.Game.Overlays.Toolbar
 {
-    public class ToolbarModeButton : ToolbarButton
+    public class ToolbarRulesetButton : ToolbarButton
     {
         private RulesetInfo ruleset;
         public RulesetInfo Ruleset

osu.Game/Overlays/Toolbar/ToolbarRulesetSelector.cs

@@ -16,18 +16,18 @@ using osu.Game.Rulesets;
 
 namespace osu.Game.Overlays.Toolbar
 {
-    public class ToolbarModeSelector : Container
+    public class ToolbarRulesetSelector : Container
     {
         private const float padding = 10;
 
         private readonly FillFlowContainer modeButtons;
         private readonly Drawable modeButtonLine;
-        private ToolbarModeButton activeButton;
+        private ToolbarRulesetButton activeButton;
 
         private RulesetStore rulesets;
         private readonly Bindable<RulesetInfo> ruleset = new Bindable<RulesetInfo>();
 
-        public ToolbarModeSelector()
+        public ToolbarRulesetSelector()
         {
             RelativeSizeAxes = Axes.Y;
 
@@ -73,7 +73,7 @@ namespace osu.Game.Overlays.Toolbar
             this.rulesets = rulesets;
             foreach (var r in rulesets.AvailableRulesets)
             {
-                modeButtons.Add(new ToolbarModeButton
+                modeButtons.Add(new ToolbarRulesetButton
                 {
                     Ruleset = r,
                     Action = delegate { ruleset.Value = r; }
@@ -115,7 +115,7 @@ namespace osu.Game.Overlays.Toolbar
 
         private void rulesetChanged(RulesetInfo ruleset)
         {
-            foreach (ToolbarModeButton m in modeButtons.Children.Cast<ToolbarModeButton>())
+            foreach (ToolbarRulesetButton m in modeButtons.Children.Cast<ToolbarRulesetButton>())
             {
                 bool isActive = m.Ruleset.ID == ruleset.ID;
                 m.Active = isActive;

osu.Game/Rulesets/Mods/ModAutoplay.cs

@@ -11,7 +11,7 @@ using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Mods
 {
-    public class ModAutoplay<T> : ModAutoplay, IApplicableToRulesetContainer<T>
+    public abstract class ModAutoplay<T> : ModAutoplay, IApplicableToRulesetContainer<T>
         where T : HitObject
     {
         protected virtual Score CreateReplayScore(Beatmap<T> beatmap) => new Score { Replay = new Replay() };

osu.Game/Rulesets/UI/RulesetContainer.cs

@@ -70,7 +70,8 @@ namespace osu.Game.Rulesets.UI
 
         protected readonly Ruleset Ruleset;
 
-        private IRulesetConfigManager rulesetConfig;
+        protected IRulesetConfigManager Config { get; private set; }
+
         private OnScreenDisplay onScreenDisplay;
 
         /// <summary>
@@ -85,17 +86,17 @@ namespace osu.Game.Rulesets.UI
             Cursor = CreateCursor();
         }
 
-        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
-            var dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
             onScreenDisplay = dependencies.Get<OnScreenDisplay>();
 
-            rulesetConfig = dependencies.Get<RulesetConfigCache>().GetConfigFor(Ruleset);
-            if (rulesetConfig != null)
+            Config = dependencies.Get<RulesetConfigCache>().GetConfigFor(Ruleset);
+            if (Config != null)
             {
-                dependencies.Cache(rulesetConfig);
-                onScreenDisplay?.BeginTracking(this, rulesetConfig);
+                dependencies.Cache(Config);
+                onScreenDisplay?.BeginTracking(this, Config);
             }
 
             return dependencies;
@@ -143,10 +144,10 @@ namespace osu.Game.Rulesets.UI
         {
             base.Dispose(isDisposing);
 
-            if (rulesetConfig != null)
+            if (Config != null)
             {
-                onScreenDisplay?.StopTracking(this, rulesetConfig);
-                rulesetConfig = null;
+                onScreenDisplay?.StopTracking(this, Config);
+                Config = null;
             }
         }
     }

osu.Game/Rulesets/UI/RulesetInputManager.cs

@@ -222,23 +222,16 @@ namespace osu.Game.Rulesets.UI
             mouseDisabled = config.GetBindable<bool>(OsuSetting.MouseDisableButtons);
         }
 
-        protected override void TransformState(InputState state)
+        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
         {
-            base.TransformState(state);
+            if (mouseDisabled.Value && (args.Button == MouseButton.Left || args.Button == MouseButton.Right)) return false;
+            return base.OnMouseDown(state, args);
+        }
 
-            // we don't want to transform the state if a replay is present (for now, at least).
-            if (replayInputHandler != null) return;
-
-            var mouse = state.Mouse as Framework.Input.MouseState;
-
-            if (mouse != null)
-            {
-                if (mouseDisabled.Value)
-                {
-                    mouse.SetPressed(MouseButton.Left, false);
-                    mouse.SetPressed(MouseButton.Right, false);
-                }
-            }
+        protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+        {
+            if (!CurrentState.Mouse.IsPressed(args.Button)) return false;
+            return base.OnMouseUp(state, args);
         }
 
         #endregion

osu.Game/Screens/Edit/Editor.cs

@@ -42,8 +42,8 @@ namespace osu.Game.Screens.Edit
         private DependencyContainer dependencies;
         private GameHost host;
 
-        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
-            => dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+            => dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
         [BackgroundDependencyLoader]
         private void load(OsuColour colours, GameHost host)

osu.Game/Screens/Menu/Button.cs

@@ -35,6 +35,12 @@ namespace osu.Game.Screens.Menu
         private readonly Box boxHoverLayer;
         private readonly SpriteIcon icon;
         private readonly string sampleName;
+
+        /// <summary>
+        /// The menu state for which we are visible for.
+        /// </summary>
+        public ButtonSystemState VisibleState = ButtonSystemState.TopLevel;
+
         private readonly Action clickAction;
         private readonly Key triggerKey;
         private SampleChannel sampleClick;
@@ -51,7 +57,7 @@ namespace osu.Game.Screens.Menu
             AutoSizeAxes = Axes.Both;
             Alpha = 0;
 
-            Vector2 boxSize = new Vector2(ButtonSystem.BUTTON_WIDTH + Math.Abs(extraWidth), ButtonSystem.BUTTON_AREA_HEIGHT);
+            Vector2 boxSize = new Vector2(ButtonSystem.BUTTON_WIDTH + Math.Abs(extraWidth), ButtonArea.BUTTON_AREA_HEIGHT);
 
             Children = new Drawable[]
             {
@@ -260,6 +266,7 @@ namespace osu.Game.Screens.Menu
                                 this.FadeOut(800);
                                 break;
                         }
+
                         break;
                     case ButtonState.Expanded:
                         const int expand_duration = 500;
@@ -276,6 +283,33 @@ namespace osu.Game.Screens.Menu
                 StateChanged?.Invoke(State);
             }
         }
+
+        public ButtonSystemState ButtonSystemState
+        {
+            set
+            {
+                ContractStyle = 0;
+
+                switch (value)
+                {
+                    case ButtonSystemState.Initial:
+                        State = ButtonState.Contracted;
+                        break;
+                    case ButtonSystemState.EnteringMode:
+                        ContractStyle = 1;
+                        State = ButtonState.Contracted;
+                        break;
+                    default:
+                        if (value == VisibleState)
+                            State = ButtonState.Expanded;
+                        else if (value < VisibleState)
+                            State = ButtonState.Contracted;
+                        else
+                            State = ButtonState.Exploded;
+                        break;
+                }
+            }
+        }
     }
 
     public enum ButtonState

osu.Game/Screens/Menu/ButtonArea.cs

@@ -0,0 +1,148 @@
+// 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 osu.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using OpenTK;
+
+namespace osu.Game.Screens.Menu
+{
+    public class ButtonArea : Container, IStateful<Visibility>
+    {
+        public FlowContainerWithOrigin Flow;
+
+        protected override Container<Drawable> Content => Flow;
+
+        private readonly ButtonAreaBackground buttonAreaBackground;
+        private Visibility state;
+
+        public const float BUTTON_AREA_HEIGHT = 100;
+
+        public ButtonArea()
+        {
+            RelativeSizeAxes = Axes.Both;
+            InternalChild = new Container
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.X,
+                Size = new Vector2(1, BUTTON_AREA_HEIGHT),
+                Alpha = 0,
+                Children = new Drawable[]
+                {
+                    buttonAreaBackground = new ButtonAreaBackground(),
+                    Flow = new FlowContainerWithOrigin
+                    {
+                        Direction = FillDirection.Horizontal,
+                        Spacing = new Vector2(-ButtonSystem.WEDGE_WIDTH, 0),
+                        Anchor = Anchor.Centre,
+                        AutoSizeAxes = Axes.Both,
+                    }
+                }
+            };
+        }
+
+        public ButtonSystemState ButtonSystemState
+        {
+            set
+            {
+                switch (value)
+                {
+                    case ButtonSystemState.Exit:
+                    case ButtonSystemState.Initial:
+                    case ButtonSystemState.EnteringMode:
+                        State = Visibility.Hidden;
+                        break;
+                    case ButtonSystemState.TopLevel:
+                    case ButtonSystemState.Play:
+                        State = Visibility.Visible;
+                        break;
+                }
+
+                buttonAreaBackground.ButtonSystemState = value;
+            }
+        }
+
+        public Visibility State
+        {
+            get => state;
+            set
+            {
+                if (value == state) return;
+
+                state = value;
+                InternalChild.FadeTo(state == Visibility.Hidden ? 0 : 1, 300);
+                StateChanged?.Invoke(state);
+            }
+        }
+
+        public event Action<Visibility> StateChanged;
+
+        private class ButtonAreaBackground : Box, IStateful<ButtonAreaBackgroundState>
+        {
+            private ButtonAreaBackgroundState state;
+
+            public ButtonAreaBackground()
+            {
+                RelativeSizeAxes = Axes.Both;
+                Size = new Vector2(2, 1);
+                Colour = OsuColour.Gray(50);
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+            }
+
+            public ButtonAreaBackgroundState State
+            {
+                get => state;
+                set
+                {
+                    if (value == state) return;
+
+                    state = value;
+
+                    switch (state)
+                    {
+                        case ButtonAreaBackgroundState.Flat:
+                            this.ScaleTo(new Vector2(2, 0), 300, Easing.InSine);
+                            break;
+                        case ButtonAreaBackgroundState.Normal:
+                            this.ScaleTo(Vector2.One, 400, Easing.OutQuint);
+                            break;
+                    }
+
+                    StateChanged?.Invoke(state);
+                }
+            }
+
+            public ButtonSystemState ButtonSystemState
+            {
+                set
+                {
+                    switch (value)
+                    {
+                        default:
+                            State = ButtonAreaBackgroundState.Normal;
+                            break;
+                        case ButtonSystemState.Initial:
+                        case ButtonSystemState.Exit:
+                        case ButtonSystemState.EnteringMode:
+                            State = ButtonAreaBackgroundState.Flat;
+                            break;
+                    }
+                }
+            }
+
+            public event Action<ButtonAreaBackgroundState> StateChanged;
+        }
+
+        public enum ButtonAreaBackgroundState
+        {
+            Normal,
+            Flat
+        }
+    }
+}

osu.Game/Screens/Menu/ButtonSystem.cs

@@ -10,9 +10,8 @@ using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
+using osu.Framework.Logging;
 using osu.Framework.Threading;
 using osu.Game.Graphics;
 using osu.Game.Input.Bindings;
@@ -23,9 +22,9 @@ using OpenTK.Input;
 
 namespace osu.Game.Screens.Menu
 {
-    public class ButtonSystem : Container, IStateful<MenuState>, IKeyBindingHandler<GlobalAction>
+    public class ButtonSystem : Container, IStateful<ButtonSystemState>, IKeyBindingHandler<GlobalAction>
     {
-        public event Action<MenuState> StateChanged;
+        public event Action<ButtonSystemState> StateChanged;
 
         public Action OnEdit;
         public Action OnExit;
@@ -34,12 +33,6 @@ namespace osu.Game.Screens.Menu
         public Action OnSettings;
         public Action OnMulti;
         public Action OnChart;
-        public Action OnTest;
-
-        private readonly FlowContainerWithOrigin buttonFlow;
-
-        //todo: make these non-internal somehow.
-        public const float BUTTON_AREA_HEIGHT = 100;
 
         public const float BUTTON_WIDTH = 140f;
         public const float WEDGE_WIDTH = 20;
@@ -55,18 +48,16 @@ namespace osu.Game.Screens.Menu
                 this.logo.Action = onOsuLogo;
 
                 // osuLogo.SizeForFlow relies on loading to be complete.
-                buttonFlow.Position = new Vector2(WEDGE_WIDTH * 2 - (BUTTON_WIDTH + this.logo.SizeForFlow / 4), 0);
+                buttonArea.Flow.Position = new Vector2(WEDGE_WIDTH * 2 - (BUTTON_WIDTH + this.logo.SizeForFlow / 4), 0);
 
                 updateLogoState();
             }
         }
 
         private readonly Drawable iconFacade;
-        private readonly Container buttonArea;
-        private readonly Box buttonAreaBackground;
+        private readonly ButtonArea buttonArea;
 
         private readonly Button backButton;
-        private readonly Button settingsButton;
 
         private readonly List<Button> buttonsTopLevel = new List<Button>();
         private readonly List<Button> buttonsPlay = new List<Button>();
@@ -77,57 +68,35 @@ namespace osu.Game.Screens.Menu
         {
             RelativeSizeAxes = Axes.Both;
 
-            Children = new Drawable[]
+            Child = buttonArea = new ButtonArea();
+
+            buttonArea.AddRange(new[]
             {
-                buttonArea = new Container
+                new Button(@"settings", string.Empty, FontAwesome.fa_gear, new Color4(85, 85, 85, 255), () => OnSettings?.Invoke(), -WEDGE_WIDTH, Key.O),
+                backButton = new Button(@"back", @"button-back-select", FontAwesome.fa_osu_left_o, new Color4(51, 58, 94, 255), () => State = ButtonSystemState.TopLevel, -WEDGE_WIDTH)
                 {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    RelativeSizeAxes = Axes.X,
-                    Size = new Vector2(1, BUTTON_AREA_HEIGHT),
-                    Alpha = 0,
-                    Children = new Drawable[]
-                    {
-                        buttonAreaBackground = new Box
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            Size = new Vector2(2, 1),
-                            Colour = OsuColour.Gray(50),
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.Centre,
-                        },
-                        buttonFlow = new FlowContainerWithOrigin
-                        {
-                            Direction = FillDirection.Horizontal,
-                            Spacing = new Vector2(-WEDGE_WIDTH, 0),
-                            Anchor = Anchor.Centre,
-                            AutoSizeAxes = Axes.Both,
-                            Children = new[]
-                            {
-                                settingsButton = new Button(@"settings", string.Empty, FontAwesome.fa_gear, new Color4(85, 85, 85, 255), () => OnSettings?.Invoke(), -WEDGE_WIDTH, Key.O),
-                                backButton = new Button(@"back", string.Empty, FontAwesome.fa_osu_left_o, new Color4(51, 58, 94, 255), onBack, -WEDGE_WIDTH),
-                                iconFacade = new Container //need a container to make the osu! icon flow properly.
-                                {
-                                    Size = new Vector2(0, BUTTON_AREA_HEIGHT)
-                                }
-                            },
-                            CentreTarget = iconFacade
-                        }
-                    }
+                    VisibleState = ButtonSystemState.Play,
                 },
-            };
+                iconFacade = new Container //need a container to make the osu! icon flow properly.
+                {
+                    Size = new Vector2(0, ButtonArea.BUTTON_AREA_HEIGHT)
+                }
+            });
+
+            buttonArea.Flow.CentreTarget = iconFacade;
 
             buttonsPlay.Add(new Button(@"solo", @"button-solo-select", FontAwesome.fa_user, new Color4(102, 68, 204, 255), () => OnSolo?.Invoke(), WEDGE_WIDTH, Key.P));
             buttonsPlay.Add(new Button(@"multi", @"button-generic-select", FontAwesome.fa_users, new Color4(94, 63, 186, 255), () => OnMulti?.Invoke(), 0, Key.M));
             buttonsPlay.Add(new Button(@"chart", @"button-generic-select", FontAwesome.fa_osu_charts, new Color4(80, 53, 160, 255), () => OnChart?.Invoke()));
+            buttonsPlay.ForEach(b => b.VisibleState = ButtonSystemState.Play);
 
-            buttonsTopLevel.Add(new Button(@"play", @"button-play-select", FontAwesome.fa_osu_logo, new Color4(102, 68, 204, 255), onPlay, WEDGE_WIDTH, Key.P));
+            buttonsTopLevel.Add(new Button(@"play", @"button-play-select", FontAwesome.fa_osu_logo, new Color4(102, 68, 204, 255), () => State = ButtonSystemState.Play, WEDGE_WIDTH, Key.P));
             buttonsTopLevel.Add(new Button(@"osu!editor", @"button-generic-select", FontAwesome.fa_osu_edit_o, new Color4(238, 170, 0, 255), () => OnEdit?.Invoke(), 0, Key.E));
             buttonsTopLevel.Add(new Button(@"osu!direct", @"button-direct-select", FontAwesome.fa_osu_chevron_down_o, new Color4(165, 204, 0, 255), () => OnDirect?.Invoke(), 0, Key.D));
-            buttonsTopLevel.Add(new Button(@"exit", string.Empty, FontAwesome.fa_osu_cross_o, new Color4(238, 51, 153, 255), onExit, 0, Key.Q));
+            buttonsTopLevel.Add(new Button(@"exit", string.Empty, FontAwesome.fa_osu_cross_o, new Color4(238, 51, 153, 255), () => OnExit?.Invoke(), 0, Key.Q));
 
-            buttonFlow.AddRange(buttonsPlay);
-            buttonFlow.AddRange(buttonsTopLevel);
+            buttonArea.AddRange(buttonsPlay);
+            buttonArea.AddRange(buttonsTopLevel);
         }
 
         private OsuGame game;
@@ -139,40 +108,14 @@ namespace osu.Game.Screens.Menu
             sampleBack = audio.Sample.Get(@"Menu/button-back-select");
         }
 
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
-        {
-            if (args.Repeat) return false;
-
-            switch (args.Key)
-            {
-                case Key.Space:
-                    logo?.TriggerOnClick(state);
-                    return true;
-            }
-
-            return false;
-        }
-
         public bool OnPressed(GlobalAction action)
         {
             switch (action)
             {
                 case GlobalAction.Back:
                     return goBack();
-                default:
-                    return false;
-            }
-        }
-
-        private bool goBack()
-        {
-            switch (State)
-            {
-                case MenuState.TopLevel:
-                    State = MenuState.Initial;
-                    return true;
-                case MenuState.Play:
-                    backButton.TriggerOnClick();
+                case GlobalAction.Select:
+                    logo?.TriggerOnClick();
                     return true;
                 default:
                     return false;
@@ -181,20 +124,20 @@ namespace osu.Game.Screens.Menu
 
         public bool OnReleased(GlobalAction action) => false;
 
-        private void onPlay()
+        private bool goBack()
         {
-            State = MenuState.Play;
-        }
-
-        private void onExit()
-        {
-            OnExit?.Invoke();
-        }
-
-        private void onBack()
-        {
-            sampleBack?.Play();
-            State = MenuState.TopLevel;
+            switch (State)
+            {
+                case ButtonSystemState.TopLevel:
+                    State = ButtonSystemState.Initial;
+                    sampleBack?.Play();
+                    return true;
+                case ButtonSystemState.Play:
+                    backButton.TriggerOnClick();
+                    return true;
+                default:
+                    return false;
+            }
         }
 
         private bool onOsuLogo()
@@ -203,24 +146,24 @@ namespace osu.Game.Screens.Menu
             {
                 default:
                     return true;
-                case MenuState.Initial:
-                    State = MenuState.TopLevel;
+                case ButtonSystemState.Initial:
+                    State = ButtonSystemState.TopLevel;
                     return true;
-                case MenuState.TopLevel:
+                case ButtonSystemState.TopLevel:
                     buttonsTopLevel.First().TriggerOnClick();
                     return false;
-                case MenuState.Play:
+                case ButtonSystemState.Play:
                     buttonsPlay.First().TriggerOnClick();
                     return false;
             }
         }
 
-        private MenuState state;
+        private ButtonSystemState state = ButtonSystemState.Initial;
 
-        public override bool HandleKeyboardInput => state != MenuState.Exit;
-        public override bool HandleMouseInput => state != MenuState.Exit;
+        public override bool HandleKeyboardInput => state != ButtonSystemState.Exit;
+        public override bool HandleMouseInput => state != ButtonSystemState.Exit;
 
-        public MenuState State
+        public ButtonSystemState State
         {
             get { return state; }
 
@@ -228,71 +171,19 @@ namespace osu.Game.Screens.Menu
             {
                 if (state == value) return;
 
-                MenuState lastState = state;
+                ButtonSystemState lastState = state;
                 state = value;
 
-                //todo: figure a more elegant way of doing this.
-                buttonsTopLevel.ForEach(b => b.ContractStyle = 0);
-                buttonsPlay.ForEach(b => b.ContractStyle = 0);
-                backButton.ContractStyle = 0;
-                settingsButton.ContractStyle = 0;
-
                 updateLogoState(lastState);
 
-                using (buttonArea.BeginDelayedSequence(lastState == MenuState.Initial ? 150 : 0, true))
+                Logger.Log($"{nameof(ButtonSystem)}'s state changed from {lastState} to {state}");
+
+                using (buttonArea.BeginDelayedSequence(lastState == ButtonSystemState.Initial ? 150 : 0, true))
                 {
-                    switch (state)
-                    {
-                        case MenuState.Exit:
-                        case MenuState.Initial:
-                            buttonAreaBackground.ScaleTo(Vector2.One, 500, Easing.Out);
-                            buttonArea.FadeOut(300);
+                    buttonArea.ButtonSystemState = state;
 
-                            foreach (Button b in buttonsTopLevel)
-                                b.State = ButtonState.Contracted;
-
-                            foreach (Button b in buttonsPlay)
-                                b.State = ButtonState.Contracted;
-
-                            if (state != MenuState.Exit && lastState == MenuState.TopLevel)
-                                sampleBack?.Play();
-                            break;
-                        case MenuState.TopLevel:
-                            buttonAreaBackground.ScaleTo(Vector2.One, 200, Easing.Out);
-
-                            buttonArea.FadeIn(300);
-
-                            foreach (Button b in buttonsTopLevel)
-                                b.State = ButtonState.Expanded;
-
-                            foreach (Button b in buttonsPlay)
-                                b.State = ButtonState.Contracted;
-                            break;
-                        case MenuState.Play:
-                            foreach (Button b in buttonsTopLevel)
-                                b.State = ButtonState.Exploded;
-
-                            foreach (Button b in buttonsPlay)
-                                b.State = ButtonState.Expanded;
-                            break;
-                        case MenuState.EnteringMode:
-                            buttonAreaBackground.ScaleTo(new Vector2(2, 0), 300, Easing.InSine);
-
-                            buttonsTopLevel.ForEach(b => b.ContractStyle = 1);
-                            buttonsPlay.ForEach(b => b.ContractStyle = 1);
-                            backButton.ContractStyle = 1;
-                            settingsButton.ContractStyle = 1;
-
-                            foreach (Button b in buttonsTopLevel)
-                                b.State = ButtonState.Contracted;
-
-                            foreach (Button b in buttonsPlay)
-                                b.State = ButtonState.Contracted;
-                            break;
-                    }
-
-                    backButton.State = state == MenuState.Play ? ButtonState.Expanded : ButtonState.Contracted;
-                    settingsButton.State = state == MenuState.TopLevel ? ButtonState.Expanded : ButtonState.Contracted;
+                    foreach (var b in buttonArea.Children.OfType<Button>())
+                        b.ButtonSystemState = state;
                 }
 
                 StateChanged?.Invoke(State);
@@ -301,14 +192,14 @@ namespace osu.Game.Screens.Menu
 
         private ScheduledDelegate logoDelayedAction;
 
-        private void updateLogoState(MenuState lastState = MenuState.Initial)
+        private void updateLogoState(ButtonSystemState lastState = ButtonSystemState.Initial)
         {
             if (logo == null) return;
 
             switch (state)
             {
-                case MenuState.Exit:
-                case MenuState.Initial:
+                case ButtonSystemState.Exit:
+                case ButtonSystemState.Initial:
                     logoDelayedAction?.Cancel();
                     logoDelayedAction = Scheduler.AddDelayed(() =>
                         {
@@ -316,7 +207,7 @@ namespace osu.Game.Screens.Menu
 
                             if (game != null)
                             {
-                                game.OverlayActivationMode.Value = state == MenuState.Exit ? OverlayActivation.Disabled : OverlayActivation.All;
+                                game.OverlayActivationMode.Value = state == ButtonSystemState.Exit ? OverlayActivation.Disabled : OverlayActivation.All;
                                 game.Toolbar.Hide();
                             }
 
@@ -327,22 +218,22 @@ namespace osu.Game.Screens.Menu
                             logo.ScaleTo(1, 800, Easing.OutExpo);
                         }, buttonArea.Alpha * 150);
                     break;
-                case MenuState.TopLevel:
-                case MenuState.Play:
+                case ButtonSystemState.TopLevel:
+                case ButtonSystemState.Play:
                     switch (lastState)
                     {
-                        case MenuState.TopLevel: // coming from toplevel to play
+                        case ButtonSystemState.TopLevel: // coming from toplevel to play
                             break;
-                        case MenuState.Initial:
+                        case ButtonSystemState.Initial:
                             logo.ClearTransforms(targetMember: nameof(Position));
                             logo.RelativePositionAxes = Axes.None;
 
                             bool impact = logo.Scale.X > 0.6f;
 
-                            if (lastState == MenuState.Initial)
+                            if (lastState == ButtonSystemState.Initial)
                                 logo.ScaleTo(0.5f, 200, Easing.In);
 
-                            logo.MoveTo(logoTrackingPosition, lastState == MenuState.EnteringMode ? 0 : 200, Easing.In);
+                            logo.MoveTo(logoTrackingPosition, lastState == ButtonSystemState.EnteringMode ? 0 : 200, Easing.In);
 
                             logoDelayedAction?.Cancel();
                             logoDelayedAction = Scheduler.AddDelayed(() =>
@@ -368,7 +259,7 @@ namespace osu.Game.Screens.Menu
                     }
 
                     break;
-                case MenuState.EnteringMode:
+                case ButtonSystemState.EnteringMode:
                     logoTracking = true;
                     break;
             }
@@ -387,7 +278,7 @@ namespace osu.Game.Screens.Menu
 
             if (logo != null)
             {
-                if (logoTracking)
+                if (logoTracking && iconFacade.IsLoaded)
                     logo.Position = logoTrackingPosition;
 
                 iconFacade.Width = logo.SizeForFlow * 0.5f;
@@ -395,12 +286,12 @@ namespace osu.Game.Screens.Menu
         }
     }
 
-    public enum MenuState
+    public enum ButtonSystemState
     {
+        Exit,
         Initial,
         TopLevel,
         Play,
         EnteringMode,
-        Exit,
     }
 }

osu.Game/Screens/Menu/Disclaimer.cs

@@ -3,10 +3,9 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Framework.Screens;
 using osu.Game.Graphics;
-using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.Containers;
 using OpenTK;
 using OpenTK.Graphics;
 using osu.Game.Overlays;
@@ -16,96 +15,89 @@ namespace osu.Game.Screens.Menu
     public class Disclaimer : OsuScreen
     {
         private Intro intro;
-        private readonly SpriteIcon icon;
+        private SpriteIcon icon;
         private Color4 iconColour;
+        private LinkFlowContainer textFlow;
 
         protected override bool HideOverlaysOnEnter => true;
         protected override OverlayActivation InitialOverlayActivationMode => OverlayActivation.Disabled;
 
         public override bool CursorVisible => false;
 
+        private const float icon_y = -0.09f;
+
         public Disclaimer()
         {
             ValidForResume = false;
-
-            Children = new Drawable[]
-            {
-                new FillFlowContainer
-                {
-                    AutoSizeAxes = Axes.Both,
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    Direction = FillDirection.Vertical,
-                    Spacing = new Vector2(0, 2),
-                    Children = new Drawable[]
-                    {
-                        icon = new SpriteIcon
-                        {
-                            Anchor = Anchor.TopCentre,
-                            Origin = Anchor.TopCentre,
-                            Icon = FontAwesome.fa_warning,
-                            Size = new Vector2(30),
-                        },
-                        new OsuSpriteText
-                        {
-                            Anchor = Anchor.TopCentre,
-                            Origin = Anchor.TopCentre,
-                            TextSize = 30,
-                            Text = "This is a development build",
-                            Margin = new MarginPadding
-                            {
-                                Bottom = 20
-                            },
-                        },
-                        new OsuSpriteText
-                        {
-                            Anchor = Anchor.TopCentre,
-                            Origin = Anchor.TopCentre,
-                            Text = "Don't expect shit to work perfectly as this is very much a work in progress."
-                        },
-                        new OsuSpriteText
-                        {
-                            Anchor = Anchor.TopCentre,
-                            Origin = Anchor.TopCentre,
-                            Text = "Don't report bugs because we are aware. Don't complain about missing features because we are adding them."
-                        },
-                        new OsuSpriteText
-                        {
-                            Anchor = Anchor.TopCentre,
-                            Origin = Anchor.TopCentre,
-                            Text = "Sit back and enjoy. Visit discord.gg/ppy if you want to help out!",
-                            Margin = new MarginPadding { Bottom = 20 },
-                        },
-                        new OsuSpriteText
-                        {
-                            Anchor = Anchor.TopCentre,
-                            Origin = Anchor.TopCentre,
-                            TextSize = 12,
-                            Text = "oh and yes, you will get seizures.",
-                        },
-                    }
-                }
-            };
         }
 
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
-            LoadComponentAsync(intro = new Intro());
+            Children = new Drawable[]
+            {
+                icon = new SpriteIcon
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Icon = FontAwesome.fa_warning,
+                    Size = new Vector2(30),
+                    RelativePositionAxes = Axes.Both,
+                    Y = icon_y,
+                },
+                textFlow = new LinkFlowContainer
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Padding = new MarginPadding(50),
+                    TextAnchor = Anchor.TopCentre,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Spacing = new Vector2(0, 2),
+                }
+            };
+
+            textFlow.AddText("This is an ", t =>
+            {
+                t.TextSize = 30;
+                t.Font = @"Exo2.0-Light";
+            });
+            textFlow.AddText("early development build", t =>
+            {
+                t.TextSize = 30;
+                t.Font = @"Exo2.0-SemiBold";
+            });
+
+            textFlow.AddParagraph("Don't expect everything to work perfectly.");
+            textFlow.AddParagraph("");
+            textFlow.AddParagraph("Detailed bug reports are welcomed via github issues.");
+            textFlow.AddParagraph("");
+
+            textFlow.AddText("Visit ");
+            textFlow.AddLink("discord.gg/ppy", "https://discord.gg/ppy");
+            textFlow.AddText(" if you want to help out or follow progress!");
 
             iconColour = colours.Yellow;
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            LoadComponentAsync(intro = new Intro());
+        }
+
         protected override void OnEntering(Screen last)
         {
             base.OnEntering(last);
 
-            icon.Delay(1500).FadeColour(iconColour, 200);
+            icon.Delay(1500).FadeColour(iconColour, 200, Easing.OutQuint);
+            icon.Delay(1500).MoveToY(icon_y * 1.1f, 100, Easing.OutCirc).Then().MoveToY(icon_y, 100, Easing.InCirc);
 
             Content
                 .FadeInFromZero(500)
                 .Then(5500)
                 .FadeOut(250)
+                .ScaleTo(0.9f, 250, Easing.InQuint)
                 .Finally(d => Push(intro));
         }
     }

osu.Game/Screens/Menu/MainMenu.cs

@@ -24,9 +24,9 @@ namespace osu.Game.Screens.Menu
     {
         private readonly ButtonSystem buttons;
 
-        protected override bool HideOverlaysOnEnter => buttons.State == MenuState.Initial;
+        protected override bool HideOverlaysOnEnter => buttons.State == ButtonSystemState.Initial;
 
-        protected override bool AllowBackButton => buttons.State != MenuState.Initial;
+        protected override bool AllowBackButton => buttons.State != ButtonSystemState.Initial;
 
         private readonly BackgroundScreenDefault background;
         private Screen songSelect;
@@ -55,7 +55,7 @@ namespace osu.Game.Screens.Menu
                             OnChart = delegate { Push(new ChartListing()); },
                             OnDirect = delegate { Push(new OnlineListing()); },
                             OnEdit = delegate { Push(new Editor()); },
-                            OnSolo = delegate { Push(consumeSongSelect()); },
+                            OnSolo = onSolo,
                             OnMulti = delegate { Push(new Multiplayer()); },
                             OnExit = Exit,
                         }
@@ -85,6 +85,10 @@ namespace osu.Game.Screens.Menu
                 LoadComponentAsync(songSelect = new PlaySongSelect());
         }
 
+        public void LoadToSolo() => Schedule(onSolo);
+
+        private void onSolo() => Push(consumeSongSelect());
+
         private Screen consumeSongSelect()
         {
             var s = songSelect;
@@ -123,7 +127,7 @@ namespace osu.Game.Screens.Menu
 
             if (resuming)
             {
-                buttons.State = MenuState.TopLevel;
+                buttons.State = ButtonSystemState.TopLevel;
 
                 const float length = 300;
 
@@ -155,7 +159,7 @@ namespace osu.Game.Screens.Menu
 
             const float length = 400;
 
-            buttons.State = MenuState.EnteringMode;
+            buttons.State = ButtonSystemState.EnteringMode;
 
             Content.FadeOut(length, Easing.InSine);
             Content.MoveTo(new Vector2(-800, 0), length, Easing.InSine);
@@ -175,7 +179,7 @@ namespace osu.Game.Screens.Menu
 
         protected override bool OnExiting(Screen next)
         {
-            buttons.State = MenuState.Exit;
+            buttons.State = ButtonSystemState.Exit;
             Content.FadeOut(3000);
             return base.OnExiting(next);
         }

osu.Game/Screens/Menu/OsuLogo.cs

@@ -19,6 +19,7 @@ using osu.Game.Graphics.Backgrounds;
 using osu.Game.Graphics.Containers;
 using OpenTK;
 using OpenTK.Graphics;
+using OpenTK.Input;
 
 namespace osu.Game.Screens.Menu
 {
@@ -345,12 +346,16 @@ namespace osu.Game.Screens.Menu
 
         protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
         {
+            if (args.Button != MouseButton.Left) return false;
+
             logoBounceContainer.ScaleTo(0.9f, 1000, Easing.Out);
             return true;
         }
 
         protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
         {
+            if (args.Button != MouseButton.Left) return false;
+
             logoBounceContainer.ScaleTo(1f, 500, Easing.OutElastic);
             return true;
         }

osu.Game/Screens/OsuScreen.cs

@@ -101,7 +101,7 @@ namespace osu.Game.Screens
             sampleExit = audio.Sample.Get(@"UI/screen-back");
         }
 
-        public bool OnPressed(GlobalAction action)
+        public virtual bool OnPressed(GlobalAction action)
         {
             if (!IsCurrentScreen) return false;
 

osu.Game/Screens/Select/Leaderboards/DrawableRank.cs

@@ -46,7 +46,9 @@ namespace osu.Game.Screens.Select.Leaderboards
         public void UpdateRank(ScoreRank newRank)
         {
             Rank = newRank;
-            updateTexture();
+
+            if (LoadState >= LoadState.Ready)
+                updateTexture();
         }
     }
 }

osu.Game/Screens/Select/PlaySongSelect.cs

@@ -84,10 +84,10 @@ namespace osu.Game.Screens.Select
 
         protected override void UpdateBeatmap(WorkingBeatmap beatmap)
         {
-            base.UpdateBeatmap(beatmap);
-
             beatmap.Mods.BindTo(SelectedMods);
 
+            base.UpdateBeatmap(beatmap);
+
             BeatmapDetails.Beatmap = beatmap;
 
             if (beatmap.Track != null)

osu.Game/Screens/Select/SongSelect.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using System.Linq;
 using OpenTK;
 using OpenTK.Input;
 using osu.Framework.Allocation;
@@ -17,8 +18,10 @@ using osu.Framework.Threading;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
+using osu.Game.Input.Bindings;
 using osu.Game.Overlays;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Screens.Backgrounds;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Menu;
@@ -67,8 +70,16 @@ namespace osu.Game.Screens.Select
         protected new readonly Bindable<RulesetInfo> Ruleset = new Bindable<RulesetInfo>();
 
         private DependencyContainer dependencies;
-        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
-            => dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+        {
+            dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
+            dependencies.CacheAs(this);
+            dependencies.CacheAs(Ruleset);
+            dependencies.CacheAs<IBindable<RulesetInfo>>(Ruleset);
+
+            return dependencies;
+        }
 
         protected SongSelect()
         {
@@ -136,7 +147,11 @@ namespace osu.Game.Screens.Select
                                 Height = filter_height,
                                 FilterChanged = c => Carousel.Filter(c),
                                 Background = { Width = 2 },
-                                Exit = Exit,
+                                Exit = () =>
+                                {
+                                    if (IsCurrentScreen)
+                                        Exit();
+                                },
                             },
                         }
                     },
@@ -183,11 +198,9 @@ namespace osu.Game.Screens.Select
         [BackgroundDependencyLoader(true)]
         private void load(BeatmapManager beatmaps, AudioManager audio, DialogOverlay dialog, OsuColour colours)
         {
-            dependencies.CacheAs(this);
-            dependencies.CacheAs(Ruleset);
-            dependencies.CacheAs<IBindable<RulesetInfo>>(Ruleset);
-
+            // manual binding to parent ruleset to allow for delayed load in the incoming direction.
             base.Ruleset.ValueChanged += r => updateSelectedBeatmap(beatmapNoDebounce);
+            Ruleset.ValueChanged += r => base.Ruleset.Value = r;
 
             if (Footer != null)
             {
@@ -216,6 +229,12 @@ namespace osu.Game.Screens.Select
             Beatmap.BindValueChanged(workingBeatmapChanged);
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            base.Ruleset.ValueChanged += r => updateSelectedBeatmap(beatmapNoDebounce);
+        }
+
         public void Edit(BeatmapInfo beatmap)
         {
             Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmap, Beatmap.Value);
@@ -229,6 +248,10 @@ namespace osu.Game.Screens.Select
         /// <param name="performStartAction">Whether to trigger <see cref="OnStart"/>.</param>
         public void FinaliseSelection(BeatmapInfo beatmap = null, bool performStartAction = true)
         {
+            // avoid attempting to continue before a selection has been obtained.
+            // this could happen via a user interaction while the carousel is still in a loading state.
+            if (Carousel.SelectedBeatmap == null) return;
+
             // if we have a pending filter operation, we want to run it now.
             // it could change selection (ie. if the ruleset has been changed).
             Carousel.FlushPendingFilterOperations();
@@ -263,7 +286,7 @@ namespace osu.Game.Screens.Select
                 // If selecting new beatmap without bypassing filters failed, there's possibly a ruleset mismatch
                 if (beatmap?.BeatmapInfo?.Ruleset != null && beatmap.BeatmapInfo.Ruleset != Ruleset.Value)
                 {
-                    Ruleset.Value = beatmap.BeatmapInfo.Ruleset;
+                    base.Ruleset.Value = beatmap.BeatmapInfo.Ruleset;
                     Carousel.SelectBeatmap(beatmap.BeatmapInfo);
                 }
         }
@@ -281,18 +304,25 @@ namespace osu.Game.Screens.Select
 
             void performLoad()
             {
+                WorkingBeatmap working = Beatmap.Value;
+                bool preview = false;
+
                 // We may be arriving here due to another component changing the bindable Beatmap.
                 // In these cases, the other component has already loaded the beatmap, so we don't need to do so again.
                 if (beatmap?.Equals(Beatmap.Value.BeatmapInfo) != true)
                 {
-                    bool preview = beatmap?.BeatmapSetInfoID != Beatmap.Value?.BeatmapInfo.BeatmapSetInfoID;
-
-                    Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmap, Beatmap.Value);
-                    ensurePlayingSelected(preview);
+                    preview = beatmap?.BeatmapSetInfoID != Beatmap.Value?.BeatmapInfo.BeatmapSetInfoID;
+                    working = beatmaps.GetWorkingBeatmap(beatmap, Beatmap.Value);
                 }
 
+
+                working.Mods.Value = Enumerable.Empty<Mod>();
+
+                Beatmap.Value = working;
                 Ruleset.Value = ruleset;
 
+                ensurePlayingSelected(preview);
+
                 UpdateBeatmap(Beatmap.Value);
             }
 
@@ -464,7 +494,8 @@ namespace osu.Game.Screens.Select
 
         private void carouselBeatmapsLoaded()
         {
-            if (!Beatmap.IsDefault && Beatmap.Value.BeatmapSetInfo?.DeletePending == false && Beatmap.Value.BeatmapSetInfo?.Protected == false && Carousel.SelectBeatmap(Beatmap.Value.BeatmapInfo, false))
+            if (!Beatmap.IsDefault && Beatmap.Value.BeatmapSetInfo?.DeletePending == false && Beatmap.Value.BeatmapSetInfo?.Protected == false
+                && Carousel.SelectBeatmap(Beatmap.Value.BeatmapInfo, false))
                 return;
 
             if (Carousel.SelectedBeatmapSet == null && !Carousel.SelectNextRandom())
@@ -481,16 +512,26 @@ namespace osu.Game.Screens.Select
             dialogOverlay?.Push(new BeatmapDeleteDialog(beatmap));
         }
 
+        public override bool OnPressed(GlobalAction action)
+        {
+            if (!IsCurrentScreen) return false;
+
+            switch (action)
+            {
+                case GlobalAction.Select:
+                    FinaliseSelection();
+                    return true;
+            }
+
+            return base.OnPressed(action);
+        }
+
         protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
         {
             if (args.Repeat) return false;
 
             switch (args.Key)
             {
-                case Key.KeypadEnter:
-                case Key.Enter:
-                    FinaliseSelection();
-                    return true;
                 case Key.Delete:
                     if (state.Keyboard.ShiftPressed)
                     {

osu.Game/Screens/Tournament/Drawings.cs

@@ -49,8 +49,8 @@ namespace osu.Game.Screens.Tournament
 
         private DependencyContainer dependencies;
 
-        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent) =>
-            dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent) =>
+            dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
         [BackgroundDependencyLoader]
         private void load(TextureStore textures, Storage storage)

osu.Game/Skinning/LocalSkinOverrideContainer.cs

@@ -71,9 +71,9 @@ namespace osu.Game.Skinning
 
         private void onSourceChanged() => SourceChanged?.Invoke();
 
-        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
-            var dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
             fallbackSource = dependencies.Get<ISkinSource>();
             dependencies.CacheAs<ISkinSource>(this);

osu.Game/Storyboards/Drawables/DrawableStoryboard.cs

@@ -36,8 +36,8 @@ namespace osu.Game.Storyboards.Drawables
         public override bool RemoveCompletedTransforms => false;
 
         private DependencyContainer dependencies;
-        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent) =>
-            dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent) =>
+            dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
         public DrawableStoryboard(Storyboard storyboard)
         {

osu.Game/Storyboards/Drawables/DrawableStoryboardSample.cs

@@ -0,0 +1,69 @@
+// 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.IO;
+using osu.Framework.Allocation;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
+
+namespace osu.Game.Storyboards.Drawables
+{
+    public class DrawableStoryboardSample : Component
+    {
+        /// <summary>
+        /// The amount of time allowable beyond the start time of the sample, for the sample to start.
+        /// </summary>
+        private const double allowable_late_start = 100;
+
+        private readonly StoryboardSample sample;
+        private SampleChannel channel;
+
+        public override bool RemoveWhenNotAlive => false;
+
+        public DrawableStoryboardSample(StoryboardSample sample)
+        {
+            this.sample = sample;
+            LifetimeStart = sample.Time;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(IBindableBeatmap beatmap)
+        {
+            // Try first with the full name, then attempt with no path
+            channel = beatmap.Value.Skin.GetSample(sample.Path) ?? beatmap.Value.Skin.GetSample(Path.ChangeExtension(sample.Path, null));
+
+            if (channel != null)
+                channel.Volume.Value = sample.Volume / 100;
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            // TODO: this logic will need to be consolidated with other game samples like hitsounds.
+            if (Time.Current < sample.Time)
+            {
+                // We've rewound before the start time of the sample
+                channel?.Stop();
+
+                // In the case that the user fast-forwards to a point far beyond the start time of the sample,
+                // we want to be able to fall into the if-conditional below (therefore we must not have a life time end)
+                LifetimeStart = sample.Time;
+                LifetimeEnd = double.MaxValue;
+            }
+            else if (Time.Current - Time.Elapsed < sample.Time)
+            {
+                // We've passed the start time of the sample. We only play the sample if we're within an allowable range
+                // from the sample's start, to reduce layering if we've been fast-forwarded far into the future
+                if (Time.Current - sample.Time < allowable_late_start)
+                    channel?.Play();
+
+                // In the case that the user rewinds to a point far behind the start time of the sample,
+                // we want to be able to fall into the if-conditional above (therefore we must not have a life time start)
+                LifetimeStart = double.MinValue;
+                LifetimeEnd = sample.Time;
+            }
+        }
+    }
+}

osu.Game/Storyboards/StoryboardSample.cs

@@ -2,14 +2,14 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Graphics;
-using System;
+using osu.Game.Storyboards.Drawables;
 
 namespace osu.Game.Storyboards
 {
     public class StoryboardSample : IStoryboardElement
     {
         public string Path { get; set; }
-        public bool IsDrawable => false;
+        public bool IsDrawable => true;
 
         public double Time;
         public float Volume;
@@ -21,9 +21,6 @@ namespace osu.Game.Storyboards
             Volume = volume;
         }
 
-        public Drawable CreateDrawable()
-        {
-            throw new InvalidOperationException();
-        }
+        public Drawable CreateDrawable() => new DrawableStoryboardSample(this);
     }
 }

osu.Game/Tests/Beatmaps/BeatmapConversionTest.cs

@@ -25,6 +25,8 @@ namespace osu.Game.Tests.Beatmaps
 
         protected abstract string ResourceAssembly { get; }
 
+        protected IBeatmapConverter Converter { get; private set; }
+
         protected void Test(string name)
         {
             var ourResult = convert(name);
@@ -41,14 +43,22 @@ namespace osu.Game.Tests.Beatmaps
                         Assert.Fail($"A conversion did not generate any hitobjects, but should have, for hitobject at time: {expectedResult.Mappings[mappingCounter].StartTime}\n");
                     else if (mappingCounter >= expectedResult.Mappings.Count)
                         Assert.Fail($"A conversion generated hitobjects, but should not have, for hitobject at time: {ourResult.Mappings[mappingCounter].StartTime}\n");
+                    else if (!expectedResult.Mappings[mappingCounter].Equals(ourResult.Mappings[mappingCounter]))
+                    {
+                        var expectedMapping = expectedResult.Mappings[mappingCounter];
+                        var ourMapping = ourResult.Mappings[mappingCounter];
+
+                        Assert.Fail($"The conversion mapping differed for object at time {expectedMapping.StartTime}:\n"
+                                    + $"Expected {JsonConvert.SerializeObject(expectedMapping)}\n"
+                                    + $"Received: {JsonConvert.SerializeObject(ourMapping)}\n");
+                    }
                     else
                     {
-                        var counter = mappingCounter;
+                        var ourMapping = ourResult.Mappings[mappingCounter];
+                        var expectedMapping = expectedResult.Mappings[mappingCounter];
+
                         Assert.Multiple(() =>
                         {
-                            var ourMapping = ourResult.Mappings[counter];
-                            var expectedMapping = expectedResult.Mappings[counter];
-
                             int objectCounter = 0;
                             while (true)
                             {
@@ -60,10 +70,6 @@ namespace osu.Game.Tests.Beatmaps
                                 else if (objectCounter >= expectedMapping.Objects.Count)
                                     Assert.Fail($"The conversion generated a hitobject, but should not have, for hitobject at time: {ourMapping.StartTime}:\n"
                                                 + $"Received: {JsonConvert.SerializeObject(ourMapping.Objects[objectCounter])}\n");
-                                else if (!expectedMapping.Equals(ourMapping))
-                                    Assert.Fail($"The conversion mapping differed for object at time {expectedMapping.StartTime}:\n"
-                                                + $"Expected {JsonConvert.SerializeObject(expectedMapping)}\n"
-                                                + $"Received: {JsonConvert.SerializeObject(ourMapping)}\n");
                                 else if (!expectedMapping.Objects[objectCounter].Equals(ourMapping.Objects[objectCounter]))
                                 {
                                     Assert.Fail($"The conversion generated differing hitobjects for object at time: {expectedMapping.StartTime}:\n"
@@ -88,10 +94,11 @@ namespace osu.Game.Tests.Beatmaps
             var rulesetInstance = CreateRuleset();
             beatmap.BeatmapInfo.Ruleset = beatmap.BeatmapInfo.RulesetID == rulesetInstance.RulesetInfo.ID ? rulesetInstance.RulesetInfo : new RulesetInfo();
 
-            var result = new ConvertResult();
-            var converter = rulesetInstance.CreateBeatmapConverter(beatmap);
+            Converter = rulesetInstance.CreateBeatmapConverter(beatmap);
 
-            converter.ObjectConverted += (orig, converted) =>
+            var result = new ConvertResult();
+
+            Converter.ObjectConverted += (orig, converted) =>
             {
                 converted.ForEach(h => h.ApplyDefaults(beatmap.ControlPointInfo, beatmap.BeatmapInfo.BaseDifficulty));
 
@@ -103,7 +110,7 @@ namespace osu.Game.Tests.Beatmaps
                 result.Mappings.Add(mapping);
             };
 
-            IBeatmap convertedBeatmap = converter.Convert();
+            IBeatmap convertedBeatmap = Converter.Convert();
             rulesetInstance.CreateBeatmapProcessor(convertedBeatmap)?.PostProcess();
 
             return result;