Merge pull request #33418 from minetoblend/feature/ssv2-animated-ghost

SongSelectV2: Animate placeholder ghost

.config/dotnet-tools.json

@@ -9,7 +9,7 @@
       ]
     },
     "nvika": {
-      "version": "3.0.0",
+      "version": "4.0.0",
       "commands": [
         "nvika"
       ]

.github/workflows/_diffcalc_processor.yml

@@ -36,7 +36,7 @@ jobs:
   generator:
     name: Run
     runs-on: self-hosted
-    timeout-minutes: 720
+    timeout-minutes: 1440
 
     outputs:
       target: ${{ steps.run.outputs.target }}

.github/workflows/ci.yml

@@ -82,8 +82,18 @@ jobs:
         run: dotnet build -c Debug -warnaserror osu.Desktop.slnf
 
       - name: Test
-        run: dotnet test $pwd/**/*.Tests/bin/Debug/*/*.Tests.dll --logger "trx;LogFileName=TestResults-${{matrix.os.prettyname}}-${{matrix.threadingMode}}.trx" -- NUnit.ConsoleOut=0
-        shell: pwsh
+        run: >
+          dotnet test
+          osu.Game.Tests/bin/Debug/**/osu.Game.Tests.dll
+          osu.Game.Rulesets.Osu.Tests/bin/Debug/**/osu.Game.Rulesets.Osu.Tests.dll
+          osu.Game.Rulesets.Taiko.Tests/bin/Debug/**/osu.Game.Rulesets.Taiko.Tests.dll
+          osu.Game.Rulesets.Catch.Tests/bin/Debug/**/osu.Game.Rulesets.Catch.Tests.dll
+          osu.Game.Rulesets.Mania.Tests/bin/Debug/**/osu.Game.Rulesets.Mania.Tests.dll
+          osu.Game.Tournament.Tests/bin/Debug/**/osu.Game.Tournament.Tests.dll
+          Templates/**/*.Tests/bin/Debug/**/*.Tests.dll
+          --logger "trx;LogFileName=TestResults-${{matrix.os.prettyname}}-${{matrix.threadingMode}}.trx"
+          --
+          NUnit.ConsoleOut=0
 
       # Attempt to upload results even if test fails.
       # https://docs.github.com/en/actions/reference/context-and-expression-syntax-for-github-actions#always
@@ -114,10 +124,7 @@ jobs:
           dotnet-version: "8.0.x"
 
       - name: Install .NET workloads
-        # since windows image 20241113.3.0, not specifying a version here
-        # installs the .NET 7 version of android workload for very unknown reasons.
-        # revisit once we upgrade to .NET 9, it's probably fixed there.
-        run: dotnet workload install android --version (dotnet --version)
+        run: dotnet workload install android
 
       - name: Compile
         run: dotnet build -c Debug osu.Android.slnf
@@ -139,4 +146,4 @@ jobs:
         run: dotnet workload install ios --from-rollback-file https://raw.githubusercontent.com/ppy/osu-framework/refs/heads/master/workloads.json
 
       - name: Build
-        run: dotnet build -c Debug osu.iOS
+        run: dotnet build -c Debug osu.iOS.slnf

.github/workflows/deploy.yml

@@ -0,0 +1,87 @@
+name: Pack and nuget
+
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  notify_pending_production_deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Submit pending deployment notification
+        run: |
+          export TITLE="Pending osu Production Deployment: $GITHUB_REF_NAME"
+          export URL="https://github.com/ppy/osu/actions/runs/$GITHUB_RUN_ID"
+          export DESCRIPTION="Awaiting approval for building NuGet packages for tag $GITHUB_REF_NAME:
+          [View Workflow Run]($URL)"
+          export ACTOR_ICON="https://avatars.githubusercontent.com/u/$GITHUB_ACTOR_ID"
+
+          BODY="$(jq --null-input '{
+            "embeds": [
+              {
+                "title": env.TITLE,
+                "color": 15098112,
+                "description": env.DESCRIPTION,
+                "url": env.URL,
+                "author": {
+                  "name": env.GITHUB_ACTOR,
+                  "icon_url": env.ACTOR_ICON
+                }
+              }
+            ]
+          }')"
+
+          curl \
+            -H "Content-Type: application/json" \
+            -d "$BODY" \
+            "${{ secrets.DISCORD_INFRA_WEBHOOK_URL }}"
+
+  pack:
+    name: Pack
+    runs-on: ubuntu-latest
+    environment: production
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set artifacts directory
+        id: artifactsPath
+        run: echo "::set-output name=nuget_artifacts::${{github.workspace}}/artifacts"
+
+      - name: Install .NET 8.0.x
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: "8.0.x"
+
+      - name: Pack
+        run: |
+          # Replace project references in templates with package reference, because they're included as source files.
+          dotnet remove Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform/osu.Game.Rulesets.EmptyFreeform.csproj reference osu.Game/osu.Game.csproj
+          dotnet remove Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon/osu.Game.Rulesets.Pippidon.csproj reference osu.Game/osu.Game.csproj
+          dotnet remove Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling/osu.Game.Rulesets.EmptyScrolling.csproj reference osu.Game/osu.Game.csproj
+          dotnet remove Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/osu.Game.Rulesets.Pippidon.csproj reference osu.Game/osu.Game.csproj
+
+          dotnet add Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform/osu.Game.Rulesets.EmptyFreeform.csproj package ppy.osu.Game -n -v ${{ github.ref_name }}
+          dotnet add Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon/osu.Game.Rulesets.Pippidon.csproj package ppy.osu.Game -n -v ${{ github.ref_name }}
+          dotnet add Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling/osu.Game.Rulesets.EmptyScrolling.csproj package ppy.osu.Game -n -v ${{ github.ref_name }}
+          dotnet add Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/osu.Game.Rulesets.Pippidon.csproj package ppy.osu.Game -n -v ${{ github.ref_name }}
+
+          # Pack
+          dotnet pack -c Release osu.Game /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release osu.Game.Rulesets.Osu /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release osu.Game.Rulesets.Taiko /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release osu.Game.Rulesets.Catch /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release osu.Game.Rulesets.Mania /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release Templates /p:Version=${{ github.ref_name }} -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: osu
+          path: |
+            ${{steps.artifactsPath.outputs.nuget_artifacts}}/*.nupkg
+            ${{steps.artifactsPath.outputs.nuget_artifacts}}/*.snupkg
+
+      - name: Publish packages to nuget.org
+        run: dotnet nuget push ${{steps.artifactsPath.outputs.nuget_artifacts}}/*.nupkg --api-key ${{ secrets.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json

.github/workflows/diffcalc.yml

@@ -115,7 +115,7 @@ jobs:
     steps:
       - name: Check permissions
         run: |
-          ALLOWED_USERS=(smoogipoo peppy bdach frenzibyte)
+          ALLOWED_USERS=(smoogipoo peppy bdach frenzibyte tsunyoku stanriders)
           for i in "${ALLOWED_USERS[@]}"; do
               if [[ "${{ github.actor }}" == "$i" ]]; then
                   exit 0

.idea/.idea.osu.Android/.idea/deploymentTargetSelector.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="deploymentTargetSelector">
+    <selectionStates>
+      <SelectionState runConfigName="osu.Android">
+        <option name="selectionMode" value="DROPDOWN" />
+      </SelectionState>
+    </selectionStates>
+  </component>
+</project>

CodeAnalysis/BannedSymbols.txt

@@ -18,3 +18,10 @@ M:Humanizer.InflectorExtensions.Pascalize(System.String);Humanizer's .Pascalize(
 M:Humanizer.InflectorExtensions.Camelize(System.String);Humanizer's .Camelize() extension method changes behaviour depending on CultureInfo.CurrentCulture. Use StringDehumanizeExtensions.ToCamelCase() instead.
 M:Humanizer.InflectorExtensions.Underscore(System.String);Humanizer's .Underscore() extension method changes behaviour depending on CultureInfo.CurrentCulture. Use StringDehumanizeExtensions.ToSnakeCase() instead.
 M:Humanizer.InflectorExtensions.Kebaberize(System.String);Humanizer's .Kebaberize() extension method changes behaviour depending on CultureInfo.CurrentCulture. Use StringDehumanizeExtensions.ToKebabCase() instead.
+M:osuTK.MathHelper.Clamp(System.Int32,System.Int32,System.Int32)~System.Int32;Use Math.Clamp() instead.
+M:osuTK.MathHelper.Clamp(System.Single,System.Single,System.Single)~System.Single;This osuTK helper has unsafe semantics when one of the bounds provided is NaN. Use Math.Clamp() instead.
+M:osuTK.MathHelper.Clamp(System.Double,System.Double,System.Double)~System.Double;This osuTK helper has unsafe semantics when one of the bounds provided is NaN. Use Math.Clamp() instead.
+M:TagLib.File.Create(System.String);TagLib's MIME type detection changes behaviour depending on CultureInfo.CurrentCulture. Use TagLibUtils.GetTagLibFile() instead.
+M:TagLib.File.Create(TagLib.File.IFileAbstraction);TagLib's MIME type detection changes behaviour depending on CultureInfo.CurrentCulture. Use TagLibUtils.GetTagLibFile() instead.
+M:TagLib.File.Create(System.String,TagLib.ReadStyle);TagLib's MIME type detection changes behaviour depending on CultureInfo.CurrentCulture. Use TagLibUtils.GetTagLibFile() instead.
+M:TagLib.File.Create(TagLib.File.IFileAbstraction,TagLib.ReadStyle);TagLib's MIME type detection changes behaviour depending on CultureInfo.CurrentCulture. Use TagLibUtils.GetTagLibFile() instead.

CodeAnalysis/osu.globalconfig

@@ -51,8 +51,11 @@ dotnet_diagnostic.IDE1006.severity = warning
 # Too many noisy warnings for parsing/formatting numbers
 dotnet_diagnostic.CA1305.severity = none
 
+# messagepack complains about "osu" not being title cased due to reserved words
+dotnet_diagnostic.CS8981.severity = none
+
 # CA1507: Use nameof to express symbol names
-# Flaggs serialization name attributes
+# Flags serialization name attributes
 dotnet_diagnostic.CA1507.severity = suggestion
 
 # CA1806: Do not ignore method results

Directory.Build.props

@@ -3,6 +3,10 @@
   <PropertyGroup Label="C#">
     <LangVersion>12.0</LangVersion>
     <Nullable>enable</Nullable>
+    <!-- Stabilises hot reload, see: https://platform.uno/docs/articles/studio/Hot%20Reload/hot-reload-overview.html?tabs=vswin%2Cwindows%2Cskia-desktop%2Ccommon-issues -->
+    <GenerateAssemblyInfo Condition="'$(Configuration)'=='Debug'">false</GenerateAssemblyInfo>
+    <!-- Required due to the above  -->
+    <NoWarn Condition="'$(Configuration)'=='Debug'">$(NoWarn);CA1416</NoWarn>
   </PropertyGroup>
   <PropertyGroup>
     <ApplicationManifest>$(MSBuildThisFileDirectory)app.manifest</ApplicationManifest>

README.md

@@ -37,7 +37,7 @@ You can also generally download a version for your current device from the [osu!
 
 If your platform is unsupported or not listed above, there is still a chance you can run the release or manually build it by following the instructions below.
 
-**For iOS/iPadOS users**: The iOS testflight link fills up very fast (Apple has a hard limit of 10,000 users). We reset it occasionally. Please do not ask about this. Check back regularly for link resets or follow [peppy](https://twitter.com/ppy) on twitter for announcements. Our goal is to get the game on mobile app stores in early 2024.
+**For iOS/iPadOS users**: The iOS testflight link fills up very fast (Apple has a hard limit of 10,000 users). We reset it occasionally. Please do not ask about this. Check back regularly for link resets or follow [peppy](https://twitter.com/ppy) on twitter for announcements. Our goal is to get the game on mobile app stores very soon so we don't have to live with this limitation.
 
 ## Developing a custom ruleset
 

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

@@ -9,9 +9,9 @@
       <GenerateProgramFile>false</GenerateProgramFile>
     </PropertyGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\osu.Game.Rulesets.EmptyFreeform\osu.Game.Rulesets.EmptyFreeform.csproj" />

Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform/Objects/EmptyFreeformHitObject.cs

@@ -14,7 +14,16 @@ namespace osu.Game.Rulesets.EmptyFreeform.Objects
 
         public Vector2 Position { get; set; }
 
-        public float X => Position.X;
-        public float Y => Position.Y;
+        public float X
+        {
+            get => Position.X;
+            set => Position = new Vector2(value, Y);
+        }
+
+        public float Y
+        {
+            get => Position.Y;
+            set => Position = new Vector2(X, value);
+        }
     }
 }

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

@@ -9,9 +9,9 @@
     <GenerateProgramFile>false</GenerateProgramFile>
   </PropertyGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj" />

Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon/Objects/PippidonHitObject.cs

@@ -14,7 +14,16 @@ namespace osu.Game.Rulesets.Pippidon.Objects
 
         public Vector2 Position { get; set; }
 
-        public float X => Position.X;
-        public float Y => Position.Y;
+        public float X
+        {
+            get => Position.X;
+            set => Position = new Vector2(value, Y);
+        }
+
+        public float Y
+        {
+            get => Position.Y;
+            set => Position = new Vector2(X, value);
+        }
     }
 }

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

@@ -9,9 +9,9 @@
     <GenerateProgramFile>false</GenerateProgramFile>
   </PropertyGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\osu.Game.Rulesets.EmptyScrolling\osu.Game.Rulesets.EmptyScrolling.csproj" />

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

@@ -9,9 +9,9 @@
     <GenerateProgramFile>false</GenerateProgramFile>
   </PropertyGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj" />

Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/Beatmaps/PippidonBeatmapConverter.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
@@ -9,7 +10,6 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Pippidon.Objects;
 using osu.Game.Rulesets.Pippidon.UI;
-using osuTK;
 
 namespace osu.Game.Rulesets.Pippidon.Beatmaps
 {
@@ -40,7 +40,7 @@ namespace osu.Game.Rulesets.Pippidon.Beatmaps
             };
         }
 
-        private int getLane(HitObject hitObject) => (int)MathHelper.Clamp(
+        private int getLane(HitObject hitObject) => (int)Math.Clamp(
             (getUsablePosition(hitObject) - minPosition) / (maxPosition - minPosition) * PippidonPlayfield.LANE_COUNT, 0, PippidonPlayfield.LANE_COUNT - 1);
 
         private float getUsablePosition(HitObject h) => (h as IHasYPosition)?.Y ?? ((IHasXPosition)h).X;

appveyor.yml

@@ -1,32 +0,0 @@
-clone_depth: 1
-version: '{branch}-{build}'
-image: Visual Studio 2022
-cache:
-  - '%LOCALAPPDATA%\NuGet\v3-cache -> appveyor.yml'
-
-dotnet_csproj:
-  patch: true
-  file: 'osu.Game\osu.Game.csproj' # Use wildcard when it's able to exclude Xamarin projects
-  version: '0.0.{build}'
-
-before_build:
-  - cmd: dotnet --info # Useful when version mismatch between CI and local
-  - cmd: dotnet workload install maui-android # Change to `dotnet workload restore` once there's no old projects
-  - cmd: dotnet workload install maui-ios # Change to `dotnet workload restore` once there's no old projects
-  - cmd: nuget restore -verbosity quiet # Only nuget.exe knows both new (.NET Core) and old (Xamarin) projects
-
-build:
-  project: osu.sln
-  parallel: true
-  verbosity: minimal
-  publish_nuget: true
-
-after_build:
-  - ps: .\InspectCode.ps1
-
-test:
-  assemblies:
-    except:
-      - '**\*Android*'
-      - '**\*iOS*'
-      - 'build\**\*'

appveyor_deploy.yml

@@ -1,86 +0,0 @@
-clone_depth: 1
-version: '{build}'
-image: Visual Studio 2022
-test: off
-skip_non_tags: true
-configuration: Release
-
-environment:
-  matrix:
-    - job_name: osu-game
-    - job_name: osu-ruleset
-      job_depends_on: osu-game
-    - job_name: taiko-ruleset
-      job_depends_on: osu-game
-    - job_name: catch-ruleset
-      job_depends_on: osu-game
-    - job_name: mania-ruleset
-      job_depends_on: osu-game
-    - job_name: templates
-      job_depends_on: osu-game
-
-nuget:
-  project_feed: true
-
-for:
-  -
-    matrix:
-      only:
-        - job_name: osu-game
-    build_script:
-      - cmd: dotnet pack osu.Game\osu.Game.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: osu-ruleset
-    build_script:
-      - cmd: dotnet remove osu.Game.Rulesets.Osu\osu.Game.Rulesets.Osu.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet add osu.Game.Rulesets.Osu\osu.Game.Rulesets.Osu.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet pack osu.Game.Rulesets.Osu\osu.Game.Rulesets.Osu.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: taiko-ruleset
-    build_script:
-      - cmd: dotnet remove osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet add osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet pack osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: catch-ruleset
-    build_script:
-      - cmd: dotnet remove osu.Game.Rulesets.Catch\osu.Game.Rulesets.Catch.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet add osu.Game.Rulesets.Catch\osu.Game.Rulesets.Catch.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet pack osu.Game.Rulesets.Catch\osu.Game.Rulesets.Catch.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: mania-ruleset
-    build_script:
-      - cmd: dotnet remove osu.Game.Rulesets.Mania\osu.Game.Rulesets.Mania.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet add osu.Game.Rulesets.Mania\osu.Game.Rulesets.Mania.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet pack osu.Game.Rulesets.Mania\osu.Game.Rulesets.Mania.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: templates
-    build_script:
-      - cmd: dotnet remove Templates\Rulesets\ruleset-empty\osu.Game.Rulesets.EmptyFreeform\osu.Game.Rulesets.EmptyFreeform.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet remove Templates\Rulesets\ruleset-example\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet remove Templates\Rulesets\ruleset-scrolling-empty\osu.Game.Rulesets.EmptyScrolling\osu.Game.Rulesets.EmptyScrolling.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet remove Templates\Rulesets\ruleset-scrolling-example\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj reference osu.Game\osu.Game.csproj
-
-      - cmd: dotnet add Templates\Rulesets\ruleset-empty\osu.Game.Rulesets.EmptyFreeform\osu.Game.Rulesets.EmptyFreeform.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet add Templates\Rulesets\ruleset-example\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet add Templates\Rulesets\ruleset-scrolling-empty\osu.Game.Rulesets.EmptyScrolling\osu.Game.Rulesets.EmptyScrolling.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet add Templates\Rulesets\ruleset-scrolling-example\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-
-      - cmd: dotnet pack Templates\osu.Game.Templates.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-
-artifacts:
-  - path: '**\*.nupkg'
-
-deploy:
-  - provider: Environment
-    name: nuget

osu.Android.props

@@ -10,7 +10,7 @@
     <EmbedAssembliesIntoApk>true</EmbedAssembliesIntoApk>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2024.1206.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2025.604.1" />
   </ItemGroup>
   <PropertyGroup>
     <!-- Fody does not handle Android build well, and warns when unchanged.

osu.Android/GameplayScreenRotationLocker.cs

@@ -1,34 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using Android.Content.PM;
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Game.Screens.Play;
-
-namespace osu.Android
-{
-    public partial class GameplayScreenRotationLocker : Component
-    {
-        private IBindable<LocalUserPlayingState> localUserPlaying = null!;
-
-        [Resolved]
-        private OsuGameActivity gameActivity { get; set; } = null!;
-
-        [BackgroundDependencyLoader]
-        private void load(ILocalUserPlayInfo localUserPlayInfo)
-        {
-            localUserPlaying = localUserPlayInfo.PlayingState.GetBoundCopy();
-            localUserPlaying.BindValueChanged(updateLock, true);
-        }
-
-        private void updateLock(ValueChangedEvent<LocalUserPlayingState> userPlaying)
-        {
-            gameActivity.RunOnUiThread(() =>
-            {
-                gameActivity.RequestedOrientation = userPlaying.NewValue == LocalUserPlayingState.Playing ? ScreenOrientation.Locked : gameActivity.DefaultOrientation;
-            });
-        }
-    }
-}

osu.Android/OsuGameActivity.cs

@@ -13,7 +13,6 @@ using Android.Graphics;
 using Android.OS;
 using Android.Views;
 using osu.Framework.Android;
-using osu.Framework.Extensions.ObjectExtensions;
 using osu.Game.Database;
 using Debug = System.Diagnostics.Debug;
 using Uri = Android.Net.Uri;
@@ -50,9 +49,25 @@ namespace osu.Android
         /// <remarks>Adjusted on startup to match expected UX for the current device type (phone/tablet).</remarks>
         public ScreenOrientation DefaultOrientation = ScreenOrientation.Unspecified;
 
-        private OsuGameAndroid game = null!;
+        public new bool IsTablet { get; private set; }
 
-        protected override Framework.Game CreateGame() => game = new OsuGameAndroid(this);
+        private readonly OsuGameAndroid game;
+
+        private bool gameCreated;
+
+        protected override Framework.Game CreateGame()
+        {
+            if (gameCreated)
+                throw new InvalidOperationException("Framework tried to create a game twice.");
+
+            gameCreated = true;
+            return game;
+        }
+
+        public OsuGameActivity()
+        {
+            game = new OsuGameAndroid(this);
+        }
 
         protected override void OnCreate(Bundle? savedInstanceState)
         {
@@ -76,9 +91,9 @@ namespace osu.Android
             WindowManager.DefaultDisplay.GetSize(displaySize);
 #pragma warning restore CA1422
             float smallestWidthDp = Math.Min(displaySize.X, displaySize.Y) / Resources.DisplayMetrics.Density;
-            bool isTablet = smallestWidthDp >= 600f;
+            IsTablet = smallestWidthDp >= 600f;
 
-            RequestedOrientation = DefaultOrientation = isTablet ? ScreenOrientation.FullUser : ScreenOrientation.SensorLandscape;
+            RequestedOrientation = DefaultOrientation = IsTablet ? ScreenOrientation.FullUser : ScreenOrientation.SensorLandscape;
 
             // Currently (SDK 6.0.200), BundleAssemblies is not runnable for net6-android.
             // The assembly files are not available as files either after native AOT.
@@ -95,25 +110,38 @@ namespace osu.Android
 
         private void handleIntent(Intent? intent)
         {
-            switch (intent?.Action)
+            if (intent == null)
+                return;
+
+            switch (intent.Action)
             {
                 case Intent.ActionDefault:
                     if (intent.Scheme == ContentResolver.SchemeContent)
-                        handleImportFromUris(intent.Data.AsNonNull());
+                    {
+                        if (intent.Data != null)
+                            handleImportFromUris(intent.Data);
+                    }
                     else if (osu_url_schemes.Contains(intent.Scheme))
-                        game.HandleLink(intent.DataString);
+                    {
+                        if (intent.DataString != null)
+                            game.HandleLink(intent.DataString);
+                    }
+
                     break;
 
                 case Intent.ActionSend:
                 case Intent.ActionSendMultiple:
                 {
+                    if (intent.ClipData == null)
+                        break;
+
                     var uris = new List<Uri>();
 
-                    for (int i = 0; i < intent.ClipData?.ItemCount; i++)
+                    for (int i = 0; i < intent.ClipData.ItemCount; i++)
                     {
-                        var content = intent.ClipData?.GetItemAt(i);
-                        if (content != null)
-                            uris.Add(content.Uri.AsNonNull());
+                        var item = intent.ClipData.GetItemAt(i);
+                        if (item?.Uri != null)
+                            uris.Add(item.Uri);
                     }
 
                     handleImportFromUris(uris.ToArray());

osu.Android/OsuGameAndroid.cs

@@ -3,13 +3,16 @@
 
 using System;
 using Android.App;
+using Android.Content.PM;
 using Microsoft.Maui.Devices;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Platform;
 using osu.Game;
+using osu.Game.Screens;
 using osu.Game.Updater;
 using osu.Game.Utils;
+using osuTK;
 
 namespace osu.Android
 {
@@ -18,6 +21,8 @@ namespace osu.Android
         [Cached]
         private readonly OsuGameActivity gameActivity;
 
+        public override Vector2 ScalingContainerTargetDrawSize => new Vector2(1024, 1024 * DrawHeight / DrawWidth);
+
         public OsuGameAndroid(OsuGameActivity activity)
             : base(null)
         {
@@ -71,7 +76,35 @@ namespace osu.Android
         protected override void LoadComplete()
         {
             base.LoadComplete();
-            LoadComponentAsync(new GameplayScreenRotationLocker(), Add);
+            UserPlayingState.BindValueChanged(_ => updateOrientation());
+        }
+
+        protected override void ScreenChanged(IOsuScreen? current, IOsuScreen? newScreen)
+        {
+            base.ScreenChanged(current, newScreen);
+
+            if (newScreen != null)
+                updateOrientation();
+        }
+
+        private void updateOrientation()
+        {
+            var orientation = MobileUtils.GetOrientation(this, (IOsuScreen)ScreenStack.CurrentScreen, gameActivity.IsTablet);
+
+            switch (orientation)
+            {
+                case MobileUtils.Orientation.Locked:
+                    gameActivity.RequestedOrientation = ScreenOrientation.Locked;
+                    break;
+
+                case MobileUtils.Orientation.Portrait:
+                    gameActivity.RequestedOrientation = ScreenOrientation.Portrait;
+                    break;
+
+                case MobileUtils.Orientation.Default:
+                    gameActivity.RequestedOrientation = gameActivity.DefaultOrientation;
+                    break;
+            }
         }
 
         public override void SetHost(GameHost host)

osu.Desktop/DiscordRichPresence.cs

@@ -51,12 +51,9 @@ namespace osu.Desktop
         [Resolved]
         private LocalUserStatisticsProvider statisticsProvider { get; set; } = null!;
 
-        [Resolved]
-        private OsuConfigManager config { get; set; } = null!;
-
-        private readonly IBindable<UserStatus?> status = new Bindable<UserStatus?>();
-        private readonly IBindable<UserActivity> activity = new Bindable<UserActivity>();
-        private readonly Bindable<DiscordRichPresenceMode> privacyMode = new Bindable<DiscordRichPresenceMode>();
+        private IBindable<DiscordRichPresenceMode> privacyMode = null!;
+        private IBindable<UserStatus> userStatus = null!;
+        private IBindable<UserActivity?> userActivity = null!;
 
         private readonly RichPresence presence = new RichPresence
         {
@@ -71,8 +68,12 @@ namespace osu.Desktop
         private IBindable<APIUser>? user;
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(OsuConfigManager config, SessionStatics session)
         {
+            privacyMode = config.GetBindable<DiscordRichPresenceMode>(OsuSetting.DiscordRichPresence);
+            userStatus = config.GetBindable<UserStatus>(OsuSetting.UserOnlineStatus);
+            userActivity = session.GetBindable<UserActivity?>(Static.UserOnlineActivity);
+
             client = new DiscordRpcClient(client_id)
             {
                 // SkipIdenticalPresence allows us to fire SetPresence at any point and leave it to the underlying implementation
@@ -81,7 +82,7 @@ namespace osu.Desktop
             };
 
             client.OnReady += onReady;
-            client.OnError += (_, e) => Logger.Log($"An error occurred with Discord RPC Client: {e.Message} ({e.Code})", LoggingTarget.Network, LogLevel.Error);
+            client.OnError += (_, e) => Logger.Log($"An error occurred with Discord RPC Client: {e.Message} ({e.Code})", LoggingTarget.Network);
 
             try
             {
@@ -105,21 +106,11 @@ namespace osu.Desktop
         {
             base.LoadComplete();
 
-            config.BindWith(OsuSetting.DiscordRichPresence, privacyMode);
-
             user = api.LocalUser.GetBoundCopy();
-            user.BindValueChanged(u =>
-            {
-                status.UnbindBindings();
-                status.BindTo(u.NewValue.Status);
-
-                activity.UnbindBindings();
-                activity.BindTo(u.NewValue.Activity);
-            }, true);
 
             ruleset.BindValueChanged(_ => schedulePresenceUpdate());
-            status.BindValueChanged(_ => schedulePresenceUpdate());
-            activity.BindValueChanged(_ => schedulePresenceUpdate());
+            userStatus.BindValueChanged(_ => schedulePresenceUpdate());
+            userActivity.BindValueChanged(_ => schedulePresenceUpdate());
             privacyMode.BindValueChanged(_ => schedulePresenceUpdate());
 
             multiplayerClient.RoomUpdated += onRoomUpdated;
@@ -151,13 +142,13 @@ namespace osu.Desktop
                 if (!client.IsInitialized)
                     return;
 
-                if (status.Value == UserStatus.Offline || privacyMode.Value == DiscordRichPresenceMode.Off)
+                if (!api.IsLoggedIn || userStatus.Value == UserStatus.Offline || privacyMode.Value == DiscordRichPresenceMode.Off)
                 {
                     client.ClearPresence();
                     return;
                 }
 
-                bool hideIdentifiableInformation = privacyMode.Value == DiscordRichPresenceMode.Limited || status.Value == UserStatus.DoNotDisturb;
+                bool hideIdentifiableInformation = privacyMode.Value == DiscordRichPresenceMode.Limited || userStatus.Value == UserStatus.DoNotDisturb;
 
                 updatePresence(hideIdentifiableInformation);
                 client.SetPresence(presence);
@@ -170,19 +161,19 @@ namespace osu.Desktop
                 return;
 
             // user activity
-            if (activity.Value != null)
+            if (userActivity.Value != null)
             {
-                presence.State = clampLength(activity.Value.GetStatus(hideIdentifiableInformation));
-                presence.Details = clampLength(activity.Value.GetDetails(hideIdentifiableInformation) ?? string.Empty);
+                presence.State = clampLength(userActivity.Value.GetStatus(hideIdentifiableInformation));
+                presence.Details = clampLength(userActivity.Value.GetDetails(hideIdentifiableInformation) ?? string.Empty);
 
-                if (activity.Value.GetBeatmapID(hideIdentifiableInformation) is int beatmapId && beatmapId > 0)
+                if (userActivity.Value.GetBeatmapID(hideIdentifiableInformation) is int beatmapId && beatmapId > 0)
                 {
                     presence.Buttons = new[]
                     {
                         new Button
                         {
                             Label = "View beatmap",
-                            Url = $@"{api.WebsiteRootUrl}/beatmaps/{beatmapId}?mode={ruleset.Value.ShortName}"
+                            Url = $@"{api.Endpoints.WebsiteUrl}/beatmaps/{beatmapId}?mode={ruleset.Value.ShortName}"
                         }
                     };
                 }

osu.Desktop/OsuGameDesktop.cs

@@ -17,6 +17,7 @@ using osu.Framework.Logging;
 using osu.Game.Updater;
 using osu.Desktop.Windows;
 using osu.Framework.Allocation;
+using osu.Game.Configuration;
 using osu.Game.IO;
 using osu.Game.IPC;
 using osu.Game.Online.Multiplayer;
@@ -33,6 +34,8 @@ namespace osu.Desktop
         [Cached(typeof(IHighPerformanceSessionManager))]
         private readonly HighPerformanceSessionManager highPerformanceSessionManager = new HighPerformanceSessionManager();
 
+        public bool IsFirstRun { get; init; }
+
         public OsuGameDesktop(string[]? args = null)
             : base(args)
         {
@@ -67,7 +70,12 @@ namespace osu.Desktop
             {
                 try
                 {
-                    stableInstallPath = getStableInstallPathFromRegistry();
+                    stableInstallPath = getStableInstallPathFromRegistry("osustable.File.osz");
+
+                    if (!string.IsNullOrEmpty(stableInstallPath) && checkExists(stableInstallPath))
+                        return stableInstallPath;
+
+                    stableInstallPath = getStableInstallPathFromRegistry("osu!");
 
                     if (!string.IsNullOrEmpty(stableInstallPath) && checkExists(stableInstallPath))
                         return stableInstallPath;
@@ -89,9 +97,9 @@ namespace osu.Desktop
         }
 
         [SupportedOSPlatform("windows")]
-        private string? getStableInstallPathFromRegistry()
+        private string? getStableInstallPathFromRegistry(string progId)
         {
-            using (RegistryKey? key = Registry.ClassesRoot.OpenSubKey("osu!"))
+            using (RegistryKey? key = Registry.ClassesRoot.OpenSubKey(progId))
                 return key?.OpenSubKey(WindowsAssociationManager.SHELL_OPEN_COMMAND)?.GetValue(string.Empty)?.ToString()?.Split('"')[1].Replace("osu!.exe", "");
         }
 
@@ -99,6 +107,14 @@ namespace osu.Desktop
 
         protected override UpdateManager CreateUpdateManager()
         {
+            // If this is the first time we've run the game, ie it is being installed,
+            // reset the user's release stream to "lazer".
+            //
+            // This ensures that if a user is trying to recover from a failed startup on an unstable release stream,
+            // the game doesn't immediately try and update them back to the release stream after starting up.
+            if (IsFirstRun)
+                LocalConfig.SetValue(OsuSetting.ReleaseStream, ReleaseStream.Lazer);
+
             if (IsPackageManaged)
                 return new NoActionUpdateManager();
 
@@ -134,7 +150,6 @@ namespace osu.Desktop
             if (iconStream != null)
                 host.Window.SetIconFromStream(iconStream);
 
-            host.Window.CursorState |= CursorState.Hidden;
             host.Window.Title = Name;
         }
 

osu.Desktop/Program.cs

@@ -28,6 +28,8 @@ namespace osu.Desktop
 
         private static LegacyTcpIpcProvider? legacyIpc;
 
+        private static bool isFirstRun;
+
         [STAThread]
         public static void Main(string[] args)
         {
@@ -135,7 +137,12 @@ namespace osu.Desktop
                 if (tournamentClient)
                     host.Run(new TournamentGame());
                 else
-                    host.Run(new OsuGameDesktop(args));
+                {
+                    host.Run(new OsuGameDesktop(args)
+                    {
+                        IsFirstRun = isFirstRun
+                    });
+                }
             }
         }
 
@@ -177,6 +184,8 @@ namespace osu.Desktop
 
             var app = VelopackApp.Build();
 
+            app.WithFirstRun(_ => isFirstRun = true);
+
             if (OperatingSystem.IsWindows())
                 configureWindows(app);
 

osu.Desktop/Security/ElevatedPrivilegesChecker.cs

@@ -30,8 +30,6 @@ namespace osu.Desktop.Security
 
         private partial class ElevatedPrivilegesNotification : SimpleNotification
         {
-            public override bool IsImportant => true;
-
             public ElevatedPrivilegesNotification()
             {
                 Text = $"Running osu! as {(RuntimeInfo.IsUnix ? "root" : "administrator")} does not improve performance, may break integrations and poses a security risk. Please run the game as a normal user.";

osu.Desktop/Updater/VelopackUpdateManager.cs

@@ -4,8 +4,10 @@
 using System;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Logging;
 using osu.Game;
+using osu.Game.Configuration;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Screens.Play;
@@ -16,8 +18,8 @@ namespace osu.Desktop.Updater
 {
     public partial class VelopackUpdateManager : Game.Updater.UpdateManager
     {
-        private readonly UpdateManager updateManager;
-        private INotificationOverlay notificationOverlay = null!;
+        [Resolved]
+        private INotificationOverlay notificationOverlay { get; set; } = null!;
 
         [Resolved]
         private OsuGameBase game { get; set; } = null!;
@@ -25,22 +27,32 @@ namespace osu.Desktop.Updater
         [Resolved]
         private ILocalUserPlayInfo? localUserInfo { get; set; }
 
+        [Resolved]
+        private OsuConfigManager osuConfigManager { get; set; } = null!;
+
         private bool isInGameplay => localUserInfo?.PlayingState.Value != LocalUserPlayingState.NotPlaying;
 
+        private readonly Bindable<ReleaseStream> releaseStream = new Bindable<ReleaseStream>();
+        private UpdateManager? updateManager;
         private UpdateInfo? pendingUpdate;
 
-        public VelopackUpdateManager()
+        protected override void LoadComplete()
         {
-            updateManager = new UpdateManager(new GithubSource(@"https://github.com/ppy/osu", null, false), new UpdateOptions
+            // Used by the base implementation.
+            osuConfigManager.BindWith(OsuSetting.ReleaseStream, releaseStream);
+            releaseStream.BindValueChanged(_ => onReleaseStreamChanged(), true);
+
+            base.LoadComplete();
+        }
+
+        private void onReleaseStreamChanged()
+        {
+            updateManager = new UpdateManager(new GithubSource(@"https://github.com/ppy/osu", null, releaseStream.Value == ReleaseStream.Tachyon), new UpdateOptions
             {
                 AllowVersionDowngrade = true,
             });
-        }
 
-        [BackgroundDependencyLoader]
-        private void load(INotificationOverlay notifications)
-        {
-            notificationOverlay = notifications;
+            Schedule(() => Task.Run(CheckForUpdateAsync));
         }
 
         protected override async Task<bool> PerformUpdateCheck() => await checkForUpdateAsync().ConfigureAwait(false);
@@ -76,6 +88,12 @@ namespace osu.Desktop.Updater
                     return true;
                 }
 
+                if (updateManager == null)
+                {
+                    scheduleRecheck = true;
+                    return false;
+                }
+
                 pendingUpdate = await updateManager.CheckForUpdatesAsync().ConfigureAwait(false);
 
                 // No update is available. We'll check again later.
@@ -141,6 +159,9 @@ namespace osu.Desktop.Updater
 
         private async Task restartToApplyUpdate()
         {
+            if (updateManager == null)
+                return;
+
             await updateManager.WaitExitThenApplyUpdatesAsync(pendingUpdate?.TargetFullRelease).ConfigureAwait(false);
             Schedule(() => game.AttemptExit());
         }

osu.Desktop/Windows/WindowsAssociationManager.cs

@@ -17,6 +17,7 @@ namespace osu.Desktop.Windows
     public static class WindowsAssociationManager
     {
         private const string software_classes = @"Software\Classes";
+        private const string software_registered_applications = @"Software\RegisteredApplications";
 
         /// <summary>
         /// Sub key for setting the icon.
@@ -36,7 +37,11 @@ namespace osu.Desktop.Windows
         /// Program ID prefix used for file associations. Should be relatively short since the full program ID has a 39 character limit,
         /// see https://learn.microsoft.com/en-us/windows/win32/com/-progid--key.
         /// </summary>
-        private const string program_id_prefix = "osu.File";
+        private const string program_id_file_prefix = "osu.File";
+
+        private const string program_id_protocol_prefix = "osu.Uri";
+
+        private static readonly ApplicationCapability application_capability = new ApplicationCapability(@"osu", @"Software\ppy\osu\Capabilities", "osu!(lazer)");
 
         private static readonly FileAssociation[] file_associations =
         {
@@ -56,14 +61,13 @@ namespace osu.Desktop.Windows
         /// Installs file and URI associations.
         /// </summary>
         /// <remarks>
-        /// Call <see cref="UpdateDescriptions"/> in a timely fashion to keep descriptions up-to-date and localised.
+        /// Call <see cref="LocaliseDescriptions"/> in a timely fashion to keep descriptions up-to-date and localised.
         /// </remarks>
         public static void InstallAssociations()
         {
             try
             {
                 updateAssociations();
-                updateDescriptions(null); // write default descriptions in case `UpdateDescriptions()` is not called.
                 NotifyShellUpdate();
             }
             catch (Exception e)
@@ -76,17 +80,13 @@ namespace osu.Desktop.Windows
         /// Updates associations with latest definitions.
         /// </summary>
         /// <remarks>
-        /// Call <see cref="UpdateDescriptions"/> in a timely fashion to keep descriptions up-to-date and localised.
+        /// Call <see cref="LocaliseDescriptions"/> in a timely fashion to keep descriptions up-to-date and localised.
         /// </remarks>
         public static void UpdateAssociations()
         {
             try
             {
                 updateAssociations();
-
-                // TODO: Remove once UpdateDescriptions() is called as specified in the xmldoc.
-                updateDescriptions(null); // always write default descriptions, in case of updating from an older version in which file associations were not implemented/installed
-
                 NotifyShellUpdate();
             }
             catch (Exception e)
@@ -95,11 +95,19 @@ namespace osu.Desktop.Windows
             }
         }
 
-        public static void UpdateDescriptions(LocalisationManager localisationManager)
+        // TODO: call this sometime.
+        public static void LocaliseDescriptions(LocalisationManager localisationManager)
         {
             try
             {
-                updateDescriptions(localisationManager);
+                application_capability.LocaliseDescription(localisationManager);
+
+                foreach (var association in file_associations)
+                    association.LocaliseDescription(localisationManager);
+
+                foreach (var association in uri_associations)
+                    association.LocaliseDescription(localisationManager);
+
                 NotifyShellUpdate();
             }
             catch (Exception e)
@@ -112,6 +120,8 @@ namespace osu.Desktop.Windows
         {
             try
             {
+                application_capability.Uninstall();
+
                 foreach (var association in file_associations)
                     association.Uninstall();
 
@@ -133,22 +143,16 @@ namespace osu.Desktop.Windows
         /// </summary>
         private static void updateAssociations()
         {
+            application_capability.Install();
+
             foreach (var association in file_associations)
                 association.Install();
 
             foreach (var association in uri_associations)
                 association.Install();
-        }
 
-        private static void updateDescriptions(LocalisationManager? localisation)
-        {
-            foreach (var association in file_associations)
-                association.UpdateDescription(getLocalisedString(association.Description));
-
-            foreach (var association in uri_associations)
-                association.UpdateDescription(getLocalisedString(association.Description));
-
-            string getLocalisedString(LocalisableString s) => localisation?.GetLocalisedString(s) ?? s.ToString();
+            application_capability.RegisterFileAssociations(file_associations);
+            application_capability.RegisterUriAssociations(uri_associations);
         }
 
         #region Native interop
@@ -174,9 +178,87 @@ namespace osu.Desktop.Windows
 
         #endregion
 
-        private record FileAssociation(string Extension, LocalisableString Description, string IconPath)
+        private class ApplicationCapability
         {
-            private string programId => $@"{program_id_prefix}{Extension}";
+            private string uniqueName { get; }
+            private string capabilityPath { get; }
+            private LocalisableString description { get; }
+
+            public ApplicationCapability(string uniqueName, string capabilityPath, LocalisableString description)
+            {
+                this.uniqueName = uniqueName;
+                this.capabilityPath = capabilityPath;
+                this.description = description;
+            }
+
+            /// <summary>
+            /// Registers an application capability according to <see href="https://learn.microsoft.com/en-us/windows/win32/shell/default-programs#registering-an-application-for-use-with-default-programs">
+            /// Registering an Application for Use with Default Programs</see>.
+            /// </summary>
+            public void Install()
+            {
+                using (var capability = Registry.CurrentUser.CreateSubKey(capabilityPath))
+                {
+                    capability.SetValue(@"ApplicationDescription", description.ToString());
+                }
+
+                using (var registeredApplications = Registry.CurrentUser.OpenSubKey(software_registered_applications, true))
+                    registeredApplications?.SetValue(uniqueName, capabilityPath);
+            }
+
+            public void RegisterFileAssociations(FileAssociation[] associations)
+            {
+                using var capability = Registry.CurrentUser.OpenSubKey(capabilityPath, true);
+                if (capability == null) return;
+
+                using var fileAssociations = capability.CreateSubKey(@"FileAssociations");
+
+                foreach (var association in associations)
+                    fileAssociations.SetValue(association.Extension, association.ProgramId);
+            }
+
+            public void RegisterUriAssociations(UriAssociation[] associations)
+            {
+                using var capability = Registry.CurrentUser.OpenSubKey(capabilityPath, true);
+                if (capability == null) return;
+
+                using var urlAssociations = capability.CreateSubKey(@"UrlAssociations");
+
+                foreach (var association in associations)
+                    urlAssociations.SetValue(association.Protocol, association.ProgramId);
+            }
+
+            public void LocaliseDescription(LocalisationManager localisationManager)
+            {
+                using (var capability = Registry.CurrentUser.OpenSubKey(capabilityPath, true))
+                {
+                    capability?.SetValue(@"ApplicationDescription", localisationManager.GetLocalisedString(description));
+                }
+            }
+
+            public void Uninstall()
+            {
+                using (var registeredApplications = Registry.CurrentUser.OpenSubKey(software_registered_applications, true))
+                    registeredApplications?.DeleteValue(uniqueName, throwOnMissingValue: false);
+
+                Registry.CurrentUser.DeleteSubKeyTree(capabilityPath, throwOnMissingSubKey: false);
+            }
+        }
+
+        private class FileAssociation
+        {
+            public string ProgramId => $@"{program_id_file_prefix}{Extension}";
+
+            public string Extension { get; }
+            private LocalisableString description { get; }
+            private string iconPath { get; }
+
+            public FileAssociation(string extension, LocalisableString description, string iconPath)
+            {
+                Extension = extension;
+                this.description = description;
+                this.iconPath = iconPath;
+            }
 
             /// <summary>
             /// Installs a file extension association in accordance with https://learn.microsoft.com/en-us/windows/win32/com/-progid--key
@@ -187,10 +269,12 @@ namespace osu.Desktop.Windows
                 if (classes == null) return;
 
                 // register a program id for the given extension
-                using (var programKey = classes.CreateSubKey(programId))
+                using (var programKey = classes.CreateSubKey(ProgramId))
                 {
+                    programKey.SetValue(null, description.ToString());
+
                     using (var defaultIconKey = programKey.CreateSubKey(default_icon))
-                        defaultIconKey.SetValue(null, IconPath);
+                        defaultIconKey.SetValue(null, iconPath);
 
                     using (var openCommandKey = programKey.CreateSubKey(SHELL_OPEN_COMMAND))
                         openCommandKey.SetValue(null, $@"""{exe_path}"" ""%1""");
@@ -198,23 +282,25 @@ namespace osu.Desktop.Windows
 
                 using (var extensionKey = classes.CreateSubKey(Extension))
                 {
-                    // set ourselves as the default program
-                    extensionKey.SetValue(null, programId);
+                    // Clear out our existing default ProgramID. Default programs in Windows are handled internally by Explorer,
+                    // so having it here is just confusing and may override user preferences.
+                    if (extensionKey.GetValue(null) is string s && s == ProgramId)
+                        extensionKey.SetValue(null, string.Empty);
 
                     // add to the open with dialog
                     // https://learn.microsoft.com/en-us/windows/win32/shell/how-to-include-an-application-on-the-open-with-dialog-box
                     using (var openWithKey = extensionKey.CreateSubKey(@"OpenWithProgIds"))
-                        openWithKey.SetValue(programId, string.Empty);
+                        openWithKey.SetValue(ProgramId, string.Empty);
                 }
             }
 
-            public void UpdateDescription(string description)
+            public void LocaliseDescription(LocalisationManager localisationManager)
             {
                 using var classes = Registry.CurrentUser.OpenSubKey(software_classes, true);
                 if (classes == null) return;
 
-                using (var programKey = classes.OpenSubKey(programId, true))
-                    programKey?.SetValue(null, description);
+                using (var programKey = classes.OpenSubKey(ProgramId, true))
+                    programKey?.SetValue(null, localisationManager.GetLocalisedString(description));
             }
 
             /// <summary>
@@ -227,26 +313,34 @@ namespace osu.Desktop.Windows
 
                 using (var extensionKey = classes.OpenSubKey(Extension, true))
                 {
-                    // clear our default association so that Explorer doesn't show the raw programId to users
-                    // the null/(Default) entry is used for both ProdID association and as a fallback friendly name, for legacy reasons
-                    if (extensionKey?.GetValue(null) is string s && s == programId)
-                        extensionKey.SetValue(null, string.Empty);
-
                     using (var openWithKey = extensionKey?.CreateSubKey(@"OpenWithProgIds"))
-                        openWithKey?.DeleteValue(programId, throwOnMissingValue: false);
+                        openWithKey?.DeleteValue(ProgramId, throwOnMissingValue: false);
                 }
 
-                classes.DeleteSubKeyTree(programId, throwOnMissingSubKey: false);
+                classes.DeleteSubKeyTree(ProgramId, throwOnMissingSubKey: false);
             }
         }
 
-        private record UriAssociation(string Protocol, LocalisableString Description, string IconPath)
+        private class UriAssociation
         {
             /// <summary>
             /// "The <c>URL Protocol</c> string value indicates that this key declares a custom pluggable protocol handler."
             /// See https://learn.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa767914(v=vs.85).
             /// </summary>
-            public const string URL_PROTOCOL = @"URL Protocol";
+            private const string url_protocol = @"URL Protocol";
+
+            public string Protocol { get; }
+            private LocalisableString description { get; }
+            private string iconPath { get; }
+
+            public UriAssociation(string protocol, LocalisableString description, string iconPath)
+            {
+                Protocol = protocol;
+                this.description = description;
+                this.iconPath = iconPath;
+            }
+
+            public string ProgramId => $@"{program_id_protocol_prefix}.{Protocol}";
 
             /// <summary>
             /// Registers an URI protocol handler in accordance with https://learn.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa767914(v=vs.85).
@@ -258,29 +352,38 @@ namespace osu.Desktop.Windows
 
                 using (var protocolKey = classes.CreateSubKey(Protocol))
                 {
-                    protocolKey.SetValue(URL_PROTOCOL, string.Empty);
+                    protocolKey.SetValue(null, $@"URL:{description}");
+                    protocolKey.SetValue(url_protocol, string.Empty);
 
-                    using (var defaultIconKey = protocolKey.CreateSubKey(default_icon))
-                        defaultIconKey.SetValue(null, IconPath);
+                    // clear out old data
+                    protocolKey.DeleteSubKeyTree(default_icon, throwOnMissingSubKey: false);
+                    protocolKey.DeleteSubKeyTree(@"Shell", throwOnMissingSubKey: false);
+                }
 
-                    using (var openCommandKey = protocolKey.CreateSubKey(SHELL_OPEN_COMMAND))
+                // register a program id for the given protocol
+                using (var programKey = classes.CreateSubKey(ProgramId))
+                {
+                    using (var defaultIconKey = programKey.CreateSubKey(default_icon))
+                        defaultIconKey.SetValue(null, iconPath);
+
+                    using (var openCommandKey = programKey.CreateSubKey(SHELL_OPEN_COMMAND))
                         openCommandKey.SetValue(null, $@"""{exe_path}"" ""%1""");
                 }
             }
 
-            public void UpdateDescription(string description)
+            public void LocaliseDescription(LocalisationManager localisationManager)
             {
                 using var classes = Registry.CurrentUser.OpenSubKey(software_classes, true);
                 if (classes == null) return;
 
                 using (var protocolKey = classes.OpenSubKey(Protocol, true))
-                    protocolKey?.SetValue(null, $@"URL:{description}");
+                    protocolKey?.SetValue(null, $@"URL:{localisationManager.GetLocalisedString(description)}");
             }
 
             public void Uninstall()
             {
                 using var classes = Registry.CurrentUser.OpenSubKey(software_classes, true);
-                classes?.DeleteSubKeyTree(Protocol, throwOnMissingSubKey: false);
+                classes?.DeleteSubKeyTree(ProgramId, throwOnMissingSubKey: false);
             }
         }
     }

osu.Desktop/osu.Desktop.csproj

@@ -24,9 +24,9 @@
     <ProjectReference Include="..\osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="System.IO.Packaging" Version="8.0.1" />
+    <PackageReference Include="System.IO.Packaging" Version="9.0.2" />
     <PackageReference Include="DiscordRichPresence" Version="1.2.1.24" />
-    <PackageReference Include="Velopack" Version="0.0.915" />
+    <PackageReference Include="Velopack" Version="0.0.1053" />
   </ItemGroup>
   <ItemGroup Label="Resources">
     <EmbeddedResource Include="lazer.ico" />

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

@@ -9,7 +9,7 @@
   <ItemGroup>
     <PackageReference Include="BenchmarkDotNet" Version="0.14.0" />
     <PackageReference Include="nunit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
   </ItemGroup>
 
   <ItemGroup>

osu.Game.Rulesets.Catch.Tests.iOS/AppDelegate.cs

@@ -0,0 +1,15 @@
+// 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 Foundation;
+using osu.Framework.iOS;
+using osu.Game.Tests;
+
+namespace osu.Game.Rulesets.Catch.Tests.iOS
+{
+    [Register("AppDelegate")]
+    public class AppDelegate : GameApplicationDelegate
+    {
+        protected override Framework.Game CreateGame() => new OsuTestBrowser();
+    }
+}

osu.Game.Rulesets.Catch.Tests.iOS/Program.cs

@@ -1,16 +1,15 @@
 // 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.iOS;
-using osu.Game.Tests;
+using UIKit;
 
 namespace osu.Game.Rulesets.Catch.Tests.iOS
 {
-    public static class Application
+    public static class Program
     {
         public static void Main(string[] args)
         {
-            GameApplication.Main(new OsuTestBrowser());
+            UIApplication.Main(args, null, typeof(AppDelegate));
         }
     }
 }

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

@@ -12,7 +12,6 @@ using osu.Framework.Testing;
 using osu.Framework.Timing;
 using osu.Game.Rulesets.Catch.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
-using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
@@ -23,6 +22,8 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
 {
     public abstract partial class CatchPlacementBlueprintTestScene : PlacementBlueprintTestScene
     {
+        protected sealed override Ruleset CreateRuleset() => new CatchRuleset();
+
         protected const double TIME_SNAP = 100;
 
         protected DrawableCatchHitObject LastObject;
@@ -71,11 +72,11 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
             contentContainer.Playfield.HitObjectContainer.Add(hitObject);
         }
 
-        protected override SnapResult SnapForBlueprint(HitObjectPlacementBlueprint blueprint)
+        protected override void UpdatePlacementTimeAndPosition()
         {
-            var result = base.SnapForBlueprint(blueprint);
-            result.Time = Math.Round(HitObjectContainer.TimeAtScreenSpacePosition(result.ScreenSpacePosition) / TIME_SNAP) * TIME_SNAP;
-            return result;
+            var position = InputManager.CurrentState.Mouse.Position;
+            double time = Math.Round(HitObjectContainer.TimeAtScreenSpacePosition(position) / TIME_SNAP) * TIME_SNAP;
+            CurrentBlueprint.UpdateTimeAndPosition(position, time);
         }
     }
 }

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

@@ -1,8 +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.
 
-#nullable disable
-
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
@@ -21,7 +19,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
 {
     public partial class TestSceneJuiceStreamSelectionBlueprint : CatchSelectionBlueprintTestScene
     {
-        private JuiceStream hitObject;
+        private JuiceStream hitObject = null!;
 
         private readonly ManualClock manualClock = new ManualClock();
 
@@ -193,6 +191,17 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
             addVertexCheckStep(1, 0, times[0], positions[0]);
         }
 
+        [Test]
+        public void TestDeletingSecondVertexDeletesEntireJuiceStream()
+        {
+            double[] times = { 100, 400 };
+            float[] positions = { 100, 150 };
+            addBlueprintStep(times, positions);
+
+            addDeleteVertexSteps(times[1], positions[1]);
+            AddAssert("juice stream deleted", () => EditorBeatmap.HitObjects, () => Is.Empty);
+        }
+
         [Test]
         public void TestVertexResampling()
         {

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

@@ -0,0 +1,75 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Testing;
+using osu.Framework.Timing;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.Replays;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Storyboards;
+using osu.Game.Tests.Visual;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    public partial class TestSceneReplayRecording : PlayerTestScene
+    {
+        protected override Ruleset CreatePlayerRuleset() => new CatchRuleset();
+
+        [Resolved]
+        private AudioManager audioManager { get; set; } = null!;
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new Beatmap
+        {
+            HitObjects =
+            {
+                new Fruit { StartTime = 0, },
+                new Fruit { StartTime = 5000, },
+                new Fruit { StartTime = 10000, },
+                new Fruit { StartTime = 15000, }
+            }
+        };
+
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard? storyboard = null) =>
+            new ClockBackedTestWorkingBeatmap(beatmap, storyboard, new FramedClock(new ManualClock { Rate = 1 }), audioManager);
+
+        [Test]
+        public void TestRecording()
+        {
+            seekTo(0);
+            AddStep("start moving left", () => InputManager.PressKey(Key.Left));
+            seekTo(5000);
+            AddStep("end moving left", () => InputManager.ReleaseKey(Key.Left));
+            AddAssert("catcher max left", () => this.ChildrenOfType<Catcher>().Single().X, () => Is.EqualTo(0));
+            AddAssert("movement to left recorded to replay", () => Player.Score.Replay.Frames.OfType<CatchReplayFrame>().Any(f => f.Actions.SequenceEqual([CatchAction.MoveLeft])));
+            AddAssert("replay reached left edge", () => Player.Score.Replay.Frames.OfType<CatchReplayFrame>().Any(f => Precision.AlmostEquals(f.Position, 0)));
+
+            AddStep("start dashing right", () =>
+            {
+                InputManager.PressKey(Key.LShift);
+                InputManager.PressKey(Key.Right);
+            });
+            seekTo(10000);
+            AddStep("end dashing right", () =>
+            {
+                InputManager.ReleaseKey(Key.LShift);
+                InputManager.ReleaseKey(Key.Right);
+            });
+            AddAssert("catcher max right", () => this.ChildrenOfType<Catcher>().Single().X, () => Is.EqualTo(CatchPlayfield.WIDTH));
+            AddAssert("dash to right recorded to replay", () => Player.Score.Replay.Frames.OfType<CatchReplayFrame>().Any(f => f.Actions.SequenceEqual([CatchAction.Dash, CatchAction.MoveRight])));
+            AddAssert("replay reached right edge", () => Player.Score.Replay.Frames.OfType<CatchReplayFrame>().Any(f => Precision.AlmostEquals(f.Position, CatchPlayfield.WIDTH)));
+        }
+
+        private void seekTo(double time)
+        {
+            AddStep($"seek to {time}ms", () => Player.GameplayClockContainer.Seek(time));
+            AddUntilStep("wait for seek to finish", () => Player.DrawableRuleset.FrameStableClock.CurrentTime, () => Is.EqualTo(time).Within(500));
+        }
+    }
+}

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

@@ -1,9 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
   </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>

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

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
@@ -16,26 +17,30 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
             int fruits = HitObjects.Count(s => s is Fruit);
             int juiceStreams = HitObjects.Count(s => s is JuiceStream);
             int bananaShowers = HitObjects.Count(s => s is BananaShower);
+            int sum = Math.Max(1, fruits + juiceStreams);
 
             return new[]
             {
                 new BeatmapStatistic
                 {
-                    Name = @"Fruit Count",
+                    Name = @"Fruits",
                     Content = fruits.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
+                    BarDisplayLength = fruits / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Juice Stream Count",
+                    Name = @"Juice Streams",
                     Content = juiceStreams.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
+                    BarDisplayLength = juiceStreams / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Banana Shower Count",
+                    Name = @"Banana Showers",
                     Content = bananaShowers.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Spinners),
+                    BarDisplayLength = Math.Min(bananaShowers / 10f, 1),
                 }
             };
         }

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

@@ -45,7 +45,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                         LegacyConvertedY = yPositionData?.Y ?? CatchHitObject.DEFAULT_LEGACY_CONVERT_Y,
                         // prior to v8, speed multipliers don't adjust for how many ticks are generated over the same distance.
                         // this results in more (or less) ticks being generated in <v8 maps for the same time duration.
-                        TickDistanceMultiplier = beatmap.BeatmapInfo.BeatmapVersion < 8 ? 1f / ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(obj.StartTime).SliderVelocity : 1,
+                        TickDistanceMultiplier = beatmap.BeatmapVersion < 8 ? 1f / ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(obj.StartTime).SliderVelocity : 1,
                         SliderVelocityMultiplier = sliderVelocityData?.SliderVelocityMultiplier ?? 1
                     }.Yield();
 

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -14,6 +14,7 @@ using osu.Game.Graphics;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Difficulty;
 using osu.Game.Rulesets.Catch.Edit;
+using osu.Game.Rulesets.Catch.Edit.Setup;
 using osu.Game.Rulesets.Catch.Mods;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Replays;
@@ -228,7 +229,7 @@ namespace osu.Game.Rulesets.Catch
         public override IEnumerable<Drawable> CreateEditorSetupSections() =>
         [
             new MetadataSection(),
-            new DifficultySection(),
+            new CatchDifficultySection(),
             new FillFlowContainer
             {
                 AutoSizeAxes = Axes.Y,

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

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using Newtonsoft.Json;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 
@@ -10,15 +9,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 {
     public class CatchDifficultyAttributes : DifficultyAttributes
     {
-        /// <summary>
-        /// The perceived approach rate inclusive of rate-adjusting mods (DT/HT/etc).
-        /// </summary>
-        /// <remarks>
-        /// Rate-adjusting mods don't directly affect the approach rate difficulty value, but have a perceived effect as a result of adjusting audio timing.
-        /// </remarks>
-        [JsonProperty("approach_rate")]
-        public double ApproachRate { get; set; }
-
         public override IEnumerable<(int attributeId, object value)> ToDatabaseAttributes()
         {
             foreach (var v in base.ToDatabaseAttributes())
@@ -26,7 +16,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
             // Todo: osu!catch should not output star rating in the 'aim' attribute.
             yield return (ATTRIB_ID_AIM, StarRating);
-            yield return (ATTRIB_ID_APPROACH_RATE, ApproachRate);
         }
 
         public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values, IBeatmapOnlineInfo onlineInfo)
@@ -34,7 +23,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty
             base.FromDatabaseAttributes(values, onlineInfo);
 
             StarRating = values[ATTRIB_ID_AIM];
-            ApproachRate = values[ATTRIB_ID_APPROACH_RATE];
         }
     }
 }

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

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Difficulty.Preprocessing;
@@ -23,7 +24,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
         private float halfCatcherWidth;
 
-        public override int Version => 20220701;
+        public override int Version => 20250306;
 
         public CatchDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
             : base(ruleset, beatmap)
@@ -35,14 +36,10 @@ namespace osu.Game.Rulesets.Catch.Difficulty
             if (beatmap.HitObjects.Count == 0)
                 return new CatchDifficultyAttributes { Mods = mods };
 
-            // this is the same as osu!, so there's potential to share the implementation... maybe
-            double preempt = IBeatmapDifficultyInfo.DifficultyRange(beatmap.Difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
-
             CatchDifficultyAttributes attributes = new CatchDifficultyAttributes
             {
-                StarRating = Math.Sqrt(skills[0].DifficultyValue()) * difficulty_multiplier,
+                StarRating = Math.Sqrt(skills.OfType<Movement>().Single().DifficultyValue()) * difficulty_multiplier,
                 Mods = mods,
-                ApproachRate = preempt > 1200.0 ? -(preempt - 1800.0) / 120.0 : -(preempt - 1200.0) / 150.0 + 5.0,
                 MaxCombo = beatmap.GetMaxCombo(),
             };
 

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

@@ -3,6 +3,9 @@
 
 using System;
 using System.Linq;
+using osu.Framework.Audio.Track;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
@@ -50,7 +53,19 @@ namespace osu.Game.Rulesets.Catch.Difficulty
             if (catchAttributes.MaxCombo > 0)
                 value *= Math.Min(Math.Pow(score.MaxCombo, 0.8) / Math.Pow(catchAttributes.MaxCombo, 0.8), 1.0);
 
-            double approachRate = catchAttributes.ApproachRate;
+            var difficulty = score.BeatmapInfo!.Difficulty.Clone();
+
+            score.Mods.OfType<IApplicableToDifficulty>().ForEach(m => m.ApplyToDifficulty(difficulty));
+
+            var track = new TrackVirtual(10000);
+            score.Mods.OfType<IApplicableToTrack>().ForEach(m => m.ApplyToTrack(track));
+            double clockRate = track.Rate;
+
+            // this is the same as osu!, so there's potential to share the implementation... maybe
+            double preempt = IBeatmapDifficultyInfo.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
+
+            double approachRate = preempt > 1200.0 ? -(preempt - 1800.0) / 120.0 : -(preempt - 1200.0) / 150.0 + 5.0;
+
             double approachRateFactor = 1.0;
             if (approachRate > 9.0)
                 approachRateFactor += 0.1 * (approachRate - 9.0); // 10% for each AR above 9

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

@@ -26,7 +26,9 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
 
         private float? lastPlayerPosition;
         private float lastDistanceMoved;
+        private float lastExactDistanceMoved;
         private double lastStrainTime;
+        private bool isInBuzzSection;
 
         /// <summary>
         /// The speed multiplier applied to the player's catcher.
@@ -59,6 +61,9 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
 
             float distanceMoved = playerPosition - lastPlayerPosition.Value;
 
+            // For the exact position we consider that the catcher is in the correct position for both objects
+            float exactDistanceMoved = catchCurrent.NormalizedPosition - lastPlayerPosition.Value;
+
             double weightedStrainTime = catchCurrent.StrainTime + 13 + (3 / catcherSpeedMultiplier);
 
             double distanceAddition = (Math.Pow(Math.Abs(distanceMoved), 1.3) / 510);
@@ -92,12 +97,30 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
                     playerPosition = catchCurrent.NormalizedPosition;
                 }
 
-                distanceAddition *= 1.0 + edgeDashBonus * ((20 - catchCurrent.LastObject.DistanceToHyperDash) / 20) * Math.Pow((Math.Min(catchCurrent.StrainTime * catcherSpeedMultiplier, 265) / 265), 1.5); // Edge Dashes are easier at lower ms values
+                distanceAddition *= 1.0 + edgeDashBonus * ((20 - catchCurrent.LastObject.DistanceToHyperDash) / 20)
+                                                        * Math.Pow((Math.Min(catchCurrent.StrainTime * catcherSpeedMultiplier, 265) / 265), 1.5); // Edge Dashes are easier at lower ms values
+            }
+
+            // There is an edge case where horizontal back and forth sliders create "buzz" patterns which are repeated "movements" with a distance lower than
+            // the platter's width but high enough to be considered a movement due to the absolute_player_positioning_error and normalized_hitobject_radius offsets
+            // We are detecting this exact scenario. The first back and forth is counted but all subsequent ones are nullified.
+            // To achieve that, we need to store the exact distances (distance ignoring absolute_player_positioning_error and normalized_hitobject_radius)
+            if (Math.Abs(exactDistanceMoved) <= HalfCatcherWidth * 2 && exactDistanceMoved == -lastExactDistanceMoved && catchCurrent.StrainTime == lastStrainTime)
+            {
+                if (isInBuzzSection)
+                    distanceAddition = 0;
+                else
+                    isInBuzzSection = true;
+            }
+            else
+            {
+                isInBuzzSection = false;
             }
 
             lastPlayerPosition = playerPosition;
             lastDistanceMoved = distanceMoved;
             lastStrainTime = catchCurrent.StrainTime;
+            lastExactDistanceMoved = exactDistanceMoved;
 
             return distanceAddition / weightedStrainTime;
         }

osu.Game.Rulesets.Catch/Edit/Blueprints/BananaShowerPlacementBlueprint.cs

@@ -7,6 +7,7 @@ using osu.Framework.Utils;
 using osu.Game.Rulesets.Catch.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Edit;
+using osuTK;
 using osuTK.Input;
 
 namespace osu.Game.Rulesets.Catch.Edit.Blueprints
@@ -59,11 +60,13 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
             return base.OnMouseDown(e);
         }
 
-        public override void UpdateTimeAndPosition(SnapResult result)
+        public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, double fallbackTime)
         {
-            base.UpdateTimeAndPosition(result);
+            var result = Composer?.FindSnappedPositionAndTime(screenSpacePosition) ?? new SnapResult(screenSpacePosition, fallbackTime);
 
-            if (!(result.Time is double time)) return;
+            base.UpdateTimeAndPosition(result.ScreenSpacePosition, result.Time ?? fallbackTime);
+
+            if (!(result.Time is double time)) return result;
 
             switch (PlacementActive)
             {
@@ -78,6 +81,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
 
             HitObject.StartTime = Math.Min(placementStartTime, placementEndTime);
             HitObject.EndTime = Math.Max(placementStartTime, placementEndTime);
+            return result;
         }
     }
 }

osu.Game.Rulesets.Catch/Edit/Blueprints/CatchPlacementBlueprint.cs

@@ -9,7 +9,7 @@ using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Catch.Edit.Blueprints
 {
-    public partial class CatchPlacementBlueprint<THitObject> : HitObjectPlacementBlueprint
+    public abstract partial class CatchPlacementBlueprint<THitObject> : HitObjectPlacementBlueprint
         where THitObject : CatchHitObject, new()
     {
         protected new THitObject HitObject => (THitObject)base.HitObject;
@@ -19,7 +19,10 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
         [Resolved]
         private Playfield playfield { get; set; } = null!;
 
-        public CatchPlacementBlueprint()
+        [Resolved]
+        protected CatchHitObjectComposer? Composer { get; private set; }
+
+        protected CatchPlacementBlueprint()
             : base(new THitObject())
         {
         }

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

@@ -92,7 +92,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints.Components
             }));
         }
 
-        public void UpdateHitObjectFromPath(JuiceStream hitObject)
+        public virtual void UpdateHitObjectFromPath(JuiceStream hitObject)
         {
             // The SV setting may need to be changed for the current path.
             var svBindable = hitObject.SliderVelocityMultiplierBindable;

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

@@ -138,5 +138,13 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints.Components
 
             EditorBeatmap?.EndChange();
         }
+
+        public override void UpdateHitObjectFromPath(JuiceStream hitObject)
+        {
+            base.UpdateHitObjectFromPath(hitObject);
+
+            if (hitObject.Path.ControlPoints.Count <= 1 || !hitObject.Path.HasValidLengthForPlacement)
+                EditorBeatmap?.Remove(hitObject);
+        }
     }
 }

osu.Game.Rulesets.Catch/Edit/Blueprints/FruitPlacementBlueprint.cs

@@ -5,6 +5,7 @@ using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Catch.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Edit;
+using osuTK;
 using osuTK.Input;
 
 namespace osu.Game.Rulesets.Catch.Edit.Blueprints
@@ -41,11 +42,20 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
             return true;
         }
 
-        public override void UpdateTimeAndPosition(SnapResult result)
+        public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, double fallbackTime)
         {
-            base.UpdateTimeAndPosition(result);
+            var gridSnapResult = Composer?.FindSnappedPositionAndTime(screenSpacePosition) ?? new SnapResult(screenSpacePosition, fallbackTime);
+            gridSnapResult.ScreenSpacePosition.X = screenSpacePosition.X;
+            var distanceSnapResult = Composer?.TryDistanceSnap(gridSnapResult.ScreenSpacePosition);
+
+            var result = distanceSnapResult != null && Vector2.Distance(gridSnapResult.ScreenSpacePosition, distanceSnapResult.ScreenSpacePosition) < CatchHitObjectComposer.DISTANCE_SNAP_RADIUS
+                ? distanceSnapResult
+                : gridSnapResult;
+
+            base.UpdateTimeAndPosition(result.ScreenSpacePosition, result.Time ?? fallbackTime);
 
             HitObject.X = ToLocalSpace(result.ScreenSpacePosition).X;
+            return result;
         }
     }
 }

osu.Game.Rulesets.Catch/Edit/Blueprints/JuiceStreamPlacementBlueprint.cs

@@ -83,15 +83,22 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
             return base.OnMouseDown(e);
         }
 
-        public override void UpdateTimeAndPosition(SnapResult result)
+        public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, double fallbackTime)
         {
+            var gridSnapResult = Composer?.FindSnappedPositionAndTime(screenSpacePosition) ?? new SnapResult(screenSpacePosition, fallbackTime);
+            gridSnapResult.ScreenSpacePosition.X = screenSpacePosition.X;
+            var distanceSnapResult = Composer?.TryDistanceSnap(gridSnapResult.ScreenSpacePosition);
+
+            var result = distanceSnapResult != null && Vector2.Distance(gridSnapResult.ScreenSpacePosition, distanceSnapResult.ScreenSpacePosition) < CatchHitObjectComposer.DISTANCE_SNAP_RADIUS
+                ? distanceSnapResult
+                : gridSnapResult;
+
             switch (PlacementActive)
             {
                 case PlacementState.Waiting:
-                    if (!(result.Time is double snappedTime)) return;
-
                     HitObject.OriginalX = ToLocalSpace(result.ScreenSpacePosition).X;
-                    HitObject.StartTime = snappedTime;
+                    if (result.Time is double snappedTime)
+                        HitObject.StartTime = snappedTime;
                     break;
 
                 case PlacementState.Active:
@@ -100,28 +107,21 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
                     break;
 
                 default:
-                    return;
+                    return result;
             }
 
             // Make sure the up-to-date position is used for outlines.
             Vector2 startPosition = CatchHitObjectUtils.GetStartPosition(HitObjectContainer, HitObject);
             editablePath.Position = nestedOutlineContainer.Position = scrollingPath.Position = startPosition;
 
-            updateHitObjectFromPath();
-        }
+            if (lastEditablePathId != editablePath.PathId)
+                editablePath.UpdateHitObjectFromPath(HitObject);
+            lastEditablePathId = editablePath.PathId;
 
-        private void updateHitObjectFromPath()
-        {
-            if (lastEditablePathId == editablePath.PathId)
-                return;
-
-            editablePath.UpdateHitObjectFromPath(HitObject);
             ApplyDefaultsToHitObject();
-
             scrollingPath.UpdatePathFrom(HitObjectContainer, HitObject);
             nestedOutlineContainer.UpdateNestedObjectsFrom(HitObjectContainer, HitObject);
-
-            lastEditablePathId = editablePath.PathId;
+            return result;
         }
 
         private double positionToTime(float relativeYPosition)

osu.Game.Rulesets.Catch/Edit/Blueprints/JuiceStreamSelectionBlueprint.cs

@@ -10,10 +10,12 @@ using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
+using osu.Framework.Utils;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Catch.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Screens.Edit;
 using osuTK;
 using osuTK.Input;
@@ -54,6 +56,12 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
         [Resolved]
         private EditorBeatmap? editorBeatmap { get; set; }
 
+        [Resolved]
+        private IEditorChangeHandler? changeHandler { get; set; }
+
+        [Resolved]
+        private BindableBeatDivisor? beatDivisor { get; set; }
+
         public JuiceStreamSelectionBlueprint(JuiceStream hitObject)
             : base(hitObject)
         {
@@ -119,6 +127,20 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
             return base.OnMouseDown(e);
         }
 
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            if (!IsSelected)
+                return false;
+
+            if (e.Key == Key.F && e.ControlPressed && e.ShiftPressed)
+            {
+                convertToStream();
+                return true;
+            }
+
+            return false;
+        }
+
         private void onDefaultsApplied(HitObject _)
         {
             computeObjectBounds();
@@ -168,6 +190,50 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
             lastSliderPathVersion = HitObject.Path.Version.Value;
         }
 
+        // duplicated in `SliderSelectionBlueprint.convertToStream()`
+        // consider extracting common helper when applying changes here
+        private void convertToStream()
+        {
+            if (editorBeatmap == null || beatDivisor == null)
+                return;
+
+            var timingPoint = editorBeatmap.ControlPointInfo.TimingPointAt(HitObject.StartTime);
+            double streamSpacing = timingPoint.BeatLength / beatDivisor.Value;
+
+            changeHandler?.BeginChange();
+
+            int i = 0;
+            double time = HitObject.StartTime;
+
+            while (!Precision.DefinitelyBigger(time, HitObject.GetEndTime(), 1))
+            {
+                // positionWithRepeats is a fractional number in the range of [0, HitObject.SpanCount()]
+                // and indicates how many fractional spans of a slider have passed up to time.
+                double positionWithRepeats = (time - HitObject.StartTime) / HitObject.Duration * HitObject.SpanCount();
+                double pathPosition = positionWithRepeats - (int)positionWithRepeats;
+                // every second span is in the reverse direction - need to reverse the path position.
+                if (positionWithRepeats % 2 >= 1)
+                    pathPosition = 1 - pathPosition;
+
+                float fruitXValue = HitObject.OriginalX + HitObject.Path.PositionAt(pathPosition).X;
+
+                editorBeatmap.Add(new Fruit
+                {
+                    StartTime = time,
+                    OriginalX = fruitXValue,
+                    NewCombo = i == 0 && HitObject.NewCombo,
+                    Samples = HitObject.Samples.Select(s => s.With()).ToList()
+                });
+
+                i += 1;
+                time = HitObject.StartTime + i * streamSpacing;
+            }
+
+            editorBeatmap.Remove(HitObject);
+
+            changeHandler?.EndChange();
+        }
+
         private IEnumerable<MenuItem> getContextMenuItems()
         {
             yield return new OsuMenuItem("Add vertex", MenuItemType.Standard, () =>
@@ -177,6 +243,11 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
             {
                 Hotkey = new Hotkey(new KeyCombination(InputKey.Control, InputKey.MouseLeft))
             };
+
+            yield return new OsuMenuItem("Convert to stream", MenuItemType.Destructive, convertToStream)
+            {
+                Hotkey = new Hotkey(new KeyCombination(InputKey.Control, InputKey.Shift, InputKey.F))
+            };
         }
 
         protected override void Dispose(bool isDisposing)

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

@@ -5,6 +5,7 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Rulesets.Catch.Edit.Checks;
 using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
 using osu.Game.Rulesets.Edit.Checks.Components;
 
 namespace osu.Game.Rulesets.Catch.Edit
@@ -13,7 +14,11 @@ namespace osu.Game.Rulesets.Catch.Edit
     {
         private readonly List<ICheck> checks = new List<ICheck>
         {
+            // Compose
             new CheckBananaShowerGap(),
+            new CheckConcurrentObjects(),
+
+            // Settings
             new CheckCatchAbnormalDifficultySettings(),
         };
 

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

@@ -1,16 +1,22 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Catch.Edit.Blueprints;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Screens.Edit.Compose.Components;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Edit
 {
     public partial class CatchBlueprintContainer : ComposeBlueprintContainer
     {
+        public new CatchHitObjectComposer Composer => (CatchHitObjectComposer)base.Composer;
+
         public CatchBlueprintContainer(CatchHitObjectComposer composer)
             : base(composer)
         {
@@ -36,5 +42,28 @@ namespace osu.Game.Rulesets.Catch.Edit
         }
 
         protected sealed override DragBox CreateDragBox() => new ScrollingDragBox(Composer.Playfield);
+
+        protected override bool TryMoveBlueprints(DragEvent e, IList<(SelectionBlueprint<HitObject> blueprint, Vector2[] originalSnapPositions)> blueprints)
+        {
+            Vector2 distanceTravelled = e.ScreenSpaceMousePosition - e.ScreenSpaceMouseDownPosition;
+
+            // The final movement position, relative to movementBlueprintOriginalPosition.
+            Vector2 movePosition = blueprints.First().originalSnapPositions.First() + distanceTravelled;
+
+            // Retrieve a snapped position.
+            var gridSnapResult = Composer.FindSnappedPositionAndTime(movePosition);
+            gridSnapResult.ScreenSpacePosition.X = movePosition.X;
+            var distanceSnapResult = Composer.TryDistanceSnap(gridSnapResult.ScreenSpacePosition);
+
+            var result = distanceSnapResult != null && Vector2.Distance(gridSnapResult.ScreenSpacePosition, distanceSnapResult.ScreenSpacePosition) < CatchHitObjectComposer.DISTANCE_SNAP_RADIUS
+                ? distanceSnapResult
+                : gridSnapResult;
+
+            var referenceBlueprint = blueprints.First().blueprint;
+            bool moved = SelectionHandler.HandleMovement(new MoveSelectionEvent<HitObject>(referenceBlueprint, result.ScreenSpacePosition - referenceBlueprint.ScreenSpaceSelectionPoint));
+            if (moved)
+                ApplySnapResultTime(result, referenceBlueprint.Item.StartTime);
+            return moved;
+        }
     }
 }

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

@@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Catch.Edit
             //
             // The implementation below is probably correct but should be checked if/when exposed via controls.
 
-            float expectedDistance = DurationToDistance(before, after.StartTime - before.GetEndTime());
+            float expectedDistance = DurationToDistance(after.StartTime - before.GetEndTime(), before.StartTime);
 
             float previousEndX = (before as JuiceStream)?.EndX ?? ((CatchHitObject)before).EffectiveX;
             float actualDistance = Math.Abs(previousEndX - ((CatchHitObject)after).EffectiveX);

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

@@ -18,15 +18,15 @@ using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.UI;
-using osu.Game.Screens.Edit.Components.TernaryButtons;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Edit
 {
+    [Cached]
     public partial class CatchHitObjectComposer : ScrollingHitObjectComposer<CatchHitObject>, IKeyBindingHandler<GlobalAction>
     {
-        private const float distance_snap_radius = 50;
+        public const float DISTANCE_SNAP_RADIUS = 50;
 
         private CatchDistanceSnapGrid distanceSnapGrid = null!;
 
@@ -72,7 +72,7 @@ namespace osu.Game.Rulesets.Catch.Edit
 
         protected override Drawable CreateHitObjectInspector() => new CatchHitObjectInspector(DistanceSnapProvider);
 
-        protected override IEnumerable<TernaryButton> CreateTernaryButtons()
+        protected override IEnumerable<Drawable> CreateTernaryButtons()
             => base.CreateTernaryButtons()
                    .Concat(DistanceSnapProvider.CreateTernaryButtons());
 
@@ -136,22 +136,12 @@ namespace osu.Game.Rulesets.Catch.Edit
             DistanceSnapProvider.HandleToggleViaKey(key);
         }
 
-        public override SnapResult FindSnappedPositionAndTime(Vector2 screenSpacePosition, SnapType snapType = SnapType.All)
+        public SnapResult? TryDistanceSnap(Vector2 screenSpacePosition)
         {
-            var result = base.FindSnappedPositionAndTime(screenSpacePosition, snapType);
+            if (distanceSnapGrid.IsPresent && distanceSnapGrid.GetSnappedPosition(screenSpacePosition) is SnapResult snapResult)
+                return snapResult;
 
-            result.ScreenSpacePosition.X = screenSpacePosition.X;
-
-            if (snapType.HasFlag(SnapType.RelativeGrids))
-            {
-                if (distanceSnapGrid.IsPresent && distanceSnapGrid.GetSnappedPosition(result.ScreenSpacePosition) is SnapResult snapResult &&
-                    Vector2.Distance(snapResult.ScreenSpacePosition, result.ScreenSpacePosition) < distance_snap_radius)
-                {
-                    result = snapResult;
-                }
-            }
-
-            return result;
+            return null;
         }
 
         private PalpableCatchHitObject? getLastSnappableHitObject(double time)

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

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Objects;
@@ -12,6 +13,7 @@ using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
+using osuTK.Input;
 using Direction = osu.Framework.Graphics.Direction;
 
 namespace osu.Game.Rulesets.Catch.Edit
@@ -38,6 +40,13 @@ namespace osu.Game.Rulesets.Catch.Edit
                 return true;
             }
 
+            moveSelection(deltaX);
+
+            return true;
+        }
+
+        private void moveSelection(float deltaX)
+        {
             EditorBeatmap.PerformOnSelection(h =>
             {
                 if (!(h is CatchHitObject catchObject)) return;
@@ -48,7 +57,60 @@ namespace osu.Game.Rulesets.Catch.Edit
                 foreach (var nested in catchObject.NestedHitObjects.OfType<CatchHitObject>())
                     nested.OriginalX += deltaX;
             });
+        }
 
+        private bool nudgeMovementActive;
+
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            // Until the keys below are global actions, this will prevent conflicts with "seek between sample points"
+            // which has a default of ctrl+shift+arrows.
+            if (e.ShiftPressed)
+                return false;
+
+            if (e.ControlPressed)
+            {
+                switch (e.Key)
+                {
+                    case Key.Left:
+                        return nudgeSelection(-1);
+
+                    case Key.Right:
+                        return nudgeSelection(1);
+                }
+            }
+
+            return false;
+        }
+
+        protected override void OnKeyUp(KeyUpEvent e)
+        {
+            base.OnKeyUp(e);
+
+            if (nudgeMovementActive && !e.ControlPressed)
+            {
+                EditorBeatmap.EndChange();
+                nudgeMovementActive = false;
+            }
+        }
+
+        /// <summary>
+        /// Move the current selection spatially by the specified delta, in gamefield coordinates (ie. the same coordinates as the blueprints).
+        /// </summary>
+        private bool nudgeSelection(float deltaX)
+        {
+            if (!nudgeMovementActive)
+            {
+                nudgeMovementActive = true;
+                EditorBeatmap.BeginChange();
+            }
+
+            var firstBlueprint = SelectedBlueprints.FirstOrDefault();
+
+            if (firstBlueprint == null)
+                return false;
+
+            moveSelection(deltaX);
             return true;
         }
 

osu.Game.Rulesets.Catch/Edit/Setup/CatchDifficultySection.cs

@@ -0,0 +1,127 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Localisation;
+using osu.Game.Resources.Localisation.Web;
+using osu.Game.Screens.Edit.Setup;
+
+namespace osu.Game.Rulesets.Catch.Edit.Setup
+{
+    public partial class CatchDifficultySection : SetupSection
+    {
+        private FormSliderBar<float> circleSizeSlider { get; set; } = null!;
+        private FormSliderBar<float> healthDrainSlider { get; set; } = null!;
+        private FormSliderBar<float> approachRateSlider { get; set; } = null!;
+        private FormSliderBar<double> baseVelocitySlider { get; set; } = null!;
+        private FormSliderBar<double> tickRateSlider { get; set; } = null!;
+
+        public override LocalisableString Title => EditorSetupStrings.DifficultyHeader;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Children = new Drawable[]
+            {
+                circleSizeSlider = new FormSliderBar<float>
+                {
+                    Caption = BeatmapsetsStrings.ShowStatsCs,
+                    HintText = EditorSetupStrings.CircleSizeDescription,
+                    Current = new BindableFloat(Beatmap.Difficulty.CircleSize)
+                    {
+                        Default = BeatmapDifficulty.DEFAULT_DIFFICULTY,
+                        MinValue = 0,
+                        MaxValue = 10,
+                        Precision = 0.1f,
+                    },
+                    TransferValueOnCommit = true,
+                    TabbableContentContainer = this,
+                },
+                healthDrainSlider = new FormSliderBar<float>
+                {
+                    Caption = BeatmapsetsStrings.ShowStatsDrain,
+                    HintText = EditorSetupStrings.DrainRateDescription,
+                    Current = new BindableFloat(Beatmap.Difficulty.DrainRate)
+                    {
+                        Default = BeatmapDifficulty.DEFAULT_DIFFICULTY,
+                        MinValue = 0,
+                        MaxValue = 10,
+                        Precision = 0.1f,
+                    },
+                    TransferValueOnCommit = true,
+                    TabbableContentContainer = this,
+                },
+                approachRateSlider = new FormSliderBar<float>
+                {
+                    Caption = BeatmapsetsStrings.ShowStatsAr,
+                    HintText = EditorSetupStrings.ApproachRateDescription,
+                    Current = new BindableFloat(Beatmap.Difficulty.ApproachRate)
+                    {
+                        Default = BeatmapDifficulty.DEFAULT_DIFFICULTY,
+                        MinValue = 0,
+                        MaxValue = 10,
+                        Precision = 0.1f,
+                    },
+                    TransferValueOnCommit = true,
+                    TabbableContentContainer = this,
+                },
+                baseVelocitySlider = new FormSliderBar<double>
+                {
+                    Caption = EditorSetupStrings.BaseVelocity,
+                    HintText = EditorSetupStrings.BaseVelocityDescription,
+                    KeyboardStep = 0.1f,
+                    Current = new BindableDouble(Beatmap.Difficulty.SliderMultiplier)
+                    {
+                        Default = 1.4,
+                        MinValue = 0.4,
+                        MaxValue = 3.6,
+                        Precision = 0.01f,
+                    },
+                    TransferValueOnCommit = true,
+                    TabbableContentContainer = this,
+                },
+                tickRateSlider = new FormSliderBar<double>
+                {
+                    Caption = EditorSetupStrings.TickRate,
+                    HintText = EditorSetupStrings.TickRateDescription,
+                    KeyboardStep = 1,
+                    Current = new BindableDouble(Beatmap.Difficulty.SliderTickRate)
+                    {
+                        Default = 1,
+                        MinValue = 1,
+                        MaxValue = 4,
+                        Precision = 1,
+                    },
+                    TransferValueOnCommit = true,
+                    TabbableContentContainer = this,
+                },
+            };
+
+            foreach (var item in Children.OfType<FormSliderBar<float>>())
+                item.Current.ValueChanged += _ => updateValues();
+
+            foreach (var item in Children.OfType<FormSliderBar<double>>())
+                item.Current.ValueChanged += _ => updateValues();
+        }
+
+        private void updateValues()
+        {
+            // for now, update these on commit rather than making BeatmapMetadata bindables.
+            // after switching database engines we can reconsider if switching to bindables is a good direction.
+            Beatmap.Difficulty.CircleSize = circleSizeSlider.Current.Value;
+            Beatmap.Difficulty.DrainRate = healthDrainSlider.Current.Value;
+            Beatmap.Difficulty.ApproachRate = approachRateSlider.Current.Value;
+            Beatmap.Difficulty.SliderMultiplier = baseVelocitySlider.Current.Value;
+            Beatmap.Difficulty.SliderTickRate = tickRateSlider.Current.Value;
+
+            Beatmap.UpdateAllHitObjects();
+            Beatmap.SaveState();
+        }
+    }
+}

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

@@ -1,10 +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.
 
-using System.Linq;
+using System.Collections.Generic;
 using osu.Framework.Bindables;
+using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
+using osu.Game.Extensions;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Mods;
 
@@ -35,21 +37,39 @@ namespace osu.Game.Rulesets.Catch.Mods
         [SettingSource("Spicy Patterns", "Adjust the patterns as if Hard Rock is enabled.")]
         public BindableBool HardRockOffsets { get; } = new BindableBool();
 
-        public override string SettingDescription
+        public override string ExtendedIconInformation
         {
             get
             {
-                string circleSize = CircleSize.IsDefault ? string.Empty : $"CS {CircleSize.Value:N1}";
-                string approachRate = ApproachRate.IsDefault ? string.Empty : $"AR {ApproachRate.Value:N1}";
-                string spicyPatterns = HardRockOffsets.IsDefault ? string.Empty : "Spicy patterns";
+                if (UserAdjustedSettingsCount != 1)
+                    return string.Empty;
 
-                return string.Join(", ", new[]
-                {
-                    circleSize,
-                    base.SettingDescription,
-                    approachRate,
-                    spicyPatterns,
-                }.Where(s => !string.IsNullOrEmpty(s)));
+                if (!CircleSize.IsDefault) return format("CS", CircleSize);
+                if (!ApproachRate.IsDefault) return format("AR", ApproachRate);
+                if (!OverallDifficulty.IsDefault) return format("OD", OverallDifficulty);
+                if (!DrainRate.IsDefault) return format("HP", DrainRate);
+
+                return string.Empty;
+
+                string format(string acronym, DifficultyBindable bindable) => $"{acronym}{bindable.Value!.Value.ToStandardFormattedString(1)}";
+            }
+        }
+
+        public override IEnumerable<(LocalisableString setting, LocalisableString value)> SettingDescription
+        {
+            get
+            {
+                if (!CircleSize.IsDefault)
+                    yield return ("Circle size", $"{CircleSize.Value:N1}");
+
+                foreach (var setting in base.SettingDescription)
+                    yield return setting;
+
+                if (!ApproachRate.IsDefault)
+                    yield return ("Approach rate", $"{ApproachRate.Value:N1}");
+
+                if (!HardRockOffsets.IsDefault)
+                    yield return ("Spicy patterns", "On");
             }
         }
 

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

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

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

@@ -159,27 +159,26 @@ namespace osu.Game.Rulesets.Catch.Objects
         {
             // Note that this implementation is shared with the osu! ruleset's implementation.
             // If a change is made here, OsuHitObject.cs should also be updated.
-            ComboIndex = lastObj?.ComboIndex ?? 0;
-            ComboIndexWithOffsets = lastObj?.ComboIndexWithOffsets ?? 0;
-            IndexInCurrentCombo = (lastObj?.IndexInCurrentCombo + 1) ?? 0;
+            int index = lastObj?.ComboIndex ?? 0;
+            int indexWithOffsets = lastObj?.ComboIndexWithOffsets ?? 0;
+            int inCurrentCombo = (lastObj?.IndexInCurrentCombo + 1) ?? 0;
 
-            if (this is BananaShower)
+            // - For the purpose of combo colours, spinners never start a new combo even if they are flagged as doing so.
+            // - At decode time, the first hitobject in the beatmap and the first hitobject after a banana shower are both enforced to be a new combo,
+            //   but this isn't directly enforced by the editor so the extra checks against the last hitobject are duplicated here.
+            if (this is not BananaShower && (NewCombo || lastObj == null || lastObj is BananaShower))
             {
-                // For the purpose of combo colours, spinners never start a new combo even if they are flagged as doing so.
-                return;
-            }
-
-            // At decode time, the first hitobject in the beatmap and the first hitobject after a banana shower are both enforced to be a new combo,
-            // but this isn't directly enforced by the editor so the extra checks against the last hitobject are duplicated here.
-            if (NewCombo || lastObj == null || lastObj is BananaShower)
-            {
-                IndexInCurrentCombo = 0;
-                ComboIndex++;
-                ComboIndexWithOffsets += ComboOffset + 1;
+                inCurrentCombo = 0;
+                index++;
+                indexWithOffsets += ComboOffset + 1;
 
                 if (lastObj != null)
                     lastObj.LastInCombo = true;
             }
+
+            ComboIndex = index;
+            ComboIndexWithOffsets = indexWithOffsets;
+            IndexInCurrentCombo = inCurrentCombo;
         }
 
         protected override HitWindows CreateHitWindows() => HitWindows.Empty;
@@ -210,11 +209,27 @@ namespace osu.Game.Rulesets.Catch.Objects
         /// </summary>
         public float LegacyConvertedY { get; set; } = DEFAULT_LEGACY_CONVERT_Y;
 
-        float IHasXPosition.X => OriginalX;
+        float IHasXPosition.X
+        {
+            get => OriginalX;
+            set => OriginalX = value;
+        }
 
-        float IHasYPosition.Y => LegacyConvertedY;
+        float IHasYPosition.Y
+        {
+            get => LegacyConvertedY;
+            set => LegacyConvertedY = value;
+        }
 
-        Vector2 IHasPosition.Position => new Vector2(OriginalX, LegacyConvertedY);
+        Vector2 IHasPosition.Position
+        {
+            get => new Vector2(OriginalX, LegacyConvertedY);
+            set
+            {
+                ((IHasXPosition)this).X = value.X;
+                ((IHasYPosition)this).Y = value.Y;
+            }
+        }
 
         #endregion
     }

osu.Game.Rulesets.Catch/Skinning/Argon/ArgonBananaPiece.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
@@ -110,7 +111,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Argon
 
             double duration = ObjectState.HitObject.StartTime - ObjectState.DisplayStartTime;
 
-            fadeContent.Alpha = MathHelper.Clamp(
+            fadeContent.Alpha = Math.Clamp(
                 Interpolation.ValueAt(
                     Time.Current, 1f, 0f,
                     ObjectState.DisplayStartTime + duration * lens_flare_start,

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

@@ -4,6 +4,7 @@
 using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Game.Screens.Play.HUD;
 using osu.Game.Skinning;
 using osuTK;
 using osuTK.Graphics;
@@ -47,6 +48,8 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
                             return new DefaultSkinComponentsContainer(container =>
                             {
                                 var keyCounter = container.OfType<LegacyKeyCounterDisplay>().FirstOrDefault();
+                                var spectatorList = container.OfType<SpectatorList>().FirstOrDefault();
+                                var leaderboard = container.OfType<DrawableGameplayLeaderboard>().FirstOrDefault();
 
                                 if (keyCounter != null)
                                 {
@@ -55,11 +58,27 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
                                     keyCounter.Origin = Anchor.TopRight;
                                     keyCounter.Position = new Vector2(0, -40) * 1.6f;
                                 }
+
+                                if (spectatorList != null)
+                                {
+                                    spectatorList.Anchor = Anchor.BottomLeft;
+                                    spectatorList.Origin = Anchor.BottomLeft;
+                                    spectatorList.Position = new Vector2(10, -10);
+                                }
+
+                                if (leaderboard != null)
+                                {
+                                    leaderboard.Anchor = Anchor.CentreLeft;
+                                    leaderboard.Origin = Anchor.CentreLeft;
+                                    leaderboard.X = 10;
+                                }
                             })
                             {
                                 Children = new Drawable[]
                                 {
                                     new LegacyKeyCounterDisplay(),
+                                    new SpectatorList(),
+                                    new DrawableGameplayLeaderboard(),
                                 }
                             };
                     }

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

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.UI;
@@ -15,6 +17,8 @@ namespace osu.Game.Rulesets.Catch.UI
         protected override Container<Drawable> Content => content;
         private readonly Container content;
 
+        private readonly Container scaleContainer;
+
         public CatchPlayfieldAdjustmentContainer()
         {
             const float base_game_width = 1024f;
@@ -26,30 +30,49 @@ namespace osu.Game.Rulesets.Catch.UI
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
 
-            InternalChild = new Container
+            InternalChild = scaleContainer = new Container
             {
-                // This container limits vertical visibility of the playfield to ensure fairness between wide and tall resolutions (i.e. tall resolutions should not see more fruits).
-                // Note that the container still extends across the screen horizontally, so that hit explosions at the sides of the playfield do not get cut off.
-                Name = "Visible area",
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
-                RelativeSizeAxes = Axes.X,
-                Height = base_game_height + extra_bottom_space,
-                Y = extra_bottom_space / 2,
-                Masking = true,
+                RelativeSizeAxes = Axes.Both,
                 Child = new Container
                 {
-                    Name = "Playable area",
-                    Anchor = Anchor.TopCentre,
-                    Origin = Anchor.TopCentre,
-                    // playfields in stable are positioned vertically at three fourths the difference between the playfield height and the window height in stable.
-                    Y = base_game_height * ((1 - playfield_size_adjust) / 4 * 3),
-                    Size = new Vector2(base_game_width, base_game_height) * playfield_size_adjust,
-                    Child = content = new ScalingContainer { RelativeSizeAxes = Axes.Both }
-                },
+                    // This container limits vertical visibility of the playfield to ensure fairness between wide and tall resolutions (i.e. tall resolutions should not see more fruits).
+                    // Note that the container still extends across the screen horizontally, so that hit explosions at the sides of the playfield do not get cut off.
+                    Name = "Visible area",
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.X,
+                    Height = base_game_height + extra_bottom_space,
+                    Y = extra_bottom_space / 2,
+                    Masking = true,
+                    Child = new Container
+                    {
+                        Name = "Playable area",
+                        Anchor = Anchor.TopCentre,
+                        Origin = Anchor.TopCentre,
+                        // playfields in stable are positioned vertically at three fourths the difference between the playfield height and the window height in stable.
+                        Y = base_game_height * ((1 - playfield_size_adjust) / 4 * 3),
+                        Size = new Vector2(base_game_width, base_game_height) * playfield_size_adjust,
+                        Child = content = new ScalingContainer { RelativeSizeAxes = Axes.Both }
+                    },
+                }
             };
         }
 
+        [BackgroundDependencyLoader]
+        private void load(OsuGame? osuGame)
+        {
+            if (osuGame != null)
+            {
+                // on mobile platforms where the base aspect ratio is wider, the catch playfield
+                // needs to be scaled down to remain playable.
+                const float base_aspect_ratio = 1024f / 768f;
+                float aspectRatio = osuGame.ScalingContainerTargetDrawSize.X / osuGame.ScalingContainerTargetDrawSize.Y;
+                scaleContainer.Scale = new Vector2(Math.Min(1, base_aspect_ratio / aspectRatio));
+            }
+        }
+
         /// <summary>
         /// A <see cref="Container"/> which scales its content relative to a target width.
         /// </summary>

osu.Game.Rulesets.Mania.Tests.iOS/AppDelegate.cs

@@ -0,0 +1,15 @@
+// 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 Foundation;
+using osu.Framework.iOS;
+using osu.Game.Tests;
+
+namespace osu.Game.Rulesets.Mania.Tests.iOS
+{
+    [Register("AppDelegate")]
+    public class AppDelegate : GameApplicationDelegate
+    {
+        protected override Framework.Game CreateGame() => new OsuTestBrowser();
+    }
+}

osu.Game.Rulesets.Mania.Tests.iOS/Program.cs

@@ -1,16 +1,15 @@
 // 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.iOS;
-using osu.Game.Tests;
+using UIKit;
 
 namespace osu.Game.Rulesets.Mania.Tests.iOS
 {
-    public static class Application
+    public static class Program
     {
         public static void Main(string[] args)
         {
-            GameApplication.Main(new OsuTestBrowser());
+            UIApplication.Main(args, null, typeof(AppDelegate));
         }
     }
 }

osu.Game.Rulesets.Mania.Tests/Editor/Checks/CheckManiaConcurrentObjectsTest.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.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
+using osu.Game.Rulesets.Mania.Edit.Checks;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Tests.Beatmaps;
+
+namespace osu.Game.Rulesets.Mania.Tests.Editor.Checks
+{
+    [TestFixture]
+    public class CheckManiaConcurrentObjectsTest
+    {
+        private CheckConcurrentObjects check = null!;
+
+        [SetUp]
+        public void Setup()
+        {
+            check = new CheckManiaConcurrentObjects();
+        }
+
+        [Test]
+        public void TestHoldNotesSeparateOnSameColumn()
+        {
+            assertOk(new List<HitObject>
+            {
+                createHoldNote(startTime: 100, endTime: 400.75d, column: 1),
+                createHoldNote(startTime: 500, endTime: 900.75d, column: 1)
+            });
+        }
+
+        [Test]
+        public void TestHoldNotesConcurrentOnDifferentColumns()
+        {
+            assertOk(new List<HitObject>
+            {
+                createHoldNote(startTime: 100, endTime: 400.75d, column: 1),
+                createHoldNote(startTime: 300, endTime: 700.75d, column: 2)
+            });
+        }
+
+        [Test]
+        public void TestHoldNotesConcurrentOnSameColumn()
+        {
+            assertConcurrentSame(new List<HitObject>
+            {
+                createHoldNote(startTime: 100, endTime: 400.75d, column: 1),
+                createHoldNote(startTime: 300, endTime: 700.75d, column: 1)
+            });
+        }
+
+        private void assertOk(List<HitObject> hitobjects)
+        {
+            Assert.That(check.Run(getContext(hitobjects)), Is.Empty);
+        }
+
+        private void assertConcurrentSame(List<HitObject> hitobjects, int count = 1)
+        {
+            var issues = check.Run(getContext(hitobjects)).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(count));
+            Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrentSame));
+        }
+
+        private BeatmapVerifierContext getContext(List<HitObject> hitobjects)
+        {
+            var beatmap = new Beatmap<HitObject> { HitObjects = hitobjects };
+            return new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+        }
+
+        private HoldNote createHoldNote(double startTime, double endTime, int column)
+        {
+            return new HoldNote
+            {
+                StartTime = startTime,
+                EndTime = endTime,
+                Column = column
+            };
+        }
+    }
+}

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

@@ -9,7 +9,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Timing;
-using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.UI;
@@ -23,6 +22,8 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     public abstract partial class ManiaPlacementBlueprintTestScene : PlacementBlueprintTestScene
     {
+        protected sealed override Ruleset CreateRuleset() => new ManiaRuleset();
+
         private readonly Column column;
 
         [Cached(typeof(IReadOnlyList<Mod>))]
@@ -47,12 +48,11 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
             });
         }
 
-        protected override SnapResult SnapForBlueprint(HitObjectPlacementBlueprint blueprint)
+        protected override void UpdatePlacementTimeAndPosition()
         {
             double time = column.TimeAtScreenSpacePosition(InputManager.CurrentState.Mouse.Position);
             var pos = column.ScreenSpacePositionAtTime(time);
-
-            return new SnapResult(pos, time, column);
+            CurrentBlueprint.UpdateTimeAndPosition(pos, time);
         }
 
         protected override Container CreateHitObjectContainer() => new ScrollingTestContainer(ScrollingDirection.Down) { RelativeSizeAxes = Axes.Both };

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

@@ -20,7 +20,6 @@ using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Compose.Components;
 using osu.Game.Tests.Visual;
-using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
@@ -100,10 +99,5 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
         {
             set => InternalChild = value;
         }
-
-        public override SnapResult FindSnappedPositionAndTime(Vector2 screenSpacePosition, SnapType snapType = SnapType.All)
-        {
-            throw new NotImplementedException();
-        }
     }
 }

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

@@ -29,7 +29,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
             {
                 keyCount.Current.Value = 8;
             });
-            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().SingleOrDefault()?.CurrentDialog, Is.InstanceOf<ReloadEditorDialog>);
+            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().SingleOrDefault()?.CurrentDialog, Is.InstanceOf<SaveAndReloadEditorDialog>);
             AddStep("refuse", () => InputManager.Key(Key.Number2));
             AddAssert("key count is 5", () => keyCount.Current.Value, () => Is.EqualTo(5));
 
@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
             {
                 keyCount.Current.Value = 8;
             });
-            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().Single().CurrentDialog, Is.InstanceOf<ReloadEditorDialog>);
+            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().Single().CurrentDialog, Is.InstanceOf<SaveAndReloadEditorDialog>);
             AddStep("acquiesce", () => InputManager.Key(Key.Number1));
             AddUntilStep("beatmap became 8K", () => Game.Beatmap.Value.BeatmapInfo.Difficulty.CircleSize, () => Is.EqualTo(8));
         }

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

@@ -22,9 +22,11 @@ namespace osu.Game.Rulesets.Mania.Tests
 
         [TestCase("basic")]
         [TestCase("zero-length-slider")]
+        [TestCase("mania-specific-spinner")]
         [TestCase("20544")]
         [TestCase("100374")]
         [TestCase("1450162")]
+        [TestCase("4869637")]
         public void Test(string name) => base.Test(name);
 
         protected override IEnumerable<ConvertValue> CreateConvertValue(HitObject hitObject)

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

@@ -0,0 +1,187 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Mods;
+using osu.Game.Screens.Select;
+using osu.Game.Screens.Select.Filter;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [TestFixture]
+    public class ManiaFilterCriteriaTest
+    {
+        [TestCase]
+        public void TestKeysEqualSingleValue()
+        {
+            var criteria = new ManiaFilterCriteria();
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.Equal, "1");
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 4 }),
+                new FilterCriteria
+                {
+                    Mods = [new ManiaModKey1()]
+                }));
+        }
+
+        [TestCase]
+        public void TestKeysEqualMultipleValues()
+        {
+            var criteria = new ManiaFilterCriteria();
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.Equal, "1,3,5,7");
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 4 }),
+                new FilterCriteria
+                {
+                    Mods = [new ManiaModKey1()]
+                }));
+        }
+
+        [TestCase]
+        public void TestKeysNotEqualSingleValue()
+        {
+            var criteria = new ManiaFilterCriteria();
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "1");
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 4 }),
+                new FilterCriteria
+                {
+                    Mods = [new ManiaModKey1()]
+                }));
+        }
+
+        [TestCase]
+        public void TestKeysNotEqualMultipleValues()
+        {
+            var criteria = new ManiaFilterCriteria();
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "1,3,5,7");
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 4 }),
+                new FilterCriteria
+                {
+                    Mods = [new ManiaModKey1()]
+                }));
+        }
+
+        [TestCase]
+        public void TestKeysGreaterOrEqualThan()
+        {
+            var criteria = new ManiaFilterCriteria();
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.GreaterOrEqual, "4");
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 4 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 5 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 3 }),
+                new FilterCriteria
+                {
+                    Mods = [new ManiaModKey7()]
+                }));
+        }
+
+        [TestCase]
+        public void TestFilterIntersection()
+        {
+            var criteria = new ManiaFilterCriteria();
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.Greater, "4");
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "7");
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 4 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 5 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 7 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 9 }),
+                new FilterCriteria()));
+        }
+
+        [TestCase]
+        public void TestInvalidFilters()
+        {
+            var criteria = new ManiaFilterCriteria();
+
+            Assert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.Equal, "some text"));
+            Assert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "4,some text"));
+            Assert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.GreaterOrEqual, "4,5,6"));
+        }
+    }
+}

osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModFadeIn.cs

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
         {
             CreateModTest(new ModTestData
             {
-                Mod = new ManiaModHidden(),
+                Mod = new ManiaModFadeIn(),
                 PassCondition = () => checkCoverage(ManiaModHidden.MIN_COVERAGE)
             });
         }
@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
         {
             CreateModTest(new ModTestData
             {
-                Mod = new ManiaModHidden(),
+                Mod = new ManiaModFadeIn(),
                 PassCondition = () => checkCoverage(ManiaModHidden.MIN_COVERAGE)
             });
 
@@ -48,7 +48,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
         {
             CreateModTest(new ModTestData
             {
-                Mod = new ManiaModHidden(),
+                Mod = new ManiaModFadeIn(),
                 PassCondition = () => checkCoverage(ManiaModHidden.MAX_COVERAGE)
             });
 
@@ -60,7 +60,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
         {
             CreateModTest(new ModTestData
             {
-                Mod = new ManiaModHidden(),
+                Mod = new ManiaModFadeIn(),
                 PassCondition = () => checkCoverage(ManiaModHidden.MAX_COVERAGE)
             });
 
@@ -73,7 +73,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
         {
             CreateModTest(new ModTestData
             {
-                Mod = new ManiaModHidden(),
+                Mod = new ManiaModFadeIn(),
                 CreateBeatmap = () => new Beatmap
                 {
                     HitObjects = Enumerable.Range(1, 100).Select(i => (HitObject)new Note { StartTime = 1000 + 200 * i }).ToList(),

osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModPerfect.cs

@@ -31,9 +31,12 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
         public void TestHoldNote(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new HoldNote { StartTime = 1000, EndTime = 3000 }), shouldMiss);
 
         [Test]
-        public void TestGreatHit() => CreateModTest(new ModTestData
+        public void TestPerfectHits([Values] bool requirePerfectHits) => CreateModTest(new ModTestData
         {
-            Mod = new ManiaModPerfect(),
+            Mod = new ManiaModPerfect
+            {
+                RequirePerfectHits = { Value = requirePerfectHits }
+            },
             PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(false),
             Autoplay = false,
             CreateBeatmap = () => new Beatmap
@@ -47,6 +50,32 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
                 },
             },
             ReplayFrames = new List<ReplayFrame>
+            {
+                new ManiaReplayFrame(1000, ManiaAction.Key1),
+                new ManiaReplayFrame(2000)
+            }
+        });
+
+        [Test]
+        public void TestGreatHit([Values] bool requirePerfectHits) => CreateModTest(new ModTestData
+        {
+            Mod = new ManiaModPerfect
+            {
+                RequirePerfectHits = { Value = requirePerfectHits }
+            },
+            PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(requirePerfectHits),
+            Autoplay = false,
+            CreateBeatmap = () => new Beatmap
+            {
+                HitObjects = new List<HitObject>
+                {
+                    new Note
+                    {
+                        StartTime = 1000,
+                    }
+                },
+            },
+            ReplayFrames = new List<ReplayFrame>
             {
                 new ManiaReplayFrame(1020, ManiaAction.Key1),
                 new ManiaReplayFrame(2000)

osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/mania-specific-spinner-expected-conversion.json

@@ -0,0 +1,60 @@
+{
+  "Mappings": [
+    {
+      "RandomW": 273071671,
+      "RandomX": 842502087,
+      "RandomY": 3579807591,
+      "RandomZ": 273326509,
+      "StartTime": 11783.0,
+      "Objects": [
+        {
+          "StartTime": 11783.0,
+          "EndTime": 15116.0,
+          "Column": 0
+        }
+      ]
+    },
+    {
+      "RandomW": 2659271247,
+      "RandomX": 3579807591,
+      "RandomY": 273326509,
+      "RandomZ": 273071671,
+      "StartTime": 91545.0,
+      "Objects": [
+        {
+          "StartTime": 91545.0,
+          "EndTime": 92735.0,
+          "Column": 0
+        }
+      ]
+    },
+    {
+      "RandomW": 3083635271,
+      "RandomX": 273326509,
+      "RandomY": 273071671,
+      "RandomZ": 2659271247,
+      "StartTime": 152497.0,
+      "Objects": [
+        {
+          "StartTime": 152497.0,
+          "EndTime": 153687.0,
+          "Column": 1
+        }
+      ]
+    },
+    {
+      "RandomW": 4073591514,
+      "RandomX": 273071671,
+      "RandomY": 2659271247,
+      "RandomZ": 3083635271,
+      "StartTime": 231545.0,
+      "Objects": [
+        {
+          "StartTime": 231545.0,
+          "EndTime": 232974.0,
+          "Column": 3
+        }
+      ]
+    }
+  ]
+}

osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/mania-specific-spinner.osu

@@ -0,0 +1,27 @@
+osu file format v14
+
+[General]
+Mode: 3
+
+[Difficulty]
+HPDrainRate:5
+CircleSize:4
+OverallDifficulty:5
+ApproachRate:0
+SliderMultiplier:2.6
+SliderTickRate:1
+
+[TimingPoints]
+355,476.190476190476,4,2,1,60,1,0
+60652,-100,4,2,1,60,0,1
+92735,-100,4,2,1,60,0,0
+121485,-100,4,2,1,60,0,1
+153688,-100,4,2,1,60,0,0
+182497,-100,4,2,1,60,0,1
+213688,-100,4,2,1,60,0,0
+
+[HitObjects]
+256,192,11783,12,0,15116,0:0:0:0:
+256,192,91545,12,0,92735,0:0:0:0:
+256,192,152497,12,0,153687,0:0:0:0:
+256,192,231545,12,0,232974,0:0:0:0:

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

@@ -28,18 +28,20 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
                     {
                         RelativeSizeAxes = Axes.Both,
                         Width = 0.5f,
-                        Child = new ColumnHitObjectArea(new HitObjectContainer())
+                        Child = new ColumnHitObjectArea
                         {
-                            RelativeSizeAxes = Axes.Both
+                            RelativeSizeAxes = Axes.Both,
+                            Child = new HitObjectContainer(),
                         }
                     },
                     new ColumnTestContainer(1, ManiaAction.Key2)
                     {
                         RelativeSizeAxes = Axes.Both,
                         Width = 0.5f,
-                        Child = new ColumnHitObjectArea(new HitObjectContainer())
+                        Child = new ColumnHitObjectArea
                         {
-                            RelativeSizeAxes = Axes.Both
+                            RelativeSizeAxes = Axes.Both,
+                            Child = new HitObjectContainer(),
                         }
                     }
                 }

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

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
             {
                 foreach (var holdNote in CreatedDrawables.SelectMany(d => d.ChildrenOfType<DrawableHoldNote>()))
                 {
-                    ((Bindable<bool>)holdNote.IsHitting).Value = v;
+                    ((Bindable<bool>)holdNote.IsHolding).Value = v;
                 }
             });
         }

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

@@ -0,0 +1,758 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Mods;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Replays;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
+    public partial class TestSceneLegacyReplayPlayback : LegacyReplayPlaybackTestScene
+    {
+        protected override Ruleset CreateRuleset() => new ManiaRuleset();
+
+        protected override string? ExportLocation => null;
+
+        private static readonly object[][] score_v2_test_cases =
+        {
+            // With respect to notation,
+            // square brackets `[]` represent *closed* or *inclusive* bounds,
+            // while round brackets `()` represent *open* or *exclusive* bounds.
+
+            // Note that mania hitwindows are heavily idiosyncratic,
+            // and if you *think* a number here is wrong, probably double check.
+
+            // Known issues / complexities:
+            // - There is a disparate set of hitwindow ranges for: score V1 non-converts, score V1 converts, and score V2 (regardless of convert)
+            // - It is NEVER POSSIBLE to get a MEH result when late; exceeding the OK hit windows will result in a MISS.
+            //   Additionally, the OK hit window when late is EXCLUSIVE / OPEN rather than INCLUSIVE / CLOSED.
+            //   Relevant stable source: https://github.com/peppy/osu-stable-reference/blob/996648fba06baf4e7d2e0b248959399444017895/osu!/GameplayElements/HitObjectManagerMania.cs#L737-L751
+            // - There is also a seemingly mania-specific issue wherein key inputs registered before time instant 0 get truncated to time 0,
+            //   which is why the beatmaps used below make sure not to cross that boundary (the note starts at t=300ms).
+            //   This is not an issue in osu! or taiko.
+            //   The source of this behaviour has not been investigated in detail.
+
+            // OD = 5 test cases.
+            // PERFECT hit window is [ -19ms,  19ms]
+            // GREAT   hit window is [ -49ms,  49ms]
+            // GOOD    hit window is [ -82ms,  82ms]
+            // OK      hit window is [-112ms, 112ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-136ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 5f, -18d, HitResult.Perfect },
+            new object[] { 5f, -19d, HitResult.Perfect },
+            new object[] { 5f, -20d, HitResult.Great },
+            new object[] { 5f, -21d, HitResult.Great },
+            new object[] { 5f, -48d, HitResult.Great },
+            new object[] { 5f, -49d, HitResult.Great },
+            new object[] { 5f, -50d, HitResult.Good },
+            new object[] { 5f, -51d, HitResult.Good },
+            new object[] { 5f, -81d, HitResult.Good },
+            new object[] { 5f, -82d, HitResult.Good },
+            new object[] { 5f, -83d, HitResult.Ok },
+            new object[] { 5f, -84d, HitResult.Ok },
+            new object[] { 5f, -111d, HitResult.Ok },
+            new object[] { 5f, -112d, HitResult.Ok },
+            new object[] { 5f, -113d, HitResult.Meh },
+            new object[] { 5f, -114d, HitResult.Meh },
+            new object[] { 5f, -135d, HitResult.Meh },
+            new object[] { 5f, -136d, HitResult.Meh },
+            new object[] { 5f, -137d, HitResult.Miss },
+            new object[] { 5f, -138d, HitResult.Miss },
+            new object[] { 5f, 111d, HitResult.Ok },
+            new object[] { 5f, 112d, HitResult.Miss },
+            new object[] { 5f, 113d, HitResult.Miss },
+            new object[] { 5f, 114d, HitResult.Miss },
+            new object[] { 5f, 135d, HitResult.Miss },
+            new object[] { 5f, 136d, HitResult.Miss },
+            new object[] { 5f, 137d, HitResult.Miss },
+            new object[] { 5f, 138d, HitResult.Miss },
+
+            // OD = 9.3 test cases.
+            // PERFECT hit window is [ -14ms,  14ms]
+            // GREAT   hit window is [ -36ms,  36ms]
+            // GOOD    hit window is [ -69ms,  69ms]
+            // OK      hit window is [ -99ms,  99ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-123ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 9.3f, 13d, HitResult.Perfect },
+            new object[] { 9.3f, 14d, HitResult.Perfect },
+            new object[] { 9.3f, 15d, HitResult.Great },
+            new object[] { 9.3f, 16d, HitResult.Great },
+            new object[] { 9.3f, 35d, HitResult.Great },
+            new object[] { 9.3f, 36d, HitResult.Great },
+            new object[] { 9.3f, 37d, HitResult.Good },
+            new object[] { 9.3f, 38d, HitResult.Good },
+            new object[] { 9.3f, 68d, HitResult.Good },
+            new object[] { 9.3f, 69d, HitResult.Good },
+            new object[] { 9.3f, 70d, HitResult.Ok },
+            new object[] { 9.3f, 71d, HitResult.Ok },
+            new object[] { 9.3f, 98d, HitResult.Ok },
+            new object[] { 9.3f, 99d, HitResult.Miss },
+            new object[] { 9.3f, 100d, HitResult.Miss },
+            new object[] { 9.3f, 101d, HitResult.Miss },
+            new object[] { 9.3f, 122d, HitResult.Miss },
+            new object[] { 9.3f, 123d, HitResult.Miss },
+            new object[] { 9.3f, 124d, HitResult.Miss },
+            new object[] { 9.3f, 125d, HitResult.Miss },
+            new object[] { 9.3f, -98d, HitResult.Ok },
+            new object[] { 9.3f, -99d, HitResult.Ok },
+            new object[] { 9.3f, -100d, HitResult.Meh },
+            new object[] { 9.3f, -101d, HitResult.Meh },
+            new object[] { 9.3f, -122d, HitResult.Meh },
+            new object[] { 9.3f, -123d, HitResult.Meh },
+            new object[] { 9.3f, -124d, HitResult.Miss },
+            new object[] { 9.3f, -125d, HitResult.Miss },
+        };
+
+        private static readonly object[][] score_v1_non_convert_test_cases =
+        {
+            // OD = 5 test cases.
+            // PERFECT hit window is [ -16ms,  16ms]
+            // GREAT   hit window is [ -49ms,  49ms]
+            // GOOD    hit window is [ -82ms,  82ms]
+            // OK      hit window is [-112ms, 112ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-136ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 5f, -15d, HitResult.Perfect },
+            new object[] { 5f, -16d, HitResult.Perfect },
+            new object[] { 5f, -17d, HitResult.Great },
+            new object[] { 5f, -18d, HitResult.Great },
+            new object[] { 5f, -48d, HitResult.Great },
+            new object[] { 5f, -49d, HitResult.Great },
+            new object[] { 5f, -50d, HitResult.Good },
+            new object[] { 5f, -51d, HitResult.Good },
+            new object[] { 5f, -81d, HitResult.Good },
+            new object[] { 5f, -82d, HitResult.Good },
+            new object[] { 5f, -83d, HitResult.Ok },
+            new object[] { 5f, -84d, HitResult.Ok },
+            new object[] { 5f, -111d, HitResult.Ok },
+            new object[] { 5f, -112d, HitResult.Ok },
+            new object[] { 5f, -113d, HitResult.Meh },
+            new object[] { 5f, -114d, HitResult.Meh },
+            new object[] { 5f, -135d, HitResult.Meh },
+            new object[] { 5f, -136d, HitResult.Meh },
+            new object[] { 5f, -137d, HitResult.Miss },
+            new object[] { 5f, -138d, HitResult.Miss },
+            new object[] { 5f, 111d, HitResult.Ok },
+            new object[] { 5f, 112d, HitResult.Miss },
+            new object[] { 5f, 113d, HitResult.Miss },
+            new object[] { 5f, 114d, HitResult.Miss },
+            new object[] { 5f, 135d, HitResult.Miss },
+            new object[] { 5f, 136d, HitResult.Miss },
+            new object[] { 5f, 137d, HitResult.Miss },
+            new object[] { 5f, 138d, HitResult.Miss },
+
+            // OD = 9.3 test cases.
+            // PERFECT hit window is [ -16ms,  16ms]
+            // GREAT   hit window is [ -36ms,  36ms]
+            // GOOD    hit window is [ -69ms,  69ms]
+            // OK      hit window is [ -99ms,  99ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-123ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 9.3f, 15d, HitResult.Perfect },
+            new object[] { 9.3f, 16d, HitResult.Perfect },
+            new object[] { 9.3f, 17d, HitResult.Great },
+            new object[] { 9.3f, 18d, HitResult.Great },
+            new object[] { 9.3f, 35d, HitResult.Great },
+            new object[] { 9.3f, 36d, HitResult.Great },
+            new object[] { 9.3f, 37d, HitResult.Good },
+            new object[] { 9.3f, 38d, HitResult.Good },
+            new object[] { 9.3f, 68d, HitResult.Good },
+            new object[] { 9.3f, 69d, HitResult.Good },
+            new object[] { 9.3f, 70d, HitResult.Ok },
+            new object[] { 9.3f, 71d, HitResult.Ok },
+            new object[] { 9.3f, 98d, HitResult.Ok },
+            new object[] { 9.3f, 99d, HitResult.Miss },
+            new object[] { 9.3f, 100d, HitResult.Miss },
+            new object[] { 9.3f, 101d, HitResult.Miss },
+            new object[] { 9.3f, 122d, HitResult.Miss },
+            new object[] { 9.3f, 123d, HitResult.Miss },
+            new object[] { 9.3f, 124d, HitResult.Miss },
+            new object[] { 9.3f, 125d, HitResult.Miss },
+            new object[] { 9.3f, -98d, HitResult.Ok },
+            new object[] { 9.3f, -99d, HitResult.Ok },
+            new object[] { 9.3f, -100d, HitResult.Meh },
+            new object[] { 9.3f, -101d, HitResult.Meh },
+            new object[] { 9.3f, -122d, HitResult.Meh },
+            new object[] { 9.3f, -123d, HitResult.Meh },
+            new object[] { 9.3f, -124d, HitResult.Miss },
+            new object[] { 9.3f, -125d, HitResult.Miss },
+
+            // OD = 3.1 test cases.
+            // PERFECT hit window is [ -16ms,  16ms]
+            // GREAT   hit window is [ -54ms,  54ms]
+            // GOOD    hit window is [ -87ms,  87ms]
+            // OK      hit window is [-117ms, 117ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-141ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 3.1f, 15d, HitResult.Perfect },
+            new object[] { 3.1f, 16d, HitResult.Perfect },
+            new object[] { 3.1f, 17d, HitResult.Great },
+            new object[] { 3.1f, 18d, HitResult.Great },
+            new object[] { 3.1f, 53d, HitResult.Great },
+            new object[] { 3.1f, 54d, HitResult.Great },
+            new object[] { 3.1f, 55d, HitResult.Good },
+            new object[] { 3.1f, 56d, HitResult.Good },
+            new object[] { 3.1f, 86d, HitResult.Good },
+            new object[] { 3.1f, 87d, HitResult.Good },
+            new object[] { 3.1f, 88d, HitResult.Ok },
+            new object[] { 3.1f, 89d, HitResult.Ok },
+            new object[] { 3.1f, 116d, HitResult.Ok },
+            new object[] { 3.1f, 117d, HitResult.Miss },
+            new object[] { 3.1f, 118d, HitResult.Miss },
+            new object[] { 3.1f, 119d, HitResult.Miss },
+            new object[] { 3.1f, 140d, HitResult.Miss },
+            new object[] { 3.1f, 141d, HitResult.Miss },
+            new object[] { 3.1f, 142d, HitResult.Miss },
+            new object[] { 3.1f, 143d, HitResult.Miss },
+            new object[] { 3.1f, -116d, HitResult.Ok },
+            new object[] { 3.1f, -117d, HitResult.Ok },
+            new object[] { 3.1f, -118d, HitResult.Meh },
+            new object[] { 3.1f, -119d, HitResult.Meh },
+            new object[] { 3.1f, -140d, HitResult.Meh },
+            new object[] { 3.1f, -141d, HitResult.Meh },
+            new object[] { 3.1f, -142d, HitResult.Miss },
+            new object[] { 3.1f, -143d, HitResult.Miss },
+        };
+
+        private static readonly object[][] score_v1_convert_test_cases =
+        {
+            // OD = 5 test cases.
+            // PERFECT hit window is [ -16ms,  16ms]
+            // GREAT   hit window is [ -34ms,  34ms]
+            // GOOD    hit window is [ -67ms,  67ms]
+            // OK      hit window is [ -97ms,  97ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-121ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 5f, -15d, HitResult.Perfect },
+            new object[] { 5f, -16d, HitResult.Perfect },
+            new object[] { 5f, -17d, HitResult.Great },
+            new object[] { 5f, -18d, HitResult.Great },
+            new object[] { 5f, -33d, HitResult.Great },
+            new object[] { 5f, -34d, HitResult.Great },
+            new object[] { 5f, -35d, HitResult.Good },
+            new object[] { 5f, -36d, HitResult.Good },
+            new object[] { 5f, -66d, HitResult.Good },
+            new object[] { 5f, -67d, HitResult.Good },
+            new object[] { 5f, -68d, HitResult.Ok },
+            new object[] { 5f, -69d, HitResult.Ok },
+            new object[] { 5f, -96d, HitResult.Ok },
+            new object[] { 5f, -97d, HitResult.Ok },
+            new object[] { 5f, -98d, HitResult.Meh },
+            new object[] { 5f, -99d, HitResult.Meh },
+            new object[] { 5f, -120d, HitResult.Meh },
+            new object[] { 5f, -121d, HitResult.Meh },
+            new object[] { 5f, -122d, HitResult.Miss },
+            new object[] { 5f, -123d, HitResult.Miss },
+            new object[] { 5f, 96d, HitResult.Ok },
+            new object[] { 5f, 97d, HitResult.Miss },
+            new object[] { 5f, 98d, HitResult.Miss },
+            new object[] { 5f, 99d, HitResult.Miss },
+            new object[] { 5f, 120d, HitResult.Miss },
+            new object[] { 5f, 121d, HitResult.Miss },
+            new object[] { 5f, 122d, HitResult.Miss },
+            new object[] { 5f, 123d, HitResult.Miss },
+
+            // OD = 3.1 test cases.
+            // PERFECT hit window is [ -16ms,  16ms]
+            // GREAT   hit window is [ -47ms,  47ms]
+            // GOOD    hit window is [ -77ms,  77ms]
+            // OK      hit window is [ -97ms,  97ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-121ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 3.1f, 15d, HitResult.Perfect },
+            new object[] { 3.1f, 16d, HitResult.Perfect },
+            new object[] { 3.1f, 17d, HitResult.Great },
+            new object[] { 3.1f, 18d, HitResult.Great },
+            new object[] { 3.1f, 46d, HitResult.Great },
+            new object[] { 3.1f, 47d, HitResult.Great },
+            new object[] { 3.1f, 48d, HitResult.Good },
+            new object[] { 3.1f, 49d, HitResult.Good },
+            new object[] { 3.1f, 76d, HitResult.Good },
+            new object[] { 3.1f, 77d, HitResult.Good },
+            new object[] { 3.1f, 78d, HitResult.Ok },
+            new object[] { 3.1f, 79d, HitResult.Ok },
+            new object[] { 3.1f, 96d, HitResult.Ok },
+            new object[] { 3.1f, 97d, HitResult.Miss },
+            new object[] { 3.1f, 98d, HitResult.Miss },
+            new object[] { 3.1f, 99d, HitResult.Miss },
+            new object[] { 3.1f, 120d, HitResult.Miss },
+            new object[] { 3.1f, 121d, HitResult.Miss },
+            new object[] { 3.1f, 122d, HitResult.Miss },
+            new object[] { 3.1f, 123d, HitResult.Miss },
+            new object[] { 3.1f, -96d, HitResult.Ok },
+            new object[] { 3.1f, -97d, HitResult.Ok },
+            new object[] { 3.1f, -98d, HitResult.Meh },
+            new object[] { 3.1f, -99d, HitResult.Meh },
+            new object[] { 3.1f, -120d, HitResult.Meh },
+            new object[] { 3.1f, -121d, HitResult.Meh },
+            new object[] { 3.1f, -122d, HitResult.Miss },
+            new object[] { 3.1f, -123d, HitResult.Miss },
+        };
+
+        private static readonly object[][] score_v1_non_convert_hard_rock_test_cases =
+        {
+            // OD = 5 test cases.
+            // This leads to "effective" OD of 7.
+            // PERFECT hit window is [-11ms, 11ms]
+            // GREAT   hit window is [-35ms, 35ms]
+            // GOOD    hit window is [-58ms, 58ms]
+            // OK      hit window is [-80ms, 80ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-97ms, ----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 5f, -10d, HitResult.Perfect },
+            new object[] { 5f, -11d, HitResult.Perfect },
+            new object[] { 5f, -12d, HitResult.Great },
+            new object[] { 5f, -13d, HitResult.Great },
+            new object[] { 5f, -34d, HitResult.Great },
+            new object[] { 5f, -35d, HitResult.Great },
+            new object[] { 5f, -36d, HitResult.Good },
+            new object[] { 5f, -37d, HitResult.Good },
+            new object[] { 5f, -57d, HitResult.Good },
+            new object[] { 5f, -58d, HitResult.Good },
+            new object[] { 5f, -59d, HitResult.Ok },
+            new object[] { 5f, -60d, HitResult.Ok },
+            new object[] { 5f, -79d, HitResult.Ok },
+            new object[] { 5f, -80d, HitResult.Ok },
+            new object[] { 5f, -81d, HitResult.Meh },
+            new object[] { 5f, -82d, HitResult.Meh },
+            new object[] { 5f, -96d, HitResult.Meh },
+            new object[] { 5f, -97d, HitResult.Meh },
+            new object[] { 5f, -98d, HitResult.Miss },
+            new object[] { 5f, -99d, HitResult.Miss },
+            new object[] { 5f, 79d, HitResult.Ok },
+            new object[] { 5f, 80d, HitResult.Miss },
+            new object[] { 5f, 81d, HitResult.Miss },
+            new object[] { 5f, 82d, HitResult.Miss },
+            new object[] { 5f, 96d, HitResult.Miss },
+            new object[] { 5f, 97d, HitResult.Miss },
+            new object[] { 5f, 98d, HitResult.Miss },
+            new object[] { 5f, 99d, HitResult.Miss },
+
+            // OD = 9.3 test cases.
+            // This leads to "effective" OD of 13.02.
+            // Note that contrary to other rulesets this does NOT cap out to OD 10!
+            // PERFECT hit window is [-11ms, 11ms]
+            // GREAT   hit window is [-25ms, 25ms]
+            // GOOD    hit window is [-49ms, 49ms]
+            // OK      hit window is [-70ms, 70ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-87ms, ----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 9.3f, 10d, HitResult.Perfect },
+            new object[] { 9.3f, 11d, HitResult.Perfect },
+            new object[] { 9.3f, 12d, HitResult.Great },
+            new object[] { 9.3f, 13d, HitResult.Great },
+            new object[] { 9.3f, 24d, HitResult.Great },
+            new object[] { 9.3f, 25d, HitResult.Great },
+            new object[] { 9.3f, 26d, HitResult.Good },
+            new object[] { 9.3f, 27d, HitResult.Good },
+            new object[] { 9.3f, 48d, HitResult.Good },
+            new object[] { 9.3f, 49d, HitResult.Good },
+            new object[] { 9.3f, 50d, HitResult.Ok },
+            new object[] { 9.3f, 51d, HitResult.Ok },
+            new object[] { 9.3f, 69d, HitResult.Ok },
+            new object[] { 9.3f, 70d, HitResult.Miss },
+            new object[] { 9.3f, 71d, HitResult.Miss },
+            new object[] { 9.3f, 72d, HitResult.Miss },
+            new object[] { 9.3f, 86d, HitResult.Miss },
+            new object[] { 9.3f, 87d, HitResult.Miss },
+            new object[] { 9.3f, 88d, HitResult.Miss },
+            new object[] { 9.3f, 89d, HitResult.Miss },
+            new object[] { 9.3f, -69d, HitResult.Ok },
+            new object[] { 9.3f, -70d, HitResult.Ok },
+            new object[] { 9.3f, -71d, HitResult.Meh },
+            new object[] { 9.3f, -72d, HitResult.Meh },
+            new object[] { 9.3f, -86d, HitResult.Meh },
+            new object[] { 9.3f, -87d, HitResult.Meh },
+            new object[] { 9.3f, -88d, HitResult.Miss },
+            new object[] { 9.3f, -89d, HitResult.Miss },
+        };
+
+        private static readonly object[][] score_v1_non_convert_easy_test_cases =
+        {
+            // Assume OD = 5 (other values are not tested, even OD 5 is enough to exercise the flooring logic).
+            // PERFECT hit window is [ -22ms,  22ms]
+            // GREAT   hit window is [ -68ms,  68ms]
+            // GOOD    hit window is [-114ms, 114ms]
+            // OK      hit window is [-156ms, 156ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-190ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 5f, -21d, HitResult.Perfect },
+            new object[] { 5f, -22d, HitResult.Perfect },
+            new object[] { 5f, -23d, HitResult.Great },
+            new object[] { 5f, -24d, HitResult.Great },
+            new object[] { 5f, -67d, HitResult.Great },
+            new object[] { 5f, -68d, HitResult.Great },
+            new object[] { 5f, -69d, HitResult.Good },
+            new object[] { 5f, -70d, HitResult.Good },
+            new object[] { 5f, -113d, HitResult.Good },
+            new object[] { 5f, -114d, HitResult.Good },
+            new object[] { 5f, -115d, HitResult.Ok },
+            new object[] { 5f, -116d, HitResult.Ok },
+            new object[] { 5f, -155d, HitResult.Ok },
+            new object[] { 5f, -156d, HitResult.Ok },
+            new object[] { 5f, -157d, HitResult.Meh },
+            new object[] { 5f, -158d, HitResult.Meh },
+            new object[] { 5f, -189d, HitResult.Meh },
+            new object[] { 5f, -190d, HitResult.Meh },
+            new object[] { 5f, -191d, HitResult.Miss },
+            new object[] { 5f, -192d, HitResult.Miss },
+            new object[] { 5f, 155d, HitResult.Ok },
+            new object[] { 5f, 156d, HitResult.Miss },
+            new object[] { 5f, 157d, HitResult.Miss },
+            new object[] { 5f, 158d, HitResult.Miss },
+            new object[] { 5f, 189d, HitResult.Miss },
+            new object[] { 5f, 190d, HitResult.Miss },
+            new object[] { 5f, 191d, HitResult.Miss },
+            new object[] { 5f, 192d, HitResult.Miss },
+        };
+
+        private static readonly object[][] score_v1_non_convert_double_time_test_cases =
+        {
+            // Assume OD = 5 (other values are not tested, even OD 5 is enough to exercise the flooring logic).
+            // PERFECT hit window is [ -24ms,  24ms]
+            // GREAT   hit window is [ -73ms,  73ms]
+            // GOOD    hit window is [-123ms, 123ms]
+            // OK      hit window is [-168ms, 168ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-204ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 5f, -23d, HitResult.Perfect },
+            new object[] { 5f, -24d, HitResult.Perfect },
+            new object[] { 5f, -25d, HitResult.Great },
+            new object[] { 5f, -26d, HitResult.Great },
+            new object[] { 5f, -72d, HitResult.Great },
+            new object[] { 5f, -73d, HitResult.Great },
+            new object[] { 5f, -74d, HitResult.Good },
+            new object[] { 5f, -75d, HitResult.Good },
+            new object[] { 5f, -122d, HitResult.Good },
+            new object[] { 5f, -123d, HitResult.Good },
+            new object[] { 5f, -124d, HitResult.Ok },
+            new object[] { 5f, -125d, HitResult.Ok },
+            new object[] { 5f, -167d, HitResult.Ok },
+            new object[] { 5f, -168d, HitResult.Ok },
+            new object[] { 5f, -169d, HitResult.Meh },
+            new object[] { 5f, -170d, HitResult.Meh },
+            new object[] { 5f, -203d, HitResult.Meh },
+            new object[] { 5f, -204d, HitResult.Meh },
+            new object[] { 5f, -205d, HitResult.Miss },
+            new object[] { 5f, -206d, HitResult.Miss },
+            new object[] { 5f, 167d, HitResult.Ok },
+            new object[] { 5f, 168d, HitResult.Miss },
+            new object[] { 5f, 169d, HitResult.Miss },
+            new object[] { 5f, 170d, HitResult.Miss },
+            new object[] { 5f, 203d, HitResult.Miss },
+            new object[] { 5f, 204d, HitResult.Miss },
+            new object[] { 5f, 205d, HitResult.Miss },
+            new object[] { 5f, 206d, HitResult.Miss },
+        };
+
+        private static readonly object[][] score_v1_non_convert_half_time_test_cases =
+        {
+            // Assume OD = 5 (other values are not tested, even OD 5 is enough to exercise the flooring logic).
+            // PERFECT hit window is [ -12ms,  12ms]
+            // GREAT   hit window is [ -36ms,  36ms]
+            // GOOD    hit window is [ -61ms,  61ms]
+            // OK      hit window is [ -84ms,  84ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-102ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 5f, -11d, HitResult.Perfect },
+            new object[] { 5f, -12d, HitResult.Perfect },
+            new object[] { 5f, -13d, HitResult.Great },
+            new object[] { 5f, -14d, HitResult.Great },
+            new object[] { 5f, -35d, HitResult.Great },
+            new object[] { 5f, -36d, HitResult.Great },
+            new object[] { 5f, -37d, HitResult.Good },
+            new object[] { 5f, -38d, HitResult.Good },
+            new object[] { 5f, -60d, HitResult.Good },
+            new object[] { 5f, -61d, HitResult.Good },
+            new object[] { 5f, -62d, HitResult.Ok },
+            new object[] { 5f, -63d, HitResult.Ok },
+            new object[] { 5f, -83d, HitResult.Ok },
+            new object[] { 5f, -84d, HitResult.Ok },
+            new object[] { 5f, -85d, HitResult.Meh },
+            new object[] { 5f, -86d, HitResult.Meh },
+            new object[] { 5f, -101d, HitResult.Meh },
+            new object[] { 5f, -102d, HitResult.Meh },
+            new object[] { 5f, -103d, HitResult.Miss },
+            new object[] { 5f, -104d, HitResult.Miss },
+            new object[] { 5f, 83d, HitResult.Ok },
+            new object[] { 5f, 84d, HitResult.Miss },
+            new object[] { 5f, 85d, HitResult.Miss },
+            new object[] { 5f, 86d, HitResult.Miss },
+            new object[] { 5f, 101d, HitResult.Miss },
+            new object[] { 5f, 102d, HitResult.Miss },
+            new object[] { 5f, 103d, HitResult.Miss },
+            new object[] { 5f, 104d, HitResult.Miss },
+        };
+
+        private const double note_time = 300;
+
+        [TestCaseSource(nameof(score_v2_test_cases))]
+        public void TestHitWindowTreatmentWithScoreV2(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            var beatmap = createNonConvertBeatmap(overallDifficulty);
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new ManiaReplayFrame(0),
+                    new ManiaReplayFrame(note_time + hitOffset, ManiaAction.Key1),
+                    new ManiaReplayFrame(note_time + hitOffset + 20),
+                }
+            };
+
+            var score = new Score
+            {
+                Replay = replay,
+                ScoreInfo = new ScoreInfo
+                {
+                    Ruleset = CreateRuleset().RulesetInfo,
+                    Mods = [new ModScoreV2()]
+                }
+            };
+
+            RunTest($@"SV2 single note @ OD{overallDifficulty}", beatmap, $@"SV2 {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        [TestCaseSource(nameof(score_v1_non_convert_test_cases))]
+        public void TestHitWindowTreatmentWithScoreV1NonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            var beatmap = createNonConvertBeatmap(overallDifficulty);
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new ManiaReplayFrame(0),
+                    new ManiaReplayFrame(note_time + hitOffset, ManiaAction.Key1),
+                    new ManiaReplayFrame(note_time + hitOffset + 20),
+                }
+            };
+
+            var score = new Score
+            {
+                Replay = replay,
+                ScoreInfo = new ScoreInfo
+                {
+                    Ruleset = CreateRuleset().RulesetInfo,
+                }
+            };
+
+            RunTest($@"SV1 single note @ OD{overallDifficulty}", beatmap, $@"SV1 {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        [TestCaseSource(nameof(score_v1_convert_test_cases))]
+        public void TestHitWindowTreatmentWithScoreV1Convert(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            var beatmap = createConvertBeatmap(overallDifficulty);
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new ManiaReplayFrame(0),
+                    new ManiaReplayFrame(note_time + hitOffset, ManiaAction.Key1),
+                    new ManiaReplayFrame(note_time + hitOffset + 20),
+                }
+            };
+
+            var score = new Score
+            {
+                Replay = replay,
+                ScoreInfo = new ScoreInfo
+                {
+                    Ruleset = CreateRuleset().RulesetInfo,
+                    Mods = [new ManiaModKey1()],
+                }
+            };
+
+            RunTest($@"SV1 convert single note @ OD{overallDifficulty}", beatmap, $@"SV1 convert {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        [TestCaseSource(nameof(score_v1_non_convert_hard_rock_test_cases))]
+        public void TestHitWindowTreatmentWithScoreV1AndHardRockNonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            var beatmap = createNonConvertBeatmap(overallDifficulty);
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new ManiaReplayFrame(0),
+                    new ManiaReplayFrame(note_time + hitOffset, ManiaAction.Key1),
+                    new ManiaReplayFrame(note_time + hitOffset + 20),
+                }
+            };
+
+            var score = new Score
+            {
+                Replay = replay,
+                ScoreInfo = new ScoreInfo
+                {
+                    Ruleset = CreateRuleset().RulesetInfo,
+                    Mods = [new ManiaModHardRock()],
+                }
+            };
+
+            RunTest($@"SV1+HR single note @ OD{overallDifficulty}", beatmap, $@"SV1+HR {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        [TestCaseSource(nameof(score_v1_non_convert_easy_test_cases))]
+        public void TestHitWindowTreatmentWithScoreV1AndEasyNonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            var beatmap = createNonConvertBeatmap(overallDifficulty);
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new ManiaReplayFrame(0),
+                    new ManiaReplayFrame(note_time + hitOffset, ManiaAction.Key1),
+                    new ManiaReplayFrame(note_time + hitOffset + 20),
+                }
+            };
+
+            var score = new Score
+            {
+                Replay = replay,
+                ScoreInfo = new ScoreInfo
+                {
+                    Ruleset = CreateRuleset().RulesetInfo,
+                    Mods = [new ManiaModEasy()],
+                }
+            };
+
+            RunTest($@"SV1+EZ single note @ OD{overallDifficulty}", beatmap, $@"SV1+EZ {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        [TestCaseSource(nameof(score_v1_non_convert_double_time_test_cases))]
+        public void TestHitWindowTreatmentWithScoreV1AndDoubleTimeNonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            var beatmap = createNonConvertBeatmap(overallDifficulty);
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new ManiaReplayFrame(0),
+                    new ManiaReplayFrame(note_time + hitOffset, ManiaAction.Key1),
+                    new ManiaReplayFrame(note_time + hitOffset + 20),
+                }
+            };
+
+            var score = new Score
+            {
+                Replay = replay,
+                ScoreInfo = new ScoreInfo
+                {
+                    Ruleset = CreateRuleset().RulesetInfo,
+                    Mods = [new ManiaModDoubleTime()],
+                }
+            };
+
+            RunTest($@"SV1+DT single note @ OD{overallDifficulty}", beatmap, $@"SV1+DT {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        [TestCaseSource(nameof(score_v1_non_convert_half_time_test_cases))]
+        public void TestHitWindowTreatmentWithScoreV1AndHalfTimeNonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            var beatmap = createNonConvertBeatmap(overallDifficulty);
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new ManiaReplayFrame(0),
+                    new ManiaReplayFrame(note_time + hitOffset, ManiaAction.Key1),
+                    new ManiaReplayFrame(note_time + hitOffset + 20),
+                }
+            };
+
+            var score = new Score
+            {
+                Replay = replay,
+                ScoreInfo = new ScoreInfo
+                {
+                    Ruleset = CreateRuleset().RulesetInfo,
+                    Mods = [new ManiaModHalfTime()],
+                }
+            };
+
+            RunTest($@"SV1+HT single note @ OD{overallDifficulty}", beatmap, $@"SV1+HT {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        private static ManiaBeatmap createNonConvertBeatmap(float overallDifficulty)
+        {
+            var cpi = new ControlPointInfo();
+            cpi.Add(0, new TimingControlPoint { BeatLength = 1000 });
+            var beatmap = new ManiaBeatmap(new StageDefinition(1))
+            {
+                HitObjects =
+                {
+                    new Note
+                    {
+                        StartTime = note_time,
+                        Column = 0,
+                    }
+                },
+                Difficulty = new BeatmapDifficulty
+                {
+                    OverallDifficulty = overallDifficulty,
+                    CircleSize = 1,
+                },
+                BeatmapInfo =
+                {
+                    Ruleset = new ManiaRuleset().RulesetInfo,
+                },
+                ControlPointInfo = cpi,
+            };
+            return beatmap;
+        }
+
+        private static Beatmap createConvertBeatmap(float overallDifficulty)
+        {
+            var cpi = new ControlPointInfo();
+            cpi.Add(0, new TimingControlPoint { BeatLength = 1000 });
+            var beatmap = new Beatmap
+            {
+                HitObjects =
+                {
+                    new FakeCircle
+                    {
+                        StartTime = note_time,
+                    }
+                },
+                Difficulty = new BeatmapDifficulty
+                {
+                    OverallDifficulty = overallDifficulty,
+                },
+                BeatmapInfo =
+                {
+                    Ruleset = new RulesetInfo { OnlineID = 0 }
+                },
+                ControlPointInfo = cpi,
+            };
+            return beatmap;
+        }
+
+        private class FakeCircle : HitObject, IHasPosition
+        {
+            public float X
+            {
+                get => Position.X;
+                set => Position = new Vector2(value, Position.Y);
+            }
+
+            public float Y
+            {
+                get => Position.Y;
+                set => Position = new Vector2(Position.X, value);
+            }
+
+            public Vector2 Position { get; set; }
+        }
+    }
+}

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

@@ -0,0 +1,215 @@
+// 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.Containers;
+using osu.Framework.Input;
+using osu.Framework.Testing;
+using osu.Game.Rulesets.Mania.Configuration;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public partial class TestSceneManiaTouchInput : PlayerTestScene
+    {
+        protected override Ruleset CreatePlayerRuleset() => new ManiaRuleset();
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            InputManager.EndTouch(new Touch(TouchSource.Touch1, Vector2.Zero));
+            InputManager.EndTouch(new Touch(TouchSource.Touch2, Vector2.Zero));
+            toggleTouchControls(false);
+        });
+
+        #region Without touch controls
+
+        [Test]
+        public void TestTouchInput()
+        {
+            for (int i = 0; i < 4; i++)
+            {
+                int index = i;
+
+                AddStep($"touch column {index}", () => InputManager.BeginTouch(new Touch(TouchSource.Touch1, getColumn(index).ScreenSpaceDrawQuad.Centre)));
+
+                AddAssert("action sent",
+                    () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                    () => Does.Contain(getColumn(index).Action.Value));
+
+                AddStep($"release column {index}", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, getColumn(index).ScreenSpaceDrawQuad.Centre)));
+
+                AddAssert("action released",
+                    () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                    () => Does.Not.Contain(getColumn(index).Action.Value));
+            }
+        }
+
+        [Test]
+        public void TestOneColumnMultipleTouches()
+        {
+            AddStep("touch column 0", () => InputManager.BeginTouch(new Touch(TouchSource.Touch1, getColumn(0).ScreenSpaceDrawQuad.Centre)));
+
+            AddAssert("action sent",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Contain(getColumn(0).Action.Value));
+
+            AddStep("touch another finger", () => InputManager.BeginTouch(new Touch(TouchSource.Touch2, getColumn(0).ScreenSpaceDrawQuad.Centre)));
+
+            AddAssert("action still pressed",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Contain(getColumn(0).Action.Value));
+
+            AddStep("release first finger", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, getColumn(0).ScreenSpaceDrawQuad.Centre)));
+
+            AddAssert("action still pressed",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Contain(getColumn(0).Action.Value));
+
+            AddStep("release second finger", () => InputManager.EndTouch(new Touch(TouchSource.Touch2, getColumn(0).ScreenSpaceDrawQuad.Centre)));
+
+            AddAssert("action released",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Not.Contain(getColumn(0).Action.Value));
+        }
+
+        [Test]
+        public void TestBetweenTwoColumns()
+        {
+            AddStep("touch after column 0", () =>
+            {
+                var column = getColumn(0);
+                InputManager.BeginTouch(new Touch(TouchSource.Touch1, column.ToScreenSpace(new Vector2(column.LayoutSize.X + 0.5f, column.LayoutSize.Y / 2))));
+            });
+            AddAssert("column 0 pressed",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Contain(getColumn(0).Action.Value));
+            AddStep("release finger", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, getColumn(0).ScreenSpaceDrawQuad.Centre)));
+            AddAssert("column 0 released",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Not.Contain(getColumn(0).Action.Value));
+            AddStep("touch before column 1", () =>
+            {
+                var column = getColumn(1);
+                InputManager.BeginTouch(new Touch(TouchSource.Touch1, column.ToScreenSpace(new Vector2(-0.5f, column.LayoutSize.Y / 2))));
+            });
+            AddAssert("column 1 pressed",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Contain(getColumn(1).Action.Value));
+            AddStep("release finger", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, getColumn(0).ScreenSpaceDrawQuad.Centre)));
+            AddAssert("column 1 released",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Not.Contain(getColumn(1).Action.Value));
+        }
+
+        #endregion
+
+        #region With touch controls
+
+        [Test]
+        public void TestTouchAreaNotInitiallyVisible()
+        {
+            AddStep("enable touch controls", () => toggleTouchControls(true));
+            AddAssert("touch area not visible", () => getTouchOverlay()?.State.Value == Visibility.Hidden);
+        }
+
+        [Test]
+        public void TestPressReceptors()
+        {
+            AddStep("enable touch controls", () => toggleTouchControls(true));
+            AddAssert("touch area not visible", () => getTouchOverlay()?.State.Value == Visibility.Hidden);
+
+            for (int i = 0; i < 4; i++)
+            {
+                int index = i;
+
+                AddStep($"touch receptor {index}", () => InputManager.BeginTouch(new Touch(TouchSource.Touch1, getReceptor(index).ScreenSpaceDrawQuad.Centre)));
+
+                AddAssert("action sent",
+                    () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                    () => Does.Contain(getReceptor(index).Action.Value));
+
+                AddStep($"release receptor {index}", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, getReceptor(index).ScreenSpaceDrawQuad.Centre)));
+
+                AddAssert("touch area visible", () => getTouchOverlay()?.State.Value == Visibility.Visible);
+            }
+        }
+
+        [Test]
+        public void TestColumnsNotTouchableWithTouchControls()
+        {
+            AddStep("enable touch controls", () => toggleTouchControls(true));
+
+            AddStep("touch receptor 0", () => InputManager.BeginTouch(new Touch(TouchSource.Touch1, getReceptor(0).ScreenSpaceDrawQuad.Centre)));
+
+            AddAssert("action sent",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Contain(getReceptor(0).Action.Value));
+
+            AddStep("release receptor 0", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, getReceptor(0).ScreenSpaceDrawQuad.Centre)));
+
+            AddAssert("touch area visible", () => getTouchOverlay()?.State.Value == Visibility.Visible);
+
+            AddStep("touch column 0", () => InputManager.BeginTouch(new Touch(TouchSource.Touch1, getColumn(0).ScreenSpaceDrawQuad.Centre + new Vector2(0f, -50f))));
+
+            AddAssert("action not sent",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Not.Contain(getColumn(0).Action.Value));
+
+            AddStep("release column 0", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, getColumn(0).ScreenSpaceDrawQuad.Centre + new Vector2(0f, -50f))));
+
+            AddAssert("action not sent",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Not.Contain(getColumn(0).Action.Value));
+        }
+
+        [Test]
+        public void TestTouchControlBetweenTwoColumns()
+        {
+            AddStep("enable touch controls", () => toggleTouchControls(true));
+
+            AddStep("touch after receptor 0", () =>
+            {
+                var column = getReceptor(0);
+                InputManager.BeginTouch(new Touch(TouchSource.Touch1, column.ToScreenSpace(new Vector2(column.LayoutSize.X + 1f, column.LayoutSize.Y / 2))));
+            });
+
+            AddAssert("column 0 pressed",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Contain(getReceptor(0).Action.Value));
+            AddStep("release finger", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, getReceptor(0).ScreenSpaceDrawQuad.Centre)));
+            AddAssert("column 0 released",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Not.Contain(getReceptor(0).Action.Value));
+            AddStep("touch before receptor 1", () =>
+            {
+                var column = getReceptor(1);
+                InputManager.BeginTouch(new Touch(TouchSource.Touch1, column.ToScreenSpace(new Vector2(-1f, column.LayoutSize.Y / 2))));
+            });
+            AddAssert("column 1 pressed",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Contain(getReceptor(1).Action.Value));
+            AddStep("release finger", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, getReceptor(0).ScreenSpaceDrawQuad.Centre)));
+            AddAssert("column 1 released",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Not.Contain(getReceptor(1).Action.Value));
+        }
+
+        #endregion
+
+        private void toggleTouchControls(bool enabled)
+        {
+            var maniaConfig = (ManiaRulesetConfigManager)RulesetConfigs.GetConfigFor(CreatePlayerRuleset())!;
+            maniaConfig.SetValue(ManiaRulesetSetting.MobileLayout, enabled ? ManiaMobileLayout.LandscapeWithOverlay : ManiaMobileLayout.Portrait);
+        }
+
+        private ManiaTouchInputArea? getTouchOverlay() => this.ChildrenOfType<ManiaTouchInputArea>().SingleOrDefault();
+
+        private ManiaTouchInputArea.ColumnInputReceptor getReceptor(int index) => this.ChildrenOfType<ManiaTouchInputArea.ColumnInputReceptor>().ElementAt(index);
+
+        private Column getColumn(int index) => this.ChildrenOfType<Column>().ElementAt(index);
+    }
+}

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

@@ -1,49 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Linq;
-using NUnit.Framework;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Input;
-using osu.Framework.Testing;
-using osu.Game.Rulesets.Mania.UI;
-using osu.Game.Tests.Visual;
-
-namespace osu.Game.Rulesets.Mania.Tests
-{
-    public partial class TestSceneManiaTouchInputArea : PlayerTestScene
-    {
-        protected override Ruleset CreatePlayerRuleset() => new ManiaRuleset();
-
-        [Test]
-        public void TestTouchAreaNotInitiallyVisible()
-        {
-            AddAssert("touch area not visible", () => getTouchOverlay()?.State.Value == Visibility.Hidden);
-        }
-
-        [Test]
-        public void TestPressReceptors()
-        {
-            AddAssert("touch area not visible", () => getTouchOverlay()?.State.Value == Visibility.Hidden);
-
-            for (int i = 0; i < 4; i++)
-            {
-                int index = i;
-
-                AddStep($"touch receptor {index}", () => InputManager.BeginTouch(new Touch(TouchSource.Touch1, getReceptor(index).ScreenSpaceDrawQuad.Centre)));
-
-                AddAssert("action sent",
-                    () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
-                    () => Does.Contain(getReceptor(index).Action.Value));
-
-                AddStep($"release receptor {index}", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, getReceptor(index).ScreenSpaceDrawQuad.Centre)));
-
-                AddAssert("touch area visible", () => getTouchOverlay()?.State.Value == Visibility.Visible);
-            }
-        }
-
-        private ManiaTouchInputArea? getTouchOverlay() => this.ChildrenOfType<ManiaTouchInputArea>().SingleOrDefault();
-
-        private ManiaTouchInputArea.ColumnInputReceptor getReceptor(int index) => this.ChildrenOfType<ManiaTouchInputArea.ColumnInputReceptor>().ElementAt(index);
-    }
-}

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

@@ -0,0 +1,61 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Replays;
+using osu.Game.Storyboards;
+using osu.Game.Tests.Visual;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public partial class TestSceneReplayRecording : PlayerTestScene
+    {
+        protected override Ruleset CreatePlayerRuleset() => new ManiaRuleset();
+
+        [Resolved]
+        private AudioManager audioManager { get; set; } = null!;
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new ManiaBeatmap(new StageDefinition(1))
+        {
+            HitObjects =
+            {
+                new Note { StartTime = 0, },
+                new Note { StartTime = 5000, },
+                new Note { StartTime = 10000, },
+                new Note { StartTime = 15000, }
+            },
+            Difficulty = { CircleSize = 1 },
+            BeatmapInfo =
+            {
+                Ruleset = ruleset,
+            }
+        };
+
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard? storyboard = null) =>
+            new ClockBackedTestWorkingBeatmap(beatmap, storyboard, new FramedClock(new ManualClock { Rate = 1 }), audioManager);
+
+        [Test]
+        public void TestRecording()
+        {
+            seekTo(0);
+            AddStep("press space", () => InputManager.PressKey(Key.Space));
+            seekTo(15);
+            AddStep("release space", () => InputManager.ReleaseKey(Key.Space));
+            AddUntilStep("button press recorded to replay", () => Player.Score.Replay.Frames.OfType<ManiaReplayFrame>().Any(f => f.Actions.SequenceEqual([ManiaAction.Key1])));
+        }
+
+        private void seekTo(double time)
+        {
+            AddStep($"seek to {time}ms", () => Player.GameplayClockContainer.Seek(time));
+            AddUntilStep("wait for seek to finish", () => Player.DrawableRuleset.FrameStableClock.CurrentTime, () => Is.EqualTo(time).Within(500));
+        }
+    }
+}

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

@@ -0,0 +1,125 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI;
+using osu.Game.Scoring;
+using osu.Game.Screens.Play;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public partial class TestSceneReplayRewinding : RateAdjustedBeatmapTestScene
+    {
+        private ReplayPlayer currentPlayer = null!;
+
+        [Test]
+        public void TestRewindingToMiddleOfHoldNote()
+        {
+            Score score = null!;
+
+            var beatmap = new ManiaBeatmap(new StageDefinition(4))
+            {
+                HitObjects =
+                {
+                    new HoldNote
+                    {
+                        StartTime = 500,
+                        EndTime = 1500,
+                        Column = 2
+                    }
+                }
+            };
+
+            AddStep(@"create replay", () => score = new Score
+            {
+                Replay = new Replay
+                {
+                    Frames =
+                    {
+                        new ManiaReplayFrame(500, ManiaAction.Key3),
+                        new ManiaReplayFrame(1500),
+                    }
+                },
+                ScoreInfo = new ScoreInfo()
+            });
+
+            AddStep(@"set beatmap", () => Beatmap.Value = CreateWorkingBeatmap(beatmap));
+            AddStep(@"set ruleset", () => Ruleset.Value = beatmap.BeatmapInfo.Ruleset);
+            AddStep(@"push player", () => LoadScreen(currentPlayer = new ReplayPlayer(score)));
+
+            AddUntilStep(@"wait until player is loaded", () => currentPlayer.IsCurrentScreen());
+            AddUntilStep(@"wait for hold to be judged", () => currentPlayer.ChildrenOfType<IFrameStableClock>().Single().CurrentTime, () => Is.GreaterThan(1600));
+            AddStep(@"seek to middle of hold note", () => currentPlayer.Seek(1000));
+            AddUntilStep(@"wait for gameplay to complete", () => currentPlayer.GameplayState.HasCompleted);
+            AddAssert(@"no misses registered", () => currentPlayer.GameplayState.ScoreProcessor.Statistics.GetValueOrDefault(HitResult.Miss), () => Is.Zero);
+
+            AddStep(@"exit player", () => currentPlayer.Exit());
+        }
+
+        [Test]
+        public void TestCorrectComboAccountingForConcurrentObjects()
+        {
+            Score score = null!;
+
+            var beatmap = new ManiaBeatmap(new StageDefinition(4))
+            {
+                HitObjects =
+                {
+                    new Note
+                    {
+                        StartTime = 500,
+                        Column = 0,
+                    },
+                    new Note
+                    {
+                        StartTime = 500,
+                        Column = 2,
+                    },
+                    new HoldNote
+                    {
+                        StartTime = 1000,
+                        EndTime = 1500,
+                        Column = 1,
+                    }
+                }
+            };
+
+            AddStep(@"create replay", () => score = new Score
+            {
+                Replay = new Replay
+                {
+                    Frames =
+                    {
+                        new ManiaReplayFrame(500, ManiaAction.Key1, ManiaAction.Key3),
+                        new ManiaReplayFrame(520),
+                        new ManiaReplayFrame(1000, ManiaAction.Key2),
+                        new ManiaReplayFrame(1500),
+                    }
+                },
+                ScoreInfo = new ScoreInfo()
+            });
+
+            AddStep(@"set beatmap", () => Beatmap.Value = CreateWorkingBeatmap(beatmap));
+            AddStep(@"set ruleset", () => Ruleset.Value = beatmap.BeatmapInfo.Ruleset);
+            AddStep(@"push player", () => LoadScreen(currentPlayer = new ReplayPlayer(score)));
+
+            AddUntilStep(@"wait until player is loaded", () => currentPlayer.IsCurrentScreen());
+            AddUntilStep(@"wait for objects to be judged", () => currentPlayer.ChildrenOfType<IFrameStableClock>().Single().CurrentTime, () => Is.GreaterThan(1600));
+            AddStep(@"stop gameplay", () => currentPlayer.ChildrenOfType<GameplayClockContainer>().Single().Stop());
+            AddStep(@"seek to start", () => currentPlayer.Seek(0));
+            AddAssert(@"combo is 0", () => currentPlayer.GameplayState.ScoreProcessor.Combo.Value, () => Is.Zero);
+
+            AddStep(@"exit player", () => currentPlayer.Exit());
+        }
+    }
+}

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

@@ -0,0 +1,149 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
+    public partial class TestSceneReplayStability : ReplayStabilityTestScene
+    {
+        private static readonly object[][] test_cases =
+        {
+            // With respect to notation,
+            // square brackets `[]` represent *closed* or *inclusive* bounds,
+            // while round brackets `()` represent *open* or *exclusive* bounds.
+
+            // OD = 5 test cases.
+            // PERFECT hit window is [ -19.4ms,  19.4ms]
+            // GREAT   hit window is [ -49.0ms,  49.0ms]
+            // GOOD    hit window is [ -82.0ms,  82.0ms]
+            // OK      hit window is [-112.0ms, 112.0ms]
+            // MEH     hit window is [-136.0ms, 136.0ms]
+            // MISS    hit window is [-173.0ms, 173.0ms]
+            new object[] { 5f, -19d, HitResult.Perfect },
+            new object[] { 5f, -19.2d, HitResult.Perfect },
+            new object[] { 5f, -19.38d, HitResult.Perfect },
+            // new object[] { 5f, -19.4d, HitResult.Perfect }, <- in theory this should work, in practice it does not (fails even before encode & rounding due to floating point precision issues)
+            new object[] { 5f, -19.44d, HitResult.Great },
+            new object[] { 5f, -19.7d, HitResult.Great },
+            new object[] { 5f, -20d, HitResult.Great },
+            new object[] { 5f, -48d, HitResult.Great },
+            new object[] { 5f, -48.4d, HitResult.Great },
+            new object[] { 5f, -48.7d, HitResult.Great },
+            new object[] { 5f, -49d, HitResult.Great },
+            new object[] { 5f, -49.2d, HitResult.Good },
+            new object[] { 5f, -49.7d, HitResult.Good },
+            new object[] { 5f, -50d, HitResult.Good },
+            new object[] { 5f, -81d, HitResult.Good },
+            new object[] { 5f, -81.2d, HitResult.Good },
+            new object[] { 5f, -81.7d, HitResult.Good },
+            new object[] { 5f, -82d, HitResult.Good },
+            new object[] { 5f, -82.2d, HitResult.Ok },
+            new object[] { 5f, -82.7d, HitResult.Ok },
+            new object[] { 5f, -83d, HitResult.Ok },
+            new object[] { 5f, -111d, HitResult.Ok },
+            new object[] { 5f, -111.2d, HitResult.Ok },
+            new object[] { 5f, -111.7d, HitResult.Ok },
+            new object[] { 5f, -112d, HitResult.Ok },
+            new object[] { 5f, -112.2d, HitResult.Meh },
+            new object[] { 5f, -112.7d, HitResult.Meh },
+            new object[] { 5f, -113d, HitResult.Meh },
+            new object[] { 5f, -135d, HitResult.Meh },
+            new object[] { 5f, -135.2d, HitResult.Meh },
+            new object[] { 5f, -135.8d, HitResult.Meh },
+            new object[] { 5f, -136d, HitResult.Meh },
+            new object[] { 5f, -136.2d, HitResult.Miss },
+            new object[] { 5f, -136.7d, HitResult.Miss },
+            new object[] { 5f, -137d, HitResult.Miss },
+
+            // OD = 9.3 test cases.
+            // PERFECT hit window is [ -14.67ms,  14.67ms]
+            // GREAT   hit window is [ -36.10ms,  36.10ms]
+            // GOOD    hit window is [ -69.10ms,  69.10ms]
+            // OK      hit window is [ -99.10ms,  99.10ms]
+            // MEH     hit window is [-123.10ms, 123.10ms]
+            // MISS    hit window is [-160.10ms, 160.10ms]
+            new object[] { 9.3f, 14d, HitResult.Perfect },
+            new object[] { 9.3f, 14.2d, HitResult.Perfect },
+            new object[] { 9.3f, 14.6d, HitResult.Perfect },
+            // new object[] { 9.3f, 14.67d, HitResult.Perfect }, <- in theory this should work, in practice it does not (fails even before encode & rounding due to floating point precision issues)
+            new object[] { 9.3f, 14.7d, HitResult.Great },
+            new object[] { 9.3f, 15d, HitResult.Great },
+            new object[] { 9.3f, 35d, HitResult.Great },
+            new object[] { 9.3f, 35.3d, HitResult.Great },
+            new object[] { 9.3f, 35.8d, HitResult.Great },
+            new object[] { 9.3f, 36.05d, HitResult.Great },
+            new object[] { 9.3f, 36.3d, HitResult.Good },
+            new object[] { 9.3f, 36.7d, HitResult.Good },
+            new object[] { 9.3f, 37d, HitResult.Good },
+            new object[] { 9.3f, 68d, HitResult.Good },
+            new object[] { 9.3f, 68.4d, HitResult.Good },
+            new object[] { 9.3f, 68.9d, HitResult.Good },
+            new object[] { 9.3f, 69.07d, HitResult.Good },
+            new object[] { 9.3f, 69.25d, HitResult.Ok },
+            new object[] { 9.3f, 69.85d, HitResult.Ok },
+            new object[] { 9.3f, 70d, HitResult.Ok },
+            new object[] { 9.3f, 98d, HitResult.Ok },
+            new object[] { 9.3f, 98.3d, HitResult.Ok },
+            new object[] { 9.3f, 98.6d, HitResult.Ok },
+            new object[] { 9.3f, 99d, HitResult.Ok },
+            new object[] { 9.3f, 99.3d, HitResult.Meh },
+            new object[] { 9.3f, 99.7d, HitResult.Meh },
+            new object[] { 9.3f, 100d, HitResult.Meh },
+            new object[] { 9.3f, 122d, HitResult.Meh },
+            new object[] { 9.3f, 122.34d, HitResult.Meh },
+            new object[] { 9.3f, 122.57d, HitResult.Meh },
+            new object[] { 9.3f, 123.04d, HitResult.Meh },
+            new object[] { 9.3f, 123.45d, HitResult.Miss },
+            new object[] { 9.3f, 123.95d, HitResult.Miss },
+            new object[] { 9.3f, 124d, HitResult.Miss },
+        };
+
+        [TestCaseSource(nameof(test_cases))]
+        public void TestHitWindowStability(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            const double note_time = 100;
+
+            var beatmap = new ManiaBeatmap(new StageDefinition(1))
+            {
+                HitObjects =
+                {
+                    new Note
+                    {
+                        StartTime = note_time,
+                        Column = 0,
+                    }
+                },
+                Difficulty = new BeatmapDifficulty
+                {
+                    OverallDifficulty = overallDifficulty,
+                    CircleSize = 1,
+                },
+                BeatmapInfo =
+                {
+                    Ruleset = new ManiaRuleset().RulesetInfo,
+                },
+            };
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new ManiaReplayFrame(0),
+                    new ManiaReplayFrame(note_time + hitOffset, ManiaAction.Key1),
+                    new ManiaReplayFrame(note_time + hitOffset + 20),
+                }
+            };
+
+            RunTest(beatmap, replay, [expectedResult]);
+        }
+    }
+}

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

@@ -1,9 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
   </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>

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

@@ -36,20 +36,23 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         {
             int notes = HitObjects.Count(s => s is Note);
             int holdNotes = HitObjects.Count(s => s is HoldNote);
+            int sum = Math.Max(1, notes + holdNotes);
 
             return new[]
             {
                 new BeatmapStatistic
                 {
-                    Name = @"Note Count",
+                    Name = @"Notes",
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
                     Content = notes.ToString(),
+                    BarDisplayLength = notes / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Hold Note Count",
+                    Name = @"Hold Notes",
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
                     Content = holdNotes.ToString(),
+                    BarDisplayLength = holdNotes / (float)sum,
                 },
             };
         }

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

@@ -7,11 +7,13 @@ using System.Linq;
 using System.Collections.Generic;
 using System.Threading;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Legacy;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Mania.Beatmaps.Patterns;
 using osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Rulesets.Scoring.Legacy;
 using osu.Game.Utils;
 using osuTK;
@@ -124,16 +126,109 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
 
         protected override IEnumerable<ManiaHitObject> ConvertHitObject(HitObject original, IBeatmap beatmap, CancellationToken cancellationToken)
         {
-            if (original is ManiaHitObject maniaOriginal)
-            {
-                yield return maniaOriginal;
+            LegacyHitObjectType legacyType;
 
-                yield break;
+            switch (original)
+            {
+                case ManiaHitObject maniaObj:
+                {
+                    yield return maniaObj;
+
+                    yield break;
+                }
+
+                case IHasLegacyHitObjectType legacy:
+                    legacyType = legacy.LegacyType & LegacyHitObjectType.ObjectTypes;
+                    break;
+
+                case IHasPath:
+                    legacyType = LegacyHitObjectType.Slider;
+                    break;
+
+                case IHasDuration:
+                    legacyType = LegacyHitObjectType.Hold;
+                    break;
+
+                default:
+                    legacyType = LegacyHitObjectType.Circle;
+                    break;
             }
 
-            var objects = IsForCurrentRuleset ? generateSpecific(original, beatmap) : generateConverted(original, beatmap);
-            foreach (ManiaHitObject obj in objects)
-                yield return obj;
+            double startTime = original.StartTime;
+            double endTime = (original as IHasDuration)?.EndTime ?? startTime;
+            Vector2 position = (original as IHasPosition)?.Position ?? Vector2.Zero;
+
+            PatternGenerator conversion;
+
+            switch (legacyType)
+            {
+                case LegacyHitObjectType.Circle:
+                    if (IsForCurrentRuleset)
+                    {
+                        conversion = new PassThroughPatternGenerator(Random, original, beatmap, TotalColumns, lastPattern);
+                        recordNote(startTime, position);
+                    }
+                    else
+                    {
+                        // Note: The density is used during the pattern generator constructor, and intentionally computed first.
+                        computeDensity(startTime);
+                        conversion = new HitCirclePatternGenerator(Random, original, beatmap, TotalColumns, lastPattern, lastTime, lastPosition, density, lastStair);
+                        recordNote(startTime, position);
+                    }
+
+                    break;
+
+                case LegacyHitObjectType.Slider:
+                    if (IsForCurrentRuleset)
+                    {
+                        conversion = new PassThroughPatternGenerator(Random, original, beatmap, TotalColumns, lastPattern);
+                        recordNote(original.StartTime, position);
+                    }
+                    else
+                    {
+                        var generator = new SliderPatternGenerator(Random, original, beatmap, TotalColumns, lastPattern);
+                        conversion = generator;
+
+                        for (int i = 0; i <= generator.SpanCount; i++)
+                        {
+                            double time = original.StartTime + generator.SegmentDuration * i;
+
+                            recordNote(time, position);
+                            computeDensity(time);
+                        }
+                    }
+
+                    break;
+
+                case LegacyHitObjectType.Spinner:
+                    // Note: Some older mania-specific beatmaps can have spinners that are converted rather than passed through.
+                    //       Newer beatmaps will usually use the "hold" hitobject type below.
+                    conversion = new SpinnerPatternGenerator(Random, original, beatmap, TotalColumns, lastPattern);
+                    recordNote(endTime, new Vector2(256, 192));
+                    computeDensity(endTime);
+                    break;
+
+                case LegacyHitObjectType.Hold:
+                    conversion = new PassThroughPatternGenerator(Random, original, beatmap, TotalColumns, lastPattern);
+                    recordNote(endTime, position);
+                    computeDensity(endTime);
+                    break;
+
+                default:
+                    throw new ArgumentException($"Invalid legacy object type: {legacyType}", nameof(original));
+            }
+
+            foreach (var newPattern in conversion.Generate())
+            {
+                if (conversion is HitCirclePatternGenerator circleGenerator)
+                    lastStair = circleGenerator.StairType;
+
+                if (conversion is HitCirclePatternGenerator || conversion is SliderPatternGenerator)
+                    lastPattern = newPattern;
+
+                foreach (var obj in newPattern.HitObjects)
+                    yield return obj;
+            }
         }
 
         private readonly LimitedCapacityQueue<double> prevNoteTimes = new LimitedCapacityQueue<double>(max_notes_for_density);
@@ -156,135 +251,5 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             lastTime = time;
             lastPosition = position;
         }
-
-        /// <summary>
-        /// Method that generates hit objects for osu!mania specific beatmaps.
-        /// </summary>
-        /// <param name="original">The original hit object.</param>
-        /// <param name="originalBeatmap">The original beatmap. This is used to look-up any values dependent on a fully-loaded beatmap.</param>
-        /// <returns>The hit objects generated.</returns>
-        private IEnumerable<ManiaHitObject> generateSpecific(HitObject original, IBeatmap originalBeatmap)
-        {
-            var generator = new SpecificBeatmapPatternGenerator(Random, original, originalBeatmap, TotalColumns, lastPattern);
-
-            foreach (var newPattern in generator.Generate())
-            {
-                lastPattern = newPattern;
-
-                foreach (var obj in newPattern.HitObjects)
-                    yield return obj;
-            }
-        }
-
-        /// <summary>
-        /// Method that generates hit objects for non-osu!mania beatmaps.
-        /// </summary>
-        /// <param name="original">The original hit object.</param>
-        /// <param name="originalBeatmap">The original beatmap. This is used to look-up any values dependent on a fully-loaded beatmap.</param>
-        /// <returns>The hit objects generated.</returns>
-        private IEnumerable<ManiaHitObject> generateConverted(HitObject original, IBeatmap originalBeatmap)
-        {
-            Patterns.PatternGenerator? conversion = null;
-
-            switch (original)
-            {
-                case IHasPath:
-                {
-                    var generator = new PathObjectPatternGenerator(Random, original, originalBeatmap, TotalColumns, lastPattern);
-                    conversion = generator;
-
-                    var positionData = original as IHasPosition;
-
-                    for (int i = 0; i <= generator.SpanCount; i++)
-                    {
-                        double time = original.StartTime + generator.SegmentDuration * i;
-
-                        recordNote(time, positionData?.Position ?? Vector2.Zero);
-                        computeDensity(time);
-                    }
-
-                    break;
-                }
-
-                case IHasDuration endTimeData:
-                {
-                    conversion = new EndTimeObjectPatternGenerator(Random, original, originalBeatmap, TotalColumns, lastPattern);
-
-                    recordNote(endTimeData.EndTime, new Vector2(256, 192));
-                    computeDensity(endTimeData.EndTime);
-                    break;
-                }
-
-                case IHasPosition positionData:
-                {
-                    computeDensity(original.StartTime);
-
-                    conversion = new HitObjectPatternGenerator(Random, original, originalBeatmap, TotalColumns, lastPattern, lastTime, lastPosition, density, lastStair);
-
-                    recordNote(original.StartTime, positionData.Position);
-                    break;
-                }
-            }
-
-            if (conversion == null)
-                yield break;
-
-            foreach (var newPattern in conversion.Generate())
-            {
-                lastPattern = conversion is EndTimeObjectPatternGenerator ? lastPattern : newPattern;
-                lastStair = (conversion as HitObjectPatternGenerator)?.StairType ?? lastStair;
-
-                foreach (var obj in newPattern.HitObjects)
-                    yield return obj;
-            }
-        }
-
-        /// <summary>
-        /// A pattern generator for osu!mania-specific beatmaps.
-        /// </summary>
-        private class SpecificBeatmapPatternGenerator : Patterns.Legacy.PatternGenerator
-        {
-            public SpecificBeatmapPatternGenerator(LegacyRandom random, HitObject hitObject, IBeatmap beatmap, int totalColumns, Pattern previousPattern)
-                : base(random, hitObject, beatmap, previousPattern, totalColumns)
-            {
-            }
-
-            public override IEnumerable<Pattern> Generate()
-            {
-                yield return generate();
-            }
-
-            private Pattern generate()
-            {
-                var positionData = HitObject as IHasXPosition;
-
-                int column = GetColumn(positionData?.X ?? 0);
-
-                var pattern = new Pattern();
-
-                if (HitObject is IHasDuration endTimeData)
-                {
-                    pattern.Add(new HoldNote
-                    {
-                        StartTime = HitObject.StartTime,
-                        Duration = endTimeData.Duration,
-                        Column = column,
-                        Samples = HitObject.Samples,
-                        NodeSamples = (HitObject as IHasRepeats)?.NodeSamples ?? HoldNote.CreateDefaultNodeSamples(HitObject)
-                    });
-                }
-                else if (HitObject is IHasXPosition)
-                {
-                    pattern.Add(new Note
-                    {
-                        StartTime = HitObject.StartTime,
-                        Samples = HitObject.Samples,
-                        Column = column
-                    });
-                }
-
-                return pattern;
-            }
-        }
     }
 }

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

@@ -16,13 +16,16 @@ using osu.Game.Utils;
 
 namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 {
-    internal class HitObjectPatternGenerator : PatternGenerator
+    /// <summary>
+    /// Converter for legacy "HitCircle" hit objects.
+    /// </summary>
+    internal class HitCirclePatternGenerator : LegacyPatternGenerator
     {
         public PatternType StairType { get; private set; }
 
         private readonly PatternType convertType;
 
-        public HitObjectPatternGenerator(LegacyRandom random, HitObject hitObject, IBeatmap beatmap, int totalColumns, Pattern previousPattern, double previousTime, Vector2 previousPosition,
+        public HitCirclePatternGenerator(LegacyRandom random, HitObject hitObject, IBeatmap beatmap, int totalColumns, Pattern previousPattern, double previousTime, Vector2 previousPosition,
                                          double density, PatternType lastStair)
             : base(random, hitObject, beatmap, previousPattern, totalColumns)
         {
@@ -114,10 +117,10 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 }
 
                 if (convertType.HasFlag(PatternType.Cycle) && PreviousPattern.HitObjects.Count() == 1
-                                                               // If we convert to 7K + 1, let's not overload the special key
-                                                               && (TotalColumns != 8 || lastColumn != 0)
-                                                               // Make sure the last column was not the centre column
-                                                               && (TotalColumns % 2 == 0 || lastColumn != TotalColumns / 2))
+                                                           // If we convert to 7K + 1, let's not overload the special key
+                                                           && (TotalColumns != 8 || lastColumn != 0)
+                                                           // Make sure the last column was not the centre column
+                                                           && (TotalColumns % 2 == 0 || lastColumn != TotalColumns / 2))
                 {
                     // Generate a new pattern by cycling backwards (similar to Reverse but for only one hit object)
                     int column = RandomStart + TotalColumns - lastColumn - 1;

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

@@ -1,8 +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.
 
-#nullable disable
-
 using System;
 using System.Linq;
 using JetBrains.Annotations;
@@ -15,7 +13,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
     /// <summary>
     /// A pattern generator for legacy hit objects.
     /// </summary>
-    internal abstract class PatternGenerator : Patterns.PatternGenerator
+    internal abstract class LegacyPatternGenerator : PatternGenerator
     {
         /// <summary>
         /// The column index at which to start generating random notes.
@@ -27,7 +25,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// </summary>
         protected readonly LegacyRandom Random;
 
-        protected PatternGenerator(LegacyRandom random, HitObject hitObject, IBeatmap beatmap, Pattern previousPattern, int totalColumns)
+        protected LegacyPatternGenerator(LegacyRandom random, HitObject hitObject, IBeatmap beatmap, Pattern previousPattern, int totalColumns)
             : base(hitObject, beatmap, totalColumns, previousPattern)
         {
             ArgumentNullException.ThrowIfNull(random);
@@ -96,8 +94,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 if (conversionDifficulty != null)
                     return conversionDifficulty.Value;
 
-                HitObject lastObject = Beatmap.HitObjects.LastOrDefault();
-                HitObject firstObject = Beatmap.HitObjects.FirstOrDefault();
+                HitObject? lastObject = Beatmap.HitObjects.LastOrDefault();
+                HitObject? firstObject = Beatmap.HitObjects.FirstOrDefault();
 
                 // Drain time in seconds
                 int drainTime = (int)(((lastObject?.StartTime ?? 0) - (firstObject?.StartTime ?? 0) - Beatmap.TotalBreakTime) / 1000);
@@ -132,13 +130,13 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// <param name="nextColumn">A function to retrieve the next column. If null, a randomisation scheme will be used.</param>
         /// <param name="validation">A function to perform additional validation checks to determine if a column is a valid candidate for a <see cref="HitObject"/>.</param>
         /// <param name="lowerBound">The minimum column index. If null, <see cref="RandomStart"/> is used.</param>
-        /// <param name="upperBound">The maximum column index. If null, <see cref="Patterns.PatternGenerator.TotalColumns">TotalColumns</see> is used.</param>
+        /// <param name="upperBound">The maximum column index. If null, <see cref="PatternGenerator.TotalColumns">TotalColumns</see> is used.</param>
         /// <param name="patterns">A list of patterns for which the validity of a column should be checked against.
         /// A column is not a valid candidate if a <see cref="HitObject"/> occupies the same column in any of the patterns.</param>
         /// <returns>A column which has passed the <paramref name="validation"/> check and for which there are no
         /// <see cref="HitObject"/>s in any of <paramref name="patterns"/> occupying the same column.</returns>
         /// <exception cref="NotEnoughColumnsException">If there are no valid candidate columns.</exception>
-        protected int FindAvailableColumn(int initialColumn, int? lowerBound = null, int? upperBound = null, Func<int, int> nextColumn = null, [InstantHandle] Func<int, bool> validation = null,
+        protected int FindAvailableColumn(int initialColumn, int? lowerBound = null, int? upperBound = null, Func<int, int>? nextColumn = null, [InstantHandle] Func<int, bool>? validation = null,
                                           params Pattern[] patterns)
         {
             lowerBound ??= RandomStart;
@@ -189,7 +187,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// Returns a random column index in the range [<paramref name="lowerBound"/>, <paramref name="upperBound"/>).
         /// </summary>
         /// <param name="lowerBound">The minimum column index. If null, <see cref="RandomStart"/> is used.</param>
-        /// <param name="upperBound">The maximum column index. If null, <see cref="Patterns.PatternGenerator.TotalColumns"/> is used.</param>
+        /// <param name="upperBound">The maximum column index. If null, <see cref="PatternGenerator.TotalColumns"/> is used.</param>
         protected int GetRandomColumn(int? lowerBound = null, int? upperBound = null) => Random.Next(lowerBound ?? RandomStart, upperBound ?? TotalColumns);
 
         /// <summary>

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

@@ -0,0 +1,55 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Utils;
+
+namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
+{
+    /// <summary>
+    /// A simple generator which, for any object, if the hitobject has an end time
+    /// it becomes a <see cref="HoldNote"/> or otherwise a <see cref="Note"/>.
+    /// </summary>
+    internal class PassThroughPatternGenerator : LegacyPatternGenerator
+    {
+        public PassThroughPatternGenerator(LegacyRandom random, HitObject hitObject, IBeatmap beatmap, int totalColumns, Pattern previousPattern)
+            : base(random, hitObject, beatmap, previousPattern, totalColumns)
+        {
+        }
+
+        public override IEnumerable<Pattern> Generate()
+        {
+            var positionData = HitObject as IHasXPosition;
+            int column = GetColumn(positionData?.X ?? 0);
+
+            var pattern = new Pattern();
+
+            if (HitObject is IHasDuration endTimeData)
+            {
+                pattern.Add(new HoldNote
+                {
+                    StartTime = HitObject.StartTime,
+                    Duration = endTimeData.Duration,
+                    Column = column,
+                    Samples = HitObject.Samples,
+                    NodeSamples = (HitObject as IHasRepeats)?.NodeSamples ?? HoldNote.CreateDefaultNodeSamples(HitObject)
+                });
+            }
+            else
+            {
+                pattern.Add(new Note
+                {
+                    StartTime = HitObject.StartTime,
+                    Samples = HitObject.Samples,
+                    Column = column
+                });
+            }
+
+            yield return pattern;
+        }
+    }
+}

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

@@ -1,8 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -19,9 +17,9 @@ using osu.Game.Utils;
 namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 {
     /// <summary>
-    /// A pattern generator for IHasDistance hit objects.
+    /// Converter for legacy "Slider" hit objects.
     /// </summary>
-    internal class PathObjectPatternGenerator : PatternGenerator
+    internal class SliderPatternGenerator : LegacyPatternGenerator
     {
         public readonly int StartTime;
         public readonly int EndTime;
@@ -30,7 +28,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
         private PatternType convertType;
 
-        public PathObjectPatternGenerator(LegacyRandom random, HitObject hitObject, IBeatmap beatmap, int totalColumns, Pattern previousPattern)
+        public SliderPatternGenerator(LegacyRandom random, HitObject hitObject, IBeatmap beatmap, int totalColumns, Pattern previousPattern)
             : base(random, hitObject, beatmap, previousPattern, totalColumns)
         {
             convertType = PatternType.None;
@@ -484,9 +482,9 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// Retrieves the list of node samples that occur at time greater than or equal to <paramref name="time"/>.
         /// </summary>
         /// <param name="time">The time to retrieve node samples at.</param>
-        private IList<IList<HitSampleInfo>> nodeSamplesAt(int time)
+        private IList<IList<HitSampleInfo>>? nodeSamplesAt(int time)
         {
-            if (!(HitObject is IHasPathWithRepeats curveData))
+            if (HitObject is not IHasPathWithRepeats curveData)
                 return null;
 
             int index = SegmentDuration == 0 ? 0 : (time - StartTime) / SegmentDuration;

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

@@ -12,12 +12,15 @@ using osu.Game.Utils;
 
 namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 {
-    internal class EndTimeObjectPatternGenerator : PatternGenerator
+    /// <summary>
+    /// Converter for legacy "Spinner" hit objects.
+    /// </summary>
+    internal class SpinnerPatternGenerator : LegacyPatternGenerator
     {
         private readonly int endTime;
         private readonly PatternType convertType;
 
-        public EndTimeObjectPatternGenerator(LegacyRandom random, HitObject hitObject, IBeatmap beatmap, int totalColumns, Pattern previousPattern)
+        public SpinnerPatternGenerator(LegacyRandom random, HitObject hitObject, IBeatmap beatmap, int totalColumns, Pattern previousPattern)
             : base(random, hitObject, beatmap, previousPattern, totalColumns)
         {
             endTime = (int)((HitObject as IHasDuration)?.EndTime ?? 0);

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

@@ -1,9 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using osu.Game.Rulesets.Mania.Objects;
 
@@ -14,8 +13,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns
     /// </summary>
     internal class Pattern
     {
-        private List<ManiaHitObject> hitObjects;
-        private HashSet<int> containedColumns;
+        private List<ManiaHitObject>? hitObjects;
+        private HashSet<int>? containedColumns;
 
         /// <summary>
         /// All the hit objects contained in this pattern.
@@ -72,6 +71,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns
             containedColumns?.Clear();
         }
 
+        [MemberNotNull(nameof(hitObjects), nameof(containedColumns))]
         private void prepareStorage()
         {
             hitObjects ??= new List<ManiaHitObject>();

osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using osu.Framework.Configuration.Tracking;
 using osu.Game.Configuration;
 using osu.Game.Localisation;
@@ -24,17 +23,7 @@ namespace osu.Game.Rulesets.Mania.Configuration
             SetDefault(ManiaRulesetSetting.ScrollSpeed, 8.0, 1.0, 40.0, 0.1);
             SetDefault(ManiaRulesetSetting.ScrollDirection, ManiaScrollingDirection.Down);
             SetDefault(ManiaRulesetSetting.TimingBasedNoteColouring, false);
-
-#pragma warning disable CS0618
-            // Although obsolete, this is still required to populate the bindable from the database in case migration is required.
-            SetDefault<double?>(ManiaRulesetSetting.ScrollTime, null);
-
-            if (Get<double?>(ManiaRulesetSetting.ScrollTime) is double scrollTime)
-            {
-                SetValue(ManiaRulesetSetting.ScrollSpeed, Math.Round(DrawableManiaRuleset.MAX_TIME_RANGE / scrollTime));
-                SetValue<double?>(ManiaRulesetSetting.ScrollTime, null);
-            }
-#pragma warning restore CS0618
+            SetDefault(ManiaRulesetSetting.MobileLayout, ManiaMobileLayout.Portrait);
         }
 
         public override TrackedSettings CreateTrackedSettings() => new TrackedSettings
@@ -51,10 +40,9 @@ namespace osu.Game.Rulesets.Mania.Configuration
 
     public enum ManiaRulesetSetting
     {
-        [Obsolete("Use ScrollSpeed instead.")] // Can be removed 2023-11-30
-        ScrollTime,
         ScrollSpeed,
         ScrollDirection,
-        TimingBasedNoteColouring
+        TimingBasedNoteColouring,
+        MobileLayout,
     }
 }

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

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using Newtonsoft.Json;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 
@@ -10,22 +9,12 @@ namespace osu.Game.Rulesets.Mania.Difficulty
 {
     public class ManiaDifficultyAttributes : DifficultyAttributes
     {
-        /// <summary>
-        /// The hit window for a GREAT hit inclusive of rate-adjusting mods (DT/HT/etc).
-        /// </summary>
-        /// <remarks>
-        /// Rate-adjusting mods do not affect the hit window at all in osu-stable.
-        /// </remarks>
-        [JsonProperty("great_hit_window")]
-        public double GreatHitWindow { get; set; }
-
         public override IEnumerable<(int attributeId, object value)> ToDatabaseAttributes()
         {
             foreach (var v in base.ToDatabaseAttributes())
                 yield return v;
 
             yield return (ATTRIB_ID_DIFFICULTY, StarRating);
-            yield return (ATTRIB_ID_GREAT_HIT_WINDOW, GreatHitWindow);
         }
 
         public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values, IBeatmapOnlineInfo onlineInfo)
@@ -33,7 +22,6 @@ namespace osu.Game.Rulesets.Mania.Difficulty
             base.FromDatabaseAttributes(values, onlineInfo);
 
             StarRating = values[ATTRIB_ID_DIFFICULTY];
-            GreatHitWindow = values[ATTRIB_ID_GREAT_HIT_WINDOW];
         }
     }
 }

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

@@ -27,7 +27,6 @@ namespace osu.Game.Rulesets.Mania.Difficulty
         private const double difficulty_multiplier = 0.018;
 
         private readonly bool isForCurrentRuleset;
-        private readonly double originalOverallDifficulty;
 
         public override int Version => 20241007;
 
@@ -35,7 +34,6 @@ namespace osu.Game.Rulesets.Mania.Difficulty
             : base(ruleset, beatmap)
         {
             isForCurrentRuleset = beatmap.BeatmapInfo.Ruleset.MatchesOnlineID(ruleset);
-            originalOverallDifficulty = beatmap.BeatmapInfo.Difficulty.OverallDifficulty;
         }
 
         protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
@@ -48,11 +46,8 @@ namespace osu.Game.Rulesets.Mania.Difficulty
 
             ManiaDifficultyAttributes attributes = new ManiaDifficultyAttributes
             {
-                StarRating = skills[0].DifficultyValue() * difficulty_multiplier,
+                StarRating = skills.OfType<Strain>().Single().DifficultyValue() * difficulty_multiplier,
                 Mods = mods,
-                // In osu-stable mania, rate-adjustment mods don't affect the hit window.
-                // This is done the way it is to introduce fractional differences in order to match osu-stable for the time being.
-                GreatHitWindow = Math.Ceiling((int)(getHitWindow300(mods) * clockRate) / clockRate),
                 MaxCombo = beatmap.HitObjects.Sum(maxComboForObject),
             };
 
@@ -124,29 +119,5 @@ namespace osu.Game.Rulesets.Mania.Difficulty
                 }).ToArray();
             }
         }
-
-        private double getHitWindow300(Mod[] mods)
-        {
-            if (isForCurrentRuleset)
-            {
-                double od = Math.Min(10.0, Math.Max(0, 10.0 - originalOverallDifficulty));
-                return applyModAdjustments(34 + 3 * od, mods);
-            }
-
-            if (Math.Round(originalOverallDifficulty) > 4)
-                return applyModAdjustments(34, mods);
-
-            return applyModAdjustments(47, mods);
-
-            static double applyModAdjustments(double value, Mod[] mods)
-            {
-                if (mods.Any(m => m is ManiaModHardRock))
-                    value /= 1.4;
-                else if (mods.Any(m => m is ManiaModEasy))
-                    value *= 1.4;
-
-                return value;
-            }
-        }
     }
 }

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

@@ -98,9 +98,9 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 
         private double originalStartTime;
 
-        public override void UpdateTimeAndPosition(SnapResult result)
+        public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, double fallbackTime)
         {
-            base.UpdateTimeAndPosition(result);
+            var result = base.UpdateTimeAndPosition(screenSpacePosition, fallbackTime);
 
             if (PlacementActive == PlacementState.Active)
             {
@@ -121,6 +121,8 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
                 if (result.Time is double startTime)
                     originalStartTime = HitObject.StartTime = startTime;
             }
+
+            return result;
         }
     }
 }

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

@@ -5,7 +5,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Primitives;
-using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
@@ -24,7 +23,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
         private EditorBeatmap? editorBeatmap { get; set; }
 
         [Resolved]
-        private IPositionSnapProvider? positionSnapProvider { get; set; }
+        private ManiaHitObjectComposer? positionSnapProvider { get; set; }
 
         private EditBodyPiece body = null!;
         private EditHoldNoteEndPiece head = null!;

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

@@ -1,8 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
+using System;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Edit;
@@ -20,13 +20,18 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
     {
         protected new T HitObject => (T)base.HitObject;
 
-        private Column column;
+        [Resolved]
+        private ManiaHitObjectComposer? composer { get; set; }
 
-        public Column Column
+        private Column? column;
+
+        public Column? Column
         {
             get => column;
             set
             {
+                ArgumentNullException.ThrowIfNull(value);
+
                 if (value == column)
                     return;
 
@@ -53,9 +58,11 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             return true;
         }
 
-        public override void UpdateTimeAndPosition(SnapResult result)
+        public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, double fallbackTime)
         {
-            base.UpdateTimeAndPosition(result);
+            var result = composer?.FindSnappedPositionAndTime(screenSpacePosition) ?? new SnapResult(screenSpacePosition, fallbackTime);
+
+            base.UpdateTimeAndPosition(result.ScreenSpacePosition, result.Time ?? fallbackTime);
 
             if (result.Playfield is Column col)
             {
@@ -76,6 +83,8 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
                 if (PlacementActive == PlacementState.Waiting)
                     Column = col;
             }
+
+            return result;
         }
 
         private float getNoteHeight(Column resultPlayfield) =>