Merge pull request #4440 from peppy/update-framework

Update framework
2026-05-16 07:32:34 +08:00 · 2019-03-08 22:46:43 +09:00 · 2019-03-08 20:48:50 +09:00 · 2019-03-08 20:32:43 +09:00 · 2019-03-08 20:23:02 +09:00 · 2019-03-08 16:05:48 +09:00
117 changed files with 1311 additions and 735 deletions
@@ -1,22 +1,24 @@
-# 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)
+# 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! Commonly known by the codename "osu!lazer". Pew pew.

-# Status
+## Status

 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
+## Requirements

 - A desktop platform with the [.NET Core SDK 2.2](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 2017+](https://visualstudio.microsoft.com/vs/), [Jetbrains Rider](https://www.jetbrains.com/rider/) or [Visual Studio Code](https://code.visualstudio.com/).
 - Note that there are **[additional requirements for Windows 7 and Windows 8.1](https://docs.microsoft.com/en-us/dotnet/core/windows-prerequisites?tabs=netcore2x)** which you may need to manually install if your operating system is not up-to-date.

-# Running osu!
+## Running osu!

-## Releases
+### Releases

 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.

@@ -26,7 +28,7 @@ If you are not interested in developing the game, please head over to the [relea

 If your platform is not listed above, there is still a chance you can manually build it by following the instructions below.

-## Downloading the source code
+### Downloading the source code

 Clone the repository **including submodules**:

@@ -41,7 +43,7 @@ To update the source code to the latest commit, run the following command inside
 git pull
 ```

-## Building
+### Building

 Build configurations for the recommended IDEs (listed above) are included. You should use the provided Build/Run functionality of your IDE to get things going. When testing or building new components, it's highly encouraged you use the `VisualTests` project/configuration. More information on this provided below.

@@ -57,7 +59,7 @@ If you are not interested in debugging osu!, you can add `-c Release` to gain pe

 If the build fails, try to restore nuget packages with `dotnet restore`.

-### A note for Linux users
+#### A note for Linux users

 On Linux, the environment variable `LD_LIBRARY_PATH` must point to the build directory, located at `osu.Desktop/bin/Debug/$NETCORE_VERSION`.

@@ -69,15 +71,15 @@ For example, you can run osu! with the following command:
 LD_LIBRARY_PATH="$(pwd)/osu.Desktop/bin/Debug/netcoreapp2.2" dotnet run --project osu.Desktop
 ```

-## Testing with resource/framework modifications
+### Testing with resource/framework modifications

 Sometimes it may be necessary to cross-test changes in [osu-resources](https://github.com/ppy/osu-resources) or [osu-framework](https://github.com/ppy/osu-framework). This can be achieved by running some commands as documented on the [osu-resources](https://github.com/ppy/osu-resources/wiki/Testing-local-resources-checkout-with-other-projects) and [osu-framework](https://github.com/ppy/osu-framework/wiki/Testing-local-framework-checkout-with-other-projects) wiki pages.

-## Code analysis
+### Code analysis

 Code analysis can be run with `powershell ./build.ps1` or `build.sh`. This is currently only supported under windows due to [resharper cli shortcomings](https://youtrack.jetbrains.com/issue/RSRP-410004). Alternatively, you can install resharper or use rider to get inline support in your IDE of choice.

-# Contributing
+## Contributing

 We welcome all contributions, but keep in mind that we already have a lot of the UI designed. If you wish to work on something with the intention on having it included in the official distribution, please open an issue for discussion and we will give you what you need from a design perspective to proceed. If you want to make *changes* to the design, we recommend you open an issue with your intentions before spending too much time, to ensure no effort is wasted.

@@ -87,7 +89,7 @@ Contributions can be made via pull requests to this repository. We hope to credi

 Note that while we already have certain standards in place, nothing is set in stone. If you have an issue with the way code is structured; with any libraries we are using; with any processes involved with contributing, *please* bring it up. I welcome all feedback so we can make contributing to this project as pain-free as possible.

-# Licence
+## Licence

 The osu! client code and framework are licensed under the [MIT licence](https://opensource.org/licenses/MIT). Please see [the licence file](LICENCE) for more information. [tl;dr](https://tldrlegal.com/license/mit-license) you can do whatever you want as long as you include the original copyright and license notice in any copy of the software/source.

@@ -1,9 +1,11 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using System;
 using NUnit.Framework;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Screens.Play;

 namespace osu.Game.Rulesets.Catch.Tests
 {
@@ -17,13 +19,30 @@ namespace osu.Game.Rulesets.Catch.Tests

        protected override IBeatmap CreateBeatmap(Ruleset ruleset)
        {
-            var beatmap = new Beatmap { BeatmapInfo = { Ruleset = ruleset.RulesetInfo } };
+            var beatmap = new Beatmap
+            {
+                BeatmapInfo =
+                {
+                    Ruleset = ruleset.RulesetInfo,
+                    BaseDifficulty = new BeatmapDifficulty { CircleSize = 3.6f }
+                }
+            };
+
+            // Should produce a hperdash
+            beatmap.HitObjects.Add(new Fruit { StartTime = 816, X = 308 / 512f, NewCombo = true });
+            beatmap.HitObjects.Add(new Fruit { StartTime = 1008, X = 56 / 512f, });

            for (int i = 0; i < 512; i++)
                if (i % 5 < 3)
-                    beatmap.HitObjects.Add(new Fruit { X = i % 10 < 5 ? 0.02f : 0.98f, StartTime = i * 100, NewCombo = i % 8 == 0 });
+                    beatmap.HitObjects.Add(new Fruit { X = i % 10 < 5 ? 0.02f : 0.98f, StartTime = 2000 + i * 100, NewCombo = i % 8 == 0 });

            return beatmap;
        }
+
+        protected override void AddCheckSteps(Func<Player> player)
+        {
+            base.AddCheckSteps(player);
+            AddAssert("First note is hyperdash", () => Beatmap.Value.Beatmap.HitObjects[0] is Fruit f && f.HyperDash);
+        }
    }
 }
@@ -100,7 +100,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                CatchHitObject nextObject = objectWithDroplets[i + 1];

                int thisDirection = nextObject.X > currentObject.X ? 1 : -1;
-                double timeToNext = nextObject.StartTime - currentObject.StartTime;
+                double timeToNext = nextObject.StartTime - currentObject.StartTime - 1000f / 60f / 4; // 1/4th of a frame of grace time, taken from osu-stable
                double distanceToNext = Math.Abs(nextObject.X - currentObject.X) - (lastDirection == thisDirection ? lastExcess : halfCatcherWidth);
                float distanceToHyper = (float)(timeToNext * CatcherArea.Catcher.BASE_SPEED - distanceToNext);
                if (distanceToHyper < 0)
@@ -10,6 +10,7 @@ using osu.Game.Rulesets.UI;
 using System.Collections.Generic;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Bindings;
+using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Beatmaps.Legacy;
@@ -99,6 +100,11 @@ namespace osu.Game.Rulesets.Catch
                        new MultiMod(new CatchModAutoplay(), new ModCinema()),
                        new CatchModRelax(),
                    };
+                case ModType.Fun:
+                    return new Mod[]
+                    {
+                        new MultiMod(new ModWindUp<CatchHitObject>(), new ModWindDown<CatchHitObject>())
+                    };
                default:
                    return new Mod[] { };
            }
@@ -12,7 +12,7 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
    public class CatchModAutoplay : ModAutoplay<CatchHitObject>
    {
-        protected override Score CreateReplayScore(Beatmap<CatchHitObject> beatmap) => new Score
+        public override Score CreateReplayScore(IBeatmap beatmap) => new Score
        {
            ScoreInfo = new ScoreInfo { User = new User { Username = "osu!salad!" } },
            Replay = new CatchAutoGenerator(beatmap).Generate(),
@@ -6,17 +6,20 @@ using System.Linq;
 using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
 using osu.Game.Replays;
+using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Replays;

 namespace osu.Game.Rulesets.Catch.Replays
 {
-    internal class CatchAutoGenerator : AutoGenerator<CatchHitObject>
+    internal class CatchAutoGenerator : AutoGenerator
    {
        public const double RELEASE_DELAY = 20;

-        public CatchAutoGenerator(Beatmap<CatchHitObject> beatmap)
+        public new CatchBeatmap Beatmap => (CatchBeatmap)base.Beatmap;
+
+        public CatchAutoGenerator(IBeatmap beatmap)
            : base(beatmap)
        {
            Replay = new Replay();
@@ -25,8 +25,8 @@ namespace osu.Game.Rulesets.Mania.Tests
        [BackgroundDependencyLoader]
        private void load(RulesetConfigCache configCache)
        {
-            var config = (ManiaConfigManager)configCache.GetConfigFor(Ruleset.Value.CreateInstance());
-            config.BindWith(ManiaSetting.ScrollDirection, direction);
+            var config = (ManiaRulesetConfigManager)configCache.GetConfigFor(Ruleset.Value.CreateInstance());
+            config.BindWith(ManiaRulesetSetting.ScrollDirection, direction);
        }
    }
 }
@@ -8,9 +8,9 @@ using osu.Game.Rulesets.Mania.UI;

 namespace osu.Game.Rulesets.Mania.Configuration
 {
-    public class ManiaConfigManager : RulesetConfigManager<ManiaSetting>
+    public class ManiaRulesetConfigManager : RulesetConfigManager<ManiaRulesetSetting>
    {
-        public ManiaConfigManager(SettingsStore settings, RulesetInfo ruleset, int? variant = null)
+        public ManiaRulesetConfigManager(SettingsStore settings, RulesetInfo ruleset, int? variant = null)
            : base(settings, ruleset, variant)
        {
        }
@@ -19,17 +19,17 @@ namespace osu.Game.Rulesets.Mania.Configuration
        {
            base.InitialiseDefaults();

-            Set(ManiaSetting.ScrollTime, 2250.0, 50.0, 10000.0, 50.0);
-            Set(ManiaSetting.ScrollDirection, ManiaScrollingDirection.Down);
+            Set(ManiaRulesetSetting.ScrollTime, 2250.0, 50.0, 10000.0, 50.0);
+            Set(ManiaRulesetSetting.ScrollDirection, ManiaScrollingDirection.Down);
        }

        public override TrackedSettings CreateTrackedSettings() => new TrackedSettings
        {
-            new TrackedSetting<double>(ManiaSetting.ScrollTime, v => new SettingDescription(v, "Scroll Time", $"{v}ms"))
+            new TrackedSetting<double>(ManiaRulesetSetting.ScrollTime, v => new SettingDescription(v, "Scroll Time", $"{v}ms"))
        };
    }

-    public enum ManiaSetting
+    public enum ManiaRulesetSetting
    {
        ScrollTime,
        ScrollDirection
@@ -12,6 +12,7 @@ using System.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Bindings;
 using osu.Game.Graphics;
+using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Replays;
 using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Beatmaps.Legacy;
@@ -145,6 +146,11 @@ namespace osu.Game.Rulesets.Mania
                    {
                        new MultiMod(new ManiaModAutoplay(), new ModCinema()),
                    };
+                case ModType.Fun:
+                    return new Mod[]
+                    {
+                        new MultiMod(new ModWindUp<ManiaHitObject>(), new ModWindDown<ManiaHitObject>())
+                    };
                default:
                    return new Mod[] { };
            }
@@ -162,7 +168,7 @@ namespace osu.Game.Rulesets.Mania

        public override IConvertibleReplayFrame CreateConvertibleReplayFrame() => new ManiaReplayFrame();

-        public override IRulesetConfigManager CreateConfig(SettingsStore settings) => new ManiaConfigManager(settings, RulesetInfo);
+        public override IRulesetConfigManager CreateConfig(SettingsStore settings) => new ManiaRulesetConfigManager(settings, RulesetInfo);

        public override RulesetSettingsSubsection CreateSettings() => new ManiaSettingsSubsection(this);

@@ -22,19 +22,19 @@ namespace osu.Game.Rulesets.Mania
        [BackgroundDependencyLoader]
        private void load()
        {
-            var config = (ManiaConfigManager)Config;
+            var config = (ManiaRulesetConfigManager)Config;

            Children = new Drawable[]
            {
                new SettingsEnumDropdown<ManiaScrollingDirection>
                {
                    LabelText = "Scrolling direction",
-                    Bindable = config.GetBindable<ManiaScrollingDirection>(ManiaSetting.ScrollDirection)
+                    Bindable = config.GetBindable<ManiaScrollingDirection>(ManiaRulesetSetting.ScrollDirection)
                },
                new SettingsSlider<double, TimeSlider>
                {
                    LabelText = "Scroll speed",
-                    Bindable = config.GetBindable<double>(ManiaSetting.ScrollTime)
+                    Bindable = config.GetBindable<double>(ManiaRulesetSetting.ScrollTime)
                },
            };
        }
@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 {
    public class ManiaModAutoplay : ModAutoplay<ManiaHitObject>
    {
-        protected override Score CreateReplayScore(Beatmap<ManiaHitObject> beatmap) => new Score
+        public override Score CreateReplayScore(IBeatmap beatmap) => new Score
        {
            ScoreInfo = new ScoreInfo { User = new User { Username = "osu!topus!" } },
            Replay = new ManiaAutoGenerator((ManiaBeatmap)beatmap).Generate(),
@@ -5,13 +5,12 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Mania.Beatmaps;
-using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Replays;

 namespace osu.Game.Rulesets.Mania.Replays
 {
-    internal class ManiaAutoGenerator : AutoGenerator<ManiaHitObject>
+    internal class ManiaAutoGenerator : AutoGenerator
    {
        public const double RELEASE_DELAY = 20;

@@ -34,7 +34,7 @@ namespace osu.Game.Rulesets.Mania.UI

        public IEnumerable<BarLine> BarLines;

-        protected new ManiaConfigManager Config => (ManiaConfigManager)base.Config;
+        protected new ManiaRulesetConfigManager Config => (ManiaRulesetConfigManager)base.Config;

        private readonly Bindable<ManiaScrollingDirection> configDirection = new Bindable<ManiaScrollingDirection>();

@@ -74,10 +74,10 @@ namespace osu.Game.Rulesets.Mania.UI
        {
            BarLines.ForEach(Playfield.Add);

-            Config.BindWith(ManiaSetting.ScrollDirection, configDirection);
+            Config.BindWith(ManiaRulesetSetting.ScrollDirection, configDirection);
            configDirection.BindValueChanged(direction => Direction.Value = (ScrollingDirection)direction.NewValue, true);

-            Config.BindWith(ManiaSetting.ScrollTime, TimeRange);
+            Config.BindWith(ManiaRulesetSetting.ScrollTime, TimeRange);
        }

        /// <summary>
@@ -16,18 +16,18 @@ namespace osu.Game.Rulesets.Osu.Tests
    [TestFixture]
    public class TestCaseGameplayCursor : OsuTestCase, IProvideCursor
    {
-        private GameplayCursor cursor;
+        private GameplayCursorContainer cursorContainer;

        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(CursorTrail) };

-        public CursorContainer Cursor => cursor;
+        public CursorContainer Cursor => cursorContainer;

        public bool ProvidingUserCursor => true;

        [BackgroundDependencyLoader]
        private void load()
        {
-            Add(cursor = new GameplayCursor { RelativeSizeAxes = Axes.Both });
+            Add(cursorContainer = new GameplayCursorContainer { RelativeSizeAxes = Axes.Both });
        }
    }
 }
@@ -0,0 +1,30 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Configuration;
+
+namespace osu.Game.Rulesets.Osu.Configuration
+{
+    public class OsuRulesetConfigManager : RulesetConfigManager<OsuRulesetSetting>
+    {
+        public OsuRulesetConfigManager(SettingsStore settings, RulesetInfo ruleset, int? variant = null)
+            : base(settings, ruleset, variant)
+        {
+        }
+
+        protected override void InitialiseDefaults()
+        {
+            base.InitialiseDefaults();
+
+            Set(OsuRulesetSetting.SnakingInSliders, true);
+            Set(OsuRulesetSetting.SnakingOutSliders, true);
+        }
+    }
+
+    public enum OsuRulesetSetting
+    {
+        SnakingInSliders,
+        SnakingOutSliders
+    }
+}
@@ -38,7 +38,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
                path = new SmoothPath
                {
                    Anchor = Anchor.Centre,
-                    PathWidth = 1
+                    PathRadius = 1
                },
                marker = new CircularContainer
                {
@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
            InternalChild = body = new ManualSliderBody
            {
                AccentColour = Color4.Transparent,
-                PathWidth = slider.Scale * 64
+                PathRadius = slider.Scale * 64
            };
        }

@@ -34,7 +34,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
            body.BorderColour = colours.Yellow;

            PositionBindable.BindValueChanged(_ => updatePosition(), true);
-            ScaleBindable.BindValueChanged(scale => body.PathWidth = scale.NewValue * 64, true);
+            ScaleBindable.BindValueChanged(scale => body.PathRadius = scale.NewValue * 64, true);
        }

        private void updatePosition() => Position = slider.StackedPosition;
@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

-using osu.Framework.Graphics.Cursor;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.UI;
@@ -16,8 +15,14 @@ namespace osu.Game.Rulesets.Osu.Edit
        {
        }

-        protected override CursorContainer CreateCursor() => null;
+        protected override Playfield CreatePlayfield() => new OsuPlayfieldNoCursor { Size = Vector2.One　};

-        protected override Playfield CreatePlayfield() => new OsuPlayfield { Size = Vector2.One　};
+        private class OsuPlayfieldNoCursor : OsuPlayfield
+        {
+            public OsuPlayfieldNoCursor()
+            {
+                Cursor?.Expire();
+            }
+        }
    }
 }
@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Osu.Mods
    {
        public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(OsuModAutopilot)).Append(typeof(OsuModSpunOut)).ToArray();

-        protected override Score CreateReplayScore(Beatmap<OsuHitObject> beatmap) => new Score
+        public override Score CreateReplayScore(IBeatmap beatmap) => new Score
        {
            ScoreInfo = new ScoreInfo { User = new User { Username = "Autoplay" } },
            Replay = new OsuAutoGenerator(beatmap).Generate()
@@ -10,8 +10,8 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Configuration;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Configuration;
 using osu.Game.Rulesets.Scoring;
 using osuTK.Graphics;
 using osu.Game.Skinning;
@@ -33,6 +33,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
        private readonly IBindable<float> scaleBindable = new Bindable<float>();
        private readonly IBindable<SliderPath> pathBindable = new Bindable<SliderPath>();

+        [Resolved(CanBeNull = true)]
+        private OsuRulesetConfigManager config { get; set; }
+
        public DrawableSlider(Slider s)
            : base(s)
        {
@@ -47,7 +50,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
            {
                Body = new SnakingSliderBody(s)
                {
-                    PathWidth = s.Scale * 64,
+                    PathRadius = s.Scale * 64,
                },
                ticks = new Container<DrawableSliderTick> { RelativeSizeAxes = Axes.Both },
                repeatPoints = new Container<DrawableRepeatPoint> { RelativeSizeAxes = Axes.Both },
@@ -94,15 +97,15 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
        }

        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
+        private void load()
        {
-            config.BindWith(OsuSetting.SnakingInSliders, Body.SnakingIn);
-            config.BindWith(OsuSetting.SnakingOutSliders, Body.SnakingOut);
+            config?.BindWith(OsuRulesetSetting.SnakingInSliders, Body.SnakingIn);
+            config?.BindWith(OsuRulesetSetting.SnakingOutSliders, Body.SnakingOut);

            positionBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
            scaleBindable.BindValueChanged(scale =>
            {
-                Body.PathWidth = scale.NewValue * 64;
+                Body.PathRadius = scale.NewValue * 64;
                Ball.Scale = new Vector2(scale.NewValue);
            });

@@ -19,10 +19,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces

        private readonly BufferedContainer container;

-        public float PathWidth
+        public float PathRadius
        {
-            get => path.PathWidth;
-            set => path.PathWidth = value;
+            get => path.PathRadius;
+            set => path.PathRadius = value;
        }

        /// <summary>
@@ -13,11 +13,15 @@ using osu.Game.Overlays.Settings;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Osu.Edit;
 using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Beatmaps.Legacy;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Configuration;
 using osu.Game.Rulesets.Osu.Difficulty;
 using osu.Game.Scoring;

@@ -125,7 +129,8 @@ namespace osu.Game.Rulesets.Osu
                    {
                        new OsuModTransform(),
                        new OsuModWiggle(),
-                        new OsuModGrow()
+                        new OsuModGrow(),
+                        new MultiMod(new ModWindUp<OsuHitObject>(), new ModWindDown<OsuHitObject>()),
                    };
                default:
                    return new Mod[] { };
@@ -144,12 +149,14 @@ namespace osu.Game.Rulesets.Osu

        public override string ShortName => "osu";

-        public override RulesetSettingsSubsection CreateSettings() => new OsuSettings(this);
+        public override RulesetSettingsSubsection CreateSettings() => new OsuSettingsSubsection(this);

        public override int? LegacyID => 0;

        public override IConvertibleReplayFrame CreateConvertibleReplayFrame() => new OsuReplayFrame();

+        public override IRulesetConfigManager CreateConfig(SettingsStore settings) => new OsuRulesetConfigManager(settings, RulesetInfo);
+
        public OsuRuleset(RulesetInfo rulesetInfo = null)
            : base(rulesetInfo)
        {
@@ -10,12 +10,15 @@ using System.Linq;
 using osu.Framework.Graphics;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Scoring;

 namespace osu.Game.Rulesets.Osu.Replays
 {
    public class OsuAutoGenerator : OsuAutoGeneratorBase
    {
+        public new OsuBeatmap Beatmap => (OsuBeatmap)base.Beatmap;
+
        #region Parameters

        /// <summary>
@@ -42,7 +45,7 @@ namespace osu.Game.Rulesets.Osu.Replays

        #region Construction / Initialisation

-        public OsuAutoGenerator(Beatmap<OsuHitObject> beatmap)
+        public OsuAutoGenerator(IBeatmap beatmap)
            : base(beatmap)
        {
            // Already superhuman, but still somewhat realistic
@@ -3,7 +3,6 @@

 using osuTK;
 using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Osu.Objects;
 using System;
 using System.Collections.Generic;
 using osu.Game.Replays;
@@ -12,7 +11,7 @@ using osu.Game.Rulesets.Replays;

 namespace osu.Game.Rulesets.Osu.Replays
 {
-    public abstract class OsuAutoGeneratorBase : AutoGenerator<OsuHitObject>
+    public abstract class OsuAutoGeneratorBase : AutoGenerator
    {
        #region Constants

@@ -35,7 +34,7 @@ namespace osu.Game.Rulesets.Osu.Replays
        protected Replay Replay;
        protected List<ReplayFrame> Frames => Replay.Frames;

-        protected OsuAutoGeneratorBase(Beatmap<OsuHitObject> beatmap)
+        protected OsuAutoGeneratorBase(IBeatmap beatmap)
            : base(beatmap)
        {
            Replay = new Replay();
@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
    {
        private int currentIndex;

-        private Shader shader;
+        private IShader shader;
        private Texture texture;

        private Vector2 size => texture.Size * Scale;
@@ -35,7 +35,6 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor

        public override bool IsPresent => true;

-        private readonly TrailDrawNodeSharedData trailDrawNodeSharedData = new TrailDrawNodeSharedData();
        private const int max_sprites = 2048;

        private readonly TrailPart[] parts = new TrailPart[max_sprites];
@@ -55,7 +54,6 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
            tNode.Texture = texture;
            tNode.Size = size;
            tNode.Time = time;
-            tNode.Shared = trailDrawNodeSharedData;

            for (int i = 0; i < parts.Length; ++i)
                if (parts[i].InvalidationID > tNode.Parts[i].InvalidationID)
@@ -81,7 +79,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
        [BackgroundDependencyLoader]
        private void load(ShaderManager shaders, TextureStore textures)
        {
-            shader = shaders?.Load(@"CursorTrail", FragmentShaderDescriptor.TEXTURE);
+            shader = shaders.Load(@"CursorTrail", FragmentShaderDescriptor.TEXTURE);
            texture = textures.Get(@"Cursor/cursortrail");
            Scale = new Vector2(1 / texture.ScaleAdjust);
        }
@@ -167,22 +165,18 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
            public bool WasUpdated;
        }

-        private class TrailDrawNodeSharedData
-        {
-            public VertexBuffer<TexturedTrailVertex> VertexBuffer;
-        }
-
        private class TrailDrawNode : DrawNode
        {
-            public Shader Shader;
+            public IShader Shader;
            public Texture Texture;

            public float Time;
-            public TrailDrawNodeSharedData Shared;

            public readonly TrailPart[] Parts = new TrailPart[max_sprites];
            public Vector2 Size;

+            private readonly VertexBuffer<TexturedTrailVertex> vertexBuffer = new QuadVertexBuffer<TexturedTrailVertex>(max_sprites, BufferUsageHint.DynamicDraw);
+
            public TrailDrawNode()
            {
                for (int i = 0; i < max_sprites; i++)
@@ -194,9 +188,6 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor

            public override void Draw(Action<TexturedVertex2D> vertexAction)
            {
-                if (Shared.VertexBuffer == null)
-                    Shared.VertexBuffer = new QuadVertexBuffer<TexturedTrailVertex>(max_sprites, BufferUsageHint.DynamicDraw);
-
                Shader.GetUniform<float>("g_FadeClock").UpdateValue(ref Time);

                int updateStart = -1, updateEnd = 0;
@@ -218,7 +209,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                            new Quad(pos.X - Size.X / 2, pos.Y - Size.Y / 2, Size.X, Size.Y),
                            DrawColourInfo.Colour,
                            null,
-                            v => Shared.VertexBuffer.Vertices[end++] = new TexturedTrailVertex
+                            v => vertexBuffer.Vertices[end++] = new TexturedTrailVertex
                            {
                                Position = v.Position,
                                TexturePosition = v.TexturePosition,
@@ -230,24 +221,31 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                    }
                    else if (updateStart != -1)
                    {
-                        Shared.VertexBuffer.UpdateRange(updateStart * 4, updateEnd * 4);
+                        vertexBuffer.UpdateRange(updateStart * 4, updateEnd * 4);
                        updateStart = -1;
                    }
                }

                // Update all remaining vertices that have been changed.
                if (updateStart != -1)
-                    Shared.VertexBuffer.UpdateRange(updateStart * 4, updateEnd * 4);
+                    vertexBuffer.UpdateRange(updateStart * 4, updateEnd * 4);

                base.Draw(vertexAction);

                Shader.Bind();

                Texture.TextureGL.Bind();
-                Shared.VertexBuffer.Draw();
+                vertexBuffer.Draw();

                Shader.Unbind();
            }
+
+            protected override void Dispose(bool isDisposing)
+            {
+                base.Dispose(isDisposing);
+
+                vertexBuffer.Dispose();
+            }
        }

        [StructLayout(LayoutKind.Sequential)]
@@ -17,7 +17,7 @@ using osuTK.Graphics;

 namespace osu.Game.Rulesets.Osu.UI.Cursor
 {
-    public class GameplayCursor : CursorContainer, IKeyBindingHandler<OsuAction>
+    public class GameplayCursorContainer : CursorContainer, IKeyBindingHandler<OsuAction>
    {
        protected override Drawable CreateCursor() => new OsuCursor();

@@ -25,7 +25,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor

        private readonly Container<Drawable> fadeContainer;

-        public GameplayCursor()
+        public GameplayCursorContainer()
        {
            InternalChild = fadeContainer = new Container
            {
@@ -103,7 +103,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
            public OsuCursor()
            {
                Origin = Anchor.Centre;
-                Size = new Vector2(42);
+                Size = new Vector2(28);
            }

            protected override void SkinChanged(ISkinSource skin, bool allowFallback)
@@ -10,7 +10,9 @@ using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Connections;
 using osu.Game.Rulesets.UI;
 using System.Linq;
+using osu.Framework.Graphics.Cursor;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Osu.UI.Cursor;

 namespace osu.Game.Rulesets.Osu.UI
 {
@@ -22,6 +24,12 @@ namespace osu.Game.Rulesets.Osu.UI

        public static readonly Vector2 BASE_SIZE = new Vector2(512, 384);

+        private readonly PlayfieldAdjustmentContainer adjustmentContainer;
+
+        protected override Container CursorTargetContainer => adjustmentContainer;
+
+        protected override CursorContainer CreateCursor() => new GameplayCursorContainer();
+
        public OsuPlayfield()
        {
            Anchor = Anchor.Centre;
@@ -29,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.UI

            Size = new Vector2(0.75f);

-            InternalChild = new PlayfieldAdjustmentContainer
+            InternalChild = adjustmentContainer = new PlayfieldAdjustmentContainer
            {
                RelativeSizeAxes = Axes.Both,
                Children = new Drawable[]
@@ -2,17 +2,16 @@
 // See the LICENCE file in the repository root for full licence text.

 using System.Linq;
-using osu.Framework.Graphics.Cursor;
 using osu.Framework.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Input.Handlers;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Configuration;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Rulesets.Osu.Scoring;
-using osu.Game.Rulesets.Osu.UI.Cursor;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;

@@ -20,6 +19,8 @@ namespace osu.Game.Rulesets.Osu.UI
 {
    public class OsuRulesetContainer : RulesetContainer<OsuPlayfield, OsuHitObject>
    {
+        protected new OsuRulesetConfigManager Config => (OsuRulesetConfigManager)base.Config;
+
        public OsuRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
            : base(ruleset, beatmap)
        {
@@ -56,7 +57,5 @@ namespace osu.Game.Rulesets.Osu.UI
                return first.StartTime - first.TimePreempt;
            }
        }
-
-        protected override CursorContainer CreateCursor() => new GameplayCursor();
    }
 }
@@ -3,34 +3,36 @@

 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Game.Configuration;
 using osu.Game.Overlays.Settings;
+using osu.Game.Rulesets.Osu.Configuration;

 namespace osu.Game.Rulesets.Osu.UI
 {
-    public class OsuSettings : RulesetSettingsSubsection
+    public class OsuSettingsSubsection : RulesetSettingsSubsection
    {
        protected override string Header => "osu!";

-        public OsuSettings(Ruleset ruleset)
+        public OsuSettingsSubsection(Ruleset ruleset)
            : base(ruleset)
        {
        }

        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
+        private void load()
        {
+            var config = (OsuRulesetConfigManager)Config;
+
            Children = new Drawable[]
            {
                new SettingsCheckbox
                {
                    LabelText = "Snaking in sliders",
-                    Bindable = config.GetBindable<bool>(OsuSetting.SnakingInSliders)
+                    Bindable = config.GetBindable<bool>(OsuRulesetSetting.SnakingInSliders)
                },
                new SettingsCheckbox
                {
                    LabelText = "Snaking out sliders",
-                    Bindable = config.GetBindable<bool>(OsuSetting.SnakingOutSliders)
+                    Bindable = config.GetBindable<bool>(OsuRulesetSetting.SnakingOutSliders)
                },
            };
        }
@@ -12,7 +12,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
 {
    public class TaikoModAutoplay : ModAutoplay<TaikoHitObject>
    {
-        protected override Score CreateReplayScore(Beatmap<TaikoHitObject> beatmap) => new Score
+        public override Score CreateReplayScore(IBeatmap beatmap) => new Score
        {
            ScoreInfo = new ScoreInfo { User = new User { Username = "mekkadosu!" } },
            Replay = new TaikoAutoGenerator(beatmap).Generate(),
@@ -9,14 +9,17 @@ using osu.Game.Replays;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.Taiko.Beatmaps;

 namespace osu.Game.Rulesets.Taiko.Replays
 {
-    public class TaikoAutoGenerator : AutoGenerator<TaikoHitObject>
+    public class TaikoAutoGenerator : AutoGenerator
    {
+        public new TaikoBeatmap Beatmap => (TaikoBeatmap)base.Beatmap;
+
        private const double swell_hit_speed = 50;

-        public TaikoAutoGenerator(Beatmap<TaikoHitObject> beatmap)
+        public TaikoAutoGenerator(IBeatmap beatmap)
            : base(beatmap)
        {
            Replay = new Replay();
@@ -11,6 +11,7 @@ using System.Collections.Generic;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Replays.Types;
+using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Rulesets.Taiko.Replays;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Rulesets.Difficulty;
@@ -99,6 +100,11 @@ namespace osu.Game.Rulesets.Taiko
                        new MultiMod(new TaikoModAutoplay(), new ModCinema()),
                        new TaikoModRelax(),
                    };
+                case ModType.Fun:
+                    return new Mod[]
+                    {
+                        new MultiMod(new ModWindUp<TaikoHitObject>(), new ModWindDown<TaikoHitObject>())
+                    };
                default:
                    return new Mod[] { };
            }
@@ -333,6 +333,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                Assert.AreEqual("hit_2.wav", getTestableSampleInfo(hitObjects[1]).LookupNames.First());
                Assert.AreEqual("normal-hitnormal2", getTestableSampleInfo(hitObjects[2]).LookupNames.First());
                Assert.AreEqual("hit_1.wav", getTestableSampleInfo(hitObjects[3]).LookupNames.First());
+                Assert.AreEqual(70, getTestableSampleInfo(hitObjects[3]).Volume);
            }

            SampleInfo getTestableSampleInfo(HitObject hitObject) => hitObject.SampleControlPoint.ApplyTo(hitObject.Samples[0]);
@@ -113,6 +113,7 @@ namespace osu.Game.Tests.Beatmaps.Formats

        [TestCase(normal)]
        [TestCase(marathon)]
+        [Ignore("temporarily disabled pending DeepEqual fix (https://github.com/jamesfoster/DeepEqual/pull/35)")]
        // Currently fails:
        // [TestCase(with_sb)]
        public void TestParity(string beatmap)
@@ -101,7 +101,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                    int fireCount = 0;

                    // ReSharper disable once AccessToModifiedClosure
-                    manager.ItemAdded += (_, __, ___) => fireCount++;
+                    manager.ItemAdded += (_, __) => fireCount++;
                    manager.ItemRemoved += _ => fireCount++;

                    var imported = LoadOszIntoOsu(osu);
@@ -13,4 +13,4 @@ SampleSet: Normal
 255,193,2170,1,0,0:0:0:0:hit_1.wav
 256,191,2638,5,0,0:0:0:0:hit_2.wav
 255,193,3107,1,0,0:0:0:0:
-256,191,3576,1,0,0:0:0:0:hit_1.wav
+256,191,3576,1,0,0:0:0:70:hit_1.wav
@@ -188,10 +188,10 @@ namespace osu.Game.Tests.Visual
        public void PauseTest()
        {
            performFullSetup(true);
-            AddStep("Pause", () => player.CurrentPauseContainer.Pause());
+            AddStep("Pause", () => player.CurrentPausableGameplayContainer.Pause());
            waitForDim();
            AddAssert("Screen is dimmed", () => songSelect.IsBackgroundDimmed());
-            AddStep("Unpause", () => player.CurrentPauseContainer.Resume());
+            AddStep("Unpause", () => player.CurrentPausableGameplayContainer.Resume());
            waitForDim();
            AddAssert("Screen is dimmed", () => songSelect.IsBackgroundDimmed());
        }
@@ -328,7 +328,7 @@ namespace osu.Game.Tests.Visual
                };
            }

-            public PauseContainer CurrentPauseContainer => PauseContainer;
+            public PausableGameplayContainer CurrentPausableGameplayContainer => PausableGameplayContainer;

            public UserDimContainer CurrentStoryboardContainer => StoryboardContainer;

@@ -23,9 +23,6 @@ namespace osu.Game.Tests.Visual
    [System.ComponentModel.Description("in BeatmapOverlay")]
    public class TestCaseBeatmapScoresContainer : OsuTestCase
    {
-        private readonly IEnumerable<APIScoreInfo> scores;
-        private readonly IEnumerable<APIScoreInfo> anotherScores;
-        private readonly APIScoreInfo topScoreInfo;
        private readonly Box background;

        public TestCaseBeatmapScoresContainer()
@@ -47,15 +44,7 @@ namespace osu.Game.Tests.Visual
                }
            };

-            AddStep("scores pack 1", () => scoresContainer.Scores = scores);
-            AddStep("scores pack 2", () => scoresContainer.Scores = anotherScores);
-            AddStep("only top score", () => scoresContainer.Scores = new[] { topScoreInfo });
-            AddStep("remove scores", () => scoresContainer.Scores = null);
-            AddStep("resize to big", () => container.ResizeWidthTo(1, 300));
-            AddStep("resize to normal", () => container.ResizeWidthTo(0.8f, 300));
-            AddStep("online scores", () => scoresContainer.Beatmap = new BeatmapInfo { OnlineBeatmapID = 75, Ruleset = new OsuRuleset().RulesetInfo });
-
-            scores = new[]
+            IEnumerable<APIScoreInfo> scores = new[]
            {
                new APIScoreInfo
                {
@@ -168,7 +157,7 @@ namespace osu.Game.Tests.Visual
                s.Statistics.Add(HitResult.Meh, RNG.Next(2000));
            }

-            anotherScores = new[]
+            IEnumerable<APIScoreInfo> anotherScores = new[]
            {
                new APIScoreInfo
                {
@@ -280,7 +269,7 @@ namespace osu.Game.Tests.Visual
                s.Statistics.Add(HitResult.Meh, RNG.Next(2000));
            }

-            topScoreInfo = new APIScoreInfo
+            var topScoreInfo = new APIScoreInfo
            {
                User = new User
                {
@@ -305,6 +294,14 @@ namespace osu.Game.Tests.Visual
            topScoreInfo.Statistics.Add(HitResult.Great, RNG.Next(2000));
            topScoreInfo.Statistics.Add(HitResult.Good, RNG.Next(2000));
            topScoreInfo.Statistics.Add(HitResult.Meh, RNG.Next(2000));
+
+            AddStep("scores pack 1", () => scoresContainer.Scores = scores);
+            AddStep("scores pack 2", () => scoresContainer.Scores = anotherScores);
+            AddStep("only top score", () => scoresContainer.Scores = new[] { topScoreInfo });
+            AddStep("remove scores", () => scoresContainer.Scores = null);
+            AddStep("resize to big", () => container.ResizeWidthTo(1, 300));
+            AddStep("resize to normal", () => container.ResizeWidthTo(0.8f, 300));
+            AddStep("online scores", () => scoresContainer.Beatmap = new BeatmapInfo { OnlineBeatmapID = 75, Ruleset = new OsuRuleset().RulesetInfo });
        }

        [BackgroundDependencyLoader]
@@ -0,0 +1,47 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Overlays.Direct;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Tests.Beatmaps;
+using osuTK;
+
+namespace osu.Game.Tests.Visual
+{
+    public class TestCaseDirectPanel : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(DirectGridPanel),
+            typeof(DirectListPanel),
+            typeof(IconPill)
+        };
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            var beatmap = new TestWorkingBeatmap(new OsuRuleset().RulesetInfo, null);
+            beatmap.BeatmapSetInfo.OnlineInfo.HasVideo = true;
+            beatmap.BeatmapSetInfo.OnlineInfo.HasStoryboard = true;
+
+            Child = new FillFlowContainer
+            {
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                Direction = FillDirection.Vertical,
+                Padding = new MarginPadding(20),
+                Spacing = new Vector2(0, 20),
+                Children = new Drawable[]
+                {
+                    new DirectGridPanel(beatmap.BeatmapSetInfo),
+                    new DirectListPanel(beatmap.BeatmapSetInfo)
+                }
+            };
+        }
+    }
+}
@@ -17,15 +17,15 @@ namespace osu.Game.Tests.Visual
    [Description("player pause/fail screens")]
    public class TestCaseGameplayMenuOverlay : ManualInputManagerTestCase
    {
-        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(FailOverlay), typeof(PauseContainer) };
+        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(FailOverlay), typeof(PausableGameplayContainer) };

        private FailOverlay failOverlay;
-        private PauseContainer.PauseOverlay pauseOverlay;
+        private PausableGameplayContainer.PauseOverlay pauseOverlay;

        [BackgroundDependencyLoader]
        private void load()
        {
-            Add(pauseOverlay = new PauseContainer.PauseOverlay
+            Add(pauseOverlay = new PausableGameplayContainer.PauseOverlay
            {
                OnResume = () => Logger.Log(@"Resume"),
                OnRetry = () => Logger.Log(@"Retry"),
@@ -1,10 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using System;
 using System.ComponentModel;
 using System.Linq;
 using osu.Game.Rulesets;
-using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
 using osu.Game.Screens.Play;

 namespace osu.Game.Tests.Visual
@@ -14,15 +16,27 @@ namespace osu.Game.Tests.Visual
    {
        protected override Player CreatePlayer(Ruleset ruleset)
        {
-            // We create a dummy RulesetContainer just to get the replay - we don't want to use mods here
-            // to simulate setting a replay rather than having the replay already set for us
-            Beatmap.Value.Mods.Value = Beatmap.Value.Mods.Value.Concat(new[] { ruleset.GetAutoplayMod() });
-            var dummyRulesetContainer = ruleset.CreateRulesetContainerWith(Beatmap.Value);
+            var beatmap = Beatmap.Value.GetPlayableBeatmap(ruleset.RulesetInfo);

-            // Reset the mods
-            Beatmap.Value.Mods.Value = Beatmap.Value.Mods.Value.Where(m => !(m is ModAutoplay));
+            return new ScoreAccessibleReplayPlayer(ruleset.GetAutoplayMod().CreateReplayScore(beatmap));
+        }

-            return new ReplayPlayer(dummyRulesetContainer.ReplayScore);
+        protected override void AddCheckSteps(Func<Player> player)
+        {
+            base.AddCheckSteps(player);
+            AddUntilStep(() => ((ScoreAccessibleReplayPlayer)player()).ScoreProcessor.TotalScore.Value > 0, "score above zero");
+            AddUntilStep(() => ((ScoreAccessibleReplayPlayer)player()).HUDOverlay.KeyCounter.Children.Any(kc => kc.CountPresses > 0), "key counter counted keys");
+        }
+
+        private class ScoreAccessibleReplayPlayer : ReplayPlayer
+        {
+            public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
+            public new HUDOverlay HUDOverlay => base.HUDOverlay;
+
+            public ScoreAccessibleReplayPlayer(Score score)
+                : base(score)
+            {
+            }
        }
    }
 }
@@ -3,6 +3,7 @@

 using System.Collections.Generic;
 using NUnit.Framework;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.MathUtils;
 using osu.Framework.Timing;
@@ -19,14 +20,20 @@ namespace osu.Game.Tests.Visual

        private readonly StopwatchClock clock;

+        [Cached]
+        private readonly GameplayClock gameplayClock;
+
+        private readonly FramedClock framedClock;
+
        public TestCaseSongProgress()
        {
            clock = new StopwatchClock(true);

+            gameplayClock = new GameplayClock(framedClock = new FramedClock(clock));
+
            Add(progress = new SongProgress
            {
                RelativeSizeAxes = Axes.X,
-                AudioClock = new StopwatchClock(true),
                Anchor = Anchor.BottomLeft,
                Origin = Anchor.BottomLeft,
            });
@@ -68,8 +75,13 @@ namespace osu.Game.Tests.Visual
            progress.Objects = objects;
            graph.Objects = objects;

-            progress.AudioClock = clock;
-            progress.OnSeek = pos => clock.Seek(pos);
+            progress.RequestSeek = pos => clock.Seek(pos);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+            framedClock.ProcessFrame();
        }

        private class TestSongProgressGraph : SongProgressGraph
@@ -24,10 +24,13 @@ namespace osu.Game.Tests.Visual
        public TestCaseToolbar()
        {
            var toolbar = new Toolbar { State = Visibility.Visible };
+            ToolbarNotificationButton notificationButton = null;

-            Add(toolbar);
-
-            var notificationButton = toolbar.Children.OfType<FillFlowContainer>().Last().Children.OfType<ToolbarNotificationButton>().First();
+            AddStep("create toolbar", () =>
+            {
+                Add(toolbar);
+                notificationButton = toolbar.Children.OfType<FillFlowContainer>().Last().Children.OfType<ToolbarNotificationButton>().First();
+            });

            void setNotifications(int count) => AddStep($"set notification count to {count}", () => notificationButton.NotificationCount.Value = count);

@@ -16,7 +16,7 @@ namespace osu.Game.Tests.Visual
 {
    public class TestCaseUpdateableBeatmapBackgroundSprite : OsuTestCase
    {
-        private UpdateableBeatmapBackgroundSprite backgroundSprite;
+        private TestUpdateableBeatmapBackgroundSprite backgroundSprite;

        [Resolved]
        private BeatmapManager beatmaps { get; set; }
@@ -28,30 +28,36 @@ namespace osu.Game.Tests.Visual

            var imported = ImportBeatmapTest.LoadOszIntoOsu(osu);

-            Child = backgroundSprite = new UpdateableBeatmapBackgroundSprite { RelativeSizeAxes = Axes.Both };
+            Child = backgroundSprite = new TestUpdateableBeatmapBackgroundSprite { RelativeSizeAxes = Axes.Both };

            backgroundSprite.Beatmap.BindTo(beatmapBindable);

            var req = new GetBeatmapSetRequest(1);
            api.Queue(req);

-            AddStep("null", () => beatmapBindable.Value = null);
-
-            AddStep("imported", () => beatmapBindable.Value = imported.Beatmaps.First());
+            AddStep("load null beatmap", () => beatmapBindable.Value = null);
+            AddUntilStep(() => backgroundSprite.ChildCount == 1, "wait for cleanup...");
+            AddStep("load imported beatmap", () => beatmapBindable.Value = imported.Beatmaps.First());
+            AddUntilStep(() => backgroundSprite.ChildCount == 1, "wait for cleanup...");

            if (api.IsLoggedIn)
            {
                AddUntilStep(() => req.Result != null, "wait for api response");
-
-                AddStep("online", () => beatmapBindable.Value = new BeatmapInfo
+                AddStep("load online beatmap", () => beatmapBindable.Value = new BeatmapInfo
                {
                    BeatmapSet = req.Result?.ToBeatmapSet(rulesets)
                });
+                AddUntilStep(() => backgroundSprite.ChildCount == 1, "wait for cleanup...");
            }
            else
            {
                AddStep("online (login first)", () => { });
            }
        }
+
+        private class TestUpdateableBeatmapBackgroundSprite : UpdateableBeatmapBackgroundSprite
+        {
+            public int ChildCount => InternalChildren.Count;
+        }
    }
 }
@@ -11,7 +11,6 @@ using Microsoft.EntityFrameworkCore;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Track;
 using osu.Framework.Extensions;
-using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Logging;
 using osu.Framework.Platform;
@@ -50,11 +49,6 @@ namespace osu.Game.Beatmaps
        /// </summary>
        public event Action<DownloadBeatmapSetRequest> BeatmapDownloadFailed;

-        /// <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>
@@ -151,8 +145,7 @@ namespace osu.Game.Beatmaps

            var downloadNotification = new DownloadNotification
            {
-                CompletionText = $"Imported {beatmapSetInfo.Metadata.Artist} - {beatmapSetInfo.Metadata.Title}!",
-                Text = $"Downloading {beatmapSetInfo.Metadata.Artist} - {beatmapSetInfo.Metadata.Title}",
+                Text = $"Downloading {beatmapSetInfo}",
            };

            var request = new DownloadBeatmapSetRequest(beatmapSetInfo, noVideo);
@@ -165,20 +158,10 @@ namespace osu.Game.Beatmaps

            request.Success += filename =>
            {
-                downloadNotification.Text = $"Importing {beatmapSetInfo.Metadata.Artist} - {beatmapSetInfo.Metadata.Title}";
-
                Task.Factory.StartNew(() =>
                {
                    // This gets scheduled back to the update thread, but we want the import to run in the background.
-                    var importedBeatmap = Import(filename);
-
-                    downloadNotification.CompletionClickAction = () =>
-                    {
-                        PresentCompletedImport(importedBeatmap.Yield());
-                        return true;
-                    };
-                    downloadNotification.State = ProgressNotificationState.Completed;
-
+                    Import(downloadNotification, filename);
                    currentDownloads.Remove(request);
                }, TaskCreationOptions.LongRunning);
            };
@@ -221,12 +204,6 @@ namespace osu.Game.Beatmaps
            return true;
        }

-        protected override void PresentCompletedImport(IEnumerable<BeatmapSetInfo> imported)
-        {
-            base.PresentCompletedImport(imported);
-            PresentBeatmap?.Invoke(imported.LastOrDefault());
-        }
-
        /// <summary>
        /// Get an existing download request if it exists.
        /// </summary>
@@ -48,11 +48,11 @@ namespace osu.Game.Beatmaps.Drawables

            var rating = beatmap.StarDifficulty;

-            if (rating < 1.5) return DifficultyRating.Easy;
-            if (rating < 2.25) return DifficultyRating.Normal;
-            if (rating < 3.75) return DifficultyRating.Hard;
-            if (rating < 5.25) return DifficultyRating.Insane;
-            if (rating < 6.75) return DifficultyRating.Expert;
+            if (rating < 2.0) return DifficultyRating.Easy;
+            if (rating < 2.7) return DifficultyRating.Normal;
+            if (rating < 4.0) return DifficultyRating.Hard;
+            if (rating < 5.3) return DifficultyRating.Insane;
+            if (rating < 6.5) return DifficultyRating.Expert;

            return DifficultyRating.ExpertPlus;
        }
@@ -9,7 +9,7 @@ using osu.Framework.Graphics.Containers;
 namespace osu.Game.Beatmaps.Drawables
 {
    /// <summary>
-    /// Display a baetmap background from a local source, but fallback to online source if not available.
+    /// Display a beatmap background from a local source, but fallback to online source if not available.
    /// </summary>
    public class UpdateableBeatmapBackgroundSprite : ModelBackedDrawable<BeatmapInfo>
    {
@@ -18,34 +18,59 @@ namespace osu.Game.Beatmaps.Drawables
        [Resolved]
        private BeatmapManager beatmaps { get; set; }

-        public UpdateableBeatmapBackgroundSprite()
+        private readonly BeatmapSetCoverType beatmapSetCoverType;
+
+        public UpdateableBeatmapBackgroundSprite(BeatmapSetCoverType beatmapSetCoverType = BeatmapSetCoverType.Cover)
        {
            Beatmap.BindValueChanged(b => Model = b.NewValue);
+            this.beatmapSetCoverType = beatmapSetCoverType;
+        }
+
+        private BeatmapInfo lastModel;
+
+        protected override DelayedLoadWrapper CreateDelayedLoadWrapper(Drawable content, double timeBeforeLoad)
+        {
+            return new DelayedLoadUnloadWrapper(() =>
+            {
+                // If DelayedLoadUnloadWrapper is attempting to RELOAD the same content (Beatmap), that means that it was
+                // previously UNLOADED and thus its children have been disposed of, so we need to recreate them here.
+                if (lastModel == Beatmap.Value && Beatmap.Value != null)
+                    return CreateDrawable(Beatmap.Value);
+
+                // If the model has changed since the previous unload (or if there was no load), then we can safely use the given content
+                lastModel = Beatmap.Value;
+                return content;
+            }, timeBeforeLoad, 10000);
        }

        protected override Drawable CreateDrawable(BeatmapInfo model)
        {
-            return new DelayedLoadUnloadWrapper(() =>
+            Drawable drawable;
+
+            var localBeatmap = beatmaps.GetWorkingBeatmap(model);
+
+            if (model?.BeatmapSet?.OnlineInfo != null)
            {
-                Drawable drawable;
+                drawable = new BeatmapSetCover(model.BeatmapSet, beatmapSetCoverType);
+            }
+            else if (localBeatmap.BeatmapInfo.ID != 0)
+            {
+                // Fall back to local background if one exists
+                drawable = new BeatmapBackgroundSprite(localBeatmap);
+            }
+            else
+            {
+                // Use the default background if somehow an online set does not exist and we don't have a local copy.
+                drawable = new BeatmapBackgroundSprite(beatmaps.DefaultBeatmap);
+            }

-                var localBeatmap = beatmaps.GetWorkingBeatmap(model);
+            drawable.RelativeSizeAxes = Axes.Both;
+            drawable.Anchor = Anchor.Centre;
+            drawable.Origin = Anchor.Centre;
+            drawable.FillMode = FillMode.Fill;
+            drawable.OnLoadComplete = d => d.FadeInFromZero(400);

-                if (localBeatmap.BeatmapInfo.ID == 0 && model?.BeatmapSet?.OnlineInfo != null)
-                    drawable = new BeatmapSetCover(model.BeatmapSet);
-                else
-                    drawable = new BeatmapBackgroundSprite(localBeatmap);
-
-                drawable.RelativeSizeAxes = Axes.Both;
-                drawable.Anchor = Anchor.Centre;
-                drawable.Origin = Anchor.Centre;
-                drawable.FillMode = FillMode.Fill;
-                drawable.OnLoadComplete = d => d.FadeInFromZero(400);
-
-                return drawable;
-            }, 500, 10000);
+            return drawable;
        }
-
-        protected override double FadeDuration => 0;
    }
 }
@@ -72,9 +72,6 @@ namespace osu.Game.Configuration

            Set(OsuSetting.MenuParallax, true);

-            Set(OsuSetting.SnakingInSliders, true);
-            Set(OsuSetting.SnakingOutSliders, true);
-
            // Gameplay
            Set(OsuSetting.DimLevel, 0.3, 0, 1, 0.01);
            Set(OsuSetting.BlurLevel, 0, 0, 1, 0.01);
@@ -150,8 +147,6 @@ namespace osu.Game.Configuration
        DisplayStarsMinimum,
        DisplayStarsMaximum,
        RandomSelectAlgorithm,
-        SnakingInSliders,
-        SnakingOutSliders,
        ShowFpsDisplay,
        ChatDisplayHeight,
        Version,
@@ -33,7 +33,7 @@ namespace osu.Game.Database
        where TModel : class, IHasFiles<TFileModel>, IHasPrimaryKey, ISoftDelete
        where TFileModel : INamedFileInfo, new()
    {
-        public delegate void ItemAddedDelegate(TModel model, bool existing, bool silent);
+        public delegate void ItemAddedDelegate(TModel model, bool existing);

        /// <summary>
        /// Set an endpoint for notifications to be posted to.
@@ -113,7 +113,7 @@ namespace osu.Game.Database
            ContextFactory = contextFactory;

            ModelStore = modelStore;
-            ModelStore.ItemAdded += (item, silent) => handleEvent(() => ItemAdded?.Invoke(item, false, silent));
+            ModelStore.ItemAdded += item => handleEvent(() => ItemAdded?.Invoke(item, false));
            ModelStore.ItemRemoved += s => handleEvent(() => ItemRemoved?.Invoke(s));

            Files = new FileStore(contextFactory, storage);
@@ -131,14 +131,18 @@ 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
-            {
-                Text = "Import is initialising...",
-                Progress = 0,
-                State = ProgressNotificationState.Active,
-            };
+            var notification = new ProgressNotification { State = ProgressNotificationState.Active };

            PostNotification?.Invoke(notification);
+            Import(notification, paths);
+        }
+
+        protected void Import(ProgressNotification notification, params string[] paths)
+        {
+            notification.Progress = 0;
+            notification.Text = "Import is initialising...";
+
+            var term = $"{typeof(TModel).Name.Replace("Info", "").ToLower()}";

            List<TModel> imported = new List<TModel>();

@@ -151,7 +155,18 @@ namespace osu.Game.Database

                try
                {
-                    notification.Text = $"Importing ({++current} of {paths.Length})\n{Path.GetFileName(path)}";
+                    var text = "Importing ";
+
+                    if (path.Length > 1)
+                        text += $"{++current} of {paths.Length} {term}s..";
+                    else
+                        text += $"{term}..";
+
+                    // only show the filename if it isn't a temporary one (as those look ugly).
+                    if (!path.Contains(Path.GetTempPath()))
+                        text += $"\n{Path.GetFileName(path)}";
+
+                    notification.Text = text;

                    imported.Add(Import(path));

@@ -171,13 +186,20 @@ namespace osu.Game.Database
            }
            else
            {
-                notification.CompletionText = $"Imported {current} {typeof(TModel).Name.Replace("Info", "").ToLower()}s!";
-                notification.CompletionClickAction += () =>
+                notification.CompletionText = imported.Count == 1
+                    ? $"Imported {imported.First()}!"
+                    : $"Imported {current} {term}s!";
+
+                if (imported.Count > 0 && PresentImport != null)
                {
-                    if (imported.Count > 0)
-                        PresentCompletedImport(imported);
-                    return true;
-                };
+                    notification.CompletionText += " Click to view.";
+                    notification.CompletionClickAction = () =>
+                    {
+                        PresentImport?.Invoke(imported);
+                        return true;
+                    };
+                }
+
                notification.State = ProgressNotificationState.Completed;
            }
        }
@@ -210,9 +232,10 @@ namespace osu.Game.Database
            return import;
        }

-        protected virtual void PresentCompletedImport(IEnumerable<TModel> imported)
-        {
-        }
+        /// <summary>
+        /// Fired when the user requests to view the resulting import.
+        /// </summary>
+        public Action<IEnumerable<TModel>> PresentImport;

        /// <summary>
        /// Import an item from an <see cref="ArchiveReader"/>.
@@ -228,7 +251,7 @@ namespace osu.Game.Database

                model.Hash = computeHash(archive);

-                return Import(model, false, archive);
+                return Import(model, archive);
            }
            catch (Exception e)
            {
@@ -262,9 +285,8 @@ namespace osu.Game.Database
        /// Import an item from a <see cref="TModel"/>.
        /// </summary>
        /// <param name="item">The model to be imported.</param>
-        /// <param name="silent">Whether the user should be notified fo the import.</param>
        /// <param name="archive">An optional archive to use for model population.</param>
-        public TModel Import(TModel item, bool silent = false, ArchiveReader archive = null)
+        public TModel Import(TModel item, ArchiveReader archive = null)
        {
            delayEvents();

@@ -284,7 +306,7 @@ namespace osu.Game.Database
                        {
                            Undelete(existing);
                            Logger.Log($"Found existing {typeof(TModel)} for {item} (ID {existing.ID}). Skipping import.", LoggingTarget.Database);
-                            handleEvent(() => ItemAdded?.Invoke(existing, true, silent));
+                            handleEvent(() => ItemAdded?.Invoke(existing, true));
                            return existing;
                        }

@@ -294,7 +316,7 @@ namespace osu.Game.Database
                        Populate(item, archive);

                        // import to store
-                        ModelStore.Add(item, silent);
+                        ModelStore.Add(item);
                    }
                    catch (Exception e)
                    {
@@ -16,9 +16,7 @@ namespace osu.Game.Database
    public abstract class MutableDatabaseBackedStore<T> : DatabaseBackedStore
        where T : class, IHasPrimaryKey, ISoftDelete
    {
-        public delegate void ItemAddedDelegate(T model, bool silent);
-
-        public event ItemAddedDelegate ItemAdded;
+        public event Action<T> ItemAdded;
        public event Action<T> ItemRemoved;

        protected MutableDatabaseBackedStore(IDatabaseContextFactory contextFactory, Storage storage = null)
@@ -35,8 +33,7 @@ namespace osu.Game.Database
        /// Add a <see cref="T"/> to the database.
        /// </summary>
        /// <param name="item">The item to add.</param>
-        /// <param name="silent">Whether the user should be notified of the addition.</param>
-        public void Add(T item, bool silent)
+        public void Add(T item)
        {
            using (var usage = ContextFactory.GetForWrite())
            {
@@ -44,7 +41,7 @@ namespace osu.Game.Database
                context.Attach(item);
            }

-            ItemAdded?.Invoke(item, silent);
+            ItemAdded?.Invoke(item);
        }

        /// <summary>
@@ -57,7 +54,7 @@ namespace osu.Game.Database
                usage.Context.Update(item);

            ItemRemoved?.Invoke(item);
-            ItemAdded?.Invoke(item, true);
+            ItemAdded?.Invoke(item);
        }

        /// <summary>
@@ -94,7 +91,7 @@ namespace osu.Game.Database
                item.DeletePending = false;
            }

-            ItemAdded?.Invoke(item, true);
+            ItemAdded?.Invoke(item);
            return true;
        }

@@ -64,7 +64,7 @@ namespace osu.Game.Graphics.Backgrounds

        private readonly SortedList<TriangleParticle> parts = new SortedList<TriangleParticle>(Comparer<TriangleParticle>.Default);

-        private Shader shader;
+        private IShader shader;
        private readonly Texture texture;

        public Triangles()
@@ -75,7 +75,7 @@ namespace osu.Game.Graphics.Backgrounds
        [BackgroundDependencyLoader]
        private void load(ShaderManager shaders)
        {
-            shader = shaders?.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE_ROUNDED);
+            shader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE_ROUNDED);
        }

        protected override void LoadComplete()
@@ -180,8 +180,6 @@ namespace osu.Game.Graphics.Backgrounds

        protected override DrawNode CreateDrawNode() => new TrianglesDrawNode();

-        private readonly TrianglesDrawNodeSharedData sharedData = new TrianglesDrawNodeSharedData();
-
        protected override void ApplyDrawNode(DrawNode node)
        {
            base.ApplyDrawNode(node);
@@ -191,27 +189,21 @@ namespace osu.Game.Graphics.Backgrounds
            trianglesNode.Shader = shader;
            trianglesNode.Texture = texture;
            trianglesNode.Size = DrawSize;
-            trianglesNode.Shared = sharedData;

            trianglesNode.Parts.Clear();
            trianglesNode.Parts.AddRange(parts);
        }

-        private class TrianglesDrawNodeSharedData
-        {
-            public readonly LinearBatch<TexturedVertex2D> VertexBatch = new LinearBatch<TexturedVertex2D>(100 * 3, 10, PrimitiveType.Triangles);
-        }
-
        private class TrianglesDrawNode : DrawNode
        {
-            public Shader Shader;
+            public IShader Shader;
            public Texture Texture;

-            public TrianglesDrawNodeSharedData Shared;
-
            public readonly List<TriangleParticle> Parts = new List<TriangleParticle>();
            public Vector2 Size;

+            private readonly LinearBatch<TexturedVertex2D> vertexBatch = new LinearBatch<TexturedVertex2D>(100 * 3, 10, PrimitiveType.Triangles);
+
            public override void Draw(Action<TexturedVertex2D> vertexAction)
            {
                base.Draw(vertexAction);
@@ -239,12 +231,19 @@ namespace osu.Game.Graphics.Backgrounds
                        triangle,
                        colourInfo,
                        null,
-                        Shared.VertexBatch.AddAction,
+                        vertexBatch.AddAction,
                        Vector2.Divide(localInflationAmount, size));
                }

                Shader.Unbind();
            }
+
+            protected override void Dispose(bool isDisposing)
+            {
+                base.Dispose(isDisposing);
+
+                vertexBatch.Dispose();
+            }
        }

        protected struct TriangleParticle : IComparable<TriangleParticle>
@@ -24,6 +24,12 @@ namespace osu.Game.Graphics.Containers

        protected override bool BlockNonPositionalInput => true;

+        /// <summary>
+        /// Temporary to allow for overlays in the main screen content to not dim theirselves.
+        /// Should be eventually replaced by dimming which is aware of the target dim container (traverse parent for certain interface type?).
+        /// </summary>
+        protected virtual bool DimMainContent => true;
+
        [Resolved(CanBeNull = true)]
        private OsuGame osuGame { get; set; }

@@ -95,7 +101,7 @@ namespace osu.Game.Graphics.Containers
                    if (OverlayActivationMode.Value != OverlayActivation.Disabled)
                    {
                        if (PlaySamplesOnStateChange) samplePopIn?.Play();
-                        if (BlockScreenWideMouse) osuGame?.AddBlockingOverlay(this);
+                        if (BlockScreenWideMouse && DimMainContent) osuGame?.AddBlockingOverlay(this);
                    }
                    else
                        State = Visibility.Hidden;
@@ -69,7 +69,7 @@ namespace osu.Game.Graphics.UserInterface
            {
                Masking = true,
                RelativeSizeAxes = Axes.Both,
-                Child = path = new SmoothPath { RelativeSizeAxes = Axes.Both, PathWidth = 1 }
+                Child = path = new SmoothPath { RelativeSizeAxes = Axes.Both, PathRadius = 1 }
            });
        }

@@ -102,9 +102,10 @@ namespace osu.Game.Graphics.UserInterface

            for (int i = 0; i < values.Length; i++)
            {
-                float x = (i + count - values.Length) / (float)(count - 1) * DrawWidth - 1;
-                float y = GetYPosition(values[i]) * DrawHeight - 1;
-                // the -1 is for inner offset in path (actually -PathWidth)
+                // Make sure that we are accounting for path width when calculating vertex positions
+                // We need to apply 2x the path radius to account for it because the full diameter of the line accounts into height
+                float x = (i + count - values.Length) / (float)(count - 1) * (DrawWidth - 2 * path.PathRadius);
+                float y = GetYPosition(values[i]) * (DrawHeight - 2 * path.PathRadius);
                path.AddVertex(new Vector2(x, y));
            }
        }
@@ -59,7 +59,6 @@ namespace osu.Game.Graphics.UserInterface

        public abstract void Increment(T amount);

-
        public float TextSize
        {
            get => DisplayedCountSpriteText.Font.Size;
@@ -70,13 +70,15 @@ namespace osu.Game.Online.API

        internal new void Schedule(Action action) => base.Schedule(action);

+        /// <summary>
+        /// Register a component to receive API events.
+        /// Fires <see cref="IOnlineComponent.APIStateChanged"/> once immediately to ensure a correct state.
+        /// </summary>
+        /// <param name="component"></param>
        public void Register(IOnlineComponent component)
        {
-            Scheduler.Add(delegate
-            {
-                components.Add(component);
-                component.APIStateChanged(this, state);
-            });
+            Scheduler.Add(delegate { components.Add(component); });
+            component.APIStateChanged(this, state);
        }

        public void Unregister(IOnlineComponent component)
@@ -36,11 +36,12 @@ namespace osu.Game.Online.API.Requests

        [Description("Ranked & Approved")]
        RankedApproved = 0,
-        Approved = 1,
+        Qualified = 3,
        Loved = 8,
        Favourites = 2,
-        Qualified = 3,
-        Pending = 4,
+
+        [Description("Pending & WIP")]
+        PendingWIP = 4,
        Graveyard = 5,

        [Description("My Maps")]
@@ -213,12 +213,6 @@ namespace osu.Game.Online.Leaderboards
            pendingUpdateScores?.Cancel();
            pendingUpdateScores = Schedule(() =>
            {
-                if (api?.IsLoggedIn != true)
-                {
-                    PlaceholderState = PlaceholderState.NotLoggedIn;
-                    return;
-                }
-
                PlaceholderState = PlaceholderState.Retrieving;
                loading.Show();

@@ -231,6 +225,12 @@ namespace osu.Game.Online.Leaderboards
                if (getScoresRequest == null)
                    return;

+                if (api?.IsLoggedIn != true)
+                {
+                    PlaceholderState = PlaceholderState.NotLoggedIn;
+                    return;
+                }
+
                getScoresRequest.Failure += e => Schedule(() =>
                {
                    if (e is OperationCanceledException)
@@ -243,6 +243,11 @@ namespace osu.Game.Online.Leaderboards
            });
        }

+        /// <summary>
+        /// Performs a fetch/refresh of scores to be displayed.
+        /// </summary>
+        /// <param name="scoresCallback">A callback which should be called when fetching is completed. Scheduling is not required.</param>
+        /// <returns>An <see cref="APIRequest"/> responsible for the fetch operation. This will be queued and performed automatically.</returns>
        protected abstract APIRequest FetchScores(Action<IEnumerable<ScoreInfo>> scoresCallback);

        private Placeholder currentPlaceholder;
@@ -124,6 +124,7 @@ namespace osu.Game.Online.Multiplayer
            if (other.Host.Value != null && Host.Value?.Id != other.Host.Value.Id)
                Host.Value = other.Host.Value;

+            ChannelId.Value = other.ChannelId.Value;
            Status.Value = other.Status.Value;
            Availability.Value = other.Availability.Value;
            Type.Value = other.Type.Value;
@@ -167,8 +167,6 @@ namespace osu.Game
        {
            this.frameworkConfig = frameworkConfig;

-            ScoreManager.ItemAdded += (score, _, silent) => Schedule(() => LoadScore(score, silent));
-
            if (!Host.IsPrimaryInstance)
            {
                Logger.Log(@"osu! does not support multiple running instances.", LoggingTarget.Runtime, LogLevel.Error);
@@ -217,63 +215,12 @@ namespace osu.Game
            externalLinkOpener.OpenUrlExternally(url);
        }

-        private ScheduledDelegate scoreLoad;
-
        /// <summary>
        /// Show a beatmap set as an overlay.
        /// </summary>
        /// <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)
-        {
-            if (menuScreen == null)
-            {
-                Schedule(() => PresentBeatmap(beatmap));
-                return;
-            }
-
-            CloseAllOverlays(false);
-
-            void setBeatmap()
-            {
-                if (Beatmap.Disabled)
-                {
-                    Schedule(setBeatmap);
-                    return;
-                }
-
-                var databasedSet = beatmap.OnlineBeatmapSetID != null ? BeatmapManager.QueryBeatmapSet(s => s.OnlineBeatmapSetID == beatmap.OnlineBeatmapSetID) : BeatmapManager.QueryBeatmapSet(s => s.Hash == beatmap.Hash);
-
-                if (databasedSet != null)
-                {
-                    // Use first beatmap available for current ruleset, else switch ruleset.
-                    var first = databasedSet.Beatmaps.Find(b => b.Ruleset == ruleset.Value) ?? databasedSet.Beatmaps.First();
-
-                    ruleset.Value = first.Ruleset;
-                    Beatmap.Value = BeatmapManager.GetWorkingBeatmap(first);
-                }
-            }
-
-            switch (screenStack.CurrentScreen)
-            {
-                case SongSelect _:
-                    break;
-                default:
-                    // navigate to song select if we are not already there.
-
-                    menuScreen.MakeCurrent();
-                    menuScreen.LoadToSolo();
-                    break;
-            }
-
-            setBeatmap();
-        }
-
        /// <summary>
        /// Show a user's profile as an overlay.
        /// </summary>
@@ -286,19 +233,44 @@ namespace osu.Game
        /// <param name="beatmapId">The beatmap to show.</param>
        public void ShowBeatmap(int beatmapId) => beatmapSetOverlay.FetchAndShowBeatmap(beatmapId);

-        protected void LoadScore(ScoreInfo score, bool silent)
+        /// <summary>
+        /// Present a beatmap at song select immediately.
+        /// The user should have already requested this interactively.
+        /// </summary>
+        /// <param name="beatmap">The beatmap to select.</param>
+        public void PresentBeatmap(BeatmapSetInfo beatmap)
        {
-            if (silent)
-                return;
+            var databasedSet = beatmap.OnlineBeatmapSetID != null
+                ? BeatmapManager.QueryBeatmapSet(s => s.OnlineBeatmapSetID == beatmap.OnlineBeatmapSetID)
+                : BeatmapManager.QueryBeatmapSet(s => s.Hash == beatmap.Hash);

-            scoreLoad?.Cancel();
-
-            if (menuScreen == null)
+            if (databasedSet == null)
            {
-                scoreLoad = Schedule(() => LoadScore(score, false));
+                Logger.Log("The requested beatmap could not be loaded.", LoggingTarget.Information);
                return;
            }

+            performFromMainMenu(() =>
+            {
+                // we might already be at song select, so a check is required before performing the load to solo.
+                if (menuScreen.IsCurrentScreen())
+                    menuScreen.LoadToSolo();
+
+                // Use first beatmap available for current ruleset, else switch ruleset.
+                var first = databasedSet.Beatmaps.Find(b => b.Ruleset == ruleset.Value) ?? databasedSet.Beatmaps.First();
+
+                ruleset.Value = first.Ruleset;
+                Beatmap.Value = BeatmapManager.GetWorkingBeatmap(first);
+            }, $"load {beatmap}", bypassScreenAllowChecks: true, targetScreen: typeof(PlaySongSelect));
+        }
+
+        /// <summary>
+        /// Present a score's replay immediately.
+        /// The user should have already requested this interactively.
+        /// </summary>
+        /// <param name="beatmap">The beatmap to select.</param>
+        public void PresentScore(ScoreInfo score)
+        {
            var databasedScore = ScoreManager.GetScore(score);
            var databasedScoreInfo = databasedScore.ScoreInfo;
            if (databasedScore.Replay == null)
@@ -314,14 +286,40 @@ namespace osu.Game
                return;
            }

-            if ((screenStack.CurrentScreen as IOsuScreen)?.AllowExternalScreenChange == false)
+            performFromMainMenu(() =>
+            {
+                ruleset.Value = databasedScoreInfo.Ruleset;
+
+                Beatmap.Value = BeatmapManager.GetWorkingBeatmap(databasedBeatmap);
+                Beatmap.Value.Mods.Value = databasedScoreInfo.Mods;
+
+                menuScreen.Push(new PlayerLoader(() => new ReplayPlayer(databasedScore)));
+            }, $"watch {databasedScoreInfo}", bypassScreenAllowChecks: true);
+        }
+
+        private ScheduledDelegate performFromMainMenuTask;
+
+        /// <summary>
+        /// Perform an action only after returning to the main menu.
+        /// Eagerly tries to exit the current screen until it succeeds.
+        /// </summary>
+        /// <param name="action">The action to perform once we are in the correct state.</param>
+        /// <param name="taskName">The task name to display in a notification (if we can't immediately reach the main menu state).</param>
+        /// <param name="targetScreen">An optional target screen type. If this screen is already current we can immediately perform the action without returning to the menu.</param>
+        /// <param name="bypassScreenAllowChecks">Whether checking <see cref="IOsuScreen.AllowExternalScreenChange"/> should be bypassed.</param>
+        private void performFromMainMenu(Action action, string taskName, Type targetScreen = null, bool bypassScreenAllowChecks = false)
+        {
+            performFromMainMenuTask?.Cancel();
+
+            // if the current screen does not allow screen changing, give the user an option to try again later.
+            if (!bypassScreenAllowChecks && (screenStack.CurrentScreen as IOsuScreen)?.AllowExternalScreenChange == false)
            {
                notifications.Post(new SimpleNotification
                {
-                    Text = $"Click here to watch {databasedScoreInfo.User.Username} on {databasedScoreInfo.Beatmap}",
+                    Text = $"Click here to {taskName}",
                    Activated = () =>
                    {
-                        loadScore();
+                        performFromMainMenu(action, taskName, targetScreen, true);
                        return true;
                    }
                });
@@ -329,24 +327,26 @@ namespace osu.Game
                return;
            }

-            loadScore();
+            CloseAllOverlays(false);

-            void loadScore()
+            // we may already be at the target screen type.
+            if (targetScreen != null && screenStack.CurrentScreen?.GetType() == targetScreen)
            {
-                if (!menuScreen.IsCurrentScreen() || Beatmap.Disabled)
-                {
-                    menuScreen.MakeCurrent();
-                    this.Delay(500).Schedule(loadScore, out scoreLoad);
-                    return;
-                }
-
-                ruleset.Value = databasedScoreInfo.Ruleset;
-
-                Beatmap.Value = BeatmapManager.GetWorkingBeatmap(databasedBeatmap);
-                Beatmap.Value.Mods.Value = databasedScoreInfo.Mods;
-
-                menuScreen.Push(new PlayerLoader(() => new ReplayPlayer(databasedScore)));
+                action();
+                return;
            }
+
+            // all conditions have been met to continue with the action.
+            if (menuScreen?.IsCurrentScreen() == true && !Beatmap.Disabled)
+            {
+                action();
+                return;
+            }
+
+            // menuScreen may not be initialised yet (null check required).
+            menuScreen?.MakeCurrent();
+
+            performFromMainMenuTask = Schedule(() => performFromMainMenu(action, taskName));
        }

        protected override void Dispose(bool isDisposing)
@@ -370,8 +370,10 @@ namespace osu.Game

            BeatmapManager.PostNotification = n => notifications?.Post(n);
            BeatmapManager.GetStableStorage = GetStorageForStableInstall;
+            BeatmapManager.PresentImport = items => PresentBeatmap(items.First());

-            BeatmapManager.PresentBeatmap = PresentBeatmap;
+            ScoreManager.PostNotification = n => notifications?.Post(n);
+            ScoreManager.PresentImport = items => PresentScore(items.First());

            Container logoContainer;

@@ -137,7 +137,7 @@ namespace osu.Game.Overlays.Chat
                        {
                            Anchor = Anchor.CentreLeft,
                            Origin = Anchor.CentreLeft,
-                            Font = OsuFont.GetFont(size: TextSize * 0.75f, weight: FontWeight.Bold, fixedWidth: true)
+                            Font = OsuFont.GetFont(size: TextSize * 0.75f, weight: FontWeight.SemiBold, fixedWidth: true)
                        },
                        new MessageSender(message.Sender)
                        {
@@ -13,6 +13,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Drawables;

 namespace osu.Game.Overlays.Direct
 {
@@ -23,6 +24,7 @@ namespace osu.Game.Overlays.Direct
        private const float vertical_padding = 5;
        private const float height = 70;

+        private FillFlowContainer statusContainer;
        private PlayButton playButton;
        private Box progressBar;

@@ -108,10 +110,24 @@ namespace osu.Game.Overlays.Direct
                                        },
                                        new FillFlowContainer
                                        {
-                                            AutoSizeAxes = Axes.X,
-                                            Height = 20,
-                                            Margin = new MarginPadding { Top = vertical_padding, Bottom = vertical_padding },
-                                            Children = GetDifficultyIcons(),
+                                            AutoSizeAxes = Axes.Both,
+                                            Direction = FillDirection.Horizontal,
+                                            Children = new Drawable[]
+                                            {
+                                                statusContainer = new FillFlowContainer
+                                                {
+                                                    AutoSizeAxes = Axes.Both,
+                                                    Margin = new MarginPadding { Vertical = vertical_padding, Horizontal = 5 },
+                                                    Spacing = new Vector2(5),
+                                                },
+                                                new FillFlowContainer
+                                                {
+                                                    AutoSizeAxes = Axes.X,
+                                                    Height = 20,
+                                                    Margin = new MarginPadding { Top = vertical_padding, Bottom = vertical_padding },
+                                                    Children = GetDifficultyIcons(),
+                                                },
+                                            },
                                        },
                                    },
                                },
@@ -194,6 +210,23 @@ namespace osu.Game.Overlays.Direct
                    Colour = colours.Yellow,
                },
            });
+
+            if (SetInfo.OnlineInfo?.HasVideo ?? false)
+            {
+                statusContainer.Add(new IconPill(FontAwesome.fa_film) { IconSize = new Vector2(20) });
+            }
+
+            if (SetInfo.OnlineInfo?.HasStoryboard ?? false)
+            {
+                statusContainer.Add(new IconPill(FontAwesome.fa_image) { IconSize = new Vector2(20) });
+            }
+
+            statusContainer.Add(new BeatmapSetOnlineStatusPill
+            {
+                TextSize = 12,
+                TextPadding = new MarginPadding { Horizontal = 10, Vertical = 4 },
+                Status = SetInfo.OnlineInfo?.Status ?? BeatmapSetOnlineStatus.None,
+            });
        }
    }
 }
@@ -118,7 +118,7 @@ namespace osu.Game.Overlays.Direct

        private void onRequestFailure(Exception e) => Schedule(() => attachDownload(null));

-        private void setAdded(BeatmapSetInfo s, bool existing, bool silent) => setDownloadStateFromManager(s, DownloadState.LocallyAvailable);
+        private void setAdded(BeatmapSetInfo s, bool existing) => setDownloadStateFromManager(s, DownloadState.LocallyAvailable);

        private void setRemoved(BeatmapSetInfo s) => setDownloadStateFromManager(s, DownloadState.NotDownloaded);

@@ -12,6 +12,14 @@ namespace osu.Game.Overlays.Direct
 {
    public class IconPill : CircularContainer
    {
+        public Vector2 IconSize
+        {
+            get => iconContainer.Size;
+            set => iconContainer.Size = value;
+        }
+
+        private readonly Container iconContainer;
+
        public IconPill(FontAwesome icon)
        {
            AutoSizeAxes = Axes.Both;
@@ -25,16 +33,16 @@ namespace osu.Game.Overlays.Direct
                    Colour = Color4.Black,
                    Alpha = 0.5f,
                },
-                new Container
+                iconContainer = new Container
                {
-                    AutoSizeAxes = Axes.Both,
-                    Margin = new MarginPadding(5),
+                    Size = new Vector2(22),
+                    Padding = new MarginPadding(5),
                    Child = new SpriteIcon
                    {
                        Anchor = Anchor.Centre,
                        Origin = Anchor.Centre,
+                        RelativeSizeAxes = Axes.Both,
                        Icon = icon,
-                        Size = new Vector2(12),
                    },
                },
            };
@@ -38,6 +38,8 @@ namespace osu.Game.Overlays.Mods

        protected override bool BlockNonPositionalInput => false;

+        protected override bool DimMainContent => false;
+
        protected readonly FillFlowContainer<ModSection> ModSectionsContainer;

        protected readonly Bindable<IEnumerable<Mod>> SelectedMods = new Bindable<IEnumerable<Mod>>(new Mod[] { });
@@ -75,7 +75,7 @@ namespace osu.Game.Overlays.Music
            [BackgroundDependencyLoader]
            private void load(BeatmapManager beatmaps, IBindable<WorkingBeatmap> beatmap)
            {
-                beatmaps.GetAllUsableBeatmapSets().ForEach(b => addBeatmapSet(b, false, false));
+                beatmaps.GetAllUsableBeatmapSets().ForEach(b => addBeatmapSet(b, false));
                beatmaps.ItemAdded += addBeatmapSet;
                beatmaps.ItemRemoved += removeBeatmapSet;

@@ -83,7 +83,7 @@ namespace osu.Game.Overlays.Music
                beatmapBacking.ValueChanged += _ => updateSelectedSet();
            }

-            private void addBeatmapSet(BeatmapSetInfo obj, bool existing, bool silent) => Schedule(() =>
+            private void addBeatmapSet(BeatmapSetInfo obj, bool existing) => Schedule(() =>
            {
                if (existing)
                    return;
@@ -212,7 +212,7 @@ namespace osu.Game.Overlays
            beatmapSets.Insert(index, beatmapSetInfo);
        }

-        private void handleBeatmapAdded(BeatmapSetInfo obj, bool existing, bool silent)
+        private void handleBeatmapAdded(BeatmapSetInfo obj, bool existing)
        {
            if (existing)
                return;
@@ -82,7 +82,7 @@ namespace osu.Game.Overlays.Settings.Sections

        private void itemRemoved(SkinInfo s) => Schedule(() => skinDropdown.Items = skinDropdown.Items.Where(i => i.ID != s.ID).ToArray());

-        private void itemAdded(SkinInfo s, bool existing, bool silent)
+        private void itemAdded(SkinInfo s, bool existing)
        {
            if (existing)
                return;
@@ -22,7 +22,7 @@ namespace osu.Game.Overlays.Toolbar

        public Action OnHome;

-        private readonly ToolbarUserArea userArea;
+        private ToolbarUserArea userArea;

        protected override bool BlockPositionalInput => false;

@@ -34,6 +34,13 @@ namespace osu.Game.Overlays.Toolbar
        private readonly Bindable<OverlayActivation> overlayActivationMode = new Bindable<OverlayActivation>(OverlayActivation.All);

        public Toolbar()
+        {
+            RelativeSizeAxes = Axes.X;
+            Size = new Vector2(1, HEIGHT);
+        }
+
+        [BackgroundDependencyLoader(true)]
+        private void load(OsuGame osuGame)
        {
            Children = new Drawable[]
            {
@@ -76,13 +83,6 @@ namespace osu.Game.Overlays.Toolbar
                }
            };

-            RelativeSizeAxes = Axes.X;
-            Size = new Vector2(1, HEIGHT);
-        }
-
-        [BackgroundDependencyLoader(true)]
-        private void load(OsuGame osuGame)
-        {
            StateChanged += visibility =>
            {
                if (overlayActivationMode.Value == OverlayActivation.Disabled)
@@ -139,6 +139,7 @@ namespace osu.Game.Overlays.Toolbar
        protected override bool OnClick(ClickEvent e)
        {
            HoverBackground.FlashColour(Color4.White.Opacity(100), 500, Easing.OutQuint);
+            tooltipContainer.FadeOut(100);
            return base.OnClick(e);
        }

@@ -14,10 +14,6 @@ namespace osu.Game.Rulesets.Mods
    public abstract class ModAutoplay<T> : ModAutoplay, IApplicableToRulesetContainer<T>
        where T : HitObject
    {
-        protected virtual Score CreateReplayScore(Beatmap<T> beatmap) => new Score { Replay = new Replay() };
-
-        public override bool HasImplementation => GetType().GenericTypeArguments.Length == 0;
-
        public virtual void ApplyToRulesetContainer(RulesetContainer<T> rulesetContainer) => rulesetContainer.SetReplayScore(CreateReplayScore(rulesetContainer.Beatmap));
    }

@@ -31,5 +27,9 @@ namespace osu.Game.Rulesets.Mods
        public override double ScoreMultiplier => 1;
        public bool AllowFail => false;
        public override Type[] IncompatibleMods => new[] { typeof(ModRelax), typeof(ModSuddenDeath), typeof(ModNoFail) };
+
+        public override bool HasImplementation => GetType().GenericTypeArguments.Length == 0;
+
+        public virtual Score CreateReplayScore(IBeatmap beatmap) => new Score { Replay = new Replay() };
    }
 }
@@ -15,7 +15,7 @@ namespace osu.Game.Rulesets.Mods
        public override ModType Type => ModType.DifficultyIncrease;
        public override string Description => "Zoooooooooom...";
        public override bool Ranked => true;
-        public override Type[] IncompatibleMods => new[] { typeof(ModHalfTime) };
+        public override Type[] IncompatibleMods => new[] { typeof(ModHalfTime), typeof(ModTimeRamp) };

        public virtual void ApplyToClock(IAdjustableClock clock)
        {
@@ -61,7 +61,7 @@ namespace osu.Game.Rulesets.Mods
        public abstract class Flashlight : Drawable
        {
            internal BindableInt Combo;
-            private Shader shader;
+            private IShader shader;

            protected override DrawNode CreateDrawNode() => new FlashlightDrawNode();

@@ -139,7 +139,7 @@ namespace osu.Game.Rulesets.Mods

        private class FlashlightDrawNode : DrawNode
        {
-            public Shader Shader;
+            public IShader Shader;
            public Quad ScreenSpaceDrawQuad;
            public Vector2 FlashlightPosition;
            public Vector2 FlashlightSize;
@@ -15,7 +15,7 @@ namespace osu.Game.Rulesets.Mods
        public override ModType Type => ModType.DifficultyReduction;
        public override string Description => "Less zoom...";
        public override bool Ranked => true;
-        public override Type[] IncompatibleMods => new[] { typeof(ModDoubleTime) };
+        public override Type[] IncompatibleMods => new[] { typeof(ModDoubleTime), typeof(ModTimeRamp) };

        public virtual void ApplyToClock(IAdjustableClock clock)
        {
@@ -0,0 +1,64 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using osu.Framework.Audio;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.UI;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mods
+{
+    public abstract class ModTimeRamp : Mod
+    {
+        public override Type[] IncompatibleMods => new[] { typeof(ModDoubleTime), typeof(ModHalfTime) };
+
+        protected abstract double FinalRateAdjustment { get; }
+    }
+
+    public abstract class ModTimeRamp<T> : ModTimeRamp, IUpdatableByPlayfield, IApplicableToClock, IApplicableToBeatmap<T>
+        where T : HitObject
+    {
+        private double finalRateTime;
+
+        private double beginRampTime;
+
+        private IAdjustableClock clock;
+
+        private IHasPitchAdjust pitchAdjust;
+
+        /// <summary>
+        /// The point in the beatmap at which the final ramping rate should be reached.
+        /// </summary>
+        private const double final_rate_progress = 0.75f;
+
+        public virtual void ApplyToClock(IAdjustableClock clock)
+        {
+            this.clock = clock;
+            pitchAdjust = (IHasPitchAdjust)clock;
+
+            // for preview purposes
+            pitchAdjust.PitchAdjust = 1.0 + FinalRateAdjustment;
+        }
+
+        public virtual void ApplyToBeatmap(Beatmap<T> beatmap)
+        {
+            HitObject lastObject = beatmap.HitObjects.LastOrDefault();
+
+            beginRampTime = beatmap.HitObjects.FirstOrDefault()?.StartTime ?? 0;
+            finalRateTime = final_rate_progress * ((lastObject as IHasEndTime)?.EndTime ?? lastObject?.StartTime ?? 0);
+        }
+
+        public virtual void Update(Playfield playfield)
+        {
+            var absRate = Math.Abs(FinalRateAdjustment);
+            var adjustment = MathHelper.Clamp(absRate * ((clock.CurrentTime - beginRampTime) / finalRateTime), 0, absRate);
+
+            pitchAdjust.PitchAdjust = 1 + Math.Sign(FinalRateAdjustment) * adjustment;
+        }
+    }
+}
@@ -0,0 +1,19 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Rulesets.Mods
+{
+    public class ModWindDown<T> : ModTimeRamp<T>
+        where T : HitObject
+    {
+        public override string Name => "Wind Down";
+        public override string Acronym => "WD";
+        public override string Description => "Sloooow doooown...";
+        public override FontAwesome Icon => FontAwesome.fa_chevron_circle_down;
+        public override double ScoreMultiplier => 1.0;
+        protected override double FinalRateAdjustment => -0.25;
+    }
+}
@@ -0,0 +1,19 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Rulesets.Mods
+{
+    public class ModWindUp<T> : ModTimeRamp<T>
+        where T : HitObject
+    {
+        public override string Name => "Wind Up";
+        public override string Acronym => "WU";
+        public override string Description => "Can you keep up?";
+        public override FontAwesome Icon => FontAwesome.fa_chevron_circle_up;
+        public override double ScoreMultiplier => 1.0;
+        protected override double FinalRateAdjustment => 0.5;
+    }
+}
@@ -301,7 +301,16 @@ namespace osu.Game.Rulesets.Objects.Legacy
        {
            // Todo: This should return the normal SampleInfos if the specified sample file isn't found, but that's a pretty edge-case scenario
            if (!string.IsNullOrEmpty(bankInfo.Filename))
-                return new List<SampleInfo> { new FileSampleInfo { Filename = bankInfo.Filename } };
+            {
+                return new List<SampleInfo>
+                {
+                    new FileSampleInfo
+                    {
+                        Filename = bankInfo.Filename,
+                        Volume = bankInfo.Volume
+                    }
+                };
+            }

            var soundTypes = new List<SampleInfo>
            {
@@ -1,14 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

-using osu.Game.Rulesets.Objects;
 using osu.Game.Beatmaps;
 using osu.Game.Replays;

 namespace osu.Game.Rulesets.Replays
 {
-    public abstract class AutoGenerator<T> : IAutoGenerator
-        where T : HitObject
+    public abstract class AutoGenerator : IAutoGenerator
    {
        /// <summary>
        /// Creates the auto replay and returns it.
@@ -21,11 +19,11 @@ namespace osu.Game.Rulesets.Replays
        /// <summary>
        /// The beatmap we're making.
        /// </summary>
-        protected Beatmap<T> Beatmap;
+        protected IBeatmap Beatmap;

        #endregion

-        protected AutoGenerator(Beatmap<T> beatmap)
+        protected AutoGenerator(IBeatmap beatmap)
        {
            Beatmap = beatmap;
        }
@@ -42,7 +42,7 @@ namespace osu.Game.Rulesets
        /// <returns>An enumerable of constructed <see cref="Mod"/>s</returns>
        public virtual IEnumerable<Mod> ConvertLegacyMods(LegacyMods mods) => new Mod[] { };

-        public Mod GetAutoplayMod() => GetAllMods().First(mod => mod is ModAutoplay);
+        public ModAutoplay GetAutoplayMod() => GetAllMods().OfType<ModAutoplay>().First();

        protected Ruleset(RulesetInfo rulesetInfo = null)
        {
@@ -10,6 +10,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 using osuTK;
@@ -63,6 +64,10 @@ namespace osu.Game.Rulesets.UI
        private void load(IBindable<WorkingBeatmap> beatmap)
        {
            this.beatmap = beatmap.Value;
+
+            Cursor = CreateCursor();
+            if (Cursor != null)
+                CursorTargetContainer.Add(Cursor);
        }

        /// <summary>
@@ -82,6 +87,23 @@ namespace osu.Game.Rulesets.UI
        /// <param name="h">The DrawableHitObject to remove.</param>
        public virtual bool Remove(DrawableHitObject h) => HitObjectContainer.Remove(h);

+        /// <summary>
+        /// The cursor currently being used by this <see cref="Playfield"/>. May be null if no cursor is provided.
+        /// </summary>
+        public CursorContainer Cursor { get; private set; }
+
+        /// <summary>
+        /// Provide an optional cursor which is to be used for gameplay.
+        /// If providing a cursor, <see cref="CursorTargetContainer"/> must also point to a valid target container.
+        /// </summary>
+        /// <returns>The cursor, or null if a cursor is not rqeuired.</returns>
+        protected virtual CursorContainer CreateCursor() => null;
+
+        /// <summary>
+        /// The target container to add the cursor after it is created.
+        /// </summary>
+        protected virtual Container CursorTargetContainer => null;
+
        /// <summary>
        /// Registers a <see cref="Playfield"/> as a nested <see cref="Playfield"/>.
        /// This does not add the <see cref="Playfield"/> to the draw hierarchy.
@@ -16,7 +16,9 @@ using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Input;
+using osu.Framework.Input.Events;
 using osu.Game.Configuration;
+using osu.Game.Graphics.Cursor;
 using osu.Game.Input.Handlers;
 using osu.Game.Overlays;
 using osu.Game.Replays;
@@ -32,7 +34,7 @@ namespace osu.Game.Rulesets.UI
    /// Should not be derived - derive <see cref="RulesetContainer{TObject}"/> instead.
    /// </para>
    /// </summary>
-    public abstract class RulesetContainer : Container
+    public abstract class RulesetContainer : Container, IProvideCursor
    {
        /// <summary>
        /// The selected variant.
@@ -74,10 +76,11 @@ namespace osu.Game.Rulesets.UI
        /// </summary>
        public Container Overlays { get; protected set; }

-        /// <summary>
-        /// The cursor provided by this <see cref="RulesetContainer"/>. May be null if no cursor is provided.
-        /// </summary>
-        public readonly CursorContainer Cursor;
+        public CursorContainer Cursor => Playfield.Cursor;
+
+        public bool ProvidingUserCursor => Playfield.Cursor != null && !HasReplayLoaded.Value;
+
+        protected override bool OnHover(HoverEvent e) => true; // required for IProvideCursor

        public readonly Ruleset Ruleset;

@@ -101,8 +104,6 @@ namespace osu.Game.Rulesets.UI

                KeyBindingInputManager.UseParentInput = !paused.NewValue;
            };
-
-            Cursor = CreateCursor();
        }

        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
@@ -259,9 +260,6 @@ namespace osu.Game.Rulesets.UI
                Playfield
            });

-            if (Cursor != null)
-                KeyBindingInputManager.Add(Cursor);
-
            InternalChildren = new Drawable[]
            {
                KeyBindingInputManager,
@@ -41,6 +41,7 @@ namespace osu.Game.Rulesets.UI
        protected RulesetInputManager(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
        {
            InternalChild = KeyBindingContainer = CreateKeyBindingContainer(ruleset, variant, unique);
+            gameplayClock = new GameplayClock(framedClock = new FramedClock(manualClock = new ManualClock()));
        }

        #region Action mapping (for replays)
@@ -86,22 +87,28 @@ namespace osu.Game.Rulesets.UI

        #region Clock control

-        private ManualClock clock;
-        private IFrameBasedClock parentClock;
+        private readonly ManualClock manualClock;
+
+        private readonly FramedClock framedClock;
+
+        [Cached]
+        private GameplayClock gameplayClock;
+
+        private IFrameBasedClock parentGameplayClock;
+
+        [BackgroundDependencyLoader(true)]
+        private void load(OsuConfigManager config, GameplayClock clock)
+        {
+            mouseDisabled = config.GetBindable<bool>(OsuSetting.MouseDisableButtons);
+
+            if (clock != null)
+                parentGameplayClock = clock;
+        }

        protected override void LoadComplete()
        {
            base.LoadComplete();
-
-            //our clock will now be our parent's clock, but we want to replace this to allow manual control.
-            parentClock = Clock;
-
-            ProcessCustomClock = false;
-            Clock = new FramedClock(clock = new ManualClock
-            {
-                CurrentTime = parentClock.CurrentTime,
-                Rate = parentClock.Rate,
-            });
+            setClock();
        }

        /// <summary>
@@ -147,25 +154,28 @@ namespace osu.Game.Rulesets.UI

        private void updateClock()
        {
-            if (parentClock == null) return;
+            if (parentGameplayClock == null)
+                setClock(); // LoadComplete may not be run yet, but we still want the clock.

-            clock.Rate = parentClock.Rate;
-            clock.IsRunning = parentClock.IsRunning;
+            validState = true;

-            var newProposedTime = parentClock.CurrentTime;
+            manualClock.Rate = parentGameplayClock.Rate;
+            manualClock.IsRunning = parentGameplayClock.IsRunning;
+
+            var newProposedTime = parentGameplayClock.CurrentTime;

            try
            {
-                if (Math.Abs(clock.CurrentTime - newProposedTime) > sixty_frame_time * 1.2f)
+                if (Math.Abs(manualClock.CurrentTime - newProposedTime) > sixty_frame_time * 1.2f)
                {
-                    newProposedTime = clock.Rate > 0
-                        ? Math.Min(newProposedTime, clock.CurrentTime + sixty_frame_time)
-                        : Math.Max(newProposedTime, clock.CurrentTime - sixty_frame_time);
+                    newProposedTime = manualClock.Rate > 0
+                        ? Math.Min(newProposedTime, manualClock.CurrentTime + sixty_frame_time)
+                        : Math.Max(newProposedTime, manualClock.CurrentTime - sixty_frame_time);
                }

                if (!isAttached)
                {
-                    clock.CurrentTime = newProposedTime;
+                    manualClock.CurrentTime = newProposedTime;
                }
                else
                {
@@ -177,35 +187,39 @@ namespace osu.Game.Rulesets.UI
                        validState = false;

                        requireMoreUpdateLoops = true;
-                        clock.CurrentTime = newProposedTime;
+                        manualClock.CurrentTime = newProposedTime;
                        return;
                    }

-                    clock.CurrentTime = newTime.Value;
+                    manualClock.CurrentTime = newTime.Value;
                }

-                requireMoreUpdateLoops = clock.CurrentTime != parentClock.CurrentTime;
+                requireMoreUpdateLoops = manualClock.CurrentTime != parentGameplayClock.CurrentTime;
            }
            finally
            {
                // The manual clock time has changed in the above code. The framed clock now needs to be updated
                // to ensure that the its time is valid for our children before input is processed
-                Clock.ProcessFrame();
+                framedClock.ProcessFrame();
            }
        }

+        private void setClock()
+        {
+            // in case a parent gameplay clock isn't available, just use the parent clock.
+            if (parentGameplayClock == null)
+                parentGameplayClock = Clock;
+
+            Clock = gameplayClock;
+            ProcessCustomClock = false;
+        }
+
        #endregion

        #region Setting application (disables etc.)

        private Bindable<bool> mouseDisabled;

-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
-        {
-            mouseDisabled = config.GetBindable<bool>(OsuSetting.MouseDisableButtons);
-        }
-
        protected override bool Handle(UIEvent e)
        {
            switch (e)
@@ -178,5 +178,7 @@ namespace osu.Game.Scoring
        {
            public string Acronym { get; set; }
        }
+
+        public override string ToString() => $"{User} playing {Beatmap}";
    }
 }
@@ -91,7 +91,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                                                RelativeSizeAxes = Axes.Y,
                                                Height = 0.5f,
                                                Icon = FontAwesome.fa_search_plus,
-                                                Action = () => timeline.Zoom++
+                                                Action = () => changeZoom(1)
                                            },
                                            new TimelineButton
                                            {
@@ -100,7 +100,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                                                RelativeSizeAxes = Axes.Y,
                                                Height = 0.5f,
                                                Icon = FontAwesome.fa_search_minus,
-                                                Action = () => timeline.Zoom--
+                                                Action = () => changeZoom(-1)
                                            },
                                        }
                                    }
@@ -124,5 +124,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline

            timeline.WaveformVisible.BindTo(waveformCheckbox.Current);
        }
+
+        private void changeZoom(float change) => timeline.Zoom += change;
    }
 }
@@ -19,7 +19,7 @@ namespace osu.Game.Screens

        /// <summary>
        /// Whether a top-level component should be allowed to exit the current screen to, for example,
-        /// complete an import.
+        /// complete an import. Note that this can be overridden by a user if they specifically request.
        /// </summary>
        bool AllowExternalScreenChange { get; }

@@ -89,7 +89,7 @@ namespace osu.Game.Screens
        /// </summary>
        public class ShaderPrecompiler : Drawable
        {
-            private readonly List<Shader> loadTargets = new List<Shader>();
+            private readonly List<IShader> loadTargets = new List<IShader>();

            public bool FinishedCompiling { get; private set; }

@@ -106,7 +106,7 @@ namespace osu.Game.Screens
                loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_3, FragmentShaderDescriptor.TEXTURE));
            }

-            protected virtual bool AllLoaded => loadTargets.All(s => s.Loaded);
+            protected virtual bool AllLoaded => loadTargets.All(s => s.IsLoaded);

            protected override void Update()
            {
@@ -5,14 +5,17 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Screens;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
+using osu.Game.Online.API;
 using osuTK;
 using osuTK.Graphics;
 using osu.Game.Overlays;
+using osu.Game.Users;

 namespace osu.Game.Screens.Menu
 {
@@ -33,13 +36,15 @@ namespace osu.Game.Screens.Menu

        private const float icon_y = -85;

+        private readonly Bindable<User> currentUser = new Bindable<User>();
+
        public Disclaimer()
        {
            ValidForResume = false;
        }

        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
+        private void load(OsuColour colours, APIAccess api)
        {
            InternalChildren = new Drawable[]
            {
@@ -70,7 +75,7 @@ namespace osu.Game.Screens.Menu
            textFlow.AddParagraph("Things may not work as expected", t => t.Font = t.Font.With(size: 20));
            textFlow.NewParagraph();

-            Action<SpriteText> format = t => t.Font = OsuFont.GetFont(size: 15, weight: FontWeight.Bold);
+            Action<SpriteText> format = t => t.Font = OsuFont.GetFont(size: 15, weight: FontWeight.SemiBold);

            textFlow.AddParagraph("Detailed bug reports are welcomed via github issues.", format);
            textFlow.NewParagraph();
@@ -96,6 +101,13 @@ namespace osu.Game.Screens.Menu
            }).First());

            iconColour = colours.Yellow;
+
+            currentUser.BindTo(api.LocalUser);
+            currentUser.BindValueChanged(e =>
+            {
+                if (e.NewValue.IsSupporter)
+                    supporterDrawables.ForEach(d => d.FadeOut(500, Easing.OutQuint).Expire());
+            }, true);
        }

        protected override void LoadComplete()
@@ -63,7 +63,7 @@ namespace osu.Game.Screens.Menu

        private readonly float[] frequencyAmplitudes = new float[256];

-        private Shader shader;
+        private IShader shader;
        private readonly Texture texture;

        public LogoVisualisation()
@@ -131,8 +131,6 @@ namespace osu.Game.Screens.Menu

        protected override DrawNode CreateDrawNode() => new VisualisationDrawNode();

-        private readonly VisualiserSharedData sharedData = new VisualiserSharedData();
-
        protected override void ApplyDrawNode(DrawNode node)
        {
            base.ApplyDrawNode(node);
@@ -142,29 +140,23 @@ namespace osu.Game.Screens.Menu
            visNode.Shader = shader;
            visNode.Texture = texture;
            visNode.Size = DrawSize.X;
-            visNode.Shared = sharedData;
            visNode.Colour = AccentColour;
            visNode.AudioData = frequencyAmplitudes;
        }

-        private class VisualiserSharedData
-        {
-            public readonly QuadBatch<TexturedVertex2D> VertexBatch = new QuadBatch<TexturedVertex2D>(100, 10);
-        }
-
        private class VisualisationDrawNode : DrawNode
        {
-            public Shader Shader;
+            public IShader Shader;
            public Texture Texture;

-            public VisualiserSharedData Shared;
-
            //Asuming the logo is a circle, we don't need a second dimension.
            public float Size;

            public Color4 Colour;
            public float[] AudioData;

+            private readonly QuadBatch<TexturedVertex2D> vertexBatch = new QuadBatch<TexturedVertex2D>(100, 10);
+
            public override void Draw(Action<TexturedVertex2D> vertexAction)
            {
                base.Draw(vertexAction);
@@ -209,7 +201,7 @@ namespace osu.Game.Screens.Menu
                                rectangle,
                                colourInfo,
                                null,
-                                Shared.VertexBatch.AddAction,
+                                vertexBatch.AddAction,
                                //barSize by itself will make it smooth more in the X axis than in the Y axis, this reverts that.
                                Vector2.Divide(inflation, barSize.Yx));
                        }
@@ -218,6 +210,13 @@ namespace osu.Game.Screens.Menu

                Shader.Unbind();
            }
+
+            protected override void Dispose(bool isDisposing)
+            {
+                base.Dispose(isDisposing);
+
+                vertexBatch.Dispose();
+            }
        }
    }
 }
@@ -9,6 +9,13 @@ namespace osu.Game.Screens.Multi.Components
 {
    public class MultiplayerBackgroundSprite : MultiplayerComposite
    {
+        private readonly BeatmapSetCoverType beatmapSetCoverType;
+
+        public MultiplayerBackgroundSprite(BeatmapSetCoverType beatmapSetCoverType = BeatmapSetCoverType.Cover)
+        {
+            this.beatmapSetCoverType = beatmapSetCoverType;
+        }
+
        [BackgroundDependencyLoader]
        private void load()
        {
@@ -19,6 +26,6 @@ namespace osu.Game.Screens.Multi.Components
            CurrentItem.BindValueChanged(item => sprite.Beatmap.Value = item.NewValue?.Beatmap, true);
        }

-        protected virtual UpdateableBeatmapBackgroundSprite CreateBackgroundSprite() => new UpdateableBeatmapBackgroundSprite { RelativeSizeAxes = Axes.Both };
+        protected virtual UpdateableBeatmapBackgroundSprite CreateBackgroundSprite() => new UpdateableBeatmapBackgroundSprite(beatmapSetCoverType) { RelativeSizeAxes = Axes.Both };
    }
 }
@@ -11,6 +11,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Drawables;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
@@ -137,7 +138,7 @@ namespace osu.Game.Screens.Multi.Lounge.Components
                                Width = cover_width,
                                Masking = true,
                                Margin = new MarginPadding { Left = side_strip_width },
-                                Child = new MultiplayerBackgroundSprite { RelativeSizeAxes = Axes.Both }
+                                Child = new MultiplayerBackgroundSprite(BeatmapSetCoverType.List) { RelativeSizeAxes = Axes.Both }
                            },
                            new Container
                            {
@@ -107,6 +107,14 @@ namespace osu.Game.Screens.Multi.Lounge
            Filter.Search.HoldFocus = false;
        }

+        public override void OnResuming(IScreen last)
+        {
+            base.OnResuming(last);
+
+            if (currentRoom.Value?.RoomID.Value == null)
+                currentRoom.Value = new Room();
+        }
+
        private void joinRequested(Room room)
        {
            processingOverlay.Show();
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.

 using System;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
@@ -13,6 +14,7 @@ using osu.Game.Beatmaps.Drawables;
 using osu.Game.Graphics;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Overlays.SearchableList;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Screens.Multi.Components;
 using osu.Game.Screens.Play.HUD;
 using osuTK;
@@ -108,7 +110,7 @@ namespace osu.Game.Screens.Multi.Match.Components
                },
            };

-            CurrentItem.BindValueChanged(item => modDisplay.Current.Value = item.NewValue?.RequiredMods, true);
+            CurrentItem.BindValueChanged(item => modDisplay.Current.Value = item.NewValue?.RequiredMods ?? Enumerable.Empty<Mod>(), true);

            beatmapButton.Action = () => RequestBeatmapSelection?.Invoke();
        }
@@ -28,13 +28,15 @@ namespace osu.Game.Screens.Multi.Match.Components
        {
            base.LoadComplete();

-            roomId.BindValueChanged(_ => updateChannel(), true);
+            channelId.BindValueChanged(_ => updateChannel(), true);
        }

        private void updateChannel()
        {
-            if (roomId.Value != null)
-                Channel.Value = channelManager?.JoinChannel(new Channel { Id = channelId.Value, Type = ChannelType.Multiplayer, Name = $"#mp_{roomId.Value}" });
+            if (roomId.Value == null || channelId.Value == 0)
+                return;
+
+            Channel.Value = channelManager?.JoinChannel(new Channel { Id = channelId.Value, Type = ChannelType.Multiplayer, Name = $"#lazermp_{roomId.Value}" });
        }
    }
 }
@@ -54,7 +54,7 @@ namespace osu.Game.Screens.Multi.Match.Components
            hasBeatmap = beatmaps.QueryBeatmap(b => b.OnlineBeatmapID == beatmap.OnlineBeatmapID) != null;
        }

-        private void beatmapAdded(BeatmapSetInfo model, bool existing, bool silent)
+        private void beatmapAdded(BeatmapSetInfo model, bool existing)
        {
            if (Beatmap.Value == null)
                return;
@@ -202,7 +202,7 @@ namespace osu.Game.Screens.Multi.Match
        /// <summary>
        /// Handle the case where a beatmap is imported (and can be used by this match).
        /// </summary>
-        private void beatmapAdded(BeatmapSetInfo model, bool existing, bool silent) => Schedule(() =>
+        private void beatmapAdded(BeatmapSetInfo model, bool existing) => Schedule(() =>
        {
            if (Beatmap.Value != beatmapManager.DefaultBeatmap)
                return;
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.

 using System.Collections.Generic;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -40,13 +41,7 @@ namespace osu.Game.Screens.Play
        private readonly BreakInfo info;
        private readonly BreakArrows breakArrows;

-        public BreakOverlay(bool letterboxing, ScoreProcessor scoreProcessor)
-            : this(letterboxing)
-        {
-            bindProcessor(scoreProcessor);
-        }
-
-        public BreakOverlay(bool letterboxing)
+        public BreakOverlay(bool letterboxing, ScoreProcessor scoreProcessor = null)
        {
            RelativeSizeAxes = Axes.Both;
            Child = fadeContainer = new Container
@@ -98,6 +93,14 @@ namespace osu.Game.Screens.Play
                    }
                }
            };
+
+            if (scoreProcessor != null) bindProcessor(scoreProcessor);
+        }
+
+        [BackgroundDependencyLoader(true)]
+        private void load(GameplayClock clock)
+        {
+            if (clock != null) Clock = clock;
        }

        protected override void LoadComplete()
@@ -0,0 +1,43 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Timing;
+
+namespace osu.Game.Screens.Play
+{
+    /// <summary>
+    /// A clock which is used for gameplay elements that need to follow audio time 1:1.
+    /// Exposed via DI by <see cref="PausableGameplayContainer"/>.
+    /// <remarks>
+    /// The main purpose of this clock is to stop components using it from accidentally processing the main
+    /// <see cref="IFrameBasedClock"/>, as this should only be done once to ensure accuracy.
+    /// </remarks>
+    /// </summary>
+    public class GameplayClock : IFrameBasedClock
+    {
+        private readonly IFrameBasedClock underlyingClock;
+
+        public GameplayClock(IFrameBasedClock underlyingClock)
+        {
+            this.underlyingClock = underlyingClock;
+        }
+
+        public double CurrentTime => underlyingClock.CurrentTime;
+
+        public double Rate => underlyingClock.Rate;
+
+        public bool IsRunning => underlyingClock.IsRunning;
+
+        public void ProcessFrame()
+        {
+            // we do not want to process the underlying clock.
+            // this is handled by PauseContainer.
+        }
+
+        public double ElapsedFrameTime => underlyingClock.ElapsedFrameTime;
+
+        public double FramesPerSecond => underlyingClock.FramesPerSecond;
+
+        public FrameTimeInfo TimeInfo => underlyingClock.TimeInfo;
+    }
+}
@@ -0,0 +1,151 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using osu.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Mods;
+
+namespace osu.Game.Screens.Play
+{
+    /// <summary>
+    /// Encapsulates gameplay timing logic and provides a <see cref="GameplayClock"/> for children.
+    /// </summary>
+    public class GameplayClockContainer : Container
+    {
+        private readonly WorkingBeatmap beatmap;
+
+        /// <summary>
+        /// The original source (usually a <see cref="WorkingBeatmap"/>'s track).
+        /// </summary>
+        private readonly IAdjustableClock sourceClock;
+
+        public readonly BindableBool IsPaused = new BindableBool();
+
+        /// <summary>
+        /// The decoupled clock used for gameplay. Should be used for seeks and clock control.
+        /// </summary>
+        private readonly DecoupleableInterpolatingFramedClock adjustableClock;
+
+        public readonly Bindable<double> UserPlaybackRate = new BindableDouble(1)
+        {
+            Default = 1,
+            MinValue = 0.5,
+            MaxValue = 2,
+            Precision = 0.1,
+        };
+
+        /// <summary>
+        /// The final clock which is exposed to underlying components.
+        /// </summary>
+        [Cached]
+        private readonly GameplayClock gameplayClock;
+
+        private Bindable<double> userAudioOffset;
+
+        private readonly FramedOffsetClock offsetClock;
+
+        public GameplayClockContainer(WorkingBeatmap beatmap, bool allowLeadIn, double gameplayStartTime)
+        {
+            this.beatmap = beatmap;
+
+            RelativeSizeAxes = Axes.Both;
+
+            sourceClock = (IAdjustableClock)beatmap.Track ?? new StopwatchClock();
+
+            adjustableClock = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
+
+            adjustableClock.Seek(allowLeadIn
+                ? Math.Min(0, gameplayStartTime - beatmap.BeatmapInfo.AudioLeadIn)
+                : gameplayStartTime);
+
+            adjustableClock.ProcessFrame();
+
+            // Lazer's audio timings in general doesn't match stable. This is the result of user testing, albeit limited.
+            // This only seems to be required on windows. We need to eventually figure out why, with a bit of luck.
+            var platformOffsetClock = new FramedOffsetClock(adjustableClock) { Offset = RuntimeInfo.OS == RuntimeInfo.Platform.Windows ? 22 : 0 };
+
+            // the final usable gameplay clock with user-set offsets applied.
+            offsetClock = new FramedOffsetClock(platformOffsetClock);
+
+            // the clock to be exposed via DI to children.
+            gameplayClock = new GameplayClock(offsetClock);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config)
+        {
+            userAudioOffset = config.GetBindable<double>(OsuSetting.AudioOffset);
+            userAudioOffset.BindValueChanged(offset => offsetClock.Offset = offset.NewValue, true);
+
+            UserPlaybackRate.ValueChanged += _ => updateRate();
+        }
+
+        public void Restart()
+        {
+            Task.Run(() =>
+            {
+                sourceClock.Reset();
+
+                Schedule(() =>
+                {
+                    adjustableClock.ChangeSource(sourceClock);
+                    updateRate();
+
+                    this.Delay(750).Schedule(() =>
+                    {
+                        if (!IsPaused.Value)
+                        {
+                            adjustableClock.Start();
+                        }
+                    });
+                });
+            });
+        }
+
+        public void Start()
+        {
+            // Seeking the decoupled clock to its current time ensures that its source clock will be seeked to the same time
+            // This accounts for the audio clock source potentially taking time to enter a completely stopped state
+            adjustableClock.Seek(adjustableClock.CurrentTime);
+            adjustableClock.Start();
+        }
+
+        public void Seek(double time) => adjustableClock.Seek(time);
+
+        public void Stop() => adjustableClock.Stop();
+
+        public void ResetLocalAdjustments()
+        {
+            // In the case of replays, we may have changed the playback rate.
+            UserPlaybackRate.Value = 1;
+        }
+
+        protected override void Update()
+        {
+            if (!IsPaused.Value)
+                offsetClock.ProcessFrame();
+
+            base.Update();
+        }
+
+        private void updateRate()
+        {
+            if (sourceClock == null) return;
+
+            sourceClock.Rate = 1;
+            foreach (var mod in beatmap.Mods.Value.OfType<IApplicableToClock>())
+                mod.ApplyToClock(sourceClock);
+
+            sourceClock.Rate *= UserPlaybackRate.Value;
+        }
+    }
+}
@@ -19,7 +19,9 @@ namespace osu.Game.Screens.Play.HUD
        public readonly PlaybackSettings PlaybackSettings;

        public readonly VisualSettings VisualSettings;
+
        //public readonly CollectionSettings CollectionSettings;
+
        //public readonly DiscussionSettings DiscussionSettings;

        public PlayerSettingsOverlay()
@@ -1,12 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using System;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Events;
-using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Graphics.UserInterface;
@@ -40,7 +40,9 @@ namespace osu.Game.Screens.Play

        private static bool hasShownNotificationOnce;

-        public HUDOverlay(ScoreProcessor scoreProcessor, RulesetContainer rulesetContainer, WorkingBeatmap working, IClock offsetClock, IAdjustableClock adjustableClock)
+        public Action<double> RequestSeek;
+
+        public HUDOverlay(ScoreProcessor scoreProcessor, RulesetContainer rulesetContainer, WorkingBeatmap working)
        {
            RelativeSizeAxes = Axes.Both;

@@ -81,7 +83,7 @@ namespace osu.Game.Screens.Play
                    Direction = FillDirection.Vertical,
                    Children = new Drawable[]
                    {
-                        KeyCounter = CreateKeyCounter(adjustableClock as IFrameBasedClock),
+                        KeyCounter = CreateKeyCounter(),
                        HoldToQuit = CreateHoldForMenuButton(),
                    }
                }
@@ -91,13 +93,10 @@ namespace osu.Game.Screens.Play
            BindRulesetContainer(rulesetContainer);

            Progress.Objects = rulesetContainer.Objects;
-            Progress.AudioClock = offsetClock;
            Progress.AllowSeeking = rulesetContainer.HasReplayLoaded.Value;
-            Progress.OnSeek = pos => adjustableClock.Seek(pos);
+            Progress.RequestSeek = time => RequestSeek(time);

            ModDisplay.Current.BindTo(working.Mods);
-
-            PlayerSettingsOverlay.PlaybackSettings.AdjustableClock = adjustableClock;
        }

        [BackgroundDependencyLoader(true)]
@@ -202,13 +201,12 @@ namespace osu.Game.Screens.Play
            Margin = new MarginPadding { Top = 20 }
        };

-        protected virtual KeyCounterCollection CreateKeyCounter(IFrameBasedClock offsetClock) => new KeyCounterCollection
+        protected virtual KeyCounterCollection CreateKeyCounter() => new KeyCounterCollection
        {
            FadeTime = 50,
            Anchor = Anchor.BottomRight,
            Origin = Anchor.BottomRight,
            Margin = new MarginPadding(10),
-            AudioClock = offsetClock
        };

        protected virtual SongProgress CreateProgress() => new SongProgress
--- a/Show More
+++ b/Show More