Update dependencies (#4731)

Update dependencies

.github/ISSUE_TEMPLATE.md

@@ -1,11 +0,0 @@
-osu!lazer is currently still under heavy development!
-
-Please ensure that you are making an issue for one of the following:
-
-- A bug with currently implemented features (not features that don't exist)
-- A feature you are considering adding, so we can collaborate on feedback and design.
-- Discussions about technical design decisions
-
-If your issue qualifies, replace this text with a detailed description of your issue with as much relevant information as you can provide.
-
-Screenshots and log files are highly welcomed.

.github/ISSUE_TEMPLATE/bug-issues.md

@@ -1,14 +1,11 @@
 ---
 name: Bug Report
-about: For issues regarding encountered game bugs
+about: Issues regarding encountered bugs.
 ---
-
-<!-- After you fill in all information, delete all comments in the issue -->
-
-**Describe your problem:** <!-- Provide any information you believe could be useful -->
+**Describe the bug:** 
 
 **Screenshots or videos showing encountered issue:** 
 
-**osu!lazer version:** <!-- Provide the version of your osu!lazer, you can find it at the bottom of the screen  -->
+**osu!lazer version:** 
 
-**Logs:** <!-- Attach your osu!lazer logs, you can find them under %appdata%\osu\logs in Windows, or under ~/.local/share/osu/ in Linux and macOS -->
+**Logs:** 

.github/ISSUE_TEMPLATE/crash-issues.md

@@ -1,16 +1,13 @@
 ---
 name: Crash Report
-about: For issues regarding game crashes or permanent freezes
+about: Issues regarding crashes or permanent freezes.
 ---
-
-<!-- After you fill in all information, delete all comments in the issue -->
-
-**Describe your problem:** <!-- Provide any information you believe could be useful -->
+**Describe the crash:** 
 
 **Screenshots or videos showing encountered issue:** 
 
-**osu!lazer version:** <!-- Provide the version of your osu!lazer, you can find it at the bottom of the screen  -->
+**osu!lazer version:** 
 
-**Logs:** <!-- Attach your osu!lazer logs, you can find them under %appdata%\osu\logs in Windows, or under ~/.local/share/osu/ in Linux and macOS -->
+**Logs:** 
 
-**Computer Specifications:** <!-- Attach your computer specifications, you can find them by using System Information in Windows, System Monitor in Linux, or About This Mac in macOS -->
+**Computer Specifications:** 

.github/ISSUE_TEMPLATE/feature-request-issues.md

@@ -1,10 +1,7 @@
 ---
 name: Feature Request
-about: Let us know what you would like to see in the game!
+about: Features you would like to see in the game!
 ---
+**Describe the new feature:** 
 
-<!-- After you fill in all information, delete all comments in the issue -->
-
-**Describe the feature:** <!-- Describe the feature you would like to see in the game -->
-
-**Proposal designs of the feature:** <!-- Attach screenshots of how the feature should look like according to you -->
+**Proposal designs of the feature:** 

.github/ISSUE_TEMPLATE/missing-for-live-issues.md

@@ -1,10 +1,7 @@
 ---
 name: Missing for Live
-about: Let us know the features you need which are available in osu-stable but not lazer
+about: Features which are available in osu!stable but not yet in osu!lazer.
 ---
+**Describe the missing feature:** 
 
-<!-- After you fill in all information, delete all comments in the issue -->
-
-**Describe the feature:** <!-- Describe the missing game feature -->
-
-**Designs:** <!-- Attach screenshots of how the feature is supposed to look like. For illustrative purpose only; final designs are usually re-imagined from scratch. -->
+**Proposal designs of the feature:** 

appveyor.yml

@@ -1,6 +1,6 @@
 clone_depth: 1
 version: '{branch}-{build}'
-image: Visual Studio 2017
+image: Previous Visual Studio 2017
 test: off
 install:
   - cmd: git submodule update --init --recursive --depth=5

build/build.cake

@@ -1,5 +1,5 @@
 #addin "nuget:?package=CodeFileSanity&version=0.0.21"
-#addin "nuget:?package=JetBrains.ReSharper.CommandLineTools&version=2018.2.2"
+#addin "nuget:?package=JetBrains.ReSharper.CommandLineTools&version=2019.1.1"
 #tool "nuget:?package=NVika.MSBuild&version=1.0.1"
 var nVikaToolPath = GetFiles("./tools/NVika.MSBuild.*/tools/NVika.exe").First();
 
@@ -46,7 +46,9 @@ Task("InspectCode")
             OutputFile = "inspectcodereport.xml",
         });
 
-        StartProcess(nVikaToolPath, @"parsereport ""inspectcodereport.xml"" --treatwarningsaserrors");
+        int returnCode = StartProcess(nVikaToolPath, $@"parsereport ""inspectcodereport.xml"" --treatwarningsaserrors");
+        if (returnCode != 0)
+            throw new Exception($"inspectcode failed with return code {returnCode}");
     });
 
 Task("CodeFileSanity")

osu.Desktop/OsuGameDesktop.cs

@@ -14,6 +14,7 @@ using osuTK.Input;
 using Microsoft.Win32;
 using osu.Desktop.Updater;
 using osu.Framework;
+using osu.Framework.Logging;
 using osu.Framework.Platform.Windows;
 using osu.Framework.Screens;
 using osu.Game.Screens.Menu;
@@ -35,12 +36,15 @@ namespace osu.Desktop
         {
             try
             {
-                return new StableStorage();
+                if (Host is DesktopGameHost desktopHost)
+                    return new StableStorage(desktopHost);
             }
-            catch
+            catch (Exception e)
             {
-                return null;
+                Logger.Error(e, "Error while searching for stable install");
             }
+
+            return null;
         }
 
         protected override void LoadComplete()
@@ -73,6 +77,7 @@ namespace osu.Desktop
                     if (versionManager != null)
                         versionManager.State = Visibility.Visible;
                     break;
+
                 default:
                     if (versionManager != null)
                         versionManager.State = Visibility.Hidden;
@@ -83,6 +88,7 @@ namespace osu.Desktop
         public override void SetHost(GameHost host)
         {
             base.SetHost(host);
+
             if (host.Window is DesktopGameWindow desktopWindow)
             {
                 desktopWindow.CursorState |= CursorState.Hidden;
@@ -139,8 +145,8 @@ namespace osu.Desktop
                 return null;
             }
 
-            public StableStorage()
-                : base(string.Empty, null)
+            public StableStorage(DesktopGameHost host)
+                : base(string.Empty, host)
             {
             }
         }

osu.Desktop/Overlays/VersionManager.cs

@@ -95,6 +95,7 @@ namespace osu.Desktop.Overlays
 
             var version = game.Version;
             var lastVersion = config.Get<string>(OsuSetting.Version);
+
             if (game.IsDeployedBuild && version != lastVersion)
             {
                 config.Set(OsuSetting.Version, version);
@@ -110,7 +111,7 @@ namespace osu.Desktop.Overlays
             public UpdateCompleteNotification(string version, Action<string> openUrl = null)
             {
                 Text = $"You are now running osu!lazer {version}.\nClick to see what's new!";
-                Icon = FontAwesome.fa_check_square;
+                Icon = FontAwesome.Solid.CheckSquare;
                 Activated = delegate
                 {
                     openUrl?.Invoke($"https://osu.ppy.sh/home/changelog/lazer/{version}");

osu.Desktop/Program.cs

@@ -31,6 +31,7 @@ namespace osu.Desktop
                     var importer = new ArchiveImportIPCChannel(host);
                     // Restore the cwd so relative paths given at the command line work correctly
                     Directory.SetCurrentDirectory(cwd);
+
                     foreach (var file in args)
                     {
                         Console.WriteLine(@"Importing {0}", file);

osu.Desktop/Updater/SimpleUpdateManager.cs

@@ -7,10 +7,10 @@ using Newtonsoft.Json;
 using osu.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.IO.Network;
 using osu.Framework.Platform;
 using osu.Game;
-using osu.Game.Graphics;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 
@@ -54,7 +54,7 @@ namespace osu.Desktop.Updater
                     {
                         Text = $"A newer release of osu! has been found ({version} → {latest.TagName}).\n\n"
                                + "Click here to download the new version, which can be installed over the top of your existing installation",
-                        Icon = FontAwesome.fa_upload,
+                        Icon = FontAwesome.Solid.Upload,
                         Activated = () =>
                         {
                             host.OpenUrlExternally(getBestUrl(latest));
@@ -78,6 +78,7 @@ namespace osu.Desktop.Updater
                 case RuntimeInfo.Platform.Windows:
                     bestAsset = release.Assets?.Find(f => f.Name.EndsWith(".exe"));
                     break;
+
                 case RuntimeInfo.Platform.MacOsx:
                     bestAsset = release.Assets?.Find(f => f.Name.EndsWith(".app.zip"));
                     break;

osu.Desktop/Updater/SquirrelUpdateManager.cs

@@ -9,6 +9,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Logging;
 using osu.Game;
 using osu.Game.Graphics;
@@ -158,7 +159,7 @@ namespace osu.Desktop.Updater
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
-                        Icon = FontAwesome.fa_upload,
+                        Icon = FontAwesome.Solid.Upload,
                         Colour = Color4.White,
                         Size = new Vector2(20),
                     }
@@ -174,7 +175,7 @@ namespace osu.Desktop.Updater
 
             public SquirrelLogger()
             {
-                var file = Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), "SquirrelSetupUpdater.log");
+                var file = Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly()?.Location ?? Directory.GetCurrentDirectory()), "SquirrelSetupUpdater.log");
                 if (File.Exists(file)) File.Delete(file);
                 path = file;
             }

osu.Desktop/osu.Desktop.csproj

@@ -26,9 +26,9 @@
   </ItemGroup>
   <ItemGroup Label="Package References">
     <PackageReference Include="System.IO.Packaging" Version="4.5.0" />
-    <PackageReference Include="ppy.squirrel.windows" Version="1.9.0.3" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.1" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.2.1" />
+    <PackageReference Include="ppy.squirrel.windows" Version="1.9.0.4" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.4" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.2.4" />
   </ItemGroup>
   <ItemGroup Label="Resources">
     <EmbeddedResource Include="lazer.ico" />

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

@@ -36,11 +36,13 @@ namespace osu.Game.Rulesets.Catch.Tests
                         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);
 

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

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

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

@@ -13,7 +13,7 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
-    public class TestCaseAutoJuiceStream : TestCasePlayer
+    public class TestCaseAutoJuiceStream : PlayerTestCase
     {
         public TestCaseAutoJuiceStream()
             : base(new CatchRuleset())
@@ -53,7 +53,7 @@ namespace osu.Game.Rulesets.Catch.Tests
 
         protected override Player CreatePlayer(Ruleset ruleset)
         {
-            Beatmap.Value.Mods.Value = Beatmap.Value.Mods.Value.Concat(new[] { ruleset.GetAutoplayMod() });
+            Mods.Value = Mods.Value.Concat(new[] { ruleset.GetAutoplayMod() }).ToArray();
             return base.CreatePlayer(ruleset);
         }
     }

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

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

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

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

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

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

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

@@ -1,22 +1,28 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using NUnit.Framework;
+using osu.Framework.Allocation;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
-using osu.Game.Screens.Play;
+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
@@ -28,7 +34,7 @@ namespace osu.Game.Rulesets.Catch.Tests
                 }
             };
 
-            // Should produce a hperdash
+            // 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, });
 
@@ -38,11 +44,5 @@ namespace osu.Game.Rulesets.Catch.Tests
 
             return beatmap;
         }
-
-        protected override void AddCheckSteps(Func<Player> player)
-        {
-            base.AddCheckSteps(player);
-            AddAssert("First note is hyperdash", () => Beatmap.Value.Beatmap.HitObjects[0] is Fruit f && f.HyperDash);
-        }
     }
 }

osu.Game.Rulesets.Catch.Tests/osu.Game.Rulesets.Catch.Tests.csproj

@@ -2,9 +2,9 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.0.1" />
     <PackageReference Include="NUnit" Version="3.11.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.12.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.13.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

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

@@ -3,8 +3,8 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Beatmaps;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Catch.Objects;
 
 namespace osu.Game.Rulesets.Catch.Beatmaps
@@ -23,19 +23,19 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                 {
                     Name = @"Fruit Count",
                     Content = fruits.ToString(),
-                    Icon = FontAwesome.fa_circle_o
+                    Icon = FontAwesome.Regular.Circle
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Juice Stream Count",
                     Content = juiceStreams.ToString(),
-                    Icon = FontAwesome.fa_circle
+                    Icon = FontAwesome.Regular.Circle
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Banana Shower Count",
                     Content = bananaShowers.ToString(),
-                    Icon = FontAwesome.fa_circle
+                    Icon = FontAwesome.Regular.Circle
                 }
             };
         }

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

@@ -31,6 +31,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
             initialiseHyperDash((List<CatchHitObject>)Beatmap.HitObjects);
 
             int index = 0;
+
             foreach (var obj in Beatmap.HitObjects.OfType<CatchHitObject>())
             {
                 obj.IndexInBeatmap = index++;
@@ -58,6 +59,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                         }
 
                         break;
+
                     case JuiceStream juiceStream:
                         foreach (var nested in juiceStream.NestedHitObjects)
                         {
@@ -103,6 +105,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                 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)
                 {
                     currentObject.HyperDashTarget = nextObject;

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -9,19 +9,22 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
 using System.Collections.Generic;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
 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;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Difficulty;
 using osu.Game.Rulesets.Difficulty;
+using osu.Game.Scoring;
 
 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, IReadOnlyList<Mod> mods) => new DrawableCatchRuleset(this, beatmap, mods);
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new CatchBeatmapConverter(beatmap);
         public override IBeatmapProcessor CreateBeatmapProcessor(IBeatmap beatmap) => new CatchBeatmapProcessor(beatmap);
 
@@ -84,6 +87,7 @@ namespace osu.Game.Rulesets.Catch
                         new CatchModNoFail(),
                         new MultiMod(new CatchModHalfTime(), new CatchModDaycore())
                     };
+
                 case ModType.DifficultyIncrease:
                     return new Mod[]
                     {
@@ -93,12 +97,20 @@ namespace osu.Game.Rulesets.Catch
                         new CatchModHidden(),
                         new CatchModFlashlight(),
                     };
+
                 case ModType.Automation:
                     return new Mod[]
                     {
                         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[] { };
             }
@@ -108,10 +120,12 @@ namespace osu.Game.Rulesets.Catch
 
         public override string ShortName => "fruits";
 
-        public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_fruits_o };
+        public override Drawable CreateIcon() => new SpriteIcon { Icon = OsuIcon.RulesetCatch };
 
         public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new CatchDifficultyCalculator(this, beatmap);
 
+        public override PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, ScoreInfo score) => new CatchPerformanceCalculator(this, beatmap, score);
+
         public override int? LegacyID => 2;
 
         public override IConvertibleReplayFrame CreateConvertibleReplayFrame() => new CatchReplayFrame();

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

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

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

@@ -0,0 +1,104 @@
+// 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.Beatmaps;
+using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Scoring.Legacy;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Difficulty
+{
+    public class CatchPerformanceCalculator : PerformanceCalculator
+    {
+        protected new CatchDifficultyAttributes Attributes => (CatchDifficultyAttributes)base.Attributes;
+
+        private Mod[] mods;
+
+        private int fruitsHit;
+        private int ticksHit;
+        private int tinyTicksHit;
+        private int tinyTicksMissed;
+        private int misses;
+
+        public CatchPerformanceCalculator(Ruleset ruleset, WorkingBeatmap beatmap, ScoreInfo score)
+            : base(ruleset, beatmap, score)
+        {
+        }
+
+        public override double Calculate(Dictionary<string, double> categoryDifficulty = null)
+        {
+            mods = Score.Mods;
+
+            var legacyScore = Score as LegacyScoreInfo;
+
+            fruitsHit = legacyScore?.Count300 ?? Score.Statistics[HitResult.Perfect];
+            ticksHit = legacyScore?.Count100 ?? 0;
+            tinyTicksHit = legacyScore?.Count50 ?? 0;
+            tinyTicksMissed = legacyScore?.CountKatu ?? 0;
+            misses = Score.Statistics[HitResult.Miss];
+
+            // Don't count scores made with supposedly unranked mods
+            if (mods.Any(m => !m.Ranked))
+                return 0;
+
+            // We are heavily relying on aim in catch the beat
+            double value = Math.Pow(5.0f * Math.Max(1.0f, Attributes.StarRating / 0.0049f) - 4.0f, 2.0f) / 100000.0f;
+
+            // Longer maps are worth more. "Longer" means how many hits there are which can contribute to combo
+            int numTotalHits = totalComboHits();
+
+            // Longer maps are worth more
+            float lengthBonus =
+                0.95f + 0.4f * Math.Min(1.0f, numTotalHits / 3000.0f) +
+                (numTotalHits > 3000 ? (float)Math.Log10(numTotalHits / 3000.0f) * 0.5f : 0.0f);
+
+            // Longer maps are worth more
+            value *= lengthBonus;
+
+            // Penalize misses exponentially. This mainly fixes tag4 maps and the likes until a per-hitobject solution is available
+            value *= Math.Pow(0.97f, misses);
+
+            // Combo scaling
+            float beatmapMaxCombo = Attributes.MaxCombo;
+            if (beatmapMaxCombo > 0)
+                value *= Math.Min(Math.Pow(Attributes.MaxCombo, 0.8f) / Math.Pow(beatmapMaxCombo, 0.8f), 1.0f);
+
+            float approachRate = (float)Attributes.ApproachRate;
+            float approachRateFactor = 1.0f;
+            if (approachRate > 9.0f)
+                approachRateFactor += 0.1f * (approachRate - 9.0f); // 10% for each AR above 9
+            else if (approachRate < 8.0f)
+                approachRateFactor += 0.025f * (8.0f - approachRate); // 2.5% for each AR below 8
+
+            value *= approachRateFactor;
+
+            if (mods.Any(m => m is ModHidden))
+                // Hiddens gives nothing on max approach rate, and more the lower it is
+                value *= 1.05f + 0.075f * (10.0f - Math.Min(10.0f, approachRate)); // 7.5% for each AR below 10
+
+            if (mods.Any(m => m is ModFlashlight))
+                // Apply length bonus again if flashlight is on simply because it becomes a lot harder on longer maps.
+                value *= 1.35f * lengthBonus;
+
+            // Scale the aim value with accuracy _slightly_
+            value *= Math.Pow(accuracy(), 5.5f);
+
+            // Custom multipliers for NoFail. SpunOut is not applicable.
+            if (mods.Any(m => m is ModNoFail))
+                value *= 0.90f;
+
+            return value;
+        }
+
+        private float accuracy() => totalHits() == 0 ? 0 : MathHelper.Clamp((float)totalSuccessfulHits() / totalHits(), 0f, 1f);
+        private int totalHits() => tinyTicksHit + ticksHit + fruitsHit + misses + tinyTicksMissed;
+        private int totalSuccessfulHits() => tinyTicksHit + ticksHit + fruitsHit;
+        private int totalComboHits() => misses + ticksHit + fruitsHit;
+    }
+}

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

@@ -16,6 +16,7 @@ namespace osu.Game.Rulesets.Catch.Judgements
             {
                 default:
                     return 0;
+
                 case HitResult.Perfect:
                     return 1100;
             }
@@ -27,8 +28,9 @@ namespace osu.Game.Rulesets.Catch.Judgements
             {
                 default:
                     return 0;
+
                 case HitResult.Perfect:
-                    return 8;
+                    return 0.008;
             }
         }
 

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

@@ -13,6 +13,7 @@ namespace osu.Game.Rulesets.Catch.Judgements
             {
                 default:
                     return 0;
+
                 case HitResult.Perfect:
                     return 30;
             }
@@ -23,9 +24,10 @@ namespace osu.Game.Rulesets.Catch.Judgements
             switch (result)
             {
                 default:
-                    return 0;
+                    return base.HealthIncreaseFor(result);
+
                 case HitResult.Perfect:
-                    return 7;
+                    return 0.007;
             }
         }
     }

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

@@ -17,6 +17,7 @@ namespace osu.Game.Rulesets.Catch.Judgements
             {
                 default:
                     return 0;
+
                 case HitResult.Perfect:
                     return 300;
             }
@@ -27,9 +28,10 @@ namespace osu.Game.Rulesets.Catch.Judgements
             switch (result)
             {
                 default:
-                    return 0;
+                    return -0.02;
+
                 case HitResult.Perfect:
-                    return 10.2;
+                    return 0.01;
             }
         }
 

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

@@ -15,6 +15,7 @@ namespace osu.Game.Rulesets.Catch.Judgements
             {
                 default:
                     return 0;
+
                 case HitResult.Perfect:
                     return 10;
             }
@@ -26,8 +27,9 @@ namespace osu.Game.Rulesets.Catch.Judgements
             {
                 default:
                     return 0;
+
                 case HitResult.Perfect:
-                    return 4;
+                    return 0.004;
             }
         }
     }

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

@@ -12,7 +12,7 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
     public class CatchModAutoplay : ModAutoplay<CatchHitObject>
     {
-        protected override Score CreateReplayScore(Beatmap<CatchHitObject> beatmap) => new Score
+        public override Score CreateReplayScore(IBeatmap beatmap) => new Score
         {
             ScoreInfo = new ScoreInfo { User = new User { Username = "osu!salad!" } },
             Replay = new CatchAutoGenerator(beatmap).Generate(),

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

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

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

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

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

@@ -13,17 +13,17 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
     {
         private readonly Container bananaContainer;
 
-        public DrawableBananaShower(BananaShower s, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> getVisualRepresentation = null)
+        public DrawableBananaShower(BananaShower s, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> createDrawableRepresentation = null)
             : base(s)
         {
             RelativeSizeAxes = Axes.X;
             Origin = Anchor.BottomLeft;
             X = 0;
 
-            InternalChild = bananaContainer = new Container { RelativeSizeAxes = Axes.Both };
+            AddInternal(bananaContainer = new Container { RelativeSizeAxes = Axes.Both });
 
             foreach (var b in s.NestedHitObjects.Cast<Banana>())
-                AddNested(getVisualRepresentation?.Invoke(b));
+                AddNested(createDrawableRepresentation?.Invoke(b));
         }
 
         protected override void AddNested(DrawableHitObject h)

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

@@ -84,6 +84,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                     case ArmedState.Miss:
                         this.FadeOut(250).RotateTo(Rotation * 2, 250, Easing.Out).Expire();
                         break;
+
                     case ArmedState.Hit:
                         this.FadeOut().Expire();
                         break;

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

@@ -26,10 +26,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
         [BackgroundDependencyLoader]
         private void load()
         {
-            InternalChild = pulp = new Pulp
-            {
-                Size = Size
-            };
+            AddInternal(pulp = new Pulp { Size = Size });
         }
 
         public override Color4 AccentColour

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

@@ -6,6 +6,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Catch.Objects.Drawable.Pieces;
@@ -42,7 +43,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
             // todo: this should come from the skin.
             AccentColour = colourForRepresentation(HitObject.VisualRepresentation);
 
-            InternalChildren = new[]
+            AddRangeInternal(new[]
             {
                 createPulp(HitObject.VisualRepresentation),
                 border = new Circle
@@ -70,7 +71,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                         }
                     }
                 },
-            };
+            });
 
             if (HitObject.HyperDash)
             {
@@ -105,6 +106,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
             {
                 default:
                     return new Container();
+
                 case FruitVisualRepresentation.Raspberry:
                     return new Container
                     {
@@ -143,6 +145,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                             },
                         }
                     };
+
                 case FruitVisualRepresentation.Pineapple:
                     return new Container
                     {
@@ -181,6 +184,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                             },
                         }
                     };
+
                 case FruitVisualRepresentation.Pear:
                     return new Container
                     {
@@ -213,6 +217,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                             },
                         }
                     };
+
                 case FruitVisualRepresentation.Grape:
                     return new Container
                     {
@@ -245,6 +250,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                             },
                         }
                     };
+
                 case FruitVisualRepresentation.Banana:
                     return new Container
                     {
@@ -282,19 +288,25 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                 default:
                 case FruitVisualRepresentation.Pear:
                     return new Color4(17, 136, 170, 255);
+
                 case FruitVisualRepresentation.Grape:
                     return new Color4(204, 102, 0, 255);
+
                 case FruitVisualRepresentation.Raspberry:
                     return new Color4(121, 9, 13, 255);
+
                 case FruitVisualRepresentation.Pineapple:
                     return new Color4(102, 136, 0, 255);
+
                 case FruitVisualRepresentation.Banana:
                     switch (RNG.Next(0, 3))
                     {
                         default:
                             return new Color4(255, 240, 0, 255);
+
                         case 1:
                             return new Color4(255, 192, 0, 255);
+
                         case 2:
                             return new Color4(214, 221, 28, 255);
                     }

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

@@ -13,17 +13,17 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
     {
         private readonly Container dropletContainer;
 
-        public DrawableJuiceStream(JuiceStream s, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> getVisualRepresentation = null)
+        public DrawableJuiceStream(JuiceStream s, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> createDrawableRepresentation = null)
             : base(s)
         {
             RelativeSizeAxes = Axes.Both;
             Origin = Anchor.BottomLeft;
             X = 0;
 
-            InternalChild = dropletContainer = new Container { RelativeSizeAxes = Axes.Both, };
+            AddInternal(dropletContainer = new Container { RelativeSizeAxes = Axes.Both, });
 
             foreach (var o in s.NestedHitObjects.Cast<CatchHitObject>())
-                AddNested(getVisualRepresentation?.Invoke(o));
+                AddNested(createDrawableRepresentation?.Invoke(o));
         }
 
         protected override void AddNested(DrawableHitObject h)

osu.Game.Rulesets.Catch/Objects/Drawable/Pieces/Pulp.cs

@@ -3,7 +3,7 @@
 
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osuTK.Graphics;

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

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

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

@@ -6,17 +6,20 @@ using System.Linq;
 using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
 using osu.Game.Replays;
+using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Replays;
 
 namespace osu.Game.Rulesets.Catch.Replays
 {
-    internal class CatchAutoGenerator : AutoGenerator<CatchHitObject>
+    internal class CatchAutoGenerator : AutoGenerator
     {
         public const double RELEASE_DELAY = 20;
 
-        public CatchAutoGenerator(Beatmap<CatchHitObject> beatmap)
+        public new CatchBeatmap Beatmap => (CatchBeatmap)base.Beatmap;
+
+        public CatchAutoGenerator(IBeatmap beatmap)
             : base(beatmap)
         {
             Replay = new Replay();

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Diagnostics;
 using osu.Framework.Input.StateChanges;
 using osu.Framework.MathUtils;
 using osu.Game.Replays;
@@ -22,10 +23,14 @@ namespace osu.Game.Rulesets.Catch.Replays
         {
             get
             {
-                if (!HasFrames)
+                var frame = CurrentFrame;
+
+                if (frame == null)
                     return null;
 
-                return Interpolation.ValueAt(CurrentTime, CurrentFrame.Position, NextFrame.Position, CurrentFrame.Time, NextFrame.Time);
+                Debug.Assert(CurrentTime != null);
+
+                return NextFrame != null ? Interpolation.ValueAt(CurrentTime.Value, frame.Position, NextFrame.Position, frame.Time, NextFrame.Time) : frame.Position;
             }
         }
 

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

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Judgements;
@@ -13,8 +12,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)
         {
         }
 
@@ -27,20 +26,16 @@ namespace osu.Game.Rulesets.Catch.Scoring
             hpDrainRate = beatmap.BeatmapInfo.BaseDifficulty.DrainRate;
         }
 
-        private const double harshness = 0.01;
-
-        protected override void ApplyResult(JudgementResult result)
+        protected override double HealthAdjustmentFactorFor(JudgementResult result)
         {
-            base.ApplyResult(result);
-
-            if (result.Type == HitResult.Miss)
+            switch (result.Type)
             {
-                if (!result.Judgement.IsBonus)
-                    Health.Value -= hpDrainRate * (harshness * 2);
-                return;
-            }
+                case HitResult.Miss:
+                    return hpDrainRate;
 
-            Health.Value += Math.Max(result.Judgement.HealthIncreaseFor(result) - hpDrainRate, 0) * harshness;
+                default:
+                    return 10.2 - hpDrainRate; // Award less HP as drain rate is increased
+            }
         }
 
         public override HitWindows CreateHitWindows() => new CatchHitWindows();

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

@@ -10,7 +10,6 @@ using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
-using osuTK;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
@@ -20,33 +19,24 @@ namespace osu.Game.Rulesets.Catch.UI
 
         internal readonly CatcherArea CatcherArea;
 
-        public CatchPlayfield(BeatmapDifficulty difficulty, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> getVisualRepresentation)
+        public CatchPlayfield(BeatmapDifficulty difficulty, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> createDrawableRepresentation)
         {
             Container explodingFruitContainer;
 
-            Anchor = Anchor.TopCentre;
-            Origin = Anchor.TopCentre;
-
-            Size = new Vector2(0.86f); // matches stable's vertical offset for catcher plate
-
-            InternalChild = new PlayfieldAdjustmentContainer
+            InternalChildren = new Drawable[]
             {
-                RelativeSizeAxes = Axes.Both,
-                Children = new Drawable[]
+                explodingFruitContainer = new Container
                 {
-                    explodingFruitContainer = new Container
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                    },
-                    CatcherArea = new CatcherArea(difficulty)
-                    {
-                        GetVisualRepresentation = getVisualRepresentation,
-                        ExplodingFruitTarget = explodingFruitContainer,
-                        Anchor = Anchor.BottomLeft,
-                        Origin = Anchor.TopLeft,
-                    },
-                    HitObjectContainer
-                }
+                    RelativeSizeAxes = Axes.Both,
+                },
+                CatcherArea = new CatcherArea(difficulty)
+                {
+                    CreateDrawableRepresentation = createDrawableRepresentation,
+                    ExplodingFruitTarget = explodingFruitContainer,
+                    Anchor = Anchor.BottomLeft,
+                    Origin = Anchor.TopLeft,
+                },
+                HitObjectContainer
             };
         }
 

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

@@ -3,17 +3,23 @@
 
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.UI;
 using osuTK;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
-    public class PlayfieldAdjustmentContainer : Container
+    public class CatchPlayfieldAdjustmentContainer : PlayfieldAdjustmentContainer
     {
         protected override Container<Drawable> Content => content;
         private readonly Container content;
 
-        public PlayfieldAdjustmentContainer()
+        public CatchPlayfieldAdjustmentContainer()
         {
+            Anchor = Anchor.TopCentre;
+            Origin = Anchor.TopCentre;
+
+            Size = new Vector2(0.86f); // matches stable's vertical offset for catcher plate
+
             InternalChild = new Container
             {
                 Anchor = Anchor.Centre,

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

@@ -29,7 +29,7 @@ namespace osu.Game.Rulesets.Catch.UI
 
         protected internal readonly Catcher MovableCatcher;
 
-        public Func<CatchHitObject, DrawableHitObject<CatchHitObject>> GetVisualRepresentation;
+        public Func<CatchHitObject, DrawableHitObject<CatchHitObject>> CreateDrawableRepresentation;
 
         public Container ExplodingFruitTarget
         {
@@ -60,12 +60,12 @@ namespace osu.Game.Rulesets.Catch.UI
                 if (lastPlateableFruit.IsLoaded)
                     action();
                 else
-                    lastPlateableFruit.OnLoadComplete = _ => action();
+                    lastPlateableFruit.OnLoadComplete += _ => action();
             }
 
             if (result.IsHit && fruit.CanBePlated)
             {
-                var caughtFruit = (DrawableCatchHitObject)GetVisualRepresentation?.Invoke(fruit.HitObject);
+                var caughtFruit = (DrawableCatchHitObject)CreateDrawableRepresentation?.Invoke(fruit.HitObject);
 
                 if (caughtFruit == null) return;
 
@@ -292,6 +292,7 @@ namespace osu.Game.Rulesets.Catch.UI
                 const float hyper_dash_transition_length = 180;
 
                 bool previouslyHyperDashing = HyperDashing;
+
                 if (modifier <= 1 || X == targetPosition)
                 {
                     hyperDashModifier = 1;
@@ -325,9 +326,11 @@ namespace osu.Game.Rulesets.Catch.UI
                     case CatchAction.MoveLeft:
                         currentDirection--;
                         return true;
+
                     case CatchAction.MoveRight:
                         currentDirection++;
                         return true;
+
                     case CatchAction.Dash:
                         Dashing = true;
                         return true;
@@ -343,9 +346,11 @@ namespace osu.Game.Rulesets.Catch.UI
                     case CatchAction.MoveLeft:
                         currentDirection++;
                         return true;
+
                     case CatchAction.MoveRight:
                         currentDirection--;
                         return true;
+
                     case CatchAction.Dash:
                         Dashing = false;
                         return true;

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

@@ -1,6 +1,7 @@
 // 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.Framework.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
@@ -10,6 +11,7 @@ using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Catch.Scoring;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
@@ -17,14 +19,14 @@ 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)
-            : base(ruleset, beatmap)
+        public DrawableCatchRuleset(Ruleset ruleset, WorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
+            : base(ruleset, beatmap, mods)
         {
             Direction.Value = ScrollingDirection.Down;
             TimeRange.Value = BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450);
@@ -34,24 +36,31 @@ namespace osu.Game.Rulesets.Catch.UI
 
         protected override ReplayInputHandler CreateReplayInputHandler(Replay replay) => new CatchFramedReplayInputHandler(replay);
 
-        protected override Playfield CreatePlayfield() => new CatchPlayfield(Beatmap.BeatmapInfo.BaseDifficulty, GetVisualRepresentation);
+        protected override Playfield CreatePlayfield() => new CatchPlayfield(Beatmap.BeatmapInfo.BaseDifficulty, CreateDrawableRepresentation);
 
-        public override PassThroughInputManager CreateInputManager() => new CatchInputManager(Ruleset.RulesetInfo);
+        public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new CatchPlayfieldAdjustmentContainer();
 
-        public override DrawableHitObject<CatchHitObject> GetVisualRepresentation(CatchHitObject h)
+        protected override PassThroughInputManager CreateInputManager() => new CatchInputManager(Ruleset.RulesetInfo);
+
+        public override DrawableHitObject<CatchHitObject> CreateDrawableRepresentation(CatchHitObject h)
         {
             switch (h)
             {
                 case Banana banana:
                     return new DrawableBanana(banana);
+
                 case Fruit fruit:
                     return new DrawableFruit(fruit);
+
                 case JuiceStream stream:
-                    return new DrawableJuiceStream(stream, GetVisualRepresentation);
+                    return new DrawableJuiceStream(stream, CreateDrawableRepresentation);
+
                 case BananaShower shower:
-                    return new DrawableBananaShower(shower, GetVisualRepresentation);
+                    return new DrawableBananaShower(shower, CreateDrawableRepresentation);
+
                 case TinyDroplet tiny:
                     return new DrawableTinyDroplet(tiny);
+
                 case Droplet droplet:
                     return new DrawableDroplet(droplet);
             }

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

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -8,6 +10,7 @@ using osu.Framework.Timing;
 using osu.Game.Rulesets.Mania.Edit;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
@@ -21,6 +24,9 @@ namespace osu.Game.Rulesets.Mania.Tests
     {
         private readonly Column column;
 
+        [Cached(typeof(IReadOnlyList<Mod>))]
+        private IReadOnlyList<Mod> mods { get; set; } = Array.Empty<Mod>();
+
         protected ManiaPlacementBlueprintTestCase()
         {
             Add(column = new Column(0)

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

@@ -13,6 +13,7 @@ using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mania.UI.Components;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
 using osuTK;
@@ -31,6 +32,9 @@ namespace osu.Game.Rulesets.Mania.Tests
             typeof(ColumnHitObjectArea)
         };
 
+        [Cached(typeof(IReadOnlyList<Mod>))]
+        private IReadOnlyList<Mod> mods { get; set; } = Array.Empty<Mod>();
+
         private readonly List<Column> columns = new List<Column>();
 
         public TestCaseColumn()

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

@@ -168,11 +168,13 @@ namespace osu.Game.Rulesets.Mania.Tests
                     foreach (var nested in obj.NestedHitObjects)
                     {
                         double finalPosition = (nested.HitObject.StartTime - obj.HitObject.StartTime) / endTime.Duration;
+
                         switch (direction)
                         {
                             case ScrollingDirection.Up:
                                 nested.Y = (float)(finalPosition * content.DrawHeight);
                                 break;
+
                             case ScrollingDirection.Down:
                                 nested.Y = (float)(-finalPosition * content.DrawHeight);
                                 break;

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

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
@@ -13,6 +14,7 @@ using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
 using osuTK;
@@ -24,6 +26,9 @@ namespace osu.Game.Rulesets.Mania.Tests
     {
         private const int columns = 4;
 
+        [Cached(typeof(IReadOnlyList<Mod>))]
+        private IReadOnlyList<Mod> mods { get; set; } = Array.Empty<Mod>();
+
         private readonly List<ManiaStage> stages = new List<ManiaStage>();
 
         private FillFlowContainer<ScrollingTestContainer> fill;

osu.Game.Rulesets.Mania.Tests/osu.Game.Rulesets.Mania.Tests.csproj

@@ -2,9 +2,9 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.0.1" />
     <PackageReference Include="NUnit" Version="3.11.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.12.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.13.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

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

@@ -3,8 +3,8 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Beatmaps;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.UI;
 
@@ -42,13 +42,13 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
                 {
                     Name = @"Note Count",
                     Content = notes.ToString(),
-                    Icon = FontAwesome.fa_circle_o
+                    Icon = FontAwesome.Regular.Circle
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Hold Note Count",
                     Content = holdnotes.ToString(),
-                    Icon = FontAwesome.fa_circle
+                    Icon = FontAwesome.Regular.Circle
                 },
             };
         }

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

@@ -48,6 +48,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             if (IsForCurrentRuleset)
             {
                 TargetColumns = (int)Math.Max(1, roundedCircleSize);
+
                 if (TargetColumns >= 10)
                 {
                     TargetColumns = TargetColumns / 2;

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

@@ -179,6 +179,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             int usableColumns = TotalColumns - RandomStart - PreviousPattern.ColumnWithObjects;
             int nextColumn = GetRandomColumn();
+
             for (int i = 0; i < Math.Min(usableColumns, noteCount); i++)
             {
                 // Find available column
@@ -217,6 +218,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 nextColumn = FindAvailableColumn(nextColumn, PreviousPattern);
 
             int lastColumn = nextColumn;
+
             for (int i = 0; i < noteCount; i++)
             {
                 addToPattern(pattern, nextColumn, startTime, startTime);
@@ -299,6 +301,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             int interval = Random.Next(1, TotalColumns - (legacy ? 1 : 0));
 
             int nextColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
+
             for (int i = 0; i <= spanCount; i++)
             {
                 addToPattern(pattern, nextColumn, startTime, startTime);
@@ -341,16 +344,19 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                     p3 = 0;
                     p4 = 0;
                     break;
+
                 case 3:
                     p2 = Math.Min(p2, 0.1);
                     p3 = 0;
                     p4 = 0;
                     break;
+
                 case 4:
                     p2 = Math.Min(p2, 0.3);
                     p3 = Math.Min(p3, 0.04);
                     p4 = 0;
                     break;
+
                 case 5:
                     p2 = Math.Min(p2, 0.34);
                     p3 = Math.Min(p3, 0.1);
@@ -440,6 +446,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             bool ignoreHead = !sampleInfoListAt(startTime).Any(s => s.Name == SampleInfo.HIT_WHISTLE || s.Name == SampleInfo.HIT_FINISH || s.Name == SampleInfo.HIT_CLAP);
 
             var rowPattern = new Pattern();
+
             for (int i = 0; i <= spanCount; i++)
             {
                 if (!(ignoreHead && startTime == HitObject.StartTime))

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

@@ -38,9 +38,11 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 case 8 when HitObject.Samples.Any(s => s.Name == SampleInfo.HIT_FINISH) && endTime - HitObject.StartTime < 1000:
                     addToPattern(pattern, 0, generateHold);
                     break;
+
                 case 8:
                     addToPattern(pattern, FindAvailableColumn(GetRandomColumn(), PreviousPattern), generateHold);
                     break;
+
                 default:
                     if (TotalColumns > 0)
                         addToPattern(pattern, GetRandomColumn(), generateHold);

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

@@ -233,6 +233,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 noteCount = Math.Min(noteCount, TotalColumns - RandomStart - PreviousPattern.ColumnWithObjects);
 
             int nextColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
+
             for (int i = 0; i < noteCount; i++)
             {
                 nextColumn = allowStacking
@@ -303,6 +304,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             int columnLimit = (TotalColumns % 2 == 0 ? TotalColumns : TotalColumns - 1) / 2;
             int nextColumn = GetRandomColumn(upperBound: columnLimit);
+
             for (int i = 0; i < noteCount; i++)
             {
                 nextColumn = FindAvailableColumn(nextColumn, upperBound: columnLimit, patterns: pattern);
@@ -340,18 +342,21 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                     p4 = 0;
                     p5 = 0;
                     break;
+
                 case 3:
                     p2 = Math.Min(p2, 0.1);
                     p3 = 0;
                     p4 = 0;
                     p5 = 0;
                     break;
+
                 case 4:
                     p2 = Math.Min(p2, 0.23);
                     p3 = Math.Min(p3, 0.04);
                     p4 = 0;
                     p5 = 0;
                     break;
+
                 case 5:
                     p3 = Math.Min(p3, 0.15);
                     p4 = Math.Min(p4, 0.03);
@@ -384,20 +389,24 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                     p2 = 0;
                     p3 = 0;
                     break;
+
                 case 3:
                     centreProbability = Math.Min(centreProbability, 0.03);
                     p2 = 0;
                     p3 = 0;
                     break;
+
                 case 4:
                     centreProbability = 0;
                     p2 = Math.Min(p2 * 2, 0.2);
                     p3 = 0;
                     break;
+
                 case 5:
                     centreProbability = Math.Min(centreProbability, 0.03);
                     p3 = 0;
                     break;
+
                 case 6:
                     centreProbability = 0;
                     p2 = Math.Min(p2 * 2, 0.5);

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

@@ -158,6 +158,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             // Ensure that we have at least one free column, so that an endless loop is avoided
             bool hasValidColumns = false;
+
             for (int i = lowerBound.Value; i < upperBound.Value; i++)
             {
                 hasValidColumns = isValid(i);

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

@@ -1,21 +1,23 @@
 // 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.Framework.Graphics;
 using osuTK;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
 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)
-            : base(ruleset, beatmap)
+        public DrawableManiaEditRuleset(Ruleset ruleset, WorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
+            : base(ruleset, beatmap, mods)
         {
         }
 

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

@@ -11,6 +11,7 @@ using System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Game.Rulesets.Mania.Edit.Blueprints;
 using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
@@ -20,7 +21,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 +33,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, IReadOnlyList<Mod> mods)
         {
-            RulesetContainer = new ManiaEditRulesetContainer(ruleset, beatmap);
+            DrawableRuleset = new DrawableManiaEditRuleset(ruleset, beatmap, mods);
 
             // 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[]
@@ -65,6 +66,7 @@ namespace osu.Game.Rulesets.Mania.Edit
             {
                 case DrawableNote note:
                     return new NoteSelectionBlueprint(note);
+
                 case DrawableHoldNote holdNote:
                     return new HoldNoteSelectionBlueprint(holdNote);
             }

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

@@ -10,5 +10,17 @@ namespace osu.Game.Rulesets.Mania.Judgements
         public override bool AffectsCombo => false;
 
         protected override int NumericResultFor(HitResult result) => 20;
+
+        protected override double HealthIncreaseFor(HitResult result)
+        {
+            switch (result)
+            {
+                case HitResult.Miss:
+                    return 0;
+
+                default:
+                    return 0.040;
+            }
+        }
     }
 }

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

@@ -14,16 +14,47 @@ namespace osu.Game.Rulesets.Mania.Judgements
             {
                 default:
                     return 0;
+
                 case HitResult.Meh:
                     return 50;
+
                 case HitResult.Ok:
                     return 100;
+
                 case HitResult.Good:
                     return 200;
+
                 case HitResult.Great:
                 case HitResult.Perfect:
                     return 300;
             }
         }
+
+        protected override double HealthIncreaseFor(HitResult result)
+        {
+            switch (result)
+            {
+                case HitResult.Miss:
+                    return -0.125;
+
+                case HitResult.Meh:
+                    return 0.005;
+
+                case HitResult.Ok:
+                    return 0.010;
+
+                case HitResult.Good:
+                    return 0.035;
+
+                case HitResult.Great:
+                    return 0.055;
+
+                case HitResult.Perfect:
+                    return 0.065;
+
+                default:
+                    return 0;
+            }
+        }
     }
 }

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -10,8 +10,10 @@ using osu.Game.Rulesets.UI;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
 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 +32,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, IReadOnlyList<Mod> mods) => new DrawableManiaRuleset(this, beatmap, mods);
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new ManiaBeatmapConverter(beatmap);
         public override PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, ScoreInfo score) => new ManiaPerformanceCalculator(this, beatmap, score);
 
@@ -115,6 +117,7 @@ namespace osu.Game.Rulesets.Mania
                         new ManiaModNoFail(),
                         new MultiMod(new ManiaModHalfTime(), new ManiaModDaycore()),
                     };
+
                 case ModType.DifficultyIncrease:
                     return new Mod[]
                     {
@@ -124,6 +127,7 @@ namespace osu.Game.Rulesets.Mania
                         new MultiMod(new ManiaModFadeIn(), new ManiaModHidden()),
                         new ManiaModFlashlight(),
                     };
+
                 case ModType.Conversion:
                     return new Mod[]
                     {
@@ -140,11 +144,19 @@ namespace osu.Game.Rulesets.Mania
                         new ManiaModDualStages(),
                         new ManiaModMirror(),
                     };
+
                 case ModType.Automation:
                     return new Mod[]
                     {
                         new MultiMod(new ManiaModAutoplay(), new ModCinema()),
                     };
+
+                case ModType.Fun:
+                    return new Mod[]
+                    {
+                        new MultiMod(new ModWindUp<ManiaHitObject>(), new ModWindDown<ManiaHitObject>())
+                    };
+
                 default:
                     return new Mod[] { };
             }
@@ -154,7 +166,7 @@ namespace osu.Game.Rulesets.Mania
 
         public override string ShortName => "mania";
 
-        public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_mania_o };
+        public override Drawable CreateIcon() => new SpriteIcon { Icon = OsuIcon.RulesetMania };
 
         public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new ManiaDifficultyCalculator(this, beatmap);
 
@@ -207,6 +219,7 @@ namespace osu.Game.Rulesets.Mania
                         SpecialAction = ManiaAction.Special1,
                         NormalActionStart = ManiaAction.Key1,
                     }.GenerateKeyBindingsFor(variant, out _);
+
                 case PlayfieldType.Dual:
                     int keys = getDualStageKeyCount(variant);
 
@@ -264,6 +277,7 @@ namespace osu.Game.Rulesets.Mania
             {
                 default:
                     return $"{variant}K";
+
                 case PlayfieldType.Dual:
                 {
                     var keys = getDualStageKeyCount(variant);

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

@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModAutoplay : ModAutoplay<ManiaHitObject>
     {
-        protected override Score CreateReplayScore(Beatmap<ManiaHitObject> beatmap) => new Score
+        public override Score CreateReplayScore(IBeatmap beatmap) => new Score
         {
             ScoreInfo = new ScoreInfo { User = new User { Username = "osu!topus!" } },
             Replay = new ManiaAutoGenerator((ManiaBeatmap)beatmap).Generate(),

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;
@@ -12,7 +13,7 @@ namespace osu.Game.Rulesets.Mania.Mods
     {
         public override string Name => "Fade In";
         public override string Acronym => "FI";
-        public override FontAwesome Icon => FontAwesome.fa_osu_mod_hidden;
+        public override IconUsage Icon => OsuIcon.ModHidden;
         public override ModType Type => ModType.DifficultyIncrease;
         public override string Description => @"Keys appear out of nowhere!";
         public override double ScoreMultiplier => 1;

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

@@ -3,6 +3,7 @@
 
 using System.Linq;
 using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
@@ -17,7 +18,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override string Name => "Random";
         public override string Acronym => "RD";
         public override ModType Type => ModType.Conversion;
-        public override FontAwesome Icon => FontAwesome.fa_osu_dice;
+        public override IconUsage Icon => OsuIcon.Dice;
         public override string Description => @"Shuffle around the keys!";
         public override double ScoreMultiplier => 1;
 

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

@@ -43,7 +43,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
             RelativeSizeAxes = Axes.X;
 
-            InternalChildren = new Drawable[]
+            AddRangeInternal(new Drawable[]
             {
                 bodyPiece = new BodyPiece
                 {
@@ -67,7 +67,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                     Anchor = Anchor.TopCentre,
                     Origin = Anchor.TopCentre
                 }
-            };
+            });
 
             foreach (var tick in tickContainer)
                 AddNested(tick);

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

@@ -7,6 +7,7 @@ using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Rulesets.Scoring;
 
@@ -33,7 +34,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             RelativeSizeAxes = Axes.X;
             Size = new Vector2(1);
 
-            InternalChildren = new[]
+            AddRangeInternal(new[]
             {
                 glowContainer = new CircularContainer
                 {
@@ -51,7 +52,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                         }
                     }
                 }
-            };
+            });
         }
 
         public override Color4 AccentColour

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

@@ -65,6 +65,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 case ArmedState.Miss:
                     this.FadeOut(150, Easing.In).Expire();
                     break;
+
                 case ArmedState.Hit:
                     this.FadeOut(150, Easing.OutQuint).Expire();
                     break;

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

@@ -5,7 +5,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osuTK.Graphics;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.Scoring;
@@ -29,7 +29,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             CornerRadius = 5;
             Masking = true;
 
-            InternalChild = headPiece = new NotePiece();
+            AddInternal(headPiece = new NotePiece());
         }
 
         protected override void OnDirectionChanged(ValueChangedEvent<ScrollingDirection> e)

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/BodyPiece.cs

@@ -7,6 +7,7 @@ using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 
@@ -144,6 +145,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
             const float animation_length = 50;
 
             Foreground.ClearTransforms(false, nameof(Foreground.Colour));
+
             if (hitting)
             {
                 // wait for the next sync point

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/GlowPiece.cs

@@ -4,6 +4,7 @@
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osuTK.Graphics;

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

@@ -5,13 +5,12 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Mania.Beatmaps;
-using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Replays;
 
 namespace osu.Game.Rulesets.Mania.Replays
 {
-    internal class ManiaAutoGenerator : AutoGenerator<ManiaHitObject>
+    internal class ManiaAutoGenerator : AutoGenerator
     {
         public const double RELEASE_DELAY = 20;
 
@@ -29,6 +28,7 @@ namespace osu.Game.Rulesets.Mania.Replays
             var normalAction = ManiaAction.Key1;
             var specialAction = ManiaAction.Special1;
             int totalCounter = 0;
+
             foreach (var stage in Beatmap.Stages)
             {
                 for (int i = 0; i < stage.Columns; i++)
@@ -52,6 +52,7 @@ namespace osu.Game.Rulesets.Mania.Replays
             var pointGroups = generateActionPoints().GroupBy(a => a.Time).OrderBy(g => g.First().Time);
 
             var actions = new List<ManiaAction>();
+
             foreach (var group in pointGroups)
             {
                 foreach (var point in group)
@@ -61,6 +62,7 @@ namespace osu.Game.Rulesets.Mania.Replays
                         case HitPoint _:
                             actions.Add(columnActions[point.Column]);
                             break;
+
                         case ReleasePoint _:
                             actions.Remove(columnActions[point.Column]);
                             break;

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

@@ -18,6 +18,6 @@ namespace osu.Game.Rulesets.Mania.Replays
 
         protected override bool IsImportant(ManiaReplayFrame frame) => frame.Actions.Any();
 
-        public override List<IInput> GetPendingInputs() => new List<IInput> { new ReplayState<ManiaAction> { PressedActions = CurrentFrame.Actions } };
+        public override List<IInput> GetPendingInputs() => new List<IInput> { new ReplayState<ManiaAction> { PressedActions = CurrentFrame?.Actions ?? new List<ManiaAction>() } };
     }
 }

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

@@ -39,6 +39,7 @@ namespace osu.Game.Rulesets.Mania.Replays
 
             int activeColumns = (int)(legacyFrame.MouseX ?? 0);
             int counter = 0;
+
             while (activeColumns > 0)
             {
                 var isSpecial = stage.IsSpecialColumn(counter);

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

@@ -3,7 +3,6 @@
 
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
@@ -28,36 +27,6 @@ namespace osu.Game.Rulesets.Mania.Scoring
         /// </summary>
         private const double hp_multiplier_max = 1;
 
-        /// <summary>
-        /// The default BAD hit HP increase.
-        /// </summary>
-        private const double hp_increase_bad = 0.005;
-
-        /// <summary>
-        /// The default OK hit HP increase.
-        /// </summary>
-        private const double hp_increase_ok = 0.010;
-
-        /// <summary>
-        /// The default GOOD hit HP increase.
-        /// </summary>
-        private const double hp_increase_good = 0.035;
-
-        /// <summary>
-        /// The default tick hit HP increase.
-        /// </summary>
-        private const double hp_increase_tick = 0.040;
-
-        /// <summary>
-        /// The default GREAT hit HP increase.
-        /// </summary>
-        private const double hp_increase_great = 0.055;
-
-        /// <summary>
-        /// The default PERFECT hit HP increase.
-        /// </summary>
-        private const double hp_increase_perfect = 0.065;
-
         /// <summary>
         /// The MISS HP multiplier at OD = 0.
         /// </summary>
@@ -73,11 +42,6 @@ namespace osu.Game.Rulesets.Mania.Scoring
         /// </summary>
         private const double hp_multiplier_miss_max = 1;
 
-        /// <summary>
-        /// The default MISS HP increase.
-        /// </summary>
-        private const double hp_increase_miss = -0.125;
-
         /// <summary>
         /// The MISS HP multiplier. This is multiplied to the miss hp increase.
         /// </summary>
@@ -88,12 +52,8 @@ namespace osu.Game.Rulesets.Mania.Scoring
         /// </summary>
         private double hpMultiplier = 1;
 
-        public ManiaScoreProcessor()
-        {
-        }
-
-        public ManiaScoreProcessor(RulesetContainer<ManiaHitObject> rulesetContainer)
-            : base(rulesetContainer)
+        public ManiaScoreProcessor(DrawableRuleset<ManiaHitObject> drawableRuleset)
+            : base(drawableRuleset)
         {
         }
 
@@ -122,42 +82,8 @@ namespace osu.Game.Rulesets.Mania.Scoring
             }
         }
 
-        protected override void ApplyResult(JudgementResult result)
-        {
-            base.ApplyResult(result);
-
-            bool isTick = result.Judgement is HoldNoteTickJudgement;
-
-            if (isTick)
-            {
-                if (result.IsHit)
-                    Health.Value += hpMultiplier * hp_increase_tick;
-            }
-            else
-            {
-                switch (result.Type)
-                {
-                    case HitResult.Miss:
-                        Health.Value += hpMissMultiplier * hp_increase_miss;
-                        break;
-                    case HitResult.Meh:
-                        Health.Value += hpMultiplier * hp_increase_bad;
-                        break;
-                    case HitResult.Ok:
-                        Health.Value += hpMultiplier * hp_increase_ok;
-                        break;
-                    case HitResult.Good:
-                        Health.Value += hpMultiplier * hp_increase_good;
-                        break;
-                    case HitResult.Great:
-                        Health.Value += hpMultiplier * hp_increase_great;
-                        break;
-                    case HitResult.Perfect:
-                        Health.Value += hpMultiplier * hp_increase_perfect;
-                        break;
-                }
-            }
-        }
+        protected override double HealthAdjustmentFactorFor(JudgementResult result)
+            => result.Type == HitResult.Miss ? hpMissMultiplier : hpMultiplier;
 
         public override HitWindows CreateHitWindows() => new ManiaHitWindows();
     }

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

@@ -6,6 +6,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.UI;

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

@@ -7,6 +7,7 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Bindings;
 using osu.Game.Graphics;

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

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

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

@@ -6,7 +6,6 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
-using osu.Framework.Graphics;
 using osu.Framework.Input;
 using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
@@ -19,6 +18,7 @@ using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.Replays;
 using osu.Game.Rulesets.Mania.Scoring;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
@@ -28,8 +28,10 @@ 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;
@@ -38,8 +40,8 @@ namespace osu.Game.Rulesets.Mania.UI
 
         private readonly Bindable<ManiaScrollingDirection> configDirection = new Bindable<ManiaScrollingDirection>();
 
-        public ManiaRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
-            : base(ruleset, beatmap)
+        public DrawableManiaRuleset(Ruleset ruleset, WorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
+            : base(ruleset, beatmap, mods)
         {
             // Generate the bar lines
             double lastObjectTime = (Objects.LastOrDefault() as IHasEndTime)?.EndTime ?? Objects.LastOrDefault()?.StartTime ?? double.MaxValue;
@@ -55,6 +57,7 @@ namespace osu.Game.Rulesets.Mania.UI
                 double endTime = i < timingPoints.Count - 1 ? timingPoints[i + 1].Time - point.BeatLength : lastObjectTime + point.BeatLength * (int)point.TimeSignature;
 
                 int index = 0;
+
                 for (double t = timingPoints[i].Time; Precision.DefinitelyBigger(endTime, t); t += point.BeatLength, index++)
                 {
                     barLines.Add(new BarLine
@@ -87,26 +90,26 @@ namespace osu.Game.Rulesets.Mania.UI
         /// <returns>The column which intersects with <paramref name="screenSpacePosition"/>.</returns>
         public Column GetColumnByPosition(Vector2 screenSpacePosition) => Playfield.GetColumnByPosition(screenSpacePosition);
 
-        protected override Playfield CreatePlayfield() => new ManiaPlayfield(Beatmap.Stages)
-        {
-            Anchor = Anchor.Centre,
-            Origin = Anchor.Centre,
-        };
+        public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new ManiaPlayfieldAdjustmentContainer();
+
+        protected override Playfield CreatePlayfield() => new ManiaPlayfield(Beatmap.Stages);
 
         public override ScoreProcessor CreateScoreProcessor() => new ManiaScoreProcessor(this);
 
         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)
+        public override DrawableHitObject<ManiaHitObject> CreateDrawableRepresentation(ManiaHitObject h)
         {
             switch (h)
             {
                 case HoldNote holdNote:
                     return new DrawableHoldNote(holdNote);
+
                 case Note note:
                     return new DrawableNote(note);
+
                 default:
                     return null;
             }

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

@@ -4,6 +4,7 @@
 using osuTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Mania.Objects.Drawables;

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

@@ -28,8 +28,6 @@ namespace osu.Game.Rulesets.Mania.UI
             if (stageDefinitions.Count <= 0)
                 throw new ArgumentException("Can't have zero or fewer stages.");
 
-            Size = new Vector2(1, 0.8f);
-
             GridContainer playfieldGrid;
             AddInternal(playfieldGrid = new GridContainer
             {
@@ -40,6 +38,7 @@ namespace osu.Game.Rulesets.Mania.UI
             var normalColumnAction = ManiaAction.Key1;
             var specialColumnAction = ManiaAction.Special1;
             int firstColumnIndex = 0;
+
             for (int i = 0; i < stageDefinitions.Count; i++)
             {
                 var newStage = new ManiaStage(firstColumnIndex, stageDefinitions[i], ref normalColumnAction, ref specialColumnAction);
@@ -94,6 +93,7 @@ namespace osu.Game.Rulesets.Mania.UI
         private ManiaStage getStageByColumn(int column)
         {
             int sum = 0;
+
             foreach (var stage in stages)
             {
                 sum = sum + stage.Columns.Count;

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

@@ -0,0 +1,20 @@
+// 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;
+using osu.Game.Rulesets.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.UI
+{
+    public class ManiaPlayfieldAdjustmentContainer : PlayfieldAdjustmentContainer
+    {
+        public ManiaPlayfieldAdjustmentContainer()
+        {
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            Size = new Vector2(1, 0.8f);
+        }
+    }
+}

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

@@ -35,6 +35,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                         yield return createConvertValue(nested);
 
                     break;
+
                 default:
                     yield return createConvertValue(hitObject);
 

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

@@ -1,11 +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;
 using System.IO;
 using System.Linq;
 using System.Text;
 using NUnit.Framework;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Tests.Beatmaps;
 using Decoder = osu.Game.Beatmaps.Formats.Decoder;
@@ -22,7 +24,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             using (var reader = new StreamReader(stream))
             {
                 var beatmap = Decoder.GetDecoder<Beatmap>(reader).Decode(reader);
-                var converted = new TestWorkingBeatmap(beatmap).GetPlayableBeatmap(new OsuRuleset().RulesetInfo);
+                var converted = new TestWorkingBeatmap(beatmap).GetPlayableBeatmap(new OsuRuleset().RulesetInfo, Array.Empty<Mod>());
 
                 var objects = converted.HitObjects.ToList();
 

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

@@ -9,6 +9,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Cursor;
 using osu.Game.Graphics.Cursor;
 using osu.Game.Rulesets.Osu.UI.Cursor;
+using osu.Game.Rulesets.UI;
 using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Osu.Tests
@@ -16,18 +17,18 @@ namespace osu.Game.Rulesets.Osu.Tests
     [TestFixture]
     public class TestCaseGameplayCursor : OsuTestCase, IProvideCursor
     {
-        private GameplayCursor cursor;
+        private GameplayCursorContainer cursorContainer;
 
         public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(CursorTrail) };
 
-        public CursorContainer Cursor => cursor;
+        public CursorContainer Cursor => cursorContainer;
 
         public bool ProvidingUserCursor => true;
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            Add(cursor = new GameplayCursor { RelativeSizeAxes = Axes.Both });
+            Add(cursorContainer = new OsuCursorContainer { RelativeSizeAxes = Axes.Both });
         }
     }
 }

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

@@ -30,7 +30,6 @@ namespace osu.Game.Rulesets.Osu.Tests
         protected override Container<Drawable> Content => content;
 
         private int depthIndex;
-        protected readonly List<Mod> Mods = new List<Mod>();
 
         public TestCaseHitCircle()
         {
@@ -68,7 +67,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 Depth = depthIndex++
             };
 
-            foreach (var mod in Mods.OfType<IApplicableToDrawableHitObjects>())
+            foreach (var mod in Mods.Value.OfType<IApplicableToDrawableHitObjects>())
                 mod.ApplyToDrawableHitObjects(new[] { drawable });
 
             Add(drawable);

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

@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         public TestCaseHitCircleHidden()
         {
-            Mods.Add(new OsuModHidden());
+            Mods.Value = new[] { new OsuModHidden() };
         }
     }
 }

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

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

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

@@ -0,0 +1,19 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Screens.Play;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestCaseOsuFlashlight : TestCaseOsuPlayer
+    {
+        protected override Player CreatePlayer(Ruleset ruleset)
+        {
+            Mods.Value = new Mod[] { new OsuModAutoplay(), new OsuModFlashlight(), };
+
+            return base.CreatePlayer(ruleset);
+        }
+    }
+}

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

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

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

@@ -0,0 +1,70 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Screens.Play;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestCaseResumeOverlay : ManualInputManagerTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(OsuResumeOverlay),
+        };
+
+        public TestCaseResumeOverlay()
+        {
+            ManualOsuInputManager osuInputManager;
+            CursorContainer cursor;
+            ResumeOverlay resume;
+
+            bool resumeFired = false;
+
+            Child = osuInputManager = new ManualOsuInputManager(new OsuRuleset().RulesetInfo)
+            {
+                Children = new Drawable[]
+                {
+                    cursor = new CursorContainer(),
+                    resume = new OsuResumeOverlay
+                    {
+                        GameplayCursor = cursor
+                    },
+                }
+            };
+
+            resume.ResumeAction = () => resumeFired = true;
+
+            AddStep("move mouse to center", () => InputManager.MoveMouseTo(ScreenSpaceDrawQuad.Centre));
+            AddStep("show", () => resume.Show());
+
+            AddStep("move mouse away", () => InputManager.MoveMouseTo(ScreenSpaceDrawQuad.TopLeft));
+            AddStep("click", () => osuInputManager.GameClick());
+            AddAssert("not dismissed", () => !resumeFired && resume.State == Visibility.Visible);
+
+            AddStep("move mouse back", () => InputManager.MoveMouseTo(ScreenSpaceDrawQuad.Centre));
+            AddStep("click", () => osuInputManager.GameClick());
+            AddAssert("dismissed", () => resumeFired && resume.State == Visibility.Hidden);
+        }
+
+        private class ManualOsuInputManager : OsuInputManager
+        {
+            public ManualOsuInputManager(RulesetInfo ruleset)
+                : base(ruleset)
+            {
+            }
+
+            public void GameClick()
+            {
+                KeyBindingContainer.TriggerPressed(OsuAction.LeftButton);
+                KeyBindingContainer.TriggerReleased(OsuAction.LeftButton);
+            }
+        }
+    }
+}

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

@@ -44,7 +44,6 @@ namespace osu.Game.Rulesets.Osu.Tests
         protected override Container<Drawable> Content => content;
 
         private int depthIndex;
-        protected readonly List<Mod> Mods = new List<Mod>();
 
         public TestCaseSlider()
         {
@@ -292,7 +291,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 Depth = depthIndex++
             };
 
-            foreach (var mod in Mods.OfType<IApplicableToDrawableHitObjects>())
+            foreach (var mod in Mods.Value.OfType<IApplicableToDrawableHitObjects>())
                 mod.ApplyToDrawableHitObjects(new[] { drawable });
 
             drawable.OnNewResult += onNewResult;

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

@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         public TestCaseSliderHidden()
         {
-            Mods.Add(new OsuModHidden());
+            Mods.Value = new[] { new OsuModHidden() };
         }
     }
 }

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

@@ -297,11 +297,6 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         private void performTest(List<ReplayFrame> frames)
         {
-            // Empty frame to be added as a workaround for first frame behavior.
-            // If an input exists on the first frame, the input would apply to the entire intro lead-in
-            // Likely requires some discussion regarding how first frame inputs should be handled.
-            frames.Insert(0, new OsuReplayFrame());
-
             AddStep("load player", () =>
             {
                 Beatmap.Value = new TestWorkingBeatmap(new Beatmap<OsuHitObject>
@@ -330,12 +325,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                     },
                 }, Clock);
 
-                var p = new ScoreAccessibleReplayPlayer(new Score { Replay = new Replay { Frames = frames } })
-                {
-                    AllowPause = false,
-                    AllowLeadIn = false,
-                    AllowResults = false
-                };
+                var p = new ScoreAccessibleReplayPlayer(new Score { Replay = new Replay { Frames = frames } });
 
                 p.OnLoadComplete += _ =>
                 {
@@ -354,9 +344,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
@@ -364,7 +354,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
 
             public ScoreAccessibleReplayPlayer(Score score)
-                : base(score)
+                : base(score, false, false)
             {
             }
         }

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

@@ -31,7 +31,6 @@ namespace osu.Game.Rulesets.Osu.Tests
         protected override Container<Drawable> Content => content;
 
         private int depthIndex;
-        protected readonly List<Mod> Mods = new List<Mod>();
 
         public TestCaseSpinner()
         {
@@ -57,7 +56,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 Depth = depthIndex++
             };
 
-            foreach (var mod in Mods.OfType<IApplicableToDrawableHitObjects>())
+            foreach (var mod in Mods.Value.OfType<IApplicableToDrawableHitObjects>())
                 mod.ApplyToDrawableHitObjects(new[] { drawable });
 
             Add(drawable);

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

@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         public TestCaseSpinnerHidden()
         {
-            Mods.Add(new OsuModHidden());
+            Mods.Value = new[] { new OsuModHidden() };
         }
     }
 }

osu.Game.Rulesets.Osu.Tests/osu.Game.Rulesets.Osu.Tests.csproj

@@ -2,9 +2,9 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.0.1" />
     <PackageReference Include="NUnit" Version="3.11.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.12.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.13.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

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

@@ -3,8 +3,8 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Beatmaps;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Beatmaps
@@ -23,19 +23,19 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                 {
                     Name = @"Circle Count",
                     Content = circles.ToString(),
-                    Icon = FontAwesome.fa_circle_o
+                    Icon = FontAwesome.Regular.Circle
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Slider Count",
                     Content = sliders.ToString(),
-                    Icon = FontAwesome.fa_circle
+                    Icon = FontAwesome.Regular.Circle
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Spinner Count",
                     Content = spinners.ToString(),
-                    Icon = FontAwesome.fa_circle
+                    Icon = FontAwesome.Regular.Circle
                 }
             };
         }

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

@@ -44,12 +44,14 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
             if (endIndex < 0) throw new ArgumentOutOfRangeException(nameof(endIndex), $"{nameof(endIndex)} cannot be less than 0.");
 
             int extendedEndIndex = endIndex;
+
             if (endIndex < beatmap.HitObjects.Count - 1)
             {
                 // Extend the end index to include objects they are stacked on
                 for (int i = endIndex; i >= startIndex; i--)
                 {
                     int stackBaseIndex = i;
+
                     for (int n = stackBaseIndex + 1; n < beatmap.HitObjects.Count; n++)
                     {
                         OsuHitObject stackBaseObject = beatmap.HitObjects[stackBaseIndex];
@@ -87,6 +89,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
 
             //Reverse pass for stack calculation.
             int extendedStartIndex = startIndex;
+
             for (int i = extendedEndIndex; i > startIndex; i--)
             {
                 int n = i;
@@ -138,6 +141,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                         if (objectN is Slider && Vector2Extensions.Distance(objectN.EndPosition, objectI.Position) < stack_distance)
                         {
                             int offset = objectI.StackHeight - objectN.StackHeight + 1;
+
                             for (int j = n + 1; j <= i; j++)
                             {
                                 //For each object which was declared under this slider, we will offset it to appear *below* the slider end (rather than above).