make score cards for failed scores look better

- argon-style cps counter
- keybinds in key counters (for now, only default)

.editorconfig

@@ -19,6 +19,11 @@ indent_style = space
 indent_size = 4
 trim_trailing_whitespace = true
 
+# temporary workaround for https://youtrack.jetbrains.com/issue/RIDER-130051/Cannot-resolve-symbol-inspections-incorrectly-firing-for-xmldoc-protected-member-references
+resharper_c_sharp_warnings_cs1574_cs1584_cs1581_cs1580_highlighting = hint
+# temporary workaround for https://youtrack.jetbrains.com/issue/RIDER-130381/Rider-does-not-respect-propagated-NoWarn-CS1591?backToIssues=false
+dotnet_diagnostic.CS1591.severity = none
+
 #license header
 file_header_template = Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.\nSee the LICENCE file in the repository root for full licence text.
 

.github/ISSUE_TEMPLATE/config.yml

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

.github/workflows/ci.yml

@@ -148,9 +148,7 @@ jobs:
       # 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
-          xcodebuild -downloadPlatform iOS
+        run: sudo xcode-select -switch /Applications/Xcode_16.4.app
 
       - name: Build
         run: dotnet build -c Debug osu.iOS.slnf

.gitignore

@@ -19,6 +19,7 @@ bld/
 [Bb]in/
 [Oo]bj/
 [Ll]og/
+[Pp]ub/
 
 # Visual Studio 2015 cache/options directory
 .vs/

.vscode/launch.json

@@ -7,9 +7,9 @@
             "request": "launch",
             "program": "dotnet",
             "args": [
-                "${workspaceRoot}/osu.Desktop/bin/Debug/net8.0/osu!.dll"
+                "${workspaceFolder}/osu.Desktop/bin/Debug/net8.0/osu!.dll"
             ],
-            "cwd": "${workspaceRoot}",
+            "cwd": "${workspaceFolder}",
             "preLaunchTask": "Build osu! (Debug)",
             "console": "internalConsole"
         },
@@ -19,9 +19,9 @@
             "request": "launch",
             "program": "dotnet",
             "args": [
-                "${workspaceRoot}/osu.Desktop/bin/Release/net8.0/osu!.dll"
+                "${workspaceFolder}/osu.Desktop/bin/Release/net8.0/osu!.dll"
             ],
-            "cwd": "${workspaceRoot}",
+            "cwd": "${workspaceFolder}",
             "preLaunchTask": "Build osu! (Release)",
             "console": "internalConsole"
         },
@@ -31,9 +31,9 @@
             "request": "launch",
             "program": "dotnet",
             "args": [
-                "${workspaceRoot}/osu.Game.Tests/bin/Debug/net8.0/osu.Game.Tests.dll"
+                "${workspaceFolder}/osu.Game.Tests/bin/Debug/net8.0/osu.Game.Tests.dll"
             ],
-            "cwd": "${workspaceRoot}",
+            "cwd": "${workspaceFolder}",
             "preLaunchTask": "Build tests (Debug)",
             "console": "internalConsole"
         },
@@ -43,9 +43,9 @@
             "request": "launch",
             "program": "dotnet",
             "args": [
-                "${workspaceRoot}/osu.Game.Tests/bin/Release/net8.0/osu.Game.Tests.dll"
+                "${workspaceFolder}/osu.Game.Tests/bin/Release/net8.0/osu.Game.Tests.dll"
             ],
-            "cwd": "${workspaceRoot}",
+            "cwd": "${workspaceFolder}",
             "preLaunchTask": "Build tests (Release)",
             "console": "internalConsole"
         },
@@ -55,10 +55,10 @@
             "request": "launch",
             "program": "dotnet",
             "args": [
-                "${workspaceRoot}/osu.Desktop/bin/Debug/net8.0/osu!.dll",
+                "${workspaceFolder}/osu.Desktop/bin/Debug/net8.0/osu!.dll",
                 "--tournament"
             ],
-            "cwd": "${workspaceRoot}",
+            "cwd": "${workspaceFolder}",
             "preLaunchTask": "Build osu! (Debug)",
             "console": "internalConsole"
         },
@@ -68,10 +68,10 @@
             "request": "launch",
             "program": "dotnet",
             "args": [
-                "${workspaceRoot}/osu.Desktop/bin/Release/net8.0/osu!.dll",
+                "${workspaceFolder}/osu.Desktop/bin/Release/net8.0/osu!.dll",
                 "--tournament"
             ],
-            "cwd": "${workspaceRoot}",
+            "cwd": "${workspaceFolder}",
             "preLaunchTask": "Build osu! (Release)",
             "console": "internalConsole"
         },
@@ -81,10 +81,10 @@
             "request": "launch",
             "program": "dotnet",
             "args": [
-                "${workspaceRoot}/osu.Game.Tournament.Tests/bin/Debug/net8.0/osu.Game.Tournament.Tests.dll",
+                "${workspaceFolder}/osu.Game.Tournament.Tests/bin/Debug/net8.0/osu.Game.Tournament.Tests.dll",
                 "--tournament"
             ],
-            "cwd": "${workspaceRoot}",
+            "cwd": "${workspaceFolder}",
             "preLaunchTask": "Build tournament tests (Debug)",
             "console": "internalConsole"
         },
@@ -94,10 +94,10 @@
             "request": "launch",
             "program": "dotnet",
             "args": [
-                "${workspaceRoot}/osu.Game.Tournament.Tests/bin/Debug/net8.0/osu.Game.Tournament.Tests.dll",
+                "${workspaceFolder}/osu.Game.Tournament.Tests/bin/Debug/net8.0/osu.Game.Tournament.Tests.dll",
                 "--tournament"
             ],
-            "cwd": "${workspaceRoot}",
+            "cwd": "${workspaceFolder}",
             "preLaunchTask": "Build tournament tests (Release)",
             "console": "internalConsole"
         },
@@ -105,12 +105,12 @@
             "name": "Benchmark",
             "type": "coreclr",
             "request": "launch",
-            "program": "${workspaceRoot}/osu.Game.Benchmarks/bin/Release/net8.0/osu.Game.Benchmarks.dll",
+            "program": "${workspaceFolder}/osu.Game.Benchmarks/bin/Release/net8.0/osu.Game.Benchmarks.dll",
             "args": [
                 "--filter",
                 "*"
             ],
-            "cwd": "${workspaceRoot}",
+            "cwd": "${workspaceFolder}",
             "preLaunchTask": "Build benchmarks",
             "console": "internalConsole"
         }

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "dotnet.defaultSolution": "osu.Desktop.slnf"
+}

Directory.Build.props

@@ -49,7 +49,7 @@
     <PackageProjectUrl>https://github.com/ppy/osu</PackageProjectUrl>
     <RepositoryUrl>https://github.com/ppy/osu</RepositoryUrl>
     <PackageReleaseNotes>Automated release.</PackageReleaseNotes>
-    <Company>ppy Pty Ltd</Company>
+    <Company>ppy Pty Ltd, jvnkosu! team</Company>
     <Copyright>Copyright (c) 2025 ppy Pty Ltd</Copyright>
     <PackageTags>osu game</PackageTags>
   </PropertyGroup>

MakeInstaller.ps1

@@ -0,0 +1,19 @@
+#!/usr/bin/env powershell
+param (
+    [string]$Version,
+    [string]$BuildConfig = "Release"
+)
+
+if ($Version -eq "") {
+    Write-Host "Usage: .\MakeInstaller.ps1 <VERSION_NUMBER> [-BuildConfig <BUILD_CONFIG>]"
+    Write-Host "Example: .\MakeInstaller.ps1 2025.823.0 -BuildConfig Debug"
+    exit
+}
+
+$tmpPub = ".\pub"
+if (-not (Test-Path -Path $tmpPub)) {
+    New-Item -ItemType Directory -path $tmpPub
+}
+
+dotnet publish -c $BuildConfig osu.Desktop --self-contained -r win-x64 -o $tmpPub -verbosity:m /p:Version=$Version
+vpk pack --packId jvnkosu.Client --packTitle "jvnkosu!lazer" --packVersion $Version --packDir ./pub --mainExe="osu!.exe"

README.md

@@ -1,147 +1,40 @@
-<p align="center">
-  <img width="500" alt="osu! logo" src="assets/lazer.png">
-</p>
+# jvnkosu! client
 
-# osu!
+A free-to-win rhythm game based on osu!(lazer). Click is just a *rhythm* away!
 
-[![Build status](https://github.com/ppy/osu/actions/workflows/ci.yml/badge.svg?branch=master&event=push)](https://github.com/ppy/osu/actions/workflows/ci.yml)
-[![GitHub release](https://img.shields.io/github/release/ppy/osu.svg)](https://github.com/ppy/osu/releases/latest)
-[![CodeFactor](https://www.codefactor.io/repository/github/ppy/osu/badge)](https://www.codefactor.io/repository/github/ppy/osu)
-[![dev chat](https://discordapp.com/api/guilds/188630481301012481/widget.png?style=shield)](https://discord.gg/ppy)
-[![Crowdin](https://d322cqt584bo4o.cloudfront.net/osu-web/localized.svg)](https://crowdin.com/project/osu-web)
+## Disclaimer
 
-A free-to-win rhythm game. Rhythm is just a *click* away!
+*osu!* is a registered trademark of ppy Pty Ltd.  
+jvnkosu! is not affiliated with, or endorsed by ppy Pty Ltd., but makes use of its open-source components and resources.
 
-This is the future – and final – iteration of the [osu!](https://osu.ppy.sh) game client which marks the beginning of an open era! Currently known by and released under the release codename "*lazer*". As in sharper than cutting-edge.
+## License
+Client source code is licensed under the MIT license, see the [LICENCE](LICENCE) file in repository root for more info.
 
-## Status
+Game assets are included as a NuGet package and licensed under the CC BY-NC 4.0, which prohibits commercial use. See [ppy/osu-resources](https://github.com/ppy/osu-resources) for more info.
 
-This project is under constant development, but we do our best to keep things in a stable state. Players are encouraged to install from a release alongside their stable *osu!* client. This project will continue to evolve until we eventually reach the point where most users prefer it over the previous "osu!stable" release.
+Registered trademarks "osu!" and "ppy" are property of ppy Pty Ltd., and protected by trademark law.
 
-A few resources are available as starting points to getting involved and understanding the project:
+## Compiling from source
+Building jvnkosu! from source is pretty much possible (and welcome here).  
 
-- Detailed release changelogs are available on the [official osu! site](https://osu.ppy.sh/home/changelog/lazer).
-- You can learn more about our approach to [project management](https://github.com/ppy/osu/wiki/Project-management).
-- Track our current efforts [towards improving the game](https://github.com/orgs/ppy/projects/7/views/6).
+First, you must have a desktop platform with [.NET Core SDK 8](https://dotnet.microsoft.com/download) installed. Windows, Linux, macOS should work well. You can check if you have the SDK installed by running `dotnet --version` in your command prompt/terminal.  
 
-## Running osu!
-
-If you are just looking to give the game a whirl, you can grab the latest release for your platform:
-
-### Latest release:
-
-| [Windows 10+ (x64)](https://github.com/ppy/osu/releases/latest/download/install.exe) | macOS 12+ ([Intel](https://github.com/ppy/osu/releases/latest/download/osu.app.Intel.zip), [Apple Silicon](https://github.com/ppy/osu/releases/latest/download/osu.app.Apple.Silicon.zip)) | [Linux (x64)](https://github.com/ppy/osu/releases/latest/download/osu.AppImage) | [iOS 13.4+](https://osu.ppy.sh/home/testflight) | [Android 5+](https://github.com/ppy/osu/releases/latest/download/sh.ppy.osulazer.apk) |
-|--------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| ------------- | ------------- | ------------- |
-
-You can also generally download a version for your current device from the [osu! site](https://osu.ppy.sh/home/download).
-
-If your platform is unsupported or not listed above, there is still a chance you can run the release or manually build it by following the instructions below.
-
-**For iOS/iPadOS users**: The iOS testflight link fills up very fast (Apple has a hard limit of 10,000 users). We reset it occasionally. Please do not ask about this. Check back regularly for link resets or follow [peppy](https://twitter.com/ppy) on twitter for announcements. Our goal is to get the game on mobile app stores very soon so we don't have to live with this limitation.
-
-## Developing a custom ruleset
-
-osu! is designed to allow user-created gameplay variations, called "rulesets". Building one of these allows a developer to harness the power of the osu! beatmap library, game engine, and general UX for a new style of gameplay. To get started working on a ruleset, we have some templates available [here](https://github.com/ppy/osu/tree/master/Templates).
-
-You can see some examples of custom rulesets by visiting the [custom ruleset directory](https://github.com/ppy/osu/discussions/13096).
-
-## Developing osu!
-
-### Prerequisites
-
-Please make sure you have the following prerequisites:
-
-- A desktop platform with the [.NET 8.0 SDK](https://dotnet.microsoft.com/download) installed.
-
-When working with the codebase, we recommend using an IDE with intelligent code completion and syntax highlighting, such as the latest version of [Visual Studio](https://visualstudio.microsoft.com/vs/), [JetBrains Rider](https://www.jetbrains.com/rider/), or [Visual Studio Code](https://code.visualstudio.com/) with the [EditorConfig](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) and [C# Dev Kit](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.csdevkit) plugin installed.
-
-### Downloading the source code
-
-Clone the repository:
-
-```shell
-git clone https://github.com/ppy/osu
-cd osu
+Then, download the source code. You may download it as an archive and unzip it, but using [Git](https://git-scm.com/) instead is recommended:
+```
+git clone https://gitea.jvnko.boats/jvnkosu/client
 ```
 
-To update the source code to the latest commit, run the following command inside the `osu` directory:
 
-```shell
-git pull
+To **run** the project, switch to project's directory and run the following:
 ```
-
-### Building
-
-#### From an IDE
-
-You should load the solution via one of the platform-specific `.slnf` files, rather than the main `.sln`. This will reduce dependencies and hide platforms that you don't care about. Valid `.slnf` files are:
-
-- `osu.Desktop.slnf` (most common)
-- `osu.Android.slnf`
-- `osu.iOS.slnf`
-
-Run configurations for the recommended IDEs (listed above) are included. You should use the provided Build/Run functionality of your IDE to get things going. When testing or building new components, it's highly encouraged you use the `osu! (Tests)` project/configuration. More information on this is provided [below](#contributing).
-
-To build for mobile platforms, you will likely need to run `sudo dotnet workload restore` if you haven't done so previously. This will install Android/iOS tooling required to complete the build.
-
-#### From CLI
-
-You can also build and run *osu!* from the command-line with a single command:
-
-```shell
 dotnet run --project osu.Desktop
 ```
 
-When running locally to do any kind of performance testing, make sure to add `-c Release` to the build command, as the overhead of running with the default `Debug` configuration can be large (especially when testing with local framework modifications as below).
-
-If the build fails, try to restore NuGet packages with `dotnet restore`.
-
-### Testing with resource/framework modifications
-
-Sometimes it may be necessary to cross-test changes in [osu-resources](https://github.com/ppy/osu-resources) or [osu-framework](https://github.com/ppy/osu-framework). This can be quickly achieved using included commands:
-
-Windows:
-
-```ps
-UseLocalFramework.ps1
-UseLocalResources.ps1
+To **compile**:
+```
+dotnet build osu.Desktop
 ```
 
-macOS / Linux:
+To reduce performance overhead in custom builds, it's recommended to build with the `-c Release` flag, that will use the release profile and remove possibly unneeded debugging code.
 
-```ps
-UseLocalFramework.sh
-UseLocalResources.sh
-```
-
-Note that these commands assume you have the relevant project(s) checked out in adjacent directories:
-
-```
-|- osu            // this repository
-|- osu-framework
-|- osu-resources
-```
-
-### Code analysis
-
-Before committing your code, please run a code formatter. This can be achieved by running `dotnet format` in the command line, or using the `Format code` command in your IDE.
-
-We have adopted some cross-platform, compiler integrated analyzers. They can provide warnings when you are editing, building inside IDE or from command line, as-if they are provided by the compiler itself.
-
-JetBrains ReSharper InspectCode is also used for wider rule sets. You can run it from PowerShell with `.\InspectCode.ps1`. Alternatively, you can install ReSharper or use Rider to get inline support in your IDE of choice.
-
-## Contributing
-
-When it comes to contributing to the project, the two main things you can do to help out are reporting issues and submitting pull requests. Please refer to the [contributing guidelines](CONTRIBUTING.md) to understand how to help in the most effective way possible.
-
-If you wish to help with localisation efforts, head over to [crowdin](https://crowdin.com/project/osu-web).
-
-We love to reward quality contributions. If you have made a large contribution, or are a regular contributor, you are welcome to [submit an expense via opencollective](https://opencollective.com/ppy/expenses/new). If you have any questions, feel free to [reach out to peppy](mailto:pe@ppy.sh) before doing so.
-
-## Licence
-
-*osu!*'s code and framework are licensed under the [MIT licence](https://opensource.org/licenses/MIT). Please see [the licence file](LICENCE) for more information. [tl;dr](https://tldrlegal.com/license/mit-license) you can do whatever you want as long as you include the original copyright and license notice in any copy of the software/source.
-
-Please note that this *does not cover* the usage of the "osu!" or "ppy" branding in any software, resources, advertising or promotion, as this is protected by trademark law.
-
-Please also note that game resources are covered by a separate licence. Please see the [ppy/osu-resources](https://github.com/ppy/osu-resources) repository for clarifications.
+### See the [original readme](README.original.md) for more info.

README.original.md

@@ -0,0 +1,147 @@
+<p align="center">
+  <img width="500" alt="osu! logo" src="assets/lazer.png">
+</p>
+
+# osu!
+
+[![Build status](https://github.com/ppy/osu/actions/workflows/ci.yml/badge.svg?branch=master&event=push)](https://github.com/ppy/osu/actions/workflows/ci.yml)
+[![GitHub release](https://img.shields.io/github/release/ppy/osu.svg)](https://github.com/ppy/osu/releases/latest)
+[![CodeFactor](https://www.codefactor.io/repository/github/ppy/osu/badge)](https://www.codefactor.io/repository/github/ppy/osu)
+[![dev chat](https://discordapp.com/api/guilds/188630481301012481/widget.png?style=shield)](https://discord.gg/ppy)
+[![Crowdin](https://d322cqt584bo4o.cloudfront.net/osu-web/localized.svg)](https://crowdin.com/project/osu-web)
+
+A free-to-win rhythm game. Rhythm is just a *click* away!
+
+This is the future – and final – iteration of the [osu!](https://osu.ppy.sh) game client which marks the beginning of an open era! Currently known by and released under the release codename "*lazer*". As in sharper than cutting-edge.
+
+## Status
+
+This project is under constant development, but we do our best to keep things in a stable state. Players are encouraged to install from a release alongside their stable *osu!* client. This project will continue to evolve until we eventually reach the point where most users prefer it over the previous "osu!stable" release.
+
+A few resources are available as starting points to getting involved and understanding the project:
+
+- Detailed release changelogs are available on the [official osu! site](https://osu.ppy.sh/home/changelog/lazer).
+- You can learn more about our approach to [project management](https://github.com/ppy/osu/wiki/Project-management).
+- Track our current efforts [towards improving the game](https://github.com/orgs/ppy/projects/7/views/6).
+
+## Running osu!
+
+If you are just looking to give the game a whirl, you can grab the latest release for your platform:
+
+### Latest release:
+
+| [Windows 10+ (x64)](https://github.com/ppy/osu/releases/latest/download/install.exe) | macOS 12+ ([Intel](https://github.com/ppy/osu/releases/latest/download/osu.app.Intel.zip), [Apple Silicon](https://github.com/ppy/osu/releases/latest/download/osu.app.Apple.Silicon.zip)) | [Linux (x64)](https://github.com/ppy/osu/releases/latest/download/osu.AppImage) | [iOS 13.4+](https://osu.ppy.sh/home/testflight) | [Android 5+](https://github.com/ppy/osu/releases/latest/download/sh.ppy.osulazer.apk) |
+|--------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| ------------- | ------------- | ------------- |
+
+You can also generally download a version for your current device from the [osu! site](https://osu.ppy.sh/home/download).
+
+If your platform is unsupported or not listed above, there is still a chance you can run the release or manually build it by following the instructions below.
+
+**For iOS/iPadOS users**: The iOS testflight link fills up very fast (Apple has a hard limit of 10,000 users). We reset it occasionally. Please do not ask about this. Check back regularly for link resets or follow [peppy](https://twitter.com/ppy) on twitter for announcements. Our goal is to get the game on mobile app stores very soon so we don't have to live with this limitation.
+
+## Developing a custom ruleset
+
+osu! is designed to allow user-created gameplay variations, called "rulesets". Building one of these allows a developer to harness the power of the osu! beatmap library, game engine, and general UX for a new style of gameplay. To get started working on a ruleset, we have some templates available [here](https://github.com/ppy/osu/tree/master/Templates).
+
+You can see some examples of custom rulesets by visiting the [custom ruleset directory](https://github.com/ppy/osu/discussions/13096).
+
+## Developing osu!
+
+### Prerequisites
+
+Please make sure you have the following prerequisites:
+
+- A desktop platform with the [.NET 8.0 SDK](https://dotnet.microsoft.com/download) installed.
+
+When working with the codebase, we recommend using an IDE with intelligent code completion and syntax highlighting, such as the latest version of [Visual Studio](https://visualstudio.microsoft.com/vs/), [JetBrains Rider](https://www.jetbrains.com/rider/), or [Visual Studio Code](https://code.visualstudio.com/) with the [EditorConfig](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) and [C# Dev Kit](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.csdevkit) plugin installed.
+
+### Downloading the source code
+
+Clone the repository:
+
+```shell
+git clone https://github.com/ppy/osu
+cd osu
+```
+
+To update the source code to the latest commit, run the following command inside the `osu` directory:
+
+```shell
+git pull
+```
+
+### Building
+
+#### From an IDE
+
+You should load the solution via one of the platform-specific `.slnf` files, rather than the main `.sln`. This will reduce dependencies and hide platforms that you don't care about. Valid `.slnf` files are:
+
+- `osu.Desktop.slnf` (most common)
+- `osu.Android.slnf`
+- `osu.iOS.slnf`
+
+Run configurations for the recommended IDEs (listed above) are included. You should use the provided Build/Run functionality of your IDE to get things going. When testing or building new components, it's highly encouraged you use the `osu! (Tests)` project/configuration. More information on this is provided [below](#contributing).
+
+To build for mobile platforms, you will likely need to run `sudo dotnet workload restore` if you haven't done so previously. This will install Android/iOS tooling required to complete the build.
+
+#### From CLI
+
+You can also build and run *osu!* from the command-line with a single command:
+
+```shell
+dotnet run --project osu.Desktop
+```
+
+When running locally to do any kind of performance testing, make sure to add `-c Release` to the build command, as the overhead of running with the default `Debug` configuration can be large (especially when testing with local framework modifications as below).
+
+If the build fails, try to restore NuGet packages with `dotnet restore`.
+
+### Testing with resource/framework modifications
+
+Sometimes it may be necessary to cross-test changes in [osu-resources](https://github.com/ppy/osu-resources) or [osu-framework](https://github.com/ppy/osu-framework). This can be quickly achieved using included commands:
+
+Windows:
+
+```ps
+UseLocalFramework.ps1
+UseLocalResources.ps1
+```
+
+macOS / Linux:
+
+```ps
+UseLocalFramework.sh
+UseLocalResources.sh
+```
+
+Note that these commands assume you have the relevant project(s) checked out in adjacent directories:
+
+```
+|- osu            // this repository
+|- osu-framework
+|- osu-resources
+```
+
+### Code analysis
+
+Before committing your code, please run a code formatter. This can be achieved by running `dotnet format` in the command line, or using the `Format code` command in your IDE.
+
+We have adopted some cross-platform, compiler integrated analyzers. They can provide warnings when you are editing, building inside IDE or from command line, as-if they are provided by the compiler itself.
+
+JetBrains ReSharper InspectCode is also used for wider rule sets. You can run it from PowerShell with `.\InspectCode.ps1`. Alternatively, you can install ReSharper or use Rider to get inline support in your IDE of choice.
+
+## Contributing
+
+When it comes to contributing to the project, the two main things you can do to help out are reporting issues and submitting pull requests. Please refer to the [contributing guidelines](CONTRIBUTING.md) to understand how to help in the most effective way possible.
+
+If you wish to help with localisation efforts, head over to [crowdin](https://crowdin.com/project/osu-web).
+
+We love to reward quality contributions. If you have made a large contribution, or are a regular contributor, you are welcome to [submit an expense via opencollective](https://opencollective.com/ppy/expenses/new). If you have any questions, feel free to [reach out to peppy](mailto:pe@ppy.sh) before doing so.
+
+## Licence
+
+*osu!*'s code and framework are licensed under the [MIT licence](https://opensource.org/licenses/MIT). Please see [the licence file](LICENCE) for more information. [tl;dr](https://tldrlegal.com/license/mit-license) you can do whatever you want as long as you include the original copyright and license notice in any copy of the software/source.
+
+Please note that this *does not cover* the usage of the "osu!" or "ppy" branding in any software, resources, advertising or promotion, as this is protected by trademark law.
+
+Please also note that game resources are covered by a separate licence. Please see the [ppy/osu-resources](https://github.com/ppy/osu-resources) repository for clarifications.

osu.Android.props

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

osu.Desktop/DiscordRichPresence.cs

@@ -189,7 +189,7 @@ namespace osu.Desktop
             }
 
             // user party
-            if (!hideIdentifiableInformation && multiplayerClient.Room != null)
+            if (!hideIdentifiableInformation && multiplayerClient.Room != null && multiplayerClient.Room.Settings.MatchType != MatchType.Matchmaking)
             {
                 MultiplayerRoom room = multiplayerClient.Room;
 

osu.Desktop/OsuGameDesktop.cs

@@ -118,7 +118,7 @@ namespace osu.Desktop
             if (IsPackageManaged)
                 return new NoActionUpdateManager();
 
-            return new VelopackUpdateManager();
+            return new VelopackUpdateManager(); // yay
         }
 
         public override bool RestartAppWhenExited()

osu.Desktop/Program.cs

@@ -44,7 +44,7 @@ namespace osu.Desktop
 
                 // While .NET 8 only supports Windows 10 and above, running on Windows 7/8.1 may still work. We are limited by realm currently, as they choose to only support 8.1 and higher.
                 // See https://www.mongodb.com/docs/realm/sdk/dotnet/compatibility/
-                if (windowsVersion.Major < 6 || (windowsVersion.Major == 6 && windowsVersion.Minor <= 2))
+                if (windowsVersion.Major < 6)
                 {
                     unsafe
                     {
@@ -53,13 +53,26 @@ namespace osu.Desktop
                         // We could also better detect compatibility mode if required:
                         // https://stackoverflow.com/questions/10744651/how-i-can-detect-if-my-application-is-running-under-compatibility-mode#comment58183249_10744730
                         SDL3.SDL_ShowSimpleMessageBox(SDL_MessageBoxFlags.SDL_MESSAGEBOX_ERROR,
-                            "Your operating system is too old to run osu!"u8,
-                            "This version of osu! requires at least Windows 8.1 to run.\n"u8
-                            + "Please upgrade your operating system or consider using an older version of osu!.\n\n"u8
-                            + "If you are running a newer version of windows, please check you don't have \"Compatibility mode\" turned on for osu!"u8, null);
+                            "Your operating system is too old to run this game!"u8,
+                            "This version of the game requires at least Windows 8.1 to run reliably.\n"u8
+                            + "You may try to run it on Windows 8 or older, but it's not guaranteed to actually work.\n\n"u8
+                            + "Please upgrade your operating system or consider using an older game version.\n\n"u8
+                            + "If you are running a newer version of Windows, please check you don't have \"Compatibility mode\" turned on for the game's executable."u8, null);
                         return;
                     }
                 }
+
+                if (windowsVersion.Major == 6 && windowsVersion.Minor <= 2)
+                {
+                    unsafe
+                    {
+                        SDL3.SDL_ShowSimpleMessageBox(SDL_MessageBoxFlags.SDL_MESSAGEBOX_WARNING,
+                            "Your operating system is too old to run this game!"u8,
+                            "While the version of Windows you're using may be able to launch it, it's likely to work unreliably and crash.\n"u8
+                            + "Please upgrade your operating system or consider using an older game version.\n\n"u8
+                            + "If you are running a newer version of Windows, please check you don't have \"Compatibility mode\" turned on for the game's executable."u8, null);
+                    }
+                }
             }
 
             // NVIDIA profiles are based on the executable name of a process.
@@ -208,9 +221,10 @@ namespace osu.Desktop
         [SupportedOSPlatform("windows")]
         private static void configureWindows(VelopackApp app)
         {
-            app.OnFirstRun(_ => WindowsAssociationManager.InstallAssociations());
-            app.OnAfterUpdateFastCallback(_ => WindowsAssociationManager.UpdateAssociations());
-            app.OnBeforeUninstallFastCallback(_ => WindowsAssociationManager.UninstallAssociations());
+            // we do not want associations here, as that breaks official lazer's associations
+            // app.OnFirstRun(_ => WindowsAssociationManager.InstallAssociations());
+            // app.OnAfterUpdateFastCallback(_ => WindowsAssociationManager.UpdateAssociations());
+            // app.OnBeforeUninstallFastCallback(_ => WindowsAssociationManager.UninstallAssociations());
         }
     }
 }

osu.Desktop/Updater/VelopackUpdateManager.cs

@@ -55,7 +55,7 @@ namespace osu.Desktop.Updater
 
             try
             {
-                IUpdateSource updateSource = new GithubSource(@"https://github.com/ppy/osu", null, ReleaseStream.Value == Game.Configuration.ReleaseStream.Tachyon);
+                IUpdateSource updateSource = new GiteaSource(@"https://gitea.jvnko.boats/jvnkosu/client", null, ReleaseStream.Value == Game.Configuration.ReleaseStream.Tachyon);
                 Velopack.UpdateManager updateManager = new Velopack.UpdateManager(updateSource, new UpdateOptions
                 {
                     AllowVersionDowngrade = true

osu.Desktop/osu.Desktop.csproj

@@ -3,11 +3,11 @@
     <TargetFramework>net8.0</TargetFramework>
     <OutputType>WinExe</OutputType>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <Description>A free-to-win rhythm game. Rhythm is just a *click* away!</Description>
+    <Description>A free-to-win rhythm game based on osu!(lazer). Click is just a *rhythm* away!</Description>
     <AssemblyName>osu!</AssemblyName>
-    <AssemblyTitle>osu!(lazer)</AssemblyTitle>
-    <Title>osu!</Title>
-    <Product>osu!(lazer)</Product>
+    <AssemblyTitle>jvnkosu!</AssemblyTitle>
+    <Title>jvnkosu!</Title>
+    <Product>jvnkosu!</Product>
     <ApplicationIcon>lazer.ico</ApplicationIcon>
     <Version>0.0.0</Version>
     <FileVersion>0.0.0</FileVersion>

osu.Desktop/osu.nuspec

@@ -3,16 +3,19 @@
     <metadata>
         <id>osulazer</id>
         <version>0.0.0</version>
-        <title>osu!</title>
-        <authors>ppy Pty Ltd</authors>
+        <title>jvnkosu!</title>
+        <authors>ppy Pty Ltd., jvnkosu! team</authors>
         <owners>Dean Herbert</owners>
-        <projectUrl>https://osu.ppy.sh/</projectUrl>
+        <projectUrl>https://osu.jvnko.boats/</projectUrl>
         <iconUrl>https://github.com/ppy/osu/blob/master/assets/lazer-nuget.png?raw=true</iconUrl>
         <icon>icon.png</icon>
         <requireLicenseAcceptance>false</requireLicenseAcceptance>
-        <description>A free-to-win rhythm game. Rhythm is just a *click* away!</description>
+        <description>A free-to-win rhythm game based on osu!(lazer). Click is just a *rhythm* away!</description>
         <releaseNotes>testing</releaseNotes>
-        <copyright>Copyright (c) 2025 ppy Pty Ltd</copyright>
+        <copyright>
+          Copyright (c) 2025 ppy Pty Ltd
+          Copyright (c) 2025 jvnkosu! team
+        </copyright>
         <language>en-AU</language>
     </metadata>
     <files>

osu.Game.Benchmarks/BenchmarkDifficultyCalculation.cs

@@ -0,0 +1,77 @@
+// 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.IO;
+using BenchmarkDotNet.Attributes;
+using osu.Framework.IO.Stores;
+using osu.Game.Beatmaps;
+using osu.Game.IO;
+using osu.Game.IO.Archives;
+using osu.Game.Rulesets.Catch;
+using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mania;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Taiko;
+using osu.Game.Tests.Resources;
+
+namespace osu.Game.Benchmarks
+{
+    public class BenchmarkDifficultyCalculation : BenchmarkTest
+    {
+        private DifficultyCalculator osuCalculator = null!;
+        private DifficultyCalculator taikoCalculator = null!;
+        private DifficultyCalculator catchCalculator = null!;
+        private DifficultyCalculator maniaCalculator = null!;
+
+        public override void SetUp()
+        {
+            using var resources = new DllResourceStore(typeof(TestResources).Assembly);
+
+            using var archive = resources.GetStream("Resources/Archives/241526 Soleily - Renatus.osz");
+            using var archiveReader = new ZipArchiveReader(archive);
+
+            var osuBeatmap = readBeatmap(archiveReader, "Soleily - Renatus (Gamu) [Insane].osu");
+            var taikoBeatmap = readBeatmap(archiveReader, "Soleily - Renatus (MMzz) [Oni].osu");
+            var catchBeatmap = readBeatmap(archiveReader, "Soleily - Renatus (Deif) [Salad].osu");
+            var maniaBeatmap = readBeatmap(archiveReader, "Soleily - Renatus (ExPew) [Another].osu");
+
+            osuCalculator = new OsuRuleset().CreateDifficultyCalculator(osuBeatmap);
+            taikoCalculator = new TaikoRuleset().CreateDifficultyCalculator(taikoBeatmap);
+            catchCalculator = new CatchRuleset().CreateDifficultyCalculator(catchBeatmap);
+            maniaCalculator = new ManiaRuleset().CreateDifficultyCalculator(maniaBeatmap);
+        }
+
+        private WorkingBeatmap readBeatmap(ZipArchiveReader archiveReader, string beatmapName)
+        {
+            using var beatmapStream = new MemoryStream();
+            archiveReader.GetStream(beatmapName).CopyTo(beatmapStream);
+
+            beatmapStream.Seek(0, SeekOrigin.Begin);
+            using var reader = new LineBufferedReader(beatmapStream);
+
+            var decoder = Beatmaps.Formats.Decoder.GetDecoder<Beatmap>(reader);
+            return new FlatWorkingBeatmap(decoder.Decode(reader));
+        }
+
+        [Benchmark]
+        public void CalculateDifficultyOsu() => osuCalculator.Calculate();
+
+        [Benchmark]
+        public void CalculateDifficultyTaiko() => taikoCalculator.Calculate();
+
+        [Benchmark]
+        public void CalculateDifficultyCatch() => catchCalculator.Calculate();
+
+        [Benchmark]
+        public void CalculateDifficultyMania() => maniaCalculator.Calculate();
+
+        [Benchmark]
+        public void CalculateDifficultyOsuHundredTimes()
+        {
+            for (int i = 0; i < 100; i++)
+            {
+                osuCalculator.Calculate();
+            }
+        }
+    }
+}

osu.Game.Rulesets.Catch.Tests/Resources/old-skin/skin.ini

@@ -1,2 +0,0 @@
-[General]
-// no version specified means v1

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

@@ -157,7 +157,7 @@ namespace osu.Game.Rulesets.Catch.Tests
         }
 
         [Test]
-        public void TestTinyDropletMissPreservesCatcherState()
+        public void TestTinyDropletMissChangesCatcherState()
         {
             AddStep("catch hyper kiai fruit", () => attemptCatch(new TestKiaiFruit
             {
@@ -165,8 +165,8 @@ namespace osu.Game.Rulesets.Catch.Tests
             }));
             AddStep("catch tiny droplet", () => attemptCatch(new TinyDroplet()));
             AddStep("miss tiny droplet", () => attemptCatch(new TinyDroplet { X = 100 }));
-            // catcher state and hyper dash state is preserved
-            checkState(CatcherAnimationState.Kiai);
+            // catcher state is changed but hyper dash state is preserved
+            checkState(CatcherAnimationState.Fail);
             checkHyperDash(true);
         }
 

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

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
         private float halfCatcherWidth;
 
-        public override int Version => 20250306;
+        public override int Version => 20251020;
 
         public CatchDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
             : base(ruleset, beatmap)

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

@@ -3,13 +3,13 @@
 
 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;
 using osu.Game.Scoring.Legacy;
+using osu.Game.Utils;
 
 namespace osu.Game.Rulesets.Catch.Difficulty
 {
@@ -51,15 +51,13 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
             // Combo scaling
             if (catchAttributes.MaxCombo > 0)
-                value *= Math.Min(Math.Pow(score.MaxCombo, 0.8) / Math.Pow(catchAttributes.MaxCombo, 0.8), 1.0);
+                value *= Math.Min(Math.Pow(score.MaxCombo, 0.35) / Math.Pow(catchAttributes.MaxCombo, 0.35), 1.0);
 
             var difficulty = score.BeatmapInfo!.Difficulty.Clone();
 
             score.Mods.OfType<IApplicableToDifficulty>().ForEach(m => m.ApplyToDifficulty(difficulty));
 
-            var track = new TrackVirtual(10000);
-            score.Mods.OfType<IApplicableToTrack>().ForEach(m => m.ApplyToTrack(track));
-            double clockRate = track.Rate;
+            double clockRate = ModUtils.CalculateRateWithMods(score.Mods);
 
             // 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;

osu.Game.Rulesets.Catch/Difficulty/Evaluators/MovementEvaluator.cs

@@ -0,0 +1,65 @@
+// 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.Game.Rulesets.Catch.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+
+namespace osu.Game.Rulesets.Catch.Difficulty.Evaluators
+{
+    public static class MovementEvaluator
+    {
+        private const double direction_change_bonus = 21.0;
+
+        public static double EvaluateDifficultyOf(DifficultyHitObject current, double catcherSpeedMultiplier)
+        {
+            var catchCurrent = (CatchDifficultyHitObject)current;
+            var catchLast = (CatchDifficultyHitObject)current.Previous(0);
+            var catchLastLast = (CatchDifficultyHitObject)current.Previous(1);
+
+            double weightedStrainTime = catchCurrent.StrainTime + 13 + (3 / catcherSpeedMultiplier);
+
+            double distanceAddition = (Math.Pow(Math.Abs(catchCurrent.DistanceMoved), 1.3) / 510);
+            double sqrtStrain = Math.Sqrt(weightedStrainTime);
+
+            double edgeDashBonus = 0;
+
+            // Direction change bonus.
+            if (Math.Abs(catchCurrent.DistanceMoved) > 0.1)
+            {
+                if (current.Index >= 1 && Math.Abs(catchLast.DistanceMoved) > 0.1 && Math.Sign(catchCurrent.DistanceMoved) != Math.Sign(catchLast.DistanceMoved))
+                {
+                    double bonusFactor = Math.Min(50, Math.Abs(catchCurrent.DistanceMoved)) / 50;
+                    double antiflowFactor = Math.Max(Math.Min(70, Math.Abs(catchLast.DistanceMoved)) / 70, 0.38);
+
+                    distanceAddition += direction_change_bonus / Math.Sqrt(catchLast.StrainTime + 16) * bonusFactor * antiflowFactor * Math.Max(1 - Math.Pow(weightedStrainTime / 1000, 3), 0);
+                }
+
+                // Base bonus for every movement, giving some weight to streams.
+                distanceAddition += 12.5 * Math.Min(Math.Abs(catchCurrent.DistanceMoved), CatchDifficultyHitObject.NORMALIZED_HALF_CATCHER_WIDTH * 2)
+                                    / (CatchDifficultyHitObject.NORMALIZED_HALF_CATCHER_WIDTH * 6) / sqrtStrain;
+            }
+
+            // Bonus for edge dashes.
+            if (catchCurrent.LastObject.DistanceToHyperDash <= 20.0f)
+            {
+                if (!catchCurrent.LastObject.HyperDash)
+                    edgeDashBonus += 5.7;
+
+                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_HALF_CATCHER_WIDTH 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_HALF_CATCHER_WIDTH)
+            if (current.Index >= 2 && Math.Abs(catchCurrent.ExactDistanceMoved) <= CatchDifficultyHitObject.NORMALIZED_HALF_CATCHER_WIDTH * 2
+                                   && catchCurrent.ExactDistanceMoved == -catchLast.ExactDistanceMoved && catchLast.ExactDistanceMoved == -catchLastLast.ExactDistanceMoved
+                                   && catchCurrent.StrainTime == catchLast.StrainTime && catchLast.StrainTime == catchLastLast.StrainTime)
+                distanceAddition = 0;
+
+            return distanceAddition / weightedStrainTime;
+        }
+    }
+}

osu.Game.Rulesets.Catch/Difficulty/Preprocessing/CatchDifficultyHitObject.cs

@@ -11,15 +11,49 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Preprocessing
 {
     public class CatchDifficultyHitObject : DifficultyHitObject
     {
-        private const float normalized_hitobject_radius = 41.0f;
+        public const float NORMALIZED_HALF_CATCHER_WIDTH = 41.0f;
+        private const float absolute_player_positioning_error = 16.0f;
 
         public new PalpableCatchHitObject BaseObject => (PalpableCatchHitObject)base.BaseObject;
 
         public new PalpableCatchHitObject LastObject => (PalpableCatchHitObject)base.LastObject;
 
+        /// <summary>
+        /// Normalized position of <see cref="BaseObject"/>.
+        /// </summary>
         public readonly float NormalizedPosition;
+
+        /// <summary>
+        /// Normalized position of <see cref="LastObject"/>.
+        /// </summary>
         public readonly float LastNormalizedPosition;
 
+        /// <summary>
+        /// Normalized position of the player required to catch <see cref="BaseObject"/>, assuming the player moves as little as possible.
+        /// </summary>
+        public float PlayerPosition { get; private set; }
+
+        /// <summary>
+        /// Normalized position of the player after catching <see cref="LastObject"/>.
+        /// </summary>
+        public float LastPlayerPosition { get; private set; }
+
+        /// <summary>
+        /// Normalized distance between <see cref="LastPlayerPosition"/> and <see cref="PlayerPosition"/>.
+        /// </summary>
+        /// <remarks>
+        /// The sign of the value indicates the direction of the movement: negative is left and positive is right.
+        /// </remarks>
+        public float DistanceMoved { get; private set; }
+
+        /// <summary>
+        /// Normalized distance the player has to move from <see cref="LastPlayerPosition"/> in order to catch <see cref="BaseObject"/> at its <see cref="NormalizedPosition"/>.
+        /// </summary>
+        /// <remarks>
+        /// The sign of the value indicates the direction of the movement: negative is left and positive is right.
+        /// </remarks>
+        public float ExactDistanceMoved { get; private set; }
+
         /// <summary>
         /// Milliseconds elapsed since the start time of the previous <see cref="CatchDifficultyHitObject"/>, with a minimum of 40ms.
         /// </summary>
@@ -29,13 +63,35 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Preprocessing
             : base(hitObject, lastObject, clockRate, objects, index)
         {
             // We will scale everything by this factor, so we can assume a uniform CircleSize among beatmaps.
-            float scalingFactor = normalized_hitobject_radius / halfCatcherWidth;
+            float scalingFactor = NORMALIZED_HALF_CATCHER_WIDTH / halfCatcherWidth;
 
             NormalizedPosition = BaseObject.EffectiveX * scalingFactor;
             LastNormalizedPosition = LastObject.EffectiveX * scalingFactor;
 
             // Every strain interval is hard capped at the equivalent of 375 BPM streaming speed as a safety measure
             StrainTime = Math.Max(40, DeltaTime);
+
+            setMovementState();
+        }
+
+        private void setMovementState()
+        {
+            LastPlayerPosition = Index == 0 ? LastNormalizedPosition : ((CatchDifficultyHitObject)Previous(0)).PlayerPosition;
+
+            PlayerPosition = Math.Clamp(
+                LastPlayerPosition,
+                NormalizedPosition - (NORMALIZED_HALF_CATCHER_WIDTH - absolute_player_positioning_error),
+                NormalizedPosition + (NORMALIZED_HALF_CATCHER_WIDTH - absolute_player_positioning_error)
+            );
+
+            DistanceMoved = PlayerPosition - LastPlayerPosition;
+
+            // For the exact position we consider that the catcher is in the correct position for both objects
+            ExactDistanceMoved = NormalizedPosition - LastPlayerPosition;
+
+            // After a hyperdash we ARE in the correct position. Always!
+            if (LastObject.HyperDash)
+                PlayerPosition = NormalizedPosition;
         }
     }
 }

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

@@ -1,8 +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.Game.Rulesets.Catch.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Catch.Difficulty.Evaluators;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Skills;
 using osu.Game.Rulesets.Mods;
@@ -11,10 +10,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
 {
     public class Movement : StrainDecaySkill
     {
-        private const float absolute_player_positioning_error = 16f;
-        private const float normalized_hitobject_radius = 41.0f;
-        private const double direction_change_bonus = 21.0;
-
         protected override double SkillMultiplier => 1;
         protected override double StrainDecayBase => 0.2;
 
@@ -24,12 +19,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
 
         protected readonly float HalfCatcherWidth;
 
-        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.
         /// </summary>
@@ -49,80 +38,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
 
         protected override double StrainValueOf(DifficultyHitObject current)
         {
-            var catchCurrent = (CatchDifficultyHitObject)current;
-
-            lastPlayerPosition ??= catchCurrent.LastNormalizedPosition;
-
-            float playerPosition = Math.Clamp(
-                lastPlayerPosition.Value,
-                catchCurrent.NormalizedPosition - (normalized_hitobject_radius - absolute_player_positioning_error),
-                catchCurrent.NormalizedPosition + (normalized_hitobject_radius - absolute_player_positioning_error)
-            );
-
-            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);
-            double sqrtStrain = Math.Sqrt(weightedStrainTime);
-
-            double edgeDashBonus = 0;
-
-            // Direction change bonus.
-            if (Math.Abs(distanceMoved) > 0.1)
-            {
-                if (Math.Abs(lastDistanceMoved) > 0.1 && Math.Sign(distanceMoved) != Math.Sign(lastDistanceMoved))
-                {
-                    double bonusFactor = Math.Min(50, Math.Abs(distanceMoved)) / 50;
-                    double antiflowFactor = Math.Max(Math.Min(70, Math.Abs(lastDistanceMoved)) / 70, 0.38);
-
-                    distanceAddition += direction_change_bonus / Math.Sqrt(lastStrainTime + 16) * bonusFactor * antiflowFactor * Math.Max(1 - Math.Pow(weightedStrainTime / 1000, 3), 0);
-                }
-
-                // Base bonus for every movement, giving some weight to streams.
-                distanceAddition += 12.5 * Math.Min(Math.Abs(distanceMoved), normalized_hitobject_radius * 2) / (normalized_hitobject_radius * 6) / sqrtStrain;
-            }
-
-            // Bonus for edge dashes.
-            if (catchCurrent.LastObject.DistanceToHyperDash <= 20.0f)
-            {
-                if (!catchCurrent.LastObject.HyperDash)
-                    edgeDashBonus += 5.7;
-                else
-                {
-                    // After a hyperdash we ARE in the correct position. Always!
-                    playerPosition = catchCurrent.NormalizedPosition;
-                }
-
-                distanceAddition *= 1.0 + edgeDashBonus * ((20 - catchCurrent.LastObject.DistanceToHyperDash) / 20)
-                                                        * Math.Pow((Math.Min(catchCurrent.StrainTime * catcherSpeedMultiplier, 265) / 265), 1.5); // Edge Dashes are easier at lower ms values
-            }
-
-            // There is an edge case where horizontal back and forth sliders create "buzz" patterns which are repeated "movements" with a distance lower than
-            // the platter's width but high enough to be considered a movement due to the absolute_player_positioning_error and normalized_hitobject_radius offsets
-            // We are detecting this exact scenario. The first back and forth is counted but all subsequent ones are nullified.
-            // To achieve that, we need to store the exact distances (distance ignoring absolute_player_positioning_error and normalized_hitobject_radius)
-            if (Math.Abs(exactDistanceMoved) <= HalfCatcherWidth * 2 && exactDistanceMoved == -lastExactDistanceMoved && catchCurrent.StrainTime == lastStrainTime)
-            {
-                if (isInBuzzSection)
-                    distanceAddition = 0;
-                else
-                    isInBuzzSection = true;
-            }
-            else
-            {
-                isInBuzzSection = false;
-            }
-
-            lastPlayerPosition = playerPosition;
-            lastDistanceMoved = distanceMoved;
-            lastStrainTime = catchCurrent.StrainTime;
-            lastExactDistanceMoved = exactDistanceMoved;
-
-            return distanceAddition / weightedStrainTime;
+            return MovementEvaluator.EvaluateDifficultyOf(current, catcherSpeedMultiplier);
         }
     }
 }

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

@@ -51,7 +51,8 @@ namespace osu.Game.Rulesets.Catch.Mods
 
                 return string.Empty;
 
-                string format(string acronym, DifficultyBindable bindable) => $"{acronym}{bindable.Value!.Value.ToStandardFormattedString(1)}";
+                string format(string acronym, DifficultyBindable bindable)
+                    => $"{acronym}{bindable.Value!.Value.ToStandardFormattedString(1)}";
             }
         }
 

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

@@ -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);
 

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

@@ -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)
         {

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

@@ -7,6 +7,7 @@ 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;
@@ -23,7 +24,7 @@ namespace osu.Game.Rulesets.Catch.Mods
         public override LocalisableString Description => "Dashing by default, slow down!";
         public override ModType Type => ModType.Fun;
         public override double ScoreMultiplier => 1;
-        public override IconUsage? Icon => FontAwesome.Solid.Running;
+        public override IconUsage? Icon => OsuIcon.ModMovingFast;
         public override Type[] IncompatibleMods => new[] { typeof(ModAutoplay), typeof(ModRelax) };
 
         private DrawableCatchRuleset drawableRuleset = null!;

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

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using osu.Game.Audio;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Types;
@@ -53,13 +54,25 @@ namespace osu.Game.Rulesets.Catch.Objects
 
             public override IEnumerable<string> LookupNames => lookup_names;
 
-            public BananaHitSampleInfo(int volume = 100)
-                : base(string.Empty, volume: volume)
+            public BananaHitSampleInfo()
+                : this(string.Empty)
             {
             }
 
-            public sealed override HitSampleInfo With(Optional<string> newName = default, Optional<string> newBank = default, Optional<string?> newSuffix = default, Optional<int> newVolume = default, Optional<bool> newEditorAutoBank = default)
-                => new BananaHitSampleInfo(newVolume.GetOr(Volume));
+            public BananaHitSampleInfo(HitSampleInfo info)
+                : this(info.Name, info.Bank, info.Suffix, info.Volume, info.EditorAutoBank, info.UseBeatmapSamples)
+            {
+            }
+
+            private BananaHitSampleInfo(string name, string bank = SampleControlPoint.DEFAULT_BANK, string? suffix = null, int volume = 100, bool editorAutoBank = true, bool useBeatmapSamples = false)
+                : base(name, bank, suffix, volume, editorAutoBank, useBeatmapSamples)
+            {
+            }
+
+            public sealed override HitSampleInfo With(Optional<string> newName = default, Optional<string> newBank = default, Optional<string?> newSuffix = default, Optional<int> newVolume = default,
+                                                      Optional<bool> newEditorAutoBank = default, Optional<bool> newUseBeatmapSamples = default)
+                => new BananaHitSampleInfo(newName.GetOr(Name), newBank.GetOr(Bank), newSuffix.GetOr(Suffix), newVolume.GetOr(Volume),
+                    newEditorAutoBank.GetOr(EditorAutoBank), newUseBeatmapSamples.GetOr(UseBeatmapSamples));
 
             public bool Equals(BananaHitSampleInfo? other)
                 => other != null;

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

@@ -43,7 +43,7 @@ namespace osu.Game.Rulesets.Catch.Objects
                 {
                     StartTime = time,
                     BananaIndex = count,
-                    Samples = new List<HitSampleInfo> { new Banana.BananaHitSampleInfo(CreateHitSampleInfo().Volume) }
+                    Samples = new List<HitSampleInfo> { new Banana.BananaHitSampleInfo(CreateHitSampleInfo()) }
                 });
 
                 count++;

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

@@ -224,7 +224,20 @@ namespace osu.Game.Rulesets.Catch.UI
                     addLighting(result, drawableObject.AccentColour.Value, positionInStack.X);
             }
 
-            // droplet doesn't affect the catcher state
+            if (result.IsHit)
+                CurrentState = hitObject.Kiai ? CatcherAnimationState.Kiai : CatcherAnimationState.Idle;
+            else if (hitObject is not Banana)
+                CurrentState = CatcherAnimationState.Fail;
+
+            if (palpableObject.HitObject.LastInCombo)
+            {
+                if (result.Judgement is CatchJudgement catchJudgement && catchJudgement.ShouldExplodeFor(result))
+                    Explode();
+                else
+                    Drop();
+            }
+
+            // droplet doesn't affect hyperdash state
             if (hitObject is TinyDroplet) return;
 
             // if a hyper fruit was already handled this frame, just go where it says to go.
@@ -244,19 +257,6 @@ namespace osu.Game.Rulesets.Catch.UI
                 else
                     SetHyperDashState();
             }
-
-            if (result.IsHit)
-                CurrentState = hitObject.Kiai ? CatcherAnimationState.Kiai : CatcherAnimationState.Idle;
-            else if (!(hitObject is Banana))
-                CurrentState = CatcherAnimationState.Fail;
-
-            if (palpableObject.HitObject.LastInCombo)
-            {
-                if (result.Judgement is CatchJudgement catchJudgement && catchJudgement.ShouldExplodeFor(result))
-                    Explode();
-                else
-                    Drop();
-            }
         }
 
         public void OnRevertResult(JudgementResult result)

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

@@ -147,7 +147,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         }
 
         [TestCase]
-        public void TestFilterIntersection()
+        public void TestKeysFilterIntersection()
         {
             var criteria = new ManiaFilterCriteria();
             criteria.TryParseCustomKeywordCriteria("keys", Operator.Greater, "4");
@@ -175,7 +175,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         }
 
         [TestCase]
-        public void TestInvalidFilters()
+        public void TestInvalidKeysFilters()
         {
             var criteria = new ManiaFilterCriteria();
 
@@ -183,5 +183,132 @@ namespace osu.Game.Rulesets.Mania.Tests
             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"));
+        }
     }
 }

osu.Game.Rulesets.Mania/Difficulty/Evaluators/IndividualStrainEvaluator.cs

@@ -0,0 +1,37 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Mania.Difficulty.Preprocessing;
+
+namespace osu.Game.Rulesets.Mania.Difficulty.Evaluators
+{
+    public class IndividualStrainEvaluator
+    {
+        public static double EvaluateDifficultyOf(DifficultyHitObject current)
+        {
+            var maniaCurrent = (ManiaDifficultyHitObject)current;
+            double startTime = maniaCurrent.StartTime;
+            double endTime = maniaCurrent.EndTime;
+
+            double holdFactor = 1.0; // Factor to all additional strains in case something else is held
+
+            // We award a bonus if this note starts and ends before the end of another hold note.
+            foreach (var maniaPrevious in maniaCurrent.PreviousHitObjects)
+            {
+                if (maniaPrevious is null)
+                    continue;
+
+                if (Precision.DefinitelyBigger(maniaPrevious.EndTime, endTime, 1) &&
+                    Precision.DefinitelyBigger(startTime, maniaPrevious.StartTime, 1))
+                {
+                    holdFactor = 1.25;
+                    break;
+                }
+            }
+
+            return 2.0 * holdFactor;
+        }
+    }
+}

osu.Game.Rulesets.Mania/Difficulty/Evaluators/OverallStrainEvaluator.cs

@@ -0,0 +1,61 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Difficulty.Utils;
+using osu.Game.Rulesets.Mania.Difficulty.Preprocessing;
+
+namespace osu.Game.Rulesets.Mania.Difficulty.Evaluators
+{
+    public class OverallStrainEvaluator
+    {
+        private const double release_threshold = 30;
+
+        public static double EvaluateDifficultyOf(DifficultyHitObject current)
+        {
+            var maniaCurrent = (ManiaDifficultyHitObject)current;
+            double startTime = maniaCurrent.StartTime;
+            double endTime = maniaCurrent.EndTime;
+            bool isOverlapping = false;
+
+            double closestEndTime = Math.Abs(endTime - startTime); // Lowest value we can assume with the current information
+            double holdFactor = 1.0; // Factor to all additional strains in case something else is held
+            double holdAddition = 0; // Addition to the current note in case it's a hold and has to be released awkwardly
+
+            foreach (var maniaPrevious in maniaCurrent.PreviousHitObjects)
+            {
+                if (maniaPrevious is null)
+                    continue;
+
+                // The current note is overlapped if a previous note or end is overlapping the current note body
+                isOverlapping |= Precision.DefinitelyBigger(maniaPrevious.EndTime, startTime, 1) &&
+                                 Precision.DefinitelyBigger(endTime, maniaPrevious.EndTime, 1) &&
+                                 Precision.DefinitelyBigger(startTime, maniaPrevious.StartTime, 1);
+
+                // We give a slight bonus to everything if something is held meanwhile
+                if (Precision.DefinitelyBigger(maniaPrevious.EndTime, endTime, 1) &&
+                    Precision.DefinitelyBigger(startTime, maniaPrevious.StartTime, 1))
+                    holdFactor = 1.25;
+
+                closestEndTime = Math.Min(closestEndTime, Math.Abs(endTime - maniaPrevious.EndTime));
+            }
+
+            // The hold addition is given if there was an overlap, however it is only valid if there are no other note with a similar ending.
+            // Releasing multiple notes is just as easy as releasing 1. Nerfs the hold addition by half if the closest release is release_threshold away.
+            // holdAddition
+            //     ^
+            // 1.0 + - - - - - -+-----------
+            //     |           /
+            // 0.5 + - - - - -/   Sigmoid Curve
+            //     |         /|
+            // 0.0 +--------+-+---------------> Release Difference / ms
+            //         release_threshold
+            if (isOverlapping)
+                holdAddition = DifficultyCalculationUtils.Logistic(x: closestEndTime, multiplier: 0.27, midpointOffset: release_threshold);
+
+            return (1 + holdAddition) * holdFactor;
+        }
+    }
+}

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

@@ -65,13 +65,22 @@ namespace osu.Game.Rulesets.Mania.Difficulty
         protected override IEnumerable<DifficultyHitObject> CreateDifficultyHitObjects(IBeatmap beatmap, double clockRate)
         {
             var sortedObjects = beatmap.HitObjects.ToArray();
+            int totalColumns = ((ManiaBeatmap)beatmap).TotalColumns;
 
             LegacySortHelper<HitObject>.Sort(sortedObjects, Comparer<HitObject>.Create((a, b) => (int)Math.Round(a.StartTime) - (int)Math.Round(b.StartTime)));
 
             List<DifficultyHitObject> objects = new List<DifficultyHitObject>();
+            List<DifficultyHitObject>[] perColumnObjects = new List<DifficultyHitObject>[totalColumns];
+
+            for (int column = 0; column < totalColumns; column++)
+                perColumnObjects[column] = new List<DifficultyHitObject>();
 
             for (int i = 1; i < sortedObjects.Length; i++)
-                objects.Add(new ManiaDifficultyHitObject(sortedObjects[i], sortedObjects[i - 1], clockRate, objects, objects.Count));
+            {
+                var currentObject = new ManiaDifficultyHitObject(sortedObjects[i], sortedObjects[i - 1], clockRate, objects, perColumnObjects, objects.Count);
+                objects.Add(currentObject);
+                perColumnObjects[currentObject.Column].Add(currentObject);
+            }
 
             return objects;
         }

osu.Game.Rulesets.Mania/Difficulty/Preprocessing/ManiaDifficultyHitObject.cs

@@ -12,9 +12,59 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Preprocessing
     {
         public new ManiaHitObject BaseObject => (ManiaHitObject)base.BaseObject;
 
-        public ManiaDifficultyHitObject(HitObject hitObject, HitObject lastObject, double clockRate, List<DifficultyHitObject> objects, int index)
+        private readonly List<DifficultyHitObject>[] perColumnObjects;
+
+        private readonly int columnIndex;
+
+        public readonly int Column;
+
+        // The hit object earlier in time than this note in each column
+        public readonly ManiaDifficultyHitObject?[] PreviousHitObjects;
+
+        public readonly double ColumnStrainTime;
+
+        public ManiaDifficultyHitObject(HitObject hitObject, HitObject lastObject, double clockRate, List<DifficultyHitObject> objects, List<DifficultyHitObject>[] perColumnObjects, int index)
             : base(hitObject, lastObject, clockRate, objects, index)
         {
+            int totalColumns = perColumnObjects.Length;
+            this.perColumnObjects = perColumnObjects;
+            Column = BaseObject.Column;
+            columnIndex = perColumnObjects[Column].Count;
+            PreviousHitObjects = new ManiaDifficultyHitObject[totalColumns];
+            ColumnStrainTime = StartTime - PrevInColumn(0)?.StartTime ?? StartTime;
+
+            if (index > 0)
+            {
+                ManiaDifficultyHitObject prevNote = (ManiaDifficultyHitObject)objects[index - 1];
+
+                for (int i = 0; i < prevNote.PreviousHitObjects.Length; i++)
+                    PreviousHitObjects[i] = prevNote.PreviousHitObjects[i];
+
+                // intentionally depends on processing order to match live.
+                PreviousHitObjects[prevNote.Column] = prevNote;
+            }
+        }
+
+        /// <summary>
+        /// The previous object in the same column as this <see cref="ManiaDifficultyHitObject"/>, exclusive of Long Note tails.
+        /// </summary>
+        /// <param name="backwardsIndex">The number of notes to go back.</param>
+        /// <returns>The object in this column <paramref name="backwardsIndex"/> notes back, or null if this is the first note in the column.</returns>
+        public ManiaDifficultyHitObject? PrevInColumn(int backwardsIndex)
+        {
+            int index = columnIndex - (backwardsIndex + 1);
+            return index >= 0 && index < perColumnObjects[Column].Count ? (ManiaDifficultyHitObject)perColumnObjects[Column][index] : null;
+        }
+
+        /// <summary>
+        /// The next object in the same column as this <see cref="ManiaDifficultyHitObject"/>, exclusive of Long Note tails.
+        /// </summary>
+        /// <param name="forwardsIndex">The number of notes to go forward.</param>
+        /// <returns>The object in this column <paramref name="forwardsIndex"/> notes forward, or null if this is the last note in the column.</returns>
+        public ManiaDifficultyHitObject? NextInColumn(int forwardsIndex)
+        {
+            int index = columnIndex + (forwardsIndex + 1);
+            return index >= 0 && index < perColumnObjects[Column].Count ? (ManiaDifficultyHitObject)perColumnObjects[Column][index] : null;
         }
     }
 }

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

@@ -2,10 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using osu.Framework.Utils;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Skills;
-using osu.Game.Rulesets.Difficulty.Utils;
+using osu.Game.Rulesets.Mania.Difficulty.Evaluators;
 using osu.Game.Rulesets.Mania.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Mods;
 
@@ -15,23 +14,17 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Skills
     {
         private const double individual_decay_base = 0.125;
         private const double overall_decay_base = 0.30;
-        private const double release_threshold = 30;
 
         protected override double SkillMultiplier => 1;
         protected override double StrainDecayBase => 1;
 
-        private readonly double[] startTimes;
-        private readonly double[] endTimes;
         private readonly double[] individualStrains;
-
-        private double individualStrain;
+        private double highestIndividualStrain;
         private double overallStrain;
 
         public Strain(Mod[] mods, int totalColumns)
             : base(mods)
         {
-            startTimes = new double[totalColumns];
-            endTimes = new double[totalColumns];
             individualStrains = new double[totalColumns];
             overallStrain = 1;
         }
@@ -39,64 +32,23 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Skills
         protected override double StrainValueOf(DifficultyHitObject current)
         {
             var maniaCurrent = (ManiaDifficultyHitObject)current;
-            double startTime = maniaCurrent.StartTime;
-            double endTime = maniaCurrent.EndTime;
-            int column = maniaCurrent.BaseObject.Column;
-            bool isOverlapping = false;
 
-            double closestEndTime = Math.Abs(endTime - startTime); // Lowest value we can assume with the current information
-            double holdFactor = 1.0; // Factor to all additional strains in case something else is held
-            double holdAddition = 0; // Addition to the current note in case it's a hold and has to be released awkwardly
+            individualStrains[maniaCurrent.Column] = applyDecay(individualStrains[maniaCurrent.Column], maniaCurrent.ColumnStrainTime, individual_decay_base);
+            individualStrains[maniaCurrent.Column] += IndividualStrainEvaluator.EvaluateDifficultyOf(current);
 
-            for (int i = 0; i < endTimes.Length; ++i)
-            {
-                // The current note is overlapped if a previous note or end is overlapping the current note body
-                isOverlapping |= Precision.DefinitelyBigger(endTimes[i], startTime, 1) &&
-                                 Precision.DefinitelyBigger(endTime, endTimes[i], 1) &&
-                                 Precision.DefinitelyBigger(startTime, startTimes[i], 1);
+            // Take the hardest individualStrain for notes that happen at the same time (in a chord).
+            // This is to ensure the order in which the notes are processed does not affect the resultant total strain.
+            highestIndividualStrain = maniaCurrent.DeltaTime <= 1 ? Math.Max(highestIndividualStrain, individualStrains[maniaCurrent.Column]) : individualStrains[maniaCurrent.Column];
 
-                // We give a slight bonus to everything if something is held meanwhile
-                if (Precision.DefinitelyBigger(endTimes[i], endTime, 1) &&
-                    Precision.DefinitelyBigger(startTime, startTimes[i], 1))
-                    holdFactor = 1.25;
-
-                closestEndTime = Math.Min(closestEndTime, Math.Abs(endTime - endTimes[i]));
-            }
-
-            // The hold addition is given if there was an overlap, however it is only valid if there are no other note with a similar ending.
-            // Releasing multiple notes is just as easy as releasing 1. Nerfs the hold addition by half if the closest release is release_threshold away.
-            // holdAddition
-            //     ^
-            // 1.0 + - - - - - -+-----------
-            //     |           /
-            // 0.5 + - - - - -/   Sigmoid Curve
-            //     |         /|
-            // 0.0 +--------+-+---------------> Release Difference / ms
-            //         release_threshold
-            if (isOverlapping)
-                holdAddition = DifficultyCalculationUtils.Logistic(x: closestEndTime, multiplier: 0.27, midpointOffset: release_threshold);
-
-            // Decay and increase individualStrains in own column
-            individualStrains[column] = applyDecay(individualStrains[column], startTime - startTimes[column], individual_decay_base);
-            individualStrains[column] += 2.0 * holdFactor;
-
-            // For notes at the same time (in a chord), the individualStrain should be the hardest individualStrain out of those columns
-            individualStrain = maniaCurrent.DeltaTime <= 1 ? Math.Max(individualStrain, individualStrains[column]) : individualStrains[column];
-
-            // Decay and increase overallStrain
-            overallStrain = applyDecay(overallStrain, current.DeltaTime, overall_decay_base);
-            overallStrain += (1 + holdAddition) * holdFactor;
-
-            // Update startTimes and endTimes arrays
-            startTimes[column] = startTime;
-            endTimes[column] = endTime;
+            overallStrain = applyDecay(overallStrain, maniaCurrent.DeltaTime, overall_decay_base);
+            overallStrain += OverallStrainEvaluator.EvaluateDifficultyOf(current);
 
             // By subtracting CurrentStrain, this skill effectively only considers the maximum strain of any one hitobject within each strain section.
-            return individualStrain + overallStrain - CurrentStrain;
+            return highestIndividualStrain + overallStrain - CurrentStrain;
         }
 
-        protected override double CalculateInitialStrain(double offset, DifficultyHitObject current)
-            => applyDecay(individualStrain, offset - current.Previous(0).StartTime, individual_decay_base)
+        protected override double CalculateInitialStrain(double offset, DifficultyHitObject current) =>
+            applyDecay(highestIndividualStrain, offset - current.Previous(0).StartTime, individual_decay_base)
             + applyDecay(overallStrain, offset - current.Previous(0).StartTime, overall_decay_base);
 
         private double applyDecay(double value, double deltaTime, double decayBase)

osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Bindables;
@@ -19,12 +20,16 @@ namespace osu.Game.Rulesets.Mania
     public class ManiaFilterCriteria : IRulesetFilterCriteria
     {
         private readonly HashSet<int> includedKeyCounts = Enumerable.Range(1, LegacyBeatmapDecoder.MAX_MANIA_KEY_COUNT).ToHashSet();
+        private FilterCriteria.OptionalRange<float> longNotePercentage;
 
         public bool Matches(BeatmapInfo beatmapInfo, FilterCriteria criteria)
         {
             int keyCount = ManiaBeatmapConverter.GetColumnCount(LegacyBeatmapConversionDifficultyInfo.FromBeatmapInfo(beatmapInfo), criteria.Mods);
 
-            return includedKeyCounts.Contains(keyCount);
+            bool keyCountMatch = includedKeyCounts.Contains(keyCount);
+            bool longNotePercentageMatch = !longNotePercentage.HasFilter || (!isConvertedBeatmap(beatmapInfo) && longNotePercentage.IsInRange(calculateLongNotePercentage(beatmapInfo)));
+
+            return keyCountMatch && longNotePercentageMatch;
         }
 
         public bool TryParseCustomKeywordCriteria(string key, Operator op, string strValues)
@@ -84,6 +89,10 @@ namespace osu.Game.Rulesets.Mania
                             return false;
                     }
                 }
+
+                case "ln":
+                case "lns":
+                    return FilterQueryParser.TryUpdateCriteriaRange(ref longNotePercentage, op, strValues);
             }
 
             return false;
@@ -103,5 +112,18 @@ namespace osu.Game.Rulesets.Mania
 
             return false;
         }
+
+        private static bool isConvertedBeatmap(BeatmapInfo beatmapInfo)
+        {
+            return !beatmapInfo.Ruleset.Equals(new ManiaRuleset().RulesetInfo);
+        }
+
+        private static float calculateLongNotePercentage(BeatmapInfo beatmapInfo)
+        {
+            int holdNotes = beatmapInfo.EndTimeObjectCount;
+            int totalNotes = Math.Max(1, beatmapInfo.TotalObjectCount);
+
+            return holdNotes / (float)totalNotes * 100;
+        }
     }
 }

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -79,6 +79,7 @@ namespace osu.Game.Rulesets.Mania
                     return new ManiaArgonSkinTransformer(skin, beatmap);
 
                 case DefaultLegacySkin:
+                case RetroSkin:
                     return new ManiaClassicSkinTransformer(skin, beatmap);
 
                 case LegacySkin:

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

@@ -14,8 +14,8 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override string Acronym => Name;
         public abstract int KeyCount { get; }
         public override ModType Type => ModType.Conversion;
-        public override double ScoreMultiplier => 0.9;
-        public override bool Ranked => UsesDefaultConfiguration;
+        public override double ScoreMultiplier => 1;
+        public override bool Ranked => true;
 
         public void ApplyToBeatmapConverter(IBeatmapConverter beatmapConverter)
         {

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

@@ -4,6 +4,7 @@
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
@@ -21,7 +22,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override LocalisableString Description => "No more tricky speed changes!";
 
-        public override IconUsage? Icon => FontAwesome.Solid.Equals;
+        public override IconUsage? Icon => OsuIcon.ModConstantSpeed;
 
         public override ModType Type => ModType.Conversion;
 

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

@@ -4,8 +4,10 @@
 using System;
 using System.Linq;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.UI;
 
 namespace osu.Game.Rulesets.Mania.Mods
@@ -14,6 +16,7 @@ namespace osu.Game.Rulesets.Mania.Mods
     {
         public override string Name => "Cover";
         public override string Acronym => "CO";
+        public override IconUsage? Icon => OsuIcon.ModCover;
 
         public override LocalisableString Description => @"Decrease the playfield's viewing area.";
 
@@ -27,7 +30,7 @@ namespace osu.Game.Rulesets.Mania.Mods
             typeof(ManiaModFadeIn)
         }).ToArray();
 
-        public override bool Ranked => false;
+        public override bool Ranked => true;
 
         public override bool ValidForFreestyleAsRequiredMod => false;
 

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

@@ -7,5 +7,20 @@ namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModDifficultyAdjust : ModDifficultyAdjust
     {
+        public override DifficultyBindable OverallDifficulty { get; } = new DifficultyBindable
+        {
+            Precision = 0.1f,
+            MinValue = 0,
+            MaxValue = 10,
+            // Use larger extended limits for mania to include OD values that occur with EZ or HR enabled
+#if !DEBUG
+            ExtendedMaxValue = 15,
+            ExtendedMinValue = -15,
+#else
+            ExtendedMinValue = -250,
+            ExtendedMaxValue = 50,
+#endif
+            ReadCurrentFromDifficulty = diff => diff.OverallDifficulty,
+        };
     }
 }

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

@@ -1,8 +1,10 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mods;
 
@@ -13,6 +15,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override string Name => "Dual Stages";
         public override string Acronym => "DS";
         public override LocalisableString Description => @"Double the stages, double the fun!";
+        public override IconUsage? Icon => OsuIcon.ModDualStages;
         public override ModType Type => ModType.Conversion;
         public override double ScoreMultiplier => 1;
 

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

@@ -3,7 +3,9 @@
 
 using System;
 using System.Linq;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.UI;
 
 namespace osu.Game.Rulesets.Mania.Mods
@@ -12,6 +14,7 @@ namespace osu.Game.Rulesets.Mania.Mods
     {
         public override string Name => "Fade In";
         public override string Acronym => "FI";
+        public override IconUsage? Icon => OsuIcon.ModFadeIn;
         public override LocalisableString Description => @"Keys appear out of nowhere!";
         public override double ScoreMultiplier => 1;
         public override bool ValidForFreestyleAsRequiredMod => false;

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

@@ -11,7 +11,7 @@ namespace osu.Game.Rulesets.Mania.Mods
     public class ManiaModHardRock : ModHardRock, IApplicableToHitObject
     {
         public override double ScoreMultiplier => 1;
-        public override bool Ranked => false;
+        public override bool Ranked => true;
 
         public const double HIT_WINDOW_DIFFICULTY_MULTIPLIER = 1.4;
 

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

@@ -9,6 +9,8 @@ using osu.Game.Rulesets.Mods;
 using osu.Framework.Graphics.Sprites;
 using System.Collections.Generic;
 using osu.Framework.Localisation;
+using osu.Framework.Utils;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Beatmaps;
 
 namespace osu.Game.Rulesets.Mania.Mods
@@ -23,7 +25,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override LocalisableString Description => @"Replaces all hold notes with normal notes.";
 
-        public override IconUsage? Icon => FontAwesome.Solid.DotCircle;
+        public override IconUsage? Icon => OsuIcon.ModHoldOff;
 
         public override ModType Type => ModType.Conversion;
 
@@ -33,6 +35,8 @@ namespace osu.Game.Rulesets.Mania.Mods
         {
             var maniaBeatmap = (ManiaBeatmap)beatmap;
 
+            double mostCommonBeatLengthBefore = beatmap.GetMostCommonBeatLength();
+
             var newObjects = new List<ManiaHitObject>();
 
             foreach (var h in beatmap.HitObjects.OfType<HoldNote>())
@@ -47,6 +51,17 @@ namespace osu.Game.Rulesets.Mania.Mods
             }
 
             maniaBeatmap.HitObjects = maniaBeatmap.HitObjects.OfType<Note>().Concat(newObjects).OrderBy(h => h.StartTime).ToList();
+
+            double mostCommonBeatLengthAfter = beatmap.GetMostCommonBeatLength();
+
+            // the process of removing hold notes can result in shortening the beatmap's play time,
+            // and therefore, as a side effect, changing the most common BPM, which will change scroll speed.
+            // to compensate for this, apply a multiplier to effect points in order to maintain the beatmap's original intended scroll speed.
+            if (!Precision.AlmostEquals(mostCommonBeatLengthBefore, mostCommonBeatLengthAfter))
+            {
+                foreach (var effectPoint in beatmap.ControlPointInfo.EffectPoints)
+                    effectPoint.ScrollSpeed *= mostCommonBeatLengthBefore / mostCommonBeatLengthAfter;
+            }
         }
     }
 }

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

@@ -8,6 +8,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;
@@ -23,7 +24,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override LocalisableString Description => "Hold the keys. To the beat.";
 
-        public override IconUsage? Icon => FontAwesome.Solid.YinYang;
+        public override IconUsage? Icon => OsuIcon.ModInvert;
 
         public override ModType Type => ModType.Conversion;
 

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

@@ -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 osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,7 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 1;
         public override string Name => "One Key";
         public override string Acronym => "1K";
+        public override IconUsage? Icon => OsuIcon.ModOneKey;
         public override LocalisableString Description => @"Play with one key.";
-        public override bool Ranked => false;
     }
 }

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

@@ -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 osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,7 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 10;
         public override string Name => "Ten Keys";
         public override string Acronym => "10K";
+        public override IconUsage? Icon => OsuIcon.ModTenKeys;
         public override LocalisableString Description => @"Play with ten keys.";
-        public override bool Ranked => false;
     }
 }

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

@@ -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 osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,7 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 2;
         public override string Name => "Two Keys";
         public override string Acronym => "2K";
+        public override IconUsage? Icon => OsuIcon.ModTwoKeys;
         public override LocalisableString Description => @"Play with two keys.";
-        public override bool Ranked => false;
     }
 }

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

@@ -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 osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,7 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 3;
         public override string Name => "Three Keys";
         public override string Acronym => "3K";
+        public override IconUsage? Icon => OsuIcon.ModThreeKeys;
         public override LocalisableString Description => @"Play with three keys.";
-        public override bool Ranked => false;
     }
 }

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

@@ -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 osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,6 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 4;
         public override string Name => "Four Keys";
         public override string Acronym => "4K";
+        public override IconUsage? Icon => OsuIcon.ModFourKeys;
         public override LocalisableString Description => @"Play with four keys.";
     }
 }

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

@@ -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 osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,6 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 5;
         public override string Name => "Five Keys";
         public override string Acronym => "5K";
+        public override IconUsage? Icon => OsuIcon.ModFiveKeys;
         public override LocalisableString Description => @"Play with five keys.";
     }
 }

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

@@ -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 osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,6 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 6;
         public override string Name => "Six Keys";
         public override string Acronym => "6K";
+        public override IconUsage? Icon => OsuIcon.ModSixKeys;
         public override LocalisableString Description => @"Play with six keys.";
     }
 }

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

@@ -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 osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,6 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 7;
         public override string Name => "Seven Keys";
         public override string Acronym => "7K";
+        public override IconUsage? Icon => OsuIcon.ModSevenKeys;
         public override LocalisableString Description => @"Play with seven keys.";
     }
 }

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

@@ -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 osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,6 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 8;
         public override string Name => "Eight Keys";
         public override string Acronym => "8K";
+        public override IconUsage? Icon => OsuIcon.ModEightKeys;
         public override LocalisableString Description => @"Play with eight keys.";
     }
 }

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

@@ -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 osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,6 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 9;
         public override string Name => "Nine Keys";
         public override string Acronym => "9K";
+        public override IconUsage? Icon => OsuIcon.ModNineKeys;
         public override LocalisableString Description => @"Play with nine keys.";
     }
 }

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

@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Mania.Mods
     public class ManiaModMirror : ModMirror, IApplicableToBeatmap
     {
         public override LocalisableString Description => "Notes are flipped horizontally.";
-        public override bool Ranked => UsesDefaultConfiguration;
+        public override bool Ranked => true;
 
         public void ApplyToBeatmap(IBeatmap beatmap)
         {

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

@@ -4,8 +4,10 @@
 using System;
 using System.Linq;
 using System.Threading;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
@@ -26,6 +28,8 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override double ScoreMultiplier => 0.9;
 
+        public override IconUsage? Icon => OsuIcon.ModNoRelease;
+
         public override ModType Type => ModType.DifficultyReduction;
 
         public override Type[] IncompatibleMods => new[] { typeof(ManiaModHoldOff) };

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

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 
         private Drawable noteAnimation = null!;
 
-        private float? minimumColumnWidth;
+        private float? widthForNoteHeightScale;
 
         public LegacyNotePiece()
         {
@@ -33,7 +33,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
         [BackgroundDependencyLoader]
         private void load(ISkinSource skin, IScrollingInfo scrollingInfo)
         {
-            minimumColumnWidth = skin.GetConfig<ManiaSkinConfigurationLookup, float>(new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.MinimumColumnWidth))?.Value;
+            widthForNoteHeightScale = skin.GetConfig<ManiaSkinConfigurationLookup, float>(new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.WidthForNoteHeightScale))?.Value;
 
             InternalChild = directionContainer = new Container
             {
@@ -60,9 +60,8 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 
             if (texture != null)
             {
-                // The height is scaled to the minimum column width, if provided.
-                float minimumWidth = minimumColumnWidth ?? DrawWidth;
-                noteAnimation.Scale = Vector2.Divide(new Vector2(DrawWidth, minimumWidth), texture.DisplayWidth);
+                float noteHeight = widthForNoteHeightScale ?? DrawWidth;
+                noteAnimation.Scale = Vector2.Divide(new Vector2(DrawWidth, noteHeight), texture.DisplayWidth);
             }
         }
 

osu.Game.Rulesets.Mania/VariantMappingGenerator.cs

@@ -42,13 +42,22 @@ namespace osu.Game.Rulesets.Mania
             var bindings = new List<KeyBinding>();
 
             for (int i = LeftKeys.Length - columns / 2; i < LeftKeys.Length; i++)
-                bindings.Add(new KeyBinding(LeftKeys[i], currentAction++));
+            {
+                bindings.Add(new KeyBinding(LeftKeys[i], currentAction));
+                bindings.Add(new KeyBinding(InputKey.None, currentAction++));
+            }
 
             if (columns % 2 == 1)
-                bindings.Add(new KeyBinding(SpecialKey, currentAction++));
+            {
+                bindings.Add(new KeyBinding(SpecialKey, currentAction));
+                bindings.Add(new KeyBinding(InputKey.None, currentAction++));
+            }
 
             for (int i = 0; i < columns / 2; i++)
-                bindings.Add(new KeyBinding(RightKeys[i], currentAction++));
+            {
+                bindings.Add(new KeyBinding(RightKeys[i], currentAction));
+                bindings.Add(new KeyBinding(InputKey.None, currentAction++));
+            }
 
             return bindings;
         }

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

@@ -32,26 +32,6 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
         [Test]
         public void TestComboBasedSize([Values] bool comboBasedSize) => CreateModTest(new ModTestData { Mod = new OsuModFlashlight { ComboBasedSize = { Value = comboBasedSize } }, PassCondition = () => true });
 
-        [Test]
-        public void TestPlayfieldBasedSize()
-        {
-            OsuModFlashlight flashlight;
-            CreateModTest(new ModTestData
-            {
-                Mods = [flashlight = new OsuModFlashlight(), new OsuModBarrelRoll()],
-                PassCondition = () =>
-                {
-                    var flashlightOverlay = Player.DrawableRuleset.Overlays
-                                                  .ChildrenOfType<ModFlashlight<OsuHitObject>.Flashlight>()
-                                                  .First();
-
-                    // the combo check is here because the flashlight radius decreases for the first time at 100 combo
-                    // and hardcoding it here eliminates the need to meddle in flashlight internals further by e.g. exposing `GetComboScaleFor()`
-                    return flashlightOverlay.GetSize() < flashlight.DefaultFlashlightSize && Player.GameplayState.ScoreProcessor.Combo.Value < 100;
-                }
-            });
-        }
-
         [Test]
         public void TestSliderDimsOnlyAfterStartTime()
         {

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

@@ -15,22 +15,22 @@ namespace osu.Game.Rulesets.Osu.Tests
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Osu.Tests";
 
-        [TestCase(6.7331304290522747d, 239, "diffcalc-test")]
-        [TestCase(1.4602604078137214d, 54, "zero-length-sliders")]
-        [TestCase(0.43052813047866129d, 4, "very-fast-slider")]
-        [TestCase(0.14143808967817237d, 2, "nan-slider")]
+        [TestCase(6.6232533278125061d, 239, "diffcalc-test")]
+        [TestCase(1.5045783545699611d, 54, "zero-length-sliders")]
+        [TestCase(0.43333836671191595d, 4, "very-fast-slider")]
+        [TestCase(0.13841532030395723d, 2, "nan-slider")]
         public void Test(double expectedStarRating, int expectedMaxCombo, string name)
             => base.Test(expectedStarRating, expectedMaxCombo, name);
 
-        [TestCase(9.6779746353001634d, 239, "diffcalc-test")]
-        [TestCase(1.7691451263718989d, 54, "zero-length-sliders")]
-        [TestCase(0.55785578988249407d, 4, "very-fast-slider")]
+        [TestCase(9.6491691624112761d, 239, "diffcalc-test")]
+        [TestCase(1.756936832498702d, 54, "zero-length-sliders")]
+        [TestCase(0.57771197086735004d, 4, "very-fast-slider")]
         public void TestClockRateAdjusted(double expectedStarRating, int expectedMaxCombo, string name)
             => Test(expectedStarRating, expectedMaxCombo, name, new OsuModDoubleTime());
 
-        [TestCase(6.7331304290522747d, 239, "diffcalc-test")]
-        [TestCase(1.4602604078137214d, 54, "zero-length-sliders")]
-        [TestCase(0.43052813047866129d, 4, "very-fast-slider")]
+        [TestCase(6.6232533278125061d, 239, "diffcalc-test")]
+        [TestCase(1.5045783545699611d, 54, "zero-length-sliders")]
+        [TestCase(0.43333836671191595d, 4, "very-fast-slider")]
         public void TestClassicMod(double expectedStarRating, int expectedMaxCombo, string name)
             => Test(expectedStarRating, expectedMaxCombo, name, new OsuModClassic());