Merge pull request #14859 from peppy/local-database-strings

Move database connection string operations local

.editorconfig

@@ -190,3 +190,5 @@ dotnet_diagnostic.CA2225.severity = none
 
 # Banned APIs
 dotnet_diagnostic.RS0030.severity = error
+
+dotnet_diagnostic.OLOC001.license_header = // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.\n// See the LICENCE file in the repository root for full licence text.

.github/ISSUE_TEMPLATE/01-bug-issues.md

@@ -1,30 +0,0 @@
----
-name: Bug Report
-about: Report a bug or crash to desktop
----
-
-<!--
-IMPORTANT: Your issue may already be reported.
-
-Please check:
-- Pinned issues, at the top of https://github.com/ppy/osu/issues
-- Current priority 0 issues at https://github.com/ppy/osu/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3Apriority%3A0
-- Search for your issue. If you find that it already exists, please respond with a reaction or add any further information that may be helpful.
--->
-
-
-**Describe the bug:** 
-
-**Screenshots or videos showing encountered issue:** 
-
-**osu!lazer version:** 
-
-**Logs:**
-
-<!--
-*please attach logs here, which are located at:*
-- `%AppData%/osu/logs` *(on Windows),*
-- `~/.local/share/osu/logs` *(on Linux & macOS).*
-- `Android/data/sh.ppy.osulazer/files/logs` *(on Android)*,
-- on iOS they can be obtained by connecting your device to your desktop and copying the `logs` directory from the app's own document storage using iTunes. (https://support.apple.com/en-us/HT201301#copy-to-computer)
--->

.github/ISSUE_TEMPLATE/config.yml

@@ -1,12 +1,12 @@
 blank_issues_enabled: false
 contact_links:
-    - name: Suggestions or feature request
-      url: https://github.com/ppy/osu/discussions/categories/ideas
-      about: Got something you think should change or be added? Search for or start a new discussion!
     - name: Help
       url: https://github.com/ppy/osu/discussions/categories/q-a
       about: osu! not working as you'd expect? Not sure it's a bug? Check the Q&A section!
+    - name: Suggestions or feature request
+      url: https://github.com/ppy/osu/discussions/categories/ideas
+      about: Got something you think should change or be added? Search for or start a new discussion!
     - name: osu!stable issues
       url: https://github.com/ppy/osu-stable-issues
-      about: For osu!stable bugs (not osu!lazer), check out the dedicated repository. Note that we only accept serious bug reports.
+      about: For osu!(stable) - ie. the current "live" game version, check out the dedicated repository. Note that this is for serious bug reports only, not tech support.
 

.github/workflows/diffcalc.yml

@@ -0,0 +1,205 @@
+# Listens for new PR comments containing !pp check [id], and runs a diffcalc comparison against master.
+# Usage:
+#   !pp check 0        | Runs only the osu! ruleset.
+#   !pp check 0 2      | Runs only the osu! and catch rulesets.
+#
+
+name: Difficulty Calculation
+on:
+  issue_comment:
+    types: [ created ]
+
+env:
+  CONCURRENCY: 4
+  ALLOW_DOWNLOAD: 1
+  SAVE_DOWNLOADED: 1
+  SKIP_INSERT_ATTRIBUTES: 1
+
+jobs:
+  metadata:
+    name: Check for requests
+    runs-on: self-hosted
+    if: github.event.issue.pull_request && contains(github.event.comment.body, '!pp check') && (github.event.comment.author_association == 'MEMBER' || github.event.comment.author_association == 'OWNER')
+    outputs:
+      matrix: ${{ steps.generate-matrix.outputs.matrix }}
+      continue: ${{ steps.generate-matrix.outputs.continue }}
+    steps:
+      - name: Construct build matrix
+        id: generate-matrix
+        run: |
+          if [[ "${{ github.event.comment.body }}" =~ "osu" ]] ; then
+            MATRIX_PROJECTS_JSON+='{ "name": "osu", "id": 0 },'
+          fi
+          if [[ "${{ github.event.comment.body }}" =~ "taiko" ]] ; then
+            MATRIX_PROJECTS_JSON+='{ "name": "taiko", "id": 1 },'
+          fi
+          if [[ "${{ github.event.comment.body }}" =~ "catch" ]] ; then
+            MATRIX_PROJECTS_JSON+='{ "name": "catch", "id": 2 },'
+          fi
+          if [[ "${{ github.event.comment.body }}" =~ "mania" ]] ; then
+            MATRIX_PROJECTS_JSON+='{ "name": "mania", "id": 3 },'
+          fi
+
+          if [[ "${MATRIX_PROJECTS_JSON}" != "" ]]; then
+            MATRIX_JSON="{ \"ruleset\": [ ${MATRIX_PROJECTS_JSON} ] }"
+            echo "${MATRIX_JSON}"
+            CONTINUE="yes"
+          else
+            CONTINUE="no"
+          fi
+
+          echo "::set-output name=continue::${CONTINUE}"
+          echo "::set-output name=matrix::${MATRIX_JSON}"
+  diffcalc:
+    name: Run
+    runs-on: self-hosted
+    if: needs.metadata.outputs.continue == 'yes'
+    needs: metadata
+    strategy:
+      matrix: ${{ fromJson(needs.metadata.outputs.matrix) }}
+    steps:
+      - name: Verify MySQL connection from host
+        run: |
+          mysql -e "SHOW DATABASES"
+
+      - name: Drop previous databases
+        run: |
+          for db in osu_master osu_pr
+          do
+            mysql -e "DROP DATABASE IF EXISTS $db"
+          done
+
+      - name: Create directory structure
+        run: |
+          mkdir -p $GITHUB_WORKSPACE/master/
+          mkdir -p $GITHUB_WORKSPACE/pr/
+
+      - name: Get upstream branch # https://akaimo.hatenablog.jp/entry/2020/05/16/101251
+        id: upstreambranch
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          echo "::set-output name=branchname::$(curl -H "Authorization: token ${GITHUB_TOKEN}" ${{ github.event.issue.pull_request.url }} | jq '.head.ref' | sed 's/\"//g')"
+          echo "::set-output name=repo::$(curl -H "Authorization: token ${GITHUB_TOKEN}" ${{ github.event.issue.pull_request.url }} | jq '.head.repo.full_name' | sed 's/\"//g')"
+
+      # Checkout osu
+      - name: Checkout osu (master)
+        uses: actions/checkout@v2
+        with:
+          path: 'master/osu'
+      - name: Checkout osu (pr)
+        uses: actions/checkout@v2
+        with:
+          path: 'pr/osu'
+          repository: ${{ steps.upstreambranch.outputs.repo }}
+          ref: ${{ steps.upstreambranch.outputs.branchname }}
+
+      - name: Checkout osu-difficulty-calculator (master)
+        uses: actions/checkout@v2
+        with:
+          repository: ppy/osu-difficulty-calculator
+          path: 'master/osu-difficulty-calculator'
+      - name: Checkout osu-difficulty-calculator (pr)
+        uses: actions/checkout@v2
+        with:
+          repository: ppy/osu-difficulty-calculator
+          path: 'pr/osu-difficulty-calculator'
+
+      - name: Install .NET 5.0.x
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: "5.0.x"
+
+      # Sanity checks to make sure diffcalc is not run when incompatible.
+      - name: Build diffcalc (master)
+        run: |
+          cd $GITHUB_WORKSPACE/master/osu-difficulty-calculator
+          ./UseLocalOsu.sh
+          dotnet build
+      - name: Build diffcalc (pr)
+        run: |
+          cd $GITHUB_WORKSPACE/pr/osu-difficulty-calculator
+          ./UseLocalOsu.sh
+          dotnet build
+
+      - name: Download + import data
+        run: |
+          PERFORMANCE_DATA_NAME=$(curl https://data.ppy.sh/ | grep performance_${{ matrix.ruleset.name }}_top_1000 | tail -1 | awk -F "\"" '{print $2}' | sed 's/\.tar\.bz2//g')
+          BEATMAPS_DATA_NAME=$(curl https://data.ppy.sh/ | grep osu_files | tail -1 | awk -F "\"" '{print $2}' | sed 's/\.tar\.bz2//g')
+
+          # Set env variable for further steps.
+          echo "BEATMAPS_PATH=$GITHUB_WORKSPACE/$BEATMAPS_DATA_NAME" >> $GITHUB_ENV
+
+          cd $GITHUB_WORKSPACE
+
+          echo "Downloading database dump $PERFORMANCE_DATA_NAME.."
+          wget -q -nc https://data.ppy.sh/$PERFORMANCE_DATA_NAME.tar.bz2
+          echo "Extracting.."
+          tar -xf $PERFORMANCE_DATA_NAME.tar.bz2
+
+          echo "Downloading beatmap dump $BEATMAPS_DATA_NAME.."
+          wget -q -nc https://data.ppy.sh/$BEATMAPS_DATA_NAME.tar.bz2
+          echo "Extracting.."
+          tar -xf $BEATMAPS_DATA_NAME.tar.bz2
+
+          cd $PERFORMANCE_DATA_NAME
+
+          for db in osu_master osu_pr
+          do
+            echo "Setting up database $db.."
+
+            mysql -e "CREATE DATABASE $db"
+
+            echo "Importing beatmaps.."
+            cat osu_beatmaps.sql | mysql $db
+            echo "Importing beatmapsets.."
+            cat osu_beatmapsets.sql | mysql $db
+
+            echo "Creating table structure.."
+            mysql $db -e 'CREATE TABLE `osu_beatmap_difficulty` (
+                `beatmap_id` int unsigned NOT NULL,
+                `mode` tinyint NOT NULL DEFAULT 0,
+                `mods` int unsigned NOT NULL,
+                `diff_unified` float NOT NULL,
+                `last_update` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+                PRIMARY KEY (`beatmap_id`,`mode`,`mods`),
+                KEY `diff_sort` (`mode`,`mods`,`diff_unified`)
+              ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;'
+          done
+
+      - name: Run diffcalc (master)
+        env:
+          DB_NAME: osu_master
+        run: |
+          cd $GITHUB_WORKSPACE/master/osu-difficulty-calculator/osu.Server.DifficultyCalculator
+          dotnet run -c:Release -- all -m ${{ matrix.ruleset.id }} -ac -c ${{ env.CONCURRENCY }}
+      - name: Run diffcalc (pr)
+        env:
+          DB_NAME: osu_pr
+        run: |
+          cd $GITHUB_WORKSPACE/pr/osu-difficulty-calculator/osu.Server.DifficultyCalculator
+          dotnet run -c:Release -- all -m ${{ matrix.ruleset.id }} -ac -c ${{ env.CONCURRENCY }}
+
+      - name: Print diffs
+        run: |
+          mysql -e "
+            SELECT
+              m.beatmap_id,
+              m.mods,
+              b.filename,
+              m.diff_unified as 'sr_master',
+              p.diff_unified as 'sr_pr',
+              (p.diff_unified - m.diff_unified) as 'diff'
+            FROM osu_master.osu_beatmap_difficulty m
+            JOIN osu_pr.osu_beatmap_difficulty p
+              ON m.beatmap_id = p.beatmap_id
+              AND m.mode = p.mode
+              AND m.mods = p.mods
+            JOIN osu_pr.osu_beatmaps b
+              ON b.beatmap_id = p.beatmap_id
+            WHERE abs(m.diff_unified - p.diff_unified) > 0.1
+            ORDER BY abs(m.diff_unified - p.diff_unified)
+              DESC
+            LIMIT 10000;"
+
+      # Todo: Run ppcalc

.idea/.idea.osu.Desktop/.idea/runConfigurations/Benchmarks.xml

@@ -1,8 +1,8 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Benchmarks" type="DotNetProject" factoryName=".NET Project">
-    <option name="EXE_PATH" value="$PROJECT_DIR$/osu.Game.Benchmarks/bin/Release/net5.0/osu.Game.Benchmarks.dll" />
-    <option name="PROGRAM_PARAMETERS" value="--filter *" />
-    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/osu.Game.Benchmarks/bin/Release/net5.0" />
+    <option name="EXE_PATH" value="$PROJECT_DIR$/osu.Game.Benchmarks/bin/Debug/net5.0/osu.Game.Benchmarks.dll" />
+    <option name="PROGRAM_PARAMETERS" value="" />
+    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/osu.Game.Benchmarks/bin/Debug/net5.0" />
     <option name="PASS_PARENT_ENVS" value="1" />
     <option name="USE_EXTERNAL_CONSOLE" value="0" />
     <option name="USE_MONO" value="0" />
@@ -14,7 +14,7 @@
     <option name="PROJECT_KIND" value="DotNetCore" />
     <option name="PROJECT_TFM" value="net5.0" />
     <method v="2">
-      <option name="Build" enabled="true" />
+      <option name="Build" />
     </method>
   </configuration>
 </component>

.idea/.idea.osu/.idea/indexLayout.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ContentModelUserStore">
+  <component name="UserContentModel">
     <attachedFolders />
     <explicitIncludes />
     <explicitExcludes />

README.md

@@ -4,7 +4,7 @@
 
 # osu!
 
-[![Build status](https://ci.appveyor.com/api/projects/status/u2p01nx7l6og8buh?svg=true)](https://ci.appveyor.com/project/peppy/osu)
+[![Build status](https://github.com/ppy/osu/actions/workflows/ci.yml/badge.svg?branch=master&event=push)](https://github.com/ppy/osu/actions/workflows/ci.yml)
 [![GitHub release](https://img.shields.io/github/release/ppy/osu.svg)](https://github.com/ppy/osu/releases/latest)
 [![CodeFactor](https://www.codefactor.io/repository/github/ppy/osu/badge)](https://www.codefactor.io/repository/github/ppy/osu)
 [![dev chat](https://discordapp.com/api/guilds/188630481301012481/widget.png?style=shield)](https://discord.gg/ppy)
@@ -31,12 +31,11 @@ If you are looking to install or test osu! without setting up a development envi
 
 **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) | [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)
+| [Windows 8.1+ (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 10+](https://osu.ppy.sh/home/testflight) | [Android 5+](https://github.com/ppy/osu/releases/latest/download/sh.ppy.osulazer.apk)
 | ------------- | ------------- | ------------- | ------------- | ------------- |
 
 - The iOS testflight link may fill up (Apple has a hard limit of 10,000 users). We reset it occasionally when this happens. Please do not ask about this. Check back regularly for link resets or follow [peppy](https://twitter.com/ppy) on twitter for announcements of link resets.
 
-- When running on Windows 7 or 8.1, *[additional prerequisites](https://docs.microsoft.com/en-us/dotnet/core/install/windows?tabs=net50&pivots=os-windows#dependencies)** may be required to correctly run .NET 5 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 a custom ruleset

Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform.Tests/TestSceneOsuGame.cs

@@ -15,9 +15,6 @@ namespace osu.Game.Rulesets.EmptyFreeform.Tests
         [BackgroundDependencyLoader]
         private void load(GameHost host, OsuGameBase gameBase)
         {
-            OsuGame game = new OsuGame();
-            game.SetHost(host);
-
             Children = new Drawable[]
             {
                 new Box
@@ -25,8 +22,9 @@ namespace osu.Game.Rulesets.EmptyFreeform.Tests
                     RelativeSizeAxes = Axes.Both,
                     Colour = Color4.Black,
                 },
-                game
             };
+
+            AddGame(new OsuGame());
         }
     }
 }

Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform.Tests/osu.Game.Rulesets.EmptyFreeform.Tests.csproj

@@ -10,7 +10,7 @@
     </PropertyGroup>
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.10.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
     <PackageReference Include="NUnit" Version="3.13.2" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon.Tests/TestSceneOsuGame.cs

@@ -15,9 +15,6 @@ namespace osu.Game.Rulesets.Pippidon.Tests
         [BackgroundDependencyLoader]
         private void load(GameHost host, OsuGameBase gameBase)
         {
-            OsuGame game = new OsuGame();
-            game.SetHost(host);
-
             Children = new Drawable[]
             {
                 new Box
@@ -25,8 +22,9 @@ namespace osu.Game.Rulesets.Pippidon.Tests
                     RelativeSizeAxes = Axes.Both,
                     Colour = Color4.Black,
                 },
-                game
             };
+
+            AddGame(new OsuGame());
         }
     }
 }

Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon.Tests/osu.Game.Rulesets.Pippidon.Tests.csproj

@@ -10,7 +10,7 @@
   </PropertyGroup>
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.10.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
     <PackageReference Include="NUnit" Version="3.13.2" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling.Tests/TestSceneOsuGame.cs

@@ -15,9 +15,6 @@ namespace osu.Game.Rulesets.EmptyScrolling.Tests
         [BackgroundDependencyLoader]
         private void load(GameHost host, OsuGameBase gameBase)
         {
-            OsuGame game = new OsuGame();
-            game.SetHost(host);
-
             Children = new Drawable[]
             {
                 new Box
@@ -25,8 +22,9 @@ namespace osu.Game.Rulesets.EmptyScrolling.Tests
                     RelativeSizeAxes = Axes.Both,
                     Colour = Color4.Black,
                 },
-                game
             };
+
+            AddGame(new OsuGame());
         }
     }
 }

Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling.Tests/osu.Game.Rulesets.EmptyScrolling.Tests.csproj

@@ -10,7 +10,7 @@
   </PropertyGroup>
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.10.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
     <PackageReference Include="NUnit" Version="3.13.2" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon.Tests/TestSceneOsuGame.cs

@@ -15,9 +15,6 @@ namespace osu.Game.Rulesets.Pippidon.Tests
         [BackgroundDependencyLoader]
         private void load(GameHost host, OsuGameBase gameBase)
         {
-            OsuGame game = new OsuGame();
-            game.SetHost(host);
-
             Children = new Drawable[]
             {
                 new Box
@@ -25,8 +22,9 @@ namespace osu.Game.Rulesets.Pippidon.Tests
                     RelativeSizeAxes = Axes.Both,
                     Colour = Color4.Black,
                 },
-                game
             };
+
+            AddGame(new OsuGame());
         }
     }
 }

Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon.Tests/osu.Game.Rulesets.Pippidon.Tests.csproj

@@ -10,7 +10,7 @@
   </PropertyGroup>
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.10.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
     <PackageReference Include="NUnit" Version="3.13.2" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/UI/PippidonCharacter.cs

@@ -8,6 +8,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics.Containers;
 using osuTK;
@@ -61,9 +62,9 @@ namespace osu.Game.Rulesets.Pippidon.UI
             }
         }
 
-        public bool OnPressed(PippidonAction action)
+        public bool OnPressed(KeyBindingPressEvent<PippidonAction> e)
         {
-            switch (action)
+            switch (e.Action)
             {
                 case PippidonAction.MoveUp:
                     changeLane(-1);
@@ -78,7 +79,7 @@ namespace osu.Game.Rulesets.Pippidon.UI
             }
         }
 
-        public void OnReleased(PippidonAction action)
+        public void OnReleased(KeyBindingReleaseEvent<PippidonAction> e)
         {
         }
 

osu.Android.props

@@ -51,11 +51,11 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.730.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.728.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.918.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.927.0" />
   </ItemGroup>
   <ItemGroup Label="Transitive Dependencies">
     <!-- Realm needs to be directly referenced in all Xamarin projects, as it will not pull in its transitive dependencies otherwise. -->
-    <PackageReference Include="Realm" Version="10.3.0" />
+    <PackageReference Include="Realm" Version="10.5.0" />
   </ItemGroup>
 </Project>

osu.Android/OsuGameActivity.cs

@@ -20,8 +20,21 @@ namespace osu.Android
     [Activity(Theme = "@android:style/Theme.NoTitleBar", MainLauncher = true, ScreenOrientation = ScreenOrientation.FullUser, SupportsPictureInPicture = false, ConfigurationChanges = ConfigChanges.Orientation | ConfigChanges.ScreenSize, HardwareAccelerated = false, LaunchMode = LaunchMode.SingleInstance, Exported = true)]
     [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataPathPattern = ".*\\\\.osz", DataHost = "*", DataMimeType = "*/*")]
     [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataPathPattern = ".*\\\\.osk", DataHost = "*", DataMimeType = "*/*")]
-    [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataMimeType = "application/x-osu-archive")]
-    [IntentFilter(new[] { Intent.ActionSend, Intent.ActionSendMultiple }, Categories = new[] { Intent.CategoryDefault }, DataMimeTypes = new[] { "application/zip", "application/octet-stream", "application/download", "application/x-zip", "application/x-zip-compressed", "application/x-osu-archive" })]
+    [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataMimeType = "application/x-osu-beatmap-archive")]
+    [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataMimeType = "application/x-osu-skin-archive")]
+    [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataMimeType = "application/x-osu-replay")]
+    [IntentFilter(new[] { Intent.ActionSend, Intent.ActionSendMultiple }, Categories = new[] { Intent.CategoryDefault }, DataMimeTypes = new[]
+    {
+        "application/zip",
+        "application/octet-stream",
+        "application/download",
+        "application/x-zip",
+        "application/x-zip-compressed",
+        // newer official mime types (see https://osu.ppy.sh/wiki/en/osu%21_File_Formats).
+        "application/x-osu-beatmap-archive",
+        "application/x-osu-skin-archive",
+        "application/x-osu-replay",
+    })]
     [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryBrowsable, Intent.CategoryDefault }, DataSchemes = new[] { "osu", "osump" })]
     public class OsuGameActivity : AndroidGameActivity
     {
@@ -66,12 +79,14 @@ namespace osu.Android
                 case Intent.ActionSendMultiple:
                 {
                     var uris = new List<Uri>();
+
                     for (int i = 0; i < intent.ClipData?.ItemCount; i++)
                     {
                         var content = intent.ClipData?.GetItemAt(i);
                         if (content != null)
                             uris.Add(content.Uri);
                     }
+
                     handleImportFromUris(uris.ToArray());
                     break;
                 }

osu.Android/osu.Android.csproj

@@ -64,7 +64,7 @@
     </PackageReference>
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Xamarin.Essentials" Version="1.6.1" />
+    <PackageReference Include="Xamarin.Essentials" Version="1.7.0" />
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
 </Project>

osu.Desktop/DiscordRichPresence.cs

@@ -139,8 +139,8 @@ namespace osu.Desktop
         {
             switch (activity)
             {
-                case UserActivity.SoloGame solo:
-                    return solo.Beatmap.ToString();
+                case UserActivity.InGame game:
+                    return game.Beatmap.ToString();
 
                 case UserActivity.Editing edit:
                     return edit.Beatmap.ToString();

osu.Desktop/Windows/GameplayWinKeyBlocker.cs

@@ -5,23 +5,23 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Platform;
-using osu.Game;
 using osu.Game.Configuration;
+using osu.Game.Screens.Play;
 
 namespace osu.Desktop.Windows
 {
     public class GameplayWinKeyBlocker : Component
     {
         private Bindable<bool> disableWinKey;
-        private Bindable<bool> localUserPlaying;
+        private IBindable<bool> localUserPlaying;
 
         [Resolved]
         private GameHost host { get; set; }
 
         [BackgroundDependencyLoader]
-        private void load(OsuGame game, OsuConfigManager config)
+        private void load(ILocalUserPlayInfo localUserInfo, OsuConfigManager config)
         {
-            localUserPlaying = game.LocalUserPlaying.GetBoundCopy();
+            localUserPlaying = localUserInfo.IsPlaying.GetBoundCopy();
             localUserPlaying.BindValueChanged(_ => updateBlocking());
 
             disableWinKey = config.GetBindable<bool>(OsuSetting.GameplayDisableWinKey);

osu.Game.Benchmarks/BenchmarkMod.cs

@@ -0,0 +1,34 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using BenchmarkDotNet.Attributes;
+using osu.Game.Rulesets.Osu.Mods;
+
+namespace osu.Game.Benchmarks
+{
+    public class BenchmarkMod : BenchmarkTest
+    {
+        private OsuModDoubleTime mod;
+
+        [Params(1, 10, 100)]
+        public int Times { get; set; }
+
+        public override void SetUp()
+        {
+            base.SetUp();
+            mod = new OsuModDoubleTime();
+        }
+
+        [Benchmark]
+        public int ModHashCode()
+        {
+            var hashCode = new HashCode();
+
+            for (int i = 0; i < Times; i++)
+                hashCode.Add(mod);
+
+            return hashCode.ToHashCode();
+        }
+    }
+}

osu.Game.Benchmarks/BenchmarkRuleset.cs

@@ -0,0 +1,62 @@
+// 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 BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Engines;
+using osu.Game.Online.API;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu;
+
+namespace osu.Game.Benchmarks
+{
+    public class BenchmarkRuleset : BenchmarkTest
+    {
+        private OsuRuleset ruleset;
+        private APIMod apiModDoubleTime;
+        private APIMod apiModDifficultyAdjust;
+
+        public override void SetUp()
+        {
+            base.SetUp();
+            ruleset = new OsuRuleset();
+            apiModDoubleTime = new APIMod { Acronym = "DT" };
+            apiModDifficultyAdjust = new APIMod { Acronym = "DA" };
+        }
+
+        [Benchmark]
+        public void BenchmarkToModDoubleTime()
+        {
+            apiModDoubleTime.ToMod(ruleset);
+        }
+
+        [Benchmark]
+        public void BenchmarkToModDifficultyAdjust()
+        {
+            apiModDifficultyAdjust.ToMod(ruleset);
+        }
+
+        [Benchmark]
+        public void BenchmarkGetAllMods()
+        {
+            ruleset.CreateAllMods().Consume(new Consumer());
+        }
+
+        [Benchmark]
+        public void BenchmarkGetAllModsForReference()
+        {
+            ruleset.AllMods.Consume(new Consumer());
+        }
+
+        [Benchmark]
+        public void BenchmarkGetForAcronym()
+        {
+            ruleset.CreateModFromAcronym("DT");
+        }
+
+        [Benchmark]
+        public void BenchmarkGetForType()
+        {
+            ruleset.CreateMod<ModDoubleTime>();
+        }
+    }
+}

osu.Game.Benchmarks/Program.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Running;
 
 namespace osu.Game.Benchmarks
@@ -11,7 +12,7 @@ namespace osu.Game.Benchmarks
         {
             BenchmarkSwitcher
                 .FromAssembly(typeof(Program).Assembly)
-                .Run(args);
+                .Run(args, DefaultConfig.Instance.WithOption(ConfigOptions.DisableOptimizationsValidator, true));
         }
     }
 }

osu.Game.Benchmarks/osu.Game.Benchmarks.csproj

@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.13.0" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.1" />
     <PackageReference Include="nunit" Version="3.13.2" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
   </ItemGroup>

osu.Game.Rulesets.Catch.Tests/Editor/TestSceneJuiceStreamSelectionBlueprint.cs

@@ -210,9 +210,9 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
                 new Vector2(50, 200),
             }), 0.5);
             AddAssert("1 vertex per 1 nested HO", () => getVertices().Count == hitObject.NestedHitObjects.Count);
-            AddAssert("slider path not yet changed", () => hitObject.Path.ControlPoints[0].Type.Value == PathType.PerfectCurve);
+            AddAssert("slider path not yet changed", () => hitObject.Path.ControlPoints[0].Type == PathType.PerfectCurve);
             addAddVertexSteps(150, 150);
-            AddAssert("slider path change to linear", () => hitObject.Path.ControlPoints[0].Type.Value == PathType.Linear);
+            AddAssert("slider path change to linear", () => hitObject.Path.ControlPoints[0].Type == PathType.Linear);
         }
 
         private void addBlueprintStep(double time, float x, SliderPath sliderPath, double velocity) => AddStep("add selection blueprint", () =>

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

@@ -154,7 +154,7 @@ namespace osu.Game.Rulesets.Catch.Tests
                     } while (rng.Next(2) != 0);
 
                     int length = sliderPath.ControlPoints.Count - start + 1;
-                    sliderPath.ControlPoints[start].Type.Value = length <= 2 ? PathType.Linear : length == 3 ? PathType.PerfectCurve : PathType.Bezier;
+                    sliderPath.ControlPoints[start].Type = length <= 2 ? PathType.Linear : length == 3 ? PathType.PerfectCurve : PathType.Bezier;
                 } while (rng.Next(3) != 0);
 
                 if (rng.Next(5) == 0)
@@ -210,13 +210,13 @@ namespace osu.Game.Rulesets.Catch.Tests
 
                 path.ConvertToSliderPath(sliderPath, sliderStartY);
                 Assert.That(sliderPath.Distance, Is.EqualTo(path.Distance).Within(1e-3));
-                Assert.That(sliderPath.ControlPoints[0].Position.Value.X, Is.EqualTo(path.Vertices[0].X));
+                Assert.That(sliderPath.ControlPoints[0].Position.X, Is.EqualTo(path.Vertices[0].X));
                 assertInvariants(path.Vertices, true);
 
                 foreach (var point in sliderPath.ControlPoints)
                 {
-                    Assert.That(point.Type.Value, Is.EqualTo(PathType.Linear).Or.Null);
-                    Assert.That(sliderStartY + point.Position.Value.Y, Is.InRange(0, JuiceStreamPath.OSU_PLAYFIELD_HEIGHT));
+                    Assert.That(point.Type, Is.EqualTo(PathType.Linear).Or.Null);
+                    Assert.That(sliderStartY + point.Position.Y, Is.InRange(0, JuiceStreamPath.OSU_PLAYFIELD_HEIGHT));
                 }
 
                 for (int i = 0; i < 10; i++)

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

@@ -0,0 +1,120 @@
+// 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.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Catch.Beatmaps;
+using osu.Game.Rulesets.Catch.Mods;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Objects;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Tests.Mods
+{
+    [TestFixture]
+    public class CatchModMirrorTest
+    {
+        [Test]
+        public void TestModMirror()
+        {
+            IBeatmap original = createBeatmap(false);
+            IBeatmap mirrored = createBeatmap(true);
+
+            assertEffectivePositionsMirrored(original, mirrored);
+        }
+
+        private static IBeatmap createBeatmap(bool withMirrorMod)
+        {
+            var beatmap = createRawBeatmap();
+            var mirrorMod = new CatchModMirror();
+
+            var beatmapProcessor = new CatchBeatmapProcessor(beatmap);
+            beatmapProcessor.PreProcess();
+
+            foreach (var hitObject in beatmap.HitObjects)
+                hitObject.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+            beatmapProcessor.PostProcess();
+
+            if (withMirrorMod)
+                mirrorMod.ApplyToBeatmap(beatmap);
+
+            return beatmap;
+        }
+
+        private static IBeatmap createRawBeatmap() => new Beatmap
+        {
+            HitObjects = new List<HitObject>
+            {
+                new Fruit
+                {
+                    OriginalX = 150,
+                    StartTime = 0
+                },
+                new Fruit
+                {
+                    OriginalX = 450,
+                    StartTime = 500
+                },
+                new JuiceStream
+                {
+                    OriginalX = 250,
+                    Path = new SliderPath
+                    {
+                        ControlPoints =
+                        {
+                            new PathControlPoint(new Vector2(-100, 1)),
+                            new PathControlPoint(new Vector2(0, 2)),
+                            new PathControlPoint(new Vector2(100, 3)),
+                            new PathControlPoint(new Vector2(0, 4))
+                        }
+                    },
+                    StartTime = 1000,
+                },
+                new BananaShower
+                {
+                    StartTime = 5000,
+                    Duration = 5000
+                }
+            }
+        };
+
+        private static void assertEffectivePositionsMirrored(IBeatmap original, IBeatmap mirrored)
+        {
+            if (original.HitObjects.Count != mirrored.HitObjects.Count)
+                Assert.Fail($"Top-level object count mismatch (original: {original.HitObjects.Count}, mirrored: {mirrored.HitObjects.Count})");
+
+            for (int i = 0; i < original.HitObjects.Count; ++i)
+            {
+                var originalObject = (CatchHitObject)original.HitObjects[i];
+                var mirroredObject = (CatchHitObject)mirrored.HitObjects[i];
+
+                // banana showers themselves are exempt, as we only really care about their nested bananas' positions.
+                if (!effectivePositionMirrored(originalObject, mirroredObject) && !(originalObject is BananaShower))
+                    Assert.Fail($"{originalObject.GetType().Name} at time {originalObject.StartTime} is not mirrored ({printEffectivePositions(originalObject, mirroredObject)})");
+
+                if (originalObject.NestedHitObjects.Count != mirroredObject.NestedHitObjects.Count)
+                    Assert.Fail($"{originalObject.GetType().Name} nested object count mismatch (original: {originalObject.NestedHitObjects.Count}, mirrored: {mirroredObject.NestedHitObjects.Count})");
+
+                for (int j = 0; j < originalObject.NestedHitObjects.Count; ++j)
+                {
+                    var originalNested = (CatchHitObject)originalObject.NestedHitObjects[j];
+                    var mirroredNested = (CatchHitObject)mirroredObject.NestedHitObjects[j];
+
+                    if (!effectivePositionMirrored(originalNested, mirroredNested))
+                        Assert.Fail($"{originalObject.GetType().Name}'s nested {originalNested.GetType().Name} at time {originalObject.StartTime} is not mirrored ({printEffectivePositions(originalNested, mirroredNested)})");
+                }
+            }
+        }
+
+        private static string printEffectivePositions(CatchHitObject original, CatchHitObject mirrored)
+            => $"original X: {original.EffectiveX}, mirrored X is: {mirrored.EffectiveX}, mirrored X should be: {CatchPlayfield.WIDTH - original.EffectiveX}";
+
+        private static bool effectivePositionMirrored(CatchHitObject original, CatchHitObject mirrored)
+            => Precision.AlmostEquals(original.EffectiveX, CatchPlayfield.WIDTH - mirrored.EffectiveX);
+    }
+}

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

@@ -40,6 +40,7 @@ namespace osu.Game.Rulesets.Catch.Tests
         {
             AddSliderStep<float>("circle size", 0, 8, 5, createCatcher);
             AddToggleStep("hyper dash", t => this.ChildrenOfType<TestCatcherArea>().ForEach(area => area.ToggleHyperDash(t)));
+            AddToggleStep("toggle hit lighting", lighting => config.SetValue(OsuSetting.HitLighting, lighting));
 
             AddStep("catch centered fruit", () => attemptCatch(new Fruit()));
             AddStep("catch many random fruit", () =>

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

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

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

@@ -75,7 +75,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
 
                     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.OriginalX + juiceStream.Path.ControlPoints[^1].Position.Value.X;
+                        lastPosition = juiceStream.OriginalX + juiceStream.Path.ControlPoints[^1].Position.X;
 
                         // 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;

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -117,6 +117,7 @@ namespace osu.Game.Rulesets.Catch
                     {
                         new CatchModDifficultyAdjust(),
                         new CatchModClassic(),
+                        new CatchModMirror(),
                     };
 
                 case ModType.Automation:

osu.Game.Rulesets.Catch/CatchSkinComponents.cs

@@ -9,6 +9,7 @@ namespace osu.Game.Rulesets.Catch
         Banana,
         Droplet,
         Catcher,
-        CatchComboCounter
+        CatchComboCounter,
+        HitExplosion
     }
 }

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

@@ -52,7 +52,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
             // In 2B beatmaps, it is possible that a normal Fruit is placed in the middle of a JuiceStream.
             foreach (var hitObject in beatmap.HitObjects
-                                             .SelectMany(obj => obj is JuiceStream stream ? stream.NestedHitObjects : new[] { obj })
+                                             .SelectMany(obj => obj is JuiceStream stream ? stream.NestedHitObjects.AsEnumerable() : new[] { obj })
                                              .Cast<CatchHitObject>()
                                              .OrderBy(x => x.StartTime))
             {

osu.Game.Rulesets.Catch/Difficulty/Skills/Movement.cs

@@ -9,7 +9,7 @@ using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Catch.Difficulty.Skills
 {
-    public class Movement : StrainSkill
+    public class Movement : StrainDecaySkill
     {
         private const float absolute_player_positioning_error = 16f;
         private const float normalized_hitobject_radius = 41.0f;

osu.Game.Rulesets.Catch/Edit/Blueprints/Components/EditablePath.cs

@@ -76,7 +76,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints.Components
             path.ConvertFromSliderPath(sliderPath);
 
             // If the original slider path has non-linear type segments, resample the vertices at nested hit object times to reduce the number of vertices.
-            if (sliderPath.ControlPoints.Any(p => p.Type.Value != null && p.Type.Value != PathType.Linear))
+            if (sliderPath.ControlPoints.Any(p => p.Type != null && p.Type != PathType.Linear))
             {
                 path.ResampleVertices(hitObject.NestedHitObjects
                                                .Skip(1).TakeWhile(h => !(h is Fruit)) // Only droplets in the first span are used.

osu.Game.Rulesets.Catch/Edit/CatchSelectionHandler.cs

@@ -127,7 +127,7 @@ namespace osu.Game.Rulesets.Catch.Edit
                     juiceStream.OriginalX = selectionRange.GetFlippedPosition(juiceStream.OriginalX);
 
                     foreach (var point in juiceStream.Path.ControlPoints)
-                        point.Position.Value *= new Vector2(-1, 1);
+                        point.Position *= new Vector2(-1, 1);
 
                     EditorBeatmap.Update(juiceStream);
                     return true;

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

@@ -0,0 +1,87 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.Beatmaps;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Objects;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Mods
+{
+    public class CatchModMirror : ModMirror, IApplicableToBeatmap
+    {
+        public override string Description => "Fruits are flipped horizontally.";
+
+        /// <remarks>
+        /// <see cref="IApplicableToBeatmap"/> is used instead of <see cref="IApplicableToHitObject"/>,
+        /// as <see cref="CatchBeatmapProcessor"/> applies offsets in <see cref="CatchBeatmapProcessor.PostProcess"/>.
+        /// <see cref="IApplicableToBeatmap"/> runs after post-processing, while <see cref="IApplicableToHitObject"/> runs before it.
+        /// </remarks>
+        public void ApplyToBeatmap(IBeatmap beatmap)
+        {
+            foreach (var hitObject in beatmap.HitObjects)
+                applyToHitObject(hitObject);
+        }
+
+        private void applyToHitObject(HitObject hitObject)
+        {
+            var catchObject = (CatchHitObject)hitObject;
+
+            switch (catchObject)
+            {
+                case Fruit fruit:
+                    mirrorEffectiveX(fruit);
+                    break;
+
+                case JuiceStream juiceStream:
+                    mirrorEffectiveX(juiceStream);
+                    mirrorJuiceStreamPath(juiceStream);
+                    break;
+
+                case BananaShower bananaShower:
+                    mirrorBananaShower(bananaShower);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Mirrors the effective X position of <paramref name="catchObject"/> and its nested hit objects.
+        /// </summary>
+        private static void mirrorEffectiveX(CatchHitObject catchObject)
+        {
+            catchObject.OriginalX = CatchPlayfield.WIDTH - catchObject.OriginalX;
+            catchObject.XOffset = -catchObject.XOffset;
+
+            foreach (var nested in catchObject.NestedHitObjects.Cast<CatchHitObject>())
+            {
+                nested.OriginalX = CatchPlayfield.WIDTH - nested.OriginalX;
+                nested.XOffset = -nested.XOffset;
+            }
+        }
+
+        /// <summary>
+        /// Mirrors the path of the <paramref name="juiceStream"/>.
+        /// </summary>
+        private static void mirrorJuiceStreamPath(JuiceStream juiceStream)
+        {
+            var controlPoints = juiceStream.Path.ControlPoints.Select(p => new PathControlPoint(p.Position, p.Type)).ToArray();
+            foreach (var point in controlPoints)
+                point.Position = new Vector2(-point.Position.X, point.Position.Y);
+
+            juiceStream.Path = new SliderPath(controlPoints, juiceStream.Path.ExpectedDistance.Value);
+        }
+
+        /// <summary>
+        /// Mirrors X positions of all bananas in the <paramref name="bananaShower"/>.
+        /// </summary>
+        private static void mirrorBananaShower(BananaShower bananaShower)
+        {
+            foreach (var banana in bananaShower.NestedHitObjects.OfType<Banana>())
+                banana.XOffset = CatchPlayfield.WIDTH - banana.XOffset;
+        }
+    }
+}

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

@@ -44,9 +44,9 @@ namespace osu.Game.Rulesets.Catch.Mods
             }
 
             // disable keyboard controls
-            public bool OnPressed(CatchAction action) => true;
+            public bool OnPressed(KeyBindingPressEvent<CatchAction> e) => true;
 
-            public void OnReleased(CatchAction action)
+            public void OnReleased(KeyBindingReleaseEvent<CatchAction> e)
             {
             }
 

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

@@ -138,7 +138,7 @@ namespace osu.Game.Rulesets.Catch.Objects
 
                 if (value != null)
                 {
-                    path.ControlPoints.AddRange(value.ControlPoints.Select(c => new PathControlPoint(c.Position.Value, c.Type.Value)));
+                    path.ControlPoints.AddRange(value.ControlPoints.Select(c => new PathControlPoint(c.Position, c.Type)));
                     path.ExpectedDistance.Value = value.ExpectedDistance.Value;
                 }
             }

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

@@ -234,7 +234,7 @@ namespace osu.Game.Rulesets.Catch.Objects
 
             for (int i = 1; i < vertices.Count; i++)
             {
-                sliderPath.ControlPoints[^1].Type.Value = PathType.Linear;
+                sliderPath.ControlPoints[^1].Type = PathType.Linear;
 
                 float deltaX = vertices[i].X - lastPosition.X;
                 double length = vertices[i].Distance - currentDistance;

osu.Game.Rulesets.Catch/Skinning/Default/DefaultHitExplosion.cs

@@ -0,0 +1,129 @@
+// 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.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Utils;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Skinning.Default
+{
+    public class DefaultHitExplosion : CompositeDrawable, IHitExplosion
+    {
+        private CircularContainer largeFaint;
+        private CircularContainer smallFaint;
+        private CircularContainer directionalGlow1;
+        private CircularContainer directionalGlow2;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Size = new Vector2(20);
+            Anchor = Anchor.BottomCentre;
+            Origin = Anchor.BottomCentre;
+
+            // scale roughly in-line with visual appearance of notes
+            const float initial_height = 10;
+
+            InternalChildren = new Drawable[]
+            {
+                largeFaint = new CircularContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    Blending = BlendingParameters.Additive,
+                },
+                smallFaint = new CircularContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    Blending = BlendingParameters.Additive,
+                },
+                directionalGlow1 = new CircularContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    Size = new Vector2(0.01f, initial_height),
+                    Blending = BlendingParameters.Additive,
+                },
+                directionalGlow2 = new CircularContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    Size = new Vector2(0.01f, initial_height),
+                    Blending = BlendingParameters.Additive,
+                }
+            };
+        }
+
+        public void Animate(HitExplosionEntry entry)
+        {
+            X = entry.Position;
+            Scale = new Vector2(entry.HitObject.Scale);
+            setColour(entry.ObjectColour);
+
+            using (BeginAbsoluteSequence(entry.LifetimeStart))
+                applyTransforms(entry.HitObject.RandomSeed);
+        }
+
+        private void applyTransforms(int randomSeed)
+        {
+            const double duration = 400;
+
+            // we want our size to be very small so the glow dominates it.
+            largeFaint.Size = new Vector2(0.8f);
+            largeFaint
+                .ResizeTo(largeFaint.Size * new Vector2(5, 1), duration, Easing.OutQuint)
+                .FadeOut(duration * 2);
+
+            const float angle_variangle = 15; // should be less than 45
+            directionalGlow1.Rotation = StatelessRNG.NextSingle(-angle_variangle, angle_variangle, randomSeed, 4);
+            directionalGlow2.Rotation = StatelessRNG.NextSingle(-angle_variangle, angle_variangle, randomSeed, 5);
+
+            this.FadeInFromZero(50).Then().FadeOut(duration, Easing.Out);
+        }
+
+        private void setColour(Color4 objectColour)
+        {
+            const float roundness = 100;
+
+            largeFaint.EdgeEffect = new EdgeEffectParameters
+            {
+                Type = EdgeEffectType.Glow,
+                Colour = Interpolation.ValueAt(0.1f, objectColour, Color4.White, 0, 1).Opacity(0.3f),
+                Roundness = 160,
+                Radius = 200,
+            };
+
+            smallFaint.EdgeEffect = new EdgeEffectParameters
+            {
+                Type = EdgeEffectType.Glow,
+                Colour = Interpolation.ValueAt(0.6f, objectColour, Color4.White, 0, 1),
+                Roundness = 20,
+                Radius = 50,
+            };
+
+            directionalGlow1.EdgeEffect = directionalGlow2.EdgeEffect = new EdgeEffectParameters
+            {
+                Type = EdgeEffectType.Glow,
+                Colour = Interpolation.ValueAt(0.4f, objectColour, Color4.White, 0, 1),
+                Roundness = roundness,
+                Radius = 40,
+            };
+        }
+    }
+}

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

@@ -70,13 +70,11 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
 
                         if (version < 2.3m)
                         {
-                            if (GetTexture(@"fruit-ryuuta") != null ||
-                                GetTexture(@"fruit-ryuuta-0") != null)
+                            if (hasOldStyleCatcherSprite())
                                 return new LegacyCatcherOld();
                         }
 
-                        if (GetTexture(@"fruit-catcher-idle") != null ||
-                            GetTexture(@"fruit-catcher-idle-0") != null)
+                        if (hasNewStyleCatcherSprite())
                             return new LegacyCatcherNew();
 
                         return null;
@@ -86,12 +84,26 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
                             return new LegacyCatchComboCounter(Skin);
 
                         return null;
+
+                    case CatchSkinComponents.HitExplosion:
+                        if (hasOldStyleCatcherSprite() || hasNewStyleCatcherSprite())
+                            return new LegacyHitExplosion();
+
+                        return null;
                 }
             }
 
             return base.GetDrawableComponent(component);
         }
 
+        private bool hasOldStyleCatcherSprite() =>
+            GetTexture(@"fruit-ryuuta") != null
+            || GetTexture(@"fruit-ryuuta-0") != null;
+
+        private bool hasNewStyleCatcherSprite() =>
+            GetTexture(@"fruit-catcher-idle") != null
+            || GetTexture(@"fruit-catcher-idle-0") != null;
+
         public override IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup)
         {
             switch (lookup)

osu.Game.Rulesets.Catch/Skinning/Legacy/LegacyHitExplosion.cs

@@ -0,0 +1,94 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Skinning.Legacy
+{
+    public class LegacyHitExplosion : CompositeDrawable, IHitExplosion
+    {
+        [Resolved]
+        private Catcher catcher { get; set; }
+
+        private const float catch_margin = (1 - Catcher.ALLOWED_CATCH_RANGE) / 2;
+
+        private readonly Sprite explosion1;
+        private readonly Sprite explosion2;
+
+        public LegacyHitExplosion()
+        {
+            Anchor = Anchor.BottomCentre;
+            Origin = Anchor.BottomCentre;
+            RelativeSizeAxes = Axes.Both;
+            Scale = new Vector2(0.5f);
+
+            InternalChildren = new[]
+            {
+                explosion1 = new Sprite
+                {
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.CentreLeft,
+                    Alpha = 0,
+                    Blending = BlendingParameters.Additive,
+                    Rotation = -90
+                },
+                explosion2 = new Sprite
+                {
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.CentreLeft,
+                    Alpha = 0,
+                    Blending = BlendingParameters.Additive,
+                    Rotation = -90
+                }
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(SkinManager skins)
+        {
+            var defaultLegacySkin = skins.DefaultLegacySkin;
+
+            // sprite names intentionally swapped to match stable member naming / ease of cross-referencing
+            explosion1.Texture = defaultLegacySkin.GetTexture("scoreboard-explosion-2");
+            explosion2.Texture = defaultLegacySkin.GetTexture("scoreboard-explosion-1");
+        }
+
+        public void Animate(HitExplosionEntry entry)
+        {
+            Colour = entry.ObjectColour;
+
+            using (BeginAbsoluteSequence(entry.LifetimeStart))
+            {
+                float halfCatchWidth = catcher.CatchWidth / 2;
+                float explosionOffset = Math.Clamp(entry.Position, -halfCatchWidth + catch_margin * 3, halfCatchWidth - catch_margin * 3);
+
+                if (!(entry.HitObject is Droplet))
+                {
+                    float scale = Math.Clamp(entry.JudgementResult.ComboAtJudgement / 200f, 0.35f, 1.125f);
+
+                    explosion1.Scale = new Vector2(1, 0.9f);
+                    explosion1.Position = new Vector2(explosionOffset, 0);
+
+                    explosion1.FadeOutFromOne(300);
+                    explosion1.ScaleTo(new Vector2(16 * scale, 1.1f), 160, Easing.Out);
+                }
+
+                explosion2.Scale = new Vector2(0.9f, 1);
+                explosion2.Position = new Vector2(explosionOffset, 0);
+
+                explosion2.FadeOutFromOne(700);
+                explosion2.ScaleTo(new Vector2(0.9f, 1.3f), 500, Easing.Out);
+
+                this.Delay(700).FadeOutFromOne();
+            }
+        }
+    }
+}

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

@@ -23,6 +23,7 @@ using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
+    [Cached]
     public class Catcher : SkinReloadableDrawable
     {
         /// <summary>
@@ -106,7 +107,7 @@ namespace osu.Game.Rulesets.Catch.UI
         /// <summary>
         /// Width of the area that can be used to attempt catches during gameplay.
         /// </summary>
-        private readonly float catchWidth;
+        public readonly float CatchWidth;
 
         private readonly SkinnableCatcher body;
 
@@ -133,7 +134,7 @@ namespace osu.Game.Rulesets.Catch.UI
             if (difficulty != null)
                 Scale = calculateScale(difficulty);
 
-            catchWidth = CalculateCatchWidth(Scale);
+            CatchWidth = CalculateCatchWidth(Scale);
 
             InternalChildren = new Drawable[]
             {
@@ -193,7 +194,7 @@ namespace osu.Game.Rulesets.Catch.UI
             if (!(hitObject is PalpableCatchHitObject fruit))
                 return false;
 
-            float halfCatchWidth = catchWidth * 0.5f;
+            float halfCatchWidth = CatchWidth * 0.5f;
             return fruit.EffectiveX >= X - halfCatchWidth &&
                    fruit.EffectiveX <= X + halfCatchWidth;
         }
@@ -216,7 +217,7 @@ namespace osu.Game.Rulesets.Catch.UI
                     placeCaughtObject(palpableObject, positionInStack);
 
                 if (hitLighting.Value)
-                    addLighting(hitObject, positionInStack.X, drawableObject.AccentColour.Value);
+                    addLighting(result, drawableObject.AccentColour.Value, positionInStack.X);
             }
 
             // droplet doesn't affect the catcher state
@@ -365,8 +366,8 @@ namespace osu.Game.Rulesets.Catch.UI
             return position;
         }
 
-        private void addLighting(CatchHitObject hitObject, float x, Color4 colour) =>
-            hitExplosionContainer.Add(new HitExplosionEntry(Time.Current, x, hitObject.Scale, colour, hitObject.RandomSeed));
+        private void addLighting(JudgementResult judgementResult, Color4 colour, float x) =>
+            hitExplosionContainer.Add(new HitExplosionEntry(Time.Current, judgementResult, colour, x));
 
         private CaughtObject getCaughtObject(PalpableCatchHitObject source)
         {

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

@@ -5,6 +5,7 @@ using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.Replays;
@@ -109,15 +110,23 @@ namespace osu.Game.Rulesets.Catch.UI
 
             comboDisplay.X = Catcher.X;
 
-            if (!lastHyperDashState && Catcher.HyperDashing && Time.Elapsed > 0)
-                catcherTrails.DisplayHyperDashAfterImage(Catcher.CurrentState, Catcher.X, Catcher.BodyScale);
+            if (Time.Elapsed <= 0)
+            {
+                // This is probably a wrong value, but currently the true value is not recorded.
+                // Setting `true` will prevent generation of false-positive after-images (with more false-negatives).
+                lastHyperDashState = true;
+                return;
+            }
+
+            if (!lastHyperDashState && Catcher.HyperDashing)
+                displayCatcherTrail(CatcherTrailAnimation.HyperDashAfterImage);
 
             if (Catcher.Dashing || Catcher.HyperDashing)
             {
                 double generationInterval = Catcher.HyperDashing ? 25 : 50;
 
                 if (Time.Current - catcherTrails.LastDashTrailTime >= generationInterval)
-                    catcherTrails.DisplayDashTrail(Catcher.CurrentState, Catcher.X, Catcher.BodyScale, Catcher.HyperDashing);
+                    displayCatcherTrail(Catcher.HyperDashing ? CatcherTrailAnimation.HyperDashing : CatcherTrailAnimation.Dashing);
             }
 
             lastHyperDashState = Catcher.HyperDashing;
@@ -136,9 +145,9 @@ namespace osu.Game.Rulesets.Catch.UI
                 Catcher.VisualDirection = Direction.Left;
         }
 
-        public bool OnPressed(CatchAction action)
+        public bool OnPressed(KeyBindingPressEvent<CatchAction> e)
         {
-            switch (action)
+            switch (e.Action)
             {
                 case CatchAction.MoveLeft:
                     currentDirection--;
@@ -156,9 +165,9 @@ namespace osu.Game.Rulesets.Catch.UI
             return false;
         }
 
-        public void OnReleased(CatchAction action)
+        public void OnReleased(KeyBindingReleaseEvent<CatchAction> e)
         {
-            switch (action)
+            switch (e.Action)
             {
                 case CatchAction.MoveLeft:
                     currentDirection++;
@@ -173,5 +182,7 @@ namespace osu.Game.Rulesets.Catch.UI
                     break;
             }
         }
+
+        private void displayCatcherTrail(CatcherTrailAnimation animation) => catcherTrails.Add(new CatcherTrailEntry(Time.Current, Catcher.CurrentState, Catcher.X, Catcher.BodyScale, animation));
     }
 }

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

@@ -2,8 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Pooling;
 using osu.Framework.Timing;
+using osu.Game.Rulesets.Objects.Pooling;
 using osuTK;
 
 namespace osu.Game.Rulesets.Catch.UI
@@ -12,13 +12,8 @@ namespace osu.Game.Rulesets.Catch.UI
     /// A trail of the catcher.
     /// It also represents a hyper dash afterimage.
     /// </summary>
-    public class CatcherTrail : PoolableDrawable
+    public class CatcherTrail : PoolableDrawableWithLifetime<CatcherTrailEntry>
     {
-        public CatcherAnimationState AnimationState
-        {
-            set => body.AnimationState.Value = value;
-        }
-
         private readonly SkinnableCatcher body;
 
         public CatcherTrail()
@@ -34,11 +29,40 @@ namespace osu.Game.Rulesets.Catch.UI
             };
         }
 
-        protected override void FreeAfterUse()
+        protected override void OnApply(CatcherTrailEntry entry)
         {
+            Position = new Vector2(entry.Position, 0);
+            Scale = entry.Scale;
+
+            body.AnimationState.Value = entry.CatcherState;
+
+            using (BeginAbsoluteSequence(entry.LifetimeStart, false))
+                applyTransforms(entry.Animation);
+        }
+
+        protected override void OnFree(CatcherTrailEntry entry)
+        {
+            ApplyTransformsAt(double.MinValue);
             ClearTransforms();
-            Alpha = 1;
-            base.FreeAfterUse();
+        }
+
+        private void applyTransforms(CatcherTrailAnimation animation)
+        {
+            switch (animation)
+            {
+                case CatcherTrailAnimation.Dashing:
+                case CatcherTrailAnimation.HyperDashing:
+                    this.FadeTo(0.4f).FadeOut(800, Easing.OutQuint);
+                    break;
+
+                case CatcherTrailAnimation.HyperDashAfterImage:
+                    this.MoveToOffset(new Vector2(0, -10), 1200, Easing.In);
+                    this.ScaleTo(Scale * 0.95f).ScaleTo(Scale * 1.2f, 1200, Easing.In);
+                    this.FadeOut(1200);
+                    break;
+            }
+
+            Expire();
         }
     }
 }

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

@@ -0,0 +1,12 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Game.Rulesets.Catch.UI
+{
+    public enum CatcherTrailAnimation
+    {
+        Dashing,
+        HyperDashing,
+        HyperDashAfterImage
+    }
+}

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

@@ -2,12 +2,13 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Pooling;
 using osu.Game.Rulesets.Catch.Skinning;
+using osu.Game.Rulesets.Objects.Pooling;
 using osu.Game.Skinning;
-using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.UI
@@ -16,7 +17,7 @@ namespace osu.Game.Rulesets.Catch.UI
     /// Represents a component responsible for displaying
     /// the appropriate catcher trails when requested to.
     /// </summary>
-    public class CatcherTrailDisplay : SkinReloadableDrawable
+    public class CatcherTrailDisplay : PooledDrawableWithLifetimeContainer<CatcherTrailEntry, CatcherTrail>
     {
         /// <summary>
         /// The most recent time a dash trail was added to this container.
@@ -29,12 +30,17 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public Color4 HyperDashAfterImageColour => hyperDashAfterImages.Colour;
 
+        protected override bool RemoveRewoundEntry => true;
+
         private readonly DrawablePool<CatcherTrail> trailPool;
 
         private readonly Container<CatcherTrail> dashTrails;
         private readonly Container<CatcherTrail> hyperDashTrails;
         private readonly Container<CatcherTrail> hyperDashAfterImages;
 
+        [Resolved]
+        private ISkinSource skin { get; set; }
+
         public CatcherTrailDisplay()
         {
             RelativeSizeAxes = Axes.Both;
@@ -48,50 +54,60 @@ namespace osu.Game.Rulesets.Catch.UI
             };
         }
 
-        protected override void SkinChanged(ISkinSource skin)
+        protected override void LoadComplete()
         {
-            base.SkinChanged(skin);
+            base.LoadComplete();
 
+            skin.SourceChanged += skinSourceChanged;
+            skinSourceChanged();
+        }
+
+        private void skinSourceChanged()
+        {
             hyperDashTrails.Colour = skin.GetConfig<CatchSkinColour, Color4>(CatchSkinColour.HyperDash)?.Value ?? Catcher.DEFAULT_HYPER_DASH_COLOUR;
             hyperDashAfterImages.Colour = skin.GetConfig<CatchSkinColour, Color4>(CatchSkinColour.HyperDashAfterImage)?.Value ?? hyperDashTrails.Colour;
         }
 
-        /// <summary>
-        /// Displays a hyper-dash after-image of the catcher.
-        /// </summary>
-        public void DisplayHyperDashAfterImage(CatcherAnimationState animationState, float x, Vector2 scale)
+        protected override void AddDrawable(CatcherTrailEntry entry, CatcherTrail drawable)
         {
-            var trail = createTrail(animationState, x, scale);
+            switch (entry.Animation)
+            {
+                case CatcherTrailAnimation.Dashing:
+                    dashTrails.Add(drawable);
+                    break;
 
-            hyperDashAfterImages.Add(trail);
+                case CatcherTrailAnimation.HyperDashing:
+                    hyperDashTrails.Add(drawable);
+                    break;
 
-            trail.MoveToOffset(new Vector2(0, -10), 1200, Easing.In);
-            trail.ScaleTo(trail.Scale * 0.95f).ScaleTo(trail.Scale * 1.2f, 1200, Easing.In);
-            trail.FadeOut(1200);
-            trail.Expire(true);
+                case CatcherTrailAnimation.HyperDashAfterImage:
+                    hyperDashAfterImages.Add(drawable);
+                    break;
+            }
         }
 
-        public void DisplayDashTrail(CatcherAnimationState animationState, float x, Vector2 scale, bool hyperDashing)
+        protected override void RemoveDrawable(CatcherTrailEntry entry, CatcherTrail drawable)
         {
-            var trail = createTrail(animationState, x, scale);
+            switch (entry.Animation)
+            {
+                case CatcherTrailAnimation.Dashing:
+                    dashTrails.Remove(drawable);
+                    break;
 
-            if (hyperDashing)
-                hyperDashTrails.Add(trail);
-            else
-                dashTrails.Add(trail);
+                case CatcherTrailAnimation.HyperDashing:
+                    hyperDashTrails.Remove(drawable);
+                    break;
 
-            trail.FadeTo(0.4f).FadeOut(800, Easing.OutQuint);
-            trail.Expire(true);
+                case CatcherTrailAnimation.HyperDashAfterImage:
+                    hyperDashAfterImages.Remove(drawable);
+                    break;
+            }
         }
 
-        private CatcherTrail createTrail(CatcherAnimationState animationState, float x, Vector2 scale)
+        protected override CatcherTrail GetDrawable(CatcherTrailEntry entry)
         {
             CatcherTrail trail = trailPool.Get();
-
-            trail.AnimationState = animationState;
-            trail.Scale = scale;
-            trail.Position = new Vector2(x, 0);
-
+            trail.Apply(entry);
             return trail;
         }
 
@@ -107,5 +123,13 @@ namespace osu.Game.Rulesets.Catch.UI
 
             return maxTime;
         }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (skin != null)
+                skin.SourceChanged -= skinSourceChanged;
+        }
     }
 }

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

@@ -0,0 +1,31 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics.Performance;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.UI
+{
+    public class CatcherTrailEntry : LifetimeEntry
+    {
+        public readonly CatcherAnimationState CatcherState;
+
+        public readonly float Position;
+
+        /// <summary>
+        /// The scaling of the catcher body. It also represents a flipped catcher (negative x component).
+        /// </summary>
+        public readonly Vector2 Scale;
+
+        public readonly CatcherTrailAnimation Animation;
+
+        public CatcherTrailEntry(double startTime, CatcherAnimationState catcherState, float position, Vector2 scale, CatcherTrailAnimation animation)
+        {
+            LifetimeStart = startTime;
+            CatcherState = catcherState;
+            Position = position;
+            Scale = scale;
+            Animation = animation;
+        }
+    }
+}

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

@@ -1,129 +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 osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Effects;
-using osu.Framework.Utils;
+using osu.Game.Rulesets.Catch.Skinning.Default;
 using osu.Game.Rulesets.Objects.Pooling;
-using osu.Game.Utils;
-using osuTK;
-using osuTK.Graphics;
+using osu.Game.Skinning;
+
+#nullable enable
 
 namespace osu.Game.Rulesets.Catch.UI
 {
     public class HitExplosion : PoolableDrawableWithLifetime<HitExplosionEntry>
     {
-        private readonly CircularContainer largeFaint;
-        private readonly CircularContainer smallFaint;
-        private readonly CircularContainer directionalGlow1;
-        private readonly CircularContainer directionalGlow2;
+        private readonly SkinnableDrawable skinnableExplosion;
 
         public HitExplosion()
         {
-            Size = new Vector2(20);
-            Anchor = Anchor.TopCentre;
+            RelativeSizeAxes = Axes.Both;
+            Anchor = Anchor.BottomCentre;
             Origin = Anchor.BottomCentre;
 
-            // scale roughly in-line with visual appearance of notes
-            const float initial_height = 10;
-
-            InternalChildren = new Drawable[]
+            InternalChild = skinnableExplosion = new SkinnableDrawable(new CatchSkinComponent(CatchSkinComponents.HitExplosion), _ => new DefaultHitExplosion())
             {
-                largeFaint = new CircularContainer
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    RelativeSizeAxes = Axes.Both,
-                    Masking = true,
-                    Blending = BlendingParameters.Additive,
-                },
-                smallFaint = new CircularContainer
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    RelativeSizeAxes = Axes.Both,
-                    Masking = true,
-                    Blending = BlendingParameters.Additive,
-                },
-                directionalGlow1 = new CircularContainer
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    RelativeSizeAxes = Axes.Both,
-                    Masking = true,
-                    Size = new Vector2(0.01f, initial_height),
-                    Blending = BlendingParameters.Additive,
-                },
-                directionalGlow2 = new CircularContainer
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    RelativeSizeAxes = Axes.Both,
-                    Masking = true,
-                    Size = new Vector2(0.01f, initial_height),
-                    Blending = BlendingParameters.Additive,
-                }
+                CentreComponent = false,
+                Anchor = Anchor.BottomCentre,
+                Origin = Anchor.BottomCentre
             };
         }
 
         protected override void OnApply(HitExplosionEntry entry)
         {
-            X = entry.Position;
-            Scale = new Vector2(entry.Scale);
-            setColour(entry.ObjectColour);
-
-            using (BeginAbsoluteSequence(entry.LifetimeStart))
-                applyTransforms(entry.RNGSeed);
+            base.OnApply(entry);
+            if (IsLoaded)
+                apply(entry);
         }
 
-        private void applyTransforms(int randomSeed)
+        protected override void LoadComplete()
         {
+            base.LoadComplete();
+            apply(Entry);
+        }
+
+        private void apply(HitExplosionEntry? entry)
+        {
+            if (entry == null)
+                return;
+
+            ApplyTransformsAt(double.MinValue, true);
             ClearTransforms(true);
 
-            const double duration = 400;
-
-            // we want our size to be very small so the glow dominates it.
-            largeFaint.Size = new Vector2(0.8f);
-            largeFaint
-                .ResizeTo(largeFaint.Size * new Vector2(5, 1), duration, Easing.OutQuint)
-                .FadeOut(duration * 2);
-
-            const float angle_variangle = 15; // should be less than 45
-            directionalGlow1.Rotation = StatelessRNG.NextSingle(-angle_variangle, angle_variangle, randomSeed, 4);
-            directionalGlow2.Rotation = StatelessRNG.NextSingle(-angle_variangle, angle_variangle, randomSeed, 5);
-
-            this.FadeInFromZero(50).Then().FadeOut(duration, Easing.Out).Expire();
-        }
-
-        private void setColour(Color4 objectColour)
-        {
-            const float roundness = 100;
-
-            largeFaint.EdgeEffect = new EdgeEffectParameters
-            {
-                Type = EdgeEffectType.Glow,
-                Colour = Interpolation.ValueAt(0.1f, objectColour, Color4.White, 0, 1).Opacity(0.3f),
-                Roundness = 160,
-                Radius = 200,
-            };
-
-            smallFaint.EdgeEffect = new EdgeEffectParameters
-            {
-                Type = EdgeEffectType.Glow,
-                Colour = Interpolation.ValueAt(0.6f, objectColour, Color4.White, 0, 1),
-                Roundness = 20,
-                Radius = 50,
-            };
-
-            directionalGlow1.EdgeEffect = directionalGlow2.EdgeEffect = new EdgeEffectParameters
-            {
-                Type = EdgeEffectType.Glow,
-                Colour = Interpolation.ValueAt(0.4f, objectColour, Color4.White, 0, 1),
-                Roundness = roundness,
-                Radius = 40,
-            };
+            (skinnableExplosion.Drawable as IHitExplosion)?.Animate(entry);
+            LifetimeEnd = skinnableExplosion.Drawable.LatestTransformEndTime;
         }
     }
 }

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

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Pooling;
 using osu.Game.Rulesets.Objects.Pooling;
 
@@ -14,6 +15,8 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public HitExplosionContainer()
         {
+            RelativeSizeAxes = Axes.Both;
+
             AddInternal(pool = new DrawablePool<HitExplosion>(10));
         }
 

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

@@ -2,24 +2,42 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics.Performance;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Judgements;
 using osuTK.Graphics;
 
+#nullable enable
+
 namespace osu.Game.Rulesets.Catch.UI
 {
     public class HitExplosionEntry : LifetimeEntry
     {
-        public readonly float Position;
-        public readonly float Scale;
-        public readonly Color4 ObjectColour;
-        public readonly int RNGSeed;
+        /// <summary>
+        /// The judgement result that triggered this explosion.
+        /// </summary>
+        public JudgementResult JudgementResult { get; }
 
-        public HitExplosionEntry(double startTime, float position, float scale, Color4 objectColour, int rngSeed)
+        /// <summary>
+        /// The hitobject which triggered this explosion.
+        /// </summary>
+        public CatchHitObject HitObject => (CatchHitObject)JudgementResult.HitObject;
+
+        /// <summary>
+        /// The accent colour of the object caught.
+        /// </summary>
+        public Color4 ObjectColour { get; }
+
+        /// <summary>
+        /// The position at which the object was caught.
+        /// </summary>
+        public float Position { get; }
+
+        public HitExplosionEntry(double startTime, JudgementResult judgementResult, Color4 objectColour, float position)
         {
             LifetimeStart = startTime;
             Position = position;
-            Scale = scale;
+            JudgementResult = judgementResult;
             ObjectColour = objectColour;
-            RNGSeed = rngSeed;
         }
     }
 }

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

@@ -0,0 +1,18 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable enable
+
+namespace osu.Game.Rulesets.Catch.UI
+{
+    /// <summary>
+    /// Common interface for all hit explosion skinnables.
+    /// </summary>
+    public interface IHitExplosion
+    {
+        /// <summary>
+        /// Begins animating this <see cref="IHitExplosion"/>.
+        /// </summary>
+        void Animate(HitExplosionEntry entry);
+    }
+}

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

@@ -0,0 +1,64 @@
+// 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.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Compose;
+using osu.Game.Skinning;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Mania.Tests.Editor
+{
+    public class TestSceneManiaComposeScreen : EditorClockTestScene
+    {
+        [Resolved]
+        private SkinManager skins { get; set; }
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("setup compose screen", () =>
+            {
+                var editorBeatmap = new EditorBeatmap(new ManiaBeatmap(new StageDefinition { Columns = 4 }))
+                {
+                    BeatmapInfo = { Ruleset = new ManiaRuleset().RulesetInfo },
+                };
+
+                Beatmap.Value = CreateWorkingBeatmap(editorBeatmap.PlayableBeatmap);
+
+                Child = new DependencyProvidingContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    CachedDependencies = new (Type, object)[]
+                    {
+                        (typeof(EditorBeatmap), editorBeatmap),
+                        (typeof(IBeatSnapProvider), editorBeatmap),
+                    },
+                    Child = new ComposeScreen { State = { Value = Visibility.Visible } },
+                };
+            });
+
+            AddUntilStep("wait for composer", () => this.ChildrenOfType<HitObjectComposer>().SingleOrDefault()?.IsLoaded == true);
+        }
+
+        [Test]
+        public void TestDefaultSkin()
+        {
+            AddStep("set default skin", () => skins.CurrentSkinInfo.Value = SkinInfo.Default);
+        }
+
+        [Test]
+        public void TestLegacySkin()
+        {
+            AddStep("set legacy skin", () => skins.CurrentSkinInfo.Value = DefaultLegacySkin.Info);
+        }
+    }
+}

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

@@ -40,7 +40,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
                         {
                             c.Add(CreateHitObject().With(h =>
                             {
-                                h.HitObject.StartTime = START_TIME;
+                                h.HitObject.StartTime = Time.Current + 5000;
                                 h.AccentColour.Value = Color4.Orange;
                             }));
                         })
@@ -58,7 +58,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
                         {
                             c.Add(CreateHitObject().With(h =>
                             {
-                                h.HitObject.StartTime = START_TIME;
+                                h.HitObject.StartTime = Time.Current + 5000;
                                 h.AccentColour.Value = Color4.Orange;
                             }));
                         })

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

@@ -19,8 +19,6 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
     /// </summary>
     public abstract class ManiaSkinnableTestScene : SkinnableTestScene
     {
-        protected const double START_TIME = 1000000000;
-
         [Cached(Type = typeof(IScrollingInfo))]
         private readonly TestScrollingInfo scrollingInfo = new TestScrollingInfo();
 
@@ -55,27 +53,8 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
             public readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
 
             IBindable<ScrollingDirection> IScrollingInfo.Direction => Direction;
-            IBindable<double> IScrollingInfo.TimeRange { get; } = new Bindable<double>(1000);
-            IScrollAlgorithm IScrollingInfo.Algorithm { get; } = new ZeroScrollAlgorithm();
-        }
-
-        private class ZeroScrollAlgorithm : IScrollAlgorithm
-        {
-            public double GetDisplayStartTime(double originTime, float offset, double timeRange, float scrollLength)
-                => double.MinValue;
-
-            public float GetLength(double startTime, double endTime, double timeRange, float scrollLength)
-                => scrollLength;
-
-            public float PositionAt(double time, double currentTime, double timeRange, float scrollLength)
-                => (float)((time - START_TIME) / timeRange) * scrollLength;
-
-            public double TimeAt(float position, double currentTime, double timeRange, float scrollLength)
-                => 0;
-
-            public void Reset()
-            {
-            }
+            IBindable<double> IScrollingInfo.TimeRange { get; } = new Bindable<double>(5000);
+            IScrollAlgorithm IScrollingInfo.Algorithm { get; } = new ConstantScrollAlgorithm();
         }
     }
 }

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

@@ -3,6 +3,7 @@
 
 using NUnit.Framework;
 using osu.Framework.Graphics;
+using osu.Framework.Input.Events;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
@@ -58,7 +59,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             AddStep("Hold key", () =>
             {
                 clock.CurrentTime = 0;
-                note.OnPressed(ManiaAction.Key1);
+                note.OnPressed(new KeyBindingPressEvent<ManiaAction>(GetContainingInputManager().CurrentState, ManiaAction.Key1));
             });
             AddStep("progress time", () => clock.CurrentTime = 500);
             AddAssert("head is visible", () => note.Head.Alpha == 1);

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

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Allocation;
@@ -13,6 +14,10 @@ using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Configuration;
 using osu.Framework.Bindables;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.UI;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {
@@ -22,14 +27,65 @@ namespace osu.Game.Rulesets.Mania.Tests
         [Resolved]
         private RulesetConfigCache configCache { get; set; }
 
-        private readonly Bindable<bool> configTimingBasedNoteColouring = new Bindable<bool>();
+        private Bindable<bool> configTimingBasedNoteColouring;
 
-        protected override void LoadComplete()
+        private ManualClock clock;
+        private DrawableManiaRuleset drawableRuleset;
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("setup hierarchy", () => Child = new Container
+            {
+                Clock = new FramedClock(clock = new ManualClock()),
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Children = new[]
+                {
+                    drawableRuleset = (DrawableManiaRuleset)Ruleset.Value.CreateInstance().CreateDrawableRulesetWith(createTestBeatmap())
+                }
+            });
+            AddStep("retrieve config bindable", () =>
+            {
+                var config = (ManiaRulesetConfigManager)configCache.GetConfigFor(Ruleset.Value.CreateInstance());
+                configTimingBasedNoteColouring = config.GetBindable<bool>(ManiaRulesetSetting.TimingBasedNoteColouring);
+            });
+        }
+
+        [Test]
+        public void TestSimple()
+        {
+            AddStep("enable", () => configTimingBasedNoteColouring.Value = true);
+            AddStep("disable", () => configTimingBasedNoteColouring.Value = false);
+        }
+
+        [Test]
+        public void TestToggleOffScreen()
+        {
+            AddStep("enable", () => configTimingBasedNoteColouring.Value = true);
+
+            seekTo(10000);
+            AddStep("disable", () => configTimingBasedNoteColouring.Value = false);
+            seekTo(0);
+            AddAssert("all notes not coloured", () => this.ChildrenOfType<DrawableNote>().All(note => note.Colour == Colour4.White));
+
+            seekTo(10000);
+            AddStep("enable again", () => configTimingBasedNoteColouring.Value = true);
+            seekTo(0);
+            AddAssert("some notes coloured", () => this.ChildrenOfType<DrawableNote>().Any(note => note.Colour != Colour4.White));
+        }
+
+        private void seekTo(double time)
+        {
+            AddStep($"seek to {time}", () => clock.CurrentTime = time);
+            AddUntilStep("wait for seek", () => Precision.AlmostEquals(drawableRuleset.FrameStableClock.CurrentTime, time, 1));
+        }
+
+        private ManiaBeatmap createTestBeatmap()
         {
             const double beat_length = 500;
 
-            var ruleset = new ManiaRuleset();
-
             var beatmap = new ManiaBeatmap(new StageDefinition { Columns = 1 })
             {
                 HitObjects =
@@ -45,7 +101,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                     new Note { StartTime = beat_length }
                 },
                 ControlPointInfo = new ControlPointInfo(),
-                BeatmapInfo = { Ruleset = ruleset.RulesetInfo },
+                BeatmapInfo = { Ruleset = Ruleset.Value },
             };
 
             foreach (var note in beatmap.HitObjects)
@@ -57,24 +113,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             {
                 BeatLength = beat_length
             });
-
-            Child = new Container
-            {
-                Clock = new FramedClock(new ManualClock()),
-                RelativeSizeAxes = Axes.Both,
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                Children = new[]
-                {
-                    ruleset.CreateDrawableRulesetWith(beatmap)
-                }
-            };
-
-            var config = (ManiaRulesetConfigManager)configCache.GetConfigFor(Ruleset.Value.CreateInstance());
-            config.BindWith(ManiaRulesetSetting.TimingBasedNoteColouring, configTimingBasedNoteColouring);
-
-            AddStep("Enable", () => configTimingBasedNoteColouring.Value = true);
-            AddStep("Disable", () => configTimingBasedNoteColouring.Value = false);
+            return beatmap;
         }
     }
 }

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

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

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

@@ -149,7 +149,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         {
             lowerBound ??= RandomStart;
             upperBound ??= TotalColumns;
-            nextColumn ??= (_ => GetRandomColumn(lowerBound, upperBound));
+            nextColumn ??= _ => GetRandomColumn(lowerBound, upperBound);
 
             // Check for the initial column
             if (isValid(initialColumn))
@@ -176,7 +176,19 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             return initialColumn;
 
-            bool isValid(int column) => validation?.Invoke(column) != false && !patterns.Any(p => p.ColumnHasObject(column));
+            bool isValid(int column)
+            {
+                if (validation?.Invoke(column) == false)
+                    return false;
+
+                foreach (var p in patterns)
+                {
+                    if (p.ColumnHasObject(column))
+                        return false;
+                }
+
+                return true;
+            }
         }
 
         /// <summary>

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Pattern.cs

@@ -12,46 +12,68 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns
     /// </summary>
     internal class Pattern
     {
-        private readonly List<ManiaHitObject> hitObjects = new List<ManiaHitObject>();
+        private List<ManiaHitObject> hitObjects;
+        private HashSet<int> containedColumns;
 
         /// <summary>
         /// All the hit objects contained in this pattern.
         /// </summary>
-        public IEnumerable<ManiaHitObject> HitObjects => hitObjects;
+        public IEnumerable<ManiaHitObject> HitObjects => hitObjects ?? Enumerable.Empty<ManiaHitObject>();
 
         /// <summary>
         /// Check whether a column of this patterns contains a hit object.
         /// </summary>
         /// <param name="column">The column index.</param>
         /// <returns>Whether the column with index <paramref name="column"/> contains a hit object.</returns>
-        public bool ColumnHasObject(int column) => hitObjects.Exists(h => h.Column == column);
+        public bool ColumnHasObject(int column) => containedColumns?.Contains(column) == true;
 
         /// <summary>
         /// Amount of columns taken up by hit objects in this pattern.
         /// </summary>
-        public int ColumnWithObjects => HitObjects.GroupBy(h => h.Column).Count();
+        public int ColumnWithObjects => containedColumns?.Count ?? 0;
 
         /// <summary>
         /// Adds a hit object to this pattern.
         /// </summary>
         /// <param name="hitObject">The hit object to add.</param>
-        public void Add(ManiaHitObject hitObject) => hitObjects.Add(hitObject);
+        public void Add(ManiaHitObject hitObject)
+        {
+            prepareStorage();
+
+            hitObjects.Add(hitObject);
+            containedColumns.Add(hitObject.Column);
+        }
 
         /// <summary>
         /// Copies hit object from another pattern to this one.
         /// </summary>
         /// <param name="other">The other pattern.</param>
-        public void Add(Pattern other) => hitObjects.AddRange(other.HitObjects);
+        public void Add(Pattern other)
+        {
+            prepareStorage();
+
+            if (other.hitObjects != null)
+            {
+                hitObjects.AddRange(other.hitObjects);
+
+                foreach (var h in other.hitObjects)
+                    containedColumns.Add(h.Column);
+            }
+        }
 
         /// <summary>
         /// Clears this pattern, removing all hit objects.
         /// </summary>
-        public void Clear() => hitObjects.Clear();
+        public void Clear()
+        {
+            hitObjects?.Clear();
+            containedColumns?.Clear();
+        }
 
-        /// <summary>
-        /// Removes a hit object from this pattern.
-        /// </summary>
-        /// <param name="hitObject">The hit object to remove.</param>
-        public bool Remove(ManiaHitObject hitObject) => hitObjects.Remove(hitObject);
+        private void prepareStorage()
+        {
+            hitObjects ??= new List<ManiaHitObject>();
+            containedColumns ??= new HashSet<int>();
+        }
     }
 }

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

@@ -10,7 +10,7 @@ using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Mania.Difficulty.Skills
 {
-    public class Strain : StrainSkill
+    public class Strain : StrainDecaySkill
     {
         private const double individual_decay_base = 0.125;
         private const double overall_decay_base = 0.30;
@@ -71,7 +71,7 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Skills
             return individualStrain + overallStrain - CurrentStrain;
         }
 
-        protected override double GetPeakStrain(double offset)
+        protected override double CalculateInitialStrain(double offset)
             => applyDecay(individualStrain, offset - Previous[0].StartTime, individual_decay_base)
                + applyDecay(overallStrain, offset - Previous[0].StartTime, overall_decay_base);
 

osu.Game.Rulesets.Mania/Edit/Setup/ManiaSetupSection.cs

@@ -0,0 +1,46 @@
+// 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.Graphics.UserInterfaceV2;
+using osu.Game.Screens.Edit.Setup;
+
+namespace osu.Game.Rulesets.Mania.Edit.Setup
+{
+    public class ManiaSetupSection : RulesetSetupSection
+    {
+        private LabelledSwitchButton specialStyle;
+
+        public ManiaSetupSection()
+            : base(new ManiaRuleset().RulesetInfo)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Children = new Drawable[]
+            {
+                specialStyle = new LabelledSwitchButton
+                {
+                    Label = "Use special (N+1) style",
+                    Description = "Changes one column to act as a classic \"scratch\" or \"special\" column, which can be moved around by the user's skin (to the left/right/centre). Generally used in 5k (4+1) or 8key (7+1) configurations.",
+                    Current = { Value = Beatmap.BeatmapInfo.SpecialStyle }
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            specialStyle.Current.BindValueChanged(_ => updateBeatmap());
+        }
+
+        private void updateBeatmap()
+        {
+            Beatmap.BeatmapInfo.SpecialStyle = specialStyle.Current.Value;
+        }
+    }
+}

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -27,11 +27,13 @@ using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.Difficulty;
 using osu.Game.Rulesets.Mania.Edit;
+using osu.Game.Rulesets.Mania.Edit.Setup;
 using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mania.Skinning.Legacy;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;
 using osu.Game.Scoring;
+using osu.Game.Screens.Edit.Setup;
 using osu.Game.Screens.Ranking.Statistics;
 
 namespace osu.Game.Rulesets.Mania
@@ -390,6 +392,8 @@ namespace osu.Game.Rulesets.Mania
         {
             return new ManiaFilterCriteria();
         }
+
+        public override RulesetSetupSection CreateEditorSetupSection() => new ManiaSetupSection();
     }
 
     public enum PlayfieldType

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

@@ -7,6 +7,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Mania.Skinning.Default;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -253,12 +254,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 HoldBrokenTime = Time.Current;
         }
 
-        public bool OnPressed(ManiaAction action)
+        public bool OnPressed(KeyBindingPressEvent<ManiaAction> e)
         {
             if (AllJudged)
                 return false;
 
-            if (action != Action.Value)
+            if (e.Action != Action.Value)
                 return false;
 
             // do not run any of this logic when rewinding, as it inverts order of presses/releases.
@@ -275,9 +276,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 return false;
 
             beginHoldAt(Time.Current - Head.HitObject.StartTime);
-            Head.UpdateResult();
 
-            return true;
+            return Head.UpdateResult();
         }
 
         private void beginHoldAt(double timeOffset)
@@ -289,12 +289,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             isHitting.Value = true;
         }
 
-        public void OnReleased(ManiaAction action)
+        public void OnReleased(KeyBindingReleaseEvent<ManiaAction> e)
         {
             if (AllJudged)
                 return;
 
-            if (action != Action.Value)
+            if (e.Action != Action.Value)
                 return;
 
             // do not run any of this logic when rewinding, as it inverts order of presses/releases.

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables
@@ -25,7 +26,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             Origin = Anchor.TopCentre;
         }
 
-        public void UpdateResult() => base.UpdateResult(true);
+        public bool UpdateResult() => base.UpdateResult(true);
 
         protected override void UpdateInitialTransforms()
         {
@@ -43,9 +44,9 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             // it will be hidden along with its parenting hold note when required.
         }
 
-        public override bool OnPressed(ManiaAction action) => false; // Handled by the hold note
+        public override bool OnPressed(KeyBindingPressEvent<ManiaAction> e) => false; // Handled by the hold note
 
-        public override void OnReleased(ManiaAction action)
+        public override void OnReleased(KeyBindingReleaseEvent<ManiaAction> e)
         {
         }
     }

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

@@ -3,6 +3,7 @@
 
 using System.Diagnostics;
 using osu.Framework.Graphics;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables
@@ -68,9 +69,9 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             });
         }
 
-        public override bool OnPressed(ManiaAction action) => false; // Handled by the hold note
+        public override bool OnPressed(KeyBindingPressEvent<ManiaAction> e) => false; // Handled by the hold note
 
-        public override void OnReleased(ManiaAction action)
+        public override void OnReleased(KeyBindingReleaseEvent<ManiaAction> e)
         {
         }
     }

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

@@ -6,7 +6,6 @@ using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Game.Audio;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Rulesets.Mania.UI;
@@ -29,11 +28,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         [Resolved(canBeNull: true)]
         private ManiaPlayfield playfield { get; set; }
 
-        /// <summary>
-        /// Gets the samples that are played by this object during gameplay.
-        /// </summary>
-        public ISampleInfo[] GetGameplaySamples() => Samples.Samples;
-
         protected override float SamplePlaybackPosition
         {
             get

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

@@ -6,6 +6,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Configuration;
@@ -66,6 +67,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             StartTimeBindable.BindValueChanged(_ => updateSnapColour(), true);
         }
 
+        protected override void OnApply()
+        {
+            base.OnApply();
+            updateSnapColour();
+        }
+
         protected override void OnDirectionChanged(ValueChangedEvent<ScrollingDirection> e)
         {
             base.OnDirectionChanged(e);
@@ -91,9 +98,9 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             ApplyResult(r => r.Type = result);
         }
 
-        public virtual bool OnPressed(ManiaAction action)
+        public virtual bool OnPressed(KeyBindingPressEvent<ManiaAction> e)
         {
-            if (action != Action.Value)
+            if (e.Action != Action.Value)
                 return false;
 
             if (CheckHittable?.Invoke(this, Time.Current) == false)
@@ -102,7 +109,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             return UpdateResult(true);
         }
 
-        public virtual void OnReleased(ManiaAction action)
+        public virtual void OnReleased(KeyBindingReleaseEvent<ManiaAction> e)
         {
         }
 

osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyColumnBackground.cs

@@ -7,6 +7,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
 using osuTK;
@@ -76,9 +77,9 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
             }
         }
 
-        public bool OnPressed(ManiaAction action)
+        public bool OnPressed(KeyBindingPressEvent<ManiaAction> e)
         {
-            if (action == Column.Action.Value)
+            if (e.Action == Column.Action.Value)
             {
                 light.FadeIn();
                 light.ScaleTo(Vector2.One);
@@ -87,12 +88,12 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
             return false;
         }
 
-        public void OnReleased(ManiaAction action)
+        public void OnReleased(KeyBindingReleaseEvent<ManiaAction> e)
         {
             // Todo: Should be 400 * 100 / CurrentBPM
             const double animation_length = 250;
 
-            if (action == Column.Action.Value)
+            if (e.Action == Column.Action.Value)
             {
                 light.FadeTo(0, animation_length);
                 light.ScaleTo(new Vector2(1, 0), animation_length);

osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyHoldNoteHeadPiece.cs

@@ -1,18 +1,18 @@
 // 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.Textures;
+using osu.Framework.Graphics;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 {
     public class LegacyHoldNoteHeadPiece : LegacyNotePiece
     {
-        protected override Texture GetTexture(ISkinSource skin)
+        protected override Drawable GetAnimation(ISkinSource skin)
         {
             // TODO: Should fallback to the head from default legacy skin instead of note.
-            return GetTextureFromLookup(skin, LegacyManiaSkinConfigurationLookups.HoldNoteHeadImage)
-                   ?? GetTextureFromLookup(skin, LegacyManiaSkinConfigurationLookups.NoteImage);
+            return GetAnimationFromLookup(skin, LegacyManiaSkinConfigurationLookups.HoldNoteHeadImage)
+                   ?? GetAnimationFromLookup(skin, LegacyManiaSkinConfigurationLookups.NoteImage);
         }
     }
 }

osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyHoldNoteTailPiece.cs

@@ -2,7 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Bindables;
-using osu.Framework.Graphics.Textures;
+using osu.Framework.Graphics;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
 
@@ -18,12 +18,12 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
                 : new ValueChangedEvent<ScrollingDirection>(ScrollingDirection.Up, ScrollingDirection.Up));
         }
 
-        protected override Texture GetTexture(ISkinSource skin)
+        protected override Drawable GetAnimation(ISkinSource skin)
         {
             // TODO: Should fallback to the head from default legacy skin instead of note.
-            return GetTextureFromLookup(skin, LegacyManiaSkinConfigurationLookups.HoldNoteTailImage)
-                   ?? GetTextureFromLookup(skin, LegacyManiaSkinConfigurationLookups.HoldNoteHeadImage)
-                   ?? GetTextureFromLookup(skin, LegacyManiaSkinConfigurationLookups.NoteImage);
+            return GetAnimationFromLookup(skin, LegacyManiaSkinConfigurationLookups.HoldNoteTailImage)
+                   ?? GetAnimationFromLookup(skin, LegacyManiaSkinConfigurationLookups.HoldNoteHeadImage)
+                   ?? GetAnimationFromLookup(skin, LegacyManiaSkinConfigurationLookups.NoteImage);
         }
     }
 }

osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyKeyArea.cs

@@ -7,6 +7,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
@@ -86,9 +87,9 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
             }
         }
 
-        public bool OnPressed(ManiaAction action)
+        public bool OnPressed(KeyBindingPressEvent<ManiaAction> e)
         {
-            if (action == column.Action.Value)
+            if (e.Action == column.Action.Value)
             {
                 upSprite.FadeTo(0);
                 downSprite.FadeTo(1);
@@ -97,9 +98,9 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
             return false;
         }
 
-        public void OnReleased(ManiaAction action)
+        public void OnReleased(KeyBindingReleaseEvent<ManiaAction> e)
         {
-            if (action == column.Action.Value)
+            if (e.Action == column.Action.Value)
             {
                 upSprite.Delay(LegacyHitExplosion.FADE_IN_DURATION).FadeTo(1);
                 downSprite.Delay(LegacyHitExplosion.FADE_IN_DURATION).FadeTo(0);

osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyNotePiece.cs

@@ -1,9 +1,11 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Animations;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Sprites;
@@ -19,7 +21,9 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
         private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
 
         private Container directionContainer;
-        private Sprite noteSprite;
+
+        [CanBeNull]
+        private Drawable noteAnimation;
 
         private float? minimumColumnWidth;
 
@@ -39,7 +43,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
                 Origin = Anchor.BottomCentre,
                 RelativeSizeAxes = Axes.X,
                 AutoSizeAxes = Axes.Y,
-                Child = noteSprite = new Sprite { Texture = GetTexture(skin) }
+                Child = noteAnimation = GetAnimation(skin) ?? Empty()
             };
 
             direction.BindTo(scrollingInfo.Direction);
@@ -50,12 +54,18 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
         {
             base.Update();
 
-            if (noteSprite.Texture != null)
+            Texture texture = null;
+
+            if (noteAnimation is Sprite sprite)
+                texture = sprite.Texture;
+            else if (noteAnimation is TextureAnimation textureAnimation && textureAnimation.FrameCount > 0)
+                texture = textureAnimation.CurrentFrame;
+
+            if (texture != null)
             {
                 // The height is scaled to the minimum column width, if provided.
                 float minimumWidth = minimumColumnWidth ?? DrawWidth;
-
-                noteSprite.Scale = Vector2.Divide(new Vector2(DrawWidth, minimumWidth), noteSprite.Texture.DisplayWidth);
+                noteAnimation.Scale = Vector2.Divide(new Vector2(DrawWidth, minimumWidth), texture.DisplayWidth);
             }
         }
 
@@ -73,9 +83,11 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
             }
         }
 
-        protected virtual Texture GetTexture(ISkinSource skin) => GetTextureFromLookup(skin, LegacyManiaSkinConfigurationLookups.NoteImage);
+        [CanBeNull]
+        protected virtual Drawable GetAnimation(ISkinSource skin) => GetAnimationFromLookup(skin, LegacyManiaSkinConfigurationLookups.NoteImage);
 
-        protected Texture GetTextureFromLookup(ISkin skin, LegacyManiaSkinConfigurationLookups lookup)
+        [CanBeNull]
+        protected Drawable GetAnimationFromLookup(ISkin skin, LegacyManiaSkinConfigurationLookups lookup)
         {
             string suffix = string.Empty;
 
@@ -93,7 +105,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
             string noteImage = GetColumnSkinConfig<string>(skin, lookup)?.Value
                                ?? $"mania-note{FallbackColumnIndex}{suffix}";
 
-            return skin.GetTexture(noteImage, WrapMode.ClampToEdge, WrapMode.ClampToEdge);
+            return skin.GetAnimation(noteImage, WrapMode.ClampToEdge, WrapMode.ClampToEdge, true, true);
         }
     }
 }

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

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.Linq;
 using osuTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -11,6 +10,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Pooling;
 using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.UI.Components;
 using osu.Game.Rulesets.UI.Scrolling;
@@ -19,6 +19,7 @@ using osuTK;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
@@ -28,12 +29,6 @@ namespace osu.Game.Rulesets.Mania.UI
         public const float COLUMN_WIDTH = 80;
         public const float SPECIAL_COLUMN_WIDTH = 70;
 
-        /// <summary>
-        /// For hitsounds played by this <see cref="Column"/> (i.e. not as a result of hitting a hitobject),
-        /// a certain number of samples are allowed to be played concurrently so that it feels better when spam-pressing the key.
-        /// </summary>
-        private const int max_concurrent_hitsounds = OsuGameBase.SAMPLE_CONCURRENCY;
-
         /// <summary>
         /// The index of this column as part of the whole playfield.
         /// </summary>
@@ -45,10 +40,10 @@ namespace osu.Game.Rulesets.Mania.UI
         internal readonly Container TopLevelContainer;
         private readonly DrawablePool<PoolableHitExplosion> hitExplosionPool;
         private readonly OrderedHitPolicy hitPolicy;
-        private readonly Container<SkinnableSound> hitSounds;
-
         public Container UnderlayElements => HitObjectArea.UnderlayElements;
 
+        private readonly GameplaySampleTriggerSource sampleTriggerSource;
+
         public Column(int index)
         {
             Index = index;
@@ -64,6 +59,7 @@ namespace osu.Game.Rulesets.Mania.UI
             InternalChildren = new[]
             {
                 hitExplosionPool = new DrawablePool<PoolableHitExplosion>(5),
+                sampleTriggerSource = new GameplaySampleTriggerSource(HitObjectContainer),
                 // For input purposes, the background is added at the highest depth, but is then proxied back below all other elements
                 background.CreateProxy(),
                 HitObjectArea = new ColumnHitObjectArea(Index, HitObjectContainer) { RelativeSizeAxes = Axes.Both },
@@ -72,12 +68,6 @@ namespace osu.Game.Rulesets.Mania.UI
                     RelativeSizeAxes = Axes.Both
                 },
                 background,
-                hitSounds = new Container<SkinnableSound>
-                {
-                    Name = "Column samples pool",
-                    RelativeSizeAxes = Axes.Both,
-                    Children = Enumerable.Range(0, max_concurrent_hitsounds).Select(_ => new SkinnableSound()).ToArray()
-                },
                 TopLevelContainer = new Container { RelativeSizeAxes = Axes.Both }
             };
 
@@ -133,33 +123,16 @@ namespace osu.Game.Rulesets.Mania.UI
             HitObjectArea.Explosions.Add(hitExplosionPool.Get(e => e.Apply(result)));
         }
 
-        private int nextHitSoundIndex;
-
-        public bool OnPressed(ManiaAction action)
+        public bool OnPressed(KeyBindingPressEvent<ManiaAction> e)
         {
-            if (action != Action.Value)
+            if (e.Action != Action.Value)
                 return false;
 
-            var nextObject =
-                HitObjectContainer.AliveObjects.FirstOrDefault(h => h.HitObject.StartTime > Time.Current) ??
-                // fallback to non-alive objects to find next off-screen object
-                HitObjectContainer.Objects.FirstOrDefault(h => h.HitObject.StartTime > Time.Current) ??
-                HitObjectContainer.Objects.LastOrDefault();
-
-            if (nextObject is DrawableManiaHitObject maniaObject)
-            {
-                var hitSound = hitSounds[nextHitSoundIndex];
-
-                hitSound.Samples = maniaObject.GetGameplaySamples();
-                hitSound.Play();
-
-                nextHitSoundIndex = (nextHitSoundIndex + 1) % max_concurrent_hitsounds;
-            }
-
+            sampleTriggerSource.Play();
             return true;
         }
 
-        public void OnReleased(ManiaAction action)
+        public void OnReleased(KeyBindingReleaseEvent<ManiaAction> e)
         {
         }
 

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

@@ -9,6 +9,7 @@ using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.UI.Scrolling;
 using osuTK.Graphics;
@@ -91,16 +92,16 @@ namespace osu.Game.Rulesets.Mania.UI.Components
                 direction.Value == ScrollingDirection.Up ? dimPoint : brightPoint);
         }
 
-        public bool OnPressed(ManiaAction action)
+        public bool OnPressed(KeyBindingPressEvent<ManiaAction> e)
         {
-            if (action == this.action.Value)
+            if (e.Action == action.Value)
                 backgroundOverlay.FadeTo(1, 50, Easing.OutQuint).Then().FadeTo(0.5f, 250, Easing.OutQuint);
             return false;
         }
 
-        public void OnReleased(ManiaAction action)
+        public void OnReleased(KeyBindingReleaseEvent<ManiaAction> e)
         {
-            if (action == this.action.Value)
+            if (e.Action == action.Value)
                 backgroundOverlay.FadeTo(0, 250, Easing.OutQuint);
         }
     }

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

@@ -9,6 +9,7 @@ using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.UI.Scrolling;
 using osuTK.Graphics;
 
@@ -74,16 +75,16 @@ namespace osu.Game.Rulesets.Mania.UI.Components
             }
         }
 
-        public bool OnPressed(ManiaAction action)
+        public bool OnPressed(KeyBindingPressEvent<ManiaAction> e)
         {
-            if (action == column.Action.Value)
+            if (e.Action == column.Action.Value)
                 backgroundOverlay.FadeTo(1, 50, Easing.OutQuint).Then().FadeTo(0.5f, 250, Easing.OutQuint);
             return false;
         }
 
-        public void OnReleased(ManiaAction action)
+        public void OnReleased(KeyBindingReleaseEvent<ManiaAction> e)
         {
-            if (action == column.Action.Value)
+            if (e.Action == column.Action.Value)
                 backgroundOverlay.FadeTo(0, 250, Easing.OutQuint);
         }
     }

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

@@ -10,6 +10,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.UI.Scrolling;
 using osuTK;
 using osuTK.Graphics;
@@ -101,16 +102,16 @@ namespace osu.Game.Rulesets.Mania.UI.Components
             }
         }
 
-        public bool OnPressed(ManiaAction action)
+        public bool OnPressed(KeyBindingPressEvent<ManiaAction> e)
         {
-            if (action == column.Action.Value)
+            if (e.Action == column.Action.Value)
                 keyIcon.ScaleTo(1.4f, 50, Easing.OutQuint).Then().ScaleTo(1.3f, 250, Easing.OutQuint);
             return false;
         }
 
-        public void OnReleased(ManiaAction action)
+        public void OnReleased(KeyBindingReleaseEvent<ManiaAction> e)
         {
-            if (action == column.Action.Value)
+            if (e.Action == column.Action.Value)
                 keyIcon.ScaleTo(1f, 125, Easing.OutQuint);
         }
     }

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

@@ -37,12 +37,11 @@ namespace osu.Game.Rulesets.Mania.UI
 
             public override void PlayAnimation()
             {
-                base.PlayAnimation();
-
                 switch (Result)
                 {
                     case HitResult.None:
                     case HitResult.Miss:
+                        base.PlayAnimation();
                         break;
 
                     default:
@@ -52,6 +51,8 @@ namespace osu.Game.Rulesets.Mania.UI
                         this.Delay(50)
                             .ScaleTo(0.75f, 250)
                             .FadeOut(200);
+
+                        // osu!mania uses a custom fade length, so the base call is intentionally omitted.
                         break;
                 }
             }

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuEditorGrids.cs

@@ -0,0 +1,78 @@
+// 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.Testing;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Osu.Edit;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles;
+using osu.Game.Tests.Visual;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Osu.Tests.Editor
+{
+    public class TestSceneOsuEditorGrids : EditorTestScene
+    {
+        protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
+
+        [Test]
+        public void TestGridExclusivity()
+        {
+            AddStep("enable distance snap grid", () => InputManager.Key(Key.T));
+            AddStep("select second object", () => EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects.ElementAt(1)));
+            AddUntilStep("distance snap grid visible", () => this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
+            rectangularGridActive(false);
+
+            AddStep("enable rectangular grid", () => InputManager.Key(Key.Y));
+            AddUntilStep("distance snap grid hidden", () => !this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
+            rectangularGridActive(true);
+
+            AddStep("enable distance snap grid", () => InputManager.Key(Key.T));
+            AddStep("select second object", () => EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects.ElementAt(1)));
+            AddUntilStep("distance snap grid visible", () => this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
+            rectangularGridActive(false);
+        }
+
+        private void rectangularGridActive(bool active)
+        {
+            AddStep("choose placement tool", () => InputManager.Key(Key.Number2));
+            AddStep("move cursor to (1, 1)", () =>
+            {
+                var composer = Editor.ChildrenOfType<OsuRectangularPositionSnapGrid>().Single();
+                InputManager.MoveMouseTo(composer.ToScreenSpace(new Vector2(1, 1)));
+            });
+
+            if (active)
+                AddAssert("placement blueprint at (0, 0)", () => Precision.AlmostEquals(Editor.ChildrenOfType<HitCirclePlacementBlueprint>().Single().HitObject.Position, new Vector2(0, 0)));
+            else
+                AddAssert("placement blueprint at (1, 1)", () => Precision.AlmostEquals(Editor.ChildrenOfType<HitCirclePlacementBlueprint>().Single().HitObject.Position, new Vector2(1, 1)));
+
+            AddStep("choose selection tool", () => InputManager.Key(Key.Number1));
+        }
+
+        [Test]
+        public void TestGridSizeToggling()
+        {
+            AddStep("enable rectangular grid", () => InputManager.Key(Key.Y));
+            AddUntilStep("rectangular grid visible", () => this.ChildrenOfType<OsuRectangularPositionSnapGrid>().Any());
+            gridSizeIs(4);
+
+            nextGridSizeIs(8);
+            nextGridSizeIs(16);
+            nextGridSizeIs(32);
+            nextGridSizeIs(4);
+        }
+
+        private void nextGridSizeIs(int size)
+        {
+            AddStep("toggle to next grid size", () => InputManager.Key(Key.G));
+            gridSizeIs(size);
+        }
+
+        private void gridSizeIs(int size)
+            => AddAssert($"grid size is {size}", () => this.ChildrenOfType<OsuRectangularPositionSnapGrid>().Single().Spacing == new Vector2(size)
+                                                       && EditorBeatmap.BeatmapInfo.GridSize == size);
+    }
+}

osu.Game.Rulesets.Osu.Tests/Editor/TestScenePathControlPointVisualiser.cs

@@ -40,7 +40,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
 
             AddAssert("last connection displayed", () =>
             {
-                var lastConnection = visualiser.Connections.Last(c => c.ControlPoint.Position.Value == new Vector2(300));
+                var lastConnection = visualiser.Connections.Last(c => c.ControlPoint.Position == new Vector2(300));
                 return lastConnection.DrawWidth > 50;
             });
         }
@@ -166,14 +166,14 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
         {
             AddStep($"move mouse to control point {index}", () =>
             {
-                Vector2 position = slider.Path.ControlPoints[index].Position.Value;
+                Vector2 position = slider.Path.ControlPoints[index].Position;
                 InputManager.MoveMouseTo(visualiser.Pieces[0].Parent.ToScreenSpace(position));
             });
         }
 
         private void assertControlPointPathType(int controlPointIndex, PathType? type)
         {
-            AddAssert($"point {controlPointIndex} is {type}", () => slider.Path.ControlPoints[controlPointIndex].Type.Value == type);
+            AddAssert($"point {controlPointIndex} is {type}", () => slider.Path.ControlPoints[controlPointIndex].Type == type);
         }
 
         private void addContextMenuItemStep(string contextMenuText)

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderControlPointPiece.cs

@@ -108,9 +108,9 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
         [Test]
         public void TestDragControlPointPathAfterChangingType()
         {
-            AddStep("change type to bezier", () => slider.Path.ControlPoints[2].Type.Value = PathType.Bezier);
+            AddStep("change type to bezier", () => slider.Path.ControlPoints[2].Type = PathType.Bezier);
             AddStep("add point", () => slider.Path.ControlPoints.Add(new PathControlPoint(new Vector2(500, 10))));
-            AddStep("change type to perfect", () => slider.Path.ControlPoints[3].Type.Value = PathType.PerfectCurve);
+            AddStep("change type to perfect", () => slider.Path.ControlPoints[3].Type = PathType.PerfectCurve);
 
             moveMouseToControlPoint(4);
             AddStep("hold", () => InputManager.PressButton(MouseButton.Left));
@@ -137,15 +137,15 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
         {
             AddStep($"move mouse to control point {index}", () =>
             {
-                Vector2 position = slider.Position + slider.Path.ControlPoints[index].Position.Value;
+                Vector2 position = slider.Position + slider.Path.ControlPoints[index].Position;
                 InputManager.MoveMouseTo(drawableObject.Parent.ToScreenSpace(position));
             });
         }
 
-        private void assertControlPointType(int index, PathType type) => AddAssert($"control point {index} is {type}", () => slider.Path.ControlPoints[index].Type.Value == type);
+        private void assertControlPointType(int index, PathType type) => AddAssert($"control point {index} is {type}", () => slider.Path.ControlPoints[index].Type == type);
 
         private void assertControlPointPosition(int index, Vector2 position) =>
-            AddAssert($"control point {index} at {position}", () => Precision.AlmostEquals(position, slider.Path.ControlPoints[index].Position.Value, 1));
+            AddAssert($"control point {index} at {position}", () => Precision.AlmostEquals(position, slider.Path.ControlPoints[index].Position, 1));
 
         private class TestSliderBlueprint : SliderSelectionBlueprint
         {

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderPlacementBlueprint.cs

@@ -385,10 +385,10 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
 
         private void assertControlPointCount(int expected) => AddAssert($"has {expected} control points", () => getSlider().Path.ControlPoints.Count == expected);
 
-        private void assertControlPointType(int index, PathType type) => AddAssert($"control point {index} is {type}", () => getSlider().Path.ControlPoints[index].Type.Value == type);
+        private void assertControlPointType(int index, PathType type) => AddAssert($"control point {index} is {type}", () => getSlider().Path.ControlPoints[index].Type == type);
 
         private void assertControlPointPosition(int index, Vector2 position) =>
-            AddAssert($"control point {index} at {position}", () => Precision.AlmostEquals(position, getSlider().Path.ControlPoints[index].Position.Value, 1));
+            AddAssert($"control point {index} at {position}", () => Precision.AlmostEquals(position, getSlider().Path.ControlPoints[index].Position, 1));
 
         private Slider getSlider() => HitObjectContainer.Count > 0 ? ((DrawableSlider)HitObjectContainer[0]).HitObject : null;
 

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderSelectionBlueprint.cs

@@ -184,7 +184,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
         {
             AddStep($"move mouse to control point {index}", () =>
             {
-                Vector2 position = slider.Position + slider.Path.ControlPoints[index].Position.Value;
+                Vector2 position = slider.Position + slider.Path.ControlPoints[index].Position;
                 InputManager.MoveMouseTo(drawableObject.Parent.ToScreenSpace(position));
             });
         }

osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModMuted.cs

@@ -0,0 +1,52 @@
+// 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.Testing;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
+
+namespace osu.Game.Rulesets.Osu.Tests.Mods
+{
+    public class TestSceneOsuModMuted : OsuModTestScene
+    {
+        /// <summary>
+        /// Ensures that a final volume combo of 0 (i.e. "always muted" mode) constantly plays metronome and completely mutes track.
+        /// </summary>
+        [Test]
+        public void TestZeroFinalCombo() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModMuted
+            {
+                MuteComboCount = { Value = 0 },
+            },
+            PassCondition = () => Beatmap.Value.Track.AggregateVolume.Value == 0.0 &&
+                                  Player.ChildrenOfType<Metronome>().SingleOrDefault()?.AggregateVolume.Value == 1.0,
+        });
+
+        /// <summary>
+        /// Ensures that copying from a normal mod with 0 final combo while originally inversed does not yield incorrect results.
+        /// </summary>
+        [Test]
+        public void TestModCopy()
+        {
+            OsuModMuted muted = null;
+
+            AddStep("create inversed mod", () => muted = new OsuModMuted
+            {
+                MuteComboCount = { Value = 100 },
+                InverseMuting = { Value = true },
+            });
+
+            AddStep("copy from normal", () => muted.CopyFrom(new OsuModMuted
+            {
+                MuteComboCount = { Value = 0 },
+                InverseMuting = { Value = false },
+            }));
+
+            AddAssert("mute combo count = 0", () => muted.MuteComboCount.Value == 0);
+            AddAssert("inverse muting = false", () => muted.InverseMuting.Value == false);
+        }
+    }
+}

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

@@ -15,13 +15,13 @@ namespace osu.Game.Rulesets.Osu.Tests
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Osu";
 
-        [TestCase(6.7568168283591499d, "diffcalc-test")]
-        [TestCase(1.0348244046058293d, "zero-length-sliders")]
+        [TestCase(6.6634445062299665d, "diffcalc-test")]
+        [TestCase(1.0414203870195022d, "zero-length-sliders")]
         public void Test(double expected, string name)
             => base.Test(expected, name);
 
-        [TestCase(8.4783236764532557d, "diffcalc-test")]
-        [TestCase(1.2708532136987165d, "zero-length-sliders")]
+        [TestCase(8.3858089051603368d, "diffcalc-test")]
+        [TestCase(1.2723279173428435d, "zero-length-sliders")]
         public void TestClockRateAdjusted(double expected, string name)
             => Test(expected, name, new OsuModDoubleTime());
 

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

@@ -0,0 +1,175 @@
+// 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.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Beatmaps.Timing;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Skinning.Legacy;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Skinning;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestSceneCursorParticles : TestSceneOsuPlayer
+    {
+        protected override bool Autoplay => autoplay;
+        protected override bool HasCustomSteps => true;
+
+        private bool autoplay;
+        private IBeatmap currentBeatmap;
+
+        [Resolved]
+        private SkinManager skinManager { get; set; }
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => currentBeatmap ?? base.CreateBeatmap(ruleset);
+
+        [Test]
+        public void TestLegacyBreakParticles()
+        {
+            LegacyCursorParticles cursorParticles = null;
+
+            createLegacyTest(false, () => new Beatmap
+            {
+                Breaks =
+                {
+                    new BreakPeriod(8500, 10000),
+                },
+                HitObjects =
+                {
+                    new HitCircle
+                    {
+                        StartTime = 8000,
+                        Position = OsuPlayfield.BASE_SIZE / 2,
+                    },
+                    new HitCircle
+                    {
+                        StartTime = 11000,
+                        Position = OsuPlayfield.BASE_SIZE / 2,
+                    },
+                }
+            });
+
+            AddUntilStep("fetch cursor particles", () =>
+            {
+                cursorParticles = this.ChildrenOfType<LegacyCursorParticles>().SingleOrDefault();
+                return cursorParticles != null;
+            });
+
+            AddStep("move mouse to centre", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.Centre));
+
+            AddAssert("particles are being spawned", () => cursorParticles.Active);
+
+            AddStep("press left mouse button", () => InputManager.PressButton(MouseButton.Left));
+            AddWaitStep("wait a bit", 5);
+            AddStep("press right mouse button", () => InputManager.PressButton(MouseButton.Right));
+            AddWaitStep("wait a bit", 5);
+            AddStep("release left mouse button", () => InputManager.ReleaseButton(MouseButton.Left));
+            AddWaitStep("wait a bit", 5);
+            AddStep("release right mouse button", () => InputManager.ReleaseButton(MouseButton.Right));
+
+            AddUntilStep("wait for beatmap start", () => !Player.IsBreakTime.Value);
+            AddAssert("particle spawning stopped", () => !cursorParticles.Active);
+
+            AddUntilStep("wait for break", () => Player.IsBreakTime.Value);
+            AddAssert("particles are being spawned", () => cursorParticles.Active);
+
+            AddUntilStep("wait for break end", () => !Player.IsBreakTime.Value);
+            AddAssert("particle spawning stopped", () => !cursorParticles.Active);
+        }
+
+        [Test]
+        public void TestLegacyKiaiParticles()
+        {
+            LegacyCursorParticles cursorParticles = null;
+            DrawableSpinner spinner = null;
+            DrawableSlider slider = null;
+
+            createLegacyTest(true, () =>
+                {
+                    var controlPointInfo = new ControlPointInfo();
+                    controlPointInfo.Add(0, new EffectControlPoint { KiaiMode = true });
+                    controlPointInfo.Add(5000, new EffectControlPoint { KiaiMode = false });
+
+                    return new Beatmap
+                    {
+                        ControlPointInfo = controlPointInfo,
+                        HitObjects =
+                        {
+                            new Spinner
+                            {
+                                StartTime = 0,
+                                Duration = 1000,
+                                Position = OsuPlayfield.BASE_SIZE / 2,
+                            },
+                            new Slider
+                            {
+                                StartTime = 2500,
+                                RepeatCount = 0,
+                                Position = OsuPlayfield.BASE_SIZE / 2,
+                                Path = new SliderPath(new[]
+                                {
+                                    new PathControlPoint(Vector2.Zero),
+                                    new PathControlPoint(new Vector2(100, 0)),
+                                })
+                            },
+                            new HitCircle
+                            {
+                                StartTime = 4500,
+                                Position = OsuPlayfield.BASE_SIZE / 2,
+                            },
+                        },
+                    };
+                }
+            );
+
+            AddUntilStep("fetch cursor particles", () =>
+            {
+                cursorParticles = this.ChildrenOfType<LegacyCursorParticles>().SingleOrDefault();
+                return cursorParticles != null;
+            });
+
+            AddUntilStep("wait for spinner tracking", () =>
+            {
+                spinner = this.ChildrenOfType<DrawableSpinner>().SingleOrDefault();
+                return spinner?.RotationTracker.Tracking == true;
+            });
+            AddAssert("particles are being spawned", () => cursorParticles.Active);
+
+            AddUntilStep("spinner tracking stopped", () => !spinner.RotationTracker.Tracking);
+            AddAssert("particle spawning stopped", () => !cursorParticles.Active);
+
+            AddUntilStep("wait for slider tracking", () =>
+            {
+                slider = this.ChildrenOfType<DrawableSlider>().SingleOrDefault();
+                return slider?.Tracking.Value == true;
+            });
+            AddAssert("particles are being spawned", () => cursorParticles.Active);
+
+            AddUntilStep("slider tracking stopped", () => !slider.Tracking.Value);
+            AddAssert("particle spawning stopped", () => !cursorParticles.Active);
+        }
+
+        private void createLegacyTest(bool autoplay, Func<IBeatmap> beatmap) => CreateTest(() =>
+        {
+            AddStep("set beatmap", () =>
+            {
+                this.autoplay = autoplay;
+                currentBeatmap = beatmap();
+            });
+            AddStep("setup default legacy skin", () =>
+            {
+                skinManager.CurrentSkinInfo.Value = skinManager.DefaultLegacySkin.SkinInfo;
+            });
+        });
+    }
+}

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

@@ -12,6 +12,7 @@ using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Input;
+using osu.Framework.Input.Events;
 using osu.Framework.Testing.Input;
 using osu.Framework.Utils;
 using osu.Game.Audio;
@@ -143,9 +144,9 @@ namespace osu.Game.Rulesets.Osu.Tests
 
                     pressed = value;
                     if (value)
-                        OnPressed(OsuAction.LeftButton);
+                        OnPressed(new KeyBindingPressEvent<OsuAction>(GetContainingInputManager().CurrentState, OsuAction.LeftButton));
                     else
-                        OnReleased(OsuAction.LeftButton);
+                        OnReleased(new KeyBindingReleaseEvent<OsuAction>(GetContainingInputManager().CurrentState, OsuAction.LeftButton));
                 }
             }
 

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

@@ -4,6 +4,7 @@
 using System;
 using NUnit.Framework;
 using osu.Framework.Graphics;
+using osu.Framework.Input.Events;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Osu.Objects;
@@ -97,7 +98,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         private void scheduleHit() => AddStep("schedule action", () =>
         {
             var delay = hitCircle.StartTime - hitCircle.HitWindows.WindowFor(HitResult.Great) - Time.Current;
-            Scheduler.AddDelayed(() => hitAreaReceptor.OnPressed(OsuAction.LeftButton), delay);
+            Scheduler.AddDelayed(() => hitAreaReceptor.OnPressed(new KeyBindingPressEvent<OsuAction>(GetContainingInputManager().CurrentState, OsuAction.LeftButton)), delay);
         });
     }
 }

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

@@ -20,6 +20,7 @@ using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Skinning.Default;
 using osu.Game.Skinning;
 using osu.Game.Storyboards;
 using osu.Game.Tests.Visual;
@@ -86,9 +87,9 @@ namespace osu.Game.Rulesets.Osu.Tests
                 if (firstObject == null)
                     return false;
 
-                var skinnable = firstObject.ApproachCircle.Child as SkinnableDrawable;
+                var skinnable = firstObject.ApproachCircle;
 
-                if (skin == null && skinnable?.Drawable is Sprite)
+                if (skin == null && skinnable?.Drawable is DefaultApproachCircle)
                     // check for default skin provider
                     return true;