Remove obsolete fucks

.github/workflows/_diffcalc_processor.yml

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

.github/workflows/ci.yml

@@ -82,18 +82,8 @@ jobs:
         run: dotnet build -c Debug -warnaserror osu.Desktop.slnf
 
       - name: Test
-        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
+        run: dotnet test $pwd/**/*.Tests/bin/Debug/*/*.Tests.dll --logger "trx;LogFileName=TestResults-${{matrix.os.prettyname}}-${{matrix.threadingMode}}.trx" -- NUnit.ConsoleOut=0
+        shell: pwsh
 
       # Attempt to upload results even if test fails.
       # https://docs.github.com/en/actions/reference/context-and-expression-syntax-for-github-actions#always
@@ -124,7 +114,10 @@ jobs:
           dotnet-version: "8.0.x"
 
       - name: Install .NET workloads
-        run: dotnet workload install android
+        # 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)
 
       - name: Compile
         run: dotnet build -c Debug osu.Android.slnf
@@ -146,4 +139,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.slnf
+        run: dotnet build -c Debug osu.iOS

.github/workflows/deploy.yml

@@ -1,87 +0,0 @@
-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

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

@@ -1,10 +0,0 @@
-<?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,10 +18,3 @@ 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.

Directory.Build.props

@@ -3,10 +3,6 @@
   <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>

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

@@ -9,7 +9,7 @@
       <GenerateProgramFile>false</GenerateProgramFile>
     </PropertyGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
     <PackageReference Include="NUnit" Version="3.14.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
   </ItemGroup>

Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform/Replays/EmptyFreeformReplayFrame.cs

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using System.Linq;
 using osu.Game.Rulesets.Replays;
 using osuTK;
 
@@ -18,8 +17,5 @@ namespace osu.Game.Rulesets.EmptyFreeform.Replays
             if (button.HasValue)
                 Actions.Add(button.Value);
         }
-
-        public override bool IsEquivalentTo(ReplayFrame other)
-            => other is EmptyFreeformReplayFrame freeformFrame && Time == freeformFrame.Time && Position == freeformFrame.Position && Actions.SequenceEqual(freeformFrame.Actions);
     }
 }

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

@@ -9,7 +9,7 @@
     <GenerateProgramFile>false</GenerateProgramFile>
   </PropertyGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
     <PackageReference Include="NUnit" Version="3.14.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
   </ItemGroup>

Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon/Replays/PippidonReplayFrame.cs

@@ -9,8 +9,5 @@ namespace osu.Game.Rulesets.Pippidon.Replays
     public class PippidonReplayFrame : ReplayFrame
     {
         public Vector2 Position;
-
-        public override bool IsEquivalentTo(ReplayFrame other)
-            => other is PippidonReplayFrame pippidonFrame && Time == pippidonFrame.Time && Position == pippidonFrame.Position;
     }
 }

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

@@ -9,7 +9,7 @@
     <GenerateProgramFile>false</GenerateProgramFile>
   </PropertyGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
     <PackageReference Include="NUnit" Version="3.14.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
   </ItemGroup>

Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling/Replays/EmptyScrollingReplayFrame.cs

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using System.Linq;
 using osu.Game.Rulesets.Replays;
 
 namespace osu.Game.Rulesets.EmptyScrolling.Replays
@@ -16,8 +15,5 @@ namespace osu.Game.Rulesets.EmptyScrolling.Replays
             if (button.HasValue)
                 Actions.Add(button.Value);
         }
-
-        public override bool IsEquivalentTo(ReplayFrame other)
-            => other is EmptyScrollingReplayFrame scrollingFrame && Time == scrollingFrame.Time && Actions.SequenceEqual(scrollingFrame.Actions);
     }
 }

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

@@ -9,7 +9,7 @@
     <GenerateProgramFile>false</GenerateProgramFile>
   </PropertyGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
     <PackageReference Include="NUnit" Version="3.14.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
   </ItemGroup>

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

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
@@ -10,6 +9,7 @@ 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)Math.Clamp(
+        private int getLane(HitObject hitObject) => (int)MathHelper.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;

Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/Replays/PippidonReplayFrame.cs

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using System.Linq;
 using osu.Game.Rulesets.Replays;
 
 namespace osu.Game.Rulesets.Pippidon.Replays
@@ -16,8 +15,5 @@ namespace osu.Game.Rulesets.Pippidon.Replays
             if (button.HasValue)
                 Actions.Add(button.Value);
         }
-
-        public override bool IsEquivalentTo(ReplayFrame other)
-            => other is PippidonReplayFrame pippidonFrame && Time == pippidonFrame.Time && Actions.SequenceEqual(pippidonFrame.Actions);
     }
 }

appveyor.yml

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,86 @@
+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="2025.604.1" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2025.115.0" />
   </ItemGroup>
   <PropertyGroup>
     <!-- Fody does not handle Android build well, and warns when unchanged.

osu.Android/GameplayScreenRotationLocker.cs

@@ -0,0 +1,34 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using Android.Content.PM;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.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

@@ -49,8 +49,6 @@ namespace osu.Android
         /// <remarks>Adjusted on startup to match expected UX for the current device type (phone/tablet).</remarks>
         public ScreenOrientation DefaultOrientation = ScreenOrientation.Unspecified;
 
-        public new bool IsTablet { get; private set; }
-
         private readonly OsuGameAndroid game;
 
         private bool gameCreated;
@@ -91,9 +89,9 @@ namespace osu.Android
             WindowManager.DefaultDisplay.GetSize(displaySize);
 #pragma warning restore CA1422
             float smallestWidthDp = Math.Min(displaySize.X, displaySize.Y) / Resources.DisplayMetrics.Density;
-            IsTablet = smallestWidthDp >= 600f;
+            bool 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.

osu.Android/OsuGameAndroid.cs

@@ -3,16 +3,13 @@
 
 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
 {
@@ -21,8 +18,6 @@ namespace osu.Android
         [Cached]
         private readonly OsuGameActivity gameActivity;
 
-        public override Vector2 ScalingContainerTargetDrawSize => new Vector2(1024, 1024 * DrawHeight / DrawWidth);
-
         public OsuGameAndroid(OsuGameActivity activity)
             : base(null)
         {
@@ -76,35 +71,7 @@ namespace osu.Android
         protected override void LoadComplete()
         {
             base.LoadComplete();
-            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;
-            }
+            LoadComponentAsync(new GameplayScreenRotationLocker(), Add);
         }
 
         public override void SetHost(GameHost host)

osu.Desktop/DiscordRichPresence.cs

@@ -82,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);
+            client.OnError += (_, e) => Logger.Log($"An error occurred with Discord RPC Client: {e.Message} ({e.Code})", LoggingTarget.Network, LogLevel.Error);
 
             try
             {
@@ -173,7 +173,7 @@ namespace osu.Desktop
                         new Button
                         {
                             Label = "View beatmap",
-                            Url = $@"{api.Endpoints.WebsiteUrl}/beatmaps/{beatmapId}?mode={ruleset.Value.ShortName}"
+                            Url = $@"{api.WebsiteRootUrl}/beatmaps/{beatmapId}?mode={ruleset.Value.ShortName}"
                         }
                     };
                 }

osu.Desktop/OsuGameDesktop.cs

@@ -17,7 +17,6 @@ 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;
@@ -34,8 +33,6 @@ namespace osu.Desktop
         [Cached(typeof(IHighPerformanceSessionManager))]
         private readonly HighPerformanceSessionManager highPerformanceSessionManager = new HighPerformanceSessionManager();
 
-        public bool IsFirstRun { get; init; }
-
         public OsuGameDesktop(string[]? args = null)
             : base(args)
         {
@@ -107,14 +104,6 @@ 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();
 

osu.Desktop/Program.cs

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

osu.Desktop/Security/ElevatedPrivilegesChecker.cs

@@ -30,6 +30,8 @@ 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,10 +4,8 @@
 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;
@@ -18,8 +16,8 @@ namespace osu.Desktop.Updater
 {
     public partial class VelopackUpdateManager : Game.Updater.UpdateManager
     {
-        [Resolved]
-        private INotificationOverlay notificationOverlay { get; set; } = null!;
+        private readonly UpdateManager updateManager;
+        private INotificationOverlay notificationOverlay = null!;
 
         [Resolved]
         private OsuGameBase game { get; set; } = null!;
@@ -27,32 +25,22 @@ 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;
 
-        protected override void LoadComplete()
+        public VelopackUpdateManager()
         {
-            // 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
+            updateManager = new UpdateManager(new GithubSource(@"https://github.com/ppy/osu", null, false), new UpdateOptions
             {
                 AllowVersionDowngrade = true,
             });
+        }
 
-            Schedule(() => Task.Run(CheckForUpdateAsync));
+        [BackgroundDependencyLoader]
+        private void load(INotificationOverlay notifications)
+        {
+            notificationOverlay = notifications;
         }
 
         protected override async Task<bool> PerformUpdateCheck() => await checkForUpdateAsync().ConfigureAwait(false);
@@ -88,12 +76,6 @@ 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.
@@ -159,9 +141,6 @@ namespace osu.Desktop.Updater
 
         private async Task restartToApplyUpdate()
         {
-            if (updateManager == null)
-                return;
-
             await updateManager.WaitExitThenApplyUpdatesAsync(pendingUpdate?.TargetFullRelease).ConfigureAwait(false);
             Schedule(() => game.AttemptExit());
         }

osu.Desktop/osu.Desktop.csproj

@@ -24,7 +24,7 @@
     <ProjectReference Include="..\osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="System.IO.Packaging" Version="9.0.2" />
+    <PackageReference Include="System.IO.Packaging" Version="9.0.0" />
     <PackageReference Include="DiscordRichPresence" Version="1.2.1.24" />
     <PackageReference Include="Velopack" Version="0.0.1053" />
   </ItemGroup>

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

@@ -12,6 +12,7 @@ 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;
@@ -22,8 +23,6 @@ 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;
@@ -72,11 +71,11 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
             contentContainer.Playfield.HitObjectContainer.Add(hitObject);
         }
 
-        protected override void UpdatePlacementTimeAndPosition()
+        protected override SnapResult SnapForBlueprint(HitObjectPlacementBlueprint blueprint)
         {
-            var position = InputManager.CurrentState.Mouse.Position;
-            double time = Math.Round(HitObjectContainer.TimeAtScreenSpacePosition(position) / TIME_SNAP) * TIME_SNAP;
-            CurrentBlueprint.UpdateTimeAndPosition(position, time);
+            var result = base.SnapForBlueprint(blueprint);
+            result.Time = Math.Round(HitObjectContainer.TimeAtScreenSpacePosition(result.ScreenSpacePosition) / TIME_SNAP) * TIME_SNAP;
+            return result;
         }
     }
 }

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

@@ -1,75 +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.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,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
     <PackageReference Include="NUnit" Version="3.14.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
   </ItemGroup>

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

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
@@ -17,30 +16,26 @@ 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 = @"Fruits",
+                    Name = @"Fruit Count",
                     Content = fruits.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
-                    BarDisplayLength = fruits / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Juice Streams",
+                    Name = @"Juice Stream Count",
                     Content = juiceStreams.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
-                    BarDisplayLength = juiceStreams / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Banana Showers",
+                    Name = @"Banana Shower Count",
                     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.BeatmapVersion < 8 ? 1f / ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(obj.StartTime).SliderVelocity : 1,
+                        TickDistanceMultiplier = beatmap.BeatmapInfo.BeatmapVersion < 8 ? 1f / ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(obj.StartTime).SliderVelocity : 1,
                         SliderVelocityMultiplier = sliderVelocityData?.SliderVelocityMultiplier ?? 1
                     }.Yield();
 

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -14,7 +14,6 @@ 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;
@@ -229,7 +228,7 @@ namespace osu.Game.Rulesets.Catch
         public override IEnumerable<Drawable> CreateEditorSetupSections() =>
         [
             new MetadataSection(),
-            new CatchDifficultySection(),
+            new DifficultySection(),
             new FillFlowContainer
             {
                 AutoSizeAxes = Axes.Y,

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

@@ -2,6 +2,7 @@
 // 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;
 
@@ -9,6 +10,15 @@ 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())
@@ -16,6 +26,7 @@ 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)
@@ -23,6 +34,7 @@ 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,7 +3,6 @@
 
 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;
@@ -24,7 +23,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
         private float halfCatcherWidth;
 
-        public override int Version => 20250306;
+        public override int Version => 20220701;
 
         public CatchDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
             : base(ruleset, beatmap)
@@ -36,10 +35,14 @@ 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.OfType<Movement>().Single().DifficultyValue()) * difficulty_multiplier,
+                StarRating = Math.Sqrt(skills[0].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,9 +3,6 @@
 
 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;
@@ -53,19 +50,7 @@ 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);
 
-            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 approachRate = catchAttributes.ApproachRate;
             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,9 +26,7 @@ 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.
@@ -61,9 +59,6 @@ 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);
@@ -97,30 +92,12 @@ 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
-            }
-
-            // 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;
+                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
             }
 
             lastPlayerPosition = playerPosition;
             lastDistanceMoved = distanceMoved;
             lastStrainTime = catchCurrent.StrainTime;
-            lastExactDistanceMoved = exactDistanceMoved;
 
             return distanceAddition / weightedStrainTime;
         }

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

@@ -7,7 +7,6 @@ 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
@@ -60,13 +59,11 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
             return base.OnMouseDown(e);
         }
 
-        public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, double fallbackTime)
+        public override void UpdateTimeAndPosition(SnapResult result)
         {
-            var result = Composer?.FindSnappedPositionAndTime(screenSpacePosition) ?? new SnapResult(screenSpacePosition, fallbackTime);
+            base.UpdateTimeAndPosition(result);
 
-            base.UpdateTimeAndPosition(result.ScreenSpacePosition, result.Time ?? fallbackTime);
-
-            if (!(result.Time is double time)) return result;
+            if (!(result.Time is double time)) return;
 
             switch (PlacementActive)
             {
@@ -81,7 +78,6 @@ 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 abstract partial class CatchPlacementBlueprint<THitObject> : HitObjectPlacementBlueprint
+    public partial class CatchPlacementBlueprint<THitObject> : HitObjectPlacementBlueprint
         where THitObject : CatchHitObject, new()
     {
         protected new THitObject HitObject => (THitObject)base.HitObject;
@@ -19,10 +19,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
         [Resolved]
         private Playfield playfield { get; set; } = null!;
 
-        [Resolved]
-        protected CatchHitObjectComposer? Composer { get; private set; }
-
-        protected CatchPlacementBlueprint()
+        public CatchPlacementBlueprint()
             : base(new THitObject())
         {
         }

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

@@ -143,7 +143,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints.Components
         {
             base.UpdateHitObjectFromPath(hitObject);
 
-            if (hitObject.Path.ControlPoints.Count <= 1 || !hitObject.Path.HasValidLengthForPlacement)
+            if (hitObject.Path.ControlPoints.Count <= 1 || !hitObject.Path.HasValidLength)
                 EditorBeatmap?.Remove(hitObject);
         }
     }

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

@@ -5,7 +5,6 @@ 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
@@ -42,20 +41,11 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
             return true;
         }
 
-        public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, double fallbackTime)
+        public override void UpdateTimeAndPosition(SnapResult 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);
+            base.UpdateTimeAndPosition(result);
 
             HitObject.X = ToLocalSpace(result.ScreenSpacePosition).X;
-            return result;
         }
     }
 }

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

@@ -83,16 +83,8 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
             return base.OnMouseDown(e);
         }
 
-        public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, double fallbackTime)
+        public override void UpdateTimeAndPosition(SnapResult 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;
-
             switch (PlacementActive)
             {
                 case PlacementState.Waiting:
@@ -107,7 +99,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
                     break;
 
                 default:
-                    return result;
+                    return;
             }
 
             // Make sure the up-to-date position is used for outlines.
@@ -121,7 +113,6 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
             ApplyDefaultsToHitObject();
             scrollingPath.UpdatePathFrom(HitObjectContainer, HitObject);
             nestedOutlineContainer.UpdateNestedObjectsFrom(HitObjectContainer, HitObject);
-            return result;
         }
 
         private double positionToTime(float relativeYPosition)

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

@@ -5,7 +5,6 @@ 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
@@ -14,11 +13,7 @@ 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,22 +1,16 @@
 // 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)
         {
@@ -42,28 +36,5 @@ 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(after.StartTime - before.GetEndTime(), before.StartTime);
+            float expectedDistance = DurationToDistance(before, after.StartTime - before.GetEndTime());
 
             float previousEndX = (before as JuiceStream)?.EndX ?? ((CatchHitObject)before).EffectiveX;
             float actualDistance = Math.Abs(previousEndX - ((CatchHitObject)after).EffectiveX);

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

@@ -23,10 +23,9 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Edit
 {
-    [Cached]
     public partial class CatchHitObjectComposer : ScrollingHitObjectComposer<CatchHitObject>, IKeyBindingHandler<GlobalAction>
     {
-        public const float DISTANCE_SNAP_RADIUS = 50;
+        private const float distance_snap_radius = 50;
 
         private CatchDistanceSnapGrid distanceSnapGrid = null!;
 
@@ -136,12 +135,22 @@ namespace osu.Game.Rulesets.Catch.Edit
             DistanceSnapProvider.HandleToggleViaKey(key);
         }
 
-        public SnapResult? TryDistanceSnap(Vector2 screenSpacePosition)
+        public override SnapResult FindSnappedPositionAndTime(Vector2 screenSpacePosition, SnapType snapType = SnapType.All)
         {
-            if (distanceSnapGrid.IsPresent && distanceSnapGrid.GetSnappedPosition(screenSpacePosition) is SnapResult snapResult)
-                return snapResult;
+            var result = base.FindSnappedPositionAndTime(screenSpacePosition, snapType);
 
-            return null;
+            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;
         }
 
         private PalpableCatchHitObject? getLastSnappableHitObject(double time)

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

@@ -5,7 +5,6 @@ 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;
@@ -13,7 +12,6 @@ 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
@@ -40,13 +38,6 @@ 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;
@@ -57,60 +48,7 @@ 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

@@ -1,127 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Linq;
-using osu.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,12 +1,10 @@
 // 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.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;
 
@@ -37,39 +35,21 @@ 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 ExtendedIconInformation
+        public override string SettingDescription
         {
             get
             {
-                if (UserAdjustedSettingsCount != 1)
-                    return string.Empty;
+                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 (!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");
+                return string.Join(", ", new[]
+                {
+                    circleSize,
+                    base.SettingDescription,
+                    approachRate,
+                    spicyPatterns,
+                }.Where(s => !string.IsNullOrEmpty(s)));
             }
         }
 

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 extra lives!";
+        public override LocalisableString Description => @"Larger fruits, more forgiving HP drain, less accuracy required, and three lives!";
     }
 }

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

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Replays.Legacy;
 using osu.Game.Rulesets.Replays;
@@ -65,12 +64,5 @@ namespace osu.Game.Rulesets.Catch.Replays
 
             return new LegacyReplayFrame(Time, Position, null, state);
         }
-
-        public override bool IsEquivalentTo(ReplayFrame other)
-            => other is CatchReplayFrame catchFrame
-               && Time == catchFrame.Time
-               && Position == catchFrame.Position
-               && Dashing == catchFrame.Dashing
-               && Actions.SequenceEqual(catchFrame.Actions);
     }
 }

osu.Game.Rulesets.Catch/Skinning/Argon/ArgonBananaPiece.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.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
@@ -111,7 +110,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Argon
 
             double duration = ObjectState.HitObject.StartTime - ObjectState.DisplayStartTime;
 
-            fadeContent.Alpha = Math.Clamp(
+            fadeContent.Alpha = MathHelper.Clamp(
                 Interpolation.ValueAt(
                     Time.Current, 1f, 0f,
                     ObjectState.DisplayStartTime + duration * lens_flare_start,

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

@@ -4,7 +4,6 @@
 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;
@@ -48,8 +47,6 @@ 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)
                                 {
@@ -58,27 +55,11 @@ 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,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.
 
-using System;
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.UI;
@@ -17,8 +15,6 @@ 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;
@@ -30,49 +26,30 @@ namespace osu.Game.Rulesets.Catch.UI
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
 
-            InternalChild = scaleContainer = new Container
+            InternalChild = 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.Both,
+                RelativeSizeAxes = Axes.X,
+                Height = base_game_height + extra_bottom_space,
+                Y = extra_bottom_space / 2,
+                Masking = true,
                 Child = 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,
-                    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 }
-                    },
-                }
+                    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/Editor/Checks/CheckManiaConcurrentObjectsTest.cs

@@ -1,87 +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.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,6 +9,7 @@ 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;
@@ -22,8 +23,6 @@ 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>))]
@@ -48,11 +47,12 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
             });
         }
 
-        protected override void UpdatePlacementTimeAndPosition()
+        protected override SnapResult SnapForBlueprint(HitObjectPlacementBlueprint blueprint)
         {
             double time = column.TimeAtScreenSpacePosition(InputManager.CurrentState.Mouse.Position);
             var pos = column.ScreenSpacePositionAtTime(time);
-            CurrentBlueprint.UpdateTimeAndPosition(pos, time);
+
+            return new SnapResult(pos, time, column);
         }
 
         protected override Container CreateHitObjectContainer() => new ScrollingTestContainer(ScrollingDirection.Down) { RelativeSizeAxes = Axes.Both };

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

@@ -20,6 +20,7 @@ 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
 {
@@ -99,5 +100,10 @@ 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<SaveAndReloadEditorDialog>);
+            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().SingleOrDefault()?.CurrentDialog, Is.InstanceOf<ReloadEditorDialog>);
             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<SaveAndReloadEditorDialog>);
+            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().Single().CurrentDialog, Is.InstanceOf<ReloadEditorDialog>);
             AddStep("acquiesce", () => InputManager.Key(Key.Number1));
             AddUntilStep("beatmap became 8K", () => Game.Beatmap.Value.BeatmapInfo.Difficulty.CircleSize, () => Is.EqualTo(8));
         }

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

@@ -1,187 +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 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 ManiaModFadeIn(),
+                Mod = new ManiaModHidden(),
                 PassCondition = () => checkCoverage(ManiaModHidden.MIN_COVERAGE)
             });
         }
@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
         {
             CreateModTest(new ModTestData
             {
-                Mod = new ManiaModFadeIn(),
+                Mod = new ManiaModHidden(),
                 PassCondition = () => checkCoverage(ManiaModHidden.MIN_COVERAGE)
             });
 
@@ -48,7 +48,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
         {
             CreateModTest(new ModTestData
             {
-                Mod = new ManiaModFadeIn(),
+                Mod = new ManiaModHidden(),
                 PassCondition = () => checkCoverage(ManiaModHidden.MAX_COVERAGE)
             });
 
@@ -60,7 +60,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
         {
             CreateModTest(new ModTestData
             {
-                Mod = new ManiaModFadeIn(),
+                Mod = new ManiaModHidden(),
                 PassCondition = () => checkCoverage(ManiaModHidden.MAX_COVERAGE)
             });
 
@@ -73,7 +73,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
         {
             CreateModTest(new ModTestData
             {
-                Mod = new ManiaModFadeIn(),
+                Mod = new ManiaModHidden(),
                 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,12 +31,9 @@ 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 TestPerfectHits([Values] bool requirePerfectHits) => CreateModTest(new ModTestData
+        public void TestGreatHit() => CreateModTest(new ModTestData
         {
-            Mod = new ManiaModPerfect
-            {
-                RequirePerfectHits = { Value = requirePerfectHits }
-            },
+            Mod = new ManiaModPerfect(),
             PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(false),
             Autoplay = false,
             CreateBeatmap = () => new Beatmap
@@ -50,32 +47,6 @@ 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/Skinning/TestSceneColumnHitObjectArea.cs

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

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.IsHolding).Value = v;
+                    ((Bindable<bool>)holdNote.IsHitting).Value = v;
                 }
             });
         }

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

@@ -1,758 +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 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

@@ -1,215 +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.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

@@ -0,0 +1,49 @@
+// 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

@@ -1,61 +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.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

@@ -1,125 +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.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

@@ -1,149 +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 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,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
     <PackageReference Include="NUnit" Version="3.14.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
   </ItemGroup>

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

@@ -36,23 +36,20 @@ 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 = @"Notes",
+                    Name = @"Note Count",
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
                     Content = notes.ToString(),
-                    BarDisplayLength = notes / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Hold Notes",
+                    Name = @"Hold Note Count",
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
                     Content = holdNotes.ToString(),
-                    BarDisplayLength = holdNotes / (float)sum,
                 },
             };
         }

osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.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.Configuration.Tracking;
 using osu.Game.Configuration;
 using osu.Game.Localisation;
@@ -23,7 +24,17 @@ 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);
-            SetDefault(ManiaRulesetSetting.MobileLayout, ManiaMobileLayout.Portrait);
+
+#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
         }
 
         public override TrackedSettings CreateTrackedSettings() => new TrackedSettings
@@ -40,9 +51,10 @@ namespace osu.Game.Rulesets.Mania.Configuration
 
     public enum ManiaRulesetSetting
     {
+        [Obsolete("Use ScrollSpeed instead.")] // Can be removed 2023-11-30
+        ScrollTime,
         ScrollSpeed,
         ScrollDirection,
-        TimingBasedNoteColouring,
-        MobileLayout,
+        TimingBasedNoteColouring
     }
 }

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

@@ -2,6 +2,7 @@
 // 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;
 
@@ -9,12 +10,22 @@ 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)
@@ -22,6 +33,7 @@ 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,6 +27,7 @@ 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;
 
@@ -34,6 +35,7 @@ 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)
@@ -46,8 +48,11 @@ namespace osu.Game.Rulesets.Mania.Difficulty
 
             ManiaDifficultyAttributes attributes = new ManiaDifficultyAttributes
             {
-                StarRating = skills.OfType<Strain>().Single().DifficultyValue() * difficulty_multiplier,
+                StarRating = skills[0].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),
             };
 
@@ -119,5 +124,29 @@ 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 SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, double fallbackTime)
+        public override void UpdateTimeAndPosition(SnapResult result)
         {
-            var result = base.UpdateTimeAndPosition(screenSpacePosition, fallbackTime);
+            base.UpdateTimeAndPosition(result);
 
             if (PlacementActive == PlacementState.Active)
             {
@@ -121,8 +121,6 @@ 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,6 +5,7 @@ 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;
@@ -23,7 +24,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
         private EditorBeatmap? editorBeatmap { get; set; }
 
         [Resolved]
-        private ManiaHitObjectComposer? positionSnapProvider { get; set; }
+        private IPositionSnapProvider? 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.
 
-using System;
-using osu.Framework.Allocation;
+#nullable disable
+
 using osu.Framework.Graphics;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Edit;
@@ -20,18 +20,13 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
     {
         protected new T HitObject => (T)base.HitObject;
 
-        [Resolved]
-        private ManiaHitObjectComposer? composer { get; set; }
+        private Column column;
 
-        private Column? column;
-
-        public Column? Column
+        public Column Column
         {
             get => column;
             set
             {
-                ArgumentNullException.ThrowIfNull(value);
-
                 if (value == column)
                     return;
 
@@ -58,11 +53,9 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             return true;
         }
 
-        public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, double fallbackTime)
+        public override void UpdateTimeAndPosition(SnapResult result)
         {
-            var result = composer?.FindSnappedPositionAndTime(screenSpacePosition) ?? new SnapResult(screenSpacePosition, fallbackTime);
-
-            base.UpdateTimeAndPosition(result.ScreenSpacePosition, result.Time ?? fallbackTime);
+            base.UpdateTimeAndPosition(result);
 
             if (result.Playfield is Column col)
             {
@@ -83,8 +76,6 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
                 if (PlacementActive == PlacementState.Waiting)
                     Column = col;
             }
-
-            return result;
         }
 
         private float getNoteHeight(Column resultPlayfield) =>

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

@@ -8,7 +8,6 @@ using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Objects;
-using osuTK;
 using osuTK.Input;
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
@@ -36,17 +35,15 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             };
         }
 
-        public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, double referenceTime)
+        public override void UpdateTimeAndPosition(SnapResult result)
         {
-            var result = base.UpdateTimeAndPosition(screenSpacePosition, referenceTime);
+            base.UpdateTimeAndPosition(result);
 
             if (result.Playfield != null)
             {
                 piece.Width = result.Playfield.DrawWidth;
                 piece.Position = ToLocalSpace(result.ScreenSpacePosition);
             }
-
-            return result;
         }
 
         protected override bool OnMouseDown(MouseDownEvent e)

osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs

@@ -1,43 +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.Collections.Generic;
-using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Edit.Checks;
-using osu.Game.Rulesets.Edit.Checks.Components;
-using osu.Game.Rulesets.Objects.Types;
-
-namespace osu.Game.Rulesets.Mania.Edit.Checks
-{
-    public class CheckManiaConcurrentObjects : CheckConcurrentObjects
-    {
-        public override IEnumerable<Issue> Run(BeatmapVerifierContext context)
-        {
-            var hitObjects = context.Beatmap.HitObjects;
-
-            for (int i = 0; i < hitObjects.Count - 1; ++i)
-            {
-                var hitobject = hitObjects[i];
-
-                for (int j = i + 1; j < hitObjects.Count; ++j)
-                {
-                    var nextHitobject = hitObjects[j];
-
-                    // Mania hitobjects are only considered concurrent if they also share the same column.
-                    if ((hitobject as IHasColumn)?.Column != (nextHitobject as IHasColumn)?.Column)
-                        continue;
-
-                    // Two hitobjects cannot be concurrent without also being concurrent with all objects in between.
-                    // So if the next object is not concurrent, then we know no future objects will be either.
-                    if (!AreConcurrent(hitobject, nextHitobject))
-                        break;
-
-                    if (hitobject.GetType() == nextHitobject.GetType())
-                        yield return new IssueTemplateConcurrentSame(this).Create(hitobject, nextHitobject);
-                    else
-                        yield return new IssueTemplateConcurrentDifferent(this).Create(hitobject, nextHitobject);
-                }
-            }
-        }
-    }
-}

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

@@ -13,9 +13,6 @@ namespace osu.Game.Rulesets.Mania.Edit
     {
         private readonly List<ICheck> checks = new List<ICheck>
         {
-            // Compose
-            new CheckManiaConcurrentObjects(),
-
             // Settings
             new CheckKeyCount(),
             new CheckManiaAbnormalDifficultySettings(),

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

@@ -1,23 +1,17 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.Collections.Generic;
-using System.Linq;
-using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Edit.Blueprints;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Screens.Edit.Compose.Components;
-using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
     public partial class ManiaBlueprintContainer : ComposeBlueprintContainer
     {
-        public new ManiaHitObjectComposer Composer => (ManiaHitObjectComposer)base.Composer;
-
-        public ManiaBlueprintContainer(ManiaHitObjectComposer composer)
+        public ManiaBlueprintContainer(HitObjectComposer composer)
             : base(composer)
         {
         }
@@ -39,22 +33,5 @@ namespace osu.Game.Rulesets.Mania.Edit
         protected override SelectionHandler<HitObject> CreateSelectionHandler() => new ManiaSelectionHandler();
 
         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 result = Composer.FindSnappedPositionAndTime(movePosition);
-
-            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.Mania/Edit/ManiaHitObjectComposer.cs

@@ -19,7 +19,6 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
-    [Cached]
     public partial class ManiaHitObjectComposer : ScrollingHitObjectComposer<ManiaHitObject>
     {
         private DrawableManiaEditorRuleset drawableRuleset = null!;
@@ -65,11 +64,11 @@ namespace osu.Game.Rulesets.Mania.Edit
                 return;
 
             List<ManiaHitObject> remainingHitObjects = EditorBeatmap.HitObjects.Cast<ManiaHitObject>().Where(h => h.StartTime >= timestamp).ToList();
-            string[] objectDescriptions = objectDescription.Split(',');
+            string[] objectDescriptions = objectDescription.Split(',').ToArray();
 
             for (int i = 0; i < objectDescriptions.Length; i++)
             {
-                string[] split = objectDescriptions[i].Split('|');
+                string[] split = objectDescriptions[i].Split('|').ToArray();
                 if (split.Length != 2)
                     continue;
 

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

@@ -89,7 +89,6 @@ namespace osu.Game.Rulesets.Mania.Edit.Setup
                 {
                     Caption = EditorSetupStrings.BaseVelocity,
                     HintText = EditorSetupStrings.BaseVelocityDescription,
-                    KeyboardStep = 0.1f,
                     Current = new BindableDouble(Beatmap.Difficulty.SliderMultiplier)
                     {
                         Default = 1.4,
@@ -104,7 +103,6 @@ namespace osu.Game.Rulesets.Mania.Edit.Setup
                 {
                     Caption = EditorSetupStrings.TickRate,
                     HintText = EditorSetupStrings.TickRateDescription,
-                    KeyboardStep = 1,
                     Current = new BindableDouble(Beatmap.Difficulty.SliderTickRate)
                     {
                         Default = 1,
@@ -136,7 +134,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Setup
 
             updatingKeyCount = true;
 
-            editor.SaveAndReload().ContinueWith(t =>
+            editor.Reload().ContinueWith(t =>
             {
                 if (!t.GetResultSafely())
                 {

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

@@ -1,48 +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.Collections.Generic;
-using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Mania.Objects;
-
-namespace osu.Game.Rulesets.Mania.Judgements
-{
-    public class HoldNoteJudgementResult : JudgementResult
-    {
-        private Stack<(double time, bool holding)> holdingState { get; } = new Stack<(double, bool)>();
-
-        public HoldNoteJudgementResult(HoldNote hitObject, Judgement judgement)
-            : base(hitObject, judgement)
-        {
-            holdingState.Push((double.NegativeInfinity, false));
-        }
-
-        private (double time, bool holding) getLastReport(double currentTime)
-        {
-            while (holdingState.Peek().time > currentTime)
-                holdingState.Pop();
-
-            return holdingState.Peek();
-        }
-
-        public bool IsHolding(double currentTime) => getLastReport(currentTime).holding;
-
-        public bool DroppedHoldAfter(double time)
-        {
-            foreach (var state in holdingState)
-            {
-                if (state.time >= time && !state.holding)
-                    return true;
-            }
-
-            return false;
-        }
-
-        public void ReportHoldState(double currentTime, bool holding)
-        {
-            var lastReport = getLastReport(currentTime);
-            if (holding != lastReport.holding)
-                holdingState.Push((currentTime, holding));
-        }
-    }
-}

osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs

@@ -5,7 +5,6 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Bindables;
 using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.Formats;
 using osu.Game.Rulesets.Filter;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Mods;
@@ -18,72 +17,20 @@ namespace osu.Game.Rulesets.Mania
 {
     public class ManiaFilterCriteria : IRulesetFilterCriteria
     {
-        private readonly HashSet<int> includedKeyCounts = Enumerable.Range(1, LegacyBeatmapDecoder.MAX_MANIA_KEY_COUNT).ToHashSet();
+        private FilterCriteria.OptionalRange<float> keys;
 
         public bool Matches(BeatmapInfo beatmapInfo, FilterCriteria criteria)
         {
-            int keyCount = ManiaBeatmapConverter.GetColumnCount(LegacyBeatmapConversionDifficultyInfo.FromBeatmapInfo(beatmapInfo), criteria.Mods);
-
-            return includedKeyCounts.Contains(keyCount);
+            return !keys.HasFilter || keys.IsInRange(ManiaBeatmapConverter.GetColumnCount(LegacyBeatmapConversionDifficultyInfo.FromBeatmapInfo(beatmapInfo), criteria.Mods));
         }
 
-        public bool TryParseCustomKeywordCriteria(string key, Operator op, string strValues)
+        public bool TryParseCustomKeywordCriteria(string key, Operator op, string value)
         {
             switch (key)
             {
                 case "key":
                 case "keys":
-                {
-                    var keyCounts = new HashSet<int>();
-
-                    foreach (string strValue in strValues.Split(','))
-                    {
-                        if (!int.TryParse(strValue, out int keyCount))
-                            return false;
-
-                        keyCounts.Add(keyCount);
-                    }
-
-                    int? singleKeyCount = keyCounts.Count == 1 ? keyCounts.Single() : null;
-
-                    switch (op)
-                    {
-                        case Operator.Equal:
-                            includedKeyCounts.IntersectWith(keyCounts);
-                            return true;
-
-                        case Operator.NotEqual:
-                            includedKeyCounts.ExceptWith(keyCounts);
-                            return true;
-
-                        case Operator.Less:
-                            if (singleKeyCount == null) return false;
-
-                            includedKeyCounts.RemoveWhere(k => k >= singleKeyCount.Value);
-                            return true;
-
-                        case Operator.LessOrEqual:
-                            if (singleKeyCount == null) return false;
-
-                            includedKeyCounts.RemoveWhere(k => k > singleKeyCount.Value);
-                            return true;
-
-                        case Operator.Greater:
-                            if (singleKeyCount == null) return false;
-
-                            includedKeyCounts.RemoveWhere(k => k <= singleKeyCount.Value);
-                            return true;
-
-                        case Operator.GreaterOrEqual:
-                            if (singleKeyCount == null) return false;
-
-                            includedKeyCounts.RemoveWhere(k => k < singleKeyCount.Value);
-                            return true;
-
-                        default:
-                            return false;
-                    }
-                }
+                    return FilterQueryParser.TryUpdateCriteriaRange(ref keys, op, value);
             }
 
             return false;
@@ -91,7 +38,7 @@ namespace osu.Game.Rulesets.Mania
 
         public bool FilterMayChangeFromMods(ValueChangedEvent<IReadOnlyList<Mod>> mods)
         {
-            if (includedKeyCounts.Count != LegacyBeatmapDecoder.MAX_MANIA_KEY_COUNT)
+            if (keys.HasFilter)
             {
                 // Interpreting as the Mod type is required for equality comparison.
                 HashSet<Mod> oldSet = mods.OldValue.OfType<ManiaKeyMod>().AsEnumerable<Mod>().ToHashSet();

osu.Game.Rulesets.Mania/ManiaInputManager.cs

@@ -8,7 +8,7 @@ using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Mania
 {
-    [Cached] // Used for touch input, see Column.OnTouchDown/OnTouchUp.
+    [Cached] // Used for touch input, see ColumnTouchInputArea.
     public partial class ManiaInputManager : RulesetInputManager<ManiaAction>
     {
         public ManiaInputManager(RulesetInfo ruleset, int variant)

osu.Game.Rulesets.Mania/ManiaMobileLayout.cs

@@ -1,20 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Localisation;
-using osu.Game.Localisation;
-
-namespace osu.Game.Rulesets.Mania
-{
-    public enum ManiaMobileLayout
-    {
-        [LocalisableDescription(typeof(RulesetSettingsStrings), nameof(RulesetSettingsStrings.PortraitExpandedColumns))]
-        Portrait,
-
-        [LocalisableDescription(typeof(RulesetSettingsStrings), nameof(RulesetSettingsStrings.LandscapeExpandedColumns))]
-        Landscape,
-
-        [LocalisableDescription(typeof(RulesetSettingsStrings), nameof(RulesetSettingsStrings.LandscapeTouchOverlay))]
-        LandscapeWithOverlay,
-    }
-}

osu.Game.Rulesets.Mania/ManiaSettingsSubsection.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 osu.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Localisation;
@@ -45,17 +44,8 @@ namespace osu.Game.Rulesets.Mania
                     Keywords = new[] { "color" },
                     LabelText = RulesetSettingsStrings.TimingBasedColouring,
                     Current = config.GetBindable<bool>(ManiaRulesetSetting.TimingBasedNoteColouring),
-                },
+                }
             };
-
-            if (RuntimeInfo.IsMobile)
-            {
-                Add(new SettingsEnumDropdown<ManiaMobileLayout>
-                {
-                    LabelText = RulesetSettingsStrings.MobileLayout,
-                    Current = config.GetBindable<ManiaMobileLayout>(ManiaRulesetSetting.MobileLayout),
-                });
-            }
         }
 
         private partial class ManiaScrollSlider : RoundedSliderBar<double>

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

@@ -29,8 +29,6 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override bool Ranked => false;
 
-        public override bool ValidForFreestyleAsRequiredMod => false;
-
         [SettingSource("Coverage", "The proportion of playfield height that notes will be hidden for.")]
         public override BindableNumber<float> Coverage { get; } = new BindableFloat(0.5f)
         {

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

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

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

@@ -14,7 +14,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override string Acronym => "FI";
         public override LocalisableString Description => @"Keys appear out of nowhere!";
         public override double ScoreMultiplier => 1;
-        public override bool ValidForFreestyleAsRequiredMod => false;
 
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[]
         {

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

@@ -42,7 +42,8 @@ namespace osu.Game.Rulesets.Mania.Mods
                 var locations = column.OfType<Note>().Select(n => (startTime: n.StartTime, samples: n.Samples))
                                       .Concat(column.OfType<HoldNote>().SelectMany(h => new[]
                                       {
-                                          (startTime: h.StartTime, samples: h.GetNodeSamples(0))
+                                          (startTime: h.StartTime, samples: h.GetNodeSamples(0)),
+                                          (startTime: h.EndTime, samples: h.GetNodeSamples(1))
                                       }))
                                       .OrderBy(h => h.startTime).ToList();
 

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

@@ -62,7 +62,7 @@ namespace osu.Game.Rulesets.Mania.Mods
             protected override void CheckForResult(bool userTriggered, double timeOffset)
             {
                 // apply perfect once the tail is reached
-                if (HoldNote.IsHolding.Value && timeOffset >= 0)
+                if (HoldNote.HoldStartTime != null && timeOffset >= 0)
                     ApplyResult(GetCappedResult(HitResult.Perfect));
                 else
                     base.CheckForResult(userTriggered, timeOffset);

osu.Game.Rulesets.Mania/Mods/ManiaModPerfect.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.
 
-using osu.Framework.Bindables;
-using osu.Game.Configuration;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
@@ -11,16 +9,13 @@ namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModPerfect : ModPerfect
     {
-        [SettingSource("Require perfect hits")]
-        public BindableBool RequirePerfectHits { get; } = new BindableBool();
-
         protected override bool FailCondition(HealthProcessor healthProcessor, JudgementResult result)
         {
             if (!isRelevantResult(result.Judgement.MinResult) && !isRelevantResult(result.Judgement.MaxResult) && !isRelevantResult(result.Type))
                 return false;
 
             // Mania allows imperfect "Great" hits without failing.
-            if (result.Judgement.MaxResult == HitResult.Perfect && !RequirePerfectHits.Value)
+            if (result.Judgement.MaxResult == HitResult.Perfect)
                 return result.Type < HitResult.Great;
 
             return result.Type != result.Judgement.MaxResult;

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

@@ -34,7 +34,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 
             foreach (Column column in maniaPlayfield.Stages.SelectMany(stage => stage.Columns))
             {
-                HitObjectContainer hoc = column.HitObjectContainer;
+                HitObjectContainer hoc = column.HitObjectArea.HitObjectContainer;
                 Container hocParent = (Container)hoc.Parent!;
 
                 hocParent.Remove(hoc, false);

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

@@ -26,10 +26,9 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             : base(barLine)
         {
             RelativeSizeAxes = Axes.X;
-            Height = 1;
         }
 
-        [BackgroundDependencyLoader(true)]
+        [BackgroundDependencyLoader]
         private void load()
         {
             AddInternal(new SkinnableDrawable(new ManiaSkinComponentLookup(ManiaSkinComponents.BarLine), _ => new DefaultBarLine())
@@ -37,6 +36,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
             });
+
+            Major.BindValueChanged(major => Height = major.NewValue ? 1.7f : 1.2f, true);
         }
 
         protected override void OnApply()

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

@@ -11,8 +11,6 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Game.Audio;
-using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Mania.Skinning.Default;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -31,9 +29,9 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
     {
         public override bool DisplayResult => false;
 
-        public IBindable<bool> IsHolding => isHolding;
+        public IBindable<bool> IsHitting => isHitting;
 
-        private readonly Bindable<bool> isHolding = new Bindable<bool>();
+        private readonly Bindable<bool> isHitting = new Bindable<bool>();
 
         public DrawableHoldNoteHead Head => headContainer.Child;
         public DrawableHoldNoteTail Tail => tailContainer.Child;
@@ -57,6 +55,16 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
         private SkinnableDrawable bodyPiece;
 
+        /// <summary>
+        /// Time at which the user started holding this hold note. Null if the user is not holding this hold note.
+        /// </summary>
+        public double? HoldStartTime { get; private set; }
+
+        /// <summary>
+        /// Used to decide whether to visually clamp the hold note to the judgement line.
+        /// </summary>
+        private double? releaseTime;
+
         public DrawableHoldNote()
             : this(null)
         {
@@ -118,7 +126,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
             base.LoadComplete();
 
-            isHolding.BindValueChanged(updateSlidingSample, true);
+            isHitting.BindValueChanged(updateSlidingSample, true);
         }
 
         protected override void OnApply()
@@ -126,6 +134,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             base.OnApply();
 
             sizingContainer.Size = Vector2.One;
+            HoldStartTime = null;
+            releaseTime = null;
         }
 
         protected override void AddNestedHitObject(DrawableHitObject hitObject)
@@ -204,7 +214,11 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
             base.Update();
 
-            isHolding.Value = Result.IsHolding(Time.Current);
+            if (Time.Current < releaseTime)
+                releaseTime = null;
+
+            if (Time.Current < HoldStartTime)
+                endHold();
 
             // Pad the full size container so its contents (i.e. the masking container) reach under the tail.
             // This is required for the tail to not be masked away, since it lies outside the bounds of the hold note.
@@ -235,7 +249,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 //
                 // As per stable, this should not apply for early hits, waiting until the object starts to touch the
                 // judgement area first.
-                if (Head.IsHit && !Result.DroppedHoldAfter(HitObject.StartTime) && DrawHeight > 0)
+                if (Head.IsHit && releaseTime == null && DrawHeight > 0)
                 {
                     // How far past the hit target this hold note is.
                     float yOffset = Direction.Value == ScrollingDirection.Up ? -Y : Y;
@@ -246,10 +260,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 sizingContainer.Height = 1;
         }
 
-        protected override JudgementResult CreateResult(Judgement judgement) => new HoldNoteJudgementResult(HitObject, judgement);
-
-        public new HoldNoteJudgementResult Result => (HoldNoteJudgementResult)base.Result;
-
         protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
             if (Tail.AllJudged)
@@ -264,7 +274,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                     Body.TriggerResult(Tail.IsHit);
 
                 // Important that this is always called when a result is applied.
-                Result.ReportHoldState(Time.Current, false);
+                endHold();
             }
         }
 
@@ -273,7 +283,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             base.MissForcefully();
 
             // Important that this is always called when a result is applied.
-            Result.ReportHoldState(Time.Current, false);
+            endHold();
         }
 
         public bool OnPressed(KeyBindingPressEvent<ManiaAction> e)
@@ -307,7 +317,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             if (timeOffset < -Head.HitObject.HitWindows.WindowFor(HitResult.Miss))
                 return;
 
-            Result.ReportHoldState(Time.Current, true);
+            HoldStartTime = Time.Current;
+            isHitting.Value = true;
         }
 
         public void OnReleased(KeyBindingReleaseEvent<ManiaAction> e)
@@ -326,15 +337,22 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             // the user has released too early (before the tail).
             //
             // In such a case, we want to record this against the DrawableHoldNoteBody.
-            if (isHolding.Value)
+            if (HoldStartTime != null)
             {
                 Tail.UpdateResult();
                 Body.TriggerResult(Tail.IsHit);
 
-                Result.ReportHoldState(Time.Current, false);
+                endHold();
+                releaseTime = Time.Current;
             }
         }
 
+        private void endHold()
+        {
+            HoldStartTime = null;
+            isHitting.Value = false;
+        }
+
         protected override void LoadSamples()
         {
             // Note: base.LoadSamples() isn't called since the slider plays the tail's hitsounds for the time being.

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

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Replays.Legacy;
 using osu.Game.Rulesets.Replays;
@@ -48,8 +47,5 @@ namespace osu.Game.Rulesets.Mania.Replays
 
             return new LegacyReplayFrame(Time, keys, null, ReplayButtonState.None);
         }
-
-        public override bool IsEquivalentTo(ReplayFrame other)
-            => other is ManiaReplayFrame maniaFrame && Time == maniaFrame.Time && Actions.SequenceEqual(maniaFrame.Actions);
     }
 }

osu.Game.Rulesets.Mania/Skinning/Argon/ArgonHoldBodyPiece.cs

@@ -48,7 +48,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
 
                 AccentColour.BindTo(holdNote.AccentColour);
                 hittingLayer.AccentColour.BindTo(holdNote.AccentColour);
-                ((IBindable<bool>)hittingLayer.IsHitting).BindTo(holdNote.IsHolding);
+                ((IBindable<bool>)hittingLayer.IsHitting).BindTo(holdNote.IsHitting);
             }
 
             AccentColour.BindValueChanged(colour =>

osu.Game.Rulesets.Mania/Skinning/Argon/ArgonHoldNoteTailPiece.cs

@@ -103,7 +103,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
             hittingLayer.AccentColour.BindTo(holdNoteTail.HoldNote.AccentColour);
 
             hittingLayer.IsHitting.UnbindBindings();
-            ((IBindable<bool>)hittingLayer.IsHitting).BindTo(holdNoteTail.HoldNote.IsHolding);
+            ((IBindable<bool>)hittingLayer.IsHitting).BindTo(holdNoteTail.HoldNote.IsHitting);
         }
 
         private void onDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)