Merge pull request #4500 from peppy/update-framework

Update framework
2026-05-16 09:42:53 +08:00 · 2019-03-20 23:59:45 +09:00 · 2019-03-20 22:50:50 +09:00 · 2019-03-20 22:22:11 +09:00 · 2019-03-20 20:48:30 +09:00 · 2019-03-20 20:47:25 +09:00
503 changed files with 6440 additions and 2882 deletions
@@ -14,6 +14,7 @@
 tools/**
 build/tools/**

+fastlane/report.xml

 # Build results
 bin/[Dd]ebug/
@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem "fastlane"
+
+plugins_path = File.join(File.dirname(__FILE__), 'fastlane', 'Pluginfile')
+eval_gemfile(plugins_path) if File.exist?(plugins_path)
@@ -0,0 +1,173 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    CFPropertyList (3.0.0)
+    addressable (2.6.0)
+      public_suffix (>= 2.0.2, < 4.0)
+    atomos (0.1.3)
+    babosa (1.0.2)
+    claide (1.0.2)
+    colored (1.2)
+    colored2 (3.1.2)
+    commander-fastlane (4.4.6)
+      highline (~> 1.7.2)
+    declarative (0.0.10)
+    declarative-option (0.1.0)
+    digest-crc (0.4.1)
+    domain_name (0.5.20180417)
+      unf (>= 0.0.5, < 1.0.0)
+    dotenv (2.7.1)
+    emoji_regex (1.0.1)
+    excon (0.62.0)
+    faraday (0.15.4)
+      multipart-post (>= 1.2, < 3)
+    faraday-cookie_jar (0.0.6)
+      faraday (>= 0.7.4)
+      http-cookie (~> 1.0.0)
+    faraday_middleware (0.13.1)
+      faraday (>= 0.7.4, < 1.0)
+    fastimage (2.1.5)
+    fastlane (2.117.0)
+      CFPropertyList (>= 2.3, < 4.0.0)
+      addressable (>= 2.3, < 3.0.0)
+      babosa (>= 1.0.2, < 2.0.0)
+      bundler (>= 1.12.0, < 3.0.0)
+      colored
+      commander-fastlane (>= 4.4.6, < 5.0.0)
+      dotenv (>= 2.1.1, < 3.0.0)
+      emoji_regex (>= 0.1, < 2.0)
+      excon (>= 0.45.0, < 1.0.0)
+      faraday (~> 0.9)
+      faraday-cookie_jar (~> 0.0.6)
+      faraday_middleware (~> 0.9)
+      fastimage (>= 2.1.0, < 3.0.0)
+      gh_inspector (>= 1.1.2, < 2.0.0)
+      google-api-client (>= 0.21.2, < 0.24.0)
+      google-cloud-storage (>= 1.15.0, < 2.0.0)
+      highline (>= 1.7.2, < 2.0.0)
+      json (< 3.0.0)
+      mini_magick (~> 4.5.1)
+      multi_json
+      multi_xml (~> 0.5)
+      multipart-post (~> 2.0.0)
+      plist (>= 3.1.0, < 4.0.0)
+      public_suffix (~> 2.0.0)
+      rubyzip (>= 1.2.2, < 2.0.0)
+      security (= 0.1.3)
+      simctl (~> 1.6.3)
+      slack-notifier (>= 2.0.0, < 3.0.0)
+      terminal-notifier (>= 1.6.2, < 2.0.0)
+      terminal-table (>= 1.4.5, < 2.0.0)
+      tty-screen (>= 0.6.3, < 1.0.0)
+      tty-spinner (>= 0.8.0, < 1.0.0)
+      word_wrap (~> 1.0.0)
+      xcodeproj (>= 1.6.0, < 2.0.0)
+      xcpretty (~> 0.3.0)
+      xcpretty-travis-formatter (>= 0.0.3)
+    fastlane-plugin-clean_testflight_testers (0.2.0)
+    fastlane-plugin-souyuz (0.8.1)
+      souyuz (>= 0.8.1)
+    fastlane-plugin-xamarin (0.6.3)
+    gh_inspector (1.1.3)
+    google-api-client (0.23.9)
+      addressable (~> 2.5, >= 2.5.1)
+      googleauth (>= 0.5, < 0.7.0)
+      httpclient (>= 2.8.1, < 3.0)
+      mime-types (~> 3.0)
+      representable (~> 3.0)
+      retriable (>= 2.0, < 4.0)
+      signet (~> 0.9)
+    google-cloud-core (1.3.0)
+      google-cloud-env (~> 1.0)
+    google-cloud-env (1.0.5)
+      faraday (~> 0.11)
+    google-cloud-storage (1.16.0)
+      digest-crc (~> 0.4)
+      google-api-client (~> 0.23)
+      google-cloud-core (~> 1.2)
+      googleauth (>= 0.6.2, < 0.10.0)
+    googleauth (0.6.7)
+      faraday (~> 0.12)
+      jwt (>= 1.4, < 3.0)
+      memoist (~> 0.16)
+      multi_json (~> 1.11)
+      os (>= 0.9, < 2.0)
+      signet (~> 0.7)
+    highline (1.7.10)
+    http-cookie (1.0.3)
+      domain_name (~> 0.5)
+    httpclient (2.8.3)
+    json (2.2.0)
+    jwt (2.1.0)
+    memoist (0.16.0)
+    mime-types (3.2.2)
+      mime-types-data (~> 3.2015)
+    mime-types-data (3.2018.0812)
+    mini_magick (4.5.1)
+    mini_portile2 (2.4.0)
+    multi_json (1.13.1)
+    multi_xml (0.6.0)
+    multipart-post (2.0.0)
+    nanaimo (0.2.6)
+    naturally (2.2.0)
+    nokogiri (1.10.1)
+      mini_portile2 (~> 2.4.0)
+    os (1.0.0)
+    plist (3.5.0)
+    public_suffix (2.0.5)
+    representable (3.0.4)
+      declarative (< 0.1.0)
+      declarative-option (< 0.2.0)
+      uber (< 0.2.0)
+    retriable (3.1.2)
+    rouge (2.0.7)
+    rubyzip (1.2.2)
+    security (0.1.3)
+    signet (0.11.0)
+      addressable (~> 2.3)
+      faraday (~> 0.9)
+      jwt (>= 1.5, < 3.0)
+      multi_json (~> 1.10)
+    simctl (1.6.5)
+      CFPropertyList
+      naturally
+    slack-notifier (2.3.2)
+    souyuz (0.8.1)
+      fastlane (>= 2.29.0)
+      highline (~> 1.7)
+      nokogiri (~> 1.7)
+    terminal-notifier (1.8.0)
+    terminal-table (1.8.0)
+      unicode-display_width (~> 1.1, >= 1.1.1)
+    tty-cursor (0.6.1)
+    tty-screen (0.6.5)
+    tty-spinner (0.9.0)
+      tty-cursor (~> 0.6.0)
+    uber (0.1.0)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.5)
+    unicode-display_width (1.4.1)
+    word_wrap (1.0.0)
+    xcodeproj (1.8.1)
+      CFPropertyList (>= 2.3.3, < 4.0)
+      atomos (~> 0.1.3)
+      claide (>= 1.0.2, < 2.0)
+      colored2 (~> 3.1)
+      nanaimo (~> 0.2.6)
+    xcpretty (0.3.0)
+      rouge (~> 2.0.7)
+    xcpretty-travis-formatter (1.0.0)
+      xcpretty (~> 0.2, >= 0.0.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fastlane
+  fastlane-plugin-clean_testflight_testers
+  fastlane-plugin-souyuz
+  fastlane-plugin-xamarin
+
+BUNDLED WITH
+   2.0.1
@@ -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.

@@ -0,0 +1,2 @@
+app_identifier("sh.ppy.osulazer") # The bundle identifier of your app
+apple_id("apple-dev@ppy.sh") # Your Apple email address
@@ -0,0 +1,65 @@
+update_fastlane
+
+default_platform(:ios)
+
+platform :ios do
+  lane :testflight_prune_dry do
+    clean_testflight_testers(days_of_inactivity:45, dry_run: true)
+  end
+
+  # Specify a custom number for what's "inactive"
+  lane :testflight_prune do
+    clean_testflight_testers(days_of_inactivity: 45) # 120 days, so about 4 months
+  end
+
+  lane :update_version do |options|
+    options[:plist_path] = '../osu.iOS/Info.plist'
+    app_version(options)
+  end
+
+  desc 'Deploy to testflight'
+  lane :beta do |options|
+    update_version(options)
+
+    provision(
+      type: 'appstore'
+    )
+
+    build(
+      build_configuration: 'Release', 
+      build_platform: 'iPhone'
+    )
+
+    client = HTTPClient.new
+    changelog = client.get_content 'https://gist.githubusercontent.com/peppy/ab89c29dcc0dce95f39eb218e8fad197/raw'
+    changelog.gsub!('$BUILD_ID', options[:build])
+
+    pilot(
+      wait_processing_interval: 900,
+      changelog: changelog,
+      ipa: './osu.iOS/bin/iPhone/Release/osu.iOS.ipa'
+    )
+  end
+
+  desc 'Compile the project'
+  lane :build do
+    nuget_restore(
+      project_path: 'osu.iOS.sln'
+    )
+
+    souyuz(
+      platform: "ios",
+      build_target: "osu_iOS",
+      plist_path: "../osu.iOS/Info.plist"
+    )
+  end
+
+  desc 'Install provisioning profiles using match'
+  lane :provision do |options|
+    if Helper.is_ci?
+      options[:readonly] = true
+    end
+
+    match(options)
+  end
+end
@@ -0,0 +1 @@
+git_url('https://github.com/peppy/apple-certificates')
@@ -0,0 +1,7 @@
+# Autogenerated by fastlane
+#
+# Ensure this file is checked in to source control!
+
+gem 'fastlane-plugin-clean_testflight_testers'
+gem 'fastlane-plugin-souyuz'
+gem 'fastlane-plugin-xamarin'
@@ -0,0 +1,54 @@
+fastlane documentation
+================
+# Installation
+
+Make sure you have the latest version of the Xcode command line tools installed:
+
+```
+xcode-select --install
+```
+
+Install _fastlane_ using
+```
+[sudo] gem install fastlane -NV
+```
+or alternatively using `brew cask install fastlane`
+
+# Available Actions
+## iOS
+### ios testflight_prune_dry
+```
+fastlane ios testflight_prune_dry
+```
+
+### ios testflight_prune
+```
+fastlane ios testflight_prune
+```
+
+### ios update_version
+```
+fastlane ios update_version
+```
+
+### ios beta
+```
+fastlane ios beta
+```
+Deploy to testflight
+### ios build
+```
+fastlane ios build
+```
+Compile the project
+### ios provision
+```
+fastlane ios provision
+```
+Install provisioning profiles using match
+
+----
+
+This README.md is auto-generated and will be re-generated every time [fastlane](https://fastlane.tools) is run.
+More information about fastlane can be found on [fastlane.tools](https://fastlane.tools).
+The documentation of fastlane can be found on [docs.fastlane.tools](https://docs.fastlane.tools).
@@ -83,8 +83,7 @@ namespace osu.Desktop
        public override void SetHost(GameHost host)
        {
            base.SetHost(host);
-            var desktopWindow = host.Window as DesktopGameWindow;
-            if (desktopWindow != null)
+            if (host.Window is DesktopGameWindow desktopWindow)
            {
                desktopWindow.CursorState |= CursorState.Hidden;

@@ -34,13 +34,16 @@ namespace osu.Game.Rulesets.Catch.Tests
                case JuiceStream stream:
                    foreach (var nested in stream.NestedHitObjects)
                        yield return new ConvertValue((CatchHitObject)nested);
+
                    break;
                case BananaShower shower:
                    foreach (var nested in shower.NestedHitObjects)
                        yield return new ConvertValue((CatchHitObject)nested);
+
                    break;
                default:
                    yield return new ConvertValue((CatchHitObject)hitObject);
+
                    break;
            }
        }
@@ -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);

@@ -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())
@@ -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()
@@ -2,13 +2,15 @@
 // 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())
+        public TestCaseCatchPlayer()
+            : base(new CatchRuleset())
        {
        }
    }
@@ -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())
@@ -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;
        }
@@ -56,6 +56,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                            rng.Next(); // osu!stable retrieved a random banana rotation
                            rng.Next(); // osu!stable retrieved a random banana colour
                        }
+
                        break;
                    case JuiceStream juiceStream:
                        foreach (var nested in juiceStream.NestedHitObjects)
@@ -67,6 +68,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                                rng.Next(); // osu!stable retrieved a random droplet rotation
                            hitObject.X = MathHelper.Clamp(hitObject.X, 0, 1);
                        }
+
                        break;
                }
            }
@@ -98,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)
@@ -19,8 +19,10 @@ namespace osu.Game.Rulesets.Catch
    {
        [Description("Move left")]
        MoveLeft,
+
        [Description("Move right")]
        MoveRight,
+
        [Description("Engage dash")]
        Dash,
    }
@@ -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[] { };
            }
@@ -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>())
@@ -68,14 +70,17 @@ namespace osu.Game.Rulesets.Catch.Difficulty
                    // We want to only consider fruits that contribute to the combo. Droplets are addressed as accuracy and spinners are not relevant for "skill" calculations.
                    case Fruit fruit:
                        yield return new CatchDifficultyHitObject(fruit, lastObject, clockRate, halfCatchWidth);
+
                        lastObject = hitObject;
                        break;
                    case JuiceStream _:
                        foreach (var nested in hitObject.NestedHitObjects.OfType<CatchHitObject>().Where(o => !(o is TinyDroplet)))
                        {
                            yield return new CatchDifficultyHitObject(nested, lastObject, clockRate, halfCatchWidth);
+
                            lastObject = nested;
                        }
+
                        break;
                }
            }
@@ -85,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(),
+        };
    }
 }
@@ -33,11 +33,11 @@ namespace osu.Game.Rulesets.Catch.MathUtils
        /// <returns>The random value.</returns>
        public uint NextUInt()
        {
-            uint t = _x ^ _x << 11;
+            uint t = _x ^ (_x << 11);
            _x = _y;
            _y = _z;
            _z = _w;
-            return _w = _w ^ _w >> 19 ^ t ^ t >> 8;
+            return _w = _w ^ (_w >> 19) ^ t ^ (t >> 8);
        }

        /// <summary>
@@ -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(),
@@ -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
@@ -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;
+            }
+        }
    }
 }
@@ -34,7 +34,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable

        public override Color4 AccentColour
        {
-            get { return base.AccentColour; }
+            get => base.AccentColour;
            set
            {
                base.AccentColour = value;
@@ -23,9 +23,10 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable.Pieces
        }

        private Color4 accentColour;
+
        public Color4 AccentColour
        {
-            get { return accentColour; }
+            get => accentColour;
            set
            {
                accentColour = value;
@@ -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;
+                }
            }
        }

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

@@ -33,7 +33,7 @@ namespace osu.Game.Rulesets.Catch.UI

        public Container ExplodingFruitTarget
        {
-            set { MovableCatcher.ExplodingFruitTarget = value; }
+            set => MovableCatcher.ExplodingFruitTarget = value;
        }

        public CatcherArea(BeatmapDifficulty difficulty = null)
@@ -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)
@@ -158,7 +158,7 @@ namespace osu.Game.Rulesets.Catch.UI

            protected bool Dashing
            {
-                get { return dashing; }
+                get => dashing;
                set
                {
                    if (value == dashing) return;
@@ -176,7 +176,7 @@ namespace osu.Game.Rulesets.Catch.UI
            /// </summary>
            protected bool Trail
            {
-                get { return trail; }
+                get => trail;
                set
                {
                    if (value == trail) return;
@@ -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)
        {
@@ -40,29 +40,29 @@ namespace osu.Game.Rulesets.Mania.Tests
        protected override Ruleset CreateRuleset() => new ManiaRuleset();
    }

-     public class ManiaConvertMapping : ConvertMapping<ConvertValue>, IEquatable<ManiaConvertMapping>
-     {
-         public uint RandomW;
-         public uint RandomX;
-         public uint RandomY;
-         public uint RandomZ;
+    public class ManiaConvertMapping : ConvertMapping<ConvertValue>, IEquatable<ManiaConvertMapping>
+    {
+        public uint RandomW;
+        public uint RandomX;
+        public uint RandomY;
+        public uint RandomZ;

-         public ManiaConvertMapping()
-         {
-         }
+        public ManiaConvertMapping()
+        {
+        }

-         public ManiaConvertMapping(IBeatmapConverter converter)
-         {
-             var maniaConverter = (ManiaBeatmapConverter)converter;
-             RandomW = maniaConverter.Random.W;
-             RandomX = maniaConverter.Random.X;
-             RandomY = maniaConverter.Random.Y;
-             RandomZ = maniaConverter.Random.Z;
-         }
+        public ManiaConvertMapping(IBeatmapConverter converter)
+        {
+            var maniaConverter = (ManiaBeatmapConverter)converter;
+            RandomW = maniaConverter.Random.W;
+            RandomX = maniaConverter.Random.X;
+            RandomY = maniaConverter.Random.Y;
+            RandomZ = maniaConverter.Random.Z;
+        }

-         public bool Equals(ManiaConvertMapping other) => other != null && RandomW == other.RandomW && RandomX == other.RandomX && RandomY == other.RandomY && RandomZ == other.RandomZ;
-         public override bool Equals(ConvertMapping<ConvertValue> other) => base.Equals(other) && Equals(other as ManiaConvertMapping);
-     }
+        public bool Equals(ManiaConvertMapping other) => other != null && RandomW == other.RandomW && RandomX == other.RandomX && RandomY == other.RandomY && RandomZ == other.RandomZ;
+        public override bool Equals(ConvertMapping<ConvertValue> other) => base.Equals(other) && Equals(other as ManiaConvertMapping);
+    }

    public struct ConvertValue : IEquatable<ConvertValue>
    {
@@ -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);
        }
    }
 }
@@ -27,6 +27,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
        protected override IEnumerable<Type> ValidConversionTypes { get; } = new[] { typeof(IHasXPosition) };

        public int TargetColumns;
+        public bool Dual;
        public readonly bool IsForCurrentRuleset;

        // Internal for testing purposes
@@ -45,7 +46,14 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
            var roundedOverallDifficulty = Math.Round(beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty);

            if (IsForCurrentRuleset)
+            {
                TargetColumns = (int)Math.Max(1, roundedCircleSize);
+                if (TargetColumns >= 10)
+                {
+                    TargetColumns = TargetColumns / 2;
+                    Dual = true;
+                }
+            }
            else
            {
                float percentSliderOrSpinner = (float)beatmap.HitObjects.Count(h => h is IHasEndTime) / beatmap.HitObjects.Count;
@@ -70,14 +78,22 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
            return base.ConvertBeatmap(original);
        }

-        protected override Beatmap<ManiaHitObject> CreateBeatmap() => beatmap = new ManiaBeatmap(new StageDefinition { Columns = TargetColumns });
+        protected override Beatmap<ManiaHitObject> CreateBeatmap()
+        {
+            beatmap = new ManiaBeatmap(new StageDefinition { Columns = TargetColumns });
+
+            if (Dual)
+                beatmap.Stages.Add(new StageDefinition { Columns = TargetColumns });
+
+            return beatmap;
+        }

        protected override IEnumerable<ManiaHitObject> ConvertHitObject(HitObject original, IBeatmap beatmap)
        {
-            var maniaOriginal = original as ManiaHitObject;
-            if (maniaOriginal != null)
+            if (original is ManiaHitObject maniaOriginal)
            {
                yield return maniaOriginal;
+
                yield break;
            }

@@ -92,6 +108,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps

        private readonly List<double> prevNoteTimes = new List<double>(max_notes_for_density);
        private double density = int.MaxValue;
+
        private void computeDensity(double newNoteTime)
        {
            if (prevNoteTimes.Count == max_notes_for_density)
@@ -104,6 +121,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
        private double lastTime;
        private Vector2 lastPosition;
        private PatternType lastStair = PatternType.Stair;
+
        private void recordNote(double time, Vector2 position)
        {
            lastTime = time;
@@ -65,6 +65,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
            if (originalPattern.HitObjects.Count() == 1)
            {
                yield return originalPattern;
+
                yield break;
            }

@@ -135,6 +136,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
            {
                if (convertType.HasFlag(PatternType.LowProbability))
                    return generateNRandomNotes(HitObject.StartTime, 0.78, 0.3, 0);
+
                return generateNRandomNotes(HitObject.StartTime, 0.85, 0.36, 0.03);
            }

@@ -142,6 +144,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
            {
                if (convertType.HasFlag(PatternType.LowProbability))
                    return generateNRandomNotes(HitObject.StartTime, 0.43, 0.08, 0);
+
                return generateNRandomNotes(HitObject.StartTime, 0.56, 0.18, 0);
            }

@@ -149,11 +152,13 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
            {
                if (convertType.HasFlag(PatternType.LowProbability))
                    return generateNRandomNotes(HitObject.StartTime, 0.3, 0, 0);
+
                return generateNRandomNotes(HitObject.StartTime, 0.37, 0.08, 0);
            }

            if (convertType.HasFlag(PatternType.LowProbability))
                return generateNRandomNotes(HitObject.StartTime, 0.17, 0, 0);
+
            return generateNRandomNotes(HitObject.StartTime, 0.27, 0, 0);
        }

@@ -116,10 +116,10 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                }

                if (convertType.HasFlag(PatternType.Cycle) && PreviousPattern.HitObjects.Count() == 1
-                                                          // If we convert to 7K + 1, let's not overload the special key
-                                                          && (TotalColumns != 8 || lastColumn != 0)
-                                                          // Make sure the last column was not the centre column
-                                                          && (TotalColumns % 2 == 0 || lastColumn != TotalColumns / 2))
+                                                           // If we convert to 7K + 1, let's not overload the special key
+                                                           && (TotalColumns != 8 || lastColumn != 0)
+                                                           // Make sure the last column was not the centre column
+                                                           && (TotalColumns % 2 == 0 || lastColumn != TotalColumns / 2))
                {
                    // Generate a new pattern by cycling backwards (similar to Reverse but for only one hit object)
                    int column = RandomStart + TotalColumns - lastColumn - 1;
@@ -172,6 +172,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                        return pattern = generateRandomPatternWithMirrored(0.12, 0.38, 0.12);
                    if (ConversionDifficulty > 4)
                        return pattern = generateRandomPatternWithMirrored(0.12, 0.17, 0);
+
                    return pattern = generateRandomPatternWithMirrored(0.12, 0, 0);
                }

@@ -179,6 +180,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                {
                    if (convertType.HasFlag(PatternType.LowProbability))
                        return pattern = generateRandomPattern(0.78, 0.42, 0, 0);
+
                    return pattern = generateRandomPattern(1, 0.62, 0, 0);
                }

@@ -186,6 +188,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                {
                    if (convertType.HasFlag(PatternType.LowProbability))
                        return pattern = generateRandomPattern(0.35, 0.08, 0, 0);
+
                    return pattern = generateRandomPattern(0.52, 0.15, 0, 0);
                }

@@ -193,6 +196,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                {
                    if (convertType.HasFlag(PatternType.LowProbability))
                        return pattern = generateRandomPattern(0.18, 0, 0, 0);
+
                    return pattern = generateRandomPattern(0.45, 0, 0, 0);
                }

@@ -250,6 +254,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                }
                else
                    last = GetRandomColumn();
+
                return last;
            }
        }
@@ -87,6 +87,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                return 4;
            if (val >= 1 - p3)
                return 3;
+
            return val >= 1 - p2 ? 2 : 1;
        }

@@ -12,51 +12,63 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
    internal enum PatternType
    {
        None = 0,
+
        /// <summary>
        /// Keep the same as last row.
        /// </summary>
        ForceStack = 1 << 0,
+
        /// <summary>
        /// Keep different from last row.
        /// </summary>
        ForceNotStack = 1 << 1,
+
        /// <summary>
        /// Keep as single note at its original position.
        /// </summary>
        KeepSingle = 1 << 2,
+
        /// <summary>
        /// Use a lower random value.
        /// </summary>
        LowProbability = 1 << 3,
+
        /// <summary>
        /// Reserved.
        /// </summary>
        Alternate = 1 << 4,
+
        /// <summary>
        /// Ignore the repeat count.
        /// </summary>
        ForceSigSlider = 1 << 5,
+
        /// <summary>
        /// Convert slider to circle.
        /// </summary>
        ForceNotSlider = 1 << 6,
+
        /// <summary>
        /// Notes gathered together.
        /// </summary>
        Gathered = 1 << 7,
        Mirror = 1 << 8,
+
        /// <summary>
        /// Change 0 -> 6.
        /// </summary>
        Reverse = 1 << 9,
+
        /// <summary>
        /// 1 -> 5 -> 1 -> 5 like reverse.
        /// </summary>
        Cycle = 1 << 10,
+
        /// <summary>
        /// Next note will be at column + 1.
        /// </summary>
        Stair = 1 << 11,
+
        /// <summary>
        /// Next note will be at column - 1.
        /// </summary>
@@ -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
@@ -114,8 +114,8 @@ namespace osu.Game.Rulesets.Mania.Difficulty
            // Lots of arbitrary values from testing.
            // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution
            double accuracyValue = Math.Max(0.0, 0.2 - (Attributes.GreatHitWindow - 34) * 0.006667)
-                                       * strainValue
-                                       * Math.Pow(Math.Max(0.0, scaledScore - 960000) / 40000, 1.1);
+                                   * strainValue
+                                   * Math.Pow(Math.Max(0.0, scaledScore - 960000) / 40000, 1.1);

            // Bonus for many hitcircles - it's harder to keep good accuracy up for longer
            // accuracyValue *= Math.Min(1.15, Math.Pow(totalHits / 1500.0, 0.3));
@@ -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)
        {
        }
@@ -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[]
@@ -19,6 +19,7 @@ namespace osu.Game.Rulesets.Mania
    {
        [Description("Special 1")]
        Special1 = 1,
+
        [Description("Special 2")]
        Special2,

@@ -26,38 +27,55 @@ namespace osu.Game.Rulesets.Mania
        // above at a later time, without breaking replays/configs.
        [Description("Key 1")]
        Key1 = 10,
+
        [Description("Key 2")]
        Key2,
+
        [Description("Key 3")]
        Key3,
+
        [Description("Key 4")]
        Key4,
+
        [Description("Key 5")]
        Key5,
+
        [Description("Key 6")]
        Key6,
+
        [Description("Key 7")]
        Key7,
+
        [Description("Key 8")]
        Key8,
+
        [Description("Key 9")]
        Key9,
+
        [Description("Key 10")]
        Key10,
+
        [Description("Key 11")]
        Key11,
+
        [Description("Key 12")]
        Key12,
+
        [Description("Key 13")]
        Key13,
+
        [Description("Key 14")]
        Key14,
+
        [Description("Key 15")]
        Key15,
+
        [Description("Key 16")]
        Key16,
+
        [Description("Key 17")]
        Key17,
+
        [Description("Key 18")]
        Key18,
    }
@@ -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);

@@ -349,6 +355,7 @@ namespace osu.Game.Rulesets.Mania
        /// Number of columns in this stage lies at (item - Single).
        /// </summary>
        Single = 0,
+
        /// <summary>
        /// Columns are grouped into two stages.
        /// Overall number of columns lies at (item - Dual), further computation is required for
@@ -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)
                },
            };
        }
@@ -37,11 +37,11 @@ namespace osu.Game.Rulesets.Mania.MathUtils
        /// <returns>The random value.</returns>
        public uint NextUInt()
        {
-            uint t = X ^ X << 11;
+            uint t = X ^ (X << 11);
            X = Y;
            Y = Z;
            Z = W;
-            return W = W ^ W >> 19 ^ t ^ t >> 8;
+            return W = W ^ (W >> 19) ^ t ^ (t >> 8);
        }

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

-using System.Collections.Generic;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Beatmaps;
-using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;

 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModDualStages : Mod, IPlayfieldTypeMod, IApplicableToBeatmapConverter, IApplicableToBeatmap<ManiaHitObject>
+    public class ManiaModDualStages : Mod, IPlayfieldTypeMod, IApplicableToBeatmapConverter
    {
        public override string Name => "Dual Stages";
        public override string Acronym => "DS";
@@ -29,24 +27,7 @@ namespace osu.Game.Rulesets.Mania.Mods
            if (isForCurrentRuleset)
                return;

-            mbc.TargetColumns *= 2;
-        }
-
-        public void ApplyToBeatmap(Beatmap<ManiaHitObject> beatmap)
-        {
-            if (isForCurrentRuleset)
-                return;
-
-            var maniaBeatmap = (ManiaBeatmap)beatmap;
-
-            var newDefinitions = new List<StageDefinition>();
-            foreach (var existing in maniaBeatmap.Stages)
-            {
-                newDefinitions.Add(new StageDefinition { Columns = existing.Columns / 2 });
-                newDefinitions.Add(new StageDefinition { Columns = existing.Columns / 2 });
-            }
-
-            maniaBeatmap.Stages = newDefinitions;
+            mbc.Dual = true;
        }

        public PlayfieldType PlayfieldType => PlayfieldType.Dual;
@@ -85,7 +85,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables

        public override Color4 AccentColour
        {
-            get { return base.AccentColour; }
+            get => base.AccentColour;
            set
            {
                base.AccentColour = value;
@@ -56,7 +56,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables

        public override Color4 AccentColour
        {
-            get { return base.AccentColour; }
+            get => base.AccentColour;
            set
            {
                base.AccentColour = value;
@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables

        public override Color4 AccentColour
        {
-            get { return base.AccentColour; }
+            get => base.AccentColour;
            set
            {
                base.AccentColour = value;
@@ -77,11 +77,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces

        public Color4 AccentColour
        {
-            get { return accentColour; }
+            get => accentColour;
            set
            {
                if (accentColour == value)
                    return;
+
                accentColour = value;

                updateAccentColour();
@@ -90,7 +91,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces

        public bool Hitting
        {
-            get { return hitting; }
+            get => hitting;
            set
            {
                hitting = value;
@@ -35,13 +35,15 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
        }

        private Color4 accentColour;
+
        public Color4 AccentColour
        {
-            get { return accentColour; }
+            get => accentColour;
            set
            {
                if (accentColour == value)
                    return;
+
                accentColour = value;

                updateGlow();
@@ -78,8 +78,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces

        public Color4 AccentColour
        {
-            get { return Colour; }
-            set { Colour = value; }
+            get => Colour;
+            set => Colour = value;
        }
    }
 }
@@ -56,13 +56,15 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
        }

        private Color4 accentColour;
+
        public Color4 AccentColour
        {
-            get { return accentColour; }
+            get => accentColour;
            set
            {
                if (accentColour == value)
                    return;
+
                accentColour = value;

                colouredBox.Colour = AccentColour.Lighten(0.9f);
@@ -17,9 +17,10 @@ namespace osu.Game.Rulesets.Mania.Objects
        public double EndTime => StartTime + Duration;

        private double duration;
+
        public double Duration
        {
-            get { return duration; }
+            get => duration;
            set
            {
                duration = value;
@@ -29,7 +30,7 @@ namespace osu.Game.Rulesets.Mania.Objects

        public override double StartTime
        {
-            get { return base.StartTime; }
+            get => base.StartTime;
            set
            {
                base.StartTime = value;
@@ -40,7 +41,7 @@ namespace osu.Game.Rulesets.Mania.Objects

        public override int Column
        {
-            get { return base.Column; }
+            get => base.Column;
            set
            {
                base.Column = value;
@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Mania.Objects
        private static readonly IReadOnlyDictionary<HitResult, (double od0, double od5, double od10)> base_ranges = new Dictionary<HitResult, (double, double, double)>
        {
            { HitResult.Perfect, (44.8, 38.8, 27.8) },
-            { HitResult.Great, (128, 98, 68 ) },
+            { HitResult.Great, (128, 98, 68) },
            { HitResult.Good, (194, 164, 134) },
            { HitResult.Ok, (254, 224, 194) },
            { HitResult.Meh, (302, 272, 242) },
@@ -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;

@@ -92,8 +92,8 @@ namespace osu.Game.Rulesets.Mania.Scoring
        {
        }

-        public ManiaScoreProcessor(RulesetContainer<ManiaHitObject> rulesetContainer)
-            : base(rulesetContainer)
+        public ManiaScoreProcessor(DrawableRuleset<ManiaHitObject> drawableRuleset)
+            : base(drawableRuleset)
        {
        }

@@ -97,13 +97,15 @@ namespace osu.Game.Rulesets.Mania.UI
        public override Axes RelativeSizeAxes => Axes.Y;

        private bool isSpecial;
+
        public bool IsSpecial
        {
-            get { return isSpecial; }
+            get => isSpecial;
            set
            {
                if (isSpecial == value)
                    return;
+
                isSpecial = value;

                Width = isSpecial ? special_column_width : column_width;
@@ -111,13 +113,15 @@ namespace osu.Game.Rulesets.Mania.UI
        }

        private Color4 accentColour;
+
        public Color4 AccentColour
        {
-            get { return accentColour; }
+            get => accentColour;
            set
            {
                if (accentColour == value)
                    return;
+
                accentColour = value;

                background.AccentColour = value;
@@ -70,6 +70,7 @@ namespace osu.Game.Rulesets.Mania.UI.Components
            {
                if (accentColour == value)
                    return;
+
                accentColour = value;

                updateColours();
@@ -73,6 +73,7 @@ namespace osu.Game.Rulesets.Mania.UI.Components
            {
                if (accentColour == value)
                    return;
+
                accentColour = value;

                updateColours();
@@ -87,6 +87,7 @@ namespace osu.Game.Rulesets.Mania.UI.Components
            {
                if (accentColour == value)
                    return;
+
                accentColour = value;

                updateColours();
@@ -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);
        }
    }
 }
@@ -15,7 +15,6 @@ using osu.Game.Input.Handlers;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Configuration;
-using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.Replays;
@@ -29,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
@@ -75,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>
@@ -96,9 +97,9 @@ namespace osu.Game.Rulesets.Mania.UI

        public override ScoreProcessor CreateScoreProcessor() => new ManiaScoreProcessor(this);

-        public override int Variant => (int)(Mods.OfType<IPlayfieldTypeMod>().FirstOrDefault()?.PlayfieldType ?? PlayfieldType.Single) + Beatmap.TotalColumns;
+        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)
        {
@@ -33,9 +33,11 @@ namespace osu.Game.Rulesets.Osu.Tests
                case Slider slider:
                    foreach (var nested in slider.NestedHitObjects)
                        yield return createConvertValue(nested);
+
                    break;
                default:
                    yield return createConvertValue(hitObject);
+
                    break;
            }

@@ -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 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 });
        }
    }
 }
@@ -89,7 +89,8 @@ namespace osu.Game.Rulesets.Osu.Tests
        {
            private readonly bool auto;

-            public TestDrawableHitCircle(HitCircle h, bool auto) : base(h)
+            public TestDrawableHitCircle(HitCircle h, bool auto)
+                : base(h)
            {
                this.auto = auto;
            }
@@ -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())
@@ -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())
+        {
+        }
+    }
+}
@@ -301,6 +301,7 @@ namespace osu.Game.Rulesets.Osu.Tests
        }

        private float judgementOffsetDirection = 1;
+
        private void onNewResult(DrawableHitObject judgedObject, JudgementResult result)
        {
            var osuObject = judgedObject as DrawableOsuHitObject;
@@ -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
@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Osu.Tests
    public class TestCaseSpinner : OsuTestCase
    {
        public override IReadOnlyList<Type> RequiredTypes => new[]
-{
+        {
            typeof(SpinnerDisc),
            typeof(DrawableSpinner),
            typeof(DrawableOsuHitObject)
@@ -67,7 +67,8 @@ namespace osu.Game.Rulesets.Osu.Tests
        {
            private bool auto;

-            public TestDrawableSpinner(Spinner s, bool auto) : base(s)
+            public TestDrawableSpinner(Spinner s, bool auto)
+                : base(s)
            {
                this.auto = auto;
            }
@@ -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
+    }
+}
@@ -97,7 +97,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty

            // Longer maps are worth more
            double lengthBonus = 0.95f + 0.4f * Math.Min(1.0f, totalHits / 2000.0f) +
-                (totalHits > 2000 ? Math.Log10(totalHits / 2000.0f) * 0.5f : 0.0f);
+                                 (totalHits > 2000 ? Math.Log10(totalHits / 2000.0f) * 0.5f : 0.0f);

            aimValue *= lengthBonus;

@@ -113,7 +113,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                approachRateFactor += 0.3f * (Attributes.ApproachRate - 10.33f);
            else if (Attributes.ApproachRate < 8.0f)
            {
-                    approachRateFactor += 0.01f * (8.0f - Attributes.ApproachRate);
+                approachRateFactor += 0.01f * (8.0f - Attributes.ApproachRate);
            }

            aimValue *= approachRateFactor;
@@ -126,8 +126,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty
            {
                // Apply object-based bonus for flashlight.
                aimValue *= 1.0f + 0.35f * Math.Min(1.0f, totalHits / 200.0f) +
-                        (totalHits > 200 ? 0.3f * Math.Min(1.0f, (totalHits - 200) / 300.0f) +
-                        (totalHits > 500 ? (totalHits - 500) / 1200.0f : 0.0f) : 0.0f);
+                            (totalHits > 200
+                                ? 0.3f * Math.Min(1.0f, (totalHits - 200) / 300.0f) +
+                                  (totalHits > 500 ? (totalHits - 500) / 1200.0f : 0.0f)
+                                : 0.0f);
            }

            // Scale the aim value with accuracy _slightly_
@@ -144,7 +146,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty

            // Longer maps are worth more
            speedValue *= 0.95f + 0.4f * Math.Min(1.0f, totalHits / 2000.0f) +
-                (totalHits > 2000 ? Math.Log10(totalHits / 2000.0f) * 0.5f : 0.0f);
+                          (totalHits > 2000 ? Math.Log10(totalHits / 2000.0f) * 0.5f : 0.0f);

            // Penalize misses exponentially. This mainly fixes tag4 maps and the likes until a per-hitobject solution is available
            speedValue *= Math.Pow(0.97f, countMiss);
@@ -92,6 +92,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
        {
            if (slider.LazyEndPosition != null)
                return;
+
            slider.LazyEndPosition = slider.StackedPosition;

            float approxFollowCircleRadius = (float)(slider.Radius * 3);
@@ -127,8 +128,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
        {
            Vector2 pos = hitObject.StackedPosition;

-            var slider = hitObject as Slider;
-            if (slider != null)
+            if (hitObject is Slider slider)
            {
                computeSliderCursorPosition(slider);
                pos = slider.LazyEndPosition ?? pos;
@@ -38,7 +38,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
                path = new SmoothPath
                {
                    Anchor = Anchor.Centre,
-                    PathWidth = 1
+                    PathRadius = 1
                },
                marker = new CircularContainer
                {
@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
            InternalChild = body = new ManualSliderBody
            {
                AccentColour = Color4.Transparent,
-                PathWidth = slider.Scale * 64
+                PathRadius = slider.Scale * 64
            };
        }

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

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

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

-using osu.Framework.Graphics.Cursor;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.UI;
@@ -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();
+            }
+        }
    }
 }
@@ -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[]
        {
@@ -9,8 +9,10 @@ namespace osu.Game.Rulesets.Osu.Judgements
    {
        [Description(@"")]
        None,
+
        [Description(@"Good")]
        Good,
+
        [Description(@"Amazing")]
        Perfect
    }
@@ -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()
@@ -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)
@@ -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;
        }
    }
@@ -28,7 +28,7 @@ namespace osu.Game.Rulesets.Osu.Mods
        {
            foreach (var drawable in drawables)
            {
-                var hitObject = (OsuHitObject) drawable.HitObject;
+                var hitObject = (OsuHitObject)drawable.HitObject;

                float appearDistance = (float)(hitObject.TimePreempt - hitObject.TimeFadeIn) / 2;

@@ -46,7 +46,7 @@ namespace osu.Game.Rulesets.Osu.Mods
                        .MoveTo(originalPosition, moveDuration, Easing.InOutSine);
                }

-                theta += (float) hitObject.TimeFadeIn / 1000;
+                theta += (float)hitObject.TimeFadeIn / 1000;
            }
        }
    }
@@ -12,39 +12,44 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
    public class FollowPointRenderer : ConnectionRenderer<OsuHitObject>
    {
        private int pointDistance = 32;
+
        /// <summary>
        /// Determines how much space there is between points.
        /// </summary>
        public int PointDistance
        {
-            get { return pointDistance; }
+            get => pointDistance;
            set
            {
                if (pointDistance == value) return;
+
                pointDistance = value;
                update();
            }
        }

        private int preEmpt = 800;
+
        /// <summary>
        /// Follow points to the next hitobject start appearing for this many milliseconds before an hitobject's end time.
        /// </summary>
        public int PreEmpt
        {
-            get { return preEmpt; }
+            get => preEmpt;
            set
            {
                if (preEmpt == value) return;
+
                preEmpt = value;
                update();
            }
        }

        private IEnumerable<OsuHitObject> hitObjects;
+
        public override IEnumerable<OsuHitObject> HitObjects
        {
-            get { return hitObjects; }
+            get => hitObjects;
            set
            {
                hitObjects = value;
@@ -107,6 +112,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
                        fp.Expire(true);
                    }
                }
+
                prevHitObject = currHitObject;
            }
        }
@@ -102,7 +102,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables

        public override Color4 AccentColour
        {
-            get { return base.AccentColour; }
+            get => base.AccentColour;
            set
            {
                base.AccentColour = value;
@@ -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();
        }
    }
 }
@@ -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);
            });

@@ -115,7 +118,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables

        public override Color4 AccentColour
        {
-            get { return base.AccentColour; }
+            get => base.AccentColour;
            set
            {
                base.AccentColour = value;
@@ -20,7 +20,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables

        public override bool DisplayResult => false;

-        public DrawableSliderTick(SliderTick sliderTick) : base(sliderTick)
+        public DrawableSliderTick(SliderTick sliderTick)
+            : base(sliderTick)
        {
            Size = new Vector2(16) * sliderTick.Scale;
            Origin = Anchor.Centre;
@@ -42,7 +42,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
        private Color4 normalColour;
        private Color4 completeColour;

-        public DrawableSpinner(Spinner s) : base(s)
+        public DrawableSpinner(Spinner s)
+            : base(s)
        {
            Origin = Anchor.Centre;
            Position = s.Position;
@@ -18,8 +18,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces

        public string Text
        {
-            get { return number.Text; }
-            set { number.Text = value; }
+            get => number.Text;
+            set => number.Text = value;
        }

        public NumberPiece()
@@ -27,7 +27,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
        /// </summary>
        public Color4 AccentColour
        {
-            get { return accentColour; }
+            get => accentColour;
            set
            {
                accentColour = value;
@@ -132,15 +132,22 @@ 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
        {
-            get { return tracking; }
+            get => tracking;
            private set
            {
                if (value == tracking)
                    return;
+
                tracking = value;

                FollowCircle.ScaleTo(tracking ? 2f : 1, 300, Easing.OutQuint);
@@ -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>
@@ -40,6 +40,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
            {
                if (path.AccentColour == value)
                    return;
+
                path.AccentColour = value;

                container.ForceRedraw();
@@ -56,6 +57,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
            {
                if (path.BorderColour == value)
                    return;
+
                path.BorderColour = value;

                container.ForceRedraw();
@@ -105,6 +107,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                {
                    if (borderColour == value)
                        return;
+
                    borderColour = value;

                    InvalidateTexture();
@@ -120,6 +123,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                {
                    if (accentColour == value)
                        return;
+
                    accentColour = value;

                    InvalidateTexture();
@@ -15,10 +15,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces

        public Color4 AccentColour
        {
-            get
-            {
-                return Disc.Colour;
-            }
+            get => Disc.Colour;
            set
            {
                Disc.Colour = value;
@@ -17,8 +17,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces

        public Color4 AccentColour
        {
-            get { return background.AccentColour; }
-            set { background.AccentColour = value; }
+            get => background.AccentColour;
+            set => background.AccentColour = value;
        }

        private readonly SpinnerBackground background;
@@ -43,12 +43,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;

        private bool tracking;
+
        public bool Tracking
        {
-            get { return tracking; }
+            get => tracking;
            set
            {
                if (value == tracking) return;
+
                tracking = value;

                background.FadeTo(tracking ? tracking_alpha : idle_alpha, 100);
@@ -56,12 +58,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
        }

        private bool complete;
+
        public bool Complete
        {
-            get { return complete; }
+            get => complete;
            set
            {
                if (value == complete) return;
+
                complete = value;

                updateCompleteTick();
@@ -41,10 +41,11 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces

        public double SpinsPerMinute
        {
-            get { return spm; }
+            get => spm;
            private set
            {
                if (value == spm) return;
+
                spm = value;
                spmText.Text = Math.Truncate(value).ToString(@"#0");
            }
@@ -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,115 +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();
    }
@@ -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>();
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`git_url('https://github.com/peppy/apple-certificates')`