Lazer release 2025-09

For tagging purposes.
Update resources
2026-05-14 07:32:36 +08:00 · 2025-09-12 16:30:29 +09:00 · 2025-09-11 15:00:21 +09:00 · 2025-09-11 13:25:24 +09:00 · 2025-09-10 10:31:22 +02:00 · 2025-09-10 17:30:30 +09:00
1573 changed files with 67827 additions and 20731 deletions
@@ -36,7 +36,7 @@ jobs:
  generator:
    name: Run
    runs-on: self-hosted
-    timeout-minutes: 720
+    timeout-minutes: 1440

    outputs:
      target: ${{ steps.run.outputs.target }}
@@ -82,8 +82,18 @@ jobs:
        run: dotnet build -c Debug -warnaserror osu.Desktop.slnf

      - name: Test
-        run: dotnet test $pwd/**/*.Tests/bin/Debug/*/*.Tests.dll --logger "trx;LogFileName=TestResults-${{matrix.os.prettyname}}-${{matrix.threadingMode}}.trx" -- NUnit.ConsoleOut=0
-        shell: pwsh
+        run: >
+          dotnet test
+          osu.Game.Tests/bin/Debug/**/osu.Game.Tests.dll
+          osu.Game.Rulesets.Osu.Tests/bin/Debug/**/osu.Game.Rulesets.Osu.Tests.dll
+          osu.Game.Rulesets.Taiko.Tests/bin/Debug/**/osu.Game.Rulesets.Taiko.Tests.dll
+          osu.Game.Rulesets.Catch.Tests/bin/Debug/**/osu.Game.Rulesets.Catch.Tests.dll
+          osu.Game.Rulesets.Mania.Tests/bin/Debug/**/osu.Game.Rulesets.Mania.Tests.dll
+          osu.Game.Tournament.Tests/bin/Debug/**/osu.Game.Tournament.Tests.dll
+          Templates/**/*.Tests/bin/Debug/**/*.Tests.dll
+          --logger "trx;LogFileName=TestResults-${{matrix.os.prettyname}}-${{matrix.threadingMode}}.trx"
+          --
+          NUnit.ConsoleOut=0

      # Attempt to upload results even if test fails.
      # https://docs.github.com/en/actions/reference/context-and-expression-syntax-for-github-actions#always
@@ -96,7 +106,7 @@ jobs:

  build-only-android:
    name: Build only (Android)
-    runs-on: windows-2019
+    runs-on: windows-latest
    timeout-minutes: 60
    steps:
      - name: Checkout
@@ -114,17 +124,14 @@ jobs:
          dotnet-version: "8.0.x"

      - name: Install .NET workloads
-        # since windows image 20241113.3.0, not specifying a version here
-        # installs the .NET 7 version of android workload for very unknown reasons.
-        # revisit once we upgrade to .NET 9, it's probably fixed there.
-        run: dotnet workload install android --version (dotnet --version)
+        run: dotnet workload install android

      - name: Compile
        run: dotnet build -c Debug osu.Android.slnf

  build-only-ios:
    name: Build only (iOS)
-    runs-on: macos-latest
+    runs-on: macos-15
    timeout-minutes: 60
    steps:
      - name: Checkout
@@ -136,7 +143,12 @@ jobs:
          dotnet-version: "8.0.x"

      - name: Install .NET Workloads
-        run: dotnet workload install ios --from-rollback-file https://raw.githubusercontent.com/ppy/osu-framework/refs/heads/master/workloads.json
+        run: dotnet workload install ios
+
+      # https://github.com/dotnet/macios/issues/19157
+      # https://github.com/actions/runner-images/issues/12758
+      - name: Use Xcode 16.4
+        run: sudo xcode-select -switch /Applications/Xcode_16.4.app

      - name: Build
-        run: dotnet build -c Debug osu.iOS
+        run: dotnet build -c Debug osu.iOS.slnf
@@ -0,0 +1,87 @@
+name: Pack and nuget
+
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  notify_pending_production_deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Submit pending deployment notification
+        run: |
+          export TITLE="Pending osu Production Deployment: $GITHUB_REF_NAME"
+          export URL="https://github.com/ppy/osu/actions/runs/$GITHUB_RUN_ID"
+          export DESCRIPTION="Awaiting approval for building NuGet packages for tag $GITHUB_REF_NAME:
+          [View Workflow Run]($URL)"
+          export ACTOR_ICON="https://avatars.githubusercontent.com/u/$GITHUB_ACTOR_ID"
+
+          BODY="$(jq --null-input '{
+            "embeds": [
+              {
+                "title": env.TITLE,
+                "color": 15098112,
+                "description": env.DESCRIPTION,
+                "url": env.URL,
+                "author": {
+                  "name": env.GITHUB_ACTOR,
+                  "icon_url": env.ACTOR_ICON
+                }
+              }
+            ]
+          }')"
+
+          curl \
+            -H "Content-Type: application/json" \
+            -d "$BODY" \
+            "${{ secrets.DISCORD_INFRA_WEBHOOK_URL }}"
+
+  pack:
+    name: Pack
+    runs-on: ubuntu-latest
+    environment: production
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set artifacts directory
+        id: artifactsPath
+        run: echo "::set-output name=nuget_artifacts::${{github.workspace}}/artifacts"
+
+      - name: Install .NET 8.0.x
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: "8.0.x"
+
+      - name: Pack
+        run: |
+          # Replace project references in templates with package reference, because they're included as source files.
+          dotnet remove Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform/osu.Game.Rulesets.EmptyFreeform.csproj reference osu.Game/osu.Game.csproj
+          dotnet remove Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon/osu.Game.Rulesets.Pippidon.csproj reference osu.Game/osu.Game.csproj
+          dotnet remove Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling/osu.Game.Rulesets.EmptyScrolling.csproj reference osu.Game/osu.Game.csproj
+          dotnet remove Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/osu.Game.Rulesets.Pippidon.csproj reference osu.Game/osu.Game.csproj
+
+          dotnet add Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform/osu.Game.Rulesets.EmptyFreeform.csproj package ppy.osu.Game -n -v ${{ github.ref_name }}
+          dotnet add Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon/osu.Game.Rulesets.Pippidon.csproj package ppy.osu.Game -n -v ${{ github.ref_name }}
+          dotnet add Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling/osu.Game.Rulesets.EmptyScrolling.csproj package ppy.osu.Game -n -v ${{ github.ref_name }}
+          dotnet add Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/osu.Game.Rulesets.Pippidon.csproj package ppy.osu.Game -n -v ${{ github.ref_name }}
+
+          # Pack
+          dotnet pack -c Release osu.Game /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release osu.Game.Rulesets.Osu /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release osu.Game.Rulesets.Taiko /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release osu.Game.Rulesets.Catch /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release osu.Game.Rulesets.Mania /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release Templates /p:Version=${{ github.ref_name }} -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: osu
+          path: |
+            ${{steps.artifactsPath.outputs.nuget_artifacts}}/*.nupkg
+            ${{steps.artifactsPath.outputs.nuget_artifacts}}/*.snupkg
+
+      - name: Publish packages to nuget.org
+        run: dotnet nuget push ${{steps.artifactsPath.outputs.nuget_artifacts}}/*.nupkg --api-key ${{ secrets.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="deploymentTargetSelector">
+    <selectionStates>
+      <SelectionState runConfigName="osu.Android">
+        <option name="selectionMode" value="DROPDOWN" />
+      </SelectionState>
+    </selectionStates>
+  </component>
+</project>
@@ -18,3 +18,10 @@ M:Humanizer.InflectorExtensions.Pascalize(System.String);Humanizer's .Pascalize(
 M:Humanizer.InflectorExtensions.Camelize(System.String);Humanizer's .Camelize() extension method changes behaviour depending on CultureInfo.CurrentCulture. Use StringDehumanizeExtensions.ToCamelCase() instead.
 M:Humanizer.InflectorExtensions.Underscore(System.String);Humanizer's .Underscore() extension method changes behaviour depending on CultureInfo.CurrentCulture. Use StringDehumanizeExtensions.ToSnakeCase() instead.
 M:Humanizer.InflectorExtensions.Kebaberize(System.String);Humanizer's .Kebaberize() extension method changes behaviour depending on CultureInfo.CurrentCulture. Use StringDehumanizeExtensions.ToKebabCase() instead.
+M:osuTK.MathHelper.Clamp(System.Int32,System.Int32,System.Int32)~System.Int32;Use Math.Clamp() instead.
+M:osuTK.MathHelper.Clamp(System.Single,System.Single,System.Single)~System.Single;This osuTK helper has unsafe semantics when one of the bounds provided is NaN. Use Math.Clamp() instead.
+M:osuTK.MathHelper.Clamp(System.Double,System.Double,System.Double)~System.Double;This osuTK helper has unsafe semantics when one of the bounds provided is NaN. Use Math.Clamp() instead.
+M:TagLib.File.Create(System.String);TagLib's MIME type detection changes behaviour depending on CultureInfo.CurrentCulture. Use TagLibUtils.GetTagLibFile() instead.
+M:TagLib.File.Create(TagLib.File.IFileAbstraction);TagLib's MIME type detection changes behaviour depending on CultureInfo.CurrentCulture. Use TagLibUtils.GetTagLibFile() instead.
+M:TagLib.File.Create(System.String,TagLib.ReadStyle);TagLib's MIME type detection changes behaviour depending on CultureInfo.CurrentCulture. Use TagLibUtils.GetTagLibFile() instead.
+M:TagLib.File.Create(TagLib.File.IFileAbstraction,TagLib.ReadStyle);TagLib's MIME type detection changes behaviour depending on CultureInfo.CurrentCulture. Use TagLibUtils.GetTagLibFile() instead.
@@ -3,6 +3,10 @@
  <PropertyGroup Label="C#">
    <LangVersion>12.0</LangVersion>
    <Nullable>enable</Nullable>
+    <!-- Stabilises hot reload, see: https://platform.uno/docs/articles/studio/Hot%20Reload/hot-reload-overview.html?tabs=vswin%2Cwindows%2Cskia-desktop%2Ccommon-issues -->
+    <GenerateAssemblyInfo Condition="'$(Configuration)'=='Debug'">false</GenerateAssemblyInfo>
+    <!-- Required due to the above  -->
+    <NoWarn Condition="'$(Configuration)'=='Debug'">$(NoWarn);CA1416</NoWarn>
  </PropertyGroup>
  <PropertyGroup>
    <ApplicationManifest>$(MSBuildThisFileDirectory)app.manifest</ApplicationManifest>
@@ -46,7 +50,7 @@
    <RepositoryUrl>https://github.com/ppy/osu</RepositoryUrl>
    <PackageReleaseNotes>Automated release.</PackageReleaseNotes>
    <Company>ppy Pty Ltd</Company>
-    <Copyright>Copyright (c) 2024 ppy Pty Ltd</Copyright>
+    <Copyright>Copyright (c) 2025 ppy Pty Ltd</Copyright>
    <PackageTags>osu game</PackageTags>
  </PropertyGroup>
 </Project>
@@ -1,4 +1,4 @@
-Copyright (c) 2024 ppy Pty Ltd <contact@ppy.sh>.
+Copyright (c) 2025 ppy Pty Ltd <contact@ppy.sh>.

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -9,7 +9,7 @@
      <GenerateProgramFile>false</GenerateProgramFile>
    </PropertyGroup>
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
    <PackageReference Include="NUnit" Version="3.14.0" />
    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
  </ItemGroup>
@@ -2,6 +2,7 @@
 // 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;

@@ -17,5 +18,8 @@ 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);
    }
 }
@@ -9,7 +9,7 @@
    <GenerateProgramFile>false</GenerateProgramFile>
  </PropertyGroup>
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
    <PackageReference Include="NUnit" Version="3.14.0" />
    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
  </ItemGroup>
@@ -9,5 +9,8 @@ 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;
    }
 }
@@ -9,7 +9,7 @@
    <GenerateProgramFile>false</GenerateProgramFile>
  </PropertyGroup>
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
    <PackageReference Include="NUnit" Version="3.14.0" />
    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
  </ItemGroup>
@@ -2,6 +2,7 @@
 // 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
@@ -15,5 +16,8 @@ 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);
    }
 }
@@ -9,7 +9,7 @@
    <GenerateProgramFile>false</GenerateProgramFile>
  </PropertyGroup>
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
    <PackageReference Include="NUnit" Version="3.14.0" />
    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
  </ItemGroup>
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
@@ -9,7 +10,6 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Pippidon.Objects;
 using osu.Game.Rulesets.Pippidon.UI;
-using osuTK;

 namespace osu.Game.Rulesets.Pippidon.Beatmaps
 {
@@ -40,7 +40,7 @@ namespace osu.Game.Rulesets.Pippidon.Beatmaps
            };
        }

-        private int getLane(HitObject hitObject) => (int)MathHelper.Clamp(
+        private int getLane(HitObject hitObject) => (int)Math.Clamp(
            (getUsablePosition(hitObject) - minPosition) / (maxPosition - minPosition) * PippidonPlayfield.LANE_COUNT, 0, PippidonPlayfield.LANE_COUNT - 1);

        private float getUsablePosition(HitObject h) => (h as IHasYPosition)?.Y ?? ((IHasXPosition)h).X;
@@ -2,6 +2,7 @@
 // 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
@@ -15,5 +16,8 @@ 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);
    }
 }
@@ -8,7 +8,7 @@
    <PackageProjectUrl>https://github.com/ppy/osu/blob/master/Templates</PackageProjectUrl>
    <RepositoryUrl>https://github.com/ppy/osu</RepositoryUrl>
    <PackageReleaseNotes>Automated release.</PackageReleaseNotes>
-    <copyright>Copyright (c) 2024 ppy Pty Ltd</copyright>
+    <copyright>Copyright (c) 2025 ppy Pty Ltd</copyright>
    <Description>Templates to use when creating a ruleset for consumption in osu!.</Description>
    <PackageTags>dotnet-new;templates;osu</PackageTags>
    <TargetFramework>netstandard2.1</TargetFramework>
@@ -1,32 +0,0 @@
-clone_depth: 1
-version: '{branch}-{build}'
-image: Visual Studio 2022
-cache:
-  - '%LOCALAPPDATA%\NuGet\v3-cache -> appveyor.yml'
-
-dotnet_csproj:
-  patch: true
-  file: 'osu.Game\osu.Game.csproj' # Use wildcard when it's able to exclude Xamarin projects
-  version: '0.0.{build}'
-
-before_build:
-  - cmd: dotnet --info # Useful when version mismatch between CI and local
-  - cmd: dotnet workload install maui-android # Change to `dotnet workload restore` once there's no old projects
-  - cmd: dotnet workload install maui-ios # Change to `dotnet workload restore` once there's no old projects
-  - cmd: nuget restore -verbosity quiet # Only nuget.exe knows both new (.NET Core) and old (Xamarin) projects
-
-build:
-  project: osu.sln
-  parallel: true
-  verbosity: minimal
-  publish_nuget: true
-
-after_build:
-  - ps: .\InspectCode.ps1
-
-test:
-  assemblies:
-    except:
-      - '**\*Android*'
-      - '**\*iOS*'
-      - 'build\**\*'
@@ -1,86 +0,0 @@
-clone_depth: 1
-version: '{build}'
-image: Visual Studio 2022
-test: off
-skip_non_tags: true
-configuration: Release
-
-environment:
-  matrix:
-    - job_name: osu-game
-    - job_name: osu-ruleset
-      job_depends_on: osu-game
-    - job_name: taiko-ruleset
-      job_depends_on: osu-game
-    - job_name: catch-ruleset
-      job_depends_on: osu-game
-    - job_name: mania-ruleset
-      job_depends_on: osu-game
-    - job_name: templates
-      job_depends_on: osu-game
-
-nuget:
-  project_feed: true
-
-for:
-  -
-    matrix:
-      only:
-        - job_name: osu-game
-    build_script:
-      - cmd: dotnet pack osu.Game\osu.Game.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: osu-ruleset
-    build_script:
-      - cmd: dotnet remove osu.Game.Rulesets.Osu\osu.Game.Rulesets.Osu.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet add osu.Game.Rulesets.Osu\osu.Game.Rulesets.Osu.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet pack osu.Game.Rulesets.Osu\osu.Game.Rulesets.Osu.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: taiko-ruleset
-    build_script:
-      - cmd: dotnet remove osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet add osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet pack osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: catch-ruleset
-    build_script:
-      - cmd: dotnet remove osu.Game.Rulesets.Catch\osu.Game.Rulesets.Catch.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet add osu.Game.Rulesets.Catch\osu.Game.Rulesets.Catch.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet pack osu.Game.Rulesets.Catch\osu.Game.Rulesets.Catch.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: mania-ruleset
-    build_script:
-      - cmd: dotnet remove osu.Game.Rulesets.Mania\osu.Game.Rulesets.Mania.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet add osu.Game.Rulesets.Mania\osu.Game.Rulesets.Mania.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet pack osu.Game.Rulesets.Mania\osu.Game.Rulesets.Mania.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: templates
-    build_script:
-      - cmd: dotnet remove Templates\Rulesets\ruleset-empty\osu.Game.Rulesets.EmptyFreeform\osu.Game.Rulesets.EmptyFreeform.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet remove Templates\Rulesets\ruleset-example\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet remove Templates\Rulesets\ruleset-scrolling-empty\osu.Game.Rulesets.EmptyScrolling\osu.Game.Rulesets.EmptyScrolling.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet remove Templates\Rulesets\ruleset-scrolling-example\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj reference osu.Game\osu.Game.csproj
-
-      - cmd: dotnet add Templates\Rulesets\ruleset-empty\osu.Game.Rulesets.EmptyFreeform\osu.Game.Rulesets.EmptyFreeform.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet add Templates\Rulesets\ruleset-example\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet add Templates\Rulesets\ruleset-scrolling-empty\osu.Game.Rulesets.EmptyScrolling\osu.Game.Rulesets.EmptyScrolling.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet add Templates\Rulesets\ruleset-scrolling-example\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-
-      - cmd: dotnet pack Templates\osu.Game.Templates.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-
-artifacts:
-  - path: '**\*.nupkg'
-
-deploy:
-  - provider: Environment
-    name: nuget
@@ -10,7 +10,7 @@
    <EmbedAssembliesIntoApk>true</EmbedAssembliesIntoApk>
  </PropertyGroup>
  <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2025.204.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2025.908.0" />
  </ItemGroup>
  <PropertyGroup>
    <!-- Fody does not handle Android build well, and warns when unchanged.
@@ -2,16 +2,19 @@
 // See the LICENCE file in the repository root for full licence text.

 using System;
+using System.Linq;
 using Android.App;
 using Android.Content.PM;
 using Microsoft.Maui.Devices;
 using osu.Framework.Allocation;
+using osu.Framework.Development;
 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
 {
@@ -20,56 +23,30 @@ namespace osu.Android
        [Cached]
        private readonly OsuGameActivity gameActivity;

+        private readonly PackageInfo packageInfo;
+
+        public override Vector2 ScalingContainerTargetDrawSize => new Vector2(1024, 1024 * DrawHeight / DrawWidth);
+
        public OsuGameAndroid(OsuGameActivity activity)
            : base(null)
        {
            gameActivity = activity;
+            packageInfo = Application.Context.ApplicationContext!.PackageManager!.GetPackageInfo(Application.Context.ApplicationContext.PackageName!, 0).AsNonNull();
        }

-        public override Version AssemblyVersion
+        public override string Version
        {
            get
            {
-                var packageInfo = Application.Context.ApplicationContext!.PackageManager!.GetPackageInfo(Application.Context.ApplicationContext.PackageName!, 0).AsNonNull();
+                if (!IsDeployedBuild)
+                    return @"local " + (DebugUtils.IsDebugBuild ? @"debug" : @"release");

-                try
-                {
-                    // We store the osu! build number in the "VersionCode" field to better support google play releases.
-                    // If we were to use the main build number, it would require a new submission each time (similar to TestFlight).
-                    // In order to do this, we should split it up and pad the numbers to still ensure sequential increase over time.
-                    //
-                    // We also need to be aware that older SDK versions store this as a 32bit int.
-                    //
-                    // Basic conversion format (as done in Fastfile): 2020.606.0 -> 202006060
-
-                    // https://stackoverflow.com/questions/52977079/android-sdk-28-versioncode-in-packageinfo-has-been-deprecated
-                    string versionName;
-
-                    if (OperatingSystem.IsAndroidVersionAtLeast(28))
-                    {
-                        versionName = packageInfo.LongVersionCode.ToString();
-                        // ensure we only read the trailing portion of long (the part we are interested in).
-                        versionName = versionName.Substring(versionName.Length - 9);
-                    }
-                    else
-                    {
-#pragma warning disable CS0618 // Type or member is obsolete
-                        // this is required else older SDKs will report missing method exception.
-                        versionName = packageInfo.VersionCode.ToString();
-#pragma warning restore CS0618 // Type or member is obsolete
-                    }
-
-                    // undo play store version garbling (as mentioned above).
-                    return new Version(int.Parse(versionName.Substring(0, 4)), int.Parse(versionName.Substring(4, 4)), int.Parse(versionName.Substring(8, 1)));
-                }
-                catch
-                {
-                }
-
-                return new Version(packageInfo.VersionName.AsNonNull());
+                return packageInfo.VersionName.AsNonNull();
            }
        }

+        public override Version AssemblyVersion => new Version(packageInfo.VersionName.AsNonNull().Split('-').First());
+
        protected override void LoadComplete()
        {
            base.LoadComplete();
@@ -173,7 +173,7 @@ namespace osu.Desktop
                        new Button
                        {
                            Label = "View beatmap",
-                            Url = $@"{api.WebsiteRootUrl}/beatmaps/{beatmapId}?mode={ruleset.Value.ShortName}"
+                            Url = $@"{api.Endpoints.WebsiteUrl}/beatmaps/{beatmapId}?mode={ruleset.Value.ShortName}"
                        }
                    };
                }
@@ -17,6 +17,7 @@ using osu.Framework.Logging;
 using osu.Game.Updater;
 using osu.Desktop.Windows;
 using osu.Framework.Allocation;
+using osu.Game.Configuration;
 using osu.Game.IO;
 using osu.Game.IPC;
 using osu.Game.Online.Multiplayer;
@@ -33,6 +34,8 @@ namespace osu.Desktop
        [Cached(typeof(IHighPerformanceSessionManager))]
        private readonly HighPerformanceSessionManager highPerformanceSessionManager = new HighPerformanceSessionManager();

+        public bool IsFirstRun { get; init; }
+
        public OsuGameDesktop(string[]? args = null)
            : base(args)
        {
@@ -104,6 +107,14 @@ namespace osu.Desktop

        protected override UpdateManager CreateUpdateManager()
        {
+            // If this is the first time we've run the game, ie it is being installed,
+            // reset the user's release stream to "lazer".
+            //
+            // This ensures that if a user is trying to recover from a failed startup on an unstable release stream,
+            // the game doesn't immediately try and update them back to the release stream after starting up.
+            if (IsFirstRun)
+                LocalConfig.SetValue(OsuSetting.ReleaseStream, ReleaseStream.Lazer);
+
            if (IsPackageManaged)
                return new NoActionUpdateManager();

@@ -112,7 +123,7 @@ namespace osu.Desktop

        public override bool RestartAppWhenExited()
        {
-            Task.Run(() => Velopack.UpdateExe.Start()).FireAndForget();
+            Task.Run(() => Velopack.UpdateExe.Start(waitPid: (uint)Environment.ProcessId)).FireAndForget();
            return true;
        }

@@ -28,13 +28,15 @@ namespace osu.Desktop

        private static LegacyTcpIpcProvider? legacyIpc;

+        private static bool isFirstRun;
+
        [STAThread]
        public static void Main(string[] args)
        {
            // IMPORTANT DON'T IGNORE: For general sanity, velopack's setup needs to run before anything else.
            // This has bitten us in the rear before (bricked updater), and although the underlying issue from
            // last time has been fixed, let's not tempt fate.
-            setupVelopack();
+            setupVelopack(args);

            if (OperatingSystem.IsWindows())
            {
@@ -135,7 +137,12 @@ namespace osu.Desktop
                if (tournamentClient)
                    host.Run(new TournamentGame());
                else
-                    host.Run(new OsuGameDesktop(args));
+                {
+                    host.Run(new OsuGameDesktop(args)
+                    {
+                        IsFirstRun = isFirstRun
+                    });
+                }
            }
        }

@@ -167,8 +174,21 @@ namespace osu.Desktop
            return false;
        }

-        private static void setupVelopack()
+        private static void setupVelopack(string[] args)
        {
+            // Arguments being present indicate the user is either starting the game in a special (aka tournament) mode,
+            // or is running with pending imports via file association or otherwise.
+            //
+            // In both these scenarios, we'd hope the game does not attempt to update.
+            //
+            // Special consideration for velopack startup arguments, which must be handled during update.
+            // See https://docs.velopack.io/integrating/hooks#command-line-hooks.
+            if (args.Length > 0 && !args[0].StartsWith("--velo", StringComparison.Ordinal))
+            {
+                Logger.Log("Handling arguments, skipping velopack setup.");
+                return;
+            }
+
            if (OsuGameDesktop.IsPackageManaged)
            {
                Logger.Log("Updates are being managed by an external provider. Skipping Velopack setup.");
@@ -177,6 +197,8 @@ namespace osu.Desktop

            var app = VelopackApp.Build();

+            app.OnFirstRun(_ => isFirstRun = true);
+
            if (OperatingSystem.IsWindows())
                configureWindows(app);

@@ -186,9 +208,9 @@ namespace osu.Desktop
        [SupportedOSPlatform("windows")]
        private static void configureWindows(VelopackApp app)
        {
-            app.WithFirstRun(_ => WindowsAssociationManager.InstallAssociations());
-            app.WithAfterUpdateFastCallback(_ => WindowsAssociationManager.UpdateAssociations());
-            app.WithBeforeUninstallFastCallback(_ => WindowsAssociationManager.UninstallAssociations());
+            app.OnFirstRun(_ => WindowsAssociationManager.InstallAssociations());
+            app.OnAfterUpdateFastCallback(_ => WindowsAssociationManager.UpdateAssociations());
+            app.OnBeforeUninstallFastCallback(_ => WindowsAssociationManager.UninstallAssociations());
        }
    }
 }
@@ -2,22 +2,25 @@
 // See the LICENCE file in the repository root for full licence text.

 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Logging;
+using osu.Framework.Threading;
 using osu.Game;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Screens.Play;
 using Velopack;
 using Velopack.Sources;
+using UpdateManager = osu.Game.Updater.UpdateManager;

 namespace osu.Desktop.Updater
 {
-    public partial class VelopackUpdateManager : Game.Updater.UpdateManager
+    public partial class VelopackUpdateManager : UpdateManager
    {
-        private readonly UpdateManager updateManager;
-        private INotificationOverlay notificationOverlay = null!;
+        [Resolved]
+        private INotificationOverlay notificationOverlay { get; set; } = null!;

        [Resolved]
        private OsuGameBase game { get; set; } = null!;
@@ -27,122 +30,128 @@ namespace osu.Desktop.Updater

        private bool isInGameplay => localUserInfo?.PlayingState.Value != LocalUserPlayingState.NotPlaying;

-        private UpdateInfo? pendingUpdate;
+        private ScheduledDelegate? scheduledBackgroundCheck;

-        public VelopackUpdateManager()
+        private void scheduleNextUpdateCheck()
        {
-            updateManager = new UpdateManager(new GithubSource(@"https://github.com/ppy/osu", null, false), new UpdateOptions
+            scheduledBackgroundCheck?.Cancel();
+            scheduledBackgroundCheck = Scheduler.AddDelayed(() =>
            {
-                AllowVersionDowngrade = true,
-            });
+                log("Running scheduled background update check...");
+                CheckForUpdate();
+            }, 60000 * 30);
        }

-        [BackgroundDependencyLoader]
-        private void load(INotificationOverlay notifications)
+        protected override async Task<bool> PerformUpdateCheck(CancellationToken cancellationToken)
        {
-            notificationOverlay = notifications;
-        }
+            scheduledBackgroundCheck?.Cancel();

-        protected override async Task<bool> PerformUpdateCheck() => await checkForUpdateAsync().ConfigureAwait(false);
-
-        private async Task<bool> checkForUpdateAsync()
-        {
-            // whether to check again in 30 minutes. generally only if there's an error or no update was found (yet).
-            bool scheduleRecheck = false;
+            if (isInGameplay)
+            {
+                log("Update check cancelled - user is in gameplay");
+                scheduleNextUpdateCheck();
+                return false;
+            }

            try
            {
-                // Avoid any kind of update checking while gameplay is running.
-                if (isInGameplay)
+                IUpdateSource updateSource = new GithubSource(@"https://github.com/ppy/osu", null, ReleaseStream.Value == Game.Configuration.ReleaseStream.Tachyon);
+                Velopack.UpdateManager updateManager = new Velopack.UpdateManager(updateSource, new UpdateOptions
                {
-                    scheduleRecheck = true;
+                    AllowVersionDowngrade = true
+                });
+
+                UpdateInfo? update = await updateManager.CheckForUpdatesAsync().ConfigureAwait(false);
+
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    log("Update check cancelled");
+                    scheduleNextUpdateCheck();
                    return true;
                }

-                // TODO: we should probably be checking if there's a more recent update, rather than shortcutting here.
-                // Velopack does support this scenario (see https://github.com/ppy/osu/pull/28743#discussion_r1743495975).
-                if (pendingUpdate != null)
+                if (update == null)
                {
-                    // If there is an update pending restart, show the notification to restart again.
-                    notificationOverlay.Post(new UpdateApplicationCompleteNotification
-                    {
-                        Activated = () =>
-                        {
-                            Task.Run(restartToApplyUpdate);
-                            return true;
-                        }
-                    });
-
-                    return true;
-                }
-
-                pendingUpdate = await updateManager.CheckForUpdatesAsync().ConfigureAwait(false);
-
-                // No update is available. We'll check again later.
-                if (pendingUpdate == null)
-                {
-                    scheduleRecheck = true;
+                    // No update is available.
+                    log("No update found");
+                    scheduleNextUpdateCheck();
                    return false;
                }

-                // An update is found, let's notify the user and start downloading it.
-                UpdateProgressNotification notification = new UpdateProgressNotification
-                {
-                    CompletionClickAction = () =>
-                    {
-                        Task.Run(restartToApplyUpdate);
-                        return true;
-                    },
-                };
-
-                runOutsideOfGameplay(() => notificationOverlay.Post(notification));
-                notification.StartDownload();
-
-                try
-                {
-                    await updateManager.DownloadUpdatesAsync(pendingUpdate, p => notification.Progress = p / 100f).ConfigureAwait(false);
-                    runOutsideOfGameplay(() => notification.State = ProgressNotificationState.Completed);
-                }
-                catch (Exception e)
-                {
-                    // In the case of an error, a separate notification will be displayed.
-                    scheduleRecheck = true;
-                    notification.FailDownload();
-                    Logger.Error(e, @"update failed!");
-                }
+                // Download update in the background while notifying awaiters of the update being available.
+                log($"New update available: {update.TargetFullRelease.Version}");
+                downloadUpdate(updateManager, update, cancellationToken);
+                return true;
            }
            catch (Exception e)
            {
-                // we'll ignore this and retry later. can be triggered by no internet connection or thread abortion.
-                scheduleRecheck = true;
-                Logger.Log($@"update check failed ({e.Message})");
+                log($"Update check failed with error ({e.Message})");
+
+                // we shouldn't crash on a web failure. or any failure for the matter.
+                scheduleNextUpdateCheck();
+                return true;
            }
-            finally
+        }
+
+        private void downloadUpdate(Velopack.UpdateManager updateManager, UpdateInfo update, CancellationToken cancellationToken) => Task.Run(async () =>
+        {
+            log($"Beginning download of update {update.TargetFullRelease.Version}...");
+
+            UpdateDownloadProgressNotification progressNotification = new UpdateDownloadProgressNotification(cancellationToken)
            {
-                if (scheduleRecheck)
+                CompletionClickAction = () =>
                {
-                    Scheduler.AddDelayed(() => Task.Run(async () => await checkForUpdateAsync().ConfigureAwait(false)), 60000 * 30);
+                    restartToApplyUpdate(updateManager, update);
+                    return true;
                }
+            };
+
+            try
+            {
+                using (var cts = CancellationTokenSource.CreateLinkedTokenSource(progressNotification.CancellationToken, cancellationToken))
+                {
+                    progressNotification.StartDownload();
+                    runOutsideOfGameplay(() => notificationOverlay.Post(progressNotification), cts.Token);
+
+                    await updateManager.DownloadUpdatesAsync(update, p => progressNotification.Progress = p / 100f, cts.Token).ConfigureAwait(false);
+                    runOutsideOfGameplay(() => progressNotification.State = ProgressNotificationState.Completed, cts.Token);
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                progressNotification.FailDownload();
+                log(@"Update cancelled");
+            }
+            catch (Exception e)
+            {
+                // In the case of an error, a separate notification will be displayed.
+                progressNotification.FailDownload();
+                Logger.Error(e, @"Update failed!");
            }

            return true;
-        }
+        }, cancellationToken);

-        private void runOutsideOfGameplay(Action action)
+        private void runOutsideOfGameplay(Action action, CancellationToken cancellationToken)
        {
+            if (cancellationToken.IsCancellationRequested)
+                return;
+
            if (isInGameplay)
            {
-                Scheduler.AddDelayed(() => runOutsideOfGameplay(action), 1000);
+                Scheduler.AddDelayed(() => runOutsideOfGameplay(action, cancellationToken), 1000);
                return;
            }

            action();
        }

-        private async Task restartToApplyUpdate()
+        private void restartToApplyUpdate(Velopack.UpdateManager updateManager, UpdateInfo update) => Task.Run(async () =>
        {
-            await updateManager.WaitExitThenApplyUpdatesAsync(pendingUpdate?.TargetFullRelease).ConfigureAwait(false);
+            await updateManager.WaitExitThenApplyUpdatesAsync(update.TargetFullRelease).ConfigureAwait(false);
            Schedule(() => game.AttemptExit());
-        }
+        });
+
+        private static void log(string text) => Logger.Log($"VelopackUpdateManager: {text}");
    }
 }
@@ -24,9 +24,9 @@
    <ProjectReference Include="..\osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj" />
  </ItemGroup>
  <ItemGroup Label="Package References">
-    <PackageReference Include="System.IO.Packaging" Version="9.0.0" />
+    <PackageReference Include="System.IO.Packaging" Version="9.0.2" />
    <PackageReference Include="DiscordRichPresence" Version="1.2.1.24" />
-    <PackageReference Include="Velopack" Version="0.0.1053" />
+    <PackageReference Include="Velopack" Version="0.0.1298" />
  </ItemGroup>
  <ItemGroup Label="Resources">
    <EmbeddedResource Include="lazer.ico" />
@@ -12,7 +12,7 @@
        <requireLicenseAcceptance>false</requireLicenseAcceptance>
        <description>A free-to-win rhythm game. Rhythm is just a *click* away!</description>
        <releaseNotes>testing</releaseNotes>
-        <copyright>Copyright (c) 2024 ppy Pty Ltd</copyright>
+        <copyright>Copyright (c) 2025 ppy Pty Ltd</copyright>
        <language>en-AU</language>
    </metadata>
    <files>
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.Mods;

 namespace osu.Game.Rulesets.Catch.Tests
 {
@@ -21,8 +22,9 @@ namespace osu.Game.Rulesets.Catch.Tests
        {
            var ruleset = new CatchRuleset();
            var difficulty = new BeatmapDifficulty { ApproachRate = originalApproachRate };
+            var beatmapInfo = new BeatmapInfo { Difficulty = difficulty };

-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 1);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(beatmapInfo, []);

            Assert.That(adjustedDifficulty.ApproachRate, Is.EqualTo(originalApproachRate));
        }
@@ -32,8 +34,9 @@ namespace osu.Game.Rulesets.Catch.Tests
        {
            var ruleset = new CatchRuleset();
            var difficulty = new BeatmapDifficulty();
+            var beatmapInfo = new BeatmapInfo { Difficulty = difficulty };

-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 0.75);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(beatmapInfo, [new CatchModHalfTime()]);

            Assert.That(adjustedDifficulty.ApproachRate, Is.EqualTo(1.67).Within(0.01));
        }
@@ -43,8 +46,9 @@ namespace osu.Game.Rulesets.Catch.Tests
        {
            var ruleset = new CatchRuleset();
            var difficulty = new BeatmapDifficulty();
+            var beatmapInfo = new BeatmapInfo { Difficulty = difficulty };

-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 1.5);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(beatmapInfo, [new CatchModDoubleTime()]);

            Assert.That(adjustedDifficulty.ApproachRate, Is.EqualTo(7.67).Within(0.01));
        }
@@ -22,6 +22,8 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
 {
    public abstract partial class CatchPlacementBlueprintTestScene : PlacementBlueprintTestScene
    {
+        protected sealed override Ruleset CreateRuleset() => new CatchRuleset();
+
        protected const double TIME_SNAP = 100;

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

+using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
+using osu.Game.Localisation;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Objects;

@@ -16,26 +18,30 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
            int fruits = HitObjects.Count(s => s is Fruit);
            int juiceStreams = HitObjects.Count(s => s is JuiceStream);
            int bananaShowers = HitObjects.Count(s => s is BananaShower);
+            int sum = Math.Max(1, fruits + juiceStreams);

            return new[]
            {
                new BeatmapStatistic
                {
-                    Name = @"Fruit Count",
+                    Name = BeatmapStatisticStrings.Fruits,
                    Content = fruits.ToString(),
                    CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
+                    BarDisplayLength = fruits / (float)sum,
                },
                new BeatmapStatistic
                {
-                    Name = @"Juice Stream Count",
+                    Name = BeatmapStatisticStrings.JuiceStreams,
                    Content = juiceStreams.ToString(),
                    CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
+                    BarDisplayLength = juiceStreams / (float)sum,
                },
                new BeatmapStatistic
                {
-                    Name = @"Banana Shower Count",
+                    Name = BeatmapStatisticStrings.BananaShowers,
                    Content = bananaShowers.ToString(),
                    CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Spinners),
+                    BarDisplayLength = Math.Min(bananaShowers / 10f, 1),
                }
            };
        }
@@ -45,7 +45,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                        LegacyConvertedY = yPositionData?.Y ?? CatchHitObject.DEFAULT_LEGACY_CONVERT_Y,
                        // prior to v8, speed multipliers don't adjust for how many ticks are generated over the same distance.
                        // this results in more (or less) ticks being generated in <v8 maps for the same time duration.
-                        TickDistanceMultiplier = beatmap.BeatmapInfo.BeatmapVersion < 8 ? 1f / ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(obj.StartTime).SliderVelocity : 1,
+                        TickDistanceMultiplier = beatmap.BeatmapVersion < 8 ? 1f / ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(obj.StartTime).SliderVelocity : 1,
                        SliderVelocityMultiplier = sliderVelocityData?.SliderVelocityMultiplier ?? 1
                    }.Yield();

@@ -3,6 +3,7 @@

 using System;
 using System.Collections.Generic;
+using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
@@ -11,6 +12,7 @@ using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Graphics;
+using osu.Game.Localisation;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Difficulty;
 using osu.Game.Rulesets.Catch.Edit;
@@ -25,6 +27,7 @@ using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Scoring.Legacy;
@@ -33,6 +36,7 @@ using osu.Game.Scoring;
 using osu.Game.Screens.Edit.Setup;
 using osu.Game.Screens.Ranking.Statistics;
 using osu.Game.Skinning;
+using osu.Game.Utils;
 using osuTK;

 namespace osu.Game.Rulesets.Catch
@@ -150,6 +154,7 @@ namespace osu.Game.Rulesets.Catch
                        new CatchModFloatingFruits(),
                        new CatchModMuted(),
                        new CatchModNoScope(),
+                        new CatchModMovingFast(),
                    };

                case ModType.System:
@@ -265,9 +270,10 @@ namespace osu.Game.Rulesets.Catch
        }

        /// <seealso cref="CatchHitObject.ApplyDefaultsToSelf"/>
-        public override BeatmapDifficulty GetRateAdjustedDisplayDifficulty(IBeatmapDifficultyInfo difficulty, double rate)
+        public override BeatmapDifficulty GetAdjustedDisplayDifficulty(IBeatmapInfo beatmapInfo, IReadOnlyCollection<Mod> mods)
        {
-            BeatmapDifficulty adjustedDifficulty = new BeatmapDifficulty(difficulty);
+            BeatmapDifficulty adjustedDifficulty = base.GetAdjustedDisplayDifficulty(beatmapInfo, mods);
+            double rate = ModUtils.CalculateRateWithMods(mods);

            double preempt = IBeatmapDifficultyInfo.DifficultyRange(adjustedDifficulty.ApproachRate, CatchHitObject.PREEMPT_MAX, CatchHitObject.PREEMPT_MID, CatchHitObject.PREEMPT_MIN);
            preempt /= rate;
@@ -276,6 +282,33 @@ namespace osu.Game.Rulesets.Catch
            return adjustedDifficulty;
        }

+        public override IEnumerable<RulesetBeatmapAttribute> GetBeatmapAttributesForDisplay(IBeatmapInfo beatmapInfo, IReadOnlyCollection<Mod> mods)
+        {
+            var originalDifficulty = beatmapInfo.Difficulty;
+            var effectiveDifficulty = GetAdjustedDisplayDifficulty(beatmapInfo, mods);
+
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.CircleSize, @"CS", originalDifficulty.CircleSize, effectiveDifficulty.CircleSize, 10)
+            {
+                Description = "Affects the size of fruits.",
+                AdditionalMetrics =
+                [
+                    new RulesetBeatmapAttribute.AdditionalMetric("Hit circle radius", (CatchHitObject.OBJECT_RADIUS * LegacyRulesetExtensions.CalculateScaleFromCircleSize(effectiveDifficulty.CircleSize)).ToLocalisableString("0.#"))
+                ]
+            };
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.ApproachRate, @"AR", originalDifficulty.ApproachRate, effectiveDifficulty.ApproachRate, 10)
+            {
+                Description = "Affects how early fruits fade in on the screen.",
+                AdditionalMetrics =
+                [
+                    new RulesetBeatmapAttribute.AdditionalMetric("Fade-in time", LocalisableString.Interpolate($@"{IBeatmapDifficultyInfo.DifficultyRange(effectiveDifficulty.ApproachRate, CatchHitObject.PREEMPT_RANGE):#,0.##} ms"))
+                ]
+            };
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.HPDrain, @"HP", originalDifficulty.DrainRate, effectiveDifficulty.DrainRate, 10)
+            {
+                Description = "Affects the harshness of health drain and the health penalties for missing."
+            };
+        }
+
        public override bool EditorShowScrollSpeed => false;
    }
 }
@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.

 using System.Collections.Generic;
-using Newtonsoft.Json;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;

@@ -10,15 +9,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 {
    public class CatchDifficultyAttributes : DifficultyAttributes
    {
-        /// <summary>
-        /// The perceived approach rate inclusive of rate-adjusting mods (DT/HT/etc).
-        /// </summary>
-        /// <remarks>
-        /// Rate-adjusting mods don't directly affect the approach rate difficulty value, but have a perceived effect as a result of adjusting audio timing.
-        /// </remarks>
-        [JsonProperty("approach_rate")]
-        public double ApproachRate { get; set; }
-
        public override IEnumerable<(int attributeId, object value)> ToDatabaseAttributes()
        {
            foreach (var v in base.ToDatabaseAttributes())
@@ -26,7 +16,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty

            // Todo: osu!catch should not output star rating in the 'aim' attribute.
            yield return (ATTRIB_ID_AIM, StarRating);
-            yield return (ATTRIB_ID_APPROACH_RATE, ApproachRate);
        }

        public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values, IBeatmapOnlineInfo onlineInfo)
@@ -34,7 +23,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty
            base.FromDatabaseAttributes(values, onlineInfo);

            StarRating = values[ATTRIB_ID_AIM];
-            ApproachRate = values[ATTRIB_ID_APPROACH_RATE];
        }
    }
 }
@@ -3,6 +3,7 @@

 using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Difficulty.Preprocessing;
@@ -23,7 +24,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty

        private float halfCatcherWidth;

-        public override int Version => 20220701;
+        public override int Version => 20250306;

        public CatchDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
            : base(ruleset, beatmap)
@@ -35,14 +36,10 @@ namespace osu.Game.Rulesets.Catch.Difficulty
            if (beatmap.HitObjects.Count == 0)
                return new CatchDifficultyAttributes { Mods = mods };

-            // this is the same as osu!, so there's potential to share the implementation... maybe
-            double preempt = IBeatmapDifficultyInfo.DifficultyRange(beatmap.Difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
-
            CatchDifficultyAttributes attributes = new CatchDifficultyAttributes
            {
-                StarRating = Math.Sqrt(skills[0].DifficultyValue()) * difficulty_multiplier,
+                StarRating = Math.Sqrt(skills.OfType<Movement>().Single().DifficultyValue()) * difficulty_multiplier,
                Mods = mods,
-                ApproachRate = preempt > 1200.0 ? -(preempt - 1800.0) / 120.0 : -(preempt - 1200.0) / 150.0 + 5.0,
                MaxCombo = beatmap.GetMaxCombo(),
            };

@@ -3,6 +3,9 @@

 using System;
 using System.Linq;
+using osu.Framework.Audio.Track;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
@@ -50,7 +53,19 @@ namespace osu.Game.Rulesets.Catch.Difficulty
            if (catchAttributes.MaxCombo > 0)
                value *= Math.Min(Math.Pow(score.MaxCombo, 0.8) / Math.Pow(catchAttributes.MaxCombo, 0.8), 1.0);

-            double approachRate = catchAttributes.ApproachRate;
+            var difficulty = score.BeatmapInfo!.Difficulty.Clone();
+
+            score.Mods.OfType<IApplicableToDifficulty>().ForEach(m => m.ApplyToDifficulty(difficulty));
+
+            var track = new TrackVirtual(10000);
+            score.Mods.OfType<IApplicableToTrack>().ForEach(m => m.ApplyToTrack(track));
+            double clockRate = track.Rate;
+
+            // this is the same as osu!, so there's potential to share the implementation... maybe
+            double preempt = IBeatmapDifficultyInfo.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
+
+            double approachRate = preempt > 1200.0 ? -(preempt - 1800.0) / 120.0 : -(preempt - 1200.0) / 150.0 + 5.0;
+
            double approachRateFactor = 1.0;
            if (approachRate > 9.0)
                approachRateFactor += 0.1 * (approachRate - 9.0); // 10% for each AR above 9
@@ -26,7 +26,9 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills

        private float? lastPlayerPosition;
        private float lastDistanceMoved;
+        private float lastExactDistanceMoved;
        private double lastStrainTime;
+        private bool isInBuzzSection;

        /// <summary>
        /// The speed multiplier applied to the player's catcher.
@@ -59,6 +61,9 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills

            float distanceMoved = playerPosition - lastPlayerPosition.Value;

+            // For the exact position we consider that the catcher is in the correct position for both objects
+            float exactDistanceMoved = catchCurrent.NormalizedPosition - lastPlayerPosition.Value;
+
            double weightedStrainTime = catchCurrent.StrainTime + 13 + (3 / catcherSpeedMultiplier);

            double distanceAddition = (Math.Pow(Math.Abs(distanceMoved), 1.3) / 510);
@@ -92,12 +97,30 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
                    playerPosition = catchCurrent.NormalizedPosition;
                }

-                distanceAddition *= 1.0 + edgeDashBonus * ((20 - catchCurrent.LastObject.DistanceToHyperDash) / 20) * Math.Pow((Math.Min(catchCurrent.StrainTime * catcherSpeedMultiplier, 265) / 265), 1.5); // Edge Dashes are easier at lower ms values
+                distanceAddition *= 1.0 + edgeDashBonus * ((20 - catchCurrent.LastObject.DistanceToHyperDash) / 20)
+                                                        * Math.Pow((Math.Min(catchCurrent.StrainTime * catcherSpeedMultiplier, 265) / 265), 1.5); // Edge Dashes are easier at lower ms values
+            }
+
+            // There is an edge case where horizontal back and forth sliders create "buzz" patterns which are repeated "movements" with a distance lower than
+            // the platter's width but high enough to be considered a movement due to the absolute_player_positioning_error and normalized_hitobject_radius offsets
+            // We are detecting this exact scenario. The first back and forth is counted but all subsequent ones are nullified.
+            // To achieve that, we need to store the exact distances (distance ignoring absolute_player_positioning_error and normalized_hitobject_radius)
+            if (Math.Abs(exactDistanceMoved) <= HalfCatcherWidth * 2 && exactDistanceMoved == -lastExactDistanceMoved && catchCurrent.StrainTime == lastStrainTime)
+            {
+                if (isInBuzzSection)
+                    distanceAddition = 0;
+                else
+                    isInBuzzSection = true;
+            }
+            else
+            {
+                isInBuzzSection = false;
            }

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

            return distanceAddition / weightedStrainTime;
        }
@@ -143,7 +143,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints.Components
        {
            base.UpdateHitObjectFromPath(hitObject);

-            if (hitObject.Path.ControlPoints.Count <= 1 || !hitObject.Path.HasValidLength)
+            if (hitObject.Path.ControlPoints.Count <= 1 || !hitObject.Path.HasValidLengthForPlacement)
                EditorBeatmap?.Remove(hitObject);
        }
    }
@@ -5,6 +5,7 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Rulesets.Catch.Edit.Checks;
 using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
 using osu.Game.Rulesets.Edit.Checks.Components;

 namespace osu.Game.Rulesets.Catch.Edit
@@ -13,7 +14,14 @@ namespace osu.Game.Rulesets.Catch.Edit
    {
        private readonly List<ICheck> checks = new List<ICheck>
        {
+            // Compose
            new CheckBananaShowerGap(),
+            new CheckConcurrentObjects(),
+
+            // Spread
+            new CheckCatchLowestDiffDrainTime(),
+
+            // Settings
            new CheckCatchAbnormalDifficultySettings(),
        };

@@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Catch.Edit
            //
            // The implementation below is probably correct but should be checked if/when exposed via controls.

-            float expectedDistance = DurationToDistance(before, after.StartTime - before.GetEndTime());
+            float expectedDistance = DurationToDistance(after.StartTime - before.GetEndTime(), before.StartTime);

            float previousEndX = (before as JuiceStream)?.EndX ?? ((CatchHitObject)before).EffectiveX;
            float actualDistance = Math.Abs(previousEndX - ((CatchHitObject)after).EffectiveX);
@@ -3,6 +3,7 @@

 using System.Collections.Generic;
 using System.Linq;
+using System.Text.RegularExpressions;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -219,5 +220,40 @@ namespace osu.Game.Rulesets.Catch.Edit
            distanceSnapGrid.StartTime = sourceHitObject.GetEndTime();
            distanceSnapGrid.StartX = sourceHitObject.EffectiveX;
        }
+
+        #region Clipboard handling
+
+        public override string ConvertSelectionToString()
+            => string.Join(',', EditorBeatmap.SelectedHitObjects.Cast<CatchHitObject>().OrderBy(h => h.StartTime).Select(h => (h.IndexInCurrentCombo + 1).ToString()));
+
+        // 1,2,3,4 ...
+        private static readonly Regex selection_regex = new Regex(@"^\d+(,\d+)*$", RegexOptions.Compiled);
+
+        public override void SelectFromTimestamp(double timestamp, string objectDescription)
+        {
+            if (!selection_regex.IsMatch(objectDescription))
+                return;
+
+            List<CatchHitObject> remainingHitObjects = EditorBeatmap.HitObjects.Cast<CatchHitObject>().Where(h => h.StartTime >= timestamp).ToList();
+            string[] splitDescription = objectDescription.Split(',');
+
+            for (int i = 0; i < splitDescription.Length; i++)
+            {
+                if (!int.TryParse(splitDescription[i], out int combo) || combo < 1)
+                    continue;
+
+                CatchHitObject? current = remainingHitObjects.FirstOrDefault(h => h.IndexInCurrentCombo + 1 == combo);
+
+                if (current == null)
+                    continue;
+
+                EditorBeatmap.SelectedHitObjects.Add(current);
+
+                if (i < splitDescription.Length - 1)
+                    remainingHitObjects = remainingHitObjects.Where(h => h != current && h.StartTime >= current.StartTime).ToList();
+            }
+        }
+
+        #endregion
    }
 }
@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Objects;
@@ -12,6 +13,7 @@ using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
+using osuTK.Input;
 using Direction = osu.Framework.Graphics.Direction;

 namespace osu.Game.Rulesets.Catch.Edit
@@ -38,6 +40,13 @@ namespace osu.Game.Rulesets.Catch.Edit
                return true;
            }

+            moveSelection(deltaX);
+
+            return true;
+        }
+
+        private void moveSelection(float deltaX)
+        {
            EditorBeatmap.PerformOnSelection(h =>
            {
                if (!(h is CatchHitObject catchObject)) return;
@@ -48,7 +57,60 @@ namespace osu.Game.Rulesets.Catch.Edit
                foreach (var nested in catchObject.NestedHitObjects.OfType<CatchHitObject>())
                    nested.OriginalX += deltaX;
            });
+        }

+        private bool nudgeMovementActive;
+
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            // Until the keys below are global actions, this will prevent conflicts with "seek between sample points"
+            // which has a default of ctrl+shift+arrows.
+            if (e.ShiftPressed)
+                return false;
+
+            if (e.ControlPressed)
+            {
+                switch (e.Key)
+                {
+                    case Key.Left:
+                        return nudgeSelection(-1);
+
+                    case Key.Right:
+                        return nudgeSelection(1);
+                }
+            }
+
+            return false;
+        }
+
+        protected override void OnKeyUp(KeyUpEvent e)
+        {
+            base.OnKeyUp(e);
+
+            if (nudgeMovementActive && !e.ControlPressed)
+            {
+                EditorBeatmap.EndChange();
+                nudgeMovementActive = false;
+            }
+        }
+
+        /// <summary>
+        /// Move the current selection spatially by the specified delta, in gamefield coordinates (ie. the same coordinates as the blueprints).
+        /// </summary>
+        private bool nudgeSelection(float deltaX)
+        {
+            if (!nudgeMovementActive)
+            {
+                nudgeMovementActive = true;
+                EditorBeatmap.BeginChange();
+            }
+
+            var firstBlueprint = SelectedBlueprints.FirstOrDefault();
+
+            if (firstBlueprint == null)
+                return false;
+
+            moveSelection(deltaX);
            return true;
        }

@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Checks

        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
        {
-            var hitObjects = context.Beatmap.HitObjects;
+            var hitObjects = context.CurrentDifficulty.Playable.HitObjects;
            (int expectedStartDelta, int expectedEndDelta) = spinner_delta_threshold[context.InterpretedDifficulty];

            for (int i = 0; i < hitObjects.Count - 1; ++i)
@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Checks

        public override IEnumerable<Issue> Run(BeatmapVerifierContext context)
        {
-            var diff = context.Beatmap.Difficulty;
+            var diff = context.CurrentDifficulty.Playable.Difficulty;
            Issue? issue;

            if (HasMoreThanOneDecimalPlace("Approach rate", diff.ApproachRate, out issue))
@@ -0,0 +1,21 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit.Checks;
+
+namespace osu.Game.Rulesets.Catch.Edit.Checks
+{
+    public class CheckCatchLowestDiffDrainTime : CheckLowestDiffDrainTime
+    {
+        protected override IEnumerable<(DifficultyRating rating, double thresholdMs, string name)> GetThresholds()
+        {
+            // See lowest difficulty requirements in https://osu.ppy.sh/wiki/en/Ranking_criteria/osu%21catch#general
+            yield return (DifficultyRating.Hard, new TimeSpan(0, 2, 30).TotalMilliseconds, "Platter");
+            yield return (DifficultyRating.Insane, new TimeSpan(0, 3, 15).TotalMilliseconds, "Rain");
+            yield return (DifficultyRating.Expert, new TimeSpan(0, 4, 0).TotalMilliseconds, "Overdose");
+        }
+    }
+}
@@ -75,6 +75,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Setup
                {
                    Caption = EditorSetupStrings.BaseVelocity,
                    HintText = EditorSetupStrings.BaseVelocityDescription,
+                    KeyboardStep = 0.1f,
                    Current = new BindableDouble(Beatmap.Difficulty.SliderMultiplier)
                    {
                        Default = 1.4,
@@ -89,6 +90,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Setup
                {
                    Caption = EditorSetupStrings.TickRate,
                    HintText = EditorSetupStrings.TickRateDescription,
+                    KeyboardStep = 1,
                    Current = new BindableDouble(Beatmap.Difficulty.SliderTickRate)
                    {
                        Default = 1,
@@ -1,7 +1,9 @@
 // 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;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Mods;
@@ -10,6 +12,8 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
    public class CatchModAutoplay : ModAutoplay
    {
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(CatchModMovingFast) }).ToArray();
+
        public override ModReplayData CreateReplayData(IBeatmap beatmap, IReadOnlyList<Mod> mods)
            => new ModReplayData(new CatchAutoGenerator(beatmap).Generate(), new ModCreatedUser { Username = "osu!salad" });
    }
@@ -1,7 +1,9 @@
 // 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;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Replays;
@@ -11,6 +13,8 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
    public class CatchModCinema : ModCinema<CatchHitObject>
    {
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(CatchModMovingFast) }).ToArray();
+
        public override ModReplayData CreateReplayData(IBeatmap beatmap, IReadOnlyList<Mod> mods)
            => new ModReplayData(new CatchAutoGenerator(beatmap).Generate(), new ModCreatedUser { Username = "osu!salad" });
    }
@@ -1,10 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

-using System.Linq;
+using System.Collections.Generic;
 using osu.Framework.Bindables;
+using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
+using osu.Game.Extensions;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Mods;

@@ -35,21 +37,39 @@ namespace osu.Game.Rulesets.Catch.Mods
        [SettingSource("Spicy Patterns", "Adjust the patterns as if Hard Rock is enabled.")]
        public BindableBool HardRockOffsets { get; } = new BindableBool();

-        public override string SettingDescription
+        public override string ExtendedIconInformation
        {
            get
            {
-                string circleSize = CircleSize.IsDefault ? string.Empty : $"CS {CircleSize.Value:N1}";
-                string approachRate = ApproachRate.IsDefault ? string.Empty : $"AR {ApproachRate.Value:N1}";
-                string spicyPatterns = HardRockOffsets.IsDefault ? string.Empty : "Spicy patterns";
+                if (!IsExactlyOneSettingChanged(CircleSize, ApproachRate, OverallDifficulty, DrainRate))
+                    return string.Empty;

-                return string.Join(", ", new[]
-                {
-                    circleSize,
-                    base.SettingDescription,
-                    approachRate,
-                    spicyPatterns,
-                }.Where(s => !string.IsNullOrEmpty(s)));
+                if (!CircleSize.IsDefault) return format("CS", CircleSize);
+                if (!ApproachRate.IsDefault) return format("AR", ApproachRate);
+                if (!OverallDifficulty.IsDefault) return format("OD", OverallDifficulty);
+                if (!DrainRate.IsDefault) return format("HP", DrainRate);
+
+                return string.Empty;
+
+                string format(string acronym, DifficultyBindable bindable) => $"{acronym}{bindable.Value!.Value.ToStandardFormattedString(1)}";
+            }
+        }
+
+        public override IEnumerable<(LocalisableString setting, LocalisableString value)> SettingDescription
+        {
+            get
+            {
+                if (!CircleSize.IsDefault)
+                    yield return ("Circle size", $"{CircleSize.Value:N1}");
+
+                foreach (var setting in base.SettingDescription)
+                    yield return setting;
+
+                if (!ApproachRate.IsDefault)
+                    yield return ("Approach rate", $"{ApproachRate.Value:N1}");
+
+                if (!HardRockOffsets.IsDefault)
+                    yield return ("Spicy patterns", "On");
            }
        }

@@ -2,12 +2,20 @@
 // See the LICENCE file in the repository root for full licence text.

 using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;

 namespace osu.Game.Rulesets.Catch.Mods
 {
    public class CatchModEasy : ModEasyWithExtraLives
    {
-        public override LocalisableString Description => @"Larger fruits, more forgiving HP drain, less accuracy required, and three lives!";
+        public override LocalisableString Description => @"Larger fruits, more forgiving HP drain, less accuracy required, and extra lives!";
+
+        public override void ApplyToDifficulty(BeatmapDifficulty difficulty)
+        {
+            base.ApplyToDifficulty(difficulty);
+
+            difficulty.OverallDifficulty *= ADJUST_RATIO;
+        }
    }
 }
@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Catch.Mods

        public override BindableBool ComboBasedSize { get; } = new BindableBool(true);

-        public override float DefaultFlashlightSize => 325;
+        public override float DefaultFlashlightSize => 203.125f;

        protected override Flashlight CreateFlashlight() => new CatchFlashlight(this, playfield);

@@ -3,6 +3,7 @@

 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
@@ -16,7 +17,7 @@ namespace osu.Game.Rulesets.Catch.Mods
        public override string Acronym => "FF";
        public override LocalisableString Description => "The fruits are... floating?";
        public override double ScoreMultiplier => 1;
-        public override IconUsage? Icon => FontAwesome.Solid.Cloud;
+        public override IconUsage? Icon => OsuIcon.ModFloatingFruits;

        public void ApplyToDrawableRuleset(DrawableRuleset<CatchHitObject> drawableRuleset)
        {
@@ -22,6 +22,7 @@ namespace osu.Game.Rulesets.Catch.Mods
        {
            base.ApplyToDifficulty(difficulty);

+            difficulty.OverallDifficulty = Math.Min(difficulty.OverallDifficulty * ADJUST_RATIO, 10.0f);
            difficulty.CircleSize = Math.Min(difficulty.CircleSize * 1.3f, 10.0f); // CS uses a custom 1.3 ratio.
            difficulty.ApproachRate = Math.Min(difficulty.ApproachRate * ADJUST_RATIO, 10.0f);
        }
@@ -0,0 +1,82 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Mods
+{
+    public partial class CatchModMovingFast : Mod, IApplicableToDrawableRuleset<CatchHitObject>, IApplicableToPlayer
+    {
+        public override string Name => "Moving Fast";
+        public override string Acronym => "MF";
+        public override LocalisableString Description => "Dashing by default, slow down!";
+        public override ModType Type => ModType.Fun;
+        public override double ScoreMultiplier => 1;
+        public override IconUsage? Icon => OsuIcon.ModMovingFast;
+        public override Type[] IncompatibleMods => new[] { typeof(ModAutoplay), typeof(ModRelax) };
+
+        private DrawableCatchRuleset drawableRuleset = null!;
+
+        public void ApplyToDrawableRuleset(DrawableRuleset<CatchHitObject> drawableRuleset)
+        {
+            this.drawableRuleset = (DrawableCatchRuleset)drawableRuleset;
+        }
+
+        public void ApplyToPlayer(Player player)
+        {
+            if (!drawableRuleset.HasReplayLoaded.Value)
+            {
+                var catchPlayfield = (CatchPlayfield)drawableRuleset.Playfield;
+                catchPlayfield.Catcher.Dashing = true;
+                catchPlayfield.CatcherArea.Add(new InvertDashInputHelper(catchPlayfield.CatcherArea));
+            }
+        }
+
+        private partial class InvertDashInputHelper : Drawable, IKeyBindingHandler<CatchAction>
+        {
+            private readonly CatcherArea catcherArea;
+
+            public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
+
+            public InvertDashInputHelper(CatcherArea catcherArea)
+            {
+                this.catcherArea = catcherArea;
+
+                RelativeSizeAxes = Axes.Both;
+            }
+
+            public bool OnPressed(KeyBindingPressEvent<CatchAction> e)
+            {
+                switch (e.Action)
+                {
+                    case CatchAction.MoveLeft or CatchAction.MoveRight:
+                        break;
+
+                    case CatchAction.Dash:
+                        catcherArea.Catcher.Dashing = false;
+                        return true;
+                }
+
+                return false;
+            }
+
+            public void OnReleased(KeyBindingReleaseEvent<CatchAction> e)
+            {
+                if (e.Action == CatchAction.Dash)
+                    catcherArea.Catcher.Dashing = true;
+            }
+        }
+    }
+}
@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using System;
+using System.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
@@ -19,6 +21,8 @@ namespace osu.Game.Rulesets.Catch.Mods
    {
        public override LocalisableString Description => @"Use the mouse to control the catcher.";

+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(CatchModMovingFast) }).ToArray();
+
        private DrawableCatchRuleset drawableRuleset = null!;

        public void ApplyToDrawableRuleset(DrawableRuleset<CatchHitObject> drawableRuleset)
@@ -150,7 +150,7 @@ namespace osu.Game.Rulesets.Catch.Objects
        {
            base.ApplyDefaultsToSelf(controlPointInfo, difficulty);

-            TimePreempt = (float)IBeatmapDifficultyInfo.DifficultyRange(difficulty.ApproachRate, PREEMPT_MAX, PREEMPT_MID, PREEMPT_MIN);
+            TimePreempt = (float)IBeatmapDifficultyInfo.DifficultyRange(difficulty.ApproachRate, PREEMPT_RANGE);

            Scale = LegacyRulesetExtensions.CalculateScaleFromCircleSize(difficulty.CircleSize);
        }
@@ -203,6 +203,8 @@ namespace osu.Game.Rulesets.Catch.Objects
        /// </summary>
        public const double PREEMPT_MAX = 1800;

+        public static readonly DifficultyRange PREEMPT_RANGE = new DifficultyRange(PREEMPT_MAX, PREEMPT_MID, PREEMPT_MIN);
+
        /// <summary>
        /// The Y position of the hit object is not used in the normal osu!catch gameplay.
        /// It is preserved to maximize the backward compatibility with the legacy editor, in which the mappers use the Y position to organize the patterns.
@@ -2,6 +2,7 @@
 // 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;
@@ -64,5 +65,12 @@ 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);
    }
 }
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using System;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
@@ -110,7 +111,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Argon

            double duration = ObjectState.HitObject.StartTime - ObjectState.DisplayStartTime;

-            fadeContent.Alpha = MathHelper.Clamp(
+            fadeContent.Alpha = Math.Clamp(
                Interpolation.ValueAt(
                    Time.Current, 1f, 0f,
                    ObjectState.DisplayStartTime + duration * lens_flare_start,
@@ -49,6 +49,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
                            {
                                var keyCounter = container.OfType<LegacyKeyCounterDisplay>().FirstOrDefault();
                                var spectatorList = container.OfType<SpectatorList>().FirstOrDefault();
+                                var leaderboard = container.OfType<DrawableGameplayLeaderboard>().FirstOrDefault();

                                if (keyCounter != null)
                                {
@@ -64,12 +65,20 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
                                    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(),
                                }
                            };
                    }
@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using System;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.UI;
@@ -15,6 +17,8 @@ namespace osu.Game.Rulesets.Catch.UI
        protected override Container<Drawable> Content => content;
        private readonly Container content;

+        private readonly Container scaleContainer;
+
        public CatchPlayfieldAdjustmentContainer()
        {
            const float base_game_width = 1024f;
@@ -26,30 +30,49 @@ namespace osu.Game.Rulesets.Catch.UI
            Anchor = Anchor.Centre;
            Origin = Anchor.Centre;

-            InternalChild = new Container
+            InternalChild = scaleContainer = new Container
            {
-                // This container limits vertical visibility of the playfield to ensure fairness between wide and tall resolutions (i.e. tall resolutions should not see more fruits).
-                // Note that the container still extends across the screen horizontally, so that hit explosions at the sides of the playfield do not get cut off.
-                Name = "Visible area",
                Anchor = Anchor.Centre,
                Origin = Anchor.Centre,
-                RelativeSizeAxes = Axes.X,
-                Height = base_game_height + extra_bottom_space,
-                Y = extra_bottom_space / 2,
-                Masking = true,
+                RelativeSizeAxes = Axes.Both,
                Child = new Container
                {
-                    Name = "Playable area",
-                    Anchor = Anchor.TopCentre,
-                    Origin = Anchor.TopCentre,
-                    // playfields in stable are positioned vertically at three fourths the difference between the playfield height and the window height in stable.
-                    Y = base_game_height * ((1 - playfield_size_adjust) / 4 * 3),
-                    Size = new Vector2(base_game_width, base_game_height) * playfield_size_adjust,
-                    Child = content = new ScalingContainer { RelativeSizeAxes = Axes.Both }
-                },
+                    // This container limits vertical visibility of the playfield to ensure fairness between wide and tall resolutions (i.e. tall resolutions should not see more fruits).
+                    // Note that the container still extends across the screen horizontally, so that hit explosions at the sides of the playfield do not get cut off.
+                    Name = "Visible area",
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.X,
+                    Height = base_game_height + extra_bottom_space,
+                    Y = extra_bottom_space / 2,
+                    Masking = true,
+                    Child = new Container
+                    {
+                        Name = "Playable area",
+                        Anchor = Anchor.TopCentre,
+                        Origin = Anchor.TopCentre,
+                        // playfields in stable are positioned vertically at three fourths the difference between the playfield height and the window height in stable.
+                        Y = base_game_height * ((1 - playfield_size_adjust) / 4 * 3),
+                        Size = new Vector2(base_game_width, base_game_height) * playfield_size_adjust,
+                        Child = content = new ScalingContainer { RelativeSizeAxes = Axes.Both }
+                    },
+                }
            };
        }

+        [BackgroundDependencyLoader]
+        private void load(OsuGame? osuGame)
+        {
+            if (osuGame != null)
+            {
+                // on mobile platforms where the base aspect ratio is wider, the catch playfield
+                // needs to be scaled down to remain playable.
+                const float base_aspect_ratio = 1024f / 768f;
+                float aspectRatio = osuGame.ScalingContainerTargetDrawSize.X / osuGame.ScalingContainerTargetDrawSize.Y;
+                scaleContainer.Scale = new Vector2(Math.Min(1, base_aspect_ratio / aspectRatio));
+            }
+        }
+
        /// <summary>
        /// A <see cref="Container"/> which scales its content relative to a target width.
        /// </summary>
@@ -0,0 +1,107 @@
+// 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)
+            });
+        }
+
+        [Test]
+        public void TestHoldNotesAlmostConcurrentOnSameColumn()
+        {
+            assertAlmostConcurrentSame(new List<HitObject>
+            {
+                createHoldNote(startTime: 100, endTime: 400.75d, column: 1),
+                createHoldNote(startTime: 408, 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.IssueTemplateConcurrent));
+            Assert.That(issues.All(issue => issue.ToString().Contains("s are concurrent here")));
+        }
+
+        private void assertAlmostConcurrentSame(List<HitObject> hitobjects)
+        {
+            var issues = check.Run(getContext(hitobjects)).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateAlmostConcurrent));
+            Assert.That(issues.All(issue => issue.ToString().Contains("s are less than 10ms apart")));
+        }
+
+        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
+            };
+        }
+    }
+}
@@ -22,6 +22,8 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
    public abstract partial class ManiaPlacementBlueprintTestScene : PlacementBlueprintTestScene
    {
+        protected sealed override Ruleset CreateRuleset() => new ManiaRuleset();
+
        private readonly Column column;

        [Cached(typeof(IReadOnlyList<Mod>))]
@@ -29,7 +29,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
            {
                keyCount.Current.Value = 8;
            });
-            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().SingleOrDefault()?.CurrentDialog, Is.InstanceOf<ReloadEditorDialog>);
+            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().SingleOrDefault()?.CurrentDialog, Is.InstanceOf<SaveAndReloadEditorDialog>);
            AddStep("refuse", () => InputManager.Key(Key.Number2));
            AddAssert("key count is 5", () => keyCount.Current.Value, () => Is.EqualTo(5));

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

        [TestCase("convert-samples")]
        [TestCase("mania-samples")]
+        [TestCase("mania-slider")] // e.g. second and fourth notes of https://osu.ppy.sh/beatmapsets/73883#mania/216407
        [TestCase("slider-convert-samples")]
        public void Test(string name) => base.Test(name);

@@ -32,6 +33,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                StartTime = hitObject.StartTime,
                EndTime = hitObject.GetEndTime(),
                Column = ((ManiaHitObject)hitObject).Column,
+                PlaySlidingSamples = hitObject is HoldNote holdNote && holdNote.PlaySlidingSamples,
                Samples = getSampleNames(hitObject.Samples),
                NodeSamples = getNodeSampleNames((hitObject as HoldNote)?.NodeSamples)
            };
@@ -57,12 +59,14 @@ namespace osu.Game.Rulesets.Mania.Tests
        public double StartTime;
        public double EndTime;
        public int Column;
+        public bool PlaySlidingSamples;
        public IList<string> Samples;
        public IList<IList<string>> NodeSamples;

        public bool Equals(SampleConvertValue other)
            => Precision.AlmostEquals(StartTime, other.StartTime, conversion_lenience)
               && Precision.AlmostEquals(EndTime, other.EndTime, conversion_lenience)
+               && PlaySlidingSamples == other.PlaySlidingSamples
               && samplesEqual(Samples, other.Samples)
               && nodeSamplesEqual(NodeSamples, other.NodeSamples);

@@ -0,0 +1,314 @@
+// 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 TestKeysFilterIntersection()
+        {
+            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 TestInvalidKeysFilters()
+        {
+            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"));
+        }
+
+        [TestCase]
+        public void TestLnsEqual()
+        {
+            var criteria = new ManiaFilterCriteria();
+            var filterCriteria = new FilterCriteria
+            {
+                Ruleset = new ManiaRuleset().RulesetInfo
+            };
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "0");
+            BeatmapInfo beatmapInfo1 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 0,
+                EndTimeObjectCount = 0
+            };
+            Assert.True(criteria.Matches(beatmapInfo1, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "0");
+            BeatmapInfo beatmapInfo2 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 0
+            };
+            Assert.True(criteria.Matches(beatmapInfo2, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "100");
+            BeatmapInfo beatmapInfo3 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 100
+            };
+            Assert.True(criteria.Matches(beatmapInfo3, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "1");
+            BeatmapInfo beatmapInfo4 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 1
+            };
+            Assert.True(criteria.Matches(beatmapInfo4, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "0.1");
+            BeatmapInfo beatmapInfo5 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 1000,
+                EndTimeObjectCount = 1
+            };
+            Assert.True(criteria.Matches(beatmapInfo5, filterCriteria));
+        }
+
+        [TestCase]
+        public void TestLnsGreaterOrEqual()
+        {
+            var criteria = new ManiaFilterCriteria();
+            var filterCriteria = new FilterCriteria
+            {
+                Ruleset = new ManiaRuleset().RulesetInfo
+            };
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "0");
+            BeatmapInfo beatmapInfo1 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 0,
+                EndTimeObjectCount = 0
+            };
+            Assert.True(criteria.Matches(beatmapInfo1, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "0");
+            BeatmapInfo beatmapInfo2 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 0
+            };
+            Assert.True(criteria.Matches(beatmapInfo2, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "100");
+            BeatmapInfo beatmapInfo3 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 100
+            };
+            Assert.True(criteria.Matches(beatmapInfo3, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "1");
+            BeatmapInfo beatmapInfo4 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 1
+            };
+            Assert.True(criteria.Matches(beatmapInfo4, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "0.1");
+            BeatmapInfo beatmapInfo5 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 1000,
+                EndTimeObjectCount = 1
+            };
+            Assert.True(criteria.Matches(beatmapInfo5, filterCriteria));
+        }
+
+        [TestCase]
+        public void TestLnsNotManiaRuleset()
+        {
+            var criteria = new ManiaFilterCriteria();
+            var filterCriteria = new FilterCriteria
+            {
+                Ruleset = new ManiaRuleset().RulesetInfo
+            };
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.LessOrEqual, "100");
+            BeatmapInfo beatmapInfo = new BeatmapInfo
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 50
+            };
+            Assert.False(criteria.Matches(beatmapInfo, filterCriteria));
+        }
+
+        [TestCase]
+        public void TestInvalidLnsFilters()
+        {
+            var criteria = new ManiaFilterCriteria();
+
+            Assert.False(criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "some text"));
+            Assert.False(criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "1some text"));
+        }
+    }
+}
@@ -5,7 +5,6 @@ using System;
 using NUnit.Framework;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Rulesets.Mania.Mods;
-using osu.Game.Rulesets.Mods;
 using osu.Game.Tests.Beatmaps;

 namespace osu.Game.Rulesets.Mania.Tests
@@ -38,7 +37,7 @@ namespace osu.Game.Rulesets.Mania.Tests
            new object[] { LegacyMods.Key2, new[] { typeof(ManiaModKey2) } },
            new object[] { LegacyMods.Mirror, new[] { typeof(ManiaModMirror) } },
            new object[] { LegacyMods.HardRock | LegacyMods.DoubleTime, new[] { typeof(ManiaModHardRock), typeof(ManiaModDoubleTime) } },
-            new object[] { LegacyMods.ScoreV2, new[] { typeof(ModScoreV2) } },
+            new object[] { LegacyMods.ScoreV2, new[] { typeof(ManiaModScoreV2) } },
        };

        [TestCaseSource(nameof(mania_mod_mapping))]
@@ -31,9 +31,12 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
        public void TestHoldNote(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new HoldNote { StartTime = 1000, EndTime = 3000 }), shouldMiss);

        [Test]
-        public void TestGreatHit() => CreateModTest(new ModTestData
+        public void TestPerfectHits([Values] bool requirePerfectHits) => CreateModTest(new ModTestData
        {
-            Mod = new ManiaModPerfect(),
+            Mod = new ManiaModPerfect
+            {
+                RequirePerfectHits = { Value = requirePerfectHits }
+            },
            PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(false),
            Autoplay = false,
            CreateBeatmap = () => new Beatmap
@@ -47,6 +50,32 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
                },
            },
            ReplayFrames = new List<ReplayFrame>
+            {
+                new ManiaReplayFrame(1000, ManiaAction.Key1),
+                new ManiaReplayFrame(2000)
+            }
+        });
+
+        [Test]
+        public void TestGreatHit([Values] bool requirePerfectHits) => CreateModTest(new ModTestData
+        {
+            Mod = new ManiaModPerfect
+            {
+                RequirePerfectHits = { Value = requirePerfectHits }
+            },
+            PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(requirePerfectHits),
+            Autoplay = false,
+            CreateBeatmap = () => new Beatmap
+            {
+                HitObjects = new List<HitObject>
+                {
+                    new Note
+                    {
+                        StartTime = 1000,
+                    }
+                },
+            },
+            ReplayFrames = new List<ReplayFrame>
            {
                new ManiaReplayFrame(1020, ManiaAction.Key1),
                new ManiaReplayFrame(2000)
@@ -5,6 +5,7 @@
      "StartTime": 1000.0,
      "EndTime": 2750.0,
      "Column": 1,
+      "PlaySlidingSamples": true,
      "NodeSamples": [
        ["Gameplay/normal-hitnormal"],
        ["Gameplay/soft-hitnormal"],
@@ -15,6 +16,7 @@
      "StartTime": 1875.0,
      "EndTime": 2750.0,
      "Column": 0,
+      "PlaySlidingSamples": true,
      "NodeSamples": [
        ["Gameplay/soft-hitnormal"],
        ["Gameplay/drum-hitnormal"]
--- a/Show More
+++ b/Show More