Merge pull request #11066 from ekrctb/fix-sample-expire

Fix DrawableHitObjects potentially expiring before their hit samples finish playback

.config/dotnet-tools.json

@@ -13,6 +13,24 @@
       "commands": [
         "dotnet-format"
       ]
+    },
+    "jetbrains.resharper.globaltools": {
+      "version": "2020.2.4",
+      "commands": [
+        "jb"
+      ]
+    },
+    "nvika": {
+      "version": "2.0.0",
+      "commands": [
+        "nvika"
+      ]
+    },
+    "codefilesanity": {
+      "version": "15.0.0",
+      "commands": [
+        "CodeFileSanity"
+      ]
     }
   }
 }

.gitignore

@@ -334,3 +334,5 @@ inspectcode
 
 # BenchmarkDotNet
 /BenchmarkDotNet.Artifacts
+
+*.GeneratedMSBuildEditorConfig.editorconfig

.idea/.idea.osu.Desktop/.idea/modules.xml

@@ -2,7 +2,7 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/.idea.osu.Desktop/riderModule.iml" filepath="$PROJECT_DIR$/.idea/.idea.osu.Desktop/riderModule.iml" />
+      <module fileurl="file://$PROJECT_DIR$/.idea/.idea.osu.Desktop/.idea/riderModule.iml" filepath="$PROJECT_DIR$/.idea/.idea.osu.Desktop/.idea/riderModule.iml" />
     </modules>
   </component>
 </project>

.vscode/tasks.json

@@ -9,11 +9,10 @@
             "command": "dotnet",
             "args": [
                 "build",
-                "--no-restore",
                 "osu.Desktop",
-                "/p:GenerateFullPaths=true",
-                "/m",
-                "/verbosity:m"
+                "-p:GenerateFullPaths=true",
+                "-m",
+                "-verbosity:m"
             ],
             "group": "build",
             "problemMatcher": "$msCompile"
@@ -24,12 +23,11 @@
             "command": "dotnet",
             "args": [
                 "build",
-                "--no-restore",
                 "osu.Desktop",
-                "/p:Configuration=Release",
-                "/p:GenerateFullPaths=true",
-                "/m",
-                "/verbosity:m"
+                "-p:Configuration=Release",
+                "-p:GenerateFullPaths=true",
+                "-m",
+                "-verbosity:m"
             ],
             "group": "build",
             "problemMatcher": "$msCompile"
@@ -40,11 +38,10 @@
             "command": "dotnet",
             "args": [
                 "build",
-                "--no-restore",
                 "osu.Game.Tests",
-                "/p:GenerateFullPaths=true",
-                "/m",
-                "/verbosity:m"
+                "-p:GenerateFullPaths=true",
+                "-m",
+                "-verbosity:m"
             ],
             "group": "build",
             "problemMatcher": "$msCompile"
@@ -55,12 +52,11 @@
             "command": "dotnet",
             "args": [
                 "build",
-                "--no-restore",
                 "osu.Game.Tests",
-                "/p:Configuration=Release",
-                "/p:GenerateFullPaths=true",
-                "/m",
-                "/verbosity:m"
+                "-p:Configuration=Release",
+                "-p:GenerateFullPaths=true",
+                "-m",
+                "-verbosity:m"
             ],
             "group": "build",
             "problemMatcher": "$msCompile"
@@ -71,11 +67,10 @@
             "command": "dotnet",
             "args": [
                 "build",
-                "--no-restore",
                 "osu.Game.Tournament.Tests",
-                "/p:GenerateFullPaths=true",
-                "/m",
-                "/verbosity:m"
+                "-p:GenerateFullPaths=true",
+                "-m",
+                "-verbosity:m"
             ],
             "group": "build",
             "problemMatcher": "$msCompile"
@@ -86,12 +81,11 @@
             "command": "dotnet",
             "args": [
                 "build",
-                "--no-restore",
                 "osu.Game.Tournament.Tests",
-                "/p:Configuration=Release",
-                "/p:GenerateFullPaths=true",
-                "/m",
-                "/verbosity:m"
+                "-p:Configuration=Release",
+                "-p:GenerateFullPaths=true",
+                "-m",
+                "-verbosity:m"
             ],
             "group": "build",
             "problemMatcher": "$msCompile"
@@ -102,25 +96,14 @@
             "command": "dotnet",
             "args": [
                 "build",
-                "--no-restore",
                 "osu.Game.Benchmarks",
-                "/p:Configuration=Release",
-                "/p:GenerateFullPaths=true",
-                "/m",
-                "/verbosity:m"
+                "-p:Configuration=Release",
+                "-p:GenerateFullPaths=true",
+                "-m",
+                "-verbosity:m"
             ],
             "group": "build",
             "problemMatcher": "$msCompile"
-        },
-        {
-            "label": "Restore (netcoreapp3.1)",
-            "type": "shell",
-            "command": "dotnet",
-            "args": [
-                "restore",
-                "build/Desktop.proj"
-            ],
-            "problemMatcher": []
         }
     ]
 }

CodeAnalysis/BannedSymbols.txt

@@ -4,5 +4,6 @@ M:System.ValueType.Equals(System.Object)~System.Boolean;Don't use object.Equals(
 M:System.Nullable`1.Equals(System.Object)~System.Boolean;Use == instead.
 T:System.IComparable;Don't use non-generic IComparable. Use generic version instead.
 M:osu.Framework.Graphics.Sprites.SpriteText.#ctor;Use OsuSpriteText.
+M:osu.Framework.Bindables.IBindableList`1.GetBoundCopy();Fails on iOS. Use manual ctor + BindTo instead. (see https://github.com/mono/mono/issues/19900)
 T:Microsoft.EntityFrameworkCore.Internal.EnumerableExtensions;Don't use internal extension methods.
 T:Microsoft.EntityFrameworkCore.Internal.TypeExtensions;Don't use internal extension methods.

Directory.Build.props

@@ -16,9 +16,9 @@
     <EmbeddedResource Include="Resources\**\*.*" />
   </ItemGroup>
   <ItemGroup Label="Code Analysis">
-    <PackageReference Include="Microsoft.CodeAnalysis.BannedApiAnalyzers" Version="3.3.0" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.CodeAnalysis.BannedApiAnalyzers" Version="3.3.1" PrivateAssets="All" />
     <AdditionalFiles Include="$(MSBuildThisFileDirectory)CodeAnalysis\BannedSymbols.txt" />
-    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="3.0.0" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="3.3.1" PrivateAssets="All" />
   </ItemGroup>
   <PropertyGroup Label="Code Analysis">
     <CodeAnalysisRuleSet>$(MSBuildThisFileDirectory)CodeAnalysis\osu.ruleset</CodeAnalysisRuleSet>

README.md

@@ -34,6 +34,8 @@ If you are looking to install or test osu! without setting up a development envi
 | [Windows (x64)](https://github.com/ppy/osu/releases/latest/download/install.exe)  | [macOS 10.12+](https://github.com/ppy/osu/releases/latest/download/osu.app.zip) | [Linux (x64)](https://github.com/ppy/osu/releases/latest/download/osu.AppImage) | [iOS(iOS 10+)](https://osu.ppy.sh/home/testflight) | [Android (5+)](https://github.com/ppy/osu/releases/latest/download/sh.ppy.osulazer.apk)
 | ------------- | ------------- | ------------- | ------------- | ------------- |
 
+- The iOS testflight link may fill up (Apple has a hard limit of 10,000 users). We reset it occasionally when this happens. Please do not ask about this. Check back regularly for link resets or follow [peppy](https://twitter.com/ppy) on twitter for announcements of link resets.
+
 - When running on Windows 7 or 8.1, **[additional prerequisites](https://docs.microsoft.com/en-us/dotnet/core/install/dependencies?tabs=netcore31&pivots=os-windows)** may be required to correctly run .NET Core applications if your operating system is not up-to-date with the latest service packs.
 
 If your platform is not listed above, there is still a chance you can manually build it by following the instructions below.
@@ -73,7 +75,6 @@ git pull
 Build configurations for the recommended IDEs (listed above) are included. You should use the provided Build/Run functionality of your IDE to get things going. When testing or building new components, it's highly encouraged you use the `VisualTests` project/configuration. More information on this is provided [below](#contributing).
 
 - Visual Studio / Rider users should load the project via one of the platform-specific `.slnf` files, rather than the main `.sln.` This will allow access to template run configurations.
-- Visual Studio Code users must run the `Restore` task before any build attempt.
 
 You can also build and run *osu!* from the command-line with a single command:
 

build/InspectCode.cake

@@ -1,7 +1,4 @@
 #addin "nuget:?package=CodeFileSanity&version=0.0.36"
-#addin "nuget:?package=JetBrains.ReSharper.CommandLineTools&version=2020.1.3"
-#tool "nuget:?package=NVika.MSBuild&version=1.0.1"
-var nVikaToolPath = GetFiles("./tools/NVika.MSBuild.*/tools/NVika.exe").First();
 
 ///////////////////////////////////////////////////////////////////////////////
 // ARGUMENTS
@@ -18,23 +15,15 @@ var desktopSlnf = rootDirectory.CombineWithFilePath("osu.Desktop.slnf");
 // TASKS
 ///////////////////////////////////////////////////////////////////////////////
 
-// windows only because both inspectcode and nvika depend on net45
 Task("InspectCode")
-    .WithCriteria(IsRunningOnWindows())
     .Does(() => {
-        InspectCode(desktopSlnf, new InspectCodeSettings {
-            CachesHome = "inspectcode",
-            OutputFile = "inspectcodereport.xml",
-            ArgumentCustomization = arg => {
-                if (AppVeyor.IsRunningOnAppVeyor) // Don't flood CI output
-                    arg.Append("--verbosity:WARN");
-                    return arg;
-            },
-        });
+        var inspectcodereport = "inspectcodereport.xml";
+        var cacheDir = "inspectcode";
+        var verbosity = AppVeyor.IsRunningOnAppVeyor ? "WARN" : "INFO"; // Don't flood CI output
 
-        int returnCode = StartProcess(nVikaToolPath, $@"parsereport ""inspectcodereport.xml"" --treatwarningsaserrors");
-        if (returnCode != 0)
-            throw new Exception($"inspectcode failed with return code {returnCode}");
+        DotNetCoreTool(rootDirectory.FullPath,
+            "jb", $@"inspectcode ""{desktopSlnf}"" --output=""{inspectcodereport}"" --caches-home=""{cacheDir}"" --verbosity={verbosity}");
+        DotNetCoreTool(rootDirectory.FullPath, "nvika", $@"parsereport ""{inspectcodereport}"" --treatwarningsaserrors");
     });
 
 Task("CodeFileSanity")

global.json

@@ -5,6 +5,6 @@
     "version": "3.1.100"
   },
   "msbuild-sdks": {
-    "Microsoft.Build.Traversal": "2.1.1"
+    "Microsoft.Build.Traversal": "3.0.2"
   }
 }

osu.Android.props

@@ -51,7 +51,7 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.904.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.1004.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.1202.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.1203.0" />
   </ItemGroup>
 </Project>

osu.Android/GameplayScreenRotationLocker.cs

@@ -0,0 +1,34 @@
+// 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 Android.Content.PM;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game;
+
+namespace osu.Android
+{
+    public class GameplayScreenRotationLocker : Component
+    {
+        private Bindable<bool> localUserPlaying;
+
+        [Resolved]
+        private OsuGameActivity gameActivity { get; set; }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuGame game)
+        {
+            localUserPlaying = game.LocalUserPlaying.GetBoundCopy();
+            localUserPlaying.BindValueChanged(updateLock, true);
+        }
+
+        private void updateLock(ValueChangedEvent<bool> userPlaying)
+        {
+            gameActivity.RunOnUiThread(() =>
+            {
+                gameActivity.RequestedOrientation = userPlaying.NewValue ? ScreenOrientation.Locked : ScreenOrientation.FullUser;
+            });
+        }
+    }
+}

osu.Android/OsuGameActivity.cs

@@ -12,7 +12,7 @@ namespace osu.Android
     [Activity(Theme = "@android:style/Theme.NoTitleBar", MainLauncher = true, ScreenOrientation = ScreenOrientation.FullUser, SupportsPictureInPicture = false, ConfigurationChanges = ConfigChanges.Orientation | ConfigChanges.ScreenSize, HardwareAccelerated = false)]
     public class OsuGameActivity : AndroidGameActivity
     {
-        protected override Framework.Game CreateGame() => new OsuGameAndroid();
+        protected override Framework.Game CreateGame() => new OsuGameAndroid(this);
 
         protected override void OnCreate(Bundle savedInstanceState)
         {

osu.Android/OsuGameAndroid.cs

@@ -4,6 +4,7 @@
 using System;
 using Android.App;
 using Android.OS;
+using osu.Framework.Allocation;
 using osu.Game;
 using osu.Game.Updater;
 
@@ -11,6 +12,15 @@ namespace osu.Android
 {
     public class OsuGameAndroid : OsuGame
     {
+        [Cached]
+        private readonly OsuGameActivity gameActivity;
+
+        public OsuGameAndroid(OsuGameActivity activity)
+            : base(null)
+        {
+            gameActivity = activity;
+        }
+
         public override Version AssemblyVersion
         {
             get
@@ -55,6 +65,12 @@ namespace osu.Android
             }
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            LoadComponentAsync(new GameplayScreenRotationLocker(), Add);
+        }
+
         protected override UpdateManager CreateUpdateManager() => new SimpleUpdateManager();
     }
 }

osu.Android/osu.Android.csproj

@@ -21,6 +21,7 @@
     <AndroidLinkTool>r8</AndroidLinkTool>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="GameplayScreenRotationLocker.cs" />
     <Compile Include="OsuGameActivity.cs" />
     <Compile Include="OsuGameAndroid.cs" />
   </ItemGroup>
@@ -53,4 +54,4 @@
     <AndroidResource Include="Resources\drawable\lazer.png" />
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
-</Project>
+</Project>

osu.Desktop/DiscordRichPresence.cs

@@ -135,6 +135,9 @@ namespace osu.Desktop
 
                 case UserActivity.Editing edit:
                     return edit.Beatmap.ToString();
+
+                case UserActivity.InLobby lobby:
+                    return lobby.Room.Name.Value;
             }
 
             return string.Empty;

osu.Desktop/OsuGameDesktop.cs

@@ -59,7 +59,7 @@ namespace osu.Desktop
             try
             {
                 using (RegistryKey key = Registry.ClassesRoot.OpenSubKey("osu"))
-                    stableInstallPath = key?.OpenSubKey(@"shell\open\command")?.GetValue(string.Empty).ToString()?.Split('"')[1].Replace("osu!.exe", "");
+                    stableInstallPath = key?.OpenSubKey(@"shell\open\command")?.GetValue(string.Empty)?.ToString()?.Split('"')[1].Replace("osu!.exe", "");
 
                 if (checkExists(stableInstallPath))
                     return stableInstallPath;
@@ -125,19 +125,22 @@ namespace osu.Desktop
         {
             base.SetHost(host);
 
+            var iconStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(GetType(), "lazer.ico");
+
             switch (host.Window)
             {
                 // Legacy osuTK DesktopGameWindow
-                case DesktopGameWindow desktopGameWindow:
+                case OsuTKDesktopWindow desktopGameWindow:
                     desktopGameWindow.CursorState |= CursorState.Hidden;
-                    desktopGameWindow.SetIconFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(GetType(), "lazer.ico"));
+                    desktopGameWindow.SetIconFromStream(iconStream);
                     desktopGameWindow.Title = Name;
                     desktopGameWindow.FileDrop += (_, e) => fileDrop(e.FileNames);
                     break;
 
                 // SDL2 DesktopWindow
-                case DesktopWindow desktopWindow:
-                    desktopWindow.CursorState.Value |= CursorState.Hidden;
+                case SDL2DesktopWindow desktopWindow:
+                    desktopWindow.CursorState |= CursorState.Hidden;
+                    desktopWindow.SetIconFromStream(iconStream);
                     desktopWindow.Title = Name;
                     desktopWindow.DragDrop += f => fileDrop(new[] { f });
                     break;

osu.Desktop/Program.cs

@@ -22,9 +22,9 @@ namespace osu.Desktop
         {
             // Back up the cwd before DesktopGameHost changes it
             var cwd = Environment.CurrentDirectory;
-            bool useSdl = args.Contains("--sdl");
+            bool useOsuTK = args.Contains("--tk");
 
-            using (DesktopGameHost host = Host.GetSuitableHost(@"osu", true, useSdl: useSdl))
+            using (DesktopGameHost host = Host.GetSuitableHost(@"osu", true, useOsuTK: useOsuTK))
             {
                 host.ExceptionThrown += handleException;
 

osu.Desktop/Updater/SquirrelUpdateManager.cs

@@ -29,6 +29,11 @@ namespace osu.Desktop.Updater
 
         private static readonly Logger logger = Logger.GetLogger("updater");
 
+        /// <summary>
+        /// Whether an update has been downloaded but not yet applied.
+        /// </summary>
+        private bool updatePending;
+
         [BackgroundDependencyLoader]
         private void load(NotificationOverlay notification)
         {
@@ -37,9 +42,9 @@ namespace osu.Desktop.Updater
             Splat.Locator.CurrentMutable.Register(() => new SquirrelLogger(), typeof(Splat.ILogger));
         }
 
-        protected override async Task PerformUpdateCheck() => await checkForUpdateAsync();
+        protected override async Task<bool> PerformUpdateCheck() => await checkForUpdateAsync();
 
-        private async Task checkForUpdateAsync(bool useDeltaPatching = true, UpdateProgressNotification notification = null)
+        private async Task<bool> checkForUpdateAsync(bool useDeltaPatching = true, UpdateProgressNotification notification = null)
         {
             // should we schedule a retry on completion of this check?
             bool scheduleRecheck = true;
@@ -49,9 +54,19 @@ namespace osu.Desktop.Updater
                 updateManager ??= await UpdateManager.GitHubUpdateManager(@"https://github.com/ppy/osu", @"osulazer", null, null, true);
 
                 var info = await updateManager.CheckForUpdate(!useDeltaPatching);
+
                 if (info.ReleasesToApply.Count == 0)
+                {
+                    if (updatePending)
+                    {
+                        // the user may have dismissed the completion notice, so show it again.
+                        notificationOverlay.Post(new UpdateCompleteNotification(this));
+                        return true;
+                    }
+
                     // no updates available. bail and retry later.
-                    return;
+                    return false;
+                }
 
                 if (notification == null)
                 {
@@ -72,6 +87,7 @@ namespace osu.Desktop.Updater
                     await updateManager.ApplyReleases(info, p => notification.Progress = p / 100f);
 
                     notification.State = ProgressNotificationState.Completed;
+                    updatePending = true;
                 }
                 catch (Exception e)
                 {
@@ -103,6 +119,8 @@ namespace osu.Desktop.Updater
                     Scheduler.AddDelayed(async () => await checkForUpdateAsync(), 60000 * 30);
                 }
             }
+
+            return true;
         }
 
         protected override void Dispose(bool isDisposing)
@@ -111,10 +129,27 @@ namespace osu.Desktop.Updater
             updateManager?.Dispose();
         }
 
+        private class UpdateCompleteNotification : ProgressCompletionNotification
+        {
+            [Resolved]
+            private OsuGame game { get; set; }
+
+            public UpdateCompleteNotification(SquirrelUpdateManager updateManager)
+            {
+                Text = @"Update ready to install. Click to restart!";
+
+                Activated = () =>
+                {
+                    updateManager.PrepareUpdateAsync()
+                                 .ContinueWith(_ => updateManager.Schedule(() => game.GracefullyExit()));
+                    return true;
+                };
+            }
+        }
+
         private class UpdateProgressNotification : ProgressNotification
         {
             private readonly SquirrelUpdateManager updateManager;
-            private OsuGame game;
 
             public UpdateProgressNotification(SquirrelUpdateManager updateManager)
             {
@@ -123,23 +158,12 @@ namespace osu.Desktop.Updater
 
             protected override Notification CreateCompletionNotification()
             {
-                return new ProgressCompletionNotification
-                {
-                    Text = @"Update ready to install. Click to restart!",
-                    Activated = () =>
-                    {
-                        updateManager.PrepareUpdateAsync()
-                                     .ContinueWith(_ => updateManager.Schedule(() => game.GracefullyExit()));
-                        return true;
-                    }
-                };
+                return new UpdateCompleteNotification(updateManager);
             }
 
             [BackgroundDependencyLoader]
-            private void load(OsuColour colours, OsuGame game)
+            private void load(OsuColour colours)
             {
-                this.game = game;
-
                 IconContent.AddRange(new Drawable[]
                 {
                     new Box

osu.Desktop/Windows/GameplayWinKeyBlocker.cs

@@ -5,24 +5,24 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Platform;
+using osu.Game;
 using osu.Game.Configuration;
 
 namespace osu.Desktop.Windows
 {
     public class GameplayWinKeyBlocker : Component
     {
-        private Bindable<bool> allowScreenSuspension;
         private Bindable<bool> disableWinKey;
+        private Bindable<bool> localUserPlaying;
 
-        private GameHost host;
+        [Resolved]
+        private GameHost host { get; set; }
 
         [BackgroundDependencyLoader]
-        private void load(GameHost host, OsuConfigManager config)
+        private void load(OsuGame game, OsuConfigManager config)
         {
-            this.host = host;
-
-            allowScreenSuspension = host.AllowScreenSuspension.GetBoundCopy();
-            allowScreenSuspension.BindValueChanged(_ => updateBlocking());
+            localUserPlaying = game.LocalUserPlaying.GetBoundCopy();
+            localUserPlaying.BindValueChanged(_ => updateBlocking());
 
             disableWinKey = config.GetBindable<bool>(OsuSetting.GameplayDisableWinKey);
             disableWinKey.BindValueChanged(_ => updateBlocking(), true);
@@ -30,7 +30,7 @@ namespace osu.Desktop.Windows
 
         private void updateBlocking()
         {
-            bool shouldDisable = disableWinKey.Value && !allowScreenSuspension.Value;
+            bool shouldDisable = disableWinKey.Value && localUserPlaying.Value;
 
             if (shouldDisable)
                 host.InputThread.Scheduler.Add(WindowsKey.Disable);

osu.Desktop/osu.Desktop.csproj

@@ -24,12 +24,12 @@
     <ProjectReference Include="..\osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="System.IO.Packaging" Version="4.7.0" />
+    <PackageReference Include="System.IO.Packaging" Version="5.0.0" />
     <PackageReference Include="ppy.squirrel.windows" Version="1.9.0.4" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.2.6" />
-    <PackageReference Include="Microsoft.Win32.Registry" Version="4.7.0" />
-    <PackageReference Include="DiscordRichPresence" Version="1.0.150" />
+    <PackageReference Include="Microsoft.Win32.Registry" Version="5.0.0" />
+    <PackageReference Include="DiscordRichPresence" Version="1.0.166" />
     <!-- .NET 3.1 SDK seems to cause issues with a runtime specification. This will likely be resolved in .NET 5. -->
     <PackageReference Include="System.IO.FileSystem.Primitives" Version="4.3.0" />
     <PackageReference Include="System.Runtime.Handles" Version="4.3.0" />

osu.Game.Rulesets.Catch.Tests/.vscode/tasks.json

@@ -9,11 +9,10 @@
             "command": "dotnet",
             "args": [
                 "build",
-                "--no-restore",
                 "osu.Game.Rulesets.Catch.Tests.csproj",
-                "/p:GenerateFullPaths=true",
-                "/m",
-                "/verbosity:m"
+                "-p:GenerateFullPaths=true",
+                "-m",
+                "-verbosity:m"
             ],
             "group": "build",
             "problemMatcher": "$msCompile"
@@ -24,24 +23,14 @@
             "command": "dotnet",
             "args": [
                 "build",
-                "--no-restore",
                 "osu.Game.Rulesets.Catch.Tests.csproj",
-                "/p:Configuration=Release",
-                "/p:GenerateFullPaths=true",
-                "/m",
-                "/verbosity:m"
+                "-p:Configuration=Release",
+                "-p:GenerateFullPaths=true",
+                "-m",
+                "-verbosity:m"
             ],
             "group": "build",
             "problemMatcher": "$msCompile"
-        },
-        {
-            "label": "Restore",
-            "type": "shell",
-            "command": "dotnet",
-            "args": [
-                "restore"
-            ],
-            "problemMatcher": []
         }
     ]
 }

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

@@ -12,17 +12,32 @@ namespace osu.Game.Rulesets.Catch.Tests
     [TestFixture]
     public class CatchLegacyModConversionTest : LegacyModConversionTest
     {
-        [TestCase(LegacyMods.Easy, new[] { typeof(CatchModEasy) })]
-        [TestCase(LegacyMods.HardRock | LegacyMods.DoubleTime, new[] { typeof(CatchModHardRock), typeof(CatchModDoubleTime) })]
-        [TestCase(LegacyMods.DoubleTime, new[] { typeof(CatchModDoubleTime) })]
-        [TestCase(LegacyMods.Nightcore, new[] { typeof(CatchModNightcore) })]
+        private static readonly object[][] catch_mod_mapping =
+        {
+            new object[] { LegacyMods.NoFail, new[] { typeof(CatchModNoFail) } },
+            new object[] { LegacyMods.Easy, new[] { typeof(CatchModEasy) } },
+            new object[] { LegacyMods.Hidden, new[] { typeof(CatchModHidden) } },
+            new object[] { LegacyMods.HardRock, new[] { typeof(CatchModHardRock) } },
+            new object[] { LegacyMods.SuddenDeath, new[] { typeof(CatchModSuddenDeath) } },
+            new object[] { LegacyMods.DoubleTime, new[] { typeof(CatchModDoubleTime) } },
+            new object[] { LegacyMods.Relax, new[] { typeof(CatchModRelax) } },
+            new object[] { LegacyMods.HalfTime, new[] { typeof(CatchModHalfTime) } },
+            new object[] { LegacyMods.Nightcore, new[] { typeof(CatchModNightcore) } },
+            new object[] { LegacyMods.Flashlight, new[] { typeof(CatchModFlashlight) } },
+            new object[] { LegacyMods.Autoplay, new[] { typeof(CatchModAutoplay) } },
+            new object[] { LegacyMods.Perfect, new[] { typeof(CatchModPerfect) } },
+            new object[] { LegacyMods.Cinema, new[] { typeof(CatchModCinema) } },
+            new object[] { LegacyMods.HardRock | LegacyMods.DoubleTime, new[] { typeof(CatchModHardRock), typeof(CatchModDoubleTime) } }
+        };
+
+        [TestCaseSource(nameof(catch_mod_mapping))]
+        [TestCase(LegacyMods.Cinema | LegacyMods.Autoplay, new[] { typeof(CatchModCinema) })]
         [TestCase(LegacyMods.Nightcore | LegacyMods.DoubleTime, new[] { typeof(CatchModNightcore) })]
-        [TestCase(LegacyMods.Flashlight | LegacyMods.Nightcore | LegacyMods.DoubleTime, new[] { typeof(CatchModFlashlight), typeof(CatchModNightcore) })]
-        [TestCase(LegacyMods.Perfect, new[] { typeof(CatchModPerfect) })]
-        [TestCase(LegacyMods.SuddenDeath, new[] { typeof(CatchModSuddenDeath) })]
         [TestCase(LegacyMods.Perfect | LegacyMods.SuddenDeath, new[] { typeof(CatchModPerfect) })]
-        [TestCase(LegacyMods.Perfect | LegacyMods.SuddenDeath | LegacyMods.DoubleTime, new[] { typeof(CatchModDoubleTime), typeof(CatchModPerfect) })]
-        public new void Test(LegacyMods legacyMods, Type[] expectedMods) => base.Test(legacyMods, expectedMods);
+        public new void TestFromLegacy(LegacyMods legacyMods, Type[] expectedMods) => base.TestFromLegacy(legacyMods, expectedMods);
+
+        [TestCaseSource(nameof(catch_mod_mapping))]
+        public new void TestToLegacy(LegacyMods legacyMods, Type[] givenMods) => base.TestToLegacy(legacyMods, givenMods);
 
         protected override Ruleset CreateRuleset() => new CatchRuleset();
     }

osu.Game.Rulesets.Catch.Tests/Mods/TestSceneCatchModRelax.cs

@@ -38,17 +38,17 @@ namespace osu.Game.Rulesets.Catch.Tests.Mods
                     new Fruit
                     {
                         X = 0,
-                        StartTime = 250
+                        StartTime = 1000
                     },
                     new Fruit
                     {
                         X = CatchPlayfield.WIDTH,
-                        StartTime = 500
+                        StartTime = 2000
                     },
                     new JuiceStream
                     {
                         X = CatchPlayfield.CENTER_X,
-                        StartTime = 750,
+                        StartTime = 3000,
                         Path = new SliderPath(PathType.Linear, new[] { Vector2.Zero, Vector2.UnitY * 200 })
                     }
                 }

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

@@ -43,7 +43,7 @@ namespace osu.Game.Rulesets.Catch.Tests
                     NewCombo = i % 8 == 0,
                     Samples = new List<HitSampleInfo>(new[]
                     {
-                        new HitSampleInfo { Bank = "normal", Name = "hitnormal", Volume = 100 }
+                        new HitSampleInfo(HitSampleInfo.HIT_NORMAL, "normal", volume: 100)
                     })
                 });
             }

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

@@ -0,0 +1,14 @@
+// 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.Catch.Tests
+{
+    [TestFixture]
+    public class TestSceneCatchPlayerLegacySkin : LegacySkinPlayerTestScene
+    {
+        protected override Ruleset CreatePlayerRuleset() => new CatchRuleset();
+    }
+}

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

@@ -1,26 +1,194 @@
 // 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 System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
-    public class TestSceneCatcher : CatchSkinnableTestScene
+    public class TestSceneCatcher : OsuTestScene
     {
-        [BackgroundDependencyLoader]
-        private void load()
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
+        private Container droppedObjectContainer;
+
+        private TestCatcher catcher;
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
         {
-            SetContents(() => new Catcher(new Container())
+            var difficulty = new BeatmapDifficulty
+            {
+                CircleSize = 0,
+            };
+
+            var trailContainer = new Container();
+            droppedObjectContainer = new Container();
+            catcher = new TestCatcher(trailContainer, droppedObjectContainer, difficulty);
+
+            Child = new Container
             {
-                RelativePositionAxes = Axes.None,
                 Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
+                Children = new Drawable[]
+                {
+                    trailContainer,
+                    droppedObjectContainer,
+                    catcher
+                }
+            };
+        });
+
+        [Test]
+        public void TestCatcherCatchWidth()
+        {
+            var halfWidth = Catcher.CalculateCatchWidth(new BeatmapDifficulty { CircleSize = 0 }) / 2;
+            AddStep("catch fruit", () =>
+            {
+                attemptCatch(new Fruit { X = -halfWidth + 1 });
+                attemptCatch(new Fruit { X = halfWidth - 1 });
             });
+            checkPlate(2);
+            AddStep("miss fruit", () =>
+            {
+                attemptCatch(new Fruit { X = -halfWidth - 1 });
+                attemptCatch(new Fruit { X = halfWidth + 1 });
+            });
+            checkPlate(2);
+        }
+
+        [Test]
+        public void TestFruitChangesCatcherState()
+        {
+            AddStep("miss fruit", () => attemptCatch(new Fruit { X = 100 }));
+            checkState(CatcherAnimationState.Fail);
+            AddStep("catch fruit", () => attemptCatch(new Fruit()));
+            checkState(CatcherAnimationState.Idle);
+            AddStep("catch kiai fruit", () => attemptCatch(new TestKiaiFruit()));
+            checkState(CatcherAnimationState.Kiai);
+        }
+
+        [Test]
+        public void TestNormalFruitResetsHyperDashState()
+        {
+            AddStep("catch hyper fruit", () => attemptCatch(new Fruit
+            {
+                HyperDashTarget = new Fruit { X = 100 }
+            }));
+            checkHyperDash(true);
+            AddStep("catch normal fruit", () => attemptCatch(new Fruit()));
+            checkHyperDash(false);
+        }
+
+        [Test]
+        public void TestTinyDropletMissPreservesCatcherState()
+        {
+            AddStep("catch hyper kiai fruit", () => attemptCatch(new TestKiaiFruit
+            {
+                HyperDashTarget = new Fruit { X = 100 }
+            }));
+            AddStep("catch tiny droplet", () => attemptCatch(new TinyDroplet()));
+            AddStep("miss tiny droplet", () => attemptCatch(new TinyDroplet { X = 100 }));
+            // catcher state and hyper dash state is preserved
+            checkState(CatcherAnimationState.Kiai);
+            checkHyperDash(true);
+        }
+
+        [Test]
+        public void TestBananaMissPreservesCatcherState()
+        {
+            AddStep("catch hyper kiai fruit", () => attemptCatch(new TestKiaiFruit
+            {
+                HyperDashTarget = new Fruit { X = 100 }
+            }));
+            AddStep("miss banana", () => attemptCatch(new Banana { X = 100 }));
+            // catcher state is preserved but hyper dash state is reset
+            checkState(CatcherAnimationState.Kiai);
+            checkHyperDash(false);
+        }
+
+        [Test]
+        public void TestCatcherStacking()
+        {
+            AddStep("catch fruit", () => attemptCatch(new Fruit()));
+            checkPlate(1);
+            AddStep("catch more fruits", () => attemptCatch(new Fruit(), 9));
+            checkPlate(10);
+            AddAssert("caught objects are stacked", () =>
+                catcher.CaughtObjects.All(obj => obj.Y <= 0) &&
+                catcher.CaughtObjects.Any(obj => obj.Y == 0) &&
+                catcher.CaughtObjects.Any(obj => obj.Y < -20));
+        }
+
+        [Test]
+        public void TestCatcherExplosionAndDropping()
+        {
+            AddStep("catch fruit", () => attemptCatch(new Fruit()));
+            AddStep("catch tiny droplet", () => attemptCatch(new TinyDroplet()));
+            AddAssert("tiny droplet is exploded", () => catcher.CaughtObjects.Count() == 1 && droppedObjectContainer.Count == 1);
+            AddUntilStep("wait explosion", () => !droppedObjectContainer.Any());
+            AddStep("catch more fruits", () => attemptCatch(new Fruit(), 9));
+            AddStep("explode", () => catcher.Explode());
+            AddAssert("fruits are exploded", () => !catcher.CaughtObjects.Any() && droppedObjectContainer.Count == 10);
+            AddUntilStep("wait explosion", () => !droppedObjectContainer.Any());
+            AddStep("catch fruits", () => attemptCatch(new Fruit(), 10));
+            AddStep("drop", () => catcher.Drop());
+            AddAssert("fruits are dropped", () => !catcher.CaughtObjects.Any() && droppedObjectContainer.Count == 10);
+        }
+
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestHitLighting(bool enabled)
+        {
+            AddStep($"{(enabled ? "enable" : "disable")} hit lighting", () => config.Set(OsuSetting.HitLighting, enabled));
+            AddStep("catch fruit", () => attemptCatch(new Fruit()));
+            AddAssert("check hit lighting", () => catcher.ChildrenOfType<HitExplosion>().Any() == enabled);
+        }
+
+        private void checkPlate(int count) => AddAssert($"{count} objects on the plate", () => catcher.CaughtObjects.Count() == count);
+
+        private void checkState(CatcherAnimationState state) => AddAssert($"catcher state is {state}", () => catcher.CurrentState == state);
+
+        private void checkHyperDash(bool state) => AddAssert($"catcher is {(state ? "" : "not ")}hyper dashing", () => catcher.HyperDashing == state);
+
+        private void attemptCatch(CatchHitObject hitObject, int count = 1)
+        {
+            hitObject.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+            for (var i = 0; i < count; i++)
+                catcher.AttemptCatch(hitObject);
+        }
+
+        public class TestCatcher : Catcher
+        {
+            public IEnumerable<DrawablePalpableCatchHitObject> CaughtObjects => this.ChildrenOfType<DrawablePalpableCatchHitObject>();
+
+            public TestCatcher(Container trailsTarget, Container droppedObjectTarget, BeatmapDifficulty difficulty)
+                : base(trailsTarget, droppedObjectTarget, difficulty)
+            {
+            }
+        }
+
+        public class TestKiaiFruit : Fruit
+        {
+            protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
+            {
+                controlPointInfo.Add(0, new EffectControlPoint { KiaiMode = true });
+                base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
+            }
         }
     }
 }

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

@@ -6,18 +6,17 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Configuration;
-using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
@@ -29,82 +28,68 @@ namespace osu.Game.Rulesets.Catch.Tests
         [Resolved]
         private OsuConfigManager config { get; set; }
 
-        private Catcher catcher => this.ChildrenOfType<CatcherArea>().First().MovableCatcher;
+        private Catcher catcher => this.ChildrenOfType<Catcher>().First();
+
+        private float circleSize;
 
         public TestSceneCatcherArea()
         {
-            AddSliderStep<float>("CircleSize", 0, 8, 5, createCatcher);
-            AddToggleStep("Hyperdash", t =>
-                CreatedDrawables.OfType<CatchInputManager>().Select(i => i.Child)
-                                .OfType<TestCatcherArea>().ForEach(c => c.ToggleHyperDash(t)));
+            AddSliderStep<float>("circle size", 0, 8, 5, createCatcher);
+            AddToggleStep("hyper dash", t => this.ChildrenOfType<TestCatcherArea>().ForEach(area => area.ToggleHyperDash(t)));
 
-            AddRepeatStep("catch fruit", () => catchFruit(new TestFruit(false)
-            {
-                X = catcher.X
-            }), 20);
-            AddRepeatStep("catch fruit last in combo", () => catchFruit(new TestFruit(false)
-            {
-                X = catcher.X,
-                LastInCombo = true,
-            }), 20);
-            AddRepeatStep("catch kiai fruit", () => catchFruit(new TestFruit(true)
-            {
-                X = catcher.X
-            }), 20);
-            AddRepeatStep("miss fruit", () => catchFruit(new Fruit
-            {
-                X = catcher.X + 100,
-                LastInCombo = true,
-            }, true), 20);
+            AddStep("catch fruit", () => attemptCatch(new Fruit()));
+            AddStep("catch fruit last in combo", () => attemptCatch(new Fruit { LastInCombo = true }));
+            AddStep("catch kiai fruit", () => attemptCatch(new TestSceneCatcher.TestKiaiFruit()));
+            AddStep("miss last in combo", () => attemptCatch(new Fruit { X = 100, LastInCombo = true }));
         }
 
-        [TestCase(true)]
-        [TestCase(false)]
-        public void TestHitLighting(bool enable)
+        private void attemptCatch(Fruit fruit)
         {
-            AddStep("create catcher", () => createCatcher(5));
-
-            AddStep("toggle hit lighting", () => config.Set(OsuSetting.HitLighting, enable));
-            AddStep("catch fruit", () => catchFruit(new TestFruit(false)
+            fruit.X += catcher.X;
+            fruit.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty
             {
-                X = catcher.X
-            }));
-            AddStep("catch fruit last in combo", () => catchFruit(new TestFruit(false)
-            {
-                X = catcher.X,
-                LastInCombo = true
-            }));
-            AddAssert("check hit explosion", () => catcher.ChildrenOfType<HitExplosion>().Any() == enable);
-        }
+                CircleSize = circleSize
+            });
 
-        private void catchFruit(Fruit fruit, bool miss = false)
-        {
-            this.ChildrenOfType<CatcherArea>().ForEach(area =>
+            foreach (var area in this.ChildrenOfType<CatcherArea>())
             {
                 DrawableFruit drawable = new DrawableFruit(fruit);
                 area.Add(drawable);
 
                 Schedule(() =>
                 {
-                    area.AttemptCatch(fruit);
-                    area.OnNewResult(drawable, new JudgementResult(fruit, new CatchJudgement()) { Type = miss ? HitResult.Miss : HitResult.Great });
+                    bool caught = area.AttemptCatch(fruit);
+                    area.OnNewResult(drawable, new JudgementResult(fruit, new CatchJudgement())
+                    {
+                        Type = caught ? HitResult.Great : HitResult.Miss
+                    });
 
                     drawable.Expire();
                 });
-            });
+            }
         }
 
         private void createCatcher(float size)
         {
-            SetContents(() => new CatchInputManager(catchRuleset)
+            circleSize = size;
+
+            SetContents(() =>
             {
-                RelativeSizeAxes = Axes.Both,
-                Child = new TestCatcherArea(new BeatmapDifficulty { CircleSize = size })
+                var droppedObjectContainer = new Container();
+
+                return new CatchInputManager(catchRuleset)
                 {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.TopCentre,
-                    CreateDrawableRepresentation = ((DrawableRuleset<CatchHitObject>)catchRuleset.CreateInstance().CreateDrawableRulesetWith(new CatchBeatmap())).CreateDrawableRepresentation
-                },
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        droppedObjectContainer,
+                        new TestCatcherArea(droppedObjectContainer, new BeatmapDifficulty { CircleSize = size })
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.TopCentre,
+                        }
+                    }
+                };
             });
         }
 
@@ -114,26 +99,13 @@ namespace osu.Game.Rulesets.Catch.Tests
             catchRuleset = rulesets.GetRuleset(2);
         }
 
-        public class TestFruit : Fruit
-        {
-            public TestFruit(bool kiai)
-            {
-                var kiaiCpi = new ControlPointInfo();
-                kiaiCpi.Add(0, new EffectControlPoint { KiaiMode = kiai });
-
-                ApplyDefaultsToSelf(kiaiCpi, new BeatmapDifficulty());
-            }
-        }
-
         private class TestCatcherArea : CatcherArea
         {
-            public TestCatcherArea(BeatmapDifficulty beatmapDifficulty)
-                : base(beatmapDifficulty)
+            public TestCatcherArea(Container droppedObjectContainer, BeatmapDifficulty beatmapDifficulty)
+                : base(droppedObjectContainer, beatmapDifficulty)
             {
             }
 
-            public new Catcher MovableCatcher => base.MovableCatcher;
-
             public void ToggleHyperDash(bool status) => MovableCatcher.SetHyperDashState(status ? 2 : 1);
         }
     }

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

@@ -136,7 +136,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             if (juice.NestedHitObjects.Last() is CatchHitObject tail)
                 tail.LastInCombo = true; // usually the (Catch)BeatmapProcessor would do this for us when necessary
 
-            addToPlayfield(new DrawableJuiceStream(juice, drawableRuleset.CreateDrawableRepresentation));
+            addToPlayfield(new DrawableJuiceStream(juice));
         }
 
         private void spawnBananas(bool hit = false)

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

@@ -1,12 +1,14 @@
 // 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.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
-using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
@@ -17,99 +19,69 @@ namespace osu.Game.Rulesets.Catch.Tests
         {
             base.LoadComplete();
 
-            foreach (FruitVisualRepresentation rep in Enum.GetValues(typeof(FruitVisualRepresentation)))
-                AddStep($"show {rep}", () => SetContents(() => createDrawable(rep)));
+            AddStep("show pear", () => SetContents(() => createDrawableFruit(0)));
+            AddStep("show grape", () => SetContents(() => createDrawableFruit(1)));
+            AddStep("show pineapple / apple", () => SetContents(() => createDrawableFruit(2)));
+            AddStep("show raspberry / orange", () => SetContents(() => createDrawableFruit(3)));
+
+            AddStep("show banana", () => SetContents(createDrawableBanana));
 
             AddStep("show droplet", () => SetContents(() => createDrawableDroplet()));
             AddStep("show tiny droplet", () => SetContents(createDrawableTinyDroplet));
 
-            foreach (FruitVisualRepresentation rep in Enum.GetValues(typeof(FruitVisualRepresentation)))
-                AddStep($"show hyperdash {rep}", () => SetContents(() => createDrawable(rep, true)));
+            AddStep("show hyperdash pear", () => SetContents(() => createDrawableFruit(0, true)));
+            AddStep("show hyperdash grape", () => SetContents(() => createDrawableFruit(1, true)));
+            AddStep("show hyperdash pineapple / apple", () => SetContents(() => createDrawableFruit(2, true)));
+            AddStep("show hyperdash raspberry / orange", () => SetContents(() => createDrawableFruit(3, true)));
 
             AddStep("show hyperdash droplet", () => SetContents(() => createDrawableDroplet(true)));
         }
 
-        private Drawable createDrawableTinyDroplet()
-        {
-            var droplet = new TestCatchTinyDroplet
+        private Drawable createDrawableFruit(int indexInBeatmap, bool hyperdash = false) =>
+            new TestDrawableCatchHitObjectSpecimen(new DrawableFruit(new Fruit
             {
-                Scale = 1.5f,
+                IndexInBeatmap = indexInBeatmap,
+                HyperDashBindable = { Value = hyperdash }
+            }));
+
+        private Drawable createDrawableBanana() =>
+            new TestDrawableCatchHitObjectSpecimen(new DrawableBanana(new Banana()));
+
+        private Drawable createDrawableDroplet(bool hyperdash = false) =>
+            new TestDrawableCatchHitObjectSpecimen(new DrawableDroplet(new Droplet
+            {
+                HyperDashBindable = { Value = hyperdash }
+            }));
+
+        private Drawable createDrawableTinyDroplet() => new TestDrawableCatchHitObjectSpecimen(new DrawableTinyDroplet(new TinyDroplet()));
+    }
+
+    public class TestDrawableCatchHitObjectSpecimen : CompositeDrawable
+    {
+        public readonly ManualClock ManualClock;
+
+        public TestDrawableCatchHitObjectSpecimen(DrawableCatchHitObject d)
+        {
+            AutoSizeAxes = Axes.Both;
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            ManualClock = new ManualClock();
+            Clock = new FramedClock(ManualClock);
+
+            var hitObject = d.HitObject;
+            hitObject.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+            hitObject.Scale = 1.5f;
+            hitObject.StartTime = 500;
+
+            d.Anchor = Anchor.Centre;
+            d.HitObjectApplied += _ =>
+            {
+                d.LifetimeStart = double.NegativeInfinity;
+                d.LifetimeEnd = double.PositiveInfinity;
             };
 
-            return new DrawableTinyDroplet(droplet)
-            {
-                Anchor = Anchor.Centre,
-                RelativePositionAxes = Axes.None,
-                Position = Vector2.Zero,
-                Alpha = 1,
-                LifetimeStart = double.NegativeInfinity,
-                LifetimeEnd = double.PositiveInfinity,
-            };
-        }
-
-        private Drawable createDrawableDroplet(bool hyperdash = false)
-        {
-            var droplet = new TestCatchDroplet
-            {
-                Scale = 1.5f,
-                HyperDashTarget = hyperdash ? new Banana() : null
-            };
-
-            return new DrawableDroplet(droplet)
-            {
-                Anchor = Anchor.Centre,
-                RelativePositionAxes = Axes.None,
-                Position = Vector2.Zero,
-                Alpha = 1,
-                LifetimeStart = double.NegativeInfinity,
-                LifetimeEnd = double.PositiveInfinity,
-            };
-        }
-
-        private Drawable createDrawable(FruitVisualRepresentation rep, bool hyperdash = false)
-        {
-            Fruit fruit = new TestCatchFruit(rep)
-            {
-                Scale = 1.5f,
-                HyperDashTarget = hyperdash ? new Banana() : null
-            };
-
-            return new DrawableFruit(fruit)
-            {
-                Anchor = Anchor.Centre,
-                RelativePositionAxes = Axes.None,
-                Position = Vector2.Zero,
-                Alpha = 1,
-                LifetimeStart = double.NegativeInfinity,
-                LifetimeEnd = double.PositiveInfinity,
-            };
-        }
-
-        public class TestCatchFruit : Fruit
-        {
-            public TestCatchFruit(FruitVisualRepresentation rep)
-            {
-                VisualRepresentation = rep;
-                StartTime = 1000000000000;
-            }
-
-            public override FruitVisualRepresentation VisualRepresentation { get; }
-        }
-
-        public class TestCatchDroplet : Droplet
-        {
-            public TestCatchDroplet()
-            {
-                StartTime = 1000000000000;
-            }
-        }
-
-        public class TestCatchTinyDroplet : TinyDroplet
-        {
-            public TestCatchTinyDroplet()
-            {
-                StartTime = 1000000000000;
-            }
+            InternalChild = d;
         }
     }
 }

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

@@ -0,0 +1,96 @@
+// 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.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Tests.Visual;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    public class TestSceneFruitRandomness : OsuTestScene
+    {
+        private readonly TestDrawableFruit drawableFruit;
+        private readonly TestDrawableBanana drawableBanana;
+
+        public TestSceneFruitRandomness()
+        {
+            drawableFruit = new TestDrawableFruit(new Fruit());
+            drawableBanana = new TestDrawableBanana(new Banana());
+
+            Add(new TestDrawableCatchHitObjectSpecimen(drawableFruit) { X = -200 });
+            Add(new TestDrawableCatchHitObjectSpecimen(drawableBanana));
+
+            AddSliderStep("start time", 500, 600, 0, x =>
+            {
+                drawableFruit.HitObject.StartTime = drawableBanana.HitObject.StartTime = x;
+            });
+        }
+
+        [Test]
+        public void TestFruitRandomness()
+        {
+            // Use values such that the banana colour changes (2/3 of the integers are okay)
+            const int initial_start_time = 500;
+            const int another_start_time = 501;
+
+            float fruitRotation = 0;
+            float bananaRotation = 0;
+            float bananaScale = 0;
+            Color4 bananaColour = new Color4();
+
+            AddStep("Initialize start time", () =>
+            {
+                drawableFruit.HitObject.StartTime = drawableBanana.HitObject.StartTime = initial_start_time;
+
+                fruitRotation = drawableFruit.InnerRotation;
+                bananaRotation = drawableBanana.InnerRotation;
+                bananaScale = drawableBanana.InnerScale;
+                bananaColour = drawableBanana.AccentColour.Value;
+            });
+
+            AddStep("change start time", () =>
+            {
+                drawableFruit.HitObject.StartTime = drawableBanana.HitObject.StartTime = another_start_time;
+            });
+
+            AddAssert("fruit rotation is changed", () => drawableFruit.InnerRotation != fruitRotation);
+            AddAssert("banana rotation is changed", () => drawableBanana.InnerRotation != bananaRotation);
+            AddAssert("banana scale is changed", () => drawableBanana.InnerScale != bananaScale);
+            AddAssert("banana colour is changed", () => drawableBanana.AccentColour.Value != bananaColour);
+
+            AddStep("reset start time", () =>
+            {
+                drawableFruit.HitObject.StartTime = drawableBanana.HitObject.StartTime = initial_start_time;
+            });
+
+            AddAssert("rotation and scale restored", () =>
+                drawableFruit.InnerRotation == fruitRotation &&
+                drawableBanana.InnerRotation == bananaRotation &&
+                drawableBanana.InnerScale == bananaScale &&
+                drawableBanana.AccentColour.Value == bananaColour);
+        }
+
+        private class TestDrawableFruit : DrawableFruit
+        {
+            public float InnerRotation => ScaleContainer.Rotation;
+
+            public TestDrawableFruit(Fruit h)
+                : base(h)
+            {
+            }
+        }
+
+        private class TestDrawableBanana : DrawableBanana
+        {
+            public float InnerRotation => ScaleContainer.Rotation;
+            public float InnerScale => ScaleContainer.Scale.X;
+
+            public TestDrawableBanana(Banana h)
+                : base(h)
+            {
+            }
+        }
+    }
+}

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

@@ -0,0 +1,32 @@
+// 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.Bindables;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    public class TestSceneFruitVisualChange : TestSceneFruitObjects
+    {
+        private readonly Bindable<int> indexInBeatmap = new Bindable<int>();
+        private readonly Bindable<bool> hyperDash = new Bindable<bool>();
+
+        protected override void LoadComplete()
+        {
+            AddStep("fruit changes visual and hyper", () => SetContents(() => new TestDrawableCatchHitObjectSpecimen(new DrawableFruit(new Fruit
+            {
+                IndexInBeatmapBindable = { BindTarget = indexInBeatmap },
+                HyperDashBindable = { BindTarget = hyperDash },
+            }))));
+
+            AddStep("droplet changes hyper", () => SetContents(() => new TestDrawableCatchHitObjectSpecimen(new DrawableDroplet(new Droplet
+            {
+                HyperDashBindable = { BindTarget = hyperDash },
+            }))));
+
+            Scheduler.AddDelayed(() => indexInBeatmap.Value++, 250, true);
+            Scheduler.AddDelayed(() => hyperDash.Value = !hyperDash.Value, 1000, true);
+        }
+    }
+}

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

@@ -117,13 +117,16 @@ namespace osu.Game.Rulesets.Catch.Tests
 
             AddStep("create hyper-dashing catcher", () =>
             {
-                Child = setupSkinHierarchy(catcherArea = new CatcherArea
+                Child = setupSkinHierarchy(catcherArea = new CatcherArea(new Container())
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     Scale = new Vector2(4f),
                 }, skin);
+            });
 
+            AddStep("get trails container", () =>
+            {
                 trails = catcherArea.OfType<CatcherTrailDisplay>().Single();
                 catcherArea.MovableCatcher.SetHyperDashState(2);
             });

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

@@ -2,7 +2,7 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

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

@@ -5,11 +5,11 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.MathUtils;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
-using osu.Game.Rulesets.Objects.Types;
-using osu.Game.Rulesets.Catch.MathUtils;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Rulesets.Catch.Beatmaps
 {
@@ -192,24 +192,24 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
 
         private static void initialiseHyperDash(IBeatmap beatmap)
         {
-            List<CatchHitObject> objectWithDroplets = new List<CatchHitObject>();
+            List<PalpableCatchHitObject> palpableObjects = new List<PalpableCatchHitObject>();
 
             foreach (var currentObject in beatmap.HitObjects)
             {
                 if (currentObject is Fruit fruitObject)
-                    objectWithDroplets.Add(fruitObject);
+                    palpableObjects.Add(fruitObject);
 
                 if (currentObject is JuiceStream)
                 {
-                    foreach (var currentJuiceElement in currentObject.NestedHitObjects)
+                    foreach (var juice in currentObject.NestedHitObjects)
                     {
-                        if (!(currentJuiceElement is TinyDroplet))
-                            objectWithDroplets.Add((CatchHitObject)currentJuiceElement);
+                        if (juice is PalpableCatchHitObject palpableObject && !(juice is TinyDroplet))
+                            palpableObjects.Add(palpableObject);
                     }
                 }
             }
 
-            objectWithDroplets.Sort((h1, h2) => h1.StartTime.CompareTo(h2.StartTime));
+            palpableObjects.Sort((h1, h2) => h1.StartTime.CompareTo(h2.StartTime));
 
             double halfCatcherWidth = Catcher.CalculateCatchWidth(beatmap.BeatmapInfo.BaseDifficulty) / 2;
 
@@ -221,10 +221,10 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
             int lastDirection = 0;
             double lastExcess = halfCatcherWidth;
 
-            for (int i = 0; i < objectWithDroplets.Count - 1; i++)
+            for (int i = 0; i < palpableObjects.Count - 1; i++)
             {
-                CatchHitObject currentObject = objectWithDroplets[i];
-                CatchHitObject nextObject = objectWithDroplets[i + 1];
+                var currentObject = palpableObjects[i];
+                var nextObject = palpableObjects[i + 1];
 
                 // Reset variables in-case values have changed (e.g. after applying HR)
                 currentObject.HyperDashTarget = null;

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -141,11 +141,40 @@ namespace osu.Game.Rulesets.Catch
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = OsuIcon.RulesetCatch };
 
+        protected override IEnumerable<HitResult> GetValidHitResults()
+        {
+            return new[]
+            {
+                HitResult.Great,
+
+                HitResult.LargeTickHit,
+                HitResult.SmallTickHit,
+                HitResult.LargeBonus,
+            };
+        }
+
+        public override string GetDisplayNameForHitResult(HitResult result)
+        {
+            switch (result)
+            {
+                case HitResult.LargeTickHit:
+                    return "large droplet";
+
+                case HitResult.SmallTickHit:
+                    return "small droplet";
+
+                case HitResult.LargeBonus:
+                    return "banana";
+            }
+
+            return base.GetDisplayNameForHitResult(result);
+        }
+
         public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new CatchDifficultyCalculator(this, beatmap);
 
         public override ISkin CreateLegacySkinProvider(ISkinSource source, IBeatmap beatmap) => new CatchLegacySkinTransformer(source);
 
-        public override PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, ScoreInfo score) => new CatchPerformanceCalculator(this, beatmap, score);
+        public override PerformanceCalculator CreatePerformanceCalculator(DifficultyAttributes attributes, ScoreInfo score) => new CatchPerformanceCalculator(this, attributes, score);
 
         public int LegacyID => 2;
 

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

@@ -5,7 +5,6 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Extensions;
-using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
@@ -25,8 +24,8 @@ namespace osu.Game.Rulesets.Catch.Difficulty
         private int tinyTicksMissed;
         private int misses;
 
-        public CatchPerformanceCalculator(Ruleset ruleset, WorkingBeatmap beatmap, ScoreInfo score)
-            : base(ruleset, beatmap, score)
+        public CatchPerformanceCalculator(Ruleset ruleset, DifficultyAttributes attributes, ScoreInfo score)
+            : base(ruleset, attributes, score)
         {
         }
 

osu.Game.Rulesets.Catch/Difficulty/Preprocessing/CatchDifficultyHitObject.cs

@@ -12,9 +12,9 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Preprocessing
     {
         private const float normalized_hitobject_radius = 41.0f;
 
-        public new CatchHitObject BaseObject => (CatchHitObject)base.BaseObject;
+        public new PalpableCatchHitObject BaseObject => (PalpableCatchHitObject)base.BaseObject;
 
-        public new CatchHitObject LastObject => (CatchHitObject)base.LastObject;
+        public new PalpableCatchHitObject LastObject => (PalpableCatchHitObject)base.LastObject;
 
         public readonly float NormalizedPosition;
         public readonly float LastNormalizedPosition;

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

@@ -5,7 +5,7 @@ using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Catch.Mods
 {
-    public class CatchModEasy : ModEasy
+    public class CatchModEasy : ModEasyWithExtraLives
     {
         public override string Description => @"Larger fruits, more forgiving HP drain, less accuracy required, and three lives!";
     }

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

@@ -17,9 +17,11 @@ namespace osu.Game.Rulesets.Catch.Mods
         private const double fade_out_offset_multiplier = 0.6;
         private const double fade_out_duration_multiplier = 0.44;
 
-        protected override void ApplyHiddenState(DrawableHitObject drawable, ArmedState state)
+        protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {
-            if (!(drawable is DrawableCatchHitObject catchDrawable))
+            base.ApplyNormalVisibilityState(hitObject, state);
+
+            if (!(hitObject is DrawableCatchHitObject catchDrawable))
                 return;
 
             if (catchDrawable.NestedHitObjects.Any())

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

@@ -1,22 +1,26 @@
 // 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.
 
+#nullable enable
+
+using System;
 using System.Collections.Generic;
 using osu.Game.Audio;
 using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Utils;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Objects
 {
-    public class Banana : Fruit
+    public class Banana : Fruit, IHasComboInformation
     {
         /// <summary>
         /// Index of banana in current shower.
         /// </summary>
         public int BananaIndex;
 
-        public override FruitVisualRepresentation VisualRepresentation => FruitVisualRepresentation.Banana;
-
         public override Judgement CreateJudgement() => new CatchBananaJudgement();
 
         private static readonly List<HitSampleInfo> samples = new List<HitSampleInfo> { new BananaHitSampleInfo() };
@@ -26,11 +30,45 @@ namespace osu.Game.Rulesets.Catch.Objects
             Samples = samples;
         }
 
-        private class BananaHitSampleInfo : HitSampleInfo
-        {
-            private static string[] lookupNames { get; } = { "metronomelow", "catch-banana" };
+        // override any external colour changes with banananana
+        Color4 IHasComboInformation.GetComboColour(IReadOnlyList<Color4> comboColours) => getBananaColour();
 
-            public override IEnumerable<string> LookupNames => lookupNames;
+        private Color4 getBananaColour()
+        {
+            switch (StatelessRNG.NextInt(3, RandomSeed))
+            {
+                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);
+            }
+        }
+
+        private class BananaHitSampleInfo : HitSampleInfo, IEquatable<BananaHitSampleInfo>
+        {
+            private static readonly string[] lookup_names = { "Gameplay/metronomelow", "Gameplay/catch-banana" };
+
+            public override IEnumerable<string> LookupNames => lookup_names;
+
+            public BananaHitSampleInfo(int volume = 0)
+                : base(string.Empty, volume: volume)
+            {
+            }
+
+            public sealed override HitSampleInfo With(Optional<string> newName = default, Optional<string?> newBank = default, Optional<string?> newSuffix = default, Optional<int> newVolume = default)
+                => new BananaHitSampleInfo(newVolume.GetOr(Volume));
+
+            public bool Equals(BananaHitSampleInfo? other)
+                => other != null;
+
+            public override bool Equals(object? obj)
+                => obj is BananaHitSampleInfo other && Equals(other);
+
+            public override int GetHashCode() => lookup_names.GetHashCode();
         }
     }
 }

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

@@ -9,8 +9,6 @@ namespace osu.Game.Rulesets.Catch.Objects
 {
     public class BananaShower : CatchHitObject, IHasDuration
     {
-        public override FruitVisualRepresentation VisualRepresentation => FruitVisualRepresentation.Banana;
-
         public override bool LastInCombo => true;
 
         public override Judgement CreateJudgement() => new IgnoreJudgement();

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

@@ -16,32 +16,47 @@ namespace osu.Game.Rulesets.Catch.Objects
     {
         public const float OBJECT_RADIUS = 64;
 
-        private float x;
+        // This value is after XOffset applied.
+        public readonly Bindable<float> XBindable = new Bindable<float>();
+
+        // This value is before XOffset applied.
+        private float originalX;
 
         /// <summary>
         /// The horizontal position of the fruit between 0 and <see cref="CatchPlayfield.WIDTH"/>.
         /// </summary>
         public float X
         {
-            get => x + XOffset;
-            set => x = value;
+            // TODO: I don't like this asymmetry.
+            get => XBindable.Value;
+            // originalX is set by `XBindable.BindValueChanged`
+            set => XBindable.Value = value + xOffset;
         }
 
-        /// <summary>
-        /// Whether this object can be placed on the catcher's plate.
-        /// </summary>
-        public virtual bool CanBePlated => false;
+        private float xOffset;
 
         /// <summary>
         /// A random offset applied to <see cref="X"/>, set by the <see cref="CatchBeatmapProcessor"/>.
         /// </summary>
-        internal float XOffset { get; set; }
+        internal float XOffset
+        {
+            get => xOffset;
+            set
+            {
+                xOffset = value;
+                XBindable.Value = originalX + xOffset;
+            }
+        }
 
         public double TimePreempt = 1000;
 
-        public int IndexInBeatmap { get; set; }
+        public readonly Bindable<int> IndexInBeatmapBindable = new Bindable<int>();
 
-        public virtual FruitVisualRepresentation VisualRepresentation => (FruitVisualRepresentation)(IndexInBeatmap % 4);
+        public int IndexInBeatmap
+        {
+            get => IndexInBeatmapBindable.Value;
+            set => IndexInBeatmapBindable.Value = value;
+        }
 
         public virtual bool NewCombo { get; set; }
 
@@ -63,13 +78,6 @@ namespace osu.Game.Rulesets.Catch.Objects
             set => ComboIndexBindable.Value = value;
         }
 
-        /// <summary>
-        /// Difference between the distance to the next object
-        /// and the distance that would have triggered a hyper dash.
-        /// A value close to 0 indicates a difficult jump (for difficulty calculation).
-        /// </summary>
-        public float DistanceToHyperDash { get; set; }
-
         public Bindable<bool> LastInComboBindable { get; } = new Bindable<bool>();
 
         /// <summary>
@@ -81,17 +89,19 @@ namespace osu.Game.Rulesets.Catch.Objects
             set => LastInComboBindable.Value = value;
         }
 
-        public float Scale { get; set; } = 1;
+        public readonly Bindable<float> ScaleBindable = new Bindable<float>(1);
+
+        public float Scale
+        {
+            get => ScaleBindable.Value;
+            set => ScaleBindable.Value = value;
+        }
 
         /// <summary>
-        /// Whether this fruit can initiate a hyperdash.
+        /// The seed value used for visual randomness such as fruit rotation.
+        /// The value is <see cref="HitObject.StartTime"/> truncated to an integer.
         /// </summary>
-        public bool HyperDash => HyperDashTarget != null;
-
-        /// <summary>
-        /// The target fruit if we are to initiate a hyperdash.
-        /// </summary>
-        public CatchHitObject HyperDashTarget;
+        public int RandomSeed => (int)StartTime;
 
         protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
         {
@@ -103,22 +113,10 @@ namespace osu.Game.Rulesets.Catch.Objects
         }
 
         protected override HitWindows CreateHitWindows() => HitWindows.Empty;
-    }
 
-    /// <summary>
-    /// Represents a single object that can be caught by the catcher.
-    /// </summary>
-    public abstract class PalpableCatchHitObject : CatchHitObject
-    {
-        public override bool CanBePlated => true;
-    }
-
-    public enum FruitVisualRepresentation
-    {
-        Pear,
-        Grape,
-        Pineapple,
-        Raspberry,
-        Banana // banananananannaanana
+        protected CatchHitObject()
+        {
+            XBindable.BindValueChanged(x => originalX = x.NewValue - xOffset);
+        }
     }
 }

osu.Game.Rulesets.Catch/Objects/Drawables/DrawableBanana.cs

@@ -1,26 +1,31 @@
 // 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 JetBrains.Annotations;
 using osu.Framework.Graphics;
-using osu.Framework.Utils;
-using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
     public class DrawableBanana : DrawableFruit
     {
-        public DrawableBanana(Banana h)
+        protected override FruitVisualRepresentation GetVisualRepresentation(int indexInBeatmap) => FruitVisualRepresentation.Banana;
+
+        public DrawableBanana()
+            : this(null)
+        {
+        }
+
+        public DrawableBanana([CanBeNull] Banana h)
             : base(h)
         {
         }
 
-        private Color4? colour;
-
-        protected override Color4 GetComboColour(IReadOnlyList<Color4> comboColours)
+        protected override void LoadComplete()
         {
-            // override any external colour changes with banananana
-            return colour ??= getBananaColour();
+            base.LoadComplete();
+
+            // start time affects the random seed which is used to determine the banana colour
+            StartTimeBindable.BindValueChanged(_ => UpdateComboColour());
         }
 
         protected override void UpdateInitialTransforms()
@@ -30,14 +35,14 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
             const float end_scale = 0.6f;
             const float random_scale_range = 1.6f;
 
-            ScaleContainer.ScaleTo(HitObject.Scale * (end_scale + random_scale_range * RNG.NextSingle()))
+            ScaleContainer.ScaleTo(HitObject.Scale * (end_scale + random_scale_range * RandomSingle(3)))
                           .Then().ScaleTo(HitObject.Scale * end_scale, HitObject.TimePreempt);
 
-            ScaleContainer.RotateTo(getRandomAngle())
+            ScaleContainer.RotateTo(getRandomAngle(1))
                           .Then()
-                          .RotateTo(getRandomAngle(), HitObject.TimePreempt);
+                          .RotateTo(getRandomAngle(2), HitObject.TimePreempt);
 
-            float getRandomAngle() => 180 * (RNG.NextSingle() * 2 - 1);
+            float getRandomAngle(int series) => 180 * (RandomSingle(series) * 2 - 1);
         }
 
         public override void PlaySamples()
@@ -46,20 +51,5 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
             if (Samples != null)
                 Samples.Frequency.Value = 0.77f + ((Banana)HitObject).BananaIndex * 0.006f;
         }
-
-        private Color4 getBananaColour()
-        {
-            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/Drawables/DrawableBananaShower.cs

@@ -1,26 +1,27 @@
 // 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 JetBrains.Annotations;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
-    public class DrawableBananaShower : DrawableCatchHitObject<BananaShower>
+    public class DrawableBananaShower : DrawableCatchHitObject
     {
-        private readonly Func<CatchHitObject, DrawableHitObject<CatchHitObject>> createDrawableRepresentation;
         private readonly Container bananaContainer;
 
-        public DrawableBananaShower(BananaShower s, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> createDrawableRepresentation = null)
+        public DrawableBananaShower()
+            : this(null)
+        {
+        }
+
+        public DrawableBananaShower([CanBeNull] BananaShower s)
             : base(s)
         {
-            this.createDrawableRepresentation = createDrawableRepresentation;
             RelativeSizeAxes = Axes.X;
             Origin = Anchor.BottomLeft;
-            X = 0;
 
             AddInternal(bananaContainer = new Container { RelativeSizeAxes = Axes.Both });
         }
@@ -34,18 +35,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
         protected override void ClearNestedHitObjects()
         {
             base.ClearNestedHitObjects();
-            bananaContainer.Clear();
-        }
-
-        protected override DrawableHitObject CreateNestedHitObject(HitObject hitObject)
-        {
-            switch (hitObject)
-            {
-                case Banana banana:
-                    return createDrawableRepresentation?.Invoke(banana)?.With(o => ((DrawableCatchHitObject)o).CheckPosition = p => CheckPosition?.Invoke(p) ?? false);
-            }
-
-            return base.CreateNestedHitObject(hitObject);
+            bananaContainer.Clear(false);
         }
     }
 }

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

@@ -2,76 +2,48 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
-using osu.Framework.Allocation;
+using JetBrains.Annotations;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Catch.UI;
-using osuTK;
-using osuTK.Graphics;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Utils;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
-    public abstract class PalpableDrawableCatchHitObject<TObject> : DrawableCatchHitObject<TObject>
-        where TObject : PalpableCatchHitObject
-    {
-        protected Container ScaleContainer { get; private set; }
-
-        protected PalpableDrawableCatchHitObject(TObject hitObject)
-            : base(hitObject)
-        {
-            Origin = Anchor.Centre;
-            Size = new Vector2(CatchHitObject.OBJECT_RADIUS * 2);
-            Masking = false;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            AddRangeInternal(new Drawable[]
-            {
-                ScaleContainer = new Container
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Origin = Anchor.Centre,
-                    Anchor = Anchor.Centre,
-                }
-            });
-
-            ScaleContainer.Scale = new Vector2(HitObject.Scale);
-        }
-
-        protected override Color4 GetComboColour(IReadOnlyList<Color4> comboColours) =>
-            comboColours[(HitObject.IndexInBeatmap + 1) % comboColours.Count];
-    }
-
-    public abstract class DrawableCatchHitObject<TObject> : DrawableCatchHitObject
-        where TObject : CatchHitObject
-    {
-        public new TObject HitObject;
-
-        protected DrawableCatchHitObject(TObject hitObject)
-            : base(hitObject)
-        {
-            HitObject = hitObject;
-            Anchor = Anchor.BottomLeft;
-        }
-    }
-
     public abstract class DrawableCatchHitObject : DrawableHitObject<CatchHitObject>
     {
-        public virtual bool StaysOnPlate => HitObject.CanBePlated;
+        public readonly Bindable<float> XBindable = new Bindable<float>();
 
-        public float DisplayRadius => DrawSize.X / 2 * Scale.X * HitObject.Scale;
+        protected override double InitialLifetimeOffset => HitObject.TimePreempt;
 
         protected override float SamplePlaybackPosition => HitObject.X / CatchPlayfield.WIDTH;
 
-        protected DrawableCatchHitObject(CatchHitObject hitObject)
+        public int RandomSeed => HitObject?.RandomSeed ?? 0;
+
+        protected DrawableCatchHitObject([CanBeNull] CatchHitObject hitObject)
             : base(hitObject)
         {
-            X = hitObject.X;
+            Anchor = Anchor.BottomLeft;
+        }
+
+        /// <summary>
+        /// Get a random number in range [0,1) based on seed <see cref="RandomSeed"/>.
+        /// </summary>
+        public float RandomSingle(int series) => StatelessRNG.NextSingle(RandomSeed, series);
+
+        protected override void OnApply()
+        {
+            base.OnApply();
+
+            XBindable.BindTo(HitObject.XBindable);
+        }
+
+        protected override void OnFree()
+        {
+            base.OnFree();
+
+            XBindable.UnbindFrom(HitObject.XBindable);
         }
 
         public Func<CatchHitObject, bool> CheckPosition;
@@ -88,22 +60,17 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
                 ApplyResult(r => r.Type = CheckPosition.Invoke(HitObject) ? r.Judgement.MaxResult : r.Judgement.MinResult);
         }
 
-        protected override void UpdateStateTransforms(ArmedState state)
+        protected override void UpdateHitStateTransforms(ArmedState state)
         {
-            var endTime = HitObject.GetEndTime();
-
-            using (BeginAbsoluteSequence(endTime, true))
+            switch (state)
             {
-                switch (state)
-                {
-                    case ArmedState.Miss:
-                        this.FadeOut(250).RotateTo(Rotation * 2, 250, Easing.Out);
-                        break;
+                case ArmedState.Miss:
+                    this.FadeOut(250).RotateTo(Rotation * 2, 250, Easing.Out);
+                    break;
 
-                    case ArmedState.Hit:
-                        this.FadeOut();
-                        break;
-                }
+                case ArmedState.Hit:
+                    this.FadeOut();
+                    break;
             }
         }
     }

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

@@ -1,18 +1,24 @@
 // 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 JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Utils;
+using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
-    public class DrawableDroplet : PalpableDrawableCatchHitObject<Droplet>
+    public class DrawableDroplet : DrawablePalpableCatchHitObject
     {
         public override bool StaysOnPlate => false;
 
-        public DrawableDroplet(Droplet h)
+        public DrawableDroplet()
+            : this(null)
+        {
+        }
+
+        public DrawableDroplet([CanBeNull] CatchHitObject h)
             : base(h)
         {
         }
@@ -20,7 +26,17 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
         [BackgroundDependencyLoader]
         private void load()
         {
-            ScaleContainer.Child = new SkinnableDrawable(new CatchSkinComponent(CatchSkinComponents.Droplet), _ => new DropletPiece());
+            HyperDash.BindValueChanged(_ => updatePiece(), true);
+        }
+
+        private void updatePiece()
+        {
+            ScaleContainer.Child = new SkinnableDrawable(
+                new CatchSkinComponent(CatchSkinComponents.Droplet),
+                _ => new DropletPiece
+                {
+                    HyperDash = { BindTarget = HyperDash }
+                });
         }
 
         protected override void UpdateInitialTransforms()
@@ -28,7 +44,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
             base.UpdateInitialTransforms();
 
             // roughly matches osu-stable
-            float startRotation = RNG.NextSingle() * 20;
+            float startRotation = RandomSingle(1) * 20;
             double duration = HitObject.TimePreempt + 2000;
 
             ScaleContainer.RotateTo(startRotation).RotateTo(startRotation + 720, duration);

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

@@ -2,15 +2,27 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
-using osu.Framework.Utils;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
-    public class DrawableFruit : PalpableDrawableCatchHitObject<Fruit>
+    public class DrawableFruit : DrawablePalpableCatchHitObject
     {
-        public DrawableFruit(Fruit h)
+        public readonly Bindable<FruitVisualRepresentation> VisualRepresentation = new Bindable<FruitVisualRepresentation>();
+
+        protected virtual FruitVisualRepresentation GetVisualRepresentation(int indexInBeatmap) => (FruitVisualRepresentation)(indexInBeatmap % 4);
+
+        public DrawableFruit()
+            : this(null)
+        {
+        }
+
+        public DrawableFruit([CanBeNull] Fruit h)
             : base(h)
         {
         }
@@ -18,10 +30,31 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
         [BackgroundDependencyLoader]
         private void load()
         {
-            ScaleContainer.Child = new SkinnableDrawable(
-                new CatchSkinComponent(getComponent(HitObject.VisualRepresentation)), _ => new FruitPiece());
+            IndexInBeatmap.BindValueChanged(change =>
+            {
+                VisualRepresentation.Value = GetVisualRepresentation(change.NewValue);
+            }, true);
 
-            ScaleContainer.Rotation = (float)(RNG.NextDouble() - 0.5f) * 40;
+            VisualRepresentation.BindValueChanged(_ => updatePiece());
+            HyperDash.BindValueChanged(_ => updatePiece(), true);
+        }
+
+        protected override void UpdateInitialTransforms()
+        {
+            base.UpdateInitialTransforms();
+
+            ScaleContainer.RotateTo((RandomSingle(1) - 0.5f) * 40);
+        }
+
+        private void updatePiece()
+        {
+            ScaleContainer.Child = new SkinnableDrawable(
+                new CatchSkinComponent(getComponent(VisualRepresentation.Value)),
+                _ => new FruitPiece
+                {
+                    VisualRepresentation = { BindTarget = VisualRepresentation },
+                    HyperDash = { BindTarget = HyperDash },
+                });
         }
 
         private CatchSkinComponents getComponent(FruitVisualRepresentation hitObjectVisualRepresentation)
@@ -48,4 +81,13 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
             }
         }
     }
+
+    public enum FruitVisualRepresentation
+    {
+        Pear,
+        Grape,
+        Pineapple,
+        Raspberry,
+        Banana // banananananannaanana
+    }
 }

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

@@ -1,37 +1,33 @@
 // 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 JetBrains.Annotations;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
-using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
-    public class DrawableJuiceStream : DrawableCatchHitObject<JuiceStream>
+    public class DrawableJuiceStream : DrawableCatchHitObject
     {
-        private readonly Func<CatchHitObject, DrawableHitObject<CatchHitObject>> createDrawableRepresentation;
         private readonly Container dropletContainer;
 
-        public override Vector2 OriginPosition => base.OriginPosition - new Vector2(0, CatchHitObject.OBJECT_RADIUS);
+        public DrawableJuiceStream()
+            : this(null)
+        {
+        }
 
-        public DrawableJuiceStream(JuiceStream s, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> createDrawableRepresentation = null)
+        public DrawableJuiceStream([CanBeNull] JuiceStream s)
             : base(s)
         {
-            this.createDrawableRepresentation = createDrawableRepresentation;
             RelativeSizeAxes = Axes.X;
             Origin = Anchor.BottomLeft;
-            X = 0;
 
             AddInternal(dropletContainer = new Container { RelativeSizeAxes = Axes.Both, });
         }
 
         protected override void AddNestedHitObject(DrawableHitObject hitObject)
         {
-            hitObject.Origin = Anchor.BottomCentre;
-
             base.AddNestedHitObject(hitObject);
             dropletContainer.Add(hitObject);
         }
@@ -39,19 +35,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
         protected override void ClearNestedHitObjects()
         {
             base.ClearNestedHitObjects();
-            dropletContainer.Clear();
-        }
-
-        protected override DrawableHitObject CreateNestedHitObject(HitObject hitObject)
-        {
-            switch (hitObject)
-            {
-                case CatchHitObject catchObject:
-                    return createDrawableRepresentation?.Invoke(catchObject)?.With(o =>
-                        ((DrawableCatchHitObject)o).CheckPosition = p => CheckPosition?.Invoke(p) ?? false);
-            }
-
-            throw new ArgumentException($"{nameof(hitObject)} must be of type {nameof(CatchHitObject)}.");
+            dropletContainer.Clear(false);
         }
     }
 }

osu.Game.Rulesets.Catch/Objects/Drawables/DrawablePalpableCatchHitObject.cs

@@ -0,0 +1,85 @@
+// 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 JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
+{
+    public abstract class DrawablePalpableCatchHitObject : DrawableCatchHitObject
+    {
+        public new PalpableCatchHitObject HitObject => (PalpableCatchHitObject)base.HitObject;
+
+        public readonly Bindable<bool> HyperDash = new Bindable<bool>();
+
+        public readonly Bindable<float> ScaleBindable = new Bindable<float>(1);
+
+        public readonly Bindable<int> IndexInBeatmap = new Bindable<int>();
+
+        /// <summary>
+        /// The multiplicative factor applied to <see cref="ScaleContainer"/> scale relative to <see cref="HitObject"/> scale.
+        /// </summary>
+        protected virtual float ScaleFactor => 1;
+
+        /// <summary>
+        /// Whether this hit object should stay on the catcher plate when the object is caught by the catcher.
+        /// </summary>
+        public virtual bool StaysOnPlate => true;
+
+        public float DisplayRadius => CatchHitObject.OBJECT_RADIUS * HitObject.Scale * ScaleFactor;
+
+        protected readonly Container ScaleContainer;
+
+        protected DrawablePalpableCatchHitObject([CanBeNull] CatchHitObject h)
+            : base(h)
+        {
+            Origin = Anchor.Centre;
+            Size = new Vector2(CatchHitObject.OBJECT_RADIUS * 2);
+
+            AddInternal(ScaleContainer = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Origin = Anchor.Centre,
+                Anchor = Anchor.Centre,
+            });
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            XBindable.BindValueChanged(x =>
+            {
+                if (!IsOnPlate) X = x.NewValue;
+            }, true);
+
+            ScaleBindable.BindValueChanged(scale =>
+            {
+                ScaleContainer.Scale = new Vector2(scale.NewValue * ScaleFactor);
+            }, true);
+
+            IndexInBeatmap.BindValueChanged(_ => UpdateComboColour());
+        }
+
+        protected override void OnApply()
+        {
+            base.OnApply();
+
+            HyperDash.BindTo(HitObject.HyperDashBindable);
+            ScaleBindable.BindTo(HitObject.ScaleBindable);
+            IndexInBeatmap.BindTo(HitObject.IndexInBeatmapBindable);
+        }
+
+        protected override void OnFree()
+        {
+            HyperDash.UnbindFrom(HitObject.HyperDashBindable);
+            ScaleBindable.UnbindFrom(HitObject.ScaleBindable);
+            IndexInBeatmap.UnbindFrom(HitObject.IndexInBeatmapBindable);
+
+            base.OnFree();
+        }
+    }
+}

osu.Game.Rulesets.Catch/Objects/Drawables/DrawableTinyDroplet.cs

@@ -1,21 +1,22 @@
 // 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.Allocation;
+using JetBrains.Annotations;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
     public class DrawableTinyDroplet : DrawableDroplet
     {
-        public DrawableTinyDroplet(TinyDroplet h)
-            : base(h)
+        protected override float ScaleFactor => base.ScaleFactor / 2;
+
+        public DrawableTinyDroplet()
+            : this(null)
         {
         }
 
-        [BackgroundDependencyLoader]
-        private void load()
+        public DrawableTinyDroplet([CanBeNull] TinyDroplet h)
+            : base(h)
         {
-            ScaleContainer.Scale /= 2;
         }
     }
 }

osu.Game.Rulesets.Catch/Objects/Drawables/DropletPiece.cs

@@ -1,69 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
-using osu.Game.Rulesets.Catch.UI;
-using osu.Game.Rulesets.Objects.Drawables;
-using osuTK;
-
-namespace osu.Game.Rulesets.Catch.Objects.Drawables
-{
-    public class DropletPiece : CompositeDrawable
-    {
-        public DropletPiece()
-        {
-            Size = new Vector2(CatchHitObject.OBJECT_RADIUS / 2);
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(DrawableHitObject drawableObject)
-        {
-            DrawableCatchHitObject drawableCatchObject = (DrawableCatchHitObject)drawableObject;
-            var hitObject = drawableCatchObject.HitObject;
-
-            InternalChild = new Pulp
-            {
-                RelativeSizeAxes = Axes.Both,
-                AccentColour = { BindTarget = drawableObject.AccentColour }
-            };
-
-            if (hitObject.HyperDash)
-            {
-                AddInternal(new Container
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    RelativeSizeAxes = Axes.Both,
-                    Size = new Vector2(2f),
-                    Depth = 1,
-                    Children = new Drawable[]
-                    {
-                        new Circle
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.Centre,
-                            BorderColour = Catcher.DEFAULT_HYPER_DASH_COLOUR,
-                            BorderThickness = 6,
-                            Children = new Drawable[]
-                            {
-                                new Box
-                                {
-                                    AlwaysPresent = true,
-                                    Alpha = 0.3f,
-                                    Blending = BlendingParameters.Additive,
-                                    RelativeSizeAxes = Axes.Both,
-                                    Colour = Catcher.DEFAULT_HYPER_DASH_COLOUR,
-                                }
-                            }
-                        }
-                    }
-                });
-            }
-        }
-    }
-}

osu.Game.Rulesets.Catch/Objects/Drawables/FruitPiece.cs

@@ -1,111 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Rulesets.Catch.UI;
-using osu.Game.Rulesets.Objects.Drawables;
-using osuTK.Graphics;
-
-namespace osu.Game.Rulesets.Catch.Objects.Drawables
-{
-    internal class FruitPiece : CompositeDrawable
-    {
-        /// <summary>
-        /// Because we're adding a border around the fruit, we need to scale down some.
-        /// </summary>
-        public const float RADIUS_ADJUST = 1.1f;
-
-        private Circle border;
-        private CatchHitObject hitObject;
-
-        public FruitPiece()
-        {
-            RelativeSizeAxes = Axes.Both;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(DrawableHitObject drawableObject)
-        {
-            DrawableCatchHitObject drawableCatchObject = (DrawableCatchHitObject)drawableObject;
-            hitObject = drawableCatchObject.HitObject;
-
-            AddRangeInternal(new[]
-            {
-                getFruitFor(drawableCatchObject.HitObject.VisualRepresentation),
-                border = new Circle
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    BorderColour = Color4.White,
-                    BorderThickness = 6f * RADIUS_ADJUST,
-                    Children = new Drawable[]
-                    {
-                        new Box
-                        {
-                            AlwaysPresent = true,
-                            Alpha = 0,
-                            RelativeSizeAxes = Axes.Both
-                        }
-                    }
-                },
-            });
-
-            if (hitObject.HyperDash)
-            {
-                AddInternal(new Circle
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    BorderColour = Catcher.DEFAULT_HYPER_DASH_COLOUR,
-                    BorderThickness = 12f * RADIUS_ADJUST,
-                    Children = new Drawable[]
-                    {
-                        new Box
-                        {
-                            AlwaysPresent = true,
-                            Alpha = 0.3f,
-                            Blending = BlendingParameters.Additive,
-                            RelativeSizeAxes = Axes.Both,
-                            Colour = Catcher.DEFAULT_HYPER_DASH_COLOUR,
-                        }
-                    }
-                });
-            }
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-            border.Alpha = (float)Math.Clamp((hitObject.StartTime - Time.Current) / 500, 0, 1);
-        }
-
-        private Drawable getFruitFor(FruitVisualRepresentation representation)
-        {
-            switch (representation)
-            {
-                case FruitVisualRepresentation.Pear:
-                    return new PearPiece();
-
-                case FruitVisualRepresentation.Grape:
-                    return new GrapePiece();
-
-                case FruitVisualRepresentation.Pineapple:
-                    return new PineapplePiece();
-
-                case FruitVisualRepresentation.Banana:
-                    return new BananaPiece();
-
-                case FruitVisualRepresentation.Raspberry:
-                    return new RaspberryPiece();
-            }
-
-            return Empty();
-        }
-    }
-}

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/BananaPiece.cs

@@ -2,10 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
 using osuTK;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawables
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
 {
     public class BananaPiece : PulpFormation
     {

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/BorderPiece.cs

@@ -0,0 +1,31 @@
+// 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.Framework.Graphics.Shapes;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
+{
+    public class BorderPiece : Circle
+    {
+        public BorderPiece()
+        {
+            Size = new Vector2(CatchHitObject.OBJECT_RADIUS * 2);
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+            BorderColour = Color4.White;
+            BorderThickness = 6f * FruitPiece.RADIUS_ADJUST;
+
+            // Border is drawn only when there is a child drawable.
+            Child = new Box
+            {
+                AlwaysPresent = true,
+                Alpha = 0,
+                RelativeSizeAxes = Axes.Both,
+            };
+        }
+    }
+}
+

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/DropletPiece.cs

@@ -0,0 +1,37 @@
+// 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.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Objects.Drawables;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
+{
+    public class DropletPiece : CompositeDrawable
+    {
+        public readonly Bindable<bool> HyperDash = new Bindable<bool>();
+
+        public DropletPiece()
+        {
+            Size = new Vector2(CatchHitObject.OBJECT_RADIUS / 2);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(DrawableHitObject drawableObject)
+        {
+            InternalChild = new Pulp
+            {
+                RelativeSizeAxes = Axes.Both,
+                AccentColour = { BindTarget = drawableObject.AccentColour }
+            };
+
+            if (HyperDash.Value)
+            {
+                AddInternal(new HyperDropletBorderPiece());
+            }
+        }
+    }
+}

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/FruitPiece.cs

@@ -0,0 +1,79 @@
+// 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 JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
+{
+    internal class FruitPiece : CompositeDrawable
+    {
+        /// <summary>
+        /// Because we're adding a border around the fruit, we need to scale down some.
+        /// </summary>
+        public const float RADIUS_ADJUST = 1.1f;
+
+        public readonly Bindable<FruitVisualRepresentation> VisualRepresentation = new Bindable<FruitVisualRepresentation>();
+        public readonly Bindable<bool> HyperDash = new Bindable<bool>();
+
+        [CanBeNull]
+        private DrawableCatchHitObject drawableHitObject;
+
+        [CanBeNull]
+        private BorderPiece borderPiece;
+
+        public FruitPiece()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader(permitNulls: true)]
+        private void load([CanBeNull] DrawableHitObject drawable)
+        {
+            drawableHitObject = (DrawableCatchHitObject)drawable;
+
+            AddInternal(getFruitFor(VisualRepresentation.Value));
+
+            // if it is not part of a DHO, the border is always invisible.
+            if (drawableHitObject != null)
+                AddInternal(borderPiece = new BorderPiece());
+
+            if (HyperDash.Value)
+                AddInternal(new HyperBorderPiece());
+        }
+
+        protected override void Update()
+        {
+            if (borderPiece != null && drawableHitObject?.HitObject != null)
+                borderPiece.Alpha = (float)Math.Clamp((drawableHitObject.HitObject.StartTime - Time.Current) / 500, 0, 1);
+        }
+
+        private Drawable getFruitFor(FruitVisualRepresentation representation)
+        {
+            switch (representation)
+            {
+                case FruitVisualRepresentation.Pear:
+                    return new PearPiece();
+
+                case FruitVisualRepresentation.Grape:
+                    return new GrapePiece();
+
+                case FruitVisualRepresentation.Pineapple:
+                    return new PineapplePiece();
+
+                case FruitVisualRepresentation.Banana:
+                    return new BananaPiece();
+
+                case FruitVisualRepresentation.Raspberry:
+                    return new RaspberryPiece();
+            }
+
+            return Empty();
+        }
+    }
+}

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/GrapePiece.cs

@@ -2,10 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
 using osuTK;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawables
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
 {
     public class GrapePiece : PulpFormation
     {

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/HyperBorderPiece.cs

@@ -0,0 +1,22 @@
+// 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.Catch.UI;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
+{
+    public class HyperBorderPiece : BorderPiece
+    {
+        public HyperBorderPiece()
+        {
+            BorderColour = Catcher.DEFAULT_HYPER_DASH_COLOUR;
+            BorderThickness = 12f * FruitPiece.RADIUS_ADJUST;
+
+            Child.Alpha = 0.3f;
+            Child.Blending = BlendingParameters.Additive;
+            Child.Colour = Catcher.DEFAULT_HYPER_DASH_COLOUR;
+        }
+    }
+}
+

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/HyperDropletBorderPiece.cs

@@ -0,0 +1,14 @@
+// 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.
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
+{
+    public class HyperDropletBorderPiece : HyperBorderPiece
+    {
+        public HyperDropletBorderPiece()
+        {
+            Size /= 2;
+            BorderThickness = 6f;
+        }
+    }
+}

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/PearPiece.cs

@@ -2,10 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
 using osuTK;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawables
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
 {
     public class PearPiece : PulpFormation
     {

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/PineapplePiece.cs

@@ -2,10 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
 using osuTK;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawables
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
 {
     public class PineapplePiece : PulpFormation
     {

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/PulpFormation.cs

@@ -10,7 +10,7 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawables
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
 {
     public abstract class PulpFormation : CompositeDrawable
     {

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/RaspberryPiece.cs

@@ -2,10 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
 using osuTK;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawables
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
 {
     public class RaspberryPiece : PulpFormation
     {

osu.Game.Rulesets.Catch/Objects/JuiceStream.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 System.Threading;
@@ -49,13 +50,9 @@ namespace osu.Game.Rulesets.Catch.Objects
         {
             base.CreateNestedHitObjects(cancellationToken);
 
-            var dropletSamples = Samples.Select(s => new HitSampleInfo
-            {
-                Bank = s.Bank,
-                Name = @"slidertick",
-                Volume = s.Volume
-            }).ToList();
+            var dropletSamples = Samples.Select(s => s.With(@"slidertick")).ToList();
 
+            int nodeIndex = 0;
             SliderEventDescriptor? lastEvent = null;
 
             foreach (var e in SliderEventGenerator.Generate(StartTime, SpanDuration, Velocity, TickDistance, Path.Distance, this.SpanCount(), LegacyLastTickOffset, cancellationToken))
@@ -105,7 +102,7 @@ namespace osu.Game.Rulesets.Catch.Objects
                     case SliderEventType.Repeat:
                         AddNested(new Fruit
                         {
-                            Samples = Samples,
+                            Samples = this.GetNodeSamples(nodeIndex++),
                             StartTime = e.Time,
                             X = X + Path.PositionAt(e.PathProgress).X,
                         });
@@ -119,7 +116,7 @@ namespace osu.Game.Rulesets.Catch.Objects
         public double Duration
         {
             get => this.SpanCount() * Path.Distance / Velocity;
-            set => throw new System.NotSupportedException($"Adjust via {nameof(RepeatCount)} instead"); // can be implemented if/when needed.
+            set => throw new NotSupportedException($"Adjust via {nameof(RepeatCount)} instead"); // can be implemented if/when needed.
         }
 
         public double EndTime => StartTime + Duration;

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

@@ -0,0 +1,48 @@
+// 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.Bindables;
+using osu.Game.Rulesets.Objects.Types;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Objects
+{
+    /// <summary>
+    /// Represents a single object that can be caught by the catcher.
+    /// This includes normal fruits, droplets, and bananas but excludes objects that act only as a container of nested hit objects.
+    /// </summary>
+    public abstract class PalpableCatchHitObject : CatchHitObject, IHasComboInformation
+    {
+        /// <summary>
+        /// Difference between the distance to the next object
+        /// and the distance that would have triggered a hyper dash.
+        /// A value close to 0 indicates a difficult jump (for difficulty calculation).
+        /// </summary>
+        public float DistanceToHyperDash { get; set; }
+
+        public readonly Bindable<bool> HyperDashBindable = new Bindable<bool>();
+
+        /// <summary>
+        /// Whether this fruit can initiate a hyperdash.
+        /// </summary>
+        public bool HyperDash => HyperDashBindable.Value;
+
+        private CatchHitObject hyperDashTarget;
+
+        /// <summary>
+        /// The target fruit if we are to initiate a hyperdash.
+        /// </summary>
+        public CatchHitObject HyperDashTarget
+        {
+            get => hyperDashTarget;
+            set
+            {
+                hyperDashTarget = value;
+                HyperDashBindable.Value = value != null;
+            }
+        }
+
+        Color4 IHasComboInformation.GetComboColour(IReadOnlyList<Color4> comboColours) => comboColours[(IndexInBeatmap + 1) % comboColours.Count];
+    }
+}

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

@@ -40,7 +40,7 @@ namespace osu.Game.Rulesets.Catch.Replays
             float lastPosition = CatchPlayfield.CENTER_X;
             double lastTime = 0;
 
-            void moveToNext(CatchHitObject h)
+            void moveToNext(PalpableCatchHitObject h)
             {
                 float positionChange = Math.Abs(lastPosition - h.X);
                 double timeAvailable = h.StartTime - lastTime;
@@ -101,23 +101,16 @@ namespace osu.Game.Rulesets.Catch.Replays
 
             foreach (var obj in Beatmap.HitObjects)
             {
-                switch (obj)
+                if (obj is PalpableCatchHitObject palpableObject)
                 {
-                    case Fruit _:
-                        moveToNext(obj);
-                        break;
+                    moveToNext(palpableObject);
                 }
 
                 foreach (var nestedObj in obj.NestedHitObjects.Cast<CatchHitObject>())
                 {
-                    switch (nestedObj)
+                    if (nestedObj is PalpableCatchHitObject palpableNestedObject)
                     {
-                        case Banana _:
-                        case TinyDroplet _:
-                        case Droplet _:
-                        case Fruit _:
-                            moveToNext(nestedObj);
-                            break;
+                        moveToNext(palpableNestedObject);
                     }
                 }
             }

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

@@ -52,7 +52,7 @@ namespace osu.Game.Rulesets.Catch.Replays
                 if (Position > lastCatchFrame.Position)
                     lastCatchFrame.Actions.Add(CatchAction.MoveRight);
                 else if (Position < lastCatchFrame.Position)
-                    Actions.Add(CatchAction.MoveLeft);
+                    lastCatchFrame.Actions.Add(CatchAction.MoveLeft);
             }
         }
 

osu.Game.Rulesets.Catch/Skinning/CatchLegacySkinTransformer.cs

@@ -13,6 +13,11 @@ namespace osu.Game.Rulesets.Catch.Skinning
 {
     public class CatchLegacySkinTransformer : LegacySkinTransformer
     {
+        /// <summary>
+        /// For simplicity, let's use legacy combo font texture existence as a way to identify legacy skins from default.
+        /// </summary>
+        private bool providesComboCounter => this.HasFont(GetConfig<LegacySetting, string>(LegacySetting.ComboPrefix)?.Value ?? "score");
+
         public CatchLegacySkinTransformer(ISkinSource source)
             : base(source)
         {
@@ -20,6 +25,16 @@ namespace osu.Game.Rulesets.Catch.Skinning
 
         public override Drawable GetDrawableComponent(ISkinComponent component)
         {
+            if (component is HUDSkinComponent hudComponent)
+            {
+                switch (hudComponent.Component)
+                {
+                    case HUDSkinComponents.ComboCounter:
+                        // catch may provide its own combo counter; hide the default.
+                        return providesComboCounter ? Drawable.Empty() : null;
+                }
+            }
+
             if (!(component is CatchSkinComponent catchSkinComponent))
                 return null;
 
@@ -55,11 +70,9 @@ namespace osu.Game.Rulesets.Catch.Skinning
                            this.GetAnimation("fruit-ryuuta", true, true, true);
 
                 case CatchSkinComponents.CatchComboCounter:
-                    var comboFont = GetConfig<LegacySetting, string>(LegacySetting.ComboPrefix)?.Value ?? "score";
 
-                    // For simplicity, let's use legacy combo font texture existence as a way to identify legacy skins from default.
-                    if (this.HasFont(comboFont))
-                        return new LegacyComboCounter(Source);
+                    if (providesComboCounter)
+                        return new LegacyCatchComboCounter(Source);
 
                     break;
             }

osu.Game.Rulesets.Catch/Skinning/LegacyCatchComboCounter.cs

@@ -14,13 +14,13 @@ namespace osu.Game.Rulesets.Catch.Skinning
     /// <summary>
     /// A combo counter implementation that visually behaves almost similar to stable's osu!catch combo counter.
     /// </summary>
-    public class LegacyComboCounter : CompositeDrawable, ICatchComboCounter
+    public class LegacyCatchComboCounter : CompositeDrawable, ICatchComboCounter
     {
         private readonly LegacyRollingCounter counter;
 
         private readonly LegacyRollingCounter explosion;
 
-        public LegacyComboCounter(ISkin skin)
+        public LegacyCatchComboCounter(ISkin skin)
         {
             var fontName = skin.GetConfig<LegacySetting, string>(LegacySetting.ComboPrefix)?.Value ?? "score";
             var fontOverlap = skin.GetConfig<LegacySetting, float>(LegacySetting.ComboOverlap)?.Value ?? -2f;

osu.Game.Rulesets.Catch/Skinning/LegacyFruitPiece.cs

@@ -19,7 +19,8 @@ namespace osu.Game.Rulesets.Catch.Skinning
     {
         private readonly string lookupName;
 
-        private readonly IBindable<Color4> accentColour = new Bindable<Color4>();
+        private readonly Bindable<Color4> accentColour = new Bindable<Color4>();
+        private readonly Bindable<bool> hyperDash = new Bindable<bool>();
         private Sprite colouredSprite;
 
         public LegacyFruitPiece(string lookupName)
@@ -31,9 +32,10 @@ namespace osu.Game.Rulesets.Catch.Skinning
         [BackgroundDependencyLoader]
         private void load(DrawableHitObject drawableObject, ISkinSource skin)
         {
-            DrawableCatchHitObject drawableCatchObject = (DrawableCatchHitObject)drawableObject;
+            var drawableCatchObject = (DrawablePalpableCatchHitObject)drawableObject;
 
             accentColour.BindTo(drawableCatchObject.AccentColour);
+            hyperDash.BindTo(drawableCatchObject.HyperDash);
 
             InternalChildren = new Drawable[]
             {
@@ -51,9 +53,9 @@ namespace osu.Game.Rulesets.Catch.Skinning
                 },
             };
 
-            if (drawableCatchObject.HitObject.HyperDash)
+            if (hyperDash.Value)
             {
-                var hyperDash = new Sprite
+                var hyperDashOverlay = new Sprite
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -67,7 +69,7 @@ namespace osu.Game.Rulesets.Catch.Skinning
                              Catcher.DEFAULT_HYPER_DASH_COLOUR,
                 };
 
-                AddInternal(hyperDash);
+                AddInternal(hyperDashOverlay);
             }
         }
 

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
@@ -35,41 +36,53 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public CatchPlayfield(BeatmapDifficulty difficulty, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> createDrawableRepresentation)
         {
-            var explodingFruitContainer = new Container
+            var droppedObjectContainer = new Container
             {
                 RelativeSizeAxes = Axes.Both,
             };
 
-            CatcherArea = new CatcherArea(difficulty)
+            CatcherArea = new CatcherArea(droppedObjectContainer, difficulty)
             {
-                CreateDrawableRepresentation = createDrawableRepresentation,
-                ExplodingFruitTarget = explodingFruitContainer,
                 Anchor = Anchor.BottomLeft,
                 Origin = Anchor.TopLeft,
             };
 
             InternalChildren = new[]
             {
-                explodingFruitContainer,
+                droppedObjectContainer,
                 CatcherArea.MovableCatcher.CreateProxiedContent(),
                 HitObjectContainer,
                 CatcherArea,
             };
         }
 
-        public bool CheckIfWeCanCatch(CatchHitObject obj) => CatcherArea.AttemptCatch(obj);
-
-        public override void Add(DrawableHitObject h)
+        [BackgroundDependencyLoader]
+        private void load()
         {
-            h.OnNewResult += onNewResult;
-            h.OnRevertResult += onRevertResult;
-
-            base.Add(h);
-
-            var fruit = (DrawableCatchHitObject)h;
-            fruit.CheckPosition = CheckIfWeCanCatch;
+            RegisterPool<Droplet, DrawableDroplet>(50);
+            RegisterPool<TinyDroplet, DrawableTinyDroplet>(50);
+            RegisterPool<Fruit, DrawableFruit>(100);
+            RegisterPool<Banana, DrawableBanana>(100);
+            RegisterPool<JuiceStream, DrawableJuiceStream>(10);
+            RegisterPool<BananaShower, DrawableBananaShower>(2);
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            // these subscriptions need to be done post constructor to ensure externally bound components have a chance to populate required fields (ScoreProcessor / ComboAtJudgement in this case).
+            NewResult += onNewResult;
+            RevertResult += onRevertResult;
+        }
+
+        protected override void OnNewDrawableHitObject(DrawableHitObject d)
+        {
+            ((DrawableCatchHitObject)d).CheckPosition = checkIfWeCanCatch;
+        }
+
+        private bool checkIfWeCanCatch(CatchHitObject obj) => CatcherArea.AttemptCatch(obj);
+
         private void onNewResult(DrawableHitObject judgedObject, JudgementResult result)
             => CatcherArea.OnNewResult((DrawableCatchHitObject)judgedObject, result);
 

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

@@ -9,6 +9,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Pooling;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
@@ -16,7 +17,6 @@ using osu.Game.Configuration;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.Skinning;
-using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Skinning;
 using osuTK;
 using osuTK.Graphics;
@@ -46,19 +46,15 @@ namespace osu.Game.Rulesets.Catch.UI
         /// </summary>
         public const double BASE_SPEED = 1.0;
 
-        public Container ExplodingFruitTarget;
-
-        private Container<DrawableHitObject> caughtFruitContainer { get; } = new Container<DrawableHitObject>
-        {
-            Anchor = Anchor.TopCentre,
-            Origin = Anchor.BottomCentre,
-        };
-
         [NotNull]
         private readonly Container trailsTarget;
 
         private CatcherTrailDisplay trails;
 
+        private readonly Container droppedObjectTarget;
+
+        private readonly Container<DrawablePalpableCatchHitObject> caughtFruitContainer;
+
         public CatcherAnimationState CurrentState { get; private set; }
 
         /// <summary>
@@ -91,9 +87,9 @@ namespace osu.Game.Rulesets.Catch.UI
         /// </summary>
         private readonly float catchWidth;
 
-        private CatcherSprite catcherIdle;
-        private CatcherSprite catcherKiai;
-        private CatcherSprite catcherFail;
+        private readonly CatcherSprite catcherIdle;
+        private readonly CatcherSprite catcherKiai;
+        private readonly CatcherSprite catcherFail;
 
         private CatcherSprite currentCatcher;
 
@@ -107,9 +103,13 @@ namespace osu.Game.Rulesets.Catch.UI
         private float hyperDashTargetPosition;
         private Bindable<bool> hitLighting;
 
-        public Catcher([NotNull] Container trailsTarget, BeatmapDifficulty difficulty = null)
+        private readonly DrawablePool<HitExplosion> hitExplosionPool;
+        private readonly Container<HitExplosion> hitExplosionContainer;
+
+        public Catcher([NotNull] Container trailsTarget, [NotNull] Container droppedObjectTarget, BeatmapDifficulty difficulty = null)
         {
             this.trailsTarget = trailsTarget;
+            this.droppedObjectTarget = droppedObjectTarget;
 
             Origin = Anchor.TopCentre;
 
@@ -118,16 +118,15 @@ namespace osu.Game.Rulesets.Catch.UI
                 Scale = calculateScale(difficulty);
 
             catchWidth = CalculateCatchWidth(Scale);
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
-        {
-            hitLighting = config.GetBindable<bool>(OsuSetting.HitLighting);
 
             InternalChildren = new Drawable[]
             {
-                caughtFruitContainer,
+                hitExplosionPool = new DrawablePool<HitExplosion>(10),
+                caughtFruitContainer = new Container<DrawablePalpableCatchHitObject>
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.BottomCentre,
+                },
                 catcherIdle = new CatcherSprite(CatcherAnimationState.Idle)
                 {
                     Anchor = Anchor.TopCentre,
@@ -142,14 +141,32 @@ namespace osu.Game.Rulesets.Catch.UI
                 {
                     Anchor = Anchor.TopCentre,
                     Alpha = 0,
-                }
+                },
+                hitExplosionContainer = new Container<HitExplosion>
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.BottomCentre,
+                },
             };
+        }
 
-            trailsTarget.Add(trails = new CatcherTrailDisplay(this));
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config)
+        {
+            hitLighting = config.GetBindable<bool>(OsuSetting.HitLighting);
+            trails = new CatcherTrailDisplay(this);
 
             updateCatcher();
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            // don't add in above load as we may potentially modify a parent in an unsafe manner.
+            trailsTarget.Add(trails);
+        }
+
         /// <summary>
         /// Creates proxied content to be displayed beneath hitobjects.
         /// </summary>
@@ -158,65 +175,28 @@ namespace osu.Game.Rulesets.Catch.UI
         /// <summary>
         /// Calculates the scale of the catcher based off the provided beatmap difficulty.
         /// </summary>
-        private static Vector2 calculateScale(BeatmapDifficulty difficulty)
-            => new Vector2(1.0f - 0.7f * (difficulty.CircleSize - 5) / 5);
+        private static Vector2 calculateScale(BeatmapDifficulty difficulty) => new Vector2(1.0f - 0.7f * (difficulty.CircleSize - 5) / 5);
 
         /// <summary>
         /// Calculates the width of the area used for attempting catches in gameplay.
         /// </summary>
         /// <param name="scale">The scale of the catcher.</param>
-        internal static float CalculateCatchWidth(Vector2 scale)
-            => CatcherArea.CATCHER_SIZE * Math.Abs(scale.X) * ALLOWED_CATCH_RANGE;
+        internal static float CalculateCatchWidth(Vector2 scale) => CatcherArea.CATCHER_SIZE * Math.Abs(scale.X) * ALLOWED_CATCH_RANGE;
 
         /// <summary>
         /// Calculates the width of the area used for attempting catches in gameplay.
         /// </summary>
         /// <param name="difficulty">The beatmap difficulty.</param>
-        internal static float CalculateCatchWidth(BeatmapDifficulty difficulty)
-            => CalculateCatchWidth(calculateScale(difficulty));
-
-        /// <summary>
-        /// Add a caught fruit to the catcher's stack.
-        /// </summary>
-        /// <param name="fruit">The fruit that was caught.</param>
-        public void PlaceOnPlate(DrawableCatchHitObject fruit)
-        {
-            var ourRadius = fruit.DisplayRadius;
-            float theirRadius = 0;
-
-            const float allowance = 10;
-
-            while (caughtFruitContainer.Any(f =>
-                f.LifetimeEnd == double.MaxValue &&
-                Vector2Extensions.Distance(f.Position, fruit.Position) < (ourRadius + (theirRadius = f.DrawSize.X / 2 * f.Scale.X)) / (allowance / 2)))
-            {
-                var diff = (ourRadius + theirRadius) / allowance;
-                fruit.X += (RNG.NextSingle() - 0.5f) * diff * 2;
-                fruit.Y -= RNG.NextSingle() * diff;
-            }
-
-            fruit.X = Math.Clamp(fruit.X, -CatcherArea.CATCHER_SIZE / 2, CatcherArea.CATCHER_SIZE / 2);
-
-            caughtFruitContainer.Add(fruit);
-
-            if (hitLighting.Value)
-            {
-                AddInternal(new HitExplosion(fruit)
-                {
-                    X = fruit.X,
-                    Scale = new Vector2(fruit.HitObject.Scale)
-                });
-            }
-        }
+        internal static float CalculateCatchWidth(BeatmapDifficulty difficulty) => CalculateCatchWidth(calculateScale(difficulty));
 
         /// <summary>
         /// Let the catcher attempt to catch a fruit.
         /// </summary>
-        /// <param name="fruit">The fruit to catch.</param>
+        /// <param name="hitObject">The fruit to catch.</param>
         /// <returns>Whether the catch is possible.</returns>
-        public bool AttemptCatch(CatchHitObject fruit)
+        public bool AttemptCatch(CatchHitObject hitObject)
         {
-            if (!fruit.CanBePlated)
+            if (!(hitObject is PalpableCatchHitObject fruit))
                 return false;
 
             var halfCatchWidth = catchWidth * 0.5f;
@@ -229,7 +209,10 @@ namespace osu.Game.Rulesets.Catch.UI
                 catchObjectPosition >= catcherPosition - halfCatchWidth &&
                 catchObjectPosition <= catcherPosition + halfCatchWidth;
 
-            // only update hyperdash state if we are not catching a tiny droplet.
+            if (validCatch)
+                placeCaughtObject(fruit);
+
+            // droplet doesn't affect the catcher state
             if (fruit is TinyDroplet) return validCatch;
 
             if (validCatch && fruit.HyperDash)
@@ -283,24 +266,17 @@ namespace osu.Game.Rulesets.Catch.UI
             }
         }
 
-        private void runHyperDashStateTransition(bool hyperDashing)
+        public void UpdatePosition(float position)
         {
-            updateTrailVisibility();
+            position = Math.Clamp(position, 0, CatchPlayfield.WIDTH);
 
-            if (hyperDashing)
-            {
-                this.FadeColour(hyperDashColour, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
-                this.FadeTo(0.2f, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
-            }
-            else
-            {
-                this.FadeColour(Color4.White, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
-                this.FadeTo(1f, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
-            }
+            if (position == X)
+                return;
+
+            Scale = new Vector2(Math.Abs(Scale.X) * (position > X ? 1 : -1), Scale.Y);
+            X = position;
         }
 
-        private void updateTrailVisibility() => trails.DisplayTrail = Dashing || HyperDashing;
-
         public bool OnPressed(CatchAction action)
         {
             switch (action)
@@ -339,56 +315,34 @@ namespace osu.Game.Rulesets.Catch.UI
             }
         }
 
-        public void UpdatePosition(float position)
-        {
-            position = Math.Clamp(position, 0, CatchPlayfield.WIDTH);
-
-            if (position == X)
-                return;
-
-            Scale = new Vector2(Math.Abs(Scale.X) * (position > X ? 1 : -1), Scale.Y);
-            X = position;
-        }
-
         /// <summary>
         /// Drop any fruit off the plate.
         /// </summary>
-        public void Drop()
-        {
-            foreach (var f in caughtFruitContainer.ToArray())
-                Drop(f);
-        }
+        public void Drop() => clearPlate(DroppedObjectAnimation.Drop);
 
         /// <summary>
-        /// Explode any fruit off the plate.
+        /// Explode all fruit off the plate.
         /// </summary>
-        public void Explode()
-        {
-            foreach (var f in caughtFruitContainer.ToArray())
-                Explode(f);
-        }
+        public void Explode() => clearPlate(DroppedObjectAnimation.Explode);
 
-        public void Drop(DrawableHitObject fruit)
+        private void runHyperDashStateTransition(bool hyperDashing)
         {
-            removeFromPlateWithTransform(fruit, f =>
+            updateTrailVisibility();
+
+            if (hyperDashing)
             {
-                f.MoveToY(f.Y + 75, 750, Easing.InSine);
-                f.FadeOut(750);
-            });
-        }
-
-        public void Explode(DrawableHitObject fruit)
-        {
-            var originalX = fruit.X * Scale.X;
-
-            removeFromPlateWithTransform(fruit, f =>
+                this.FadeColour(hyperDashColour, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
+                this.FadeTo(0.2f, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
+            }
+            else
             {
-                f.MoveToY(f.Y - 50, 250, Easing.OutSine).Then().MoveToY(f.Y + 50, 500, Easing.InSine);
-                f.MoveToX(f.X + originalX * 6, 1000);
-                f.FadeOut(750);
-            });
+                this.FadeColour(Color4.White, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
+                this.FadeTo(1f, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
+            }
         }
 
+        private void updateTrailVisibility() => trails.DisplayTrail = Dashing || HyperDashing;
+
         protected override void SkinChanged(ISkinSource skin, bool allowFallback)
         {
             base.SkinChanged(skin, allowFallback);
@@ -461,33 +415,143 @@ namespace osu.Game.Rulesets.Catch.UI
             updateCatcher();
         }
 
-        private void removeFromPlateWithTransform(DrawableHitObject fruit, Action<DrawableHitObject> action)
+        private void placeCaughtObject(PalpableCatchHitObject source)
         {
-            if (ExplodingFruitTarget != null)
+            var caughtObject = createCaughtObject(source);
+
+            if (caughtObject == null) return;
+
+            caughtObject.RelativePositionAxes = Axes.None;
+            caughtObject.X = source.X - X;
+            caughtObject.IsOnPlate = true;
+
+            caughtObject.Anchor = Anchor.TopCentre;
+            caughtObject.Origin = Anchor.Centre;
+            caughtObject.Scale *= 0.5f;
+            caughtObject.LifetimeStart = source.StartTime;
+            caughtObject.LifetimeEnd = double.MaxValue;
+
+            adjustPositionInStack(caughtObject);
+
+            caughtFruitContainer.Add(caughtObject);
+
+            addLighting(caughtObject);
+
+            if (!caughtObject.StaysOnPlate)
+                removeFromPlate(caughtObject, DroppedObjectAnimation.Explode);
+        }
+
+        private void adjustPositionInStack(DrawablePalpableCatchHitObject caughtObject)
+        {
+            const float radius_div_2 = CatchHitObject.OBJECT_RADIUS / 2;
+            const float allowance = 10;
+
+            float caughtObjectRadius = caughtObject.DisplayRadius;
+
+            while (caughtFruitContainer.Any(f => Vector2Extensions.Distance(f.Position, caughtObject.Position) < (caughtObjectRadius + radius_div_2) / (allowance / 2)))
             {
-                fruit.Anchor = Anchor.TopLeft;
-                fruit.Position = caughtFruitContainer.ToSpaceOfOtherDrawable(fruit.DrawPosition, ExplodingFruitTarget);
+                float diff = (caughtObjectRadius + radius_div_2) / allowance;
 
-                if (!caughtFruitContainer.Remove(fruit))
-                    // we may have already been removed by a previous operation (due to the weird OnLoadComplete scheduling).
-                    // this avoids a crash on potentially attempting to Add a fruit to ExplodingFruitTarget twice.
-                    return;
-
-                ExplodingFruitTarget.Add(fruit);
+                caughtObject.X += (RNG.NextSingle() - 0.5f) * diff * 2;
+                caughtObject.Y -= RNG.NextSingle() * diff;
             }
 
-            var actionTime = Clock.CurrentTime;
+            caughtObject.X = Math.Clamp(caughtObject.X, -CatcherArea.CATCHER_SIZE / 2, CatcherArea.CATCHER_SIZE / 2);
+        }
 
-            fruit.ApplyCustomUpdateState += onFruitOnApplyCustomUpdateState;
-            onFruitOnApplyCustomUpdateState(fruit, fruit.State.Value);
+        private void addLighting(DrawablePalpableCatchHitObject caughtObject)
+        {
+            if (!hitLighting.Value) return;
 
-            void onFruitOnApplyCustomUpdateState(DrawableHitObject o, ArmedState state)
+            HitExplosion hitExplosion = hitExplosionPool.Get();
+            hitExplosion.X = caughtObject.X;
+            hitExplosion.Scale = new Vector2(caughtObject.HitObject.Scale);
+            hitExplosion.ObjectColour = caughtObject.AccentColour.Value;
+            hitExplosionContainer.Add(hitExplosion);
+        }
+
+        private DrawablePalpableCatchHitObject createCaughtObject(PalpableCatchHitObject source)
+        {
+            switch (source)
             {
-                using (fruit.BeginAbsoluteSequence(actionTime))
-                    action(fruit);
+                case Banana banana:
+                    return new DrawableBanana(banana);
 
-                fruit.Expire();
+                case Fruit fruit:
+                    return new DrawableFruit(fruit);
+
+                case TinyDroplet tiny:
+                    return new DrawableTinyDroplet(tiny);
+
+                case Droplet droplet:
+                    return new DrawableDroplet(droplet);
+
+                default:
+                    return null;
             }
         }
+
+        private void clearPlate(DroppedObjectAnimation animation)
+        {
+            var caughtObjects = caughtFruitContainer.Children.ToArray();
+            caughtFruitContainer.Clear(false);
+
+            droppedObjectTarget.AddRange(caughtObjects);
+
+            foreach (var caughtObject in caughtObjects)
+                drop(caughtObject, animation);
+        }
+
+        private void removeFromPlate(DrawablePalpableCatchHitObject caughtObject, DroppedObjectAnimation animation)
+        {
+            if (!caughtFruitContainer.Remove(caughtObject))
+                throw new InvalidOperationException("Can only drop a caught object on the plate");
+
+            droppedObjectTarget.Add(caughtObject);
+
+            drop(caughtObject, animation);
+        }
+
+        private void drop(DrawablePalpableCatchHitObject d, DroppedObjectAnimation animation)
+        {
+            var originalX = d.X * Scale.X;
+            var startTime = Clock.CurrentTime;
+
+            d.Anchor = Anchor.TopLeft;
+            d.Position = caughtFruitContainer.ToSpaceOfOtherDrawable(d.DrawPosition, droppedObjectTarget);
+
+            // we cannot just apply the transforms because DHO clears transforms when state is updated
+            d.ApplyCustomUpdateState += (o, state) => animate(o, animation, originalX, startTime);
+            if (d.IsLoaded)
+                animate(d, animation, originalX, startTime);
+        }
+
+        private void animate(Drawable d, DroppedObjectAnimation animation, float originalX, double startTime)
+        {
+            using (d.BeginAbsoluteSequence(startTime))
+            {
+                switch (animation)
+                {
+                    case DroppedObjectAnimation.Drop:
+                        d.MoveToY(d.Y + 75, 750, Easing.InSine);
+                        d.FadeOut(750);
+                        break;
+
+                    case DroppedObjectAnimation.Explode:
+                        d.MoveToY(d.Y - 50, 250, Easing.OutSine).Then().MoveToY(d.Y + 50, 500, Easing.InSine);
+                        d.MoveToX(d.X + originalX * 6, 1000);
+                        d.FadeOut(750);
+                        break;
+                }
+
+                d.Expire();
+            }
+        }
+
+        private enum DroppedObjectAnimation
+        {
+            Drop,
+            Explode
+        }
     }
 }

osu.Game.Rulesets.Catch/UI/CatcherArea.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.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
@@ -10,7 +9,6 @@ using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 using osuTK;
@@ -21,19 +19,10 @@ namespace osu.Game.Rulesets.Catch.UI
     {
         public const float CATCHER_SIZE = 106.75f;
 
-        public Func<CatchHitObject, DrawableHitObject<CatchHitObject>> CreateDrawableRepresentation;
-
         public readonly Catcher MovableCatcher;
         private readonly CatchComboDisplay comboDisplay;
 
-        public Container ExplodingFruitTarget
-        {
-            set => MovableCatcher.ExplodingFruitTarget = value;
-        }
-
-        private DrawableCatchHitObject lastPlateableFruit;
-
-        public CatcherArea(BeatmapDifficulty difficulty = null)
+        public CatcherArea(Container droppedObjectContainer, BeatmapDifficulty difficulty = null)
         {
             Size = new Vector2(CatchPlayfield.WIDTH, CATCHER_SIZE);
             Children = new Drawable[]
@@ -47,70 +36,29 @@ namespace osu.Game.Rulesets.Catch.UI
                     Margin = new MarginPadding { Bottom = 350f },
                     X = CatchPlayfield.CENTER_X
                 },
-                MovableCatcher = new Catcher(this, difficulty) { X = CatchPlayfield.CENTER_X },
+                MovableCatcher = new Catcher(this, droppedObjectContainer, difficulty) { X = CatchPlayfield.CENTER_X },
             };
         }
 
-        public void OnNewResult(DrawableCatchHitObject fruit, JudgementResult result)
+        public void OnNewResult(DrawableCatchHitObject hitObject, JudgementResult result)
         {
             if (!result.Type.IsScorable())
                 return;
 
-            void runAfterLoaded(Action action)
-            {
-                if (lastPlateableFruit == null)
-                    return;
-
-                // this is required to make this run after the last caught fruit runs updateState() at least once.
-                // TODO: find a better alternative
-                if (lastPlateableFruit.IsLoaded)
-                    action();
-                else
-                    lastPlateableFruit.OnLoadComplete += _ => action();
-            }
-
-            if (result.IsHit && fruit.HitObject.CanBePlated)
-            {
-                // create a new (cloned) fruit to stay on the plate. the original is faded out immediately.
-                var caughtFruit = (DrawableCatchHitObject)CreateDrawableRepresentation?.Invoke(fruit.HitObject);
-
-                if (caughtFruit == null) return;
-
-                caughtFruit.RelativePositionAxes = Axes.None;
-                caughtFruit.Position = new Vector2(MovableCatcher.ToLocalSpace(fruit.ScreenSpaceDrawQuad.Centre).X - MovableCatcher.DrawSize.X / 2, 0);
-                caughtFruit.IsOnPlate = true;
-
-                caughtFruit.Anchor = Anchor.TopCentre;
-                caughtFruit.Origin = Anchor.Centre;
-                caughtFruit.Scale *= 0.5f;
-                caughtFruit.LifetimeStart = caughtFruit.HitObject.StartTime;
-                caughtFruit.LifetimeEnd = double.MaxValue;
-
-                MovableCatcher.PlaceOnPlate(caughtFruit);
-                lastPlateableFruit = caughtFruit;
-
-                if (!fruit.StaysOnPlate)
-                    runAfterLoaded(() => MovableCatcher.Explode(caughtFruit));
-            }
-
-            if (fruit.HitObject.LastInCombo)
+            if (hitObject.HitObject.LastInCombo)
             {
                 if (result.Judgement is CatchJudgement catchJudgement && catchJudgement.ShouldExplodeFor(result))
-                    runAfterLoaded(() => MovableCatcher.Explode());
+                    MovableCatcher.Explode();
                 else
                     MovableCatcher.Drop();
             }
 
-            comboDisplay.OnNewResult(fruit, result);
+            comboDisplay.OnNewResult(hitObject, result);
         }
 
         public void OnRevertResult(DrawableCatchHitObject fruit, JudgementResult result)
             => comboDisplay.OnRevertResult(fruit, result);
 
-        public void OnReleased(CatchAction action)
-        {
-        }
-
         public bool AttemptCatch(CatchHitObject obj)
         {
             return MovableCatcher.AttemptCatch(obj);

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

@@ -8,7 +8,6 @@ using osu.Game.Configuration;
 using osu.Game.Input.Handlers;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Catch.Objects;
-using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -40,30 +39,6 @@ namespace osu.Game.Rulesets.Catch.UI
 
         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, CreateDrawableRepresentation);
-
-                case BananaShower shower:
-                    return new DrawableBananaShower(shower, CreateDrawableRepresentation);
-
-                case TinyDroplet tiny:
-                    return new DrawableTinyDroplet(tiny);
-
-                case Droplet droplet:
-                    return new DrawableDroplet(droplet);
-            }
-
-            return null;
-        }
+        public override DrawableHitObject<CatchHitObject> CreateDrawableRepresentation(CatchHitObject h) => null;
     }
 }

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

@@ -5,35 +5,43 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
+using osu.Framework.Graphics.Pooling;
 using osu.Framework.Utils;
-using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
-    public class HitExplosion : CompositeDrawable
+    public class HitExplosion : PoolableDrawable
     {
-        private readonly CircularContainer largeFaint;
+        private Color4 objectColour;
 
-        public HitExplosion(DrawableCatchHitObject fruit)
+        public Color4 ObjectColour
+        {
+            get => objectColour;
+            set
+            {
+                if (objectColour == value) return;
+
+                objectColour = value;
+                onColourChanged();
+            }
+        }
+
+        private readonly CircularContainer largeFaint;
+        private readonly CircularContainer smallFaint;
+        private readonly CircularContainer directionalGlow1;
+        private readonly CircularContainer directionalGlow2;
+
+        public HitExplosion()
         {
             Size = new Vector2(20);
             Anchor = Anchor.TopCentre;
             Origin = Anchor.BottomCentre;
 
-            Color4 objectColour = fruit.AccentColour.Value;
-
             // scale roughly in-line with visual appearance of notes
-
-            const float angle_variangle = 15; // should be less than 45
-
-            const float roundness = 100;
-
             const float initial_height = 10;
 
-            var colour = Interpolation.ValueAt(0.4f, objectColour, Color4.White, 0, 1);
-
             InternalChildren = new Drawable[]
             {
                 largeFaint = new CircularContainer
@@ -42,33 +50,17 @@ namespace osu.Game.Rulesets.Catch.UI
                     Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.Both,
                     Masking = true,
-                    // we want our size to be very small so the glow dominates it.
-                    Size = new Vector2(0.8f),
                     Blending = BlendingParameters.Additive,
-                    EdgeEffect = new EdgeEffectParameters
-                    {
-                        Type = EdgeEffectType.Glow,
-                        Colour = Interpolation.ValueAt(0.1f, objectColour, Color4.White, 0, 1).Opacity(0.3f),
-                        Roundness = 160,
-                        Radius = 200,
-                    },
                 },
-                new CircularContainer
+                smallFaint = new CircularContainer
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.Both,
                     Masking = true,
                     Blending = BlendingParameters.Additive,
-                    EdgeEffect = new EdgeEffectParameters
-                    {
-                        Type = EdgeEffectType.Glow,
-                        Colour = Interpolation.ValueAt(0.6f, objectColour, Color4.White, 0, 1),
-                        Roundness = 20,
-                        Radius = 50,
-                    },
                 },
-                new CircularContainer
+                directionalGlow1 = new CircularContainer
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -76,16 +68,8 @@ namespace osu.Game.Rulesets.Catch.UI
                     Masking = true,
                     Size = new Vector2(0.01f, initial_height),
                     Blending = BlendingParameters.Additive,
-                    Rotation = RNG.NextSingle(-angle_variangle, angle_variangle),
-                    EdgeEffect = new EdgeEffectParameters
-                    {
-                        Type = EdgeEffectType.Glow,
-                        Colour = colour,
-                        Roundness = roundness,
-                        Radius = 40,
-                    },
                 },
-                new CircularContainer
+                directionalGlow2 = new CircularContainer
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -93,30 +77,57 @@ namespace osu.Game.Rulesets.Catch.UI
                     Masking = true,
                     Size = new Vector2(0.01f, initial_height),
                     Blending = BlendingParameters.Additive,
-                    Rotation = RNG.NextSingle(-angle_variangle, angle_variangle),
-                    EdgeEffect = new EdgeEffectParameters
-                    {
-                        Type = EdgeEffectType.Glow,
-                        Colour = colour,
-                        Roundness = roundness,
-                        Radius = 40,
-                    },
                 }
             };
         }
 
-        protected override void LoadComplete()
+        protected override void PrepareForUse()
         {
-            base.LoadComplete();
+            base.PrepareForUse();
 
             const double duration = 400;
 
+            // we want our size to be very small so the glow dominates it.
+            largeFaint.Size = new Vector2(0.8f);
             largeFaint
                 .ResizeTo(largeFaint.Size * new Vector2(5, 1), duration, Easing.OutQuint)
                 .FadeOut(duration * 2);
 
+            const float angle_variangle = 15; // should be less than 45
+            directionalGlow1.Rotation = RNG.NextSingle(-angle_variangle, angle_variangle);
+            directionalGlow2.Rotation = RNG.NextSingle(-angle_variangle, angle_variangle);
+
             this.FadeInFromZero(50).Then().FadeOut(duration, Easing.Out);
             Expire(true);
         }
+
+        private void onColourChanged()
+        {
+            const float roundness = 100;
+
+            largeFaint.EdgeEffect = new EdgeEffectParameters
+            {
+                Type = EdgeEffectType.Glow,
+                Colour = Interpolation.ValueAt(0.1f, objectColour, Color4.White, 0, 1).Opacity(0.3f),
+                Roundness = 160,
+                Radius = 200,
+            };
+
+            smallFaint.EdgeEffect = new EdgeEffectParameters
+            {
+                Type = EdgeEffectType.Glow,
+                Colour = Interpolation.ValueAt(0.6f, objectColour, Color4.White, 0, 1),
+                Roundness = 20,
+                Radius = 50,
+            };
+
+            directionalGlow1.EdgeEffect = directionalGlow2.EdgeEffect = new EdgeEffectParameters
+            {
+                Type = EdgeEffectType.Glow,
+                Colour = Interpolation.ValueAt(0.4f, objectColour, Color4.White, 0, 1),
+                Roundness = roundness,
+                Radius = 40,
+            };
+        }
     }
 }

osu.Game.Rulesets.Mania.Tests/.vscode/tasks.json

@@ -9,11 +9,10 @@
             "command": "dotnet",
             "args": [
                 "build",
-                "--no-restore",
                 "osu.Game.Rulesets.Mania.Tests.csproj",
-                "/p:GenerateFullPaths=true",
-                "/m",
-                "/verbosity:m"
+                "-p:GenerateFullPaths=true",
+                "-m",
+                "-verbosity:m"
             ],
             "group": "build",
             "problemMatcher": "$msCompile"
@@ -24,24 +23,14 @@
             "command": "dotnet",
             "args": [
                 "build",
-                "--no-restore",
                 "osu.Game.Rulesets.Mania.Tests.csproj",
-                "/p:Configuration=Release",
-                "/p:GenerateFullPaths=true",
-                "/m",
-                "/verbosity:m"
+                "-p:Configuration=Release",
+                "-p:GenerateFullPaths=true",
+                "-m",
+                "-verbosity:m"
             ],
             "group": "build",
             "problemMatcher": "$msCompile"
-        },
-        {
-            "label": "Restore",
-            "type": "shell",
-            "command": "dotnet",
-            "args": [
-                "restore"
-            ],
-            "problemMatcher": []
         }
     ]
 }

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaBeatSnapGrid.cs

@@ -96,6 +96,11 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
             throw new System.NotImplementedException();
         }
 
+        public override SnapResult SnapScreenSpacePositionToValidPosition(Vector2 screenSpacePosition)
+        {
+            throw new System.NotImplementedException();
+        }
+
         public override float GetBeatSnapDistanceAt(double referenceTime)
         {
             throw new System.NotImplementedException();

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

@@ -83,11 +83,17 @@ namespace osu.Game.Rulesets.Mania.Tests
             RandomZ = snapshot.RandomZ;
         }
 
+        public override void PostProcess()
+        {
+            base.PostProcess();
+            Objects.Sort();
+        }
+
         public bool Equals(ManiaConvertMapping other) => other != null && RandomW == other.RandomW && RandomX == other.RandomX && RandomY == other.RandomY && RandomZ == other.RandomZ;
         public override bool Equals(ConvertMapping<ConvertValue> other) => base.Equals(other) && Equals(other as ManiaConvertMapping);
     }
 
-    public struct ConvertValue : IEquatable<ConvertValue>
+    public struct ConvertValue : IEquatable<ConvertValue>, IComparable<ConvertValue>
     {
         /// <summary>
         /// A sane value to account for osu!stable using ints everwhere.
@@ -102,5 +108,15 @@ namespace osu.Game.Rulesets.Mania.Tests
             => Precision.AlmostEquals(StartTime, other.StartTime, conversion_lenience)
                && Precision.AlmostEquals(EndTime, other.EndTime, conversion_lenience)
                && Column == other.Column;
+
+        public int CompareTo(ConvertValue other)
+        {
+            var result = StartTime.CompareTo(other.StartTime);
+
+            if (result != 0)
+                return result;
+
+            return Column.CompareTo(other.Column);
+        }
     }
 }

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

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

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

@@ -12,19 +12,44 @@ namespace osu.Game.Rulesets.Mania.Tests
     [TestFixture]
     public class ManiaLegacyModConversionTest : LegacyModConversionTest
     {
-        [TestCase(LegacyMods.Easy, new[] { typeof(ManiaModEasy) })]
-        [TestCase(LegacyMods.HardRock | LegacyMods.DoubleTime, new[] { typeof(ManiaModHardRock), typeof(ManiaModDoubleTime) })]
-        [TestCase(LegacyMods.DoubleTime, new[] { typeof(ManiaModDoubleTime) })]
-        [TestCase(LegacyMods.Nightcore, new[] { typeof(ManiaModNightcore) })]
+        private static readonly object[][] mania_mod_mapping =
+        {
+            new object[] { LegacyMods.NoFail, new[] { typeof(ManiaModNoFail) } },
+            new object[] { LegacyMods.Easy, new[] { typeof(ManiaModEasy) } },
+            new object[] { LegacyMods.Hidden, new[] { typeof(ManiaModHidden) } },
+            new object[] { LegacyMods.HardRock, new[] { typeof(ManiaModHardRock) } },
+            new object[] { LegacyMods.SuddenDeath, new[] { typeof(ManiaModSuddenDeath) } },
+            new object[] { LegacyMods.DoubleTime, new[] { typeof(ManiaModDoubleTime) } },
+            new object[] { LegacyMods.HalfTime, new[] { typeof(ManiaModHalfTime) } },
+            new object[] { LegacyMods.Nightcore, new[] { typeof(ManiaModNightcore) } },
+            new object[] { LegacyMods.Flashlight, new[] { typeof(ManiaModFlashlight) } },
+            new object[] { LegacyMods.Autoplay, new[] { typeof(ManiaModAutoplay) } },
+            new object[] { LegacyMods.Perfect, new[] { typeof(ManiaModPerfect) } },
+            new object[] { LegacyMods.Key4, new[] { typeof(ManiaModKey4) } },
+            new object[] { LegacyMods.Key5, new[] { typeof(ManiaModKey5) } },
+            new object[] { LegacyMods.Key6, new[] { typeof(ManiaModKey6) } },
+            new object[] { LegacyMods.Key7, new[] { typeof(ManiaModKey7) } },
+            new object[] { LegacyMods.Key8, new[] { typeof(ManiaModKey8) } },
+            new object[] { LegacyMods.FadeIn, new[] { typeof(ManiaModFadeIn) } },
+            new object[] { LegacyMods.Random, new[] { typeof(ManiaModRandom) } },
+            new object[] { LegacyMods.Cinema, new[] { typeof(ManiaModCinema) } },
+            new object[] { LegacyMods.Key9, new[] { typeof(ManiaModKey9) } },
+            new object[] { LegacyMods.KeyCoop, new[] { typeof(ManiaModDualStages) } },
+            new object[] { LegacyMods.Key1, new[] { typeof(ManiaModKey1) } },
+            new object[] { LegacyMods.Key3, new[] { typeof(ManiaModKey3) } },
+            new object[] { LegacyMods.Key2, new[] { typeof(ManiaModKey2) } },
+            new object[] { LegacyMods.Mirror, new[] { typeof(ManiaModMirror) } },
+            new object[] { LegacyMods.HardRock | LegacyMods.DoubleTime, new[] { typeof(ManiaModHardRock), typeof(ManiaModDoubleTime) } }
+        };
+
+        [TestCaseSource(nameof(mania_mod_mapping))]
+        [TestCase(LegacyMods.Cinema | LegacyMods.Autoplay, new[] { typeof(ManiaModCinema) })]
         [TestCase(LegacyMods.Nightcore | LegacyMods.DoubleTime, new[] { typeof(ManiaModNightcore) })]
-        [TestCase(LegacyMods.Flashlight | LegacyMods.Nightcore | LegacyMods.DoubleTime, new[] { typeof(ManiaModFlashlight), typeof(ManiaModNightcore) })]
-        [TestCase(LegacyMods.Perfect, new[] { typeof(ManiaModPerfect) })]
-        [TestCase(LegacyMods.SuddenDeath, new[] { typeof(ManiaModSuddenDeath) })]
         [TestCase(LegacyMods.Perfect | LegacyMods.SuddenDeath, new[] { typeof(ManiaModPerfect) })]
-        [TestCase(LegacyMods.Perfect | LegacyMods.SuddenDeath | LegacyMods.DoubleTime, new[] { typeof(ManiaModDoubleTime), typeof(ManiaModPerfect) })]
-        [TestCase(LegacyMods.Random | LegacyMods.SuddenDeath, new[] { typeof(ManiaModRandom), typeof(ManiaModSuddenDeath) })]
-        [TestCase(LegacyMods.Flashlight | LegacyMods.Mirror, new[] { typeof(ManiaModFlashlight), typeof(ManiaModMirror) })]
-        public new void Test(LegacyMods legacyMods, Type[] expectedMods) => base.Test(legacyMods, expectedMods);
+        public new void TestFromLegacy(LegacyMods legacyMods, Type[] expectedMods) => base.TestFromLegacy(legacyMods, expectedMods);
+
+        [TestCaseSource(nameof(mania_mod_mapping))]
+        public new void TestToLegacy(LegacyMods legacyMods, Type[] givenMods) => base.TestToLegacy(legacyMods, givenMods);
 
         protected override Ruleset CreateRuleset() => new ManiaRuleset();
     }

osu.Game.Rulesets.Mania.Tests/Skinning/ManiaHitObjectTestScene.cs

@@ -1,7 +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 osu.Framework.Allocation;
+using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
@@ -15,8 +15,8 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
     /// </summary>
     public abstract class ManiaHitObjectTestScene : ManiaSkinnableTestScene
     {
-        [BackgroundDependencyLoader]
-        private void load()
+        [SetUp]
+        public void SetUp() => Schedule(() =>
         {
             SetContents(() => new FillFlowContainer
             {
@@ -65,7 +65,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
                     },
                 }
             });
-        }
+        });
 
         protected abstract DrawableManiaHitObject CreateHitObject();
     }

osu.Game.Rulesets.Mania.Tests/Skinning/TestSceneDrawableJudgement.cs

@@ -24,7 +24,10 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
                 if (hitWindows.IsHitResultAllowed(result))
                 {
                     AddStep("Show " + result.GetDescription(), () => SetContents(() =>
-                        new DrawableManiaJudgement(new JudgementResult(new HitObject(), new Judgement()) { Type = result }, null)
+                        new DrawableManiaJudgement(new JudgementResult(new HitObject { StartTime = Time.Current }, new Judgement())
+                        {
+                            Type = result
+                        }, null)
                         {
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,

osu.Game.Rulesets.Mania.Tests/Skinning/TestSceneHoldNote.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 System.Linq;
 using NUnit.Framework;
 using osu.Framework.Bindables;
@@ -26,6 +27,18 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
             });
         }
 
+        [Test]
+        public void TestFadeOnMiss()
+        {
+            AddStep("miss tick", () =>
+            {
+                foreach (var holdNote in holdNotes)
+                    holdNote.ChildrenOfType<DrawableHoldNoteHead>().First().MissForcefully();
+            });
+        }
+
+        private IEnumerable<DrawableHoldNote> holdNotes => CreatedDrawables.SelectMany(d => d.ChildrenOfType<DrawableHoldNote>());
+
         protected override DrawableManiaHitObject CreateHitObject()
         {
             var note = new HoldNote { Duration = 1000 };

osu.Game.Rulesets.Mania.Tests/TestSceneOutOfOrderHits.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;
@@ -35,6 +36,7 @@ namespace osu.Game.Rulesets.Mania.Tests
 
                 objects.Add(new Note { StartTime = time });
 
+                // don't hit the first note
                 if (i > 0)
                 {
                     frames.Add(new ManiaReplayFrame(time + 10, ManiaAction.Key1));
@@ -53,12 +55,77 @@ namespace osu.Game.Rulesets.Mania.Tests
             }
         }
 
+        [Test]
+        public void TestHoldNoteMissAfterNextObjectStartTime()
+        {
+            var objects = new List<ManiaHitObject>
+            {
+                new HoldNote
+                {
+                    StartTime = 1000,
+                    EndTime = 1010,
+                },
+                new HoldNote
+                {
+                    StartTime = 1020,
+                    EndTime = 1030
+                }
+            };
+
+            performTest(objects, new List<ReplayFrame>());
+
+            addJudgementAssert(objects[0], HitResult.IgnoreHit);
+            addJudgementAssert(objects[1], HitResult.IgnoreHit);
+        }
+
+        [Test]
+        public void TestHoldNoteReleasedHitAfterNextObjectStartTime()
+        {
+            var objects = new List<ManiaHitObject>
+            {
+                new HoldNote
+                {
+                    StartTime = 1000,
+                    EndTime = 1010,
+                },
+                new HoldNote
+                {
+                    StartTime = 1020,
+                    EndTime = 1030
+                }
+            };
+
+            var frames = new List<ReplayFrame>
+            {
+                new ManiaReplayFrame(1000, ManiaAction.Key1),
+                new ManiaReplayFrame(1030),
+                new ManiaReplayFrame(1040, ManiaAction.Key1),
+                new ManiaReplayFrame(1050)
+            };
+
+            performTest(objects, frames);
+
+            addJudgementAssert(objects[0], HitResult.IgnoreHit);
+            addJudgementAssert("first head", () => ((HoldNote)objects[0]).Head, HitResult.Perfect);
+            addJudgementAssert("first tail", () => ((HoldNote)objects[0]).Tail, HitResult.Perfect);
+
+            addJudgementAssert(objects[1], HitResult.IgnoreHit);
+            addJudgementAssert("second head", () => ((HoldNote)objects[1]).Head, HitResult.Great);
+            addJudgementAssert("second tail", () => ((HoldNote)objects[1]).Tail, HitResult.Perfect);
+        }
+
         private void addJudgementAssert(ManiaHitObject hitObject, HitResult result)
         {
             AddAssert($"({hitObject.GetType().ReadableName()} @ {hitObject.StartTime}) judgement is {result}",
                 () => judgementResults.Single(r => r.HitObject == hitObject).Type == result);
         }
 
+        private void addJudgementAssert(string name, Func<ManiaHitObject> hitObject, HitResult result)
+        {
+            AddAssert($"{name} judgement is {result}",
+                () => judgementResults.Single(r => r.HitObject == hitObject()).Type == result);
+        }
+
         private void addJudgementOffsetAssert(ManiaHitObject hitObject, double offset)
         {
             AddAssert($"({hitObject.GetType().ReadableName()} @ {hitObject.StartTime}) judged at {offset}",

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

@@ -2,7 +2,7 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

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

@@ -21,13 +21,20 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         /// </summary>
         public int TotalColumns => Stages.Sum(g => g.Columns);
 
+        /// <summary>
+        /// The total number of columns that were present in this <see cref="ManiaBeatmap"/> before any user adjustments.
+        /// </summary>
+        public readonly int OriginalTotalColumns;
+
         /// <summary>
         /// Creates a new <see cref="ManiaBeatmap"/>.
         /// </summary>
         /// <param name="defaultStage">The initial stages.</param>
-        public ManiaBeatmap(StageDefinition defaultStage)
+        /// <param name="originalTotalColumns">The total number of columns present before any user adjustments. Defaults to the total columns in <paramref name="defaultStage"/>.</param>
+        public ManiaBeatmap(StageDefinition defaultStage, int? originalTotalColumns = null)
         {
             Stages.Add(defaultStage);
+            OriginalTotalColumns = originalTotalColumns ?? defaultStage.Columns;
         }
 
         public override IEnumerable<BeatmapStatistic> GetStatistics()

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

@@ -28,6 +28,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         public bool Dual;
         public readonly bool IsForCurrentRuleset;
 
+        private readonly int originalTargetColumns;
+
         // Internal for testing purposes
         internal FastRandom Random { get; private set; }
 
@@ -65,6 +67,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
                 else
                     TargetColumns = Math.Max(4, Math.Min((int)roundedOverallDifficulty + 1, 7));
             }
+
+            originalTargetColumns = TargetColumns;
         }
 
         public override bool CanConvert() => Beatmap.HitObjects.All(h => h is IHasXPosition);
@@ -81,7 +85,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
 
         protected override Beatmap<ManiaHitObject> CreateBeatmap()
         {
-            beatmap = new ManiaBeatmap(new StageDefinition { Columns = TargetColumns });
+            beatmap = new ManiaBeatmap(new StageDefinition { Columns = TargetColumns }, originalTargetColumns);
 
             if (Dual)
                 beatmap.Stages.Add(new StageDefinition { Columns = TargetColumns });
@@ -116,7 +120,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
                 prevNoteTimes.RemoveAt(0);
             prevNoteTimes.Add(newNoteTime);
 
-            density = (prevNoteTimes[^1] - prevNoteTimes[0]) / prevNoteTimes.Count;
+            if (prevNoteTimes.Count >= 2)
+                density = (prevNoteTimes[^1] - prevNoteTimes[0]) / prevNoteTimes.Count;
         }
 
         private double lastTime;
@@ -180,7 +185,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
 
                 case IHasDuration endTimeData:
                 {
-                    conversion = new EndTimeObjectPatternGenerator(Random, original, beatmap, originalBeatmap);
+                    conversion = new EndTimeObjectPatternGenerator(Random, original, beatmap, lastPattern, originalBeatmap);
 
                     recordNote(endTimeData.EndTime, new Vector2(256, 192));
                     computeDensity(endTimeData.EndTime);

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

@@ -3,8 +3,8 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
-using osu.Framework.Utils;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.MathUtils;
@@ -12,6 +12,7 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Beatmaps.Formats;
 
 namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 {
@@ -25,8 +26,9 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// </summary>
         private const float osu_base_scoring_distance = 100;
 
-        public readonly double EndTime;
-        public readonly double SegmentDuration;
+        public readonly int StartTime;
+        public readonly int EndTime;
+        public readonly int SegmentDuration;
         public readonly int SpanCount;
 
         private PatternType convertType;
@@ -41,20 +43,26 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             var distanceData = hitObject as IHasDistance;
             var repeatsData = hitObject as IHasRepeats;
 
-            SpanCount = repeatsData?.SpanCount() ?? 1;
+            Debug.Assert(distanceData != null);
 
             TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(hitObject.StartTime);
             DifficultyControlPoint difficultyPoint = beatmap.ControlPointInfo.DifficultyPointAt(hitObject.StartTime);
 
-            // The true distance, accounting for any repeats
-            double distance = (distanceData?.Distance ?? 0) * SpanCount;
-            // The velocity of the osu! hit object - calculated as the velocity of a slider
-            double osuVelocity = osu_base_scoring_distance * beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier * difficultyPoint.SpeedMultiplier / timingPoint.BeatLength;
-            // The duration of the osu! hit object
-            double osuDuration = distance / osuVelocity;
+            double beatLength;
+#pragma warning disable 618
+            if (difficultyPoint is LegacyBeatmapDecoder.LegacyDifficultyControlPoint legacyDifficultyPoint)
+#pragma warning restore 618
+                beatLength = timingPoint.BeatLength * legacyDifficultyPoint.BpmMultiplier;
+            else
+                beatLength = timingPoint.BeatLength / difficultyPoint.SpeedMultiplier;
 
-            EndTime = hitObject.StartTime + osuDuration;
-            SegmentDuration = (EndTime - HitObject.StartTime) / SpanCount;
+            SpanCount = repeatsData?.SpanCount() ?? 1;
+            StartTime = (int)Math.Round(hitObject.StartTime);
+
+            // This matches stable's calculation.
+            EndTime = (int)Math.Floor(StartTime + distanceData.Distance * beatLength * SpanCount * 0.01 / beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier);
+
+            SegmentDuration = (EndTime - StartTime) / SpanCount;
         }
 
         public override IEnumerable<Pattern> Generate()
@@ -76,7 +84,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             foreach (var obj in originalPattern.HitObjects)
             {
-                if (!Precision.AlmostEquals(EndTime, obj.GetEndTime()))
+                if (EndTime != (int)Math.Round(obj.GetEndTime()))
                     intermediatePattern.Add(obj);
                 else
                     endTimePattern.Add(obj);
@@ -91,35 +99,35 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             if (TotalColumns == 1)
             {
                 var pattern = new Pattern();
-                addToPattern(pattern, 0, HitObject.StartTime, EndTime);
+                addToPattern(pattern, 0, StartTime, EndTime);
                 return pattern;
             }
 
             if (SpanCount > 1)
             {
                 if (SegmentDuration <= 90)
-                    return generateRandomHoldNotes(HitObject.StartTime, 1);
+                    return generateRandomHoldNotes(StartTime, 1);
 
                 if (SegmentDuration <= 120)
                 {
                     convertType |= PatternType.ForceNotStack;
-                    return generateRandomNotes(HitObject.StartTime, SpanCount + 1);
+                    return generateRandomNotes(StartTime, SpanCount + 1);
                 }
 
                 if (SegmentDuration <= 160)
-                    return generateStair(HitObject.StartTime);
+                    return generateStair(StartTime);
 
                 if (SegmentDuration <= 200 && ConversionDifficulty > 3)
-                    return generateRandomMultipleNotes(HitObject.StartTime);
+                    return generateRandomMultipleNotes(StartTime);
 
-                double duration = EndTime - HitObject.StartTime;
+                double duration = EndTime - StartTime;
                 if (duration >= 4000)
-                    return generateNRandomNotes(HitObject.StartTime, 0.23, 0, 0);
+                    return generateNRandomNotes(StartTime, 0.23, 0, 0);
 
                 if (SegmentDuration > 400 && SpanCount < TotalColumns - 1 - RandomStart)
-                    return generateTiledHoldNotes(HitObject.StartTime);
+                    return generateTiledHoldNotes(StartTime);
 
-                return generateHoldAndNormalNotes(HitObject.StartTime);
+                return generateHoldAndNormalNotes(StartTime);
             }
 
             if (SegmentDuration <= 110)
@@ -128,37 +136,37 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                     convertType |= PatternType.ForceNotStack;
                 else
                     convertType &= ~PatternType.ForceNotStack;
-                return generateRandomNotes(HitObject.StartTime, SegmentDuration < 80 ? 1 : 2);
+                return generateRandomNotes(StartTime, SegmentDuration < 80 ? 1 : 2);
             }
 
             if (ConversionDifficulty > 6.5)
             {
                 if (convertType.HasFlag(PatternType.LowProbability))
-                    return generateNRandomNotes(HitObject.StartTime, 0.78, 0.3, 0);
+                    return generateNRandomNotes(StartTime, 0.78, 0.3, 0);
 
-                return generateNRandomNotes(HitObject.StartTime, 0.85, 0.36, 0.03);
+                return generateNRandomNotes(StartTime, 0.85, 0.36, 0.03);
             }
 
             if (ConversionDifficulty > 4)
             {
                 if (convertType.HasFlag(PatternType.LowProbability))
-                    return generateNRandomNotes(HitObject.StartTime, 0.43, 0.08, 0);
+                    return generateNRandomNotes(StartTime, 0.43, 0.08, 0);
 
-                return generateNRandomNotes(HitObject.StartTime, 0.56, 0.18, 0);
+                return generateNRandomNotes(StartTime, 0.56, 0.18, 0);
             }
 
             if (ConversionDifficulty > 2.5)
             {
                 if (convertType.HasFlag(PatternType.LowProbability))
-                    return generateNRandomNotes(HitObject.StartTime, 0.3, 0, 0);
+                    return generateNRandomNotes(StartTime, 0.3, 0, 0);
 
-                return generateNRandomNotes(HitObject.StartTime, 0.37, 0.08, 0);
+                return generateNRandomNotes(StartTime, 0.37, 0.08, 0);
             }
 
             if (convertType.HasFlag(PatternType.LowProbability))
-                return generateNRandomNotes(HitObject.StartTime, 0.17, 0, 0);
+                return generateNRandomNotes(StartTime, 0.17, 0, 0);
 
-            return generateNRandomNotes(HitObject.StartTime, 0.27, 0, 0);
+            return generateNRandomNotes(StartTime, 0.27, 0, 0);
         }
 
         /// <summary>
@@ -167,7 +175,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// <param name="startTime">Start time of each hold note.</param>
         /// <param name="noteCount">Number of hold notes.</param>
         /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
-        private Pattern generateRandomHoldNotes(double startTime, int noteCount)
+        private Pattern generateRandomHoldNotes(int startTime, int noteCount)
         {
             // - - - -
             // ■ - ■ ■
@@ -202,7 +210,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// <param name="startTime">The start time.</param>
         /// <param name="noteCount">The number of notes.</param>
         /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
-        private Pattern generateRandomNotes(double startTime, int noteCount)
+        private Pattern generateRandomNotes(int startTime, int noteCount)
         {
             // - - - -
             // x - - -
@@ -234,7 +242,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// </summary>
         /// <param name="startTime">The start time.</param>
         /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
-        private Pattern generateStair(double startTime)
+        private Pattern generateStair(int startTime)
         {
             // - - - -
             // x - - -
@@ -286,7 +294,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// </summary>
         /// <param name="startTime">The start time.</param>
         /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
-        private Pattern generateRandomMultipleNotes(double startTime)
+        private Pattern generateRandomMultipleNotes(int startTime)
         {
             // - - - -
             // x - - -
@@ -329,7 +337,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// <param name="p3">The probability required for 3 hold notes to be generated.</param>
         /// <param name="p4">The probability required for 4 hold notes to be generated.</param>
         /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
-        private Pattern generateNRandomNotes(double startTime, double p2, double p3, double p4)
+        private Pattern generateNRandomNotes(int startTime, double p2, double p3, double p4)
         {
             // - - - -
             // ■ - ■ ■
@@ -366,7 +374,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             static bool isDoubleSample(HitSampleInfo sample) => sample.Name == HitSampleInfo.HIT_CLAP || sample.Name == HitSampleInfo.HIT_FINISH;
 
             bool canGenerateTwoNotes = !convertType.HasFlag(PatternType.LowProbability);
-            canGenerateTwoNotes &= HitObject.Samples.Any(isDoubleSample) || sampleInfoListAt(HitObject.StartTime).Any(isDoubleSample);
+            canGenerateTwoNotes &= HitObject.Samples.Any(isDoubleSample) || sampleInfoListAt(StartTime).Any(isDoubleSample);
 
             if (canGenerateTwoNotes)
                 p2 = 1;
@@ -379,7 +387,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// </summary>
         /// <param name="startTime">The first hold note start time.</param>
         /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
-        private Pattern generateTiledHoldNotes(double startTime)
+        private Pattern generateTiledHoldNotes(int startTime)
         {
             // - - - -
             // ■ ■ ■ ■
@@ -394,6 +402,9 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             int columnRepeat = Math.Min(SpanCount, TotalColumns);
 
+            // Due to integer rounding, this is not guaranteed to be the same as EndTime (the class-level variable).
+            int endTime = startTime + SegmentDuration * SpanCount;
+
             int nextColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
             if (convertType.HasFlag(PatternType.ForceNotStack) && PreviousPattern.ColumnWithObjects < TotalColumns)
                 nextColumn = FindAvailableColumn(nextColumn, PreviousPattern);
@@ -401,7 +412,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             for (int i = 0; i < columnRepeat; i++)
             {
                 nextColumn = FindAvailableColumn(nextColumn, pattern);
-                addToPattern(pattern, nextColumn, startTime, EndTime);
+                addToPattern(pattern, nextColumn, startTime, endTime);
                 startTime += SegmentDuration;
             }
 
@@ -413,7 +424,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// </summary>
         /// <param name="startTime">The start time of notes.</param>
         /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
-        private Pattern generateHoldAndNormalNotes(double startTime)
+        private Pattern generateHoldAndNormalNotes(int startTime)
         {
             // - - - -
             // ■ x x -
@@ -448,7 +459,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             for (int i = 0; i <= SpanCount; i++)
             {
-                if (!(ignoreHead && startTime == HitObject.StartTime))
+                if (!(ignoreHead && startTime == StartTime))
                 {
                     for (int j = 0; j < noteCount; j++)
                     {
@@ -471,19 +482,18 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// </summary>
         /// <param name="time">The time to retrieve the sample info list from.</param>
         /// <returns></returns>
-        private IList<HitSampleInfo> sampleInfoListAt(double time) => nodeSamplesAt(time)?.First() ?? HitObject.Samples;
+        private IList<HitSampleInfo> sampleInfoListAt(int time) => nodeSamplesAt(time)?.First() ?? HitObject.Samples;
 
         /// <summary>
         /// Retrieves the list of node samples that occur at time greater than or equal to <paramref name="time"/>.
         /// </summary>
         /// <param name="time">The time to retrieve node samples at.</param>
-        private List<IList<HitSampleInfo>> nodeSamplesAt(double time)
+        private List<IList<HitSampleInfo>> nodeSamplesAt(int time)
         {
             if (!(HitObject is IHasPathWithRepeats curveData))
                 return null;
 
-            // mathematically speaking this should be a whole number always, but floating-point arithmetic is not so kind
-            var index = (int)Math.Round(SegmentDuration == 0 ? 0 : (time - HitObject.StartTime) / SegmentDuration, MidpointRounding.AwayFromZero);
+            var index = SegmentDuration == 0 ? 0 : (time - StartTime) / SegmentDuration;
 
             // avoid slicing the list & creating copies, if at all possible.
             return index == 0 ? curveData.NodeSamples : curveData.NodeSamples.Skip(index).ToList();
@@ -496,7 +506,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// <param name="column">The column to add the note to.</param>
         /// <param name="startTime">The start time of the note.</param>
         /// <param name="endTime">The end time of the note (set to <paramref name="startTime"/> for a non-hold note).</param>
-        private void addToPattern(Pattern pattern, int column, double startTime, double endTime)
+        private void addToPattern(Pattern pattern, int column, int startTime, int endTime)
         {
             ManiaHitObject newObject;
 

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

@@ -14,12 +14,17 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 {
     internal class EndTimeObjectPatternGenerator : PatternGenerator
     {
-        private readonly double endTime;
+        private readonly int endTime;
+        private readonly PatternType convertType;
 
-        public EndTimeObjectPatternGenerator(FastRandom random, HitObject hitObject, ManiaBeatmap beatmap, IBeatmap originalBeatmap)
-            : base(random, hitObject, beatmap, new Pattern(), originalBeatmap)
+        public EndTimeObjectPatternGenerator(FastRandom random, HitObject hitObject, ManiaBeatmap beatmap, Pattern previousPattern, IBeatmap originalBeatmap)
+            : base(random, hitObject, beatmap, previousPattern, originalBeatmap)
         {
-            endTime = (HitObject as IHasDuration)?.EndTime ?? 0;
+            endTime = (int)((HitObject as IHasDuration)?.EndTime ?? 0);
+
+            convertType = PreviousPattern.ColumnWithObjects == TotalColumns
+                ? PatternType.None
+                : PatternType.ForceNotStack;
         }
 
         public override IEnumerable<Pattern> Generate()
@@ -40,18 +45,25 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                     break;
 
                 case 8:
-                    addToPattern(pattern, FindAvailableColumn(GetRandomColumn(), PreviousPattern), generateHold);
+                    addToPattern(pattern, getRandomColumn(), generateHold);
                     break;
 
                 default:
-                    if (TotalColumns > 0)
-                        addToPattern(pattern, GetRandomColumn(), generateHold);
+                    addToPattern(pattern, getRandomColumn(0), generateHold);
                     break;
             }
 
             return pattern;
         }
 
+        private int getRandomColumn(int? lowerBound = null)
+        {
+            if ((convertType & PatternType.ForceNotStack) > 0)
+                return FindAvailableColumn(GetRandomColumn(lowerBound), lowerBound, patterns: PreviousPattern);
+
+            return FindAvailableColumn(GetRandomColumn(lowerBound), lowerBound);
+        }
+
         /// <summary>
         /// Constructs and adds a note to a pattern.
         /// </summary>

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

@@ -397,7 +397,11 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
                 case 4:
                     centreProbability = 0;
-                    p2 = Math.Min(p2 * 2, 0.2);
+
+                    // Stable requires rngValue > x, which is an inverse-probability. Lazer uses true probability (1 - x).
+                    // But multiplying this value by 2 (stable) is not the same operation as dividing it by 2 (lazer),
+                    // so it needs to be converted to from a probability and then back after the multiplication.
+                    p2 = 1 - Math.Max((1 - p2) * 2, 0.8);
                     p3 = 0;
                     break;
 
@@ -408,11 +412,20 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
                 case 6:
                     centreProbability = 0;
-                    p2 = Math.Min(p2 * 2, 0.5);
-                    p3 = Math.Min(p3 * 2, 0.15);
+
+                    // Stable requires rngValue > x, which is an inverse-probability. Lazer uses true probability (1 - x).
+                    // But multiplying this value by 2 (stable) is not the same operation as dividing it by 2 (lazer),
+                    // so it needs to be converted to from a probability and then back after the multiplication.
+                    p2 = 1 - Math.Max((1 - p2) * 2, 0.5);
+                    p3 = 1 - Math.Max((1 - p3) * 2, 0.85);
                     break;
             }
 
+            // The stable values were allowed to exceed 1, which indicate <0% probability.
+            // These values needs to be clamped otherwise GetRandomNoteCount() will throw an exception.
+            p2 = Math.Clamp(p2, 0, 1);
+            p3 = Math.Clamp(p3, 0, 1);
+
             double centreVal = Random.NextDouble();
             int noteCount = GetRandomNoteCount(p2, p3);
 

osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyAttributes.cs

@@ -8,5 +8,6 @@ namespace osu.Game.Rulesets.Mania.Difficulty
     public class ManiaDifficultyAttributes : DifficultyAttributes
     {
         public double GreatHitWindow;
+        public double ScoreMultiplier;
     }
 }

osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.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 osu.Game.Beatmaps;
@@ -10,10 +11,12 @@ using osu.Game.Rulesets.Difficulty.Skills;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Mania.Difficulty.Skills;
+using osu.Game.Rulesets.Mania.MathUtils;
 using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Difficulty
@@ -23,11 +26,13 @@ namespace osu.Game.Rulesets.Mania.Difficulty
         private const double star_scaling_factor = 0.018;
 
         private readonly bool isForCurrentRuleset;
+        private readonly double originalOverallDifficulty;
 
         public ManiaDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
             isForCurrentRuleset = beatmap.BeatmapInfo.Ruleset.Equals(ruleset.RulesetInfo);
+            originalOverallDifficulty = beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty;
         }
 
         protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
@@ -40,64 +45,33 @@ namespace osu.Game.Rulesets.Mania.Difficulty
 
             return new ManiaDifficultyAttributes
             {
-                StarRating = difficultyValue(skills) * star_scaling_factor,
+                StarRating = skills[0].DifficultyValue() * star_scaling_factor,
                 Mods = mods,
                 // Todo: This int cast is temporary to achieve 1:1 results with osu!stable, and should be removed in the future
-                GreatHitWindow = (int)(hitWindows.WindowFor(HitResult.Great)) / clockRate,
+                GreatHitWindow = (int)Math.Ceiling(getHitWindow300(mods) / clockRate),
+                ScoreMultiplier = getScoreMultiplier(beatmap, mods),
                 MaxCombo = beatmap.HitObjects.Sum(h => h is HoldNote ? 2 : 1),
                 Skills = skills
             };
         }
 
-        private double difficultyValue(Skill[] skills)
-        {
-            // Preprocess the strains to find the maximum overall + individual (aggregate) strain from each section
-            var overall = skills.OfType<Overall>().Single();
-            var aggregatePeaks = new List<double>(Enumerable.Repeat(0.0, overall.StrainPeaks.Count));
-
-            foreach (var individual in skills.OfType<Individual>())
-            {
-                for (int i = 0; i < individual.StrainPeaks.Count; i++)
-                {
-                    double aggregate = individual.StrainPeaks[i] + overall.StrainPeaks[i];
-
-                    if (aggregate > aggregatePeaks[i])
-                        aggregatePeaks[i] = aggregate;
-                }
-            }
-
-            aggregatePeaks.Sort((a, b) => b.CompareTo(a)); // Sort from highest to lowest strain.
-
-            double difficulty = 0;
-            double weight = 1;
-
-            // Difficulty is the weighted sum of the highest strains from every section.
-            foreach (double strain in aggregatePeaks)
-            {
-                difficulty += strain * weight;
-                weight *= 0.9;
-            }
-
-            return difficulty;
-        }
-
         protected override IEnumerable<DifficultyHitObject> CreateDifficultyHitObjects(IBeatmap beatmap, double clockRate)
         {
-            for (int i = 1; i < beatmap.HitObjects.Count; i++)
-                yield return new ManiaDifficultyHitObject(beatmap.HitObjects[i], beatmap.HitObjects[i - 1], clockRate);
+            var sortedObjects = beatmap.HitObjects.ToArray();
+
+            LegacySortHelper<HitObject>.Sort(sortedObjects, Comparer<HitObject>.Create((a, b) => (int)Math.Round(a.StartTime) - (int)Math.Round(b.StartTime)));
+
+            for (int i = 1; i < sortedObjects.Length; i++)
+                yield return new ManiaDifficultyHitObject(sortedObjects[i], sortedObjects[i - 1], clockRate);
         }
 
-        protected override Skill[] CreateSkills(IBeatmap beatmap)
+        // Sorting is done in CreateDifficultyHitObjects, since the full list of hitobjects is required.
+        protected override IEnumerable<DifficultyHitObject> SortObjects(IEnumerable<DifficultyHitObject> input) => input;
+
+        protected override Skill[] CreateSkills(IBeatmap beatmap) => new Skill[]
         {
-            int columnCount = ((ManiaBeatmap)beatmap).TotalColumns;
-
-            var skills = new List<Skill> { new Overall(columnCount) };
-
-            for (int i = 0; i < columnCount; i++)
-                skills.Add(new Individual(i, columnCount));
-
-            return skills.ToArray();
-        }
+            new Strain(((ManiaBeatmap)beatmap).TotalColumns)
+        };
 
         protected override Mod[] DifficultyAdjustmentMods
         {
@@ -122,12 +96,73 @@ namespace osu.Game.Rulesets.Mania.Difficulty
                     new ManiaModKey3(),
                     new ManiaModKey4(),
                     new ManiaModKey5(),
+                    new MultiMod(new ManiaModKey5(), new ManiaModDualStages()),
                     new ManiaModKey6(),
+                    new MultiMod(new ManiaModKey6(), new ManiaModDualStages()),
                     new ManiaModKey7(),
+                    new MultiMod(new ManiaModKey7(), new ManiaModDualStages()),
                     new ManiaModKey8(),
+                    new MultiMod(new ManiaModKey8(), new ManiaModDualStages()),
                     new ManiaModKey9(),
+                    new MultiMod(new ManiaModKey9(), new ManiaModDualStages()),
                 }).ToArray();
             }
         }
+
+        private int getHitWindow300(Mod[] mods)
+        {
+            if (isForCurrentRuleset)
+            {
+                double od = Math.Min(10.0, Math.Max(0, 10.0 - originalOverallDifficulty));
+                return applyModAdjustments(34 + 3 * od, mods);
+            }
+
+            if (Math.Round(originalOverallDifficulty) > 4)
+                return applyModAdjustments(34, mods);
+
+            return applyModAdjustments(47, mods);
+
+            static int applyModAdjustments(double value, Mod[] mods)
+            {
+                if (mods.Any(m => m is ManiaModHardRock))
+                    value /= 1.4;
+                else if (mods.Any(m => m is ManiaModEasy))
+                    value *= 1.4;
+
+                if (mods.Any(m => m is ManiaModDoubleTime))
+                    value *= 1.5;
+                else if (mods.Any(m => m is ManiaModHalfTime))
+                    value *= 0.75;
+
+                return (int)value;
+            }
+        }
+
+        private double getScoreMultiplier(IBeatmap beatmap, Mod[] mods)
+        {
+            double scoreMultiplier = 1;
+
+            foreach (var m in mods)
+            {
+                switch (m)
+                {
+                    case ManiaModNoFail _:
+                    case ManiaModEasy _:
+                    case ManiaModHalfTime _:
+                        scoreMultiplier *= 0.5;
+                        break;
+                }
+            }
+
+            var maniaBeatmap = (ManiaBeatmap)beatmap;
+            int diff = maniaBeatmap.TotalColumns - maniaBeatmap.OriginalTotalColumns;
+
+            if (diff > 0)
+                scoreMultiplier *= 0.9;
+            else if (diff < 0)
+                scoreMultiplier *= 0.9 + 0.04 * diff;
+
+            return scoreMultiplier;
+        }
     }
 }

osu.Game.Rulesets.Mania/Difficulty/ManiaPerformanceCalculator.cs

@@ -5,7 +5,6 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Extensions;
-using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
@@ -29,8 +28,8 @@ namespace osu.Game.Rulesets.Mania.Difficulty
         private int countMeh;
         private int countMiss;
 
-        public ManiaPerformanceCalculator(Ruleset ruleset, WorkingBeatmap beatmap, ScoreInfo score)
-            : base(ruleset, beatmap, score)
+        public ManiaPerformanceCalculator(Ruleset ruleset, DifficultyAttributes attributes, ScoreInfo score)
+            : base(ruleset, attributes, score)
         {
         }
 

osu.Game.Rulesets.Mania/Difficulty/Skills/Individual.cs

@@ -1,47 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Linq;
-using osu.Game.Rulesets.Difficulty.Preprocessing;
-using osu.Game.Rulesets.Difficulty.Skills;
-using osu.Game.Rulesets.Mania.Difficulty.Preprocessing;
-using osu.Game.Rulesets.Objects;
-
-namespace osu.Game.Rulesets.Mania.Difficulty.Skills
-{
-    public class Individual : Skill
-    {
-        protected override double SkillMultiplier => 1;
-        protected override double StrainDecayBase => 0.125;
-
-        private readonly double[] holdEndTimes;
-
-        private readonly int column;
-
-        public Individual(int column, int columnCount)
-        {
-            this.column = column;
-
-            holdEndTimes = new double[columnCount];
-        }
-
-        protected override double StrainValueOf(DifficultyHitObject current)
-        {
-            var maniaCurrent = (ManiaDifficultyHitObject)current;
-            var endTime = maniaCurrent.BaseObject.GetEndTime();
-
-            try
-            {
-                if (maniaCurrent.BaseObject.Column != column)
-                    return 0;
-
-                // We give a slight bonus if something is held meanwhile
-                return holdEndTimes.Any(t => t > endTime) ? 2.5 : 2;
-            }
-            finally
-            {
-                holdEndTimes[maniaCurrent.BaseObject.Column] = endTime;
-            }
-        }
-    }
-}

osu.Game.Rulesets.Mania/Difficulty/Skills/Overall.cs

@@ -1,56 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Game.Rulesets.Difficulty.Preprocessing;
-using osu.Game.Rulesets.Difficulty.Skills;
-using osu.Game.Rulesets.Mania.Difficulty.Preprocessing;
-using osu.Game.Rulesets.Objects;
-
-namespace osu.Game.Rulesets.Mania.Difficulty.Skills
-{
-    public class Overall : Skill
-    {
-        protected override double SkillMultiplier => 1;
-        protected override double StrainDecayBase => 0.3;
-
-        private readonly double[] holdEndTimes;
-
-        private readonly int columnCount;
-
-        public Overall(int columnCount)
-        {
-            this.columnCount = columnCount;
-
-            holdEndTimes = new double[columnCount];
-        }
-
-        protected override double StrainValueOf(DifficultyHitObject current)
-        {
-            var maniaCurrent = (ManiaDifficultyHitObject)current;
-            var endTime = maniaCurrent.BaseObject.GetEndTime();
-
-            double holdFactor = 1.0; // Factor in case something else is held
-            double holdAddition = 0; // Addition to the current note in case it's a hold and has to be released awkwardly
-
-            for (int i = 0; i < columnCount; i++)
-            {
-                // If there is at least one other overlapping end or note, then we get an addition, buuuuuut...
-                if (current.BaseObject.StartTime < holdEndTimes[i] && endTime > holdEndTimes[i])
-                    holdAddition = 1.0;
-
-                // ... this addition only is valid if there is _no_ other note with the same ending.
-                // Releasing multiple notes at the same time is just as easy as releasing one
-                if (endTime == holdEndTimes[i])
-                    holdAddition = 0;
-
-                // We give a slight bonus if something is held meanwhile
-                if (holdEndTimes[i] > endTime)
-                    holdFactor = 1.25;
-            }
-
-            holdEndTimes[maniaCurrent.BaseObject.Column] = endTime;
-
-            return (1 + holdAddition) * holdFactor;
-        }
-    }
-}

osu.Game.Rulesets.Mania/Difficulty/Skills/Strain.cs

@@ -0,0 +1,80 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Difficulty.Skills;
+using osu.Game.Rulesets.Mania.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Rulesets.Mania.Difficulty.Skills
+{
+    public class Strain : Skill
+    {
+        private const double individual_decay_base = 0.125;
+        private const double overall_decay_base = 0.30;
+
+        protected override double SkillMultiplier => 1;
+        protected override double StrainDecayBase => 1;
+
+        private readonly double[] holdEndTimes;
+        private readonly double[] individualStrains;
+
+        private double individualStrain;
+        private double overallStrain;
+
+        public Strain(int totalColumns)
+        {
+            holdEndTimes = new double[totalColumns];
+            individualStrains = new double[totalColumns];
+            overallStrain = 1;
+        }
+
+        protected override double StrainValueOf(DifficultyHitObject current)
+        {
+            var maniaCurrent = (ManiaDifficultyHitObject)current;
+            var endTime = maniaCurrent.BaseObject.GetEndTime();
+            var column = maniaCurrent.BaseObject.Column;
+
+            double holdFactor = 1.0; // Factor to all additional strains in case something else is held
+            double holdAddition = 0; // Addition to the current note in case it's a hold and has to be released awkwardly
+
+            // Fill up the holdEndTimes array
+            for (int i = 0; i < holdEndTimes.Length; ++i)
+            {
+                // If there is at least one other overlapping end or note, then we get an addition, buuuuuut...
+                if (Precision.DefinitelyBigger(holdEndTimes[i], maniaCurrent.BaseObject.StartTime, 1) && Precision.DefinitelyBigger(endTime, holdEndTimes[i], 1))
+                    holdAddition = 1.0;
+
+                // ... this addition only is valid if there is _no_ other note with the same ending. Releasing multiple notes at the same time is just as easy as releasing 1
+                if (Precision.AlmostEquals(endTime, holdEndTimes[i], 1))
+                    holdAddition = 0;
+
+                // We give a slight bonus to everything if something is held meanwhile
+                if (Precision.DefinitelyBigger(holdEndTimes[i], endTime, 1))
+                    holdFactor = 1.25;
+
+                // Decay individual strains
+                individualStrains[i] = applyDecay(individualStrains[i], current.DeltaTime, individual_decay_base);
+            }
+
+            holdEndTimes[column] = endTime;
+
+            // Increase individual strain in own column
+            individualStrains[column] += 2.0 * holdFactor;
+            individualStrain = individualStrains[column];
+
+            overallStrain = applyDecay(overallStrain, current.DeltaTime, overall_decay_base) + (1 + holdAddition) * holdFactor;
+
+            return individualStrain + overallStrain - CurrentStrain;
+        }
+
+        protected override double GetPeakStrain(double offset)
+            => applyDecay(individualStrain, offset - Previous[0].BaseObject.StartTime, individual_decay_base)
+               + applyDecay(overallStrain, offset - Previous[0].BaseObject.StartTime, overall_decay_base);
+
+        private double applyDecay(double value, double deltaTime, double decayBase)
+            => value * Math.Pow(decayBase, deltaTime / 1000);
+    }
+}

osu.Game.Rulesets.Mania/Edit/Blueprints/HoldNotePlacementBlueprint.cs

@@ -78,9 +78,9 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 
         private double originalStartTime;
 
-        public override void UpdatePosition(SnapResult result)
+        public override void UpdateTimeAndPosition(SnapResult result)
         {
-            base.UpdatePosition(result);
+            base.UpdateTimeAndPosition(result);
 
             if (PlacementActive)
             {

osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaPlacementBlueprint.cs

@@ -48,9 +48,9 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             return true;
         }
 
-        public override void UpdatePosition(SnapResult result)
+        public override void UpdateTimeAndPosition(SnapResult result)
         {
-            base.UpdatePosition(result);
+            base.UpdateTimeAndPosition(result);
 
             if (!PlacementActive)
                 Column = result.Playfield as Column;

osu.Game.Rulesets.Mania/Edit/Blueprints/NotePlacementBlueprint.cs

@@ -22,9 +22,9 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             InternalChild = piece = new EditNotePiece { Origin = Anchor.Centre };
         }
 
-        public override void UpdatePosition(SnapResult result)
+        public override void UpdateTimeAndPosition(SnapResult result)
         {
-            base.UpdatePosition(result);
+            base.UpdateTimeAndPosition(result);
 
             if (result.Playfield != null)
             {

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

@@ -204,10 +204,6 @@ namespace osu.Game.Rulesets.Mania.Edit
             protected override void UpdateInitialTransforms()
             {
                 // don't perform any fading – we are handling that ourselves.
-            }
-
-            protected override void UpdateStateTransforms(ArmedState state)
-            {
                 LifetimeEnd = HitObject.StartTime + visible_range;
             }
         }