Merge pull request #8970 from peppy/android-version-update

Fix android usage of obsoleted VersionCode
Merge pull request #8971 from peppy/commit-rider-vcs-update
2026-05-15 00:33:11 +08:00 · 2020-05-08 16:09:04 +09:00 · 2020-05-08 15:35:58 +09:00 · 2020-05-08 15:35:25 +09:00 · 2020-05-08 15:12:29 +09:00 · 2020-05-08 15:11:50 +09:00
1212 changed files with 37079 additions and 14016 deletions
@@ -1,8 +0,0 @@
---
-name: Mobile Report
-about: ⚠ Due to current development priorities we are not accepting mobile reports at this time (unless you're willing to fix them yourself!)
---
-
-⚠ **PLEASE READ** ⚠: Due to prioritising finishing the client for desktop first we are not accepting reports related to mobile platforms for the time being, unless you're willing to fix them.
-If you'd like to report a problem or suggest a feature and then work on it, feel free to open an issue and highlight that you'd like to address it yourself in the issue body; mobile pull requests are also welcome.
-Otherwise, please check back in the future when the focus of development shifts towards mobile!
@@ -8,4 +8,9 @@ about: Issues regarding encountered bugs.

 **osu!lazer version:** 

-**Logs:** 
+**Logs:**
+<!--
+*please attach logs here, which are located at:*
+- `%AppData%/osu/logs` *(on Windows),*
+- `~/.local/share/osu/logs` *(on Linux & macOS).*
+-->
@@ -8,6 +8,11 @@ about: Issues regarding crashes or permanent freezes.

 **osu!lazer version:** 

-**Logs:** 
+**Logs:**
+<!--
+*please attach logs here, which are located at:*
+- `%AppData%/osu/logs` *(on Windows),*
+- `~/.local/share/osu/logs` *(on Linux & macOS).*
+-->

 **Computer Specifications:** 
@@ -2,6 +2,7 @@
 <project version="4">
  <component name="ProjectModuleManager">
    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/.idea.osu.Desktop/.idea/.idea.osu.Desktop.iml" filepath="$PROJECT_DIR$/.idea/.idea.osu.Desktop/.idea/.idea.osu.Desktop.iml" />
      <module fileurl="file://$PROJECT_DIR$/.idea/.idea.osu.Desktop/riderModule.iml" filepath="$PROJECT_DIR$/.idea/.idea.osu.Desktop/riderModule.iml" />
    </modules>
  </component>
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="RiderProjectSettingsUpdater">
-    <option name="vcsConfiguration" value="1" />
+    <option name="vcsConfiguration" value="2" />
  </component>
 </project>
@@ -11,11 +11,6 @@
            ],
            "cwd": "${workspaceRoot}",
            "preLaunchTask": "Build osu! (Debug)",
-            "linux": {
-                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Desktop/bin/Debug/netcoreapp3.1:${env:LD_LIBRARY_PATH}"
-                }
-            },
            "console": "internalConsole"
        },
        {
@@ -28,11 +23,6 @@
            ],
            "cwd": "${workspaceRoot}",
            "preLaunchTask": "Build osu! (Release)",
-            "linux": {
-                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Desktop/bin/Release/netcoreapp3.1:${env:LD_LIBRARY_PATH}"
-                }
-            },
            "console": "internalConsole"
        },
        {
@@ -45,11 +35,6 @@
            ],
            "cwd": "${workspaceRoot}",
            "preLaunchTask": "Build tests (Debug)",
-            "linux": {
-                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Game.Tests/bin/Debug/netcoreapp3.1:${env:LD_LIBRARY_PATH}"
-                }
-            },
            "console": "internalConsole"
        },
        {
@@ -62,11 +47,6 @@
            ],
            "cwd": "${workspaceRoot}",
            "preLaunchTask": "Build tests (Release)",
-            "linux": {
-                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Game.Tests/bin/Release/netcoreapp3.1:${env:LD_LIBRARY_PATH}"
-                }
-            },
            "console": "internalConsole"
        },
        {
@@ -80,11 +60,6 @@
            ],
            "cwd": "${workspaceRoot}",
            "preLaunchTask": "Build osu! (Debug)",
-            "linux": {
-                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Desktop/bin/Debug/netcoreapp3.1:${env:LD_LIBRARY_PATH}"
-                }
-            },
            "console": "internalConsole"
        },
        {
@@ -98,11 +73,6 @@
            ],
            "cwd": "${workspaceRoot}",
            "preLaunchTask": "Build osu! (Release)",
-            "linux": {
-                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Desktop/bin/Release/netcoreapp3.1:${env:LD_LIBRARY_PATH}"
-                }
-            },
            "console": "internalConsole"
        },
        {
@@ -116,11 +86,6 @@
            ],
            "cwd": "${workspaceRoot}",
            "preLaunchTask": "Build tournament tests (Debug)",
-            "linux": {
-                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Game.Tournament.Tests/bin/Debug/netcoreapp3.1:${env:LD_LIBRARY_PATH}"
-                }
-            },
            "console": "internalConsole"
        },
        {
@@ -134,11 +99,6 @@
            ],
            "cwd": "${workspaceRoot}",
            "preLaunchTask": "Build tournament tests (Release)",
-            "linux": {
-                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Game.Tournament.Tests/bin/Debug/netcoreapp3.1:${env:LD_LIBRARY_PATH}"
-                }
-            },
            "console": "internalConsole"
        },
        {
@@ -169,4 +129,4 @@
            "externalConsole": false
        }
    ]
-}
+}
@@ -4,3 +4,5 @@ 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.
+T:Microsoft.EntityFrameworkCore.Internal.EnumerableExtensions;Don't use internal extension methods.
+T:Microsoft.EntityFrameworkCore.Internal.TypeExtensions;Don't use internal extension methods.
@@ -16,9 +16,9 @@
    <EmbeddedResource Include="Resources\**\*.*" />
  </ItemGroup>
  <ItemGroup Label="Code Analysis">
-    <PackageReference Include="Microsoft.CodeAnalysis.BannedApiAnalyzers" Version="2.9.8" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.CodeAnalysis.BannedApiAnalyzers" Version="3.0.0" PrivateAssets="All" />
    <AdditionalFiles Include="$(MSBuildThisFileDirectory)CodeAnalysis\BannedSymbols.txt" />
-    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.8" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="3.0.0" PrivateAssets="All" />
  </ItemGroup>
  <PropertyGroup Label="Code Analysis">
    <CodeAnalysisRuleSet>$(MSBuildThisFileDirectory)CodeAnalysis\osu.ruleset</CodeAnalysisRuleSet>
@@ -13,35 +13,36 @@ Rhythm is just a *click* away. The future of [osu!](https://osu.ppy.sh) and the

 ## Status

-This project is still heavily under development, but is in a state where users are encouraged to try it out and keep it installed alongside the stable *osu!* client. It will continue to evolve over the coming months and hopefully bring some new unique features to the table.
+This project is under heavy development, but is in a stable state. Users are encouraged to try it out and keep it installed alongside the stable *osu!* client. It will continue to evolve to the point of eventually replacing the existing stable client as an update.

-We are accepting bug reports (please report with as much detail as possible). Feature requests are welcome as long as you read and understand the contribution guidelines listed below.
+We are accepting bug reports (please report with as much detail as possible and follow the existing issue templates). Feature requests are also welcome, but understand that our focus is on completing the game to feature parity before adding new features. A few resources are available as starting points to getting involved and understanding the project:

-Detailed changelogs are published on the [official osu! site](https://osu.ppy.sh/home/changelog).
-
-## Requirements
-
- A desktop platform with the [.NET Core 3.1 SDK](https://dotnet.microsoft.com/download) or higher installed.
- When running on Linux, please have a system-wide FFmpeg installation available to support video decoding.
- 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.
- When developing with mobile, [Xamarin](https://docs.microsoft.com/en-us/xamarin/) is required, which is shipped together with Visual Studio or [Visual Studio for Mac](https://visualstudio.microsoft.com/vs/mac/).
- When working with the codebase, we recommend using an IDE with intelligent code completion and syntax highlighting, such as [Visual Studio 2019+](https://visualstudio.microsoft.com/vs/), [JetBrains Rider](https://www.jetbrains.com/rider/) or [Visual Studio Code](https://code.visualstudio.com/).
+- Detailed release changelogs are available on the [official osu! site](https://osu.ppy.sh/home/changelog/lazer).
+- You can learn more about our approach to [project management](https://github.com/ppy/osu/wiki/Project-management).
+- Read peppy's [latest blog post](https://blog.ppy.sh/a-definitive-lazer-faq/) exploring where lazer is currently and the roadmap going forward.

 ## Running osu!

-### Releases
-
-If you are not interested in developing the game, you can still consume our [binary releases](https://github.com/ppy/osu/releases).
+If you are looking to install or test osu! without setting up a development environment, you can consume our [binary releases](https://github.com/ppy/osu/releases). Handy links below will download the latest version for your operating system of choice:

 **Latest build:**

-| [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) | [iOS(iOS 10+)](https://osu.ppy.sh/home/testflight) | [Android (5+)](https://github.com/ppy/osu/releases/latest/download/sh.ppy.osulazer.apk)
-| ------------- | ------------- | ------------- | ------------- |
+| [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)
+| ------------- | ------------- | ------------- | ------------- | ------------- |

- **Linux** users are recommended to self-compile until we have official deployment in place.
+- 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.

+## Developing or debugging
+
+Please make sure you have the following prerequisites:
+
+- A desktop platform with the [.NET Core 3.1 SDK](https://dotnet.microsoft.com/download) or higher installed.
+- When developing with mobile, [Xamarin](https://docs.microsoft.com/en-us/xamarin/) is required, which is shipped together with Visual Studio or [Visual Studio for Mac](https://visualstudio.microsoft.com/vs/mac/).
+- When working with the codebase, we recommend using an IDE with intelligent code completion and syntax highlighting, such as [Visual Studio 2019+](https://visualstudio.microsoft.com/vs/), [JetBrains Rider](https://www.jetbrains.com/rider/) or [Visual Studio Code](https://code.visualstudio.com/).
+- When running on Linux, please have a system-wide FFmpeg installation available to support video decoding.
+
 ### Downloading the source code

 Clone the repository:
@@ -92,7 +93,7 @@ JetBrains ReSharper InspectCode is also used for wider rule sets. You can run it

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

-If you're unsure of what you can help with, check out the [list of open issues](https://github.com/ppy/osu/issues) (especially those with the ["good first issue"](https://github.com/ppy/osu/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22good+first+issue%22) label).
+If you're unsure of what you can help with, check out the [list of open issues](https://github.com/ppy/osu/issues) (especially those with the ["good first issue"](https://github.com/ppy/osu/issues?q=is%3Aopen+label%3Agood-first-issue+sort%3Aupdated-desc) label).

 Before starting, please make sure you are familiar with the [development and testing](https://github.com/ppy/osu-framework/wiki/Development-and-Testing) procedure we have set up. New component development, and where possible, bug fixing and debugging existing components **should always be done under VisualTests**.

@@ -1,5 +1,5 @@
 #addin "nuget:?package=CodeFileSanity&version=0.0.33"
-#addin "nuget:?package=JetBrains.ReSharper.CommandLineTools&version=2019.3.0"
+#addin "nuget:?package=JetBrains.ReSharper.CommandLineTools&version=2019.3.2"
 #tool "nuget:?package=NVika.MSBuild&version=1.0.1"
 var nVikaToolPath = GetFiles("./tools/NVika.MSBuild.*/tools/NVika.exe").First();

@@ -97,8 +97,10 @@ platform :ios do
    changelog.gsub!('$BUILD_ID', options[:build])

    pilot(
-      wait_processing_interval: 1800,
+      wait_processing_interval: 900,
      changelog: changelog,
+      groups: ['osu! supporters', 'public'],
+      distribute_external: true,
      ipa: './osu.iOS/bin/iPhone/Release/osu.iOS.ipa'
    )
  end
@@ -5,6 +5,6 @@
    "version": "3.1.100"
  },
  "msbuild-sdks": {
-    "Microsoft.Build.Traversal": "2.0.24"
+    "Microsoft.Build.Traversal": "2.0.34"
  }
 }
@@ -25,7 +25,6 @@
    <DebugType>portable</DebugType>
    <Optimize>False</Optimize>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <EnableLLVM>false</EnableLLVM>
    <AndroidManagedSymbols>false</AndroidManagedSymbols>
    <AndroidUseSharedRuntime>true</AndroidUseSharedRuntime>
    <EmbedAssembliesIntoApk>false</EmbedAssembliesIntoApk>
@@ -34,7 +33,6 @@
    <DebugSymbols>false</DebugSymbols>
    <DebugType>None</DebugType>
    <Optimize>True</Optimize>
-    <EnableLLVM>true</EnableLLVM>
    <AndroidManagedSymbols>false</AndroidManagedSymbols>
    <AndroidUseSharedRuntime>False</AndroidUseSharedRuntime>
    <EmbedAssembliesIntoApk>true</EmbedAssembliesIntoApk>
@@ -53,7 +51,7 @@
    <Reference Include="Java.Interop" />
  </ItemGroup>
  <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2019.1230.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.207.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.427.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.508.1" />
  </ItemGroup>
 </Project>
@@ -18,7 +18,8 @@ namespace osu.Android

                try
                {
-                    string versionName = packageInfo.VersionCode.ToString();
+                    // todo: needs checking before play store redeploy.
+                    string versionName = packageInfo.VersionName;
                    // undo play store version garbling
                    return new Version(int.Parse(versionName.Substring(0, 4)), int.Parse(versionName.Substring(4, 4)), int.Parse(versionName.Substring(8, 1)));
                }
@@ -30,11 +31,6 @@ namespace osu.Android
            }
        }

-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            Add(new SimpleUpdateManager());
-        }
+        protected override UpdateManager CreateUpdateManager() => new SimpleUpdateManager();
    }
 }
@@ -13,6 +13,7 @@
    <AssemblyName>osu.Android</AssemblyName>
    <AndroidManifest>Properties\AndroidManifest.xml</AndroidManifest>
    <AndroidSupportedAbis>armeabi-v7a;x86;arm64-v8a</AndroidSupportedAbis>
+    <EnableLLVM>false</EnableLLVM> <!-- This currently causes random lockups during gameplay. https://github.com/mono/mono/issues/18973 -->
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    <MandroidI18n>cjk;mideast;other;rare;west</MandroidI18n>
@@ -52,4 +53,4 @@
    <AndroidResource Include="Resources\drawable\lazer.png" />
  </ItemGroup>
  <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
-</Project>
+</Project>
@@ -6,15 +6,14 @@ using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
+using Microsoft.Win32;
 using osu.Desktop.Overlays;
 using osu.Framework.Platform;
 using osu.Game;
 using osuTK.Input;
-using Microsoft.Win32;
 using osu.Desktop.Updater;
 using osu.Framework;
 using osu.Framework.Logging;
-using osu.Framework.Platform.Windows;
 using osu.Framework.Screens;
 using osu.Game.Screens.Menu;
 using osu.Game.Updater;
@@ -37,7 +36,11 @@ namespace osu.Desktop
            try
            {
                if (Host is DesktopGameHost desktopHost)
-                    return new StableStorage(desktopHost);
+                {
+                    string stablePath = getStableInstallPath();
+                    if (!string.IsNullOrEmpty(stablePath))
+                        return new DesktopStorage(stablePath, desktopHost);
+                }
            }
            catch (Exception)
            {
@@ -47,20 +50,54 @@ namespace osu.Desktop
            return null;
        }

+        private string getStableInstallPath()
+        {
+            static bool checkExists(string p) => Directory.Exists(Path.Combine(p, "Songs"));
+
+            string stableInstallPath;
+
+            try
+            {
+                using (RegistryKey key = Registry.ClassesRoot.OpenSubKey("osu"))
+                    stableInstallPath = key?.OpenSubKey(@"shell\open\command")?.GetValue(string.Empty).ToString().Split('"')[1].Replace("osu!.exe", "");
+
+                if (checkExists(stableInstallPath))
+                    return stableInstallPath;
+            }
+            catch
+            {
+            }
+
+            stableInstallPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), @"osu!");
+            if (checkExists(stableInstallPath))
+                return stableInstallPath;
+
+            stableInstallPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".osu");
+            if (checkExists(stableInstallPath))
+                return stableInstallPath;
+
+            return null;
+        }
+
+        protected override UpdateManager CreateUpdateManager()
+        {
+            switch (RuntimeInfo.OS)
+            {
+                case RuntimeInfo.Platform.Windows:
+                    return new SquirrelUpdateManager();
+
+                default:
+                    return new SimpleUpdateManager();
+            }
+        }
+
        protected override void LoadComplete()
        {
            base.LoadComplete();

            if (!noVersionOverlay)
-            {
                LoadComponentAsync(versionManager = new VersionManager { Depth = int.MinValue }, Add);

-                if (RuntimeInfo.OS == RuntimeInfo.Platform.Windows)
-                    Add(new SquirrelUpdateManager());
-                else
-                    Add(new SimpleUpdateManager());
-            }
-
            LoadComponentAsync(new DiscordRichPresence(), Add);
        }

@@ -106,45 +143,5 @@ namespace osu.Desktop

            Task.Factory.StartNew(() => Import(filePaths), TaskCreationOptions.LongRunning);
        }
-
-        /// <summary>
-        /// A method of accessing an osu-stable install in a controlled fashion.
-        /// </summary>
-        private class StableStorage : WindowsStorage
-        {
-            protected override string LocateBasePath()
-            {
-                static bool checkExists(string p) => Directory.Exists(Path.Combine(p, "Songs"));
-
-                string stableInstallPath;
-
-                try
-                {
-                    using (RegistryKey key = Registry.ClassesRoot.OpenSubKey("osu"))
-                        stableInstallPath = key?.OpenSubKey(@"shell\open\command")?.GetValue(string.Empty).ToString().Split('"')[1].Replace("osu!.exe", "");
-
-                    if (checkExists(stableInstallPath))
-                        return stableInstallPath;
-                }
-                catch
-                {
-                }
-
-                stableInstallPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), @"osu!");
-                if (checkExists(stableInstallPath))
-                    return stableInstallPath;
-
-                stableInstallPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".osu");
-                if (checkExists(stableInstallPath))
-                    return stableInstallPath;
-
-                return null;
-            }
-
-            public StableStorage(DesktopGameHost host)
-                : base(string.Empty, host)
-            {
-            }
-        }
    }
 }
@@ -43,7 +43,7 @@ namespace osu.Desktop.Updater

        private async void checkForUpdateAsync(bool useDeltaPatching = true, UpdateProgressNotification notification = null)
        {
-            //should we schedule a retry on completion of this check?
+            // should we schedule a retry on completion of this check?
            bool scheduleRecheck = true;

            try
@@ -52,7 +52,7 @@ namespace osu.Desktop.Updater

                var info = await updateManager.CheckForUpdate(!useDeltaPatching);
                if (info.ReleasesToApply.Count == 0)
-                    //no updates available. bail and retry later.
+                    // no updates available. bail and retry later.
                    return;

                if (notification == null)
@@ -81,8 +81,8 @@ namespace osu.Desktop.Updater
                    {
                        logger.Add(@"delta patching failed; will attempt full download!");

-                        //could fail if deltas are unavailable for full update path (https://github.com/Squirrel/Squirrel.Windows/issues/959)
-                        //try again without deltas.
+                        // could fail if deltas are unavailable for full update path (https://github.com/Squirrel/Squirrel.Windows/issues/959)
+                        // try again without deltas.
                        checkForUpdateAsync(false, notification);
                        scheduleRecheck = false;
                    }
@@ -101,7 +101,7 @@ namespace osu.Desktop.Updater
            {
                if (scheduleRecheck)
                {
-                    //check again in 30 minutes.
+                    // check again in 30 minutes.
                    Scheduler.AddDelayed(() => checkForUpdateAsync(), 60000 * 30);
                }
            }
@@ -29,7 +29,7 @@
    <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.147" />
+    <PackageReference Include="DiscordRichPresence" Version="1.0.150" />
  </ItemGroup>
  <ItemGroup Label="Resources">
    <EmbeddedResource Include="lazer.ico" />
@@ -7,7 +7,7 @@
  </PropertyGroup>

  <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.12.0" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.12.1" />
    <PackageReference Include="nunit" Version="3.12.0" />
    <PackageReference Include="NUnit3TestAdapter" Version="3.15.1" />
  </ItemGroup>
@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Catch.Tests
    {
        protected override string ResourceAssembly => "osu.Game.Rulesets.Catch";

-        [TestCase(4.2058561036909863d, "diffcalc-test")]
+        [TestCase(4.050601681491468d, "diffcalc-test")]
        public void Test(double expected, string name)
            => base.Test(expected, name);

@@ -0,0 +1,21 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Game.Rulesets.Catch.Skinning;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    public abstract class CatchSkinnableTestScene : SkinnableTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(CatchRuleset),
+            typeof(CatchLegacySkinTransformer),
+        };
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new CatchRuleset();
+    }
+}
@@ -0,0 +1,54 @@
+// 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.Mods;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Tests.Mods
+{
+    public class TestSceneCatchModPerfect : ModPerfectTestScene
+    {
+        public TestSceneCatchModPerfect()
+            : base(new CatchRuleset(), new CatchModPerfect())
+        {
+        }
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestBananaShower(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new BananaShower { StartTime = 1000, EndTime = 3000 }, false), shouldMiss);
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestFruit(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new Fruit { StartTime = 1000 }), shouldMiss);
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestJuiceStream(bool shouldMiss)
+        {
+            var stream = new JuiceStream
+            {
+                StartTime = 1000,
+                Path = new SliderPath(PathType.Linear, new[]
+                {
+                    Vector2.Zero,
+                    new Vector2(100, 0),
+                })
+            };
+
+            CreateHitObjectTest(new HitObjectTestData(stream), shouldMiss);
+        }
+
+        // We only care about testing misses, hits are tested via JuiceStream
+        [TestCase(true)]
+        public void TestDroplet(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new Droplet { StartTime = 1000 }), shouldMiss);
+
+        // We only care about testing misses, hits are tested via JuiceStream
+        [TestCase(true)]
+        public void TestTinyDroplet(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new TinyDroplet { StartTime = 1000 }), shouldMiss);
+    }
+}
@@ -7,7 +7,6 @@ using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
-using osu.Game.Screens.Play;
 using osu.Game.Tests.Visual;
 using osuTK;

@@ -51,7 +50,7 @@ namespace osu.Game.Rulesets.Catch.Tests
            return beatmap;
        }

-        protected override Player CreatePlayer(Ruleset ruleset)
+        protected override TestPlayer CreatePlayer(Ruleset ruleset)
        {
            SelectedMods.Value = SelectedMods.Value.Concat(new[] { ruleset.GetAutoplayMod() }).ToArray();
            return base.CreatePlayer(ruleset);
@@ -6,7 +6,7 @@ using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
-using osu.Game.Rulesets.Catch.Objects.Drawable;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Tests.Visual;

@@ -18,7 +18,9 @@ namespace osu.Game.Rulesets.Catch.Tests
        public override IReadOnlyList<Type> RequiredTypes => new[]
        {
            typeof(BananaShower),
+            typeof(Banana),
            typeof(DrawableBananaShower),
+            typeof(DrawableBanana),

            typeof(CatchRuleset),
            typeof(DrawableCatchRuleset),
@@ -29,6 +31,12 @@ namespace osu.Game.Rulesets.Catch.Tests
        {
        }

+        [Test]
+        public void TestBananaShower()
+        {
+            AddUntilStep("player is done", () => !Player.ValidForResume);
+        }
+
        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset)
        {
            var beatmap = new Beatmap
@@ -40,7 +48,7 @@ namespace osu.Game.Rulesets.Catch.Tests
                }
            };

-            beatmap.HitObjects.Add(new BananaShower { StartTime = 200, Duration = 5000, NewCombo = true });
+            beatmap.HitObjects.Add(new BananaShower { StartTime = 200, Duration = 3000, NewCombo = true });

            return beatmap;
        }
@@ -3,104 +3,32 @@

 using NUnit.Framework;
 using osu.Framework.Allocation;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics;
 using osu.Game.Rulesets.Catch.UI;
-using osu.Game.Tests.Visual;
 using System;
 using System.Collections.Generic;
-using osu.Game.Skinning;
-using osu.Framework.Graphics.Shapes;
-using osuTK.Graphics;
-using osu.Framework.Audio.Sample;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics.Textures;
-using osu.Game.Audio;
-using osu.Game.Graphics.Sprites;
+using System.Linq;
+using osu.Framework.Graphics;

 namespace osu.Game.Rulesets.Catch.Tests
 {
    [TestFixture]
-    public class TestSceneCatcher : OsuTestScene
+    public class TestSceneCatcher : CatchSkinnableTestScene
    {
-        public override IReadOnlyList<Type> RequiredTypes => new[]
+        public override IReadOnlyList<Type> RequiredTypes => base.RequiredTypes.Concat(new[]
        {
-            typeof(CatcherSprite),
-        };
-
-        private readonly Container container;
-
-        public TestSceneCatcher()
-        {
-            Child = container = new Container
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-            };
-        }
+            typeof(CatcherArea),
+            typeof(CatcherSprite)
+        }).ToList();

        [BackgroundDependencyLoader]
        private void load()
        {
-            AddStep("show default catcher implementation", () => { container.Child = new CatcherSprite(); });
-
-            AddStep("show custom catcher implementation", () =>
+            SetContents(() => new Catcher
            {
-                container.Child = new CatchCustomSkinSourceContainer
-                {
-                    Child = new CatcherSprite()
-                };
+                RelativePositionAxes = Axes.None,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
            });
        }
-
-        private class CatcherCustomSkin : Container
-        {
-            public CatcherCustomSkin()
-            {
-                RelativeSizeAxes = Axes.Both;
-
-                Children = new Drawable[]
-                {
-                    new Box
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Colour = Color4.Blue
-                    },
-                    new OsuSpriteText
-                    {
-                        Text = "custom"
-                    }
-                };
-            }
-        }
-
-        [Cached(typeof(ISkinSource))]
-        private class CatchCustomSkinSourceContainer : Container, ISkinSource
-        {
-            public event Action SourceChanged
-            {
-                add { }
-                remove { }
-            }
-
-            public Drawable GetDrawableComponent(ISkinComponent component)
-            {
-                switch (component.LookupName)
-                {
-                    case "Gameplay/catch/fruit-catcher-idle":
-                        return new CatcherCustomSkin();
-                }
-
-                return null;
-            }
-
-            public SampleChannel GetSample(ISampleInfo sampleInfo) =>
-                throw new NotImplementedException();
-
-            public Texture GetTexture(string componentName) =>
-                throw new NotImplementedException();
-
-            public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => throw new NotImplementedException();
-        }
    }
 }
@@ -1,45 +1,86 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

-using System;
-using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+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.Tests.Visual;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI;

 namespace osu.Game.Rulesets.Catch.Tests
 {
    [TestFixture]
-    public class TestSceneCatcherArea : OsuTestScene
+    public class TestSceneCatcherArea : CatchSkinnableTestScene
    {
        private RulesetInfo catchRuleset;
-        private TestCatcherArea catcherArea;
-
-        public override IReadOnlyList<Type> RequiredTypes => new[]
-        {
-            typeof(CatcherArea),
-        };

        public TestSceneCatcherArea()
        {
            AddSliderStep<float>("CircleSize", 0, 8, 5, createCatcher);
-            AddToggleStep("Hyperdash", t => catcherArea.ToggleHyperDash(t));
+            AddToggleStep("Hyperdash", t =>
+                CreatedDrawables.OfType<CatchInputManager>().Select(i => i.Child)
+                                .OfType<TestCatcherArea>().ForEach(c => c.ToggleHyperDash(t)));
+
+            AddRepeatStep("catch fruit", () => catchFruit(new TestFruit(false)
+            {
+                X = this.ChildrenOfType<CatcherArea>().First().MovableCatcher.X
+            }), 20);
+            AddRepeatStep("catch fruit last in combo", () => catchFruit(new TestFruit(false)
+            {
+                X = this.ChildrenOfType<CatcherArea>().First().MovableCatcher.X,
+                LastInCombo = true,
+            }), 20);
+            AddRepeatStep("catch kiai fruit", () => catchFruit(new TestFruit(true)
+            {
+                X = this.ChildrenOfType<CatcherArea>().First().MovableCatcher.X,
+            }), 20);
+            AddRepeatStep("miss fruit", () => catchFruit(new Fruit
+            {
+                X = this.ChildrenOfType<CatcherArea>().First().MovableCatcher.X + 100,
+                LastInCombo = true,
+            }, true), 20);
+        }
+
+        private void catchFruit(Fruit fruit, bool miss = false)
+        {
+            this.ChildrenOfType<CatcherArea>().ForEach(area =>
+            {
+                DrawableFruit drawable = new DrawableFruit(fruit);
+                area.Add(drawable);
+
+                Schedule(() =>
+                {
+                    area.AttemptCatch(fruit);
+                    area.OnResult(drawable, new JudgementResult(fruit, new CatchJudgement()) { Type = miss ? HitResult.Miss : HitResult.Great });
+
+                    drawable.Expire();
+                });
+            });
        }

        private void createCatcher(float size)
        {
-            Child = new CatchInputManager(catchRuleset)
+            SetContents(() => new CatchInputManager(catchRuleset)
            {
                RelativeSizeAxes = Axes.Both,
-                Child = catcherArea = new TestCatcherArea(new BeatmapDifficulty { CircleSize = size })
+                Child = new TestCatcherArea(new BeatmapDifficulty { CircleSize = size })
                {
                    Anchor = Anchor.CentreLeft,
-                    Origin = Anchor.TopLeft
+                    Origin = Anchor.TopLeft,
+                    CreateDrawableRepresentation = ((DrawableRuleset<CatchHitObject>)catchRuleset.CreateInstance().CreateDrawableRulesetWith(new CatchBeatmap())).CreateDrawableRepresentation
                },
-            };
+            });
        }

        [BackgroundDependencyLoader]
@@ -48,6 +89,17 @@ 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)
@@ -55,6 +107,8 @@ namespace osu.Game.Rulesets.Catch.Tests
            {
            }

+            public new Catcher MovableCatcher => base.MovableCatcher;
+
            public void ToggleHyperDash(bool status) => MovableCatcher.SetHyperDashState(status ? 2 : 1);
        }
    }
@@ -4,13 +4,13 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using osu.Framework.Allocation;
+using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Catch.Objects;
-using osu.Game.Rulesets.Catch.Objects.Drawable;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Catch.Tests
    {
        public override IReadOnlyList<Type> RequiredTypes => new[]
        {
-            typeof(CatcherArea.Catcher),
+            typeof(Catcher),
            typeof(DrawableCatchRuleset),
            typeof(DrawableFruit),
            typeof(DrawableJuiceStream),
@@ -34,8 +34,8 @@ namespace osu.Game.Rulesets.Catch.Tests
        private DrawableCatchRuleset drawableRuleset;
        private double playfieldTime => drawableRuleset.Playfield.Time.Current;

-        [BackgroundDependencyLoader]
-        private void load()
+        [SetUp]
+        public void Setup() => Schedule(() =>
        {
            var controlPointInfo = new ControlPointInfo();
            controlPointInfo.Add(0, new TimingControlPoint());
@@ -57,7 +57,7 @@ namespace osu.Game.Rulesets.Catch.Tests
                ControlPointInfo = controlPointInfo
            });

-            Add(new Container
+            Child = new Container
            {
                Anchor = Anchor.Centre,
                Origin = Anchor.Centre,
@@ -66,16 +66,49 @@ namespace osu.Game.Rulesets.Catch.Tests
                {
                    drawableRuleset = new DrawableCatchRuleset(new CatchRuleset(), beatmap.GetPlayableBeatmap(new CatchRuleset().RulesetInfo))
                }
-            });
+            };
+        });
+
+        [Test]
+        public void TestFruits()
+        {
+            AddStep("hit fruits", () => spawnFruits(true));
+            AddUntilStep("wait for completion", () => playfieldIsEmpty);
+            AddAssert("catcher state is idle", () => catcherState == CatcherAnimationState.Idle);

            AddStep("miss fruits", () => spawnFruits());
-            AddStep("hit fruits", () => spawnFruits(true));
-            AddStep("miss juicestream", () => spawnJuiceStream());
-            AddStep("hit juicestream", () => spawnJuiceStream(true));
-            AddStep("miss bananas", () => spawnBananas());
-            AddStep("hit bananas", () => spawnBananas(true));
+            AddUntilStep("wait for completion", () => playfieldIsEmpty);
+            AddAssert("catcher state is failed", () => catcherState == CatcherAnimationState.Fail);
        }

+        [Test]
+        public void TestJuicestream()
+        {
+            AddStep("hit juicestream", () => spawnJuiceStream(true));
+            AddUntilStep("wait for completion", () => playfieldIsEmpty);
+            AddAssert("catcher state is idle", () => catcherState == CatcherAnimationState.Idle);
+
+            AddStep("miss juicestream", () => spawnJuiceStream());
+            AddUntilStep("wait for completion", () => playfieldIsEmpty);
+            AddAssert("catcher state is failed", () => catcherState == CatcherAnimationState.Fail);
+        }
+
+        [Test]
+        public void TestBananas()
+        {
+            AddStep("hit bananas", () => spawnBananas(true));
+            AddUntilStep("wait for completion", () => playfieldIsEmpty);
+            AddAssert("catcher state is idle", () => catcherState == CatcherAnimationState.Idle);
+
+            AddStep("miss bananas", () => spawnBananas());
+            AddUntilStep("wait for completion", () => playfieldIsEmpty);
+            AddAssert("catcher state is idle", () => catcherState == CatcherAnimationState.Idle);
+        }
+
+        private bool playfieldIsEmpty => !((CatchPlayfield)drawableRuleset.Playfield).AllHitObjects.Any(h => h.IsAlive);
+
+        private CatcherAnimationState catcherState => ((CatchPlayfield)drawableRuleset.Playfield).CatcherArea.MovableCatcher.CurrentState;
+
        private void spawnFruits(bool hit = false)
        {
            for (int i = 1; i <= 4; i++)
@@ -3,80 +3,116 @@

 using System;
 using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Catch.Objects;
-using osu.Game.Rulesets.Catch.Objects.Drawable;
-using osu.Game.Rulesets.Catch.Objects.Drawable.Pieces;
-using osu.Game.Tests.Visual;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
 using osuTK;

 namespace osu.Game.Rulesets.Catch.Tests
 {
    [TestFixture]
-    public class TestSceneFruitObjects : OsuTestScene
+    public class TestSceneFruitObjects : CatchSkinnableTestScene
    {
-        public override IReadOnlyList<Type> RequiredTypes => new[]
+        public override IReadOnlyList<Type> RequiredTypes => base.RequiredTypes.Concat(new[]
        {
            typeof(CatchHitObject),
            typeof(Fruit),
+            typeof(FruitPiece),
            typeof(Droplet),
+            typeof(Banana),
+            typeof(BananaShower),
            typeof(DrawableCatchHitObject),
            typeof(DrawableFruit),
            typeof(DrawableDroplet),
-            typeof(BananaShower),
+            typeof(DrawableBanana),
+            typeof(DrawableBananaShower),
            typeof(Pulp),
-        };
+        }).ToList();

-        public TestSceneFruitObjects()
+        protected override void LoadComplete()
        {
-            Add(new GridContainer
-            {
-                RelativeSizeAxes = Axes.Both,
-                Content = new[]
-                {
-                    new Drawable[]
-                    {
-                        createDrawable(0),
-                        createDrawable(1),
-                        createDrawable(2),
-                    },
-                    new Drawable[]
-                    {
-                        createDrawable(3),
-                        createDrawable(4),
-                        createDrawable(5),
-                    },
-                }
-            });
+            base.LoadComplete();
+
+            foreach (FruitVisualRepresentation rep in Enum.GetValues(typeof(FruitVisualRepresentation)))
+                AddStep($"show {rep}", () => SetContents(() => createDrawable(rep)));
+
+            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)));
        }

-        private DrawableFruit createDrawable(int index)
+        private Drawable createDrawableTinyDroplet()
        {
-            Fruit fruit = index == 5
-                ? new Banana
-                {
-                    StartTime = 1000000000000,
-                    IndexInBeatmap = index,
-                    Scale = 1.5f,
-                }
-                : new Fruit
-                {
-                    StartTime = 1000000000000,
-                    IndexInBeatmap = index,
-                    Scale = 1.5f,
-                };
+            var droplet = new TinyDroplet
+            {
+                StartTime = Clock.CurrentTime,
+                Scale = 1.5f,
+            };

-            return new DrawableFruit(fruit)
+            return new DrawableTinyDroplet(droplet)
            {
                Anchor = Anchor.Centre,
-                RelativePositionAxes = Axes.Both,
+                RelativePositionAxes = Axes.None,
                Position = Vector2.Zero,
                Alpha = 1,
                LifetimeStart = double.NegativeInfinity,
                LifetimeEnd = double.PositiveInfinity,
            };
        }
+
+        private Drawable createDrawableDroplet()
+        {
+            var droplet = new Droplet
+            {
+                StartTime = Clock.CurrentTime,
+                Scale = 1.5f,
+            };
+
+            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; }
+        }
    }
 }
@@ -1,16 +1,28 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using System;
+using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Tests.Visual;
+using osuTK;

 namespace osu.Game.Rulesets.Catch.Tests
 {
    [TestFixture]
    public class TestSceneHyperDash : PlayerTestScene
    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(CatcherArea),
+        };
+
        public TestSceneHyperDash()
            : base(new CatchRuleset())
        {
@@ -22,8 +34,19 @@ namespace osu.Game.Rulesets.Catch.Tests
        public void TestHyperDash()
        {
            AddAssert("First note is hyperdash", () => Beatmap.Value.Beatmap.HitObjects[0] is Fruit f && f.HyperDash);
+            AddUntilStep("wait for right movement", () => getCatcher().Scale.X > 0); // don't check hyperdashing as it happens too fast.
+
+            AddUntilStep("wait for left movement", () => getCatcher().Scale.X < 0);
+
+            for (int i = 0; i < 3; i++)
+            {
+                AddUntilStep("wait for right hyperdash", () => getCatcher().Scale.X > 0 && getCatcher().HyperDashing);
+                AddUntilStep("wait for left hyperdash", () => getCatcher().Scale.X < 0 && getCatcher().HyperDashing);
+            }
        }

+        private Catcher getCatcher() => Player.ChildrenOfType<CatcherArea>().First().MovableCatcher;
+
        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset)
        {
            var beatmap = new Beatmap
@@ -35,17 +58,52 @@ namespace osu.Game.Rulesets.Catch.Tests
                }
            };

-            // Should produce a hyper-dash
-            beatmap.HitObjects.Add(new Fruit { StartTime = 816, X = 308 / 512f, NewCombo = true });
-            beatmap.HitObjects.Add(new Fruit { StartTime = 1008, X = 56 / 512f, });
+            // Should produce a hyper-dash (edge case test)
+            beatmap.HitObjects.Add(new Fruit { StartTime = 1816, X = 56 / 512f, NewCombo = true });
+            beatmap.HitObjects.Add(new Fruit { StartTime = 2008, X = 308 / 512f, NewCombo = true });

-            for (int i = 0; i < 512; i++)
-            {
-                if (i % 5 < 3)
-                    beatmap.HitObjects.Add(new Fruit { X = i % 10 < 5 ? 0.02f : 0.98f, StartTime = 2000 + i * 100, NewCombo = i % 8 == 0 });
-            }
+            double startTime = 3000;
+
+            const float left_x = 0.02f;
+            const float right_x = 0.98f;
+
+            createObjects(() => new Fruit { X = left_x });
+            createObjects(() => new TestJuiceStream(right_x), 1);
+            createObjects(() => new TestJuiceStream(left_x), 1);
+            createObjects(() => new Fruit { X = right_x });
+            createObjects(() => new Fruit { X = left_x });
+            createObjects(() => new Fruit { X = right_x });
+            createObjects(() => new TestJuiceStream(left_x), 1);

            return beatmap;
+
+            void createObjects(Func<CatchHitObject> createObject, int count = 3)
+            {
+                const float spacing = 140;
+
+                for (int i = 0; i < count; i++)
+                {
+                    var hitObject = createObject();
+                    hitObject.StartTime = startTime + i * spacing;
+                    beatmap.HitObjects.Add(hitObject);
+                }
+
+                startTime += 700;
+            }
+        }
+
+        private class TestJuiceStream : JuiceStream
+        {
+            public TestJuiceStream(float x)
+            {
+                X = x;
+
+                Path = new SliderPath(new[]
+                {
+                    new PathControlPoint(Vector2.Zero),
+                    new PathControlPoint(new Vector2(30, 0)),
+                });
+            }
        }
    }
 }
@@ -0,0 +1,132 @@
+// 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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Rulesets.Catch.Skinning;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Skinning;
+using osu.Game.Tests.Visual;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    public class TestSceneHyperDashColouring : OsuTestScene
+    {
+        [Resolved]
+        private SkinManager skins { get; set; }
+
+        [Test]
+        public void TestDefaultFruitColour()
+        {
+            var skin = new TestSkin();
+
+            checkHyperDashFruitColour(skin, Catcher.DEFAULT_HYPER_DASH_COLOUR);
+        }
+
+        [Test]
+        public void TestCustomFruitColour()
+        {
+            var skin = new TestSkin
+            {
+                HyperDashFruitColour = Color4.Cyan
+            };
+
+            checkHyperDashFruitColour(skin, skin.HyperDashFruitColour);
+        }
+
+        [Test]
+        public void TestCustomFruitColourPriority()
+        {
+            var skin = new TestSkin
+            {
+                HyperDashColour = Color4.Goldenrod,
+                HyperDashFruitColour = Color4.Cyan
+            };
+
+            checkHyperDashFruitColour(skin, skin.HyperDashFruitColour);
+        }
+
+        [Test]
+        public void TestFruitColourFallback()
+        {
+            var skin = new TestSkin
+            {
+                HyperDashColour = Color4.Goldenrod
+            };
+
+            checkHyperDashFruitColour(skin, skin.HyperDashColour);
+        }
+
+        private void checkHyperDashFruitColour(ISkin skin, Color4 expectedColour)
+        {
+            DrawableFruit drawableFruit = null;
+
+            AddStep("create hyper-dash fruit", () =>
+            {
+                var fruit = new Fruit { HyperDashTarget = new Banana() };
+                fruit.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+                Child = setupSkinHierarchy(drawableFruit = new DrawableFruit(fruit)
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Scale = new Vector2(4f),
+                }, skin);
+            });
+
+            AddAssert("hyper-dash colour is correct", () => checkLegacyFruitHyperDashColour(drawableFruit, expectedColour));
+        }
+
+        private Drawable setupSkinHierarchy(Drawable child, ISkin skin)
+        {
+            var legacySkinProvider = new SkinProvidingContainer(skins.GetSkin(DefaultLegacySkin.Info));
+            var testSkinProvider = new SkinProvidingContainer(skin);
+            var legacySkinTransformer = new SkinProvidingContainer(new CatchLegacySkinTransformer(testSkinProvider));
+
+            return legacySkinProvider
+                .WithChild(testSkinProvider
+                    .WithChild(legacySkinTransformer
+                        .WithChild(child)));
+        }
+
+        private bool checkLegacyFruitHyperDashColour(DrawableFruit fruit, Color4 expectedColour) =>
+            fruit.ChildrenOfType<SkinnableDrawable>().First().Drawable.ChildrenOfType<Sprite>().Any(c => c.Colour == expectedColour);
+
+        private class TestSkin : LegacySkin
+        {
+            public Color4 HyperDashColour
+            {
+                get => Configuration.CustomColours[CatchSkinColour.HyperDash.ToString()];
+                set => Configuration.CustomColours[CatchSkinColour.HyperDash.ToString()] = value;
+            }
+
+            public Color4 HyperDashAfterImageColour
+            {
+                get => Configuration.CustomColours[CatchSkinColour.HyperDashAfterImage.ToString()];
+                set => Configuration.CustomColours[CatchSkinColour.HyperDashAfterImage.ToString()] = value;
+            }
+
+            public Color4 HyperDashFruitColour
+            {
+                get => Configuration.CustomColours[CatchSkinColour.HyperDashFruit.ToString()];
+                set => Configuration.CustomColours[CatchSkinColour.HyperDashFruit.ToString()] = value;
+            }
+
+            public TestSkin()
+                : base(new SkinInfo(), null, null, string.Empty)
+            {
+            }
+        }
+    }
+}
@@ -0,0 +1,56 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    public class TestSceneJuiceStream : PlayerTestScene
+    {
+        public TestSceneJuiceStream()
+            : base(new CatchRuleset())
+        {
+        }
+
+        [Test]
+        public void TestJuiceStreamEndingCombo()
+        {
+            AddUntilStep("player is done", () => !Player.ValidForResume);
+        }
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new Beatmap
+        {
+            BeatmapInfo = new BeatmapInfo
+            {
+                BaseDifficulty = new BeatmapDifficulty { CircleSize = 5, SliderMultiplier = 2 },
+                Ruleset = ruleset
+            },
+            HitObjects = new List<HitObject>
+            {
+                new JuiceStream
+                {
+                    X = 0.5f,
+                    Path = new SliderPath(PathType.Linear, new[]
+                    {
+                        Vector2.Zero,
+                        new Vector2(0, 100)
+                    }),
+                    StartTime = 200
+                },
+                new Banana
+                {
+                    X = 0.5f,
+                    StartTime = 1000,
+                    NewCombo = true
+                }
+            }
+        };
+    }
+}
@@ -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.4.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.6.1" />
    <PackageReference Include="NUnit" Version="3.12.0" />
    <PackageReference Include="NUnit3TestAdapter" Version="3.15.1" />
    <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
@@ -28,15 +28,18 @@ namespace osu.Game.Rulesets.Catch.Beatmaps

            ApplyPositionOffsets(Beatmap);

-            initialiseHyperDash((List<CatchHitObject>)Beatmap.HitObjects);
-
            int index = 0;

            foreach (var obj in Beatmap.HitObjects.OfType<CatchHitObject>())
            {
-                obj.IndexInBeatmap = index++;
+                obj.IndexInBeatmap = index;
+                foreach (var nested in obj.NestedHitObjects.OfType<CatchHitObject>())
+                    nested.IndexInBeatmap = index;
+
                if (obj.LastInCombo && obj.NestedHitObjects.LastOrDefault() is IHasComboInformation lastNested)
                    lastNested.LastInCombo = true;
+
+                index++;
            }
        }

@@ -71,6 +74,12 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                        break;

                    case JuiceStream juiceStream:
+                        // Todo: BUG!! Stable used the last control point as the final position of the path, but it should use the computed path instead.
+                        lastPosition = juiceStream.X + juiceStream.Path.ControlPoints[^1].Position.Value.X / CatchPlayfield.BASE_WIDTH;
+
+                        // Todo: BUG!! Stable attempted to use the end time of the stream, but referenced it too early in execution and used the start time instead.
+                        lastStartTime = juiceStream.StartTime;
+
                        foreach (var nested in juiceStream.NestedHitObjects)
                        {
                            var catchObject = (CatchHitObject)nested;
@@ -85,20 +94,12 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                        break;
                }
            }
+
+            initialiseHyperDash(beatmap);
        }

        private static void applyHardRockOffset(CatchHitObject hitObject, ref float? lastPosition, ref double lastStartTime, FastRandom rng)
        {
-            if (hitObject is JuiceStream stream)
-            {
-                lastPosition = stream.EndX;
-                lastStartTime = stream.EndTime;
-                return;
-            }
-
-            if (!(hitObject is Fruit))
-                return;
-
            float offsetPosition = hitObject.X;
            double startTime = hitObject.StartTime;

@@ -111,7 +112,9 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
            }

            float positionDiff = offsetPosition - lastPosition.Value;
-            double timeDiff = startTime - lastStartTime;
+
+            // Todo: BUG!! Stable calculated time deltas as ints, which affects randomisation. This should be changed to a double.
+            int timeDiff = (int)(startTime - lastStartTime);

            if (timeDiff > 1000)
            {
@@ -127,7 +130,8 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                return;
            }

-            if (Math.Abs(positionDiff * CatchPlayfield.BASE_WIDTH) < timeDiff / 3d)
+            // ReSharper disable once PossibleLossOfFraction
+            if (Math.Abs(positionDiff * CatchPlayfield.BASE_WIDTH) < timeDiff / 3)
                applyOffset(ref offsetPosition, positionDiff);

            hitObject.XOffset = offsetPosition - hitObject.X;
@@ -186,14 +190,14 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
            }
        }

-        private void initialiseHyperDash(List<CatchHitObject> objects)
+        private static void initialiseHyperDash(IBeatmap beatmap)
        {
            List<CatchHitObject> objectWithDroplets = new List<CatchHitObject>();

-            foreach (var currentObject in objects)
+            foreach (var currentObject in beatmap.HitObjects)
            {
-                if (currentObject is Fruit)
-                    objectWithDroplets.Add(currentObject);
+                if (currentObject is Fruit fruitObject)
+                    objectWithDroplets.Add(fruitObject);

                if (currentObject is JuiceStream)
                {
@@ -207,7 +211,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps

            objectWithDroplets.Sort((h1, h2) => h1.StartTime.CompareTo(h2.StartTime));

-            double halfCatcherWidth = CatcherArea.GetCatcherSize(Beatmap.BeatmapInfo.BaseDifficulty) / 2;
+            double halfCatcherWidth = CatcherArea.GetCatcherSize(beatmap.BeatmapInfo.BaseDifficulty) / 2;
            int lastDirection = 0;
            double lastExcess = halfCatcherWidth;

@@ -216,10 +220,14 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                CatchHitObject currentObject = objectWithDroplets[i];
                CatchHitObject nextObject = objectWithDroplets[i + 1];

+                // Reset variables in-case values have changed (e.g. after applying HR)
+                currentObject.HyperDashTarget = null;
+                currentObject.DistanceToHyperDash = 0;
+
                int thisDirection = nextObject.X > currentObject.X ? 1 : -1;
                double timeToNext = nextObject.StartTime - currentObject.StartTime - 1000f / 60f / 4; // 1/4th of a frame of grace time, taken from osu-stable
                double distanceToNext = Math.Abs(nextObject.X - currentObject.X) - (lastDirection == thisDirection ? lastExcess : halfCatcherWidth);
-                float distanceToHyper = (float)(timeToNext * CatcherArea.Catcher.BASE_SPEED - distanceToNext);
+                float distanceToHyper = (float)(timeToNext * Catcher.BASE_SPEED - distanceToNext);

                if (distanceToHyper < 0)
                {
@@ -21,6 +21,8 @@ using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 using System;
+using osu.Game.Rulesets.Catch.Skinning;
+using osu.Game.Skinning;

 namespace osu.Game.Rulesets.Catch
 {
@@ -46,7 +48,7 @@ namespace osu.Game.Rulesets.Catch
            new KeyBinding(InputKey.Shift, CatchAction.Dash),
        };

-        public override IEnumerable<Mod> ConvertLegacyMods(LegacyMods mods)
+        public override IEnumerable<Mod> ConvertFromLegacyMods(LegacyMods mods)
        {
            if (mods.HasFlag(LegacyMods.Nightcore))
                yield return new CatchModNightcore();
@@ -141,6 +143,8 @@ namespace osu.Game.Rulesets.Catch

        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 int LegacyID => 2;
@@ -5,5 +5,14 @@ namespace osu.Game.Rulesets.Catch
 {
    public enum CatchSkinComponents
    {
+        FruitBananas,
+        FruitApple,
+        FruitGrapes,
+        FruitOrange,
+        FruitPear,
+        Droplet,
+        CatcherIdle,
+        CatcherFail,
+        CatcherKiai
    }
 }
@@ -19,10 +19,12 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 {
    public class CatchDifficultyCalculator : DifficultyCalculator
    {
-        private const double star_scaling_factor = 0.145;
+        private const double star_scaling_factor = 0.153;

        protected override int SectionLength => 750;

+        private float halfCatcherWidth;
+
        public CatchDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
            : base(ruleset, beatmap)
        {
@@ -48,14 +50,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty

        protected override IEnumerable<DifficultyHitObject> CreateDifficultyHitObjects(IBeatmap beatmap, double clockRate)
        {
-            float halfCatchWidth;
-
-            using (var catcher = new CatcherArea.Catcher(beatmap.BeatmapInfo.BaseDifficulty))
-            {
-                halfCatchWidth = catcher.CatchWidth * 0.5f;
-                halfCatchWidth *= 0.8f; // We're only using 80% of the catcher's width to simulate imperfect gameplay.
-            }
-
            CatchHitObject lastObject = null;

            // In 2B beatmaps, it is possible that a normal Fruit is placed in the middle of a JuiceStream.
@@ -69,16 +63,24 @@ namespace osu.Game.Rulesets.Catch.Difficulty
                    continue;

                if (lastObject != null)
-                    yield return new CatchDifficultyHitObject(hitObject, lastObject, clockRate, halfCatchWidth);
+                    yield return new CatchDifficultyHitObject(hitObject, lastObject, clockRate, halfCatcherWidth);

                lastObject = hitObject;
            }
        }

-        protected override Skill[] CreateSkills(IBeatmap beatmap) => new Skill[]
+        protected override Skill[] CreateSkills(IBeatmap beatmap)
        {
-            new Movement(),
-        };
+            halfCatcherWidth = Catcher.CalculateCatchWidth(beatmap.BeatmapInfo.BaseDifficulty) * 0.5f;
+
+            // For circle sizes above 5.5, reduce the catcher width further to simulate imperfect gameplay.
+            halfCatcherWidth *= 1 - (Math.Max(0, beatmap.BeatmapInfo.BaseDifficulty.CircleSize - 5.5f) * 0.0625f);
+
+            return new Skill[]
+            {
+                new Movement(halfCatcherWidth),
+            };
+        }

        protected override Mod[] DifficultyAdjustmentMods => new Mod[]
        {
@@ -52,8 +52,8 @@ namespace osu.Game.Rulesets.Catch.Difficulty

            // Longer maps are worth more
            double lengthBonus =
-                0.95 + 0.4 * Math.Min(1.0, numTotalHits / 3000.0) +
-                (numTotalHits > 3000 ? Math.Log10(numTotalHits / 3000.0) * 0.5 : 0.0);
+                0.95f + 0.3f * Math.Min(1.0f, numTotalHits / 2500.0f) +
+                (numTotalHits > 2500 ? (float)Math.Log10(numTotalHits / 2500.0f) * 0.475f : 0.0f);

            // Longer maps are worth more
            value *= lengthBonus;
@@ -63,19 +63,28 @@ namespace osu.Game.Rulesets.Catch.Difficulty

            // Combo scaling
            if (Attributes.MaxCombo > 0)
-                value *= Math.Min(Math.Pow(Attributes.MaxCombo, 0.8) / Math.Pow(Attributes.MaxCombo, 0.8), 1.0);
+                value *= Math.Min(Math.Pow(Score.MaxCombo, 0.8) / Math.Pow(Attributes.MaxCombo, 0.8), 1.0);

-            double approachRateFactor = 1.0;
-            if (Attributes.ApproachRate > 9.0)
-                approachRateFactor += 0.1 * (Attributes.ApproachRate - 9.0); // 10% for each AR above 9
-            else if (Attributes.ApproachRate < 8.0)
-                approachRateFactor += 0.025 * (8.0 - Attributes.ApproachRate); // 2.5% for each AR below 8
+            float approachRate = (float)Attributes.ApproachRate;
+            float approachRateFactor = 1.0f;
+            if (approachRate > 9.0f)
+                approachRateFactor += 0.1f * (approachRate - 9.0f); // 10% for each AR above 9
+            if (approachRate > 10.0f)
+                approachRateFactor += 0.1f * (approachRate - 10.0f); // Additional 10% at AR 11, 30% total
+            else if (approachRate < 8.0f)
+                approachRateFactor += 0.025f * (8.0f - approachRate); // 2.5% for each AR below 8

            value *= approachRateFactor;

            if (mods.Any(m => m is ModHidden))
-                // Hiddens gives nothing on max approach rate, and more the lower it is
+            {
                value *= 1.05 + 0.075 * (10.0 - Math.Min(10.0, Attributes.ApproachRate)); // 7.5% for each AR below 10
+                // Hiddens gives almost nothing on max approach rate, and more the lower it is
+                if (approachRate <= 10.0f)
+                    value *= 1.05f + 0.075f * (10.0f - approachRate); // 7.5% for each AR below 10
+                else if (approachRate > 10.0f)
+                    value *= 1.01f + 0.04f * (11.0f - Math.Min(11.0f, approachRate)); // 5% at AR 10, 1% at AR 11
+            }

            if (mods.Any(m => m is ModFlashlight))
                // Apply length bonus again if flashlight is on simply because it becomes a lot harder on longer maps.
@@ -21,10 +21,12 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Preprocessing
        public readonly float LastNormalizedPosition;

        /// <summary>
-        /// Milliseconds elapsed since the start time of the previous <see cref="CatchDifficultyHitObject"/>, with a minimum of 25ms.
+        /// Milliseconds elapsed since the start time of the previous <see cref="CatchDifficultyHitObject"/>, with a minimum of 40ms.
        /// </summary>
        public readonly double StrainTime;

+        public readonly double ClockRate;
+
        public CatchDifficultyHitObject(HitObject hitObject, HitObject lastObject, double clockRate, float halfCatcherWidth)
            : base(hitObject, lastObject, clockRate)
        {
@@ -34,8 +36,9 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Preprocessing
            NormalizedPosition = BaseObject.X * CatchPlayfield.BASE_WIDTH * scalingFactor;
            LastNormalizedPosition = LastObject.X * CatchPlayfield.BASE_WIDTH * scalingFactor;

-            // Every strain interval is hard capped at the equivalent of 600 BPM streaming speed as a safety measure
-            StrainTime = Math.Max(25, DeltaTime);
+            // Every strain interval is hard capped at the equivalent of 375 BPM streaming speed as a safety measure
+            StrainTime = Math.Max(40, DeltaTime);
+            ClockRate = clockRate;
        }
    }
 }
@@ -13,15 +13,23 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
    {
        private const float absolute_player_positioning_error = 16f;
        private const float normalized_hitobject_radius = 41.0f;
-        private const double direction_change_bonus = 12.5;
+        private const double direction_change_bonus = 21.0;

-        protected override double SkillMultiplier => 850;
+        protected override double SkillMultiplier => 900;
        protected override double StrainDecayBase => 0.2;

        protected override double DecayWeight => 0.94;

+        protected readonly float HalfCatcherWidth;
+
        private float? lastPlayerPosition;
        private float lastDistanceMoved;
+        private double lastStrainTime;
+
+        public Movement(float halfCatcherWidth)
+        {
+            HalfCatcherWidth = halfCatcherWidth;
+        }

        protected override double StrainValueOf(DifficultyHitObject current)
        {
@@ -38,47 +46,47 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills

            float distanceMoved = playerPosition - lastPlayerPosition.Value;

-            double distanceAddition = Math.Pow(Math.Abs(distanceMoved), 1.3) / 500;
-            double sqrtStrain = Math.Sqrt(catchCurrent.StrainTime);
+            double weightedStrainTime = catchCurrent.StrainTime + 13 + (3 / catchCurrent.ClockRate);

-            double bonus = 0;
+            double distanceAddition = (Math.Pow(Math.Abs(distanceMoved), 1.3) / 510);
+            double sqrtStrain = Math.Sqrt(weightedStrainTime);

-            // Direction changes give an extra point!
+            double edgeDashBonus = 0;
+
+            // Direction change bonus.
            if (Math.Abs(distanceMoved) > 0.1)
            {
                if (Math.Abs(lastDistanceMoved) > 0.1 && Math.Sign(distanceMoved) != Math.Sign(lastDistanceMoved))
                {
-                    double bonusFactor = Math.Min(absolute_player_positioning_error, Math.Abs(distanceMoved)) / absolute_player_positioning_error;
+                    double bonusFactor = Math.Min(50, Math.Abs(distanceMoved)) / 50;
+                    double antiflowFactor = Math.Max(Math.Min(70, Math.Abs(lastDistanceMoved)) / 70, 0.38);

-                    distanceAddition += direction_change_bonus / sqrtStrain * bonusFactor;
-
-                    // Bonus for tougher direction switches and "almost" hyperdashes at this point
-                    if (catchCurrent.LastObject.DistanceToHyperDash <= 10 / CatchPlayfield.BASE_WIDTH)
-                        bonus = 0.3 * bonusFactor;
+                    distanceAddition += direction_change_bonus / Math.Sqrt(lastStrainTime + 16) * bonusFactor * antiflowFactor * Math.Max(1 - Math.Pow(weightedStrainTime / 1000, 3), 0);
                }

                // Base bonus for every movement, giving some weight to streams.
-                distanceAddition += 7.5 * Math.Min(Math.Abs(distanceMoved), normalized_hitobject_radius * 2) / (normalized_hitobject_radius * 6) / sqrtStrain;
+                distanceAddition += 12.5 * Math.Min(Math.Abs(distanceMoved), normalized_hitobject_radius * 2) / (normalized_hitobject_radius * 6) / sqrtStrain;
            }

-            // Bonus for "almost" hyperdashes at corner points
-            if (catchCurrent.LastObject.DistanceToHyperDash <= 10.0f / CatchPlayfield.BASE_WIDTH)
+            // Bonus for edge dashes.
+            if (catchCurrent.LastObject.DistanceToHyperDash <= 20.0f / CatchPlayfield.BASE_WIDTH)
            {
                if (!catchCurrent.LastObject.HyperDash)
-                    bonus += 1.0;
+                    edgeDashBonus += 5.7;
                else
                {
                    // After a hyperdash we ARE in the correct position. Always!
                    playerPosition = catchCurrent.NormalizedPosition;
                }

-                distanceAddition *= 1.0 + bonus * ((10 - catchCurrent.LastObject.DistanceToHyperDash * CatchPlayfield.BASE_WIDTH) / 10);
+                distanceAddition *= 1.0 + edgeDashBonus * ((20 - catchCurrent.LastObject.DistanceToHyperDash * CatchPlayfield.BASE_WIDTH) / 20) * Math.Pow((Math.Min(catchCurrent.StrainTime * catchCurrent.ClockRate, 265) / 265), 1.5); // Edge Dashes are easier at lower ms values
            }

            lastPlayerPosition = playerPosition;
            lastDistanceMoved = distanceMoved;
+            lastStrainTime = catchCurrent.StrainTime;

-            return distanceAddition / catchCurrent.StrainTime;
+            return distanceAddition / weightedStrainTime;
        }
    }
 }
@@ -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.Linq;
 using osu.Framework.Bindables;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
@@ -10,7 +11,7 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
    public class CatchModDifficultyAdjust : ModDifficultyAdjust
    {
-        [SettingSource("Fruit Size", "Override a beatmap's set CS.")]
+        [SettingSource("Circle Size", "Override a beatmap's set CS.", FIRST_SETTING_ORDER - 1)]
        public BindableNumber<float> CircleSize { get; } = new BindableFloat
        {
            Precision = 0.1f,
@@ -20,7 +21,7 @@ namespace osu.Game.Rulesets.Catch.Mods
            Value = 5,
        };

-        [SettingSource("Approach Rate", "Override a beatmap's set AR.")]
+        [SettingSource("Approach Rate", "Override a beatmap's set AR.", LAST_SETTING_ORDER + 1)]
        public BindableNumber<float> ApproachRate { get; } = new BindableFloat
        {
            Precision = 0.1f,
@@ -30,6 +31,22 @@ namespace osu.Game.Rulesets.Catch.Mods
            Value = 5,
        };

+        public override string SettingDescription
+        {
+            get
+            {
+                string circleSize = CircleSize.IsDefault ? string.Empty : $"CS {CircleSize.Value:N1}";
+                string approachRate = ApproachRate.IsDefault ? string.Empty : $"AR {ApproachRate.Value:N1}";
+
+                return string.Join(", ", new[]
+                {
+                    circleSize,
+                    base.SettingDescription,
+                    approachRate
+                }.Where(s => !string.IsNullOrEmpty(s)));
+            }
+        }
+
        protected override void TransferSettings(BeatmapDifficulty difficulty)
        {
            base.TransferSettings(difficulty);
@@ -3,7 +3,7 @@

 using System.Linq;
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Catch.Objects.Drawable;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;

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

+using osu.Game.Rulesets.Catch.Judgements;
+using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;

 namespace osu.Game.Rulesets.Catch.Mods
 {
    public class CatchModPerfect : ModPerfect
    {
+        protected override bool FailCondition(HealthProcessor healthProcessor, JudgementResult result)
+            => !(result.Judgement is CatchBananaJudgement)
+               && base.FailCondition(healthProcessor, result);
    }
 }
@@ -9,22 +9,31 @@ using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play;
 using osuTK;

 namespace osu.Game.Rulesets.Catch.Mods
 {
-    public class CatchModRelax : ModRelax, IApplicableToDrawableRuleset<CatchHitObject>
+    public class CatchModRelax : ModRelax, IApplicableToDrawableRuleset<CatchHitObject>, IApplicableToPlayer
    {
        public override string Description => @"Use the mouse to control the catcher.";

+        private DrawableRuleset<CatchHitObject> drawableRuleset;
+
        public void ApplyToDrawableRuleset(DrawableRuleset<CatchHitObject> drawableRuleset)
        {
-            drawableRuleset.Cursor.Add(new MouseInputHelper((CatchPlayfield)drawableRuleset.Playfield));
+            this.drawableRuleset = drawableRuleset;
+        }
+
+        public void ApplyToPlayer(Player player)
+        {
+            if (!drawableRuleset.HasReplayLoaded.Value)
+                drawableRuleset.Cursor.Add(new MouseInputHelper((CatchPlayfield)drawableRuleset.Playfield));
        }

        private class MouseInputHelper : Drawable, IKeyBindingHandler<CatchAction>, IRequireHighFrequencyMousePosition
        {
-            private readonly CatcherArea.Catcher catcher;
+            private readonly Catcher catcher;

            public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;

@@ -34,7 +43,7 @@ namespace osu.Game.Rulesets.Catch.Mods
                RelativeSizeAxes = Axes.Both;
            }

-            //disable keyboard controls
+            // disable keyboard controls
            public bool OnPressed(CatchAction action) => true;

            public void OnReleased(CatchAction action)
@@ -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 osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Types;

 namespace osu.Game.Rulesets.Catch.Objects
@@ -11,6 +12,8 @@ namespace osu.Game.Rulesets.Catch.Objects

        public override bool LastInCombo => true;

+        public override Judgement CreateJudgement() => new IgnoreJudgement();
+
        protected override void CreateNestedHitObjects()
        {
            base.CreateNestedHitObjects();
@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Catch.Objects
 {
    public abstract class CatchHitObject : HitObject, IHasXPosition, IHasComboInformation
    {
-        public const double OBJECT_RADIUS = 44;
+        public const float OBJECT_RADIUS = 64;

        private float x;

@@ -32,7 +32,7 @@ namespace osu.Game.Rulesets.Catch.Objects

        public int IndexInBeatmap { get; set; }

-        public virtual FruitVisualRepresentation VisualRepresentation => (FruitVisualRepresentation)(ComboIndex % 4);
+        public virtual FruitVisualRepresentation VisualRepresentation => (FruitVisualRepresentation)(IndexInBeatmap % 4);

        public virtual bool NewCombo { get; set; }

@@ -90,7 +90,7 @@ namespace osu.Game.Rulesets.Catch.Objects

            TimePreempt = (float)BeatmapDifficulty.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450);

-            Scale = 1.0f - 0.7f * (difficulty.CircleSize - 5) / 5;
+            Scale = (1.0f - 0.7f * (difficulty.CircleSize - 5) / 5) / 2;
        }

        protected override HitWindows CreateHitWindows() => HitWindows.Empty;
@@ -100,8 +100,8 @@ namespace osu.Game.Rulesets.Catch.Objects
    {
        Pear,
        Grape,
-        Raspberry,
        Pineapple,
+        Raspberry,
        Banana // banananananannaanana
    }
 }
@@ -1,13 +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.
-
-namespace osu.Game.Rulesets.Catch.Objects.Drawable
-{
-    public class DrawableBanana : DrawableFruit
-    {
-        public DrawableBanana(Banana h)
-            : base(h)
-        {
-        }
-    }
-}
@@ -1,33 +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.Game.Rulesets.Catch.Objects.Drawable.Pieces;
-using osuTK;
-
-namespace osu.Game.Rulesets.Catch.Objects.Drawable
-{
-    public class DrawableDroplet : PalpableCatchHitObject<Droplet>
-    {
-        private Pulp pulp;
-
-        public override bool StaysOnPlate => false;
-
-        public DrawableDroplet(Droplet h)
-            : base(h)
-        {
-            Origin = Anchor.Centre;
-            Size = new Vector2((float)CatchHitObject.OBJECT_RADIUS) / 4;
-            Masking = false;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            AddInternal(pulp = new Pulp { Size = Size });
-
-            AccentColour.BindValueChanged(colour => { pulp.AccentColour = colour.NewValue; }, true);
-        }
-    }
-}
@@ -1,316 +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.Extensions.Color4Extensions;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Effects;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Utils;
-using osu.Game.Rulesets.Catch.Objects.Drawable.Pieces;
-using osuTK;
-using osuTK.Graphics;
-
-namespace osu.Game.Rulesets.Catch.Objects.Drawable
-{
-    public class DrawableFruit : PalpableCatchHitObject<Fruit>
-    {
-        private Circle border;
-
-        private const float drawable_radius = (float)CatchHitObject.OBJECT_RADIUS * radius_adjust;
-
-        /// <summary>
-        /// Because we're adding a border around the fruit, we need to scale down some.
-        /// </summary>
-        private const float radius_adjust = 1.1f;
-
-        public DrawableFruit(Fruit h)
-            : base(h)
-        {
-            Origin = Anchor.Centre;
-
-            Size = new Vector2(drawable_radius);
-            Masking = false;
-
-            Rotation = (float)(RNG.NextDouble() - 0.5f) * 40;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            // todo: this should come from the skin.
-            AccentColour.Value = colourForRepresentation(HitObject.VisualRepresentation);
-
-            AddRangeInternal(new[]
-            {
-                createPulp(HitObject.VisualRepresentation),
-                border = new Circle
-                {
-                    EdgeEffect = new EdgeEffectParameters
-                    {
-                        Hollow = !HitObject.HyperDash,
-                        Type = EdgeEffectType.Glow,
-                        Radius = 4 * radius_adjust,
-                        Colour = HitObject.HyperDash ? Color4.Red : AccentColour.Value.Darken(1).Opacity(0.6f)
-                    },
-                    Size = new Vector2(Height),
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    BorderColour = Color4.White,
-                    BorderThickness = 3f * radius_adjust,
-                    Children = new Framework.Graphics.Drawable[]
-                    {
-                        new Box
-                        {
-                            AlwaysPresent = true,
-                            Colour = AccentColour.Value,
-                            Alpha = 0,
-                            RelativeSizeAxes = Axes.Both
-                        }
-                    }
-                },
-            });
-
-            if (HitObject.HyperDash)
-            {
-                AddInternal(new Pulp
-                {
-                    RelativePositionAxes = Axes.Both,
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    AccentColour = Color4.Red,
-                    Blending = BlendingParameters.Additive,
-                    Alpha = 0.5f,
-                    Scale = new Vector2(1.333f)
-                });
-            }
-        }
-
-        private Framework.Graphics.Drawable createPulp(FruitVisualRepresentation representation)
-        {
-            const float large_pulp_3 = 8f * radius_adjust;
-            const float distance_from_centre_3 = 0.15f;
-
-            const float large_pulp_4 = large_pulp_3 * 0.925f;
-            const float distance_from_centre_4 = distance_from_centre_3 / 0.925f;
-
-            const float small_pulp = large_pulp_3 / 2;
-
-            static Vector2 positionAt(float angle, float distance) => new Vector2(
-                distance * MathF.Sin(angle * MathF.PI / 180),
-                distance * MathF.Cos(angle * MathF.PI / 180));
-
-            switch (representation)
-            {
-                default:
-                    return new Container();
-
-                case FruitVisualRepresentation.Raspberry:
-                    return new Container
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Children = new Framework.Graphics.Drawable[]
-                        {
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(small_pulp),
-                                Y = -0.34f,
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_4),
-                                Position = positionAt(0, distance_from_centre_4),
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_4),
-                                Position = positionAt(90, distance_from_centre_4),
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_4),
-                                Position = positionAt(180, distance_from_centre_4),
-                            },
-                            new Pulp
-                            {
-                                Size = new Vector2(large_pulp_4),
-                                AccentColour = AccentColour.Value,
-                                Position = positionAt(270, distance_from_centre_4),
-                            },
-                        }
-                    };
-
-                case FruitVisualRepresentation.Pineapple:
-                    return new Container
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Children = new Framework.Graphics.Drawable[]
-                        {
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(small_pulp),
-                                Y = -0.3f,
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_4),
-                                Position = positionAt(45, distance_from_centre_4),
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_4),
-                                Position = positionAt(135, distance_from_centre_4),
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_4),
-                                Position = positionAt(225, distance_from_centre_4),
-                            },
-                            new Pulp
-                            {
-                                Size = new Vector2(large_pulp_4),
-                                AccentColour = AccentColour.Value,
-                                Position = positionAt(315, distance_from_centre_4),
-                            },
-                        }
-                    };
-
-                case FruitVisualRepresentation.Pear:
-                    return new Container
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Children = new Framework.Graphics.Drawable[]
-                        {
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(small_pulp),
-                                Y = -0.33f,
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_3),
-                                Position = positionAt(60, distance_from_centre_3),
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_3),
-                                Position = positionAt(180, distance_from_centre_3),
-                            },
-                            new Pulp
-                            {
-                                Size = new Vector2(large_pulp_3),
-                                AccentColour = AccentColour.Value,
-                                Position = positionAt(300, distance_from_centre_3),
-                            },
-                        }
-                    };
-
-                case FruitVisualRepresentation.Grape:
-                    return new Container
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Children = new Framework.Graphics.Drawable[]
-                        {
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(small_pulp),
-                                Y = -0.25f,
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_3),
-                                Position = positionAt(0, distance_from_centre_3),
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_3),
-                                Position = positionAt(120, distance_from_centre_3),
-                            },
-                            new Pulp
-                            {
-                                Size = new Vector2(large_pulp_3),
-                                AccentColour = AccentColour.Value,
-                                Position = positionAt(240, distance_from_centre_3),
-                            },
-                        }
-                    };
-
-                case FruitVisualRepresentation.Banana:
-                    return new Container
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Children = new Framework.Graphics.Drawable[]
-                        {
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(small_pulp),
-                                Y = -0.3f
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_4 * 0.8f, large_pulp_4 * 2.5f),
-                                Y = 0.05f,
-                            },
-                        }
-                    };
-            }
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-
-            border.Alpha = (float)Math.Clamp((HitObject.StartTime - Time.Current) / 500, 0, 1);
-        }
-
-        private Color4 colourForRepresentation(FruitVisualRepresentation representation)
-        {
-            switch (representation)
-            {
-                default:
-                case FruitVisualRepresentation.Pear:
-                    return new Color4(17, 136, 170, 255);
-
-                case FruitVisualRepresentation.Grape:
-                    return new Color4(204, 102, 0, 255);
-
-                case FruitVisualRepresentation.Raspberry:
-                    return new Color4(121, 9, 13, 255);
-
-                case FruitVisualRepresentation.Pineapple:
-                    return new Color4(102, 136, 0, 255);
-
-                case FruitVisualRepresentation.Banana:
-                    switch (RNG.Next(0, 3))
-                    {
-                        default:
-                            return new Color4(255, 240, 0, 255);
-
-                        case 1:
-                            return new Color4(255, 192, 0, 255);
-
-                        case 2:
-                            return new Color4(214, 221, 28, 255);
-                    }
-            }
-        }
-    }
-}
@@ -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.Game.Rulesets.Catch.Objects.Drawables.Pieces;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
+{
+    public class BananaPiece : PulpFormation
+    {
+        public BananaPiece()
+        {
+            InternalChildren = new Drawable[]
+            {
+                new Pulp
+                {
+                    AccentColour = { BindTarget = AccentColour },
+                    Size = new Vector2(SMALL_PULP),
+                    Y = -0.3f
+                },
+                new Pulp
+                {
+                    AccentColour = { BindTarget = AccentColour },
+                    Size = new Vector2(LARGE_PULP_4 * 0.8f, LARGE_PULP_4 * 2.5f),
+                    Y = 0.05f,
+                },
+            };
+        }
+    }
+}
@@ -0,0 +1,58 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Framework.Graphics;
+using osu.Framework.Utils;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
+{
+    public class DrawableBanana : DrawableFruit
+    {
+        public DrawableBanana(Banana h)
+            : base(h)
+        {
+        }
+
+        private Color4? colour;
+
+        protected override Color4 GetComboColour(IReadOnlyList<Color4> comboColours)
+        {
+            // override any external colour changes with banananana
+            return colour ??= getBananaColour();
+        }
+
+        protected override void UpdateInitialTransforms()
+        {
+            base.UpdateInitialTransforms();
+
+            const float end_scale = 0.6f;
+            const float random_scale_range = 1.6f;
+
+            ScaleContainer.ScaleTo(HitObject.Scale * (end_scale + random_scale_range * RNG.NextSingle()))
+                          .Then().ScaleTo(HitObject.Scale * end_scale, HitObject.TimePreempt);
+
+            ScaleContainer.RotateTo(getRandomAngle())
+                          .Then()
+                          .RotateTo(getRandomAngle(), HitObject.TimePreempt);
+
+            float getRandomAngle() => 180 * (RNG.NextSingle() * 2 - 1);
+        }
+
+        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);
+            }
+        }
+    }
+}
@@ -7,7 +7,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;

-namespace osu.Game.Rulesets.Catch.Objects.Drawable
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
    public class DrawableBananaShower : DrawableCatchHitObject<BananaShower>
    {
--- a/Show More
+++ b/Show More