(NOT STABLE!!) Added custom mode using music from MainMenu

.editorconfig

@@ -19,11 +19,6 @@ 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,6 +1,12 @@
-blank_issues_enabled: true
+blank_issues_enabled: false
 contact_links:
     - name: Help
-      url: https://t.me/jvnkosu_chat
-      about: Your jvnkosu! is not working right? Please contact us using our Telegram chat
+      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.
 

.github/workflows/ci.yml

@@ -1,10 +1,4 @@
-on:
-  push:
-    tags:
-      - '*'
-  workflow_dispatch:
-
-
+on: [push, pull_request]
 name: Continuous Integration
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -39,7 +33,7 @@ jobs:
           key: inspectcode-${{ hashFiles('.config/dotnet-tools.json', '.github/workflows/ci.yml', 'osu.sln*', 'osu*.slnf', '.editorconfig', '.globalconfig', 'CodeAnalysis/*', '**/*.csproj', '**/*.props') }}
 
       - name: Dotnet code style
-        run: dotnet build -c Debug -warnaserror osu.Desktop.slnf
+        run: dotnet build -c Debug -warnaserror osu.Desktop.slnf -p:EnforceCodeStyleInBuild=true
 
       - name: CodeFileSanity
         run: |
@@ -154,7 +148,9 @@ 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
+        run: |
+          sudo xcode-select -switch /Applications/Xcode_16.4.app
+          xcodebuild -downloadPlatform iOS
 
       - name: Build
         run: dotnet build -c Debug osu.iOS.slnf

.github/workflows/deploy.yml

@@ -4,7 +4,6 @@ on:
   push:
     tags:
       - '*'
-  workflow_dispatch:
 
 jobs:
   notify_pending_production_deploy:
@@ -13,7 +12,7 @@ jobs:
       - name: Submit pending deployment notification
         run: |
           export TITLE="Pending osu Production Deployment: $GITHUB_REF_NAME"
-          export URL="https://github.com/jvnkosu-dev/client/actions/runs/$GITHUB_RUN_ID"
+          export URL="https://github.com/ppy/osu/actions/runs/$GITHUB_RUN_ID"
           export DESCRIPTION="Awaiting approval for building NuGet packages for tag $GITHUB_REF_NAME:
           [View Workflow Run]($URL)"
           export ACTOR_ICON="https://avatars.githubusercontent.com/u/$GITHUB_ACTOR_ID"

.github/workflows/sentry-release.yml

@@ -21,9 +21,9 @@ jobs:
         uses: getsentry/action-release@v1
         env:
           SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
-          SENTRY_ORG: jvnkosu
-          SENTRY_PROJECT: client
-          SENTRY_URL: https://satellite.jvnko.boats/
+          SENTRY_ORG: ppy
+          SENTRY_PROJECT: osu
+          SENTRY_URL: https://sentry.ppy.sh/
         with:
           environment: production
-          version: jvnkosu@${{ github.ref_name }}
+          version: osu@${{ github.ref_name }}

.github/workflows/update-web-mod-definitions.yml

@@ -1,10 +1,8 @@
-name: Update osu-web mod definitions (DO NOT USE YET!!!!!)
+name: Update osu-web mod definitions
 on:
-  workflow_dispatch:
-  # push:
-  #   tags:
-  #     - '*'
-
+  push:
+    tags:
+      - '*'
 
 permissions:
   contents: read # to fetch code (actions/checkout)

.gitignore

@@ -344,4 +344,4 @@ inspectcode
 FodyWeavers.xsd
 
 .idea/.idea.osu.Desktop/.idea/misc.xml
-.idea/.idea.osu.Android/.idea/deploymentTargetDropDown.xml
+.idea/.idea.osu.Android/.idea/deploymentTargetDropDown.xml

.vscode/settings.json

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

CONTRIBUTING.md

@@ -73,9 +73,6 @@ Aside from the above, below is a brief checklist of things to watch out when you
 After you're done with your changes and you wish to open the PR, please observe the following recommendations:
 
 - Please submit the pull request from a [topic branch](https://git-scm.com/book/en/v2/Git-Branching-Branching-Workflows#_topic_branch) (not `master`), and keep the *Allow edits from maintainers* check box selected, so that we can push fixes to your PR if necessary.
-- Please pick the following target branch for your pull request:
-    - `pp-dev`, if the change impacts star rating or performance points calculations for any of the rulesets,
-    - `master`, otherwise.
 - Please avoid pushing untested or incomplete code.
 - Please do not force-push or rebase unless we ask you to.
 - Please do not merge `master` continually if there are no conflicts to resolve. We will do this for you when the change is ready for merge.

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, jvnkosu! team</Company>
+    <Company>ppy Pty Ltd</Company>
     <Copyright>Copyright (c) 2025 ppy Pty Ltd</Copyright>
     <PackageTags>osu game</PackageTags>
   </PropertyGroup>

README.md

@@ -1,40 +1,147 @@
-# jvnkosu! client
+<p align="center">
+  <img width="500" alt="osu! logo" src="assets/lazer.png">
+</p>
 
-A free-to-win rhythm game based on osu!(lazer). Click is just a *rhythm* away!
+# osu!
 
-## Disclaimer
+[![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)
 
-*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.
+A free-to-win rhythm game. Rhythm is just a *click* away!
 
-## License
-Client source code is licensed under the MIT license, see the [LICENCE](LICENCE) file in repository root for more info.
+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.
 
-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.
+## Status
 
-Registered trademarks "osu!" and "ppy" are property of ppy Pty Ltd., and protected by trademark law.
+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.
 
-## Compiling from source
-Building jvnkosu! from source is pretty much possible (and welcome here).  
+A few resources are available as starting points to getting involved and understanding the project:
 
-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.  
+- 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).
 
-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
+## 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:
 
-To **run** the project, switch to project's directory and run the following:
+```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
 ```
 
-To **compile**:
-```
-dotnet build 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 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.
+macOS / Linux:
 
-### See the [original readme](README.original.md) for more info.
+```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.

README.original.md

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

Templates/osu.Game.Templates.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <PackageType>Template</PackageType>
-    <PackageId>jvnkosu.Client.Templates</PackageId>
+    <PackageId>ppy.osu.Game.Templates</PackageId>
     <Title>osu! templates</Title>
     <Authors>ppy Pty Ltd</Authors>
     <PackageLicenseUrl>https://github.com/ppy/osu/blob/master/LICENCE</PackageLicenseUrl>

osu.Android.props

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

osu.Android/AndroidManifest.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="boats.jvnko.osu.android" android:installLocation="auto">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="sh.ppy.osulazer" android:installLocation="auto">
 	<uses-sdk android:minSdkVersion="21" android:targetSdkVersion="34" />
 	<application android:allowBackup="true"
 				 android:supportsRtl="true"

osu.Desktop/DiscordRichPresence.cs

@@ -29,7 +29,7 @@ namespace osu.Desktop
 {
     internal partial class DiscordRichPresence : Component
     {
-        private const string client_id = "1440647613358800918";
+        private const string client_id = "1216669957799018608";
 
         private DiscordRpcClient client = null!;
 
@@ -189,7 +189,7 @@ namespace osu.Desktop
             }
 
             // user party
-            if (!hideIdentifiableInformation && multiplayerClient.Room != null && multiplayerClient.Room.Settings.MatchType != MatchType.Matchmaking)
+            if (!hideIdentifiableInformation && multiplayerClient.Room != null)
             {
                 MultiplayerRoom room = multiplayerClient.Room;
 

osu.Desktop/OsuGameDesktop.cs

@@ -115,10 +115,12 @@ namespace osu.Desktop
             if (IsFirstRun)
                 LocalConfig.SetValue(OsuSetting.ReleaseStream, ReleaseStream.Lazer);
 
-            if (IsPackageManaged)
-                return new NoActionUpdateManager();
+            // if (IsPackageManaged)
+            //     return new NoActionUpdateManager();
 
-            return new VelopackUpdateManager(); // yay
+            // return new VelopackUpdateManager();
+
+            return new NoActionUpdateManager(); // for now, APIs are useless for actually downloading the releases. TODO: adapt UpdateManager for gitea
         }
 
         public override bool RestartAppWhenExited()
@@ -148,13 +150,7 @@ namespace osu.Desktop
 
             var iconStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(GetType(), "lazer.ico");
             if (iconStream != null)
-                try
-                {
-                    host.Window.SetIconFromStream(iconStream);
-                }
-                catch
-                {
-                }
+                host.Window.SetIconFromStream(iconStream);
 
             host.Window.Title = Name;
         }

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)
+                if (windowsVersion.Major < 6 || (windowsVersion.Major == 6 && windowsVersion.Minor <= 2))
                 {
                     unsafe
                     {
@@ -53,26 +53,13 @@ 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 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);
+                            "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);
                         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.
@@ -221,10 +208,9 @@ namespace osu.Desktop
         [SupportedOSPlatform("windows")]
         private static void configureWindows(VelopackApp app)
         {
-            // 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());
+            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 GiteaSource(@"https://gitea.jvnko.boats/jvnkosu/client", null, ReleaseStream.Value == Game.Configuration.ReleaseStream.Tachyon);
+                IUpdateSource updateSource = new GithubSource(@"https://github.com/ppy/osu", null, ReleaseStream.Value == Game.Configuration.ReleaseStream.Tachyon);
                 Velopack.UpdateManager updateManager = new Velopack.UpdateManager(updateSource, new UpdateOptions
                 {
                     AllowVersionDowngrade = true

osu.Desktop/Windows/WindowsAssociationManager.cs

@@ -53,8 +53,8 @@ namespace osu.Desktop.Windows
 
         private static readonly UriAssociation[] uri_associations =
         {
-            new UriAssociation(@"jvnkosu", WindowsAssociationManagerStrings.OsuProtocol, Icons.Lazer),
-            new UriAssociation(@"jvnkosump", WindowsAssociationManagerStrings.OsuMultiplayer, Icons.Lazer),
+            new UriAssociation(@"osu", WindowsAssociationManagerStrings.OsuProtocol, Icons.Lazer),
+            new UriAssociation(@"osump", WindowsAssociationManagerStrings.OsuMultiplayer, Icons.Lazer),
         };
 
         /// <summary>

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 based on osu!(lazer). Click is just a *rhythm* away!</Description>
+    <Description>A free-to-win rhythm game. Rhythm is just a *click* away!</Description>
     <AssemblyName>osu!</AssemblyName>
-    <AssemblyTitle>jvnkosu!</AssemblyTitle>
-    <Title>jvnkosu!</Title>
-    <Product>jvnkosu!</Product>
+    <AssemblyTitle>osu!(lazer)</AssemblyTitle>
+    <Title>osu!</Title>
+    <Product>osu!(lazer)</Product>
     <ApplicationIcon>lazer.ico</ApplicationIcon>
     <Version>0.0.0</Version>
     <FileVersion>0.0.0</FileVersion>

osu.Desktop/osu.nuspec

@@ -3,19 +3,16 @@
     <metadata>
         <id>osulazer</id>
         <version>0.0.0</version>
-        <title>jvnkosu!</title>
-        <authors>ppy Pty Ltd., jvnkosu! team</authors>
+        <title>osu!</title>
+        <authors>ppy Pty Ltd</authors>
         <owners>Dean Herbert</owners>
-        <projectUrl>https://osu.jvnko.boats/</projectUrl>
+        <projectUrl>https://osu.ppy.sh/</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 based on osu!(lazer). Click is just a *rhythm* away!</description>
+        <description>A free-to-win rhythm game. Rhythm is just a *click* away!</description>
         <releaseNotes>testing</releaseNotes>
-        <copyright>
-          Copyright (c) 2025 ppy Pty Ltd
-          Copyright (c) 2025 jvnkosu! team
-        </copyright>
+        <copyright>Copyright (c) 2025 ppy Pty Ltd</copyright>
         <language>en-AU</language>
     </metadata>
     <files>

osu.Game.Benchmarks/BenchmarkDifficultyCalculation.cs

@@ -1,77 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.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

@@ -0,0 +1,2 @@
+[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 TestTinyDropletMissChangesCatcherState()
+        public void TestTinyDropletMissPreservesCatcherState()
         {
             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 is changed but hyper dash state is preserved
-            checkState(CatcherAnimationState.Fail);
+            // catcher state and hyper dash state is preserved
+            checkState(CatcherAnimationState.Kiai);
             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 => 20251020;
+        public override int Version => 20250306;
 
         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,13 +51,15 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
             // Combo scaling
             if (catchAttributes.MaxCombo > 0)
-                value *= Math.Min(Math.Pow(score.MaxCombo, 0.35) / Math.Pow(catchAttributes.MaxCombo, 0.35), 1.0);
+                value *= Math.Min(Math.Pow(score.MaxCombo, 0.8) / Math.Pow(catchAttributes.MaxCombo, 0.8), 1.0);
 
             var difficulty = score.BeatmapInfo!.Difficulty.Clone();
 
             score.Mods.OfType<IApplicableToDifficulty>().ForEach(m => m.ApplyToDifficulty(difficulty));
 
-            double clockRate = ModUtils.CalculateRateWithMods(score.Mods);
+            var track = new TrackVirtual(10000);
+            score.Mods.OfType<IApplicableToTrack>().ForEach(m => m.ApplyToTrack(track));
+            double clockRate = track.Rate;
 
             // this is the same as osu!, so there's potential to share the implementation... maybe
             double preempt = IBeatmapDifficultyInfo.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450) / clockRate;

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

@@ -1,65 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-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,49 +11,15 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Preprocessing
 {
     public class CatchDifficultyHitObject : DifficultyHitObject
     {
-        public const float NORMALIZED_HALF_CATCHER_WIDTH = 41.0f;
-        private const float absolute_player_positioning_error = 16.0f;
+        private const float normalized_hitobject_radius = 41.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>
@@ -63,35 +29,13 @@ 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_HALF_CATCHER_WIDTH / halfCatcherWidth;
+            float scalingFactor = normalized_hitobject_radius / 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,7 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Game.Rulesets.Catch.Difficulty.Evaluators;
+using System;
+using osu.Game.Rulesets.Catch.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Skills;
 using osu.Game.Rulesets.Mods;
@@ -10,6 +11,10 @@ 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;
 
@@ -19,6 +24,12 @@ 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>
@@ -38,7 +49,80 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
 
         protected override double StrainValueOf(DifficultyHitObject current)
         {
-            return MovementEvaluator.EvaluateDifficultyOf(current, catcherSpeedMultiplier);
+            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;
         }
     }
 }

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

@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
         private double placementStartTime;
         private double placementEndTime;
 
-        protected override bool IsValidForPlacement => base.IsValidForPlacement && (PlacementActive == PlacementState.Waiting || Precision.DefinitelyBigger(HitObject.Duration, 0));
+        protected override bool IsValidForPlacement => Precision.DefinitelyBigger(HitObject.Duration, 0);
 
         public BananaShowerPlacementBlueprint()
         {

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

@@ -25,7 +25,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
 
         private InputManager inputManager = null!;
 
-        protected override bool IsValidForPlacement => base.IsValidForPlacement && (PlacementActive == PlacementState.Waiting || Precision.DefinitelyBigger(HitObject.Duration, 0));
+        protected override bool IsValidForPlacement => Precision.DefinitelyBigger(HitObject.Duration, 0);
 
         public JuiceStreamPlacementBlueprint()
         {

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

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using System.Globalization;
 using System.Linq;
 using System.Text.RegularExpressions;
 using osu.Framework.Allocation;
@@ -225,8 +224,7 @@ namespace osu.Game.Rulesets.Catch.Edit
         #region Clipboard handling
 
         public override string ConvertSelectionToString()
-            => string.Join(',', EditorBeatmap.SelectedHitObjects.Cast<CatchHitObject>().OrderBy(h => h.StartTime)
-                                             .Select(h => (h.IndexInCurrentCombo + 1).ToString(CultureInfo.InvariantCulture)));
+            => string.Join(',', EditorBeatmap.SelectedHitObjects.Cast<CatchHitObject>().OrderBy(h => h.StartTime).Select(h => (h.IndexInCurrentCombo + 1).ToString()));
 
         // 1,2,3,4 ...
         private static readonly Regex selection_regex = new Regex(@"^\d+(,\d+)*$", RegexOptions.Compiled);

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

@@ -51,8 +51,7 @@ 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 => 203.125f;
+        public override float DefaultFlashlightSize => 325;
 
         protected override Flashlight CreateFlashlight() => new CatchFlashlight(this, playfield);
 

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

@@ -3,7 +3,6 @@
 
 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;
@@ -17,7 +16,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 => OsuIcon.ModFloatingFruits;
+        public override IconUsage? Icon => FontAwesome.Solid.Cloud;
 
         public void ApplyToDrawableRuleset(DrawableRuleset<CatchHitObject> drawableRuleset)
         {

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

@@ -7,7 +7,6 @@ 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;
@@ -24,7 +23,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 => OsuIcon.ModMovingFast;
+        public override IconUsage? Icon => FontAwesome.Solid.Running;
         public override Type[] IncompatibleMods => new[] { typeof(ModAutoplay), typeof(ModRelax) };
 
         private DrawableCatchRuleset drawableRuleset = null!;

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

@@ -4,7 +4,6 @@
 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;
@@ -54,25 +53,13 @@ namespace osu.Game.Rulesets.Catch.Objects
 
             public override IEnumerable<string> LookupNames => lookup_names;
 
-            public BananaHitSampleInfo()
-                : this(string.Empty)
+            public BananaHitSampleInfo(int volume = 100)
+                : base(string.Empty, volume: 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 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 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()) }
+                    Samples = new List<HitSampleInfo> { new Banana.BananaHitSampleInfo(CreateHitSampleInfo().Volume) }
                 });
 
                 count++;

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

@@ -224,20 +224,7 @@ namespace osu.Game.Rulesets.Catch.UI
                     addLighting(result, drawableObject.AccentColour.Value, positionInStack.X);
             }
 
-            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
+            // droplet doesn't affect the catcher state
             if (hitObject is TinyDroplet) return;
 
             // if a hyper fruit was already handled this frame, just go where it says to go.
@@ -257,6 +244,19 @@ 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.Catch/osu.Game.Rulesets.Catch.csproj

@@ -8,7 +8,7 @@
 
   <PropertyGroup Label="Nuget">
     <Title>osu!catch (ruleset)</Title>
-    <PackageId>jvnkosu.Client.Rulesets.Catch</PackageId>
+    <PackageId>ppy.osu.Game.Rulesets.Catch</PackageId>
     <IsPackable>true</IsPackable>
   </PropertyGroup>
 

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

@@ -5,7 +5,6 @@
 
 using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Allocation;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Testing;
 using osu.Game.Rulesets.Edit;
@@ -17,7 +16,6 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
-using osu.Game.Screens.Edit;
 using osu.Game.Tests.Visual;
 using osuTK.Input;
 
@@ -38,8 +36,21 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
         [Test]
         public void TestPlaceBeforeCurrentTimeDownwards()
         {
-            AddStep("seek to 200", () => HitObjectContainer.Dependencies.Get<EditorClock>().Seek(200));
             AddStep("move mouse before current time", () =>
+            {
+                var column = this.ChildrenOfType<Column>().Single();
+                InputManager.MoveMouseTo(column.ScreenSpacePositionAtTime(-100));
+            });
+
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+
+            AddAssert("note start time < 0", () => getNote().StartTime < 0);
+        }
+
+        [Test]
+        public void TestPlaceAfterCurrentTimeDownwards()
+        {
+            AddStep("move mouse after current time", () =>
             {
                 var column = this.ChildrenOfType<Column>().Single();
                 InputManager.MoveMouseTo(column.ScreenSpacePositionAtTime(100));
@@ -47,22 +58,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
 
             AddStep("click", () => InputManager.Click(MouseButton.Left));
 
-            AddAssert("note start time < 200", () => getNote().StartTime < 200);
-        }
-
-        [Test]
-        public void TestPlaceAfterCurrentTimeDownwards()
-        {
-            AddStep("seek to 200", () => HitObjectContainer.Dependencies.Get<EditorClock>().Seek(200));
-            AddStep("move mouse after current time", () =>
-            {
-                var column = this.ChildrenOfType<Column>().Single();
-                InputManager.MoveMouseTo(column.ScreenSpacePositionAtTime(300));
-            });
-
-            AddStep("click", () => InputManager.Click(MouseButton.Left));
-
-            AddAssert("note start time > 200", () => getNote().StartTime > 200);
+            AddAssert("note start time > 0", () => getNote().StartTime > 0);
         }
 
         private Note getNote() => this.ChildrenOfType<DrawableNote>().FirstOrDefault()?.HitObject;

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

@@ -18,11 +18,15 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
         public void TestNormalSelection()
         {
             addStepClickLink("00:05:920 (5920|3,6623|3,6857|2,7326|1)");
-            AddAssert("selected group", () => checkSnapAndSelectColumn(5_920, [(5_920, 3), (6_623, 3), (6_857, 2), (7_326, 1)]));
+            AddAssert("selected group", () => checkSnapAndSelectColumn(5_920, new List<(int, int)>
+                { (5_920, 3), (6_623, 3), (6_857, 2), (7_326, 1) }
+            ));
 
             addReset();
             addStepClickLink("00:42:716 (42716|3,43420|2,44123|0,44357|1,45295|1)");
-            AddAssert("selected ungrouped", () => checkSnapAndSelectColumn(42_716, [(42_716, 3), (43_420, 2), (44_123, 0), (44_357, 1), (45_295, 1)]));
+            AddAssert("selected ungrouped", () => checkSnapAndSelectColumn(42_716, new List<(int, int)>
+                { (42_716, 3), (43_420, 2), (44_123, 0), (44_357, 1), (45_295, 1) }
+            ));
 
             addReset();
             AddStep("add notes to row", () =>
@@ -37,20 +41,15 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
                 EditorBeatmap.AddRange(new[] { second, third, forth });
             });
             addStepClickLink("00:11:545 (11545|0,11545|1,11545|2,11545|3)");
-            AddAssert("selected in row", () => checkSnapAndSelectColumn(11_545, [(11_545, 0), (11_545, 1), (11_545, 2), (11_545, 3)]));
+            AddAssert("selected in row", () => checkSnapAndSelectColumn(11_545, new List<(int, int)>
+                { (11_545, 0), (11_545, 1), (11_545, 2), (11_545, 3) }
+            ));
 
             addReset();
             addStepClickLink("01:36:623 (96623|1,97560|1,97677|1,97795|1,98966|1)");
-            AddAssert("selected in column", () => checkSnapAndSelectColumn(96_623, [(96_623, 1), (97_560, 1), (97_677, 1), (97_795, 1), (98_966, 1)]));
-        }
-
-        [Test]
-        public void TestRoundingToNearestMillisecondApplied()
-        {
-            AddStep("resnap note to have fractional coordinates",
-                () => EditorBeatmap.HitObjects.OfType<ManiaHitObject>().Single(ho => ho.StartTime == 85_373 && ho.Column == 1).StartTime = 85_373.125);
-            addStepClickLink("01:25:373 (85373|1)");
-            AddAssert("selected note", () => checkSnapAndSelectColumn(85_373.125, [(85_373.125, 1)]));
+            AddAssert("selected in column", () => checkSnapAndSelectColumn(96_623, new List<(int, int)>
+                { (96_623, 1), (97_560, 1), (97_677, 1), (97_795, 1), (98_966, 1) }
+            ));
         }
 
         [Test]
@@ -76,7 +75,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
 
         private void addReset() => addStepClickLink("00:00:000", "reset", false);
 
-        private bool checkSnapAndSelectColumn(double startTime, IReadOnlyCollection<(double, int)>? columnPairs = null)
+        private bool checkSnapAndSelectColumn(double startTime, IReadOnlyCollection<(int, int)>? columnPairs = null)
         {
             bool checkColumns = columnPairs != null
                 ? EditorBeatmap.SelectedHitObjects.All(x => columnPairs.Any(col => isNoteAt(x, col.Item1, col.Item2)))

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

@@ -24,7 +24,6 @@ namespace osu.Game.Rulesets.Mania.Tests
         [TestCase("mania-samples")]
         [TestCase("mania-slider")] // e.g. second and fourth notes of https://osu.ppy.sh/beatmapsets/73883#mania/216407
         [TestCase("slider-convert-samples")]
-        [TestCase("spinner-convert-samples")]
         public void Test(string name) => base.Test(name);
 
         protected override IEnumerable<SampleConvertValue> CreateConvertValue(HitObject hitObject)

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

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

@@ -1,10 +0,0 @@
-osu file format v14
-
-[General]
-Mode: 0
-
-[TimingPoints]
-0,300,4,0,2,100,1,0
-
-[HitObjects]
-444,320,1000,5,2,0:0:0:0:

osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/spinner-convert-samples-expected-conversion.json

@@ -1,16 +0,0 @@
-{
-  "Mappings": [{
-    "StartTime": 1000.0,
-    "Objects": [{
-      "StartTime": 1000.0,
-      "EndTime": 8000.0,
-      "Column": 0,
-      "PlaySlidingSamples": false,
-      "NodeSamples": [
-        ["Gameplay/soft-hitnormal"],
-        ["Gameplay/soft-hitnormal", "Gameplay/soft-hitfinish"]
-      ],
-      "Samples": ["Gameplay/soft-hitnormal", "Gameplay/soft-hitfinish"],
-    }]
-  }]
-}

osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/spinner-convert-samples.osu

@@ -1,18 +0,0 @@
-osu file format v14
-
-[General]
-Mode: 0
-
-[Difficulty]
-HPDrainRate:5
-CircleSize:5
-OverallDifficulty:5
-ApproachRate:5
-SliderMultiplier:1.4
-SliderTickRate:1
-
-[TimingPoints]
-0,500,4,2,0,100,1,0
-
-[HitObjects]
-256,192,1000,8,4,8000,0:2:0:0:

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

@@ -45,19 +45,5 @@ namespace osu.Game.Rulesets.Mania.Tests
             AssertBeatmapLookup(expected_sample);
             AssertNoLookup(unwanted_sample);
         }
-
-        [Test]
-        public void TestConvertHitObjectCustomSampleBank()
-        {
-            const string beatmap_sample = "normal-hitwhistle2";
-            const string user_skin_sample = "normal-hitnormal";
-
-            SetupSkins(beatmap_sample, user_skin_sample);
-
-            CreateTestWithBeatmap("convert-beatmap-custom-sample-bank.osu");
-
-            AssertBeatmapLookup(beatmap_sample);
-            AssertUserLookup(user_skin_sample);
-        }
     }
 }

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

@@ -85,11 +85,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                     Duration = endTime - HitObject.StartTime,
                     Column = column,
                     Samples = HitObject.Samples,
-                    NodeSamples =
-                    [
-                        HitObject.Samples.Where(s => s.Name == HitSampleInfo.HIT_NORMAL).ToList(),
-                        HitObject.Samples
-                    ]
+                    NodeSamples = (HitObject as IHasRepeats)?.NodeSamples
                 };
             }
             else

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

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

@@ -1,61 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-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,22 +65,13 @@ 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++)
-            {
-                var currentObject = new ManiaDifficultyHitObject(sortedObjects[i], sortedObjects[i - 1], clockRate, objects, perColumnObjects, objects.Count);
-                objects.Add(currentObject);
-                perColumnObjects[currentObject.Column].Add(currentObject);
-            }
+                objects.Add(new ManiaDifficultyHitObject(sortedObjects[i], sortedObjects[i - 1], clockRate, objects, objects.Count));
 
             return objects;
         }

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

@@ -12,59 +12,9 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Preprocessing
     {
         public new ManiaHitObject BaseObject => (ManiaHitObject)base.BaseObject;
 
-        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)
+        public ManiaDifficultyHitObject(HitObject hitObject, HitObject lastObject, double clockRate, List<DifficultyHitObject> objects, 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,9 +2,10 @@
 // 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.Mania.Difficulty.Evaluators;
+using osu.Game.Rulesets.Difficulty.Utils;
 using osu.Game.Rulesets.Mania.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Mods;
 
@@ -14,17 +15,23 @@ 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 highestIndividualStrain;
+
+        private double individualStrain;
         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;
         }
@@ -32,24 +39,65 @@ 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;
 
-            individualStrains[maniaCurrent.Column] = applyDecay(individualStrains[maniaCurrent.Column], maniaCurrent.ColumnStrainTime, individual_decay_base);
-            individualStrains[maniaCurrent.Column] += IndividualStrainEvaluator.EvaluateDifficultyOf(current);
+            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
 
-            // 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];
+            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);
 
-            overallStrain = applyDecay(overallStrain, maniaCurrent.DeltaTime, overall_decay_base);
-            overallStrain += OverallStrainEvaluator.EvaluateDifficultyOf(current);
+                // 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;
 
             // By subtracting CurrentStrain, this skill effectively only considers the maximum strain of any one hitobject within each strain section.
-            return highestIndividualStrain + overallStrain - CurrentStrain;
+            return individualStrain + overallStrain - CurrentStrain;
         }
 
-        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);
+        protected override double CalculateInitialStrain(double offset, DifficultyHitObject current)
+            => applyDecay(individualStrain, 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)
             => value * Math.Pow(decayBase, deltaTime / 1000);

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

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
         [Resolved]
         private IScrollingInfo scrollingInfo { get; set; } = null!;
 
-        protected override bool IsValidForPlacement => base.IsValidForPlacement && (PlacementActive == PlacementState.Waiting || Precision.DefinitelyBigger(HitObject.Duration, 0));
+        protected override bool IsValidForPlacement => Precision.DefinitelyBigger(HitObject.Duration, 0);
 
         public HoldNotePlacementBlueprint()
             : base(new HoldNote())

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

@@ -1,12 +1,10 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
 using osu.Framework.Allocation;
-using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
@@ -56,8 +54,7 @@ namespace osu.Game.Rulesets.Mania.Edit
         };
 
         public override string ConvertSelectionToString()
-            => string.Join(',', EditorBeatmap.SelectedHitObjects.Cast<ManiaHitObject>().OrderBy(h => h.StartTime)
-                                             .Select(h => FormattableString.Invariant($"{Math.Round(h.StartTime)}|{h.Column}")));
+            => string.Join(',', EditorBeatmap.SelectedHitObjects.Cast<ManiaHitObject>().OrderBy(h => h.StartTime).Select(h => $"{h.StartTime}|{h.Column}"));
 
         // 123|0,456|1,789|2 ...
         private static readonly Regex selection_regex = new Regex(@"^\d+\|\d+(,\d+\|\d+)*$", RegexOptions.Compiled);
@@ -76,10 +73,10 @@ namespace osu.Game.Rulesets.Mania.Edit
                 if (split.Length != 2)
                     continue;
 
-                if (!int.TryParse(split[0], out int time) || !int.TryParse(split[1], out int column))
+                if (!double.TryParse(split[0], out double time) || !int.TryParse(split[1], out int column))
                     continue;
 
-                ManiaHitObject? current = remainingHitObjects.FirstOrDefault(h => Precision.AlmostEquals(h.StartTime, time, 0.5) && h.Column == column);
+                ManiaHitObject? current = remainingHitObjects.FirstOrDefault(h => h.StartTime == time && h.Column == column);
 
                 if (current == null)
                     continue;

osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Bindables;
@@ -20,16 +19,12 @@ 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);
 
-            bool keyCountMatch = includedKeyCounts.Contains(keyCount);
-            bool longNotePercentageMatch = !longNotePercentage.HasFilter || (!isConvertedBeatmap(beatmapInfo) && longNotePercentage.IsInRange(calculateLongNotePercentage(beatmapInfo)));
-
-            return keyCountMatch && longNotePercentageMatch;
+            return includedKeyCounts.Contains(keyCount);
         }
 
         public bool TryParseCustomKeywordCriteria(string key, Operator op, string strValues)
@@ -89,10 +84,6 @@ namespace osu.Game.Rulesets.Mania
                             return false;
                     }
                 }
-
-                case "ln":
-                case "lns":
-                    return FilterQueryParser.TryUpdateCriteriaRange(ref longNotePercentage, op, strValues);
             }
 
             return false;
@@ -112,18 +103,5 @@ 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,7 +79,6 @@ 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 => 1;
-        public override bool Ranked => true;
+        public override double ScoreMultiplier => 0.9;
+        public override bool Ranked => UsesDefaultConfiguration;
 
         public void ApplyToBeatmapConverter(IBeatmapConverter beatmapConverter)
         {

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

@@ -4,7 +4,6 @@
 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;
@@ -22,7 +21,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override LocalisableString Description => "No more tricky speed changes!";
 
-        public override IconUsage? Icon => OsuIcon.ModConstantSpeed;
+        public override IconUsage? Icon => FontAwesome.Solid.Equals;
 
         public override ModType Type => ModType.Conversion;
 

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

@@ -4,10 +4,8 @@
 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
@@ -16,7 +14,6 @@ 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.";
 
@@ -30,7 +27,7 @@ namespace osu.Game.Rulesets.Mania.Mods
             typeof(ManiaModFadeIn)
         }).ToArray();
 
-        public override bool Ranked => true;
+        public override bool Ranked => false;
 
         public override bool ValidForFreestyleAsRequiredMod => false;
 

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

@@ -7,20 +7,5 @@ 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,10 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using 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;
 
@@ -15,7 +13,6 @@ 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,9 +3,7 @@
 
 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
@@ -14,7 +12,6 @@ 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 => true;
+        public override bool Ranked => false;
 
         public const double HIT_WINDOW_DIFFICULTY_MULTIPLIER = 1.4;
 

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

@@ -9,8 +9,6 @@ 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
@@ -25,7 +23,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override LocalisableString Description => @"Replaces all hold notes with normal notes.";
 
-        public override IconUsage? Icon => OsuIcon.ModHoldOff;
+        public override IconUsage? Icon => FontAwesome.Solid.DotCircle;
 
         public override ModType Type => ModType.Conversion;
 
@@ -35,8 +33,6 @@ 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>())
@@ -51,17 +47,6 @@ 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,7 +8,6 @@ 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;
@@ -24,7 +23,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override LocalisableString Description => "Hold the keys. To the beat.";
 
-        public override IconUsage? Icon => OsuIcon.ModInvert;
+        public override IconUsage? Icon => FontAwesome.Solid.YinYang;
 
         public override ModType Type => ModType.Conversion;
 

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

@@ -1,9 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
-using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -12,7 +10,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,9 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
-using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -12,7 +10,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,9 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
-using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -12,7 +10,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,9 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
-using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -12,7 +10,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;
     }
 }