Merge pull request #4500 from peppy/update-framework

Update framework

README.md

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

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

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

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

@@ -13,7 +13,7 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
-    public class TestCaseAutoJuiceStream : TestCasePlayer
+    public class TestCaseAutoJuiceStream : PlayerTestCase
     {
         public TestCaseAutoJuiceStream()
             : base(new CatchRuleset())

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

@@ -8,11 +8,12 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
-    public class TestCaseBananaShower : Game.Tests.Visual.TestCasePlayer
+    public class TestCaseBananaShower : PlayerTestCase
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
@@ -20,7 +21,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             typeof(DrawableBananaShower),
 
             typeof(CatchRuleset),
-            typeof(CatchRulesetContainer),
+            typeof(DrawableCatchRuleset),
         };
 
         public TestCaseBananaShower()

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

@@ -2,11 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
+using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
-    public class TestCaseCatchPlayer : Game.Tests.Visual.TestCasePlayer
+    public class TestCaseCatchPlayer : PlayerTestCase
     {
         public TestCaseCatchPlayer()
             : base(new CatchRuleset())

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

@@ -4,11 +4,12 @@
 using NUnit.Framework;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
-    public class TestCaseCatchStacker : Game.Tests.Visual.TestCasePlayer
+    public class TestCaseCatchStacker : PlayerTestCase
     {
         public TestCaseCatchStacker()
             : base(new CatchRuleset())

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

@@ -2,26 +2,45 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
+using osu.Framework.Allocation;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
-    public class TestCaseHyperDash : Game.Tests.Visual.TestCasePlayer
+    public class TestCaseHyperDash : PlayerTestCase
     {
         public TestCaseHyperDash()
             : base(new CatchRuleset())
         {
         }
 
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            AddAssert("First note is hyperdash", () => Beatmap.Value.Beatmap.HitObjects[0] is Fruit f && f.HyperDash);
+        }
+
         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 hyper-dash
+            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;
         }

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

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

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -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;
@@ -21,7 +22,7 @@ namespace osu.Game.Rulesets.Catch
 {
     public class CatchRuleset : Ruleset
     {
-        public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap) => new CatchRulesetContainer(this, beatmap);
+        public override DrawableRuleset CreateDrawableRulesetWith(WorkingBeatmap beatmap) => new DrawableCatchRuleset(this, beatmap);
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new CatchBeatmapConverter(beatmap);
         public override IBeatmapProcessor CreateBeatmapProcessor(IBeatmap beatmap) => new CatchBeatmapProcessor(beatmap);
 
@@ -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[] { };
             }

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

@@ -7,6 +7,7 @@ using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Catch.Difficulty.Skills;
+using osu.Game.Rulesets.Catch.Mods;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Difficulty;
@@ -22,16 +23,9 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
         protected override int SectionLength => 750;
 
-        private readonly float halfCatchWidth;
-
         public CatchDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
-            var catcher = new CatcherArea.Catcher(beatmap.BeatmapInfo.BaseDifficulty);
-            halfCatchWidth = catcher.CatchWidth * 0.5f;
-
-            // We're only using 80% of the catcher's width to simulate imperfect gameplay.
-            halfCatchWidth *= 0.8f;
         }
 
         protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
@@ -53,6 +47,14 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
         protected override IEnumerable<DifficultyHitObject> CreateDifficultyHitObjects(IBeatmap beatmap, double clockRate)
         {
+            float halfCatchWidth;
+
+            using (var catcher = new CatcherArea.Catcher(beatmap.BeatmapInfo.BaseDifficulty))
+            {
+                halfCatchWidth = catcher.CatchWidth * 0.5f;
+                halfCatchWidth *= 0.8f; // We're only using 80% of the catcher's width to simulate imperfect gameplay.
+            }
+
             CatchHitObject lastObject = null;
 
             foreach (var hitObject in beatmap.HitObjects.OfType<CatchHitObject>())
@@ -88,5 +90,13 @@ namespace osu.Game.Rulesets.Catch.Difficulty
         {
             new Movement(),
         };
+
+        protected override Mod[] DifficultyAdjustmentMods => new Mod[]
+        {
+            new CatchModDoubleTime(),
+            new CatchModHalfTime(),
+            new CatchModHardRock(),
+            new CatchModEasy(),
+        };
     }
 }

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

@@ -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(),

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

@@ -21,10 +21,10 @@ namespace osu.Game.Rulesets.Catch.Mods
 
         private CatchPlayfield playfield;
 
-        public override void ApplyToRulesetContainer(RulesetContainer<CatchHitObject> rulesetContainer)
+        public override void ApplyToDrawableRuleset(DrawableRuleset<CatchHitObject> drawableRuleset)
         {
-            playfield = (CatchPlayfield)rulesetContainer.Playfield;
-            base.ApplyToRulesetContainer(rulesetContainer);
+            playfield = (CatchPlayfield)drawableRuleset.Playfield;
+            base.ApplyToDrawableRuleset(drawableRuleset);
         }
 
         private class CatchFlashlight : Flashlight

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

@@ -15,77 +15,107 @@ namespace osu.Game.Rulesets.Catch.Mods
         public override double ScoreMultiplier => 1.12;
         public override bool Ranked => true;
 
-        private float lastStartX;
-        private int lastStartTime;
+        private float? lastPosition;
+        private double lastStartTime;
 
         public void ApplyToHitObject(HitObject hitObject)
         {
+            if (hitObject is JuiceStream stream)
+            {
+                lastPosition = stream.EndX;
+                lastStartTime = stream.EndTime;
+                return;
+            }
+
+            if (!(hitObject is Fruit))
+                return;
+
             var catchObject = (CatchHitObject)hitObject;
 
             float position = catchObject.X;
-            int startTime = (int)hitObject.StartTime;
+            double startTime = hitObject.StartTime;
 
-            if (lastStartX == 0)
+            if (lastPosition == null)
             {
-                lastStartX = position;
+                lastPosition = position;
                 lastStartTime = startTime;
+
                 return;
             }
 
-            float diff = lastStartX - position;
-            int timeDiff = startTime - lastStartTime;
+            float positionDiff = position - lastPosition.Value;
+            double timeDiff = startTime - lastStartTime;
 
             if (timeDiff > 1000)
             {
-                lastStartX = position;
+                lastPosition = position;
                 lastStartTime = startTime;
                 return;
             }
 
-            if (diff == 0)
+            if (positionDiff == 0)
             {
-                bool right = RNG.NextBool();
-
-                float rand = Math.Min(20, (float)RNG.NextDouble(0, timeDiff / 4d)) / CatchPlayfield.BASE_WIDTH;
-
-                if (right)
-                {
-                    if (position + rand <= 1)
-                        position += rand;
-                    else
-                        position -= rand;
-                }
-                else
-                {
-                    if (position - rand >= 0)
-                        position -= rand;
-                    else
-                        position += rand;
-                }
-
+                applyRandomOffset(ref position, timeDiff / 4d);
                 catchObject.X = position;
-
                 return;
             }
 
-            if (Math.Abs(diff) < timeDiff / 3d)
-            {
-                if (diff > 0)
-                {
-                    if (position - diff > 0)
-                        position -= diff;
-                }
-                else
-                {
-                    if (position - diff < 1)
-                        position -= diff;
-                }
-            }
+            if (Math.Abs(positionDiff * CatchPlayfield.BASE_WIDTH) < timeDiff / 3d)
+                applyOffset(ref position, positionDiff);
 
             catchObject.X = position;
 
-            lastStartX = position;
+            lastPosition = position;
             lastStartTime = startTime;
         }
+
+        /// <summary>
+        /// Applies a random offset in a random direction to a position, ensuring that the final position remains within the boundary of the playfield.
+        /// </summary>
+        /// <param name="position">The position which the offset should be applied to.</param>
+        /// <param name="maxOffset">The maximum offset, cannot exceed 20px.</param>
+        private void applyRandomOffset(ref float position, double maxOffset)
+        {
+            bool right = RNG.NextBool();
+            float rand = Math.Min(20, (float)RNG.NextDouble(0, Math.Max(0, maxOffset))) / CatchPlayfield.BASE_WIDTH;
+
+            if (right)
+            {
+                // Clamp to the right bound
+                if (position + rand <= 1)
+                    position += rand;
+                else
+                    position -= rand;
+            }
+            else
+            {
+                // Clamp to the left bound
+                if (position - rand >= 0)
+                    position -= rand;
+                else
+                    position += rand;
+            }
+        }
+
+        /// <summary>
+        /// Applies an offset to a position, ensuring that the final position remains within the boundary of the playfield.
+        /// </summary>
+        /// <param name="position">The position which the offset should be applied to.</param>
+        /// <param name="amount">The amount to offset by.</param>
+        private void applyOffset(ref float position, float amount)
+        {
+            if (amount > 0)
+            {
+                // Clamp to the right bound
+                if (position + amount < 1)
+                    position += amount;
+            }
+            else
+            {
+                // Clamp to the left bound
+                if (position + amount > 0)
+                    position += amount;
+            }
+        }
     }
 }

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

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Audio;
@@ -25,6 +24,11 @@ namespace osu.Game.Rulesets.Catch.Objects
         public double Velocity;
         public double TickDistance;
 
+        /// <summary>
+        /// The length of one span of this <see cref="JuiceStream"/>.
+        /// </summary>
+        public double SpanDuration => Duration / this.SpanCount();
+
         protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
         {
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
@@ -41,19 +45,6 @@ namespace osu.Game.Rulesets.Catch.Objects
         protected override void CreateNestedHitObjects()
         {
             base.CreateNestedHitObjects();
-            createTicks();
-        }
-
-        private void createTicks()
-        {
-            if (TickDistance == 0)
-                return;
-
-            var length = Path.Distance;
-            var tickDistance = Math.Min(TickDistance, length);
-            var spanDuration = length / Velocity;
-
-            var minDistanceFromEnd = Velocity * 0.01;
 
             var tickSamples = Samples.Select(s => new SampleInfo
             {
@@ -62,81 +53,59 @@ namespace osu.Game.Rulesets.Catch.Objects
                 Volume = s.Volume
             }).ToList();
 
-            AddNested(new Fruit
+            SliderEventDescriptor? lastEvent = null;
+
+            foreach (var e in SliderEventGenerator.Generate(StartTime, SpanDuration, Velocity, TickDistance, Path.Distance, this.SpanCount(), LegacyLastTickOffset))
             {
-                Samples = Samples,
-                StartTime = StartTime,
-                X = X
-            });
-
-            double lastTickTime = StartTime;
-
-            for (int span = 0; span < this.SpanCount(); span++)
-            {
-                var spanStartTime = StartTime + span * spanDuration;
-                var reversed = span % 2 == 1;
-
-                for (double d = tickDistance;; d += tickDistance)
+                // generate tiny droplets since the last point
+                if (lastEvent != null)
                 {
-                    bool isLastTick = false;
-                    if (d + minDistanceFromEnd >= length)
+                    double sinceLastTick = e.Time - lastEvent.Value.Time;
+
+                    if (sinceLastTick > 80)
                     {
-                        d = length;
-                        isLastTick = true;
-                    }
+                        double timeBetweenTiny = sinceLastTick;
+                        while (timeBetweenTiny > 100)
+                            timeBetweenTiny /= 2;
 
-                    var timeProgress = d / length;
-                    var distanceProgress = reversed ? 1 - timeProgress : timeProgress;
-
-                    double time = spanStartTime + timeProgress * spanDuration;
-
-                    if (LegacyLastTickOffset != null)
-                    {
-                        // If we're the last tick, apply the legacy offset
-                        if (span == this.SpanCount() - 1 && isLastTick)
-                            time = Math.Max(StartTime + Duration / 2, time - LegacyLastTickOffset.Value);
-                    }
-
-                    int tinyTickCount = 1;
-                    double tinyTickInterval = time - lastTickTime;
-                    while (tinyTickInterval > 100 && tinyTickCount < 10000)
-                    {
-                        tinyTickInterval /= 2;
-                        tinyTickCount *= 2;
-                    }
-
-                    for (int tinyTickIndex = 0; tinyTickIndex < tinyTickCount - 1; tinyTickIndex++)
-                    {
-                        var t = lastTickTime + (tinyTickIndex + 1) * tinyTickInterval;
-                        double progress = reversed ? 1 - (t - spanStartTime) / spanDuration : (t - spanStartTime) / spanDuration;
-
-                        AddNested(new TinyDroplet
+                        for (double t = timeBetweenTiny; t < sinceLastTick; t += timeBetweenTiny)
                         {
-                            StartTime = t,
-                            X = X + Path.PositionAt(progress).X / CatchPlayfield.BASE_WIDTH,
-                            Samples = tickSamples
-                        });
+                            AddNested(new TinyDroplet
+                            {
+                                Samples = tickSamples,
+                                StartTime = t + lastEvent.Value.Time,
+                                X = X + Path.PositionAt(
+                                        lastEvent.Value.PathProgress + (t / sinceLastTick) * (e.PathProgress - lastEvent.Value.PathProgress)).X / CatchPlayfield.BASE_WIDTH,
+                            });
+                        }
                     }
-
-                    lastTickTime = time;
-
-                    if (isLastTick)
-                        break;
-
-                    AddNested(new Droplet
-                    {
-                        StartTime = time,
-                        X = X + Path.PositionAt(distanceProgress).X / CatchPlayfield.BASE_WIDTH,
-                        Samples = tickSamples
-                    });
                 }
 
-                AddNested(new Fruit
+                // this also includes LegacyLastTick and this is used for TinyDroplet generation above.
+                // this means that the final segment of TinyDroplets are increasingly mistimed where LegacyLastTickOffset is being applied.
+                lastEvent = e;
+
+                switch (e.Type)
                 {
-                    Samples = Samples,
-                    StartTime = spanStartTime + spanDuration,
-                    X = X + Path.PositionAt(reversed ? 0 : 1).X / CatchPlayfield.BASE_WIDTH
-                });
+                    case SliderEventType.Tick:
+                        AddNested(new Droplet
+                        {
+                            Samples = tickSamples,
+                            StartTime = e.Time,
+                            X = X + Path.PositionAt(e.PathProgress).X / CatchPlayfield.BASE_WIDTH,
+                        });
+                        break;
+                    case SliderEventType.Head:
+                    case SliderEventType.Tail:
+                    case SliderEventType.Repeat:
+                        AddNested(new Fruit
+                        {
+                            Samples = Samples,
+                            StartTime = e.Time,
+                            X = X + Path.PositionAt(e.PathProgress).X / CatchPlayfield.BASE_WIDTH,
+                        });
+                        break;
+                }
             }
         }
 

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

@@ -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();

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

@@ -13,8 +13,8 @@ namespace osu.Game.Rulesets.Catch.Scoring
 {
     public class CatchScoreProcessor : ScoreProcessor<CatchHitObject>
     {
-        public CatchScoreProcessor(RulesetContainer<CatchHitObject> rulesetContainer)
-            : base(rulesetContainer)
+        public CatchScoreProcessor(DrawableRuleset<CatchHitObject> drawableRuleset)
+            : base(drawableRuleset)
         {
         }
 

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

@@ -60,7 +60,7 @@ namespace osu.Game.Rulesets.Catch.UI
                 if (lastPlateableFruit.IsLoaded)
                     action();
                 else
-                    lastPlateableFruit.OnLoadComplete = _ => action();
+                    lastPlateableFruit.OnLoadComplete += _ => action();
             }
 
             if (result.IsHit && fruit.CanBePlated)

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

@@ -17,13 +17,13 @@ using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
-    public class CatchRulesetContainer : ScrollingRulesetContainer<CatchPlayfield, CatchHitObject>
+    public class DrawableCatchRuleset : DrawableScrollingRuleset<CatchHitObject>
     {
         protected override ScrollVisualisationMethod VisualisationMethod => ScrollVisualisationMethod.Constant;
 
         protected override bool UserScrollSpeedAdjustment => false;
 
-        public CatchRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
+        public DrawableCatchRuleset(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
             Direction.Value = ScrollingDirection.Down;
@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Catch.UI
 
         protected override Playfield CreatePlayfield() => new CatchPlayfield(Beatmap.BeatmapInfo.BaseDifficulty, GetVisualRepresentation);
 
-        public override PassThroughInputManager CreateInputManager() => new CatchInputManager(Ruleset.RulesetInfo);
+        protected override PassThroughInputManager CreateInputManager() => new CatchInputManager(Ruleset.RulesetInfo);
 
         public override DrawableHitObject<CatchHitObject> GetVisualRepresentation(CatchHitObject h)
         {

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

@@ -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);
         }
     }
 }

osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs

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

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

@@ -10,11 +10,11 @@ using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
-    public class ManiaEditRulesetContainer : ManiaRulesetContainer
+    public class DrawableManiaEditRuleset : DrawableManiaRuleset
     {
         public new IScrollingInfo ScrollingInfo => base.ScrollingInfo;
 
-        public ManiaEditRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
+        public DrawableManiaEditRuleset(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
         }

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

@@ -20,7 +20,7 @@ namespace osu.Game.Rulesets.Mania.Edit
     [Cached(Type = typeof(IManiaHitObjectComposer))]
     public class ManiaHitObjectComposer : HitObjectComposer<ManiaHitObject>, IManiaHitObjectComposer
     {
-        protected new ManiaEditRulesetContainer RulesetContainer { get; private set; }
+        protected new DrawableManiaEditRuleset DrawableRuleset { get; private set; }
 
         public ManiaHitObjectComposer(Ruleset ruleset)
             : base(ruleset)
@@ -32,23 +32,23 @@ namespace osu.Game.Rulesets.Mania.Edit
         /// </summary>
         /// <param name="screenSpacePosition">The screen-space position.</param>
         /// <returns>The column which intersects with <paramref name="screenSpacePosition"/>.</returns>
-        public Column ColumnAt(Vector2 screenSpacePosition) => RulesetContainer.GetColumnByPosition(screenSpacePosition);
+        public Column ColumnAt(Vector2 screenSpacePosition) => DrawableRuleset.GetColumnByPosition(screenSpacePosition);
 
         private DependencyContainer dependencies;
 
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
             => dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
-        public int TotalColumns => ((ManiaPlayfield)RulesetContainer.Playfield).TotalColumns;
+        public int TotalColumns => ((ManiaPlayfield)DrawableRuleset.Playfield).TotalColumns;
 
-        protected override RulesetContainer<ManiaHitObject> CreateRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
+        protected override DrawableRuleset<ManiaHitObject> CreateDrawableRuleset(Ruleset ruleset, WorkingBeatmap beatmap)
         {
-            RulesetContainer = new ManiaEditRulesetContainer(ruleset, beatmap);
+            DrawableRuleset = new DrawableManiaEditRuleset(ruleset, beatmap);
 
             // This is the earliest we can cache the scrolling info to ourselves, before masks are added to the hierarchy and inject it
-            dependencies.CacheAs(RulesetContainer.ScrollingInfo);
+            dependencies.CacheAs(DrawableRuleset.ScrollingInfo);
 
-            return RulesetContainer;
+            return DrawableRuleset;
         }
 
         protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -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;
@@ -30,7 +31,7 @@ namespace osu.Game.Rulesets.Mania
 {
     public class ManiaRuleset : Ruleset
     {
-        public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap) => new ManiaRulesetContainer(this, beatmap);
+        public override DrawableRuleset CreateDrawableRulesetWith(WorkingBeatmap beatmap) => new DrawableManiaRuleset(this, beatmap);
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new ManiaBeatmapConverter(beatmap);
         public override PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, ScoreInfo score) => new ManiaPerformanceCalculator(this, beatmap, score);
 
@@ -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);
 

osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs

@@ -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)
                 },
             };
         }

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

@@ -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(),

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

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

osu.Game.Rulesets.Mania/Scoring/ManiaScoreProcessor.cs

@@ -92,8 +92,8 @@ namespace osu.Game.Rulesets.Mania.Scoring
         {
         }
 
-        public ManiaScoreProcessor(RulesetContainer<ManiaHitObject> rulesetContainer)
-            : base(rulesetContainer)
+        public ManiaScoreProcessor(DrawableRuleset<ManiaHitObject> drawableRuleset)
+            : base(drawableRuleset)
         {
         }
 

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

@@ -22,22 +22,15 @@ namespace osu.Game.Rulesets.Mania.UI
                 JudgementText.Font = JudgementText.Font.With(size: 25);
         }
 
-        protected override void LoadComplete()
+        protected override double FadeInDuration => 50;
+
+        protected override void ApplyHitAnimations()
         {
-            base.LoadComplete();
+            JudgementBody.ScaleTo(0.8f);
+            JudgementBody.ScaleTo(1, 250, Easing.OutElastic);
 
-            this.FadeInFromZero(50, Easing.OutQuint);
-
-            if (Result.IsHit)
-            {
-                JudgementBody.ScaleTo(0.8f);
-                JudgementBody.ScaleTo(1, 250, Easing.OutElastic);
-
-                JudgementBody.Delay(50).ScaleTo(0.75f, 250);
-                this.Delay(50).FadeOut(200);
-            }
-
-            Expire();
+            JudgementBody.Delay(FadeInDuration).ScaleTo(0.75f, 250);
+            this.Delay(FadeInDuration).FadeOut(200);
         }
     }
 }

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

@@ -28,17 +28,19 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
-    public class ManiaRulesetContainer : ScrollingRulesetContainer<ManiaPlayfield, ManiaHitObject>
+    public class DrawableManiaRuleset : DrawableScrollingRuleset<ManiaHitObject>
     {
+        protected new ManiaPlayfield Playfield => (ManiaPlayfield)base.Playfield;
+
         public new ManiaBeatmap Beatmap => (ManiaBeatmap)base.Beatmap;
 
         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>();
 
-        public ManiaRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
+        public DrawableManiaRuleset(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
             // Generate the bar lines
@@ -74,10 +76,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>
@@ -97,7 +99,7 @@ namespace osu.Game.Rulesets.Mania.UI
 
         public override int Variant => (int)(Beatmap.Stages.Count == 1 ? PlayfieldType.Single : PlayfieldType.Dual) + Beatmap.TotalColumns;
 
-        public override PassThroughInputManager CreateInputManager() => new ManiaInputManager(Ruleset.RulesetInfo, Variant);
+        protected override PassThroughInputManager CreateInputManager() => new ManiaInputManager(Ruleset.RulesetInfo, Variant);
 
         public override DrawableHitObject<ManiaHitObject> GetVisualRepresentation(ManiaHitObject h)
         {

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

@@ -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 });
         }
     }
 }

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

@@ -4,12 +4,13 @@
 using NUnit.Framework;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Tests.Visual;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
     [TestFixture]
-    public class TestCaseHitCircleLongCombo : Game.Tests.Visual.TestCasePlayer
+    public class TestCaseHitCircleLongCombo : PlayerTestCase
     {
         public TestCaseHitCircleLongCombo()
             : base(new OsuRuleset())

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

@@ -0,0 +1,17 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    [TestFixture]
+    public class TestCaseOsuPlayer : PlayerTestCase
+    {
+        public TestCaseOsuPlayer()
+            : base(new OsuRuleset())
+        {
+        }
+    }
+}

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

@@ -354,9 +354,9 @@ namespace osu.Game.Rulesets.Osu.Tests
                 judgementResults = new List<JudgementResult>();
             });
 
-            AddUntilStep(() => Beatmap.Value.Track.CurrentTime == 0, "Beatmap at 0");
-            AddUntilStep(() => currentPlayer.IsCurrentScreen(), "Wait until player is loaded");
-            AddUntilStep(() => allJudgedFired, "Wait for all judged");
+            AddUntilStep("Beatmap at 0", () => Beatmap.Value.Track.CurrentTime == 0);
+            AddUntilStep("Wait until player is loaded", () => currentPlayer.IsCurrentScreen());
+            AddUntilStep("Wait for all judged", () => allJudgedFired);
         }
 
         private class ScoreAccessibleReplayPlayer : ReplayPlayer

osu.Game.Rulesets.Osu/Configuration/OsuRulesetConfigManager.cs

@@ -0,0 +1,30 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.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
+    }
+}

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

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

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

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

osu.Game.Rulesets.Osu/Edit/DrawableOsuEditRuleset.cs

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Graphics.Cursor;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.UI;
@@ -9,15 +8,21 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Edit
 {
-    public class OsuEditRulesetContainer : OsuRulesetContainer
+    public class DrawableOsuEditRuleset : DrawableOsuRuleset
     {
-        public OsuEditRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
+        public DrawableOsuEditRuleset(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
         }
 
-        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();
+            }
+        }
     }
 }

osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs

@@ -26,8 +26,8 @@ namespace osu.Game.Rulesets.Osu.Edit
         {
         }
 
-        protected override RulesetContainer<OsuHitObject> CreateRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
-            => new OsuEditRulesetContainer(ruleset, beatmap);
+        protected override DrawableRuleset<OsuHitObject> CreateDrawableRuleset(Ruleset ruleset, WorkingBeatmap beatmap)
+            => new DrawableOsuEditRuleset(ruleset, beatmap);
 
         protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
         {

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

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

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

@@ -18,7 +18,7 @@ using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModBlinds : Mod, IApplicableToRulesetContainer<OsuHitObject>, IApplicableToScoreProcessor
+    public class OsuModBlinds : Mod, IApplicableToDrawableRuleset<OsuHitObject>, IApplicableToScoreProcessor
     {
         public override string Name => "Blinds";
         public override string Description => "Play with blinds on your screen.";
@@ -32,9 +32,9 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override double ScoreMultiplier => 1.12;
         private DrawableOsuBlinds blinds;
 
-        public void ApplyToRulesetContainer(RulesetContainer<OsuHitObject> rulesetContainer)
+        public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
         {
-            rulesetContainer.Overlays.Add(blinds = new DrawableOsuBlinds(rulesetContainer.Playfield.HitObjectContainer, rulesetContainer.Beatmap));
+            drawableRuleset.Overlays.Add(blinds = new DrawableOsuBlinds(drawableRuleset.Playfield.HitObjectContainer, drawableRuleset.Beatmap));
         }
 
         public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor)

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

@@ -13,7 +13,7 @@ using static osu.Game.Input.Handlers.ReplayInputHandler;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModRelax : ModRelax, IApplicableFailOverride, IUpdatableByPlayfield, IApplicableToRulesetContainer<OsuHitObject>
+    public class OsuModRelax : ModRelax, IApplicableFailOverride, IUpdatableByPlayfield, IApplicableToDrawableRuleset<OsuHitObject>
     {
         public override string Description => @"You don't need to click. Give your clicking/tapping fingers a break from the heat of things.";
         public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(OsuModAutopilot)).ToArray();
@@ -79,10 +79,10 @@ namespace osu.Game.Rulesets.Osu.Mods
             state.Apply(osuInputManager.CurrentState, osuInputManager);
         }
 
-        public void ApplyToRulesetContainer(RulesetContainer<OsuHitObject> rulesetContainer)
+        public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
         {
             // grab the input manager for future use.
-            osuInputManager = (OsuInputManager)rulesetContainer.KeyBindingInputManager;
+            osuInputManager = (OsuInputManager)drawableRuleset.KeyBindingInputManager;
             osuInputManager.AllowUserPresses = false;
         }
     }

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

@@ -5,7 +5,6 @@ using osu.Framework.Graphics;
 using osuTK;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -16,12 +15,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
         }
 
-        protected override void LoadComplete()
+        protected override void ApplyHitAnimations()
         {
-            if (Result.Type != HitResult.Miss)
-                JudgementText?.TransformSpacingTo(new Vector2(14, 0), 1800, Easing.OutQuint);
-
-            base.LoadComplete();
+            JudgementText?.TransformSpacingTo(new Vector2(14, 0), 1800, Easing.OutQuint);
+            base.ApplyHitAnimations();
         }
     }
 }

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

@@ -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);
             });
 

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

@@ -132,6 +132,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             base.ClearTransformsAfter(time, false, targetMember);
         }
 
+        public override void ApplyTransformsAt(double time, bool propagateChildren = false)
+        {
+            // For the same reasons as above w.r.t rewinding, we shouldn't propagate to children here either.
+            base.ApplyTransformsAt(time, false);
+        }
+
         private bool tracking;
 
         public bool Tracking

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

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

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

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using osuTK;
 using osu.Game.Rulesets.Objects.Types;
 using System.Collections.Generic;
@@ -155,116 +154,76 @@ namespace osu.Game.Rulesets.Osu.Objects
         {
             base.CreateNestedHitObjects();
 
-            createSliderEnds();
-            createTicks();
-            createRepeatPoints();
-
-            if (LegacyLastTickOffset != null)
-                TailCircle.StartTime = Math.Max(StartTime + Duration / 2, TailCircle.StartTime - LegacyLastTickOffset.Value);
-        }
-
-        private void createSliderEnds()
-        {
-            HeadCircle = new SliderCircle
+            foreach (var e in
+                SliderEventGenerator.Generate(StartTime, SpanDuration, Velocity, TickDistance, Path.Distance, this.SpanCount(), LegacyLastTickOffset))
             {
-                StartTime = StartTime,
-                Position = Position,
-                Samples = getNodeSamples(0),
-                SampleControlPoint = SampleControlPoint,
-                IndexInCurrentCombo = IndexInCurrentCombo,
-                ComboIndex = ComboIndex,
-            };
+                var firstSample = Samples.Find(s => s.Name == SampleInfo.HIT_NORMAL)
+                                  ?? Samples.FirstOrDefault(); // TODO: remove this when guaranteed sort is present for samples (https://github.com/ppy/osu/issues/1933)
+                var sampleList = new List<SampleInfo>();
 
-            TailCircle = new SliderTailCircle(this)
-            {
-                StartTime = EndTime,
-                Position = EndPosition,
-                IndexInCurrentCombo = IndexInCurrentCombo,
-                ComboIndex = ComboIndex,
-            };
-
-            AddNested(HeadCircle);
-            AddNested(TailCircle);
-        }
-
-        private void createTicks()
-        {
-            // A very lenient maximum length of a slider for ticks to be generated.
-            // This exists for edge cases such as /b/1573664 where the beatmap has been edited by the user, and should never be reached in normal usage.
-            const double max_length = 100000;
-
-            var length = Math.Min(max_length, Path.Distance);
-            var tickDistance = MathHelper.Clamp(TickDistance, 0, length);
-
-            if (tickDistance == 0) return;
-
-            var minDistanceFromEnd = Velocity * 10;
-
-            var spanCount = this.SpanCount();
-
-            for (var span = 0; span < spanCount; span++)
-            {
-                var spanStartTime = StartTime + span * SpanDuration;
-                var reversed = span % 2 == 1;
-
-                for (var d = tickDistance; d <= length; d += tickDistance)
-                {
-                    if (d > length - minDistanceFromEnd)
-                        break;
-
-                    var distanceProgress = d / length;
-                    var timeProgress = reversed ? 1 - distanceProgress : distanceProgress;
-
-                    var firstSample = Samples.Find(s => s.Name == SampleInfo.HIT_NORMAL)
-                                      ?? Samples.FirstOrDefault(); // TODO: remove this when guaranteed sort is present for samples (https://github.com/ppy/osu/issues/1933)
-                    var sampleList = new List<SampleInfo>();
-
-                    if (firstSample != null)
-                        sampleList.Add(new SampleInfo
-                        {
-                            Bank = firstSample.Bank,
-                            Volume = firstSample.Volume,
-                            Name = @"slidertick",
-                        });
-
-                    AddNested(new SliderTick
+                if (firstSample != null)
+                    sampleList.Add(new SampleInfo
                     {
-                        SpanIndex = span,
-                        SpanStartTime = spanStartTime,
-                        StartTime = spanStartTime + timeProgress * SpanDuration,
-                        Position = Position + Path.PositionAt(distanceProgress),
-                        StackHeight = StackHeight,
-                        Scale = Scale,
-                        Samples = sampleList
+                        Bank = firstSample.Bank,
+                        Volume = firstSample.Volume,
+                        Name = @"slidertick",
                     });
+
+                switch (e.Type)
+                {
+                    case SliderEventType.Tick:
+                        AddNested(new SliderTick
+                        {
+                            SpanIndex = e.SpanIndex,
+                            SpanStartTime = e.SpanStartTime,
+                            StartTime = e.Time,
+                            Position = Position + Path.PositionAt(e.PathProgress),
+                            StackHeight = StackHeight,
+                            Scale = Scale,
+                            Samples = sampleList
+                        });
+                        break;
+                    case SliderEventType.Head:
+                        AddNested(HeadCircle = new SliderCircle
+                        {
+                            StartTime = e.Time,
+                            Position = Position,
+                            Samples = getNodeSamples(0),
+                            SampleControlPoint = SampleControlPoint,
+                            IndexInCurrentCombo = IndexInCurrentCombo,
+                            ComboIndex = ComboIndex,
+                        });
+                        break;
+                    case SliderEventType.LegacyLastTick:
+                        // we need to use the LegacyLastTick here for compatibility reasons (difficulty).
+                        // it is *okay* to use this because the TailCircle is not used for any meaningful purpose in gameplay.
+                        // if this is to change, we should revisit this.
+                        AddNested(TailCircle = new SliderTailCircle(this)
+                        {
+                            StartTime = e.Time,
+                            Position = EndPosition,
+                            IndexInCurrentCombo = IndexInCurrentCombo,
+                            ComboIndex = ComboIndex,
+                        });
+                        break;
+                    case SliderEventType.Repeat:
+                        AddNested(new RepeatPoint
+                        {
+                            RepeatIndex = e.SpanIndex,
+                            SpanDuration = SpanDuration,
+                            StartTime = StartTime + (e.SpanIndex + 1) * SpanDuration,
+                            Position = Position + Path.PositionAt(e.PathProgress),
+                            StackHeight = StackHeight,
+                            Scale = Scale,
+                            Samples = getNodeSamples(e.SpanIndex + 1)
+                        });
+                        break;
                 }
             }
         }
 
-        private void createRepeatPoints()
-        {
-            for (int repeatIndex = 0, repeat = 1; repeatIndex < RepeatCount; repeatIndex++, repeat++)
-            {
-                AddNested(new RepeatPoint
-                {
-                    RepeatIndex = repeatIndex,
-                    SpanDuration = SpanDuration,
-                    StartTime = StartTime + repeat * SpanDuration,
-                    Position = Position + Path.PositionAt(repeat % 2),
-                    StackHeight = StackHeight,
-                    Scale = Scale,
-                    Samples = getNodeSamples(1 + repeatIndex)
-                });
-            }
-        }
-
-        private List<SampleInfo> getNodeSamples(int nodeIndex)
-        {
-            if (nodeIndex < NodeSamples.Count)
-                return NodeSamples[nodeIndex];
-
-            return Samples;
-        }
+        private List<SampleInfo> getNodeSamples(int nodeIndex) =>
+            nodeIndex < NodeSamples.Count ? NodeSamples[nodeIndex] : Samples;
 
         public override Judgement CreateJudgement() => new OsuJudgement();
     }

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

@@ -8,6 +8,10 @@ using osu.Game.Rulesets.Osu.Judgements;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {
+    /// <summary>
+    /// Note that this should not be used for timing correctness.
+    /// See <see cref="SliderEventType.LegacyLastTick"/> usage in <see cref="Slider"/> for more information.
+    /// </summary>
     public class SliderTailCircle : SliderCircle
     {
         private readonly IBindable<SliderPath> pathBindable = new Bindable<SliderPath>();

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -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;
 
@@ -25,7 +29,7 @@ namespace osu.Game.Rulesets.Osu
 {
     public class OsuRuleset : Ruleset
     {
-        public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap) => new OsuRulesetContainer(this, beatmap);
+        public override DrawableRuleset CreateDrawableRulesetWith(WorkingBeatmap beatmap) => new DrawableOsuRuleset(this, beatmap);
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new OsuBeatmapConverter(beatmap);
         public override IBeatmapProcessor CreateBeatmapProcessor(IBeatmap beatmap) => new OsuBeatmapProcessor(beatmap);
 
@@ -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)
         {

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

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

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

@@ -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();

osu.Game.Rulesets.Osu/Scoring/OsuScoreProcessor.cs

@@ -15,8 +15,8 @@ namespace osu.Game.Rulesets.Osu.Scoring
 {
     internal class OsuScoreProcessor : ScoreProcessor<OsuHitObject>
     {
-        public OsuScoreProcessor(RulesetContainer<OsuHitObject> rulesetContainer)
-            : base(rulesetContainer)
+        public OsuScoreProcessor(DrawableRuleset<OsuHitObject> drawableRuleset)
+            : base(drawableRuleset)
         {
         }
 

osu.Game.Rulesets.Osu/UI/Cursor/CursorTrail.cs

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

osu.Game.Rulesets.Osu/UI/Cursor/GameplayCursorContainer.cs

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

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

@@ -2,25 +2,26 @@
 // 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;
 
 namespace osu.Game.Rulesets.Osu.UI
 {
-    public class OsuRulesetContainer : RulesetContainer<OsuPlayfield, OsuHitObject>
+    public class DrawableOsuRuleset : DrawableRuleset<OsuHitObject>
     {
-        public OsuRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
+        protected new OsuRulesetConfigManager Config => (OsuRulesetConfigManager)base.Config;
+
+        public DrawableOsuRuleset(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
         }
@@ -29,7 +30,7 @@ namespace osu.Game.Rulesets.Osu.UI
 
         protected override Playfield CreatePlayfield() => new OsuPlayfield();
 
-        public override PassThroughInputManager CreateInputManager() => new OsuInputManager(Ruleset.RulesetInfo);
+        protected override PassThroughInputManager CreateInputManager() => new OsuInputManager(Ruleset.RulesetInfo);
 
         public override DrawableHitObject<OsuHitObject> GetVisualRepresentation(OsuHitObject h)
         {
@@ -56,7 +57,5 @@ namespace osu.Game.Rulesets.Osu.UI
                 return first.StartTime - first.TimePreempt;
             }
         }
-
-        protected override CursorContainer CreateCursor() => new GameplayCursor();
     }
 }

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

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

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

@@ -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)
                 },
             };
         }

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

@@ -33,7 +33,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
         protected override double TimePerAction => default_duration * 2;
 
         private readonly Random rng = new Random(1337);
-        private TaikoRulesetContainer rulesetContainer;
+        private DrawableTaikoRuleset drawableRuleset;
         private Container playfieldContainer;
 
         [BackgroundDependencyLoader]
@@ -86,7 +86,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
                 Origin = Anchor.Centre,
                 RelativeSizeAxes = Axes.X,
                 Height = 768,
-                Children = new[] { rulesetContainer = new TaikoRulesetContainer(new TaikoRuleset(), beatmap) }
+                Children = new[] { drawableRuleset = new DrawableTaikoRuleset(new TaikoRuleset(), beatmap) }
             });
         }
 
@@ -139,7 +139,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
             var h = new DrawableTestHit(hit) { X = RNG.NextSingle(hitResult == HitResult.Good ? -0.1f : -0.05f, hitResult == HitResult.Good ? 0.1f : 0.05f) };
 
-            ((TaikoPlayfield)rulesetContainer.Playfield).OnNewResult(h, new JudgementResult(new TaikoJudgement()) { Type = hitResult });
+            ((TaikoPlayfield)drawableRuleset.Playfield).OnNewResult(h, new JudgementResult(new TaikoJudgement()) { Type = hitResult });
         }
 
         private void addStrongHitJudgement(bool kiai)
@@ -154,33 +154,33 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
             var h = new DrawableTestHit(hit) { X = RNG.NextSingle(hitResult == HitResult.Good ? -0.1f : -0.05f, hitResult == HitResult.Good ? 0.1f : 0.05f) };
 
-            ((TaikoPlayfield)rulesetContainer.Playfield).OnNewResult(h, new JudgementResult(new TaikoJudgement()) { Type = hitResult });
-            ((TaikoPlayfield)rulesetContainer.Playfield).OnNewResult(new TestStrongNestedHit(h), new JudgementResult(new TaikoStrongJudgement()) { Type = HitResult.Great });
+            ((TaikoPlayfield)drawableRuleset.Playfield).OnNewResult(h, new JudgementResult(new TaikoJudgement()) { Type = hitResult });
+            ((TaikoPlayfield)drawableRuleset.Playfield).OnNewResult(new TestStrongNestedHit(h), new JudgementResult(new TaikoStrongJudgement()) { Type = HitResult.Great });
         }
 
         private void addMissJudgement()
         {
-            ((TaikoPlayfield)rulesetContainer.Playfield).OnNewResult(new DrawableTestHit(new Hit()), new JudgementResult(new TaikoJudgement()) { Type = HitResult.Miss });
+            ((TaikoPlayfield)drawableRuleset.Playfield).OnNewResult(new DrawableTestHit(new Hit()), new JudgementResult(new TaikoJudgement()) { Type = HitResult.Miss });
         }
 
         private void addBarLine(bool major, double delay = scroll_time)
         {
-            BarLine bl = new BarLine { StartTime = rulesetContainer.Playfield.Time.Current + delay };
+            BarLine bl = new BarLine { StartTime = drawableRuleset.Playfield.Time.Current + delay };
 
-            rulesetContainer.Playfield.Add(major ? new DrawableBarLineMajor(bl) : new DrawableBarLine(bl));
+            drawableRuleset.Playfield.Add(major ? new DrawableBarLineMajor(bl) : new DrawableBarLine(bl));
         }
 
         private void addSwell(double duration = default_duration)
         {
             var swell = new Swell
             {
-                StartTime = rulesetContainer.Playfield.Time.Current + scroll_time,
+                StartTime = drawableRuleset.Playfield.Time.Current + scroll_time,
                 Duration = duration,
             };
 
             swell.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
 
-            rulesetContainer.Playfield.Add(new DrawableSwell(swell));
+            drawableRuleset.Playfield.Add(new DrawableSwell(swell));
         }
 
         private void addDrumRoll(bool strong, double duration = default_duration)
@@ -190,40 +190,40 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
             var d = new DrumRoll
             {
-                StartTime = rulesetContainer.Playfield.Time.Current + scroll_time,
+                StartTime = drawableRuleset.Playfield.Time.Current + scroll_time,
                 IsStrong = strong,
                 Duration = duration,
             };
 
             d.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
 
-            rulesetContainer.Playfield.Add(new DrawableDrumRoll(d));
+            drawableRuleset.Playfield.Add(new DrawableDrumRoll(d));
         }
 
         private void addCentreHit(bool strong)
         {
             Hit h = new Hit
             {
-                StartTime = rulesetContainer.Playfield.Time.Current + scroll_time,
+                StartTime = drawableRuleset.Playfield.Time.Current + scroll_time,
                 IsStrong = strong
             };
 
             h.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
 
-            rulesetContainer.Playfield.Add(new DrawableCentreHit(h));
+            drawableRuleset.Playfield.Add(new DrawableCentreHit(h));
         }
 
         private void addRimHit(bool strong)
         {
             Hit h = new Hit
             {
-                StartTime = rulesetContainer.Playfield.Time.Current + scroll_time,
+                StartTime = drawableRuleset.Playfield.Time.Current + scroll_time,
                 IsStrong = strong
             };
 
             h.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
 
-            rulesetContainer.Playfield.Add(new DrawableRimHit(h));
+            drawableRuleset.Playfield.Add(new DrawableRimHit(h));
         }
 
         private class TestStrongNestedHit : DrawableStrongNestedHit

osu.Game.Rulesets.Taiko/Mods/TaikoModAutoplay.cs

@@ -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(),

osu.Game.Rulesets.Taiko/Mods/TaikoModFlashlight.cs

@@ -22,10 +22,10 @@ namespace osu.Game.Rulesets.Taiko.Mods
 
         private TaikoPlayfield playfield;
 
-        public override void ApplyToRulesetContainer(RulesetContainer<TaikoHitObject> rulesetContainer)
+        public override void ApplyToDrawableRuleset(DrawableRuleset<TaikoHitObject> drawableRuleset)
         {
-            playfield = (TaikoPlayfield)rulesetContainer.Playfield;
-            base.ApplyToRulesetContainer(rulesetContainer);
+            playfield = (TaikoPlayfield)drawableRuleset.Playfield;
+            base.ApplyToDrawableRuleset(drawableRuleset);
         }
 
         private class TaikoFlashlight : Flashlight

osu.Game.Rulesets.Taiko/Replays/TaikoAutoGenerator.cs

@@ -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();

osu.Game.Rulesets.Taiko/Scoring/TaikoScoreProcessor.cs

@@ -32,8 +32,8 @@ namespace osu.Game.Rulesets.Taiko.Scoring
         /// </summary>
         private double hpMissMultiplier;
 
-        public TaikoScoreProcessor(RulesetContainer<TaikoHitObject> rulesetContainer)
-            : base(rulesetContainer)
+        public TaikoScoreProcessor(DrawableRuleset<TaikoHitObject> drawableRuleset)
+            : base(drawableRuleset)
         {
         }
 

osu.Game.Rulesets.Taiko/TaikoRuleset.cs

@@ -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;
@@ -22,7 +23,7 @@ namespace osu.Game.Rulesets.Taiko
 {
     public class TaikoRuleset : Ruleset
     {
-        public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap) => new TaikoRulesetContainer(this, beatmap);
+        public override DrawableRuleset CreateDrawableRulesetWith(WorkingBeatmap beatmap) => new DrawableTaikoRuleset(this, beatmap);
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new TaikoBeatmapConverter(beatmap);
 
         public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0) => new[]
@@ -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[] { };
             }

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

@@ -39,12 +39,10 @@ namespace osu.Game.Rulesets.Taiko.UI
             }
         }
 
-        protected override void LoadComplete()
+        protected override void ApplyHitAnimations()
         {
-            if (Result.IsHit)
-                this.MoveToY(-100, 500);
-
-            base.LoadComplete();
+            this.MoveToY(-100, 500);
+            base.ApplyHitAnimations();
         }
     }
 }

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

@@ -20,13 +20,13 @@ using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Taiko.UI
 {
-    public class TaikoRulesetContainer : ScrollingRulesetContainer<TaikoPlayfield, TaikoHitObject>
+    public class DrawableTaikoRuleset : DrawableScrollingRuleset<TaikoHitObject>
     {
         protected override ScrollVisualisationMethod VisualisationMethod => ScrollVisualisationMethod.Overlapping;
 
         protected override bool UserScrollSpeedAdjustment => false;
 
-        public TaikoRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
+        public DrawableTaikoRuleset(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
             Direction.Value = ScrollingDirection.Left;
@@ -81,7 +81,7 @@ namespace osu.Game.Rulesets.Taiko.UI
 
         public override ScoreProcessor CreateScoreProcessor() => new TaikoScoreProcessor(this);
 
-        public override PassThroughInputManager CreateInputManager() => new TaikoInputManager(Ruleset.RulesetInfo);
+        protected override PassThroughInputManager CreateInputManager() => new TaikoInputManager(Ruleset.RulesetInfo);
 
         protected override Playfield CreatePlayfield() => new TaikoPlayfield(Beatmap.ControlPointInfo);
 

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

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Taiko.UI
     public class TaikoPlayfield : ScrollingPlayfield
     {
         /// <summary>
-        /// Default height of a <see cref="TaikoPlayfield"/> when inside a <see cref="TaikoRulesetContainer"/>.
+        /// Default height of a <see cref="TaikoPlayfield"/> when inside a <see cref="DrawableTaikoRuleset"/>.
         /// </summary>
         public const float DEFAULT_HEIGHT = 178;
 

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

@@ -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]);

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

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

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

@@ -0,0 +1,72 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Globalization;
+using NUnit.Framework;
+using osu.Game.Beatmaps.Formats;
+
+namespace osu.Game.Tests.Beatmaps.Formats
+{
+    [TestFixture]
+    public class ParsingTest
+    {
+        [Test]
+        public void TestNaNHandling() => allThrow<FormatException>("NaN");
+
+        [Test]
+        public void TestBadStringHandling() => allThrow<FormatException>("Random string 123");
+
+        [TestCase(Parsing.MAX_PARSE_VALUE)]
+        [TestCase(-1)]
+        [TestCase(0)]
+        [TestCase(1)]
+        [TestCase(-Parsing.MAX_PARSE_VALUE)]
+        [TestCase(10, 10)]
+        [TestCase(-10, 10)]
+        public void TestValidRanges(double input, double limit = Parsing.MAX_PARSE_VALUE)
+        {
+            Assert.AreEqual(Parsing.ParseInt((input).ToString(CultureInfo.InvariantCulture), (int)limit), (int)input);
+            Assert.AreEqual(Parsing.ParseFloat((input).ToString(CultureInfo.InvariantCulture), (float)limit), (float)input);
+            Assert.AreEqual(Parsing.ParseDouble((input).ToString(CultureInfo.InvariantCulture), limit), input);
+        }
+
+        [TestCase(double.PositiveInfinity)]
+        [TestCase(double.NegativeInfinity)]
+        [TestCase(999999999999)]
+        [TestCase(Parsing.MAX_PARSE_VALUE * 1.1)]
+        [TestCase(-Parsing.MAX_PARSE_VALUE * 1.1)]
+        [TestCase(11, 10)]
+        [TestCase(-11, 10)]
+        public void TestOutOfRangeHandling(double input, double limit = Parsing.MAX_PARSE_VALUE)
+            => allThrow<OverflowException>(input.ToString(CultureInfo.InvariantCulture), limit);
+
+        private void allThrow<T>(string input, double limit = Parsing.MAX_PARSE_VALUE)
+            where T : Exception
+        {
+            Assert.Throws(getIntParseException(input) ?? typeof(T), () => Parsing.ParseInt(input, (int)limit));
+            Assert.Throws<T>(() => Parsing.ParseFloat(input, (float)limit));
+            Assert.Throws<T>(() => Parsing.ParseDouble(input, limit));
+        }
+
+        /// <summary>
+        /// <see cref="int"/> may not be able to parse some inputs.
+        /// In this case we expect to receive the raw parsing exception.
+        /// </summary>
+        /// <param name="input">The input attempting to be parsed.</param>
+        /// <returns>The type of exception thrown by <see cref="int.Parse(string)"/>. Null if no exception is thrown.</returns>
+        private Type getIntParseException(string input)
+        {
+            try
+            {
+                var _ = int.Parse(input);
+            }
+            catch (Exception e)
+            {
+                return e.GetType();
+            }
+
+            return null;
+        }
+    }
+}

osu.Game.Tests/Beatmaps/IO/ImportBeatmapTest.cs

@@ -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);
@@ -207,6 +207,96 @@ namespace osu.Game.Tests.Beatmaps.IO
             }
         }
 
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestImportThenDeleteThenImportWithOnlineIDMismatch(bool set)
+        {
+            //unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost($"TestImportThenDeleteThenImport-{set}"))
+            {
+                try
+                {
+                    var osu = loadOsu(host);
+
+                    var imported = LoadOszIntoOsu(osu);
+
+                    if (set)
+                        imported.OnlineBeatmapSetID = 1234;
+                    else
+                        imported.Beatmaps.First().OnlineBeatmapID = 1234;
+
+                    osu.Dependencies.Get<BeatmapManager>().Update(imported);
+
+                    deleteBeatmapSet(imported, osu);
+
+                    var importedSecondTime = LoadOszIntoOsu(osu);
+
+                    // check the newly "imported" beatmap has been reimported due to mismatch (even though hashes matched)
+                    Assert.IsTrue(imported.ID != importedSecondTime.ID);
+                    Assert.IsTrue(imported.Beatmaps.First().ID != importedSecondTime.Beatmaps.First().ID);
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
+        [Test]
+        public void TestImportWithDuplicateBeatmapIDs()
+        {
+            //unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost("TestImportWithDuplicateBeatmapID"))
+            {
+                try
+                {
+                    var osu = loadOsu(host);
+
+                    var metadata = new BeatmapMetadata
+                    {
+                        Artist = "SomeArtist",
+                        AuthorString = "SomeAuthor"
+                    };
+
+                    var difficulty = new BeatmapDifficulty();
+
+                    var toImport = new BeatmapSetInfo
+                    {
+                        OnlineBeatmapSetID = 1,
+                        Metadata = metadata,
+                        Beatmaps = new List<BeatmapInfo>
+                        {
+                            new BeatmapInfo
+                            {
+                                OnlineBeatmapID = 2,
+                                Metadata = metadata,
+                                BaseDifficulty = difficulty
+                            },
+                            new BeatmapInfo
+                            {
+                                OnlineBeatmapID = 2,
+                                Metadata = metadata,
+                                Status = BeatmapSetOnlineStatus.Loved,
+                                BaseDifficulty = difficulty
+                            }
+                        }
+                    };
+
+                    var manager = osu.Dependencies.Get<BeatmapManager>();
+
+                    var imported = manager.Import(toImport);
+
+                    Assert.NotNull(imported);
+                    Assert.AreEqual(null, imported.Beatmaps[0].OnlineBeatmapID);
+                    Assert.AreEqual(null, imported.Beatmaps[1].OnlineBeatmapID);
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
         [Test]
         [NonParallelizable]
         [Ignore("Binding IPC on Appveyor isn't working (port in use). Need to figure out why")]

osu.Game.Tests/Resources/hitobject-file-samples.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

osu.Game.Tests/Visual/TestCaseAllPlayers.cs

@@ -1,12 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using NUnit.Framework;
-
-namespace osu.Game.Tests.Visual
-{
-    [TestFixture]
-    public class TestCaseAllPlayers : TestCasePlayer
-    {
-    }
-}

osu.Game.Tests/Visual/TestCaseAutoplay.cs

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using System.ComponentModel;
 using System.Linq;
 using osu.Game.Rulesets;
@@ -11,7 +10,7 @@ using osu.Game.Screens.Play;
 namespace osu.Game.Tests.Visual
 {
     [Description("Player instantiated with an autoplay mod.")]
-    public class TestCaseAutoplay : TestCasePlayer
+    public class TestCaseAutoplay : AllPlayersTestCase
     {
         protected override Player CreatePlayer(Ruleset ruleset)
         {
@@ -24,11 +23,10 @@ namespace osu.Game.Tests.Visual
             };
         }
 
-        protected override void AddCheckSteps(Func<Player> player)
+        protected override void AddCheckSteps()
         {
-            base.AddCheckSteps(player);
-            AddUntilStep(() => ((ScoreAccessiblePlayer)player()).ScoreProcessor.TotalScore.Value > 0, "score above zero");
-            AddUntilStep(() => ((ScoreAccessiblePlayer)player()).HUDOverlay.KeyCounter.Children.Any(kc => kc.CountPresses > 0), "key counter counted keys");
+            AddUntilStep("score above zero", () => ((ScoreAccessiblePlayer)Player).ScoreProcessor.TotalScore.Value > 0);
+            AddUntilStep("key counter counted keys", () => ((ScoreAccessiblePlayer)Player).HUDOverlay.KeyCounter.Children.Any(kc => kc.CountPresses > 0));
         }
 
         private class ScoreAccessiblePlayer : Player

osu.Game.Tests/Visual/TestCaseBackgroundScreenBeatmap.cs

@@ -48,8 +48,8 @@ namespace osu.Game.Tests.Visual
         };
 
         private DummySongSelect songSelect;
-        private DimAccessiblePlayerLoader playerLoader;
-        private DimAccessiblePlayer player;
+        private TestPlayerLoader playerLoader;
+        private TestPlayer player;
         private DatabaseContextFactory factory;
         private BeatmapManager manager;
         private RulesetStore rulesets;
@@ -74,31 +74,27 @@ namespace osu.Game.Tests.Visual
             Dependencies.Cache(manager = new BeatmapManager(LocalStorage, factory, rulesets, null, null, host, Beatmap.Default));
             Dependencies.Cache(new OsuConfigManager(LocalStorage));
 
+            manager.Import(TestResources.GetTestBeatmapForImport());
+
             Beatmap.SetDefault();
         }
 
         [SetUp]
-        public virtual void SetUp()
+        public virtual void SetUp() => Schedule(() =>
         {
-            Schedule(() =>
-            {
-                manager.Delete(manager.GetAllUsableBeatmapSets());
-                var temp = TestResources.GetTestBeatmapForImport();
-                manager.Import(temp);
-                Child = screenStackContainer = new ScreenStackCacheContainer { RelativeSizeAxes = Axes.Both };
-                screenStackContainer.ScreenStack.Push(songSelect = new DummySongSelect());
-            });
-        }
+            Child = screenStackContainer = new ScreenStackCacheContainer { RelativeSizeAxes = Axes.Both };
+            screenStackContainer.ScreenStack.Push(songSelect = new DummySongSelect());
+        });
 
         /// <summary>
-        /// Check if <see cref="PlayerLoader"/> properly triggers background dim previews when a user hovers over the visual settings panel.
+        /// Check if <see cref="PlayerLoader"/> properly triggers the visual settings preview when a user hovers over the visual settings panel.
         /// </summary>
         [Test]
         public void PlayerLoaderSettingsHoverTest()
         {
             setupUserSettings();
-            AddStep("Start player loader", () => songSelect.Push(playerLoader = new DimAccessiblePlayerLoader(player = new DimAccessiblePlayer())));
-            AddUntilStep(() => playerLoader?.IsLoaded ?? false, "Wait for Player Loader to load");
+            AddStep("Start player loader", () => songSelect.Push(playerLoader = new TestPlayerLoader(player = new TestPlayer())));
+            AddUntilStep("Wait for Player Loader to load", () => playerLoader?.IsLoaded ?? false);
             AddAssert("Background retained from song select", () => songSelect.IsBackgroundCurrent());
             AddStep("Trigger background preview", () =>
             {
@@ -106,16 +102,16 @@ namespace osu.Game.Tests.Visual
                 InputManager.MoveMouseTo(playerLoader.VisualSettingsPos);
             });
             waitForDim();
-            AddAssert("Screen is dimmed", () => songSelect.IsBackgroundDimmed());
+            AddAssert("Screen is dimmed and blur applied", () => songSelect.IsBackgroundDimmed() && songSelect.IsUserBlurApplied());
             AddStep("Stop background preview", () => InputManager.MoveMouseTo(playerLoader.ScreenPos));
             waitForDim();
-            AddAssert("Screen is undimmed", () => songSelect.IsBackgroundUndimmed());
+            AddAssert("Screen is undimmed and user blur removed", () => songSelect.IsBackgroundUndimmed() && playerLoader.IsBlurCorrect());
         }
 
         /// <summary>
         /// In the case of a user triggering the dim preview the instant player gets loaded, then moving the cursor off of the visual settings:
-        /// The OnHover of PlayerLoader will trigger, which could potentially trigger an undim unless checked for in PlayerLoader.
-        /// We need to check that in this scenario, the dim is still properly applied after entering player.
+        /// The OnHover of PlayerLoader will trigger, which could potentially cause visual settings to be unapplied unless checked for in PlayerLoader.
+        /// We need to check that in this scenario, the dim and blur is still properly applied after entering player.
         /// </summary>
         [Test]
         public void PlayerLoaderTransitionTest()
@@ -124,7 +120,7 @@ namespace osu.Game.Tests.Visual
             AddStep("Trigger hover event", () => playerLoader.TriggerOnHover());
             AddAssert("Background retained from song select", () => songSelect.IsBackgroundCurrent());
             waitForDim();
-            AddAssert("Screen is dimmed and unblurred", () => songSelect.IsBackgroundDimmed() && songSelect.IsBackgroundUnblurred());
+            AddAssert("Screen is dimmed and blur applied", () => songSelect.IsBackgroundDimmed() && songSelect.IsUserBlurApplied());
         }
 
         /// <summary>
@@ -165,51 +161,54 @@ namespace osu.Game.Tests.Visual
         }
 
         /// <summary>
-        /// Check if the <see cref="UserDimContainer"/> is properly accepting user dim changes at all.
+        /// Check if the <see cref="UserDimContainer"/> is properly accepting user-defined visual changes at all.
         /// </summary>
         [Test]
         public void DisableUserDimTest()
         {
             performFullSetup();
             waitForDim();
-            AddAssert("Screen is dimmed", () => songSelect.IsBackgroundDimmed());
+            AddAssert("Screen is dimmed and blur applied", () => songSelect.IsBackgroundDimmed() && songSelect.IsUserBlurApplied());
             AddStep("EnableUserDim disabled", () => songSelect.DimEnabled.Value = false);
             waitForDim();
-            AddAssert("Screen is undimmed", () => songSelect.IsBackgroundUndimmed());
+            AddAssert("Screen is undimmed and user blur removed", () => songSelect.IsBackgroundUndimmed() && songSelect.IsUserBlurDisabled());
             AddStep("EnableUserDim enabled", () => songSelect.DimEnabled.Value = true);
             waitForDim();
-            AddAssert("Screen is dimmed", () => songSelect.IsBackgroundDimmed());
+            AddAssert("Screen is dimmed and blur applied", () => songSelect.IsBackgroundDimmed() && songSelect.IsUserBlurApplied());
         }
 
         /// <summary>
-        /// Check if the fade container retains dim when pausing
+        /// Check if the visual settings container retains dim and blur when pausing
         /// </summary>
         [Test]
         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());
+            AddAssert("Screen is dimmed and blur applied", () => songSelect.IsBackgroundDimmed() && songSelect.IsUserBlurApplied());
+            AddStep("Unpause", () => player.CurrentPausableGameplayContainer.Resume());
             waitForDim();
-            AddAssert("Screen is dimmed", () => songSelect.IsBackgroundDimmed());
+            AddAssert("Screen is dimmed and blur applied", () => songSelect.IsBackgroundDimmed() && songSelect.IsUserBlurApplied());
         }
 
         /// <summary>
-        /// Check if the fade container removes user dim when suspending <see cref="Player"/> for <see cref="SoloResults"/>
+        /// Check if the visual settings container removes user dim when suspending <see cref="Player"/> for <see cref="SoloResults"/>
         /// </summary>
         [Test]
         public void TransitionTest()
         {
             performFullSetup();
-            AddStep("Transition to Results", () => player.Push(new FadeAccessibleResults(new ScoreInfo { User = new User { Username = "osu!" } })));
+            var results = new FadeAccessibleResults(new ScoreInfo { User = new User { Username = "osu!" } });
+            AddStep("Transition to Results", () => player.Push(results));
+            AddUntilStep("Wait for results is current", results.IsCurrentScreen);
             waitForDim();
-            AddAssert("Screen is undimmed and is original background", () => songSelect.IsBackgroundUndimmed() && songSelect.IsBackgroundCurrent());
+            AddAssert("Screen is undimmed, original background retained", () =>
+                songSelect.IsBackgroundUndimmed() && songSelect.IsBackgroundCurrent() && results.IsBlurCorrect());
         }
 
         /// <summary>
-        /// Check if background gets undimmed when leaving <see cref="Player"/>  for <see cref="PlaySongSelect"/>
+        /// Check if background gets undimmed and unblurred when leaving <see cref="Player"/>  for <see cref="PlaySongSelect"/>
         /// </summary>
         [Test]
         public void TransitionOutTest()
@@ -217,10 +216,26 @@ namespace osu.Game.Tests.Visual
             performFullSetup();
             AddStep("Exit to song select", () => player.Exit());
             waitForDim();
-            AddAssert("Screen is undimmed", () => songSelect.IsBackgroundUndimmed());
+            AddAssert("Screen is undimmed and user blur removed", () => songSelect.IsBackgroundUndimmed() && songSelect.IsBlurCorrect());
         }
 
-        private void waitForDim() => AddWaitStep(5, "Wait for dim");
+        /// <summary>
+        /// Check if hovering on the visual settings dialogue after resuming from player still previews the background dim.
+        /// </summary>
+        [Test]
+        public void ResumeFromPlayerTest()
+        {
+            performFullSetup();
+            AddStep("Move mouse to Visual Settings", () => InputManager.MoveMouseTo(playerLoader.VisualSettingsPos));
+            AddStep("Resume PlayerLoader", () => player.Restart());
+            waitForDim();
+            AddAssert("Screen is dimmed and blur applied", () => songSelect.IsBackgroundDimmed() && songSelect.IsUserBlurApplied());
+            AddStep("Move mouse to center of screen", () => InputManager.MoveMouseTo(playerLoader.ScreenPos));
+            waitForDim();
+            AddAssert("Screen is undimmed and user blur removed", () => songSelect.IsBackgroundUndimmed() && playerLoader.IsBlurCorrect());
+        }
+
+        private void waitForDim() => AddWaitStep("Wait for dim", 5);
 
         private void createFakeStoryboard() => AddStep("Create storyboard", () =>
         {
@@ -243,25 +258,25 @@ namespace osu.Game.Tests.Visual
 
             AddStep("Start player loader", () =>
             {
-                songSelect.Push(playerLoader = new DimAccessiblePlayerLoader(player = new DimAccessiblePlayer
+                songSelect.Push(playerLoader = new TestPlayerLoader(player = new TestPlayer
                 {
                     AllowPause = allowPause,
                     Ready = true,
                 }));
             });
-            AddUntilStep(() => playerLoader.IsLoaded, "Wait for Player Loader to load");
+            AddUntilStep("Wait for Player Loader to load", () => playerLoader.IsLoaded);
             AddStep("Move mouse to center of screen", () => InputManager.MoveMouseTo(playerLoader.ScreenPos));
-            AddUntilStep(() => player.IsLoaded, "Wait for player to load");
+            AddUntilStep("Wait for player to load", () => player.IsLoaded);
         }
 
         private void setupUserSettings()
         {
-            AddUntilStep(() => songSelect.Carousel.SelectedBeatmap != null, "Song select has selection");
+            AddUntilStep("Song select has selection", () => songSelect.Carousel.SelectedBeatmap != null);
             AddStep("Set default user settings", () =>
             {
                 Beatmap.Value.Mods.Value = Beatmap.Value.Mods.Value.Concat(new[] { new OsuModNoFail() });
                 songSelect.DimLevel.Value = 0.7f;
-                songSelect.BlurLevel.Value = 0.0f;
+                songSelect.BlurLevel.Value = 0.4f;
             });
         }
 
@@ -289,14 +304,18 @@ namespace osu.Game.Tests.Visual
 
             public bool IsBackgroundDimmed() => ((FadeAccessibleBackground)Background).CurrentColour == OsuColour.Gray(1 - (float)DimLevel.Value);
 
-            public bool IsBackgroundUnblurred() => ((FadeAccessibleBackground)Background).CurrentBlur == new Vector2(0);
-
             public bool IsBackgroundUndimmed() => ((FadeAccessibleBackground)Background).CurrentColour == Color4.White;
 
+            public bool IsUserBlurApplied() => ((FadeAccessibleBackground)Background).CurrentBlur == new Vector2((float)BlurLevel.Value * 25);
+
+            public bool IsUserBlurDisabled() => ((FadeAccessibleBackground)Background).CurrentBlur == new Vector2(0);
+
             public bool IsBackgroundInvisible() => ((FadeAccessibleBackground)Background).CurrentAlpha == 0;
 
             public bool IsBackgroundVisible() => ((FadeAccessibleBackground)Background).CurrentAlpha == 1;
 
+            public bool IsBlurCorrect() => ((FadeAccessibleBackground)Background).CurrentBlur == new Vector2(BACKGROUND_BLUR);
+
             /// <summary>
             /// Make sure every time a screen gets pushed, the background doesn't get replaced
             /// </summary>
@@ -312,9 +331,11 @@ namespace osu.Game.Tests.Visual
             }
 
             protected override BackgroundScreen CreateBackground() => new FadeAccessibleBackground(Beatmap.Value);
+
+            public bool IsBlurCorrect() => ((FadeAccessibleBackground)Background).CurrentBlur == new Vector2(BACKGROUND_BLUR);
         }
 
-        private class DimAccessiblePlayer : Player
+        private class TestPlayer : Player
         {
             protected override BackgroundScreen CreateBackground() => new FadeAccessibleBackground(Beatmap.Value);
 
@@ -328,7 +349,7 @@ namespace osu.Game.Tests.Visual
                 };
             }
 
-            public PauseContainer CurrentPauseContainer => PauseContainer;
+            public PausableGameplayContainer CurrentPausableGameplayContainer => PausableGameplayContainer;
 
             public UserDimContainer CurrentStoryboardContainer => StoryboardContainer;
 
@@ -350,7 +371,7 @@ namespace osu.Game.Tests.Visual
                     Thread.Sleep(1);
                 StoryboardEnabled = config.GetBindable<bool>(OsuSetting.ShowStoryboard);
                 ReplacesBackground.BindTo(Background.StoryboardReplacesBackground);
-                RulesetContainer.IsPaused.BindTo(IsPaused);
+                DrawableRuleset.IsPaused.BindTo(IsPaused);
             }
         }
 
@@ -368,18 +389,20 @@ namespace osu.Game.Tests.Visual
             }
         }
 
-        private class DimAccessiblePlayerLoader : PlayerLoader
+        private class TestPlayerLoader : PlayerLoader
         {
             public VisualSettings VisualSettingsPos => VisualSettings;
             public BackgroundScreen ScreenPos => Background;
 
-            public DimAccessiblePlayerLoader(Player player)
+            public TestPlayerLoader(Player player)
                 : base(() => player)
             {
             }
 
             public void TriggerOnHover() => OnHover(new HoverEvent(new InputState()));
 
+            public bool IsBlurCorrect() => ((FadeAccessibleBackground)Background).CurrentBlur == new Vector2(BACKGROUND_BLUR);
+
             protected override BackgroundScreen CreateBackground() => new FadeAccessibleBackground(Beatmap.Value);
         }
 
@@ -388,6 +411,7 @@ namespace osu.Game.Tests.Visual
             protected override UserDimContainer CreateFadeContainer() => fadeContainer = new TestUserDimContainer { RelativeSizeAxes = Axes.Both };
 
             public Color4 CurrentColour => fadeContainer.CurrentColour;
+
             public float CurrentAlpha => fadeContainer.CurrentAlpha;
 
             public Vector2 CurrentBlur => Background.BlurSigma;

osu.Game.Tests/Visual/TestCaseBeatmapCarousel.cs

@@ -87,7 +87,7 @@ namespace osu.Game.Tests.Visual
                 carousel.BeatmapSetsChanged = () => changed = true;
                 carousel.BeatmapSets = beatmapSets;
             });
-            AddUntilStep(() => changed, "Wait for load");
+            AddUntilStep("Wait for load", () => changed);
         }
 
         private void ensureRandomFetchSuccess() =>
@@ -214,7 +214,7 @@ namespace osu.Game.Tests.Visual
             checkSelected(3, 2);
 
             AddStep("Un-filter (debounce)", () => carousel.Filter(new FilterCriteria()));
-            AddUntilStep(() => !carousel.PendingFilterTask, "Wait for debounce");
+            AddUntilStep("Wait for debounce", () => !carousel.PendingFilterTask);
             checkVisibleItemCount(diff: false, count: set_count);
             checkVisibleItemCount(diff: true, count: 3);
 
@@ -327,13 +327,13 @@ namespace osu.Game.Tests.Visual
             AddStep("Remove first", () => carousel.RemoveBeatmapSet(carousel.BeatmapSets.First()));
             checkSelected(1);
 
-            AddUntilStep(() =>
+            AddUntilStep("Remove all", () =>
             {
                 if (!carousel.BeatmapSets.Any()) return true;
 
                 carousel.RemoveBeatmapSet(carousel.BeatmapSets.Last());
                 return false;
-            }, "Remove all");
+            });
 
             checkNoSelection();
         }

osu.Game.Tests/Visual/TestCaseBeatmapDetailArea.cs

@@ -1,8 +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.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
 using osu.Game.Screens.Select;
 using osuTK;
 
@@ -12,14 +16,145 @@ namespace osu.Game.Tests.Visual
     [System.ComponentModel.Description("PlaySongSelect leaderboard/details area")]
     public class TestCaseBeatmapDetailArea : OsuTestCase
     {
+        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(BeatmapDetails) };
+
         public TestCaseBeatmapDetailArea()
         {
-            Add(new BeatmapDetailArea
+            BeatmapDetailArea detailsArea;
+            Add(detailsArea = new BeatmapDetailArea
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
                 Size = new Vector2(550f, 450f),
             });
+
+            AddStep("all metrics", () => detailsArea.Beatmap = new DummyWorkingBeatmap
+                {
+                    BeatmapInfo =
+                    {
+                        Version = "All Metrics",
+                        Metadata = new BeatmapMetadata
+                        {
+                            Source = "osu!lazer",
+                            Tags = "this beatmap has all the metrics",
+                        },
+                        BaseDifficulty = new BeatmapDifficulty
+                        {
+                            CircleSize = 7,
+                            DrainRate = 1,
+                            OverallDifficulty = 5.7f,
+                            ApproachRate = 3.5f,
+                        },
+                        StarDifficulty = 5.3f,
+                        Metrics = new BeatmapMetrics
+                        {
+                            Ratings = Enumerable.Range(0, 11),
+                            Fails = Enumerable.Range(1, 100).Select(i => i % 12 - 6),
+                            Retries = Enumerable.Range(-2, 100).Select(i => i % 12 - 6),
+                        },
+                    }
+                }
+            );
+
+            AddStep("all except source", () => detailsArea.Beatmap = new DummyWorkingBeatmap
+            {
+                BeatmapInfo =
+                {
+                    Version = "All Metrics",
+                    Metadata = new BeatmapMetadata
+                    {
+                        Tags = "this beatmap has all the metrics",
+                    },
+                    BaseDifficulty = new BeatmapDifficulty
+                    {
+                        CircleSize = 7,
+                        DrainRate = 1,
+                        OverallDifficulty = 5.7f,
+                        ApproachRate = 3.5f,
+                    },
+                    StarDifficulty = 5.3f,
+                    Metrics = new BeatmapMetrics
+                    {
+                        Ratings = Enumerable.Range(0, 11),
+                        Fails = Enumerable.Range(1, 100).Select(i => i % 12 - 6),
+                        Retries = Enumerable.Range(-2, 100).Select(i => i % 12 - 6),
+                    },
+                }
+            });
+
+            AddStep("ratings", () => detailsArea.Beatmap = new DummyWorkingBeatmap
+            {
+                BeatmapInfo =
+                {
+                    Version = "Only Ratings",
+                    Metadata = new BeatmapMetadata
+                    {
+                        Source = "osu!lazer",
+                        Tags = "this beatmap has ratings metrics but not retries or fails",
+                    },
+                    BaseDifficulty = new BeatmapDifficulty
+                    {
+                        CircleSize = 6,
+                        DrainRate = 9,
+                        OverallDifficulty = 6,
+                        ApproachRate = 6,
+                    },
+                    StarDifficulty = 4.8f,
+                    Metrics = new BeatmapMetrics
+                    {
+                        Ratings = Enumerable.Range(0, 11),
+                    },
+                }
+            });
+
+            AddStep("fails+retries", () => detailsArea.Beatmap = new DummyWorkingBeatmap
+            {
+                BeatmapInfo =
+                {
+                    Version = "Only Retries and Fails",
+                    Metadata = new BeatmapMetadata
+                    {
+                        Source = "osu!lazer",
+                        Tags = "this beatmap has retries and fails but no ratings",
+                    },
+                    BaseDifficulty = new BeatmapDifficulty
+                    {
+                        CircleSize = 3.7f,
+                        DrainRate = 6,
+                        OverallDifficulty = 6,
+                        ApproachRate = 7,
+                    },
+                    StarDifficulty = 2.91f,
+                    Metrics = new BeatmapMetrics
+                    {
+                        Fails = Enumerable.Range(1, 100).Select(i => i % 12 - 6),
+                        Retries = Enumerable.Range(-2, 100).Select(i => i % 12 - 6),
+                    },
+                }
+            });
+
+            AddStep("null metrics", () => detailsArea.Beatmap = new DummyWorkingBeatmap
+            {
+                BeatmapInfo =
+                {
+                    Version = "No Metrics",
+                    Metadata = new BeatmapMetadata
+                    {
+                        Source = "osu!lazer",
+                        Tags = "this beatmap has no metrics",
+                    },
+                    BaseDifficulty = new BeatmapDifficulty
+                    {
+                        CircleSize = 5,
+                        DrainRate = 5,
+                        OverallDifficulty = 5.5f,
+                        ApproachRate = 6.5f,
+                    },
+                    StarDifficulty = 1.97f,
+                }
+            });
+
+            AddStep("null beatmap", () => detailsArea.Beatmap = null);
         }
     }
 }

osu.Game.Tests/Visual/TestCaseBeatmapInfoWedge.cs

@@ -56,11 +56,11 @@ namespace osu.Game.Tests.Visual
             // select part is redundant, but wait for load isn't
             selectBeatmap(Beatmap.Value.Beatmap);
 
-            AddWaitStep(3);
+            AddWaitStep("wait for select", 3);
 
             AddStep("hide", () => { infoWedge.State = Visibility.Hidden; });
 
-            AddWaitStep(3);
+            AddWaitStep("wait for hide", 3);
 
             AddStep("show", () => { infoWedge.State = Visibility.Visible; });
 
@@ -135,7 +135,7 @@ namespace osu.Game.Tests.Visual
                 infoWedge.Beatmap = Beatmap.Value = b == null ? Beatmap.Default : new TestWorkingBeatmap(b);
             });
 
-            AddUntilStep(() => infoWedge.Info != infoBefore, "wait for async load");
+            AddUntilStep("wait for async load", () => infoWedge.Info != infoBefore);
         }
 
         private IBeatmap createTestBeatmap(RulesetInfo ruleset)

osu.Game.Tests/Visual/TestCaseBeatmapScoresContainer.cs

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

osu.Game.Tests/Visual/TestCaseChannelTabControl.cs

@@ -90,7 +90,7 @@ namespace osu.Game.Tests.Visual
             AddStep("set second channel", () => channelTabControl.Current.Value = channelTabControl.Items.Skip(1).First());
             AddAssert("selector tab is inactive", () => !channelTabControl.ChannelSelectorActive.Value);
 
-            AddUntilStep(() =>
+            AddUntilStep("remove all channels", () =>
             {
                 var first = channelTabControl.Items.First();
                 if (first.Name == "+")
@@ -98,7 +98,7 @@ namespace osu.Game.Tests.Visual
 
                 channelTabControl.RemoveChannel(first);
                 return false;
-            }, "remove all channels");
+            });
 
             AddAssert("selector tab is active", () => channelTabControl.ChannelSelectorActive.Value);
         }

osu.Game.Tests/Visual/TestCaseChatLink.cs

@@ -159,7 +159,7 @@ namespace osu.Game.Tests.Visual
                     Scheduler.AddDelayed(() => newLine.Message = new DummyMessage(completeText ?? text), delay);
                 });
 
-                AddUntilStep(() => textContainer.All(line => line.Message is DummyMessage), $"wait for msg #{echoCounter}");
+                AddUntilStep($"wait for msg #{echoCounter}", () => textContainer.All(line => line.Message is DummyMessage));
             }
         }
 

osu.Game.Tests/Visual/TestCaseDirectPanel.cs

@@ -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)
+                }
+            };
+        }
+    }
+}

osu.Game.Tests/Visual/TestCaseDisclaimer.cs

@@ -2,16 +2,31 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
+using osu.Game.Online.API;
 using osu.Game.Screens.Menu;
+using osu.Game.Users;
 
 namespace osu.Game.Tests.Visual
 {
     public class TestCaseDisclaimer : ScreenTestCase
     {
+        [Cached(typeof(IAPIProvider))]
+        private readonly DummyAPIAccess api = new DummyAPIAccess();
+
         [BackgroundDependencyLoader]
         private void load()
         {
-            LoadScreen(new Disclaimer());
+            AddStep("load disclaimer", () => LoadScreen(new Disclaimer()));
+
+            AddStep("toggle support", () =>
+            {
+                api.LocalUser.Value = new User
+                {
+                    Username = api.LocalUser.Value.Username,
+                    Id = api.LocalUser.Value.Id,
+                    IsSupporter = !api.LocalUser.Value.IsSupporter,
+                };
+            });
         }
     }
 }

osu.Game.Tests/Visual/TestCaseGameplayMenuOverlay.cs

@@ -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"),

osu.Game.Tests/Visual/TestCaseHoldForMenuButton.cs

@@ -32,9 +32,9 @@ namespace osu.Game.Tests.Visual
             var text = holdForMenuButton.Children.OfType<SpriteText>().First();
 
             AddStep("Trigger text fade in", () => InputManager.MoveMouseTo(holdForMenuButton));
-            AddUntilStep(() => text.IsPresent && !exitAction, "Text visible");
+            AddUntilStep("Text visible", () => text.IsPresent && !exitAction);
             AddStep("Trigger text fade out", () => InputManager.MoveMouseTo(Vector2.One));
-            AddUntilStep(() => !text.IsPresent && !exitAction, "Text is not visible");
+            AddUntilStep("Text is not visible", () => !text.IsPresent && !exitAction);
 
             AddStep("Trigger exit action", () =>
             {
@@ -47,7 +47,7 @@ namespace osu.Game.Tests.Visual
             AddAssert("action not triggered", () => !exitAction);
 
             AddStep("Trigger exit action", () => InputManager.PressButton(MouseButton.Left));
-            AddUntilStep(() => exitAction, $"{nameof(holdForMenuButton.Action)} was triggered");
+            AddUntilStep($"{nameof(holdForMenuButton.Action)} was triggered", () => exitAction);
         }
     }
 }

osu.Game.Tests/Visual/TestCaseHoldToConfirmOverlay.cs

@@ -49,7 +49,7 @@ namespace osu.Game.Tests.Visual
 
             AddStep("start confirming", () => overlay.Begin());
 
-            AddUntilStep(() => fired, "wait until confirmed");
+            AddUntilStep("wait until confirmed", () => fired);
         }
 
         private class TestHoldToConfirmOverlay : ExitConfirmOverlay

osu.Game.Tests/Visual/TestCaseIdleTracker.cs

@@ -59,7 +59,7 @@ namespace osu.Game.Tests.Visual
         {
             AddStep("move mouse to top left", () => InputManager.MoveMouseTo(box1.ScreenSpaceDrawQuad.Centre));
 
-            AddUntilStep(() => box1.IsIdle && box2.IsIdle && box3.IsIdle && box4.IsIdle, "Wait for all idle");
+            AddUntilStep("Wait for all idle", () => box1.IsIdle && box2.IsIdle && box3.IsIdle && box4.IsIdle);
 
             AddStep("nudge mouse", () => InputManager.MoveMouseTo(box1.ScreenSpaceDrawQuad.Centre + new Vector2(1)));
 
@@ -87,7 +87,7 @@ namespace osu.Game.Tests.Visual
             AddAssert("check idle", () => !box3.IsIdle);
             AddAssert("check idle", () => !box4.IsIdle);
 
-            AddUntilStep(() => box1.IsIdle && box2.IsIdle && box3.IsIdle && box4.IsIdle, "Wait for all idle");
+            AddUntilStep("Wait for all idle", () => box1.IsIdle && box2.IsIdle && box3.IsIdle && box4.IsIdle);
         }
 
         [Test]
@@ -96,13 +96,13 @@ namespace osu.Game.Tests.Visual
             AddStep("move mouse", () => InputManager.MoveMouseTo(ScreenSpaceDrawQuad.Centre));
 
             AddAssert("check not idle", () => !box1.IsIdle && !box2.IsIdle && !box3.IsIdle && !box4.IsIdle);
-            AddUntilStep(() => box1.IsIdle, "Wait for idle");
+            AddUntilStep("Wait for idle", () => box1.IsIdle);
             AddAssert("check not idle", () => !box2.IsIdle && !box3.IsIdle && !box4.IsIdle);
-            AddUntilStep(() => box2.IsIdle, "Wait for idle");
+            AddUntilStep("Wait for idle", () => box2.IsIdle);
             AddAssert("check not idle", () => !box3.IsIdle && !box4.IsIdle);
-            AddUntilStep(() => box3.IsIdle, "Wait for idle");
+            AddUntilStep("Wait for idle", () => box3.IsIdle);
 
-            AddUntilStep(() => box1.IsIdle && box2.IsIdle && box3.IsIdle && box4.IsIdle, "Wait for all idle");
+            AddUntilStep("Wait for all idle", () => box1.IsIdle && box2.IsIdle && box3.IsIdle && box4.IsIdle);
         }
 
         private class IdleTrackingBox : CompositeDrawable

osu.Game.Tests/Visual/TestCaseLoaderAnimation.cs

@@ -25,30 +25,30 @@ namespace osu.Game.Tests.Visual
 
             bool logoVisible = false;
             AddStep("almost instant display", () => Child = loader = new TestLoader(250));
-            AddUntilStep(() =>
+            AddUntilStep("loaded", () =>
             {
                 logoVisible = loader.Logo?.Alpha > 0;
                 return loader.Logo != null && loader.ScreenLoaded;
-            }, "loaded");
+            });
             AddAssert("logo not visible", () => !logoVisible);
 
             AddStep("short load", () => Child = loader = new TestLoader(800));
-            AddUntilStep(() =>
+            AddUntilStep("loaded", () =>
             {
                 logoVisible = loader.Logo?.Alpha > 0;
                 return loader.Logo != null && loader.ScreenLoaded;
-            }, "loaded");
+            });
             AddAssert("logo visible", () => logoVisible);
-            AddUntilStep(() => loader.Logo?.Alpha == 0, "logo gone");
+            AddUntilStep("logo gone", () => loader.Logo?.Alpha == 0);
 
             AddStep("longer load", () => Child = loader = new TestLoader(1400));
-            AddUntilStep(() =>
+            AddUntilStep("loaded", () =>
             {
                 logoVisible = loader.Logo?.Alpha > 0;
                 return loader.Logo != null && loader.ScreenLoaded;
-            }, "loaded");
+            });
             AddAssert("logo visible", () => logoVisible);
-            AddUntilStep(() => loader.Logo?.Alpha == 0, "logo gone");
+            AddUntilStep("logo gone", () => loader.Logo?.Alpha == 0);
         }
 
         private class TestLoader : Loader

osu.Game.Tests/Visual/TestCaseMatchLeaderboard.cs

@@ -28,7 +28,7 @@ namespace osu.Game.Tests.Visual
         }
 
         [Resolved]
-        private APIAccess api { get; set; }
+        private IAPIProvider api { get; set; }
 
         [BackgroundDependencyLoader]
         private void load()

osu.Game.Tests/Visual/TestCaseMatchSettingsOverlay.cs

@@ -111,7 +111,7 @@ namespace osu.Game.Tests.Visual
                 settings.ApplyButton.Action.Invoke();
             });
 
-            AddUntilStep(() => !settings.ErrorText.IsPresent, "error not displayed");
+            AddUntilStep("error not displayed", () => !settings.ErrorText.IsPresent);
         }
 
         private class TestRoomSettings : MatchSettingsOverlay

osu.Game.Tests/Visual/TestCaseMods.cs

@@ -208,22 +208,22 @@ namespace osu.Game.Tests.Visual
         {
             checkLabelColor(Color4.White);
             selectNext(mod);
-            AddWaitStep(1, "wait for changing colour");
+            AddWaitStep("wait for changing colour", 1);
             checkLabelColor(colour);
             selectPrevious(mod);
-            AddWaitStep(1, "wait for changing colour");
+            AddWaitStep("wait for changing colour", 1);
             checkLabelColor(Color4.White);
         }
 
         private void testRankedText(Mod mod)
         {
-            AddWaitStep(1, "wait for fade");
+            AddWaitStep("wait for fade", 1);
             AddAssert("check for ranked", () => modSelect.UnrankedLabel.Alpha == 0);
             selectNext(mod);
-            AddWaitStep(1, "wait for fade");
+            AddWaitStep("wait for fade", 1);
             AddAssert("check for unranked", () => modSelect.UnrankedLabel.Alpha != 0);
             selectPrevious(mod);
-            AddWaitStep(1, "wait for fade");
+            AddWaitStep("wait for fade", 1);
             AddAssert("check for ranked", () => modSelect.UnrankedLabel.Alpha == 0);
         }
 

osu.Game.Tests/Visual/TestCaseNotificationOverlay.cs

@@ -60,7 +60,7 @@ namespace osu.Game.Tests.Visual
             setState(Visibility.Hidden);
 
             AddRepeatStep(@"add many simple", sendManyNotifications, 3);
-            AddWaitStep(5);
+            AddWaitStep("wait some", 5);
 
             checkProgressingCount(0);
 
@@ -70,7 +70,7 @@ namespace osu.Game.Tests.Visual
 
             AddAssert("Displayed count is 33", () => manager.UnreadCount.Value == 33);
 
-            AddWaitStep(10);
+            AddWaitStep("wait some", 10);
 
             checkProgressingCount(0);
 

osu.Game.Tests/Visual/TestCasePlaySongSelect.cs

@@ -112,10 +112,10 @@ namespace osu.Game.Tests.Visual
             createSongSelect();
             AddAssert("dummy selected", () => songSelect.CurrentBeatmap == defaultBeatmap);
 
-            AddUntilStep(() => songSelect.CurrentBeatmapDetailsBeatmap == defaultBeatmap, "dummy shown on wedge");
+            AddUntilStep("dummy shown on wedge", () => songSelect.CurrentBeatmapDetailsBeatmap == defaultBeatmap);
 
             addManyTestMaps();
-            AddWaitStep(3);
+            AddWaitStep("wait for select", 3);
 
             AddAssert("random map selected", () => songSelect.CurrentBeatmap != defaultBeatmap);
         }
@@ -125,7 +125,7 @@ namespace osu.Game.Tests.Visual
         {
             createSongSelect();
             addManyTestMaps();
-            AddWaitStep(3);
+            AddWaitStep("wait for add", 3);
 
             AddAssert("random map selected", () => songSelect.CurrentBeatmap != defaultBeatmap);
 
@@ -142,7 +142,7 @@ namespace osu.Game.Tests.Visual
             createSongSelect();
             changeRuleset(2);
             importForRuleset(0);
-            AddUntilStep(() => songSelect.Carousel.SelectedBeatmap == null, "no selection");
+            AddUntilStep("no selection", () => songSelect.Carousel.SelectedBeatmap == null);
         }
 
         [Test]
@@ -152,13 +152,13 @@ namespace osu.Game.Tests.Visual
             changeRuleset(2);
             importForRuleset(2);
             importForRuleset(1);
-            AddUntilStep(() => songSelect.Carousel.SelectedBeatmap.RulesetID == 2, "has selection");
+            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmap.RulesetID == 2);
 
             changeRuleset(1);
-            AddUntilStep(() => songSelect.Carousel.SelectedBeatmap.RulesetID == 1, "has selection");
+            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmap.RulesetID == 1);
 
             changeRuleset(0);
-            AddUntilStep(() => songSelect.Carousel.SelectedBeatmap == null, "no selection");
+            AddUntilStep("no selection", () => songSelect.Carousel.SelectedBeatmap == null);
         }
 
         [Test]
@@ -196,7 +196,7 @@ namespace osu.Game.Tests.Visual
         {
             createSongSelect();
             addManyTestMaps();
-            AddUntilStep(() => songSelect.Carousel.SelectedBeatmap != null, "has selection");
+            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmap != null);
 
             bool startRequested = false;
 
@@ -225,7 +225,7 @@ namespace osu.Game.Tests.Visual
         private void createSongSelect()
         {
             AddStep("create song select", () => LoadScreen(songSelect = new TestSongSelect()));
-            AddUntilStep(() => songSelect.IsCurrentScreen(), "wait for present");
+            AddUntilStep("wait for present", () => songSelect.IsCurrentScreen());
         }
 
         private void addManyTestMaps()

osu.Game.Tests/Visual/TestCasePlayerLoader.cs

@@ -37,15 +37,15 @@ namespace osu.Game.Tests.Visual
                 AllowResults = false,
             })));
 
-            AddUntilStep(() => loader.IsCurrentScreen(), "wait for current");
+            AddUntilStep("wait for current", () => loader.IsCurrentScreen());
 
             AddStep("mouse in centre", () => InputManager.MoveMouseTo(loader.ScreenSpaceDrawQuad.Centre));
 
-            AddUntilStep(() => !loader.IsCurrentScreen(), "wait for no longer current");
+            AddUntilStep("wait for no longer current", () => !loader.IsCurrentScreen());
 
             AddStep("exit loader", () => loader.Exit());
 
-            AddUntilStep(() => !loader.IsAlive, "wait for no longer alive");
+            AddUntilStep("wait for no longer alive", () => !loader.IsAlive);
 
             AddStep("load slow dummy beatmap", () =>
             {
@@ -61,7 +61,7 @@ namespace osu.Game.Tests.Visual
                 Scheduler.AddDelayed(() => slow.Ready = true, 5000);
             });
 
-            AddUntilStep(() => !loader.IsCurrentScreen(), "wait for no longer current");
+            AddUntilStep("wait for no longer current", () => !loader.IsCurrentScreen());
         }
 
         protected class SlowLoadPlayer : Player

osu.Game.Tests/Visual/TestCasePlayerReferenceLeaking.cs

@@ -0,0 +1,56 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Lists;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Screens.Play;
+
+namespace osu.Game.Tests.Visual
+{
+    public class TestCasePlayerReferenceLeaking : AllPlayersTestCase
+    {
+        private readonly WeakList<WorkingBeatmap> workingWeakReferences = new WeakList<WorkingBeatmap>();
+
+        private readonly WeakList<Player> playerWeakReferences = new WeakList<Player>();
+
+        protected override void AddCheckSteps()
+        {
+            AddUntilStep("no leaked beatmaps", () =>
+            {
+                GC.Collect();
+                GC.WaitForPendingFinalizers();
+                int count = 0;
+
+                workingWeakReferences.ForEachAlive(_ => count++);
+                return count == 1;
+            });
+
+            AddUntilStep("no leaked players", () =>
+            {
+                GC.Collect();
+                GC.WaitForPendingFinalizers();
+                int count = 0;
+
+                playerWeakReferences.ForEachAlive(_ => count++);
+                return count == 1;
+            });
+        }
+
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, IFrameBasedClock clock)
+        {
+            var working = base.CreateWorkingBeatmap(beatmap, clock);
+            workingWeakReferences.Add(working);
+            return working;
+        }
+
+        protected override Player CreatePlayer(Ruleset ruleset)
+        {
+            var player = base.CreatePlayer(ruleset);
+            playerWeakReferences.Add(player);
+            return player;
+        }
+    }
+}

osu.Game.Tests/Visual/TestCaseReplay.cs

@@ -4,25 +4,37 @@
 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
 {
     [Description("Player instantiated with a replay.")]
-    public class TestCaseReplay : TestCasePlayer
+    public class TestCaseReplay : AllPlayersTestCase
     {
         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()
+        {
+            AddUntilStep("score above zero", () => ((ScoreAccessibleReplayPlayer)Player).ScoreProcessor.TotalScore.Value > 0);
+            AddUntilStep("key counter counted keys", () => ((ScoreAccessibleReplayPlayer)Player).HUDOverlay.KeyCounter.Children.Any(kc => kc.CountPresses > 0));
+        }
+
+        private class ScoreAccessibleReplayPlayer : ReplayPlayer
+        {
+            public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
+            public new HUDOverlay HUDOverlay => base.HUDOverlay;
+
+            public ScoreAccessibleReplayPlayer(Score score)
+                : base(score)
+            {
+            }
         }
     }
 }

osu.Game.Tests/Visual/TestCaseScreenBreadcrumbControl.cs

@@ -74,7 +74,7 @@ namespace osu.Game.Tests.Visual
         }
 
         private void pushNext() => AddStep(@"push next screen", () => ((TestScreen)screenStack.CurrentScreen).PushNext());
-        private void waitForCurrent() => AddUntilStep(() => screenStack.CurrentScreen.IsCurrentScreen(), "current screen");
+        private void waitForCurrent() => AddUntilStep("current screen", () => screenStack.CurrentScreen.IsCurrentScreen());
 
         private abstract class TestScreen : OsuScreen
         {

osu.Game.Tests/Visual/TestCaseSongProgress.cs

@@ -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,
             });
@@ -39,23 +46,23 @@ namespace osu.Game.Tests.Visual
                 Origin = Anchor.TopLeft,
             });
 
-            AddWaitStep(5);
+            AddWaitStep("wait some", 5);
             AddAssert("ensure not created", () => graph.CreationCount == 0);
 
             AddStep("display values", displayNewValues);
-            AddWaitStep(5);
-            AddUntilStep(() => graph.CreationCount == 1, "wait for creation count");
+            AddWaitStep("wait some", 5);
+            AddUntilStep("wait for creation count", () => graph.CreationCount == 1);
 
             AddStep("Toggle Bar", () => progress.AllowSeeking = !progress.AllowSeeking);
-            AddWaitStep(5);
-            AddUntilStep(() => graph.CreationCount == 1, "wait for creation count");
+            AddWaitStep("wait some", 5);
+            AddUntilStep("wait for creation count", () => graph.CreationCount == 1);
 
             AddStep("Toggle Bar", () => progress.AllowSeeking = !progress.AllowSeeking);
-            AddWaitStep(5);
-            AddUntilStep(() => graph.CreationCount == 1, "wait for creation count");
+            AddWaitStep("wait some", 5);
+            AddUntilStep("wait for creation count", () => graph.CreationCount == 1);
             AddRepeatStep("New Values", displayNewValues, 5);
 
-            AddWaitStep(5);
+            AddWaitStep("wait some", 5);
             AddAssert("ensure debounced", () => graph.CreationCount == 2);
         }
 
@@ -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

osu.Game.Tests/Visual/TestCaseToolbar.cs

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

osu.Game.Tests/Visual/TestCaseUpdateableBeatmapBackgroundSprite.cs

@@ -16,42 +16,48 @@ namespace osu.Game.Tests.Visual
 {
     public class TestCaseUpdateableBeatmapBackgroundSprite : OsuTestCase
     {
-        private UpdateableBeatmapBackgroundSprite backgroundSprite;
+        private TestUpdateableBeatmapBackgroundSprite backgroundSprite;
 
         [Resolved]
         private BeatmapManager beatmaps { get; set; }
 
         [BackgroundDependencyLoader]
-        private void load(OsuGameBase osu, APIAccess api, RulesetStore rulesets)
+        private void load(OsuGameBase osu, IAPIProvider api, RulesetStore rulesets)
         {
             Bindable<BeatmapInfo> beatmapBindable = new Bindable<BeatmapInfo>();
 
             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("wait for cleanup...", () => backgroundSprite.ChildCount == 1);
+            AddStep("load imported beatmap", () => beatmapBindable.Value = imported.Beatmaps.First());
+            AddUntilStep("wait for cleanup...", () => backgroundSprite.ChildCount == 1);
 
             if (api.IsLoggedIn)
             {
-                AddUntilStep(() => req.Result != null, "wait for api response");
-
-                AddStep("online", () => beatmapBindable.Value = new BeatmapInfo
+                AddUntilStep("wait for api response", () => req.Result != null);
+                AddStep("load online beatmap", () => beatmapBindable.Value = new BeatmapInfo
                 {
                     BeatmapSet = req.Result?.ToBeatmapSet(rulesets)
                 });
+                AddUntilStep("wait for cleanup...", () => backgroundSprite.ChildCount == 1);
             }
             else
             {
                 AddStep("online (login first)", () => { });
             }
         }
+
+        private class TestUpdateableBeatmapBackgroundSprite : UpdateableBeatmapBackgroundSprite
+        {
+            public int ChildCount => InternalChildren.Count;
+        }
     }
 }

osu.Game.Tests/Visual/TestCaseUserProfile.cs

@@ -19,7 +19,7 @@ namespace osu.Game.Tests.Visual
     public class TestCaseUserProfile : OsuTestCase
     {
         private readonly TestUserProfileOverlay profile;
-        private APIAccess api;
+        private IAPIProvider api;
 
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
@@ -36,7 +36,7 @@ namespace osu.Game.Tests.Visual
         }
 
         [BackgroundDependencyLoader]
-        private void load(APIAccess api)
+        private void load(IAPIProvider api)
         {
             this.api = api;
         }
@@ -108,7 +108,7 @@ namespace osu.Game.Tests.Visual
 
         private void checkSupporterTag(bool isSupporter)
         {
-            AddUntilStep(() => profile.Header.User != null, "wait for load");
+            AddUntilStep("wait for load", () => profile.Header.User != null);
             if (isSupporter)
                 AddAssert("is supporter", () => profile.Header.SupporterTag.Alpha == 1);
             else

osu.Game/Beatmaps/BeatmapManager.cs

@@ -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>
@@ -70,7 +64,7 @@ namespace osu.Game.Beatmaps
 
         private readonly BeatmapStore beatmaps;
 
-        private readonly APIAccess api;
+        private readonly IAPIProvider api;
 
         private readonly AudioManager audioManager;
 
@@ -78,7 +72,7 @@ namespace osu.Game.Beatmaps
 
         private readonly List<DownloadBeatmapSetRequest> currentDownloads = new List<DownloadBeatmapSetRequest>();
 
-        public BeatmapManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, APIAccess api, AudioManager audioManager, GameHost host = null,
+        public BeatmapManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, AudioManager audioManager, GameHost host = null,
                               WorkingBeatmap defaultBeatmap = null)
             : base(storage, contextFactory, new BeatmapStore(contextFactory), host)
         {
@@ -108,10 +102,16 @@ namespace osu.Game.Beatmaps
                 b.BeatmapSet = beatmapSet;
             }
 
-            validateOnlineIds(beatmapSet.Beatmaps);
+            validateOnlineIds(beatmapSet);
 
             foreach (BeatmapInfo b in beatmapSet.Beatmaps)
-                fetchAndPopulateOnlineValues(b, beatmapSet.Beatmaps);
+                fetchAndPopulateOnlineValues(b);
+        }
+
+        protected override void PreImport(BeatmapSetInfo beatmapSet)
+        {
+            if (beatmapSet.Beatmaps.Any(b => b.BaseDifficulty == null))
+                throw new InvalidOperationException($"Cannot import {nameof(BeatmapInfo)} with null {nameof(BeatmapInfo.BaseDifficulty)}.");
 
             // check if a set already exists with the same online id, delete if it does.
             if (beatmapSet.OnlineBeatmapSetID != null)
@@ -126,14 +126,30 @@ namespace osu.Game.Beatmaps
             }
         }
 
-        private void validateOnlineIds(List<BeatmapInfo> beatmaps)
+        private void validateOnlineIds(BeatmapSetInfo beatmapSet)
         {
-            var beatmapIds = beatmaps.Where(b => b.OnlineBeatmapID.HasValue).Select(b => b.OnlineBeatmapID).ToList();
+            var beatmapIds = beatmapSet.Beatmaps.Where(b => b.OnlineBeatmapID.HasValue).Select(b => b.OnlineBeatmapID).ToList();
 
-            // ensure all IDs are unique in this set and none match existing IDs in the local beatmap store.
-            if (beatmapIds.GroupBy(b => b).Any(g => g.Count() > 1) || QueryBeatmaps(b => beatmapIds.Contains(b.OnlineBeatmapID)).Any())
-                // remove all online IDs if any problems were found.
-                beatmaps.ForEach(b => b.OnlineBeatmapID = null);
+            // ensure all IDs are unique
+            if (beatmapIds.GroupBy(b => b).Any(g => g.Count() > 1))
+            {
+                resetIds();
+                return;
+            }
+
+            // find any existing beatmaps in the database that have matching online ids
+            var existingBeatmaps = QueryBeatmaps(b => beatmapIds.Contains(b.OnlineBeatmapID)).ToList();
+
+            if (existingBeatmaps.Count > 0)
+            {
+                // reset the import ids (to force a re-fetch) *unless* they match the candidate CheckForExisting set.
+                // we can ignore the case where the new ids are contained by the CheckForExisting set as it will either be used (import skipped) or deleted.
+                var existing = CheckForExisting(beatmapSet);
+                if (existing == null || existingBeatmaps.Any(b => !existing.Beatmaps.Contains(b)))
+                    resetIds();
+            }
+
+            void resetIds() => beatmapSet.Beatmaps.ForEach(b => b.OnlineBeatmapID = null);
         }
 
         /// <summary>
@@ -151,8 +167,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 +180,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 +226,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>
@@ -277,6 +276,18 @@ namespace osu.Game.Beatmaps
         /// <returns>The first result for the provided query, or null if no results were found.</returns>
         public BeatmapSetInfo QueryBeatmapSet(Expression<Func<BeatmapSetInfo, bool>> query) => beatmaps.ConsumableItems.AsNoTracking().FirstOrDefault(query);
 
+        protected override bool CanUndelete(BeatmapSetInfo existing, BeatmapSetInfo import)
+        {
+            if (!base.CanUndelete(existing, import))
+                return false;
+
+            var existingIds = existing.Beatmaps.Select(b => b.OnlineBeatmapID).OrderBy(i => i);
+            var importIds = import.Beatmaps.Select(b => b.OnlineBeatmapID).OrderBy(i => i);
+
+            // force re-import if we are not in a sane state.
+            return existing.OnlineBeatmapSetID == import.OnlineBeatmapSetID && existingIds.SequenceEqual(importIds);
+        }
+
         /// <summary>
         /// Returns a list of all usable <see cref="BeatmapSetInfo"/>s.
         /// </summary>
@@ -374,7 +385,7 @@ namespace osu.Game.Beatmaps
         /// <param name="otherBeatmaps">The other beatmaps contained within this set.</param>
         /// <param name="force">Whether to re-query if the provided beatmap already has populated values.</param>
         /// <returns>True if population was successful.</returns>
-        private bool fetchAndPopulateOnlineValues(BeatmapInfo beatmap, IEnumerable<BeatmapInfo> otherBeatmaps, bool force = false)
+        private bool fetchAndPopulateOnlineValues(BeatmapInfo beatmap, bool force = false)
         {
             if (api?.State != APIState.Online)
                 return false;
@@ -397,13 +408,6 @@ namespace osu.Game.Beatmaps
 
                 beatmap.Status = res.Status;
                 beatmap.BeatmapSet.Status = res.BeatmapSet.Status;
-
-                if (otherBeatmaps.Any(b => b.OnlineBeatmapID == res.OnlineBeatmapID))
-                {
-                    Logger.Log("Another beatmap in the same set already mapped to this ID. We'll skip adding it this time.", LoggingTarget.Database);
-                    return false;
-                }
-
                 beatmap.BeatmapSet.OnlineBeatmapSetID = res.OnlineBeatmapSetID;
                 beatmap.OnlineBeatmapID = res.OnlineBeatmapID;