Update framework

This reverts commit 03c61a573e.

The goal here was to handle an edge case discovered during work on note
lock, wherein it was determined that on stable hit circles would block
input from reaching objects underneath them. However, the change
mentioned above did that _too_ hard and caused overlaps to also be
blocked even long past a hit circle has been faded out.

Revert the change pending further (and more careful) investigation.

.github/workflows/diffcalc.yml

@@ -1,382 +1,206 @@
-# ## Description
+# Listens for new PR comments containing !pp check [id], and runs a diffcalc comparison against master.
+# Usage:
+#   !pp check 0        | Runs only the osu! ruleset.
+#   !pp check 0 2      | Runs only the osu! and catch rulesets.
 #
-# Uses [diffcalc-sheet-generator](https://github.com/smoogipoo/diffcalc-sheet-generator) to run two builds of osu and generate an SR/PP/Score comparison spreadsheet.
-#
-# ## Requirements
-#
-# Self-hosted runner with installed:
-# - `docker >= 20.10.16`
-# - `docker-compose >= 2.5.1`
-# - `lbzip2`
-# - `jq`
-#
-# ## Usage
-#
-# The workflow can be run in two ways:
-# 1. Via workflow dispatch.
-# 2. By an owner of the repository posting a pull request or issue comment containing `!diffcalc`.
-# For pull requests, the workflow will assume the pull request as the target to compare against (i.e. the `OSU_B` variable).
-# Any lines in the comment of the form `KEY=VALUE` are treated as variables for the generator.
-#
-# ## Google Service Account
-#
-# Spreadsheets are uploaded to a Google Service Account, and exposed with read-only permissions to the wider audience.
-#
-# 1. Create a project at https://console.cloud.google.com
-# 2. Enable the `Google Sheets` and `Google Drive` APIs.
-# 3. Create a Service Account
-# 4. Generate a key in the JSON format.
-# 5. Encode the key as base64 and store as an **actions secret** with name **`DIFFCALC_GOOGLE_CREDENTIALS`**
-#
-# ## Environment variables
-#
-# The default environment may be configured via **actions variables**.
-#
-# Refer to [the sample environment](https://github.com/smoogipoo/diffcalc-sheet-generator/blob/master/.env.sample), and prefix each variable with `DIFFCALC_` (e.g. `DIFFCALC_THREADS`, `DIFFCALC_INNODB_BUFFER_SIZE`, etc...).
-
-name: Run difficulty calculation comparison
-
-run-name: "${{ github.event_name == 'workflow_dispatch' && format('Manual run: {0}', inputs.osu-b) || 'Automatic comment trigger' }}"
 
+name: Difficulty Calculation
 on:
   issue_comment:
     types: [ created ]
-  workflow_dispatch:
-    inputs:
-      osu-b:
-        description: "The target build of ppy/osu"
-        type: string
-        required: true
-      ruleset:
-        description: "The ruleset to process"
-        type: choice
-        required: true
-        options:
-          - osu
-          - taiko
-          - catch
-          - mania
-      converts:
-        description: "Include converted beatmaps"
-        type: boolean
-        required: false
-        default: true
-      ranked-only:
-        description: "Only ranked beatmaps"
-        type: boolean
-        required: false
-        default: true
-      generators:
-        description: "Comma-separated list of generators (available: [sr, pp, score])"
-        type: string
-        required: false
-        default: 'pp,sr'
-      osu-a:
-        description: "The source build of ppy/osu"
-        type: string
-        required: false
-        default: 'latest'
-      difficulty-calculator-a:
-        description: "The source build of ppy/osu-difficulty-calculator"
-        type: string
-        required: false
-        default: 'latest'
-      difficulty-calculator-b:
-        description: "The target build of ppy/osu-difficulty-calculator"
-        type: string
-        required: false
-        default: 'latest'
-      score-processor-a:
-        description: "The source build of ppy/osu-queue-score-statistics"
-        type: string
-        required: false
-        default: 'latest'
-      score-processor-b:
-        description: "The target build of ppy/osu-queue-score-statistics"
-        type: string
-        required: false
-        default: 'latest'
-
-permissions:
-  pull-requests: write
 
 env:
-  EXECUTION_ID: execution-${{ github.run_id }}-${{ github.run_number }}-${{ github.run_attempt }}
+  CONCURRENCY: 4
+  ALLOW_DOWNLOAD: 1
+  SAVE_DOWNLOADED: 1
+  SKIP_INSERT_ATTRIBUTES: 1
 
 jobs:
-  check-permissions:
-    name: Check permissions
-    runs-on: ubuntu-latest
-    if: ${{ github.event_name == 'workflow_dispatch' || contains(github.event.comment.body, '!diffcalc') }}
-    steps:
-      - name: Check permissions
-        if: ${{ github.event_name != 'workflow_dispatch' }}
-        uses: actions-cool/check-user-permission@a0668c9aec87f3875fc56170b6452a453e9dd819 # v2.2.0
-        with:
-          require: 'write'
-
-  create-comment:
-    name: Create PR comment
-    needs: check-permissions
-    runs-on: ubuntu-latest
-    if: ${{ github.event_name == 'issue_comment' && github.event.issue.pull_request }}
-    steps:
-      - name: Create comment
-        uses: thollander/actions-comment-pull-request@363c6f6eae92cc5c3a66e95ba016fc771bb38943 # v2.4.2
-        with:
-          comment_tag: ${{ env.EXECUTION_ID }}
-          message: |
-            Difficulty calculation queued -- please wait! (${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})
-
-            *This comment will update on completion*
-
-  directory:
-    name: Prepare directory
-    needs: check-permissions
+  metadata:
+    name: Check for requests
     runs-on: self-hosted
+    if: github.event.issue.pull_request && contains(github.event.comment.body, '!pp check') && (github.event.comment.author_association == 'MEMBER' || github.event.comment.author_association == 'OWNER')
     outputs:
-      GENERATOR_DIR: ${{ steps.set-outputs.outputs.GENERATOR_DIR }}
-      GENERATOR_ENV: ${{ steps.set-outputs.outputs.GENERATOR_ENV }}
-      GOOGLE_CREDS_FILE: ${{ steps.set-outputs.outputs.GOOGLE_CREDS_FILE }}
+      matrix: ${{ steps.generate-matrix.outputs.matrix }}
+      continue: ${{ steps.generate-matrix.outputs.continue }}
     steps:
-      - name: Checkout diffcalc-sheet-generator
+      - name: Construct build matrix
+        id: generate-matrix
+        run: |
+          if [[ "${{ github.event.comment.body }}" =~ "osu" ]] ; then
+            MATRIX_PROJECTS_JSON+='{ "name": "osu", "id": 0 },'
+          fi
+          if [[ "${{ github.event.comment.body }}" =~ "taiko" ]] ; then
+            MATRIX_PROJECTS_JSON+='{ "name": "taiko", "id": 1 },'
+          fi
+          if [[ "${{ github.event.comment.body }}" =~ "catch" ]] ; then
+            MATRIX_PROJECTS_JSON+='{ "name": "catch", "id": 2 },'
+          fi
+          if [[ "${{ github.event.comment.body }}" =~ "mania" ]] ; then
+            MATRIX_PROJECTS_JSON+='{ "name": "mania", "id": 3 },'
+          fi
+
+          if [[ "${MATRIX_PROJECTS_JSON}" != "" ]]; then
+            MATRIX_JSON="{ \"ruleset\": [ ${MATRIX_PROJECTS_JSON} ] }"
+            echo "${MATRIX_JSON}"
+            CONTINUE="yes"
+          else
+            CONTINUE="no"
+          fi
+
+          echo "continue=${CONTINUE}" >> $GITHUB_OUTPUT
+          echo "matrix=${MATRIX_JSON}" >> $GITHUB_OUTPUT
+  diffcalc:
+    name: Run
+    runs-on: self-hosted
+    timeout-minutes: 1440
+    if: needs.metadata.outputs.continue == 'yes'
+    needs: metadata
+    strategy:
+      matrix: ${{ fromJson(needs.metadata.outputs.matrix) }}
+    steps:
+      - name: Verify MySQL connection from host
+        run: |
+          mysql -e "SHOW DATABASES"
+
+      - name: Drop previous databases
+        run: |
+          for db in osu_master osu_pr
+          do
+            mysql -e "DROP DATABASE IF EXISTS $db"
+          done
+
+      - name: Create directory structure
+        run: |
+          mkdir -p $GITHUB_WORKSPACE/master/
+          mkdir -p $GITHUB_WORKSPACE/pr/
+
+      - name: Get upstream branch # https://akaimo.hatenablog.jp/entry/2020/05/16/101251
+        id: upstreambranch
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          echo "branchname=$(curl -H "Authorization: token ${GITHUB_TOKEN}" ${{ github.event.issue.pull_request.url }} | jq '.head.ref' | sed 's/\"//g')" >> $GITHUB_OUTPUT
+          echo "repo=$(curl -H "Authorization: token ${GITHUB_TOKEN}" ${{ github.event.issue.pull_request.url }} | jq '.head.repo.full_name' | sed 's/\"//g')" >> $GITHUB_OUTPUT
+
+      # Checkout osu
+      - name: Checkout osu (master)
         uses: actions/checkout@v3
         with:
-          path: ${{ env.EXECUTION_ID }}
-          repository: 'smoogipoo/diffcalc-sheet-generator'
+          path: 'master/osu'
+      - name: Checkout osu (pr)
+        uses: actions/checkout@v3
+        with:
+          path: 'pr/osu'
+          repository: ${{ steps.upstreambranch.outputs.repo }}
+          ref: ${{ steps.upstreambranch.outputs.branchname }}
 
-      - name: Set outputs
-        id: set-outputs
+      - name: Checkout osu-difficulty-calculator (master)
+        uses: actions/checkout@v3
+        with:
+          repository: ppy/osu-difficulty-calculator
+          path: 'master/osu-difficulty-calculator'
+      - name: Checkout osu-difficulty-calculator (pr)
+        uses: actions/checkout@v3
+        with:
+          repository: ppy/osu-difficulty-calculator
+          path: 'pr/osu-difficulty-calculator'
+
+      - name: Install .NET 5.0.x
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: "5.0.x"
+
+      # Sanity checks to make sure diffcalc is not run when incompatible.
+      - name: Build diffcalc (master)
         run: |
-          echo "GENERATOR_DIR=${{ github.workspace }}/${{ env.EXECUTION_ID }}" >> "${GITHUB_OUTPUT}"
-          echo "GENERATOR_ENV=${{ github.workspace }}/${{ env.EXECUTION_ID }}/.env" >> "${GITHUB_OUTPUT}"
-          echo "GOOGLE_CREDS_FILE=${{ github.workspace }}/${{ env.EXECUTION_ID }}/google-credentials.json" >> "${GITHUB_OUTPUT}"
-
-  environment:
-    name: Setup environment
-    needs: directory
-    runs-on: self-hosted
-    env:
-      VARS_JSON: ${{ toJSON(vars) }}
-    steps:
-      - name: Add base environment
+          cd $GITHUB_WORKSPACE/master/osu-difficulty-calculator
+          ./UseLocalOsu.sh
+          dotnet build
+      - name: Build diffcalc (pr)
         run: |
-          # Required by diffcalc-sheet-generator
-          cp '${{ needs.directory.outputs.GENERATOR_DIR }}/.env.sample' "${{ needs.directory.outputs.GENERATOR_ENV }}"
+          cd $GITHUB_WORKSPACE/pr/osu-difficulty-calculator
+          ./UseLocalOsu.sh
+          dotnet build
 
-          # Add Google credentials
-          echo '${{ secrets.DIFFCALC_GOOGLE_CREDENTIALS }}' | base64 -d > "${{ needs.directory.outputs.GOOGLE_CREDS_FILE }}"
+      - name: Download + import data
+        run: |
+          PERFORMANCE_DATA_NAME=$(curl https://data.ppy.sh/ | grep performance_${{ matrix.ruleset.name }}_top_1000 | tail -1 | awk -F "\"" '{print $2}' | sed 's/\.tar\.bz2//g')
+          BEATMAPS_DATA_NAME=$(curl https://data.ppy.sh/ | grep osu_files | tail -1 | awk -F "\"" '{print $2}' | sed 's/\.tar\.bz2//g')
 
-          # Add repository variables
-          echo "${VARS_JSON}" | jq -c '. | to_entries | .[]' | while read -r line; do
-              opt=$(jq -r '.key' <<< ${line})
-              val=$(jq -r '.value' <<< ${line})
+          # Set env variable for further steps.
+          echo "BEATMAPS_PATH=$GITHUB_WORKSPACE/$BEATMAPS_DATA_NAME" >> $GITHUB_ENV
 
-              if [[ "${opt}" =~ ^DIFFCALC_ ]]; then
-                optNoPrefix=$(echo "${opt}" | cut -d '_' -f2-)
-                sed -i "s;^${optNoPrefix}=.*$;${optNoPrefix}=${val};" "${{ needs.directory.outputs.GENERATOR_ENV }}"
-              fi
+          cd $GITHUB_WORKSPACE
+
+          echo "Downloading database dump $PERFORMANCE_DATA_NAME.."
+          wget -q -nc https://data.ppy.sh/$PERFORMANCE_DATA_NAME.tar.bz2
+          echo "Extracting.."
+          tar -xf $PERFORMANCE_DATA_NAME.tar.bz2
+
+          echo "Downloading beatmap dump $BEATMAPS_DATA_NAME.."
+          wget -q -nc https://data.ppy.sh/$BEATMAPS_DATA_NAME.tar.bz2
+          echo "Extracting.."
+          tar -xf $BEATMAPS_DATA_NAME.tar.bz2
+
+          cd $PERFORMANCE_DATA_NAME
+
+          for db in osu_master osu_pr
+          do
+            echo "Setting up database $db.."
+
+            mysql -e "CREATE DATABASE $db"
+
+            echo "Importing beatmaps.."
+            cat osu_beatmaps.sql | mysql $db
+            echo "Importing beatmapsets.."
+            cat osu_beatmapsets.sql | mysql $db
+
+            echo "Creating table structure.."
+            mysql $db -e 'CREATE TABLE `osu_beatmap_difficulty` (
+                `beatmap_id` int unsigned NOT NULL,
+                `mode` tinyint NOT NULL DEFAULT 0,
+                `mods` int unsigned NOT NULL,
+                `diff_unified` float NOT NULL,
+                `last_update` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+                PRIMARY KEY (`beatmap_id`,`mode`,`mods`),
+                KEY `diff_sort` (`mode`,`mods`,`diff_unified`)
+              ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;'
           done
 
-      - name: Add pull-request environment
-        if: ${{ github.event_name == 'issue_comment' && github.event.issue.pull_request }}
-        run: |
-          sed -i "s;^OSU_B=.*$;OSU_B=${{ github.event.issue.pull_request.html_url }};" "${{ needs.directory.outputs.GENERATOR_ENV }}"
-
-      - name: Add comment environment
-        if: ${{ github.event_name == 'issue_comment' }}
+      - name: Run diffcalc (master)
         env:
-          COMMENT_BODY: ${{ github.event.comment.body }}
+          DB_NAME: osu_master
         run: |
-          # Add comment environment
-          echo $COMMENT_BODY | sed -r 's/\r$//' | grep -E '^\w+=' | while read -r line; do
-              opt=$(echo ${line} | cut -d '=' -f1)
-              sed -i "s;^${opt}=.*$;${line};" "${{ needs.directory.outputs.GENERATOR_ENV }}"
-          done
-
-      - name: Add dispatch environment
-        if: ${{ github.event_name == 'workflow_dispatch' }}
+          cd $GITHUB_WORKSPACE/master/osu-difficulty-calculator/osu.Server.DifficultyCalculator
+          dotnet run -c:Release -- all -m ${{ matrix.ruleset.id }} -ac -c ${{ env.CONCURRENCY }}
+      - name: Run diffcalc (pr)
+        env:
+          DB_NAME: osu_pr
         run: |
-          sed -i 's;^OSU_B=.*$;OSU_B=${{ inputs.osu-b }};' "${{ needs.directory.outputs.GENERATOR_ENV }}"
-          sed -i 's/^RULESET=.*$/RULESET=${{ inputs.ruleset }}/' "${{ needs.directory.outputs.GENERATOR_ENV }}"
-          sed -i 's/^GENERATORS=.*$/GENERATORS=${{ inputs.generators }}/' "${{ needs.directory.outputs.GENERATOR_ENV }}"
+          cd $GITHUB_WORKSPACE/pr/osu-difficulty-calculator/osu.Server.DifficultyCalculator
+          dotnet run -c:Release -- all -m ${{ matrix.ruleset.id }} -ac -c ${{ env.CONCURRENCY }}
 
-          if [[ '${{ inputs.osu-a }}' != 'latest' ]]; then
-              sed -i 's;^OSU_A=.*$;OSU_A=${{ inputs.osu-a }};' "${{ needs.directory.outputs.GENERATOR_ENV }}"
-          fi
-
-          if [[ '${{ inputs.difficulty-calculator-a }}' != 'latest' ]]; then
-              sed -i 's;^DIFFICULTY_CALCULATOR_A=.*$;DIFFICULTY_CALCULATOR_A=${{ inputs.difficulty-calculator-a }};' "${{ needs.directory.outputs.GENERATOR_ENV }}"
-          fi
-
-          if [[ '${{ inputs.difficulty-calculator-b }}' != 'latest' ]]; then
-              sed -i 's;^DIFFICULTY_CALCULATOR_B=.*$;DIFFICULTY_CALCULATOR_B=${{ inputs.difficulty-calculator-b }};' "${{ needs.directory.outputs.GENERATOR_ENV }}"
-          fi
-
-          if [[ '${{ inputs.score-processor-a }}' != 'latest' ]]; then
-              sed -i 's;^SCORE_PROCESSOR_A=.*$;SCORE_PROCESSOR_A=${{ inputs.score-processor-a }};' "${{ needs.directory.outputs.GENERATOR_ENV }}"
-          fi
-
-          if [[ '${{ inputs.score-processor-b }}' != 'latest' ]]; then
-              sed -i 's;^SCORE_PROCESSOR_B=.*$;SCORE_PROCESSOR_B=${{ inputs.score-processor-b }};' "${{ needs.directory.outputs.GENERATOR_ENV }}"
-          fi
-
-          if [[ '${{ inputs.converts }}' == 'true' ]]; then
-              sed -i 's/^NO_CONVERTS=.*$/NO_CONVERTS=0/' "${{ needs.directory.outputs.GENERATOR_ENV }}"
-          else
-              sed -i 's/^NO_CONVERTS=.*$/NO_CONVERTS=1/' "${{ needs.directory.outputs.GENERATOR_ENV }}"
-          fi
-
-          if [[ '${{ inputs.ranked-only }}' == 'true' ]]; then
-              sed -i 's/^RANKED_ONLY=.*$/RANKED_ONLY=1/' "${{ needs.directory.outputs.GENERATOR_ENV }}"
-          else
-              sed -i 's/^RANKED_ONLY=.*$/RANKED_ONLY=0/' "${{ needs.directory.outputs.GENERATOR_ENV }}"
-          fi
-
-  scores:
-    name: Setup scores
-    needs: [ directory, environment ]
-    runs-on: self-hosted
-    steps:
-      - name: Query latest data
-        id: query
+      - name: Print diffs
         run: |
-          ruleset=$(cat ${{ needs.directory.outputs.GENERATOR_ENV }} | grep -E '^RULESET=' | cut -d '=' -f2-)
-          performance_data_name=$(curl -s "https://data.ppy.sh/" | grep "performance_${ruleset}_top_1000\b" | tail -1 | awk -F "'" '{print $2}' | sed 's/\.tar\.bz2//g')
+          mysql -e "
+            SELECT
+              m.beatmap_id,
+              m.mods,
+              b.filename,
+              m.diff_unified as 'sr_master',
+              p.diff_unified as 'sr_pr',
+              (p.diff_unified - m.diff_unified) as 'diff'
+            FROM osu_master.osu_beatmap_difficulty m
+            JOIN osu_pr.osu_beatmap_difficulty p
+              ON m.beatmap_id = p.beatmap_id
+              AND m.mode = p.mode
+              AND m.mods = p.mods
+            JOIN osu_pr.osu_beatmaps b
+              ON b.beatmap_id = p.beatmap_id
+            WHERE abs(m.diff_unified - p.diff_unified) > 0.1
+            ORDER BY abs(m.diff_unified - p.diff_unified)
+              DESC
+            LIMIT 10000;"
 
-          echo "TARGET_DIR=${{ needs.directory.outputs.GENERATOR_DIR }}/sql/${ruleset}" >> "${GITHUB_OUTPUT}"
-          echo "DATA_NAME=${performance_data_name}" >> "${GITHUB_OUTPUT}"
-
-      - name: Restore cache
-        id: restore-cache
-        uses: maxnowack/local-cache@038cc090b52e4f205fbc468bf5b0756df6f68775 # v1
-        with:
-          path: ${{ steps.query.outputs.DATA_NAME }}.tar.bz2
-          key: ${{ steps.query.outputs.DATA_NAME }}
-
-      - name: Download
-        if: steps.restore-cache.outputs.cache-hit != 'true'
-        run: |
-          wget -q -nc "https://data.ppy.sh/${{ steps.query.outputs.DATA_NAME }}.tar.bz2"
-
-      - name: Extract
-        run: |
-          tar -I lbzip2 -xf "${{ steps.query.outputs.DATA_NAME }}.tar.bz2"
-          rm -r "${{ steps.query.outputs.TARGET_DIR }}"
-          mv "${{ steps.query.outputs.DATA_NAME }}" "${{ steps.query.outputs.TARGET_DIR }}"
-
-  beatmaps:
-    name: Setup beatmaps
-    needs: directory
-    runs-on: self-hosted
-    steps:
-      - name: Query latest data
-        id: query
-        run: |
-          beatmaps_data_name=$(curl -s "https://data.ppy.sh/" | grep "osu_files" | tail -1 | awk -F "'" '{print $2}' | sed 's/\.tar\.bz2//g')
-
-          echo "TARGET_DIR=${{ needs.directory.outputs.GENERATOR_DIR }}/beatmaps" >> "${GITHUB_OUTPUT}"
-          echo "DATA_NAME=${beatmaps_data_name}" >> "${GITHUB_OUTPUT}"
-
-      - name: Restore cache
-        id: restore-cache
-        uses: maxnowack/local-cache@038cc090b52e4f205fbc468bf5b0756df6f68775 # v1
-        with:
-          path: ${{ steps.query.outputs.DATA_NAME }}.tar.bz2
-          key: ${{ steps.query.outputs.DATA_NAME }}
-
-      - name: Download
-        if: steps.restore-cache.outputs.cache-hit != 'true'
-        run: |
-          wget -q -nc "https://data.ppy.sh/${{ steps.query.outputs.DATA_NAME }}.tar.bz2"
-
-      - name: Extract
-        run: |
-          tar -I lbzip2 -xf "${{ steps.query.outputs.DATA_NAME }}.tar.bz2"
-          rm -r "${{ steps.query.outputs.TARGET_DIR }}"
-          mv "${{ steps.query.outputs.DATA_NAME }}" "${{ steps.query.outputs.TARGET_DIR }}"
-
-  generator:
-    name: Run generator
-    needs: [ directory, environment, scores, beatmaps ]
-    runs-on: self-hosted
-    timeout-minutes: 720
-    outputs:
-      TARGET: ${{ steps.run.outputs.TARGET }}
-      SPREADSHEET_LINK: ${{ steps.run.outputs.SPREADSHEET_LINK }}
-    steps:
-      - name: Run
-        id: run
-        run: |
-          # Add the GitHub token. This needs to be done here because it's unique per-job.
-          sed -i 's/^GH_TOKEN=.*$/GH_TOKEN=${{ github.token }}/' "${{ needs.directory.outputs.GENERATOR_ENV }}"
-
-          cd "${{ needs.directory.outputs.GENERATOR_DIR }}"
-          docker-compose up --build generator
-
-          link=$(docker-compose logs generator -n 10 | grep 'http' | sed -E 's/^.*(http.*)$/\1/')
-          target=$(cat "${{ needs.directory.outputs.GENERATOR_ENV }}" | grep -E '^OSU_B=' | cut -d '=' -f2-)
-
-          echo "TARGET=${target}" >> "${GITHUB_OUTPUT}"
-          echo "SPREADSHEET_LINK=${link}" >> "${GITHUB_OUTPUT}"
-
-      - name: Shutdown
-        if: ${{ always() }}
-        run: |
-          cd "${{ needs.directory.outputs.GENERATOR_DIR }}"
-          docker-compose down -v
-
-  output-cli:
-    name: Output info
-    needs: generator
-    runs-on: ubuntu-latest
-    steps:
-      - name: Output info
-        run: |
-          echo "Target: ${{ needs.generator.outputs.TARGET }}"
-          echo "Spreadsheet: ${{ needs.generator.outputs.SPREADSHEET_LINK }}"
-
-  cleanup:
-    name: Cleanup
-    needs: [ directory, generator ]
-    if: ${{ always() && needs.directory.result == 'success' }}
-    runs-on: self-hosted
-    steps:
-      - name: Cleanup
-        run: |
-          rm -rf "${{ needs.directory.outputs.GENERATOR_DIR }}"
-
-  update-comment:
-    name: Update PR comment
-    needs: [ create-comment, generator ]
-    runs-on: ubuntu-latest
-    if: ${{ always() && needs.create-comment.result == 'success' }}
-    steps:
-      - name: Update comment on success
-        if: ${{ needs.generator.result == 'success' }}
-        uses: thollander/actions-comment-pull-request@363c6f6eae92cc5c3a66e95ba016fc771bb38943 # v2.4.2
-        with:
-          comment_tag: ${{ env.EXECUTION_ID }}
-          mode: upsert
-          create_if_not_exists: false
-          message: |
-            Target: ${{ needs.generator.outputs.TARGET }}
-            Spreadsheet: ${{ needs.generator.outputs.SPREADSHEET_LINK }}
-
-      - name: Update comment on failure
-        if: ${{ needs.generator.result == 'failure' }}
-        uses: thollander/actions-comment-pull-request@363c6f6eae92cc5c3a66e95ba016fc771bb38943 # v2.4.2
-        with:
-          comment_tag: ${{ env.EXECUTION_ID }}
-          mode: upsert
-          create_if_not_exists: false
-          message: |
-            Difficulty calculation failed: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
-
-      - name: Update comment on cancellation
-        if: ${{ needs.generator.result == 'cancelled' }}
-        uses: thollander/actions-comment-pull-request@363c6f6eae92cc5c3a66e95ba016fc771bb38943 # v2.4.2
-        with:
-          comment_tag: ${{ env.EXECUTION_ID }}
-          mode: delete
-          message: '.' # Appears to be required by this action for non-error status code.
+      # Todo: Run ppcalc

README.md

@@ -12,43 +12,40 @@
 
 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.
+The future of [osu!](https://osu.ppy.sh) and 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.
+This project is under constant development, but we aim to keep things in a stable state. Users are encouraged to try it out and keep it installed alongside the stable *osu!* client. It will continue to evolve to the point of eventually replacing the existing stable client as an update.
 
-A few resources are available as starting points to getting involved and understanding the project:
+**IMPORTANT:** Gameplay mechanics (and other features which you may have come to know and love) are in a constant state of flux. Game balance and final quality-of-life passes come at the end of development, preceded by experimentation and changes which may potentially **reduce playability or usability**. This is done in order to allow us to move forward as developers and designers more efficiently. If this offends you, please consider sticking to a [stable release](https://osu.ppy.sh/home/download) of osu!. We are not yet open to heated discussion over game mechanics and will not be using github as a forum for such discussions just yet.
+
+We are accepting bug reports (please report with as much detail as possible and follow the existing issue templates). Feature requests are also welcome, but understand that our focus is on completing the game to feature parity before adding new features. 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 full "ranked play" support](https://github.com/orgs/ppy/projects/13?query=is%3Aopen+sort%3Aupdated-desc).
 
 ## Running osu!
 
-If you are just looking to give the game a whirl, you can grab the latest release for your platform:
+If you are looking to install or test osu! without setting up a development environment, you can consume our [releases](https://github.com/ppy/osu/releases). You can also generally download a version for your current device from the [osu! site](https://osu.ppy.sh/home/download). Failing that, you may use the links below to download the latest version for your operating system of choice:
 
-### Latest release:
+**Latest release:**
 
 | [Windows 8.1+ (x64)](https://github.com/ppy/osu/releases/latest/download/install.exe) | macOS 10.15+ ([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).
+- The iOS testflight link may fill up (Apple has a hard limit of 10,000 users). We reset it occasionally when this happens. Please do not ask about this. Check back regularly for link resets or follow [peppy](https://twitter.com/ppy) on twitter for announcements of link resets.
 
 If your platform is not listed above, there is still a chance you can manually build it by following the instructions below.
 
-**For iOS/iPadOS users**: The iOS testflight link fills up very fast (Apple has a hard limit of 10,000 users). We reset it occasionally. Please do not ask about this. Check back regularly for link resets or follow [peppy](https://twitter.com/ppy) on twitter for announcements. Our goal is to get the game on mobile app stores in early 2024.
-
 ## 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).
+osu! is designed to have extensible modular gameplay modes, called "rulesets". Building one of these allows a developer to harness the power of osu! for their own game style. 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 6.0 SDK](https://dotnet.microsoft.com/download) installed.
@@ -72,19 +69,9 @@ git pull
 
 ### Building
 
-#### From an IDE
+Build 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 `VisualTests` project/configuration. More information on this is provided [below](#contributing).
 
-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
+- Visual Studio / Rider users should load the project via one of the platform-specific `.slnf` files, rather than the main `.sln`. This will allow access to template run configurations.
 
 You can also build and run *osu!* from the command-line with a single command:
 
@@ -92,10 +79,12 @@ You can also build and run *osu!* from the command-line with a single command:
 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 you are not interested in debugging *osu!*, you can add `-c Release` to gain performance. In this case, you must replace `Debug` with `Release` in any commands mentioned in this document.
 
 If the build fails, try to restore NuGet packages with `dotnet restore`.
 
+_Due to a historical feature gap between .NET Core and Xamarin, running `dotnet` CLI from the root directory will not work for most commands. This can be resolved by specifying a target `.csproj` or the helper project at `build/Desktop.proj`. Configurations have been provided to work around this issue for all supported IDEs mentioned above._
+
 ### 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:

Templates/README.md

@@ -7,7 +7,7 @@ Templates for use when creating osu! dependent projects. Create a fully-testable
 ```bash
 # install (or update) templates package.
 # this only needs to be done once
-dotnet new install ppy.osu.Game.Templates
+dotnet new -i ppy.osu.Game.Templates
 
 # create an empty freeform ruleset
 dotnet new ruleset -n MyCoolRuleset

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

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

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

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

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

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

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

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

osu.Android.props

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

osu.Android/AndroidMouseSettings.cs

@@ -70,7 +70,7 @@ namespace osu.Android
                 },
                 new SettingsCheckbox
                 {
-                    LabelText = MouseSettingsStrings.DisableClicksDuringGameplay,
+                    LabelText = MouseSettingsStrings.DisableMouseButtons,
                     Current = osuConfig.GetBindable<bool>(OsuSetting.MouseDisableButtons),
                 },
             });

osu.Android/OsuGameAndroid.cs

@@ -11,7 +11,6 @@ using osu.Framework.Input.Handlers;
 using osu.Framework.Platform;
 using osu.Game;
 using osu.Game.Overlays.Settings;
-using osu.Game.Overlays.Settings.Sections.Input;
 using osu.Game.Updater;
 using osu.Game.Utils;
 
@@ -98,9 +97,6 @@ namespace osu.Android
                 case AndroidJoystickHandler jh:
                     return new AndroidJoystickSettings(jh);
 
-                case AndroidTouchHandler th:
-                    return new TouchSettings(th);
-
                 default:
                     return base.CreateSettingsSubsectionFor(handler);
             }

osu.Desktop/Program.cs

@@ -30,6 +30,10 @@ namespace osu.Desktop
         [STAThread]
         public static void Main(string[] args)
         {
+            // Too many performance issues reported. We're going to have to do more testing before pushing this out.
+            // See https://github.com/ppy/osu/issues/24751.
+            Environment.SetEnvironmentVariable("OSU_GRAPHICS_NO_SSBO", "1");
+
             // run Squirrel first, as the app may exit after these run
             if (OperatingSystem.IsWindows())
             {

osu.Desktop/Updater/SquirrelUpdateManager.cs

@@ -10,8 +10,8 @@ using osu.Game;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Screens.Play;
+using Squirrel;
 using Squirrel.SimpleSplat;
-using Squirrel.Sources;
 using LogLevel = Squirrel.SimpleSplat.LogLevel;
 using UpdateManager = osu.Game.Updater.UpdateManager;
 
@@ -63,7 +63,7 @@ namespace osu.Desktop.Updater
                 if (localUserInfo?.IsPlaying.Value == true)
                     return false;
 
-                updateManager ??= new Squirrel.UpdateManager(new GithubSource(@"https://github.com/ppy/osu", github_token, false), @"osulazer");
+                updateManager ??= new GithubUpdateManager(@"https://github.com/ppy/osu", false, github_token, @"osulazer");
 
                 var info = await updateManager.CheckForUpdate(!useDeltaPatching).ConfigureAwait(false);
 

osu.Desktop/osu.Desktop.csproj

@@ -23,10 +23,10 @@
     <ProjectReference Include="..\osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="Clowd.Squirrel" Version="2.10.2" />
+    <PackageReference Include="Clowd.Squirrel" Version="2.9.42" />
     <PackageReference Include="Mono.Posix.NETStandard" Version="1.0.0" />
     <PackageReference Include="System.IO.Packaging" Version="7.0.0" />
-    <PackageReference Include="DiscordRichPresence" Version="1.2.1.24" />
+    <PackageReference Include="DiscordRichPresence" Version="1.1.4.20" />
   </ItemGroup>
   <ItemGroup Label="Resources">
     <EmbeddedResource Include="lazer.ico" />

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

@@ -7,9 +7,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.13.9" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.4" />
     <PackageReference Include="nunit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
   </ItemGroup>
 
   <ItemGroup>

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

@@ -45,7 +45,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
             AddAssert("end time is correct", () => Precision.AlmostEquals(lastObject.EndTime, times[1]));
             AddAssert("start position is correct", () => Precision.AlmostEquals(lastObject.OriginalX, positions[0]));
             AddAssert("end position is correct", () => Precision.AlmostEquals(lastObject.EndX, positions[1]));
-            AddAssert("default slider velocity", () => lastObject.SliderVelocityMultiplierBindable.IsDefault);
+            AddAssert("default slider velocity", () => lastObject.SliderVelocityBindable.IsDefault);
         }
 
         [Test]
@@ -76,7 +76,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
             addPlacementSteps(times, positions);
             addPathCheckStep(times, positions);
 
-            AddAssert("slider velocity changed", () => !lastObject.SliderVelocityMultiplierBindable.IsDefault);
+            AddAssert("slider velocity changed", () => !lastObject.SliderVelocityBindable.IsDefault);
         }
 
         [Test]

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

@@ -108,11 +108,11 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
             double[] times = { 100, 300 };
             float[] positions = { 200, 300 };
             addBlueprintStep(times, positions);
-            AddAssert("default slider velocity", () => hitObject.SliderVelocityMultiplierBindable.IsDefault);
+            AddAssert("default slider velocity", () => hitObject.SliderVelocityBindable.IsDefault);
 
             addDragStartStep(times[1], positions[1]);
             AddMouseMoveStep(times[1], 400);
-            AddAssert("slider velocity changed", () => !hitObject.SliderVelocityMultiplierBindable.IsDefault);
+            AddAssert("slider velocity changed", () => !hitObject.SliderVelocityBindable.IsDefault);
         }
 
         [Test]

osu.Game.Rulesets.Catch.Tests/Mods/TestSceneCatchModFloatingFruits.cs

@@ -1,21 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using NUnit.Framework;
-using osu.Game.Rulesets.Catch.Mods;
-using osu.Game.Tests.Visual;
-
-namespace osu.Game.Rulesets.Catch.Tests.Mods
-{
-    public partial class TestSceneCatchModFloatingFruits : ModTestScene
-    {
-        protected override Ruleset CreatePlayerRuleset() => new CatchRuleset();
-
-        [Test]
-        public void TestFloating() => CreateModTest(new ModTestData
-        {
-            Mod = new CatchModFloatingFruits(),
-            PassCondition = () => true
-        });
-    }
-}

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

@@ -73,7 +73,7 @@ namespace osu.Game.Rulesets.Catch.Tests
         private float getCaughtObjectPosition(Fruit fruit)
         {
             var caughtObject = catcher.ChildrenOfType<CaughtObject>().Single(c => c.HitObject == fruit);
-            return caughtObject.Parent!.ToSpaceOfOtherDrawable(caughtObject.Position, catcher).X;
+            return caughtObject.Parent.ToSpaceOfOtherDrawable(caughtObject.Position, catcher).X;
         }
 
         private void catchFruit(Fruit fruit, float x)

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

@@ -1,157 +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 NUnit.Framework;
-using osu.Framework.Bindables;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Catch.Beatmaps;
-using osu.Game.Rulesets.Catch.Judgements;
-using osu.Game.Rulesets.Catch.Objects;
-using osu.Game.Rulesets.Catch.Scoring;
-using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Tests.Visual.Gameplay;
-
-namespace osu.Game.Rulesets.Catch.Tests
-{
-    [TestFixture]
-    public partial class TestSceneScoring : ScoringTestScene
-    {
-        public TestSceneScoring()
-            : base(supportsNonPerfectJudgements: false)
-        {
-        }
-
-        private Bindable<double> scoreMultiplier { get; } = new BindableDouble
-        {
-            Default = 4,
-            Value = 4
-        };
-
-        protected override IBeatmap CreateBeatmap(int maxCombo)
-        {
-            var beatmap = new CatchBeatmap();
-            for (int i = 0; i < maxCombo; ++i)
-                beatmap.HitObjects.Add(new Fruit());
-            return beatmap;
-        }
-
-        protected override IScoringAlgorithm CreateScoreV1() => new ScoreV1 { ScoreMultiplier = { BindTarget = scoreMultiplier } };
-
-        protected override IScoringAlgorithm CreateScoreV2(int maxCombo) => new ScoreV2(maxCombo);
-
-        protected override ProcessorBasedScoringAlgorithm CreateScoreAlgorithm(IBeatmap beatmap, ScoringMode mode) => new CatchProcessorBasedScoringAlgorithm(beatmap, mode);
-
-        [Test]
-        public void TestBasicScenarios()
-        {
-            AddStep("set up score multiplier", () =>
-            {
-                scoreMultiplier.BindValueChanged(_ => Rerun());
-            });
-            AddStep("set max combo to 100", () => MaxCombo.Value = 100);
-            AddStep("set perfect score", () =>
-            {
-                NonPerfectLocations.Clear();
-                MissLocations.Clear();
-            });
-            AddStep("set score with misses", () =>
-            {
-                NonPerfectLocations.Clear();
-                MissLocations.Clear();
-                MissLocations.AddRange(new[] { 24d, 49 });
-            });
-            AddSliderStep("adjust score multiplier", 0, 10, (int)scoreMultiplier.Default, multiplier => scoreMultiplier.Value = multiplier);
-        }
-
-        private const int base_great = 300;
-
-        private class ScoreV1 : IScoringAlgorithm
-        {
-            private int currentCombo;
-
-            public BindableDouble ScoreMultiplier { get; } = new BindableDouble();
-
-            public void ApplyHit() => applyHitV1(base_great);
-
-            public void ApplyNonPerfect() => throw new NotSupportedException("catch does not have \"non-perfect\" judgements.");
-
-            public void ApplyMiss() => applyHitV1(0);
-
-            private void applyHitV1(int baseScore)
-            {
-                if (baseScore == 0)
-                {
-                    currentCombo = 0;
-                    return;
-                }
-
-                TotalScore += baseScore;
-
-                // combo multiplier
-                // ReSharper disable once PossibleLossOfFraction
-                TotalScore += (int)(Math.Max(0, currentCombo - 1) * (baseScore / 25 * ScoreMultiplier.Value));
-
-                currentCombo++;
-            }
-
-            public long TotalScore { get; private set; }
-        }
-
-        private class ScoreV2 : IScoringAlgorithm
-        {
-            private int currentCombo;
-            private double comboPortion;
-
-            private readonly double comboPortionMax;
-
-            private const double combo_base = 4;
-            private const int combo_cap = 200;
-
-            public ScoreV2(int maxCombo)
-            {
-                for (int i = 0; i < maxCombo; i++)
-                    ApplyHit();
-
-                comboPortionMax = comboPortion;
-
-                currentCombo = 0;
-                comboPortion = 0;
-            }
-
-            public void ApplyHit() => applyHitV2(base_great);
-
-            public void ApplyNonPerfect() => throw new NotSupportedException("catch does not have \"non-perfect\" judgements.");
-
-            private void applyHitV2(int baseScore)
-            {
-                comboPortion += baseScore * Math.Min(Math.Max(0.5, Math.Log(++currentCombo, combo_base)), Math.Log(combo_cap, combo_base));
-            }
-
-            public void ApplyMiss()
-            {
-                currentCombo = 0;
-            }
-
-            public long TotalScore
-                => (int)Math.Round(1000000 * comboPortion / comboPortionMax); // vast simplification, as we're not doing ticks here.
-        }
-
-        private class CatchProcessorBasedScoringAlgorithm : ProcessorBasedScoringAlgorithm
-        {
-            public CatchProcessorBasedScoringAlgorithm(IBeatmap beatmap, ScoringMode mode)
-                : base(beatmap, mode)
-            {
-            }
-
-            protected override ScoreProcessor CreateScoreProcessor() => new CatchScoreProcessor();
-
-            protected override JudgementResult CreatePerfectJudgementResult() => new CatchJudgementResult(new Fruit(), new CatchJudgement()) { Type = HitResult.Great };
-
-            protected override JudgementResult CreateNonPerfectJudgementResult() => throw new NotSupportedException("catch does not have \"non-perfect\" judgements.");
-
-            protected override JudgementResult CreateMissJudgementResult() => new CatchJudgementResult(new Fruit(), new CatchJudgement()) { Type = HitResult.Miss };
-        }
-    }
-}

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

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

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

@@ -41,8 +41,9 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                         X = xPositionData?.X ?? 0,
                         NewCombo = comboData?.NewCombo ?? false,
                         ComboOffset = comboData?.ComboOffset ?? 0,
+                        LegacyLastTickOffset = (obj as IHasLegacyLastTickOffset)?.LegacyLastTickOffset ?? 0,
                         LegacyConvertedY = yPositionData?.Y ?? CatchHitObject.DEFAULT_LEGACY_CONVERT_Y,
-                        SliderVelocityMultiplier = sliderVelocityData?.SliderVelocityMultiplier ?? 1
+                        SliderVelocity = sliderVelocityData?.SliderVelocity ?? 1
                     }.Yield();
 
                 case IHasDuration endTime:

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -25,7 +25,6 @@ using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.Scoring.Legacy;
 using osu.Game.Rulesets.UI;
 using osu.Game.Scoring;
 using osu.Game.Screens.Ranking.Statistics;
@@ -54,7 +53,7 @@ namespace osu.Game.Rulesets.Catch
             new KeyBinding(InputKey.X, CatchAction.MoveRight),
             new KeyBinding(InputKey.Right, CatchAction.MoveRight),
             new KeyBinding(InputKey.Shift, CatchAction.Dash),
-            new KeyBinding(InputKey.MouseLeft, CatchAction.Dash),
+            new KeyBinding(InputKey.Shift, CatchAction.Dash),
         };
 
         public override IEnumerable<Mod> ConvertFromLegacyMods(LegacyMods mods)

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

@@ -25,9 +25,12 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
         public override int Version => 20220701;
 
+        private readonly IWorkingBeatmap workingBeatmap;
+
         public CatchDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
+            workingBeatmap = beatmap;
         }
 
         protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
@@ -46,6 +49,15 @@ namespace osu.Game.Rulesets.Catch.Difficulty
                 MaxCombo = beatmap.HitObjects.Count(h => h is Fruit) + beatmap.HitObjects.OfType<JuiceStream>().SelectMany(j => j.NestedHitObjects).Count(h => !(h is TinyDroplet)),
             };
 
+            if (ComputeLegacyScoringValues)
+            {
+                CatchLegacyScoreSimulator sv1Simulator = new CatchLegacyScoreSimulator();
+                sv1Simulator.Simulate(workingBeatmap, beatmap, mods);
+                attributes.LegacyAccuracyScore = sv1Simulator.AccuracyScore;
+                attributes.LegacyComboScore = sv1Simulator.ComboScore;
+                attributes.LegacyBonusScoreRatio = sv1Simulator.BonusScoreRatio;
+            }
+
             return attributes;
         }
 

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

@@ -5,26 +5,30 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Catch.Mods;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.Scoring.Legacy;
 
 namespace osu.Game.Rulesets.Catch.Difficulty
 {
     internal class CatchLegacyScoreSimulator : ILegacyScoreSimulator
     {
+        public int AccuracyScore { get; private set; }
+
+        public int ComboScore { get; private set; }
+
+        public double BonusScoreRatio => legacyBonusScore == 0 ? 0 : (double)modernBonusScore / legacyBonusScore;
+
         private int legacyBonusScore;
-        private int standardisedBonusScore;
+        private int modernBonusScore;
         private int combo;
 
         private double scoreMultiplier;
 
-        public LegacyScoreAttributes Simulate(IWorkingBeatmap workingBeatmap, IBeatmap playableBeatmap)
+        public void Simulate(IWorkingBeatmap workingBeatmap, IBeatmap playableBeatmap, IReadOnlyList<Mod> mods)
         {
             IBeatmap baseBeatmap = workingBeatmap.Beatmap;
 
@@ -66,19 +70,13 @@ namespace osu.Game.Rulesets.Catch.Difficulty
                  + baseBeatmap.Difficulty.CircleSize
                  + Math.Clamp((float)objectCount / drainLength * 8, 0, 16)) / 38 * 5);
 
-            scoreMultiplier = difficultyPeppyStars;
-
-            LegacyScoreAttributes attributes = new LegacyScoreAttributes();
+            scoreMultiplier = difficultyPeppyStars * mods.Aggregate(1.0, (current, mod) => current * mod.ScoreMultiplier);
 
             foreach (var obj in playableBeatmap.HitObjects)
-                simulateHit(obj, ref attributes);
-
-            attributes.BonusScoreRatio = legacyBonusScore == 0 ? 0 : (double)standardisedBonusScore / legacyBonusScore;
-
-            return attributes;
+                simulateHit(obj);
         }
 
-        private void simulateHit(HitObject hitObject, ref LegacyScoreAttributes attributes)
+        private void simulateHit(HitObject hitObject)
         {
             bool increaseCombo = true;
             bool addScoreComboMultiplier = false;
@@ -114,79 +112,31 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
                 case JuiceStream:
                     foreach (var nested in hitObject.NestedHitObjects)
-                        simulateHit(nested, ref attributes);
+                        simulateHit(nested);
                     return;
 
                 case BananaShower:
                     foreach (var nested in hitObject.NestedHitObjects)
-                        simulateHit(nested, ref attributes);
+                        simulateHit(nested);
                     return;
             }
 
             if (addScoreComboMultiplier)
             {
                 // ReSharper disable once PossibleLossOfFraction (intentional to match osu-stable...)
-                attributes.ComboScore += (int)(Math.Max(0, combo - 1) * (scoreIncrease / 25 * scoreMultiplier));
+                ComboScore += (int)(Math.Max(0, combo - 1) * (scoreIncrease / 25 * scoreMultiplier));
             }
 
             if (isBonus)
             {
                 legacyBonusScore += scoreIncrease;
-                standardisedBonusScore += Judgement.ToNumericResult(bonusResult);
+                modernBonusScore += Judgement.ToNumericResult(bonusResult);
             }
             else
-                attributes.AccuracyScore += scoreIncrease;
+                AccuracyScore += scoreIncrease;
 
             if (increaseCombo)
                 combo++;
         }
-
-        public double GetLegacyScoreMultiplier(IReadOnlyList<Mod> mods, LegacyBeatmapConversionDifficultyInfo difficulty)
-        {
-            bool scoreV2 = mods.Any(m => m is ModScoreV2);
-
-            double multiplier = 1.0;
-
-            foreach (var mod in mods)
-            {
-                switch (mod)
-                {
-                    case CatchModNoFail:
-                        multiplier *= scoreV2 ? 1.0 : 0.5;
-                        break;
-
-                    case CatchModEasy:
-                        multiplier *= 0.5;
-                        break;
-
-                    case CatchModHalfTime:
-                    case CatchModDaycore:
-                        multiplier *= 0.3;
-                        break;
-
-                    case CatchModHidden:
-                        multiplier *= scoreV2 ? 1.0 : 1.06;
-                        break;
-
-                    case CatchModHardRock:
-                        multiplier *= 1.12;
-                        break;
-
-                    case CatchModDoubleTime:
-                    case CatchModNightcore:
-                        multiplier *= 1.06;
-                        break;
-
-                    case CatchModFlashlight:
-                        multiplier *= 1.12;
-                        break;
-
-                    case CatchModRelax:
-                        return 0;
-                }
-            }
-
-            return multiplier;
-        }
     }
 }

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

@@ -91,7 +91,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints.Components
         public void UpdateHitObjectFromPath(JuiceStream hitObject)
         {
             // The SV setting may need to be changed for the current path.
-            var svBindable = hitObject.SliderVelocityMultiplierBindable;
+            var svBindable = hitObject.SliderVelocityBindable;
             double svToVelocityFactor = hitObject.Velocity / svBindable.Value;
             double requiredVelocity = path.ComputeRequiredVelocity();
 

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

@@ -1,19 +1,180 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
-using osu.Framework.Graphics.Containers;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Caching;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Edit;
-using osu.Game.Screens.Edit.Compose.Components;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Screens.Edit;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Edit
 {
-    public partial class CatchBeatSnapGrid : BeatSnapGrid
+    /// <summary>
+    /// A grid which displays coloured beat divisor lines in proximity to the selection or placement cursor.
+    /// </summary>
+    /// <remarks>
+    /// This class heavily borrows from osu!mania's implementation (ManiaBeatSnapGrid).
+    /// If further changes are to be made, they should also be applied there.
+    /// If the scale of the changes are large enough, abstracting may be a good path.
+    /// </remarks>
+    public partial class CatchBeatSnapGrid : Component
     {
-        protected override IEnumerable<Container> GetTargetContainers(HitObjectComposer composer) => new[]
+        private const double visible_range = 750;
+
+        /// <summary>
+        /// The range of time values of the current selection.
+        /// </summary>
+        public (double start, double end)? SelectionTimeRange
         {
-            ((CatchPlayfield)composer.Playfield).UnderlayElements
-        };
+            set
+            {
+                if (value == selectionTimeRange)
+                    return;
+
+                selectionTimeRange = value;
+                lineCache.Invalidate();
+            }
+        }
+
+        [Resolved]
+        private EditorBeatmap beatmap { get; set; } = null!;
+
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
+        [Resolved]
+        private BindableBeatDivisor beatDivisor { get; set; } = null!;
+
+        private readonly Cached lineCache = new Cached();
+
+        private (double start, double end)? selectionTimeRange;
+
+        private ScrollingHitObjectContainer lineContainer = null!;
+
+        [BackgroundDependencyLoader]
+        private void load(HitObjectComposer composer)
+        {
+            lineContainer = new ScrollingHitObjectContainer();
+
+            ((CatchPlayfield)composer.Playfield).UnderlayElements.Add(lineContainer);
+
+            beatDivisor.BindValueChanged(_ => createLines(), true);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (!lineCache.IsValid)
+            {
+                lineCache.Validate();
+                createLines();
+            }
+        }
+
+        private readonly Stack<DrawableGridLine> availableLines = new Stack<DrawableGridLine>();
+
+        private void createLines()
+        {
+            foreach (var line in lineContainer.Objects.OfType<DrawableGridLine>())
+                availableLines.Push(line);
+
+            lineContainer.Clear();
+
+            if (selectionTimeRange == null)
+                return;
+
+            var range = selectionTimeRange.Value;
+
+            var timingPoint = beatmap.ControlPointInfo.TimingPointAt(range.start - visible_range);
+
+            double time = timingPoint.Time;
+            int beat = 0;
+
+            // progress time until in the visible range.
+            while (time < range.start - visible_range)
+            {
+                time += timingPoint.BeatLength / beatDivisor.Value;
+                beat++;
+            }
+
+            while (time < range.end + visible_range)
+            {
+                var nextTimingPoint = beatmap.ControlPointInfo.TimingPointAt(time);
+
+                // switch to the next timing point if we have reached it.
+                if (nextTimingPoint.Time > timingPoint.Time)
+                {
+                    beat = 0;
+                    time = nextTimingPoint.Time;
+                    timingPoint = nextTimingPoint;
+                }
+
+                Color4 colour = BindableBeatDivisor.GetColourFor(
+                    BindableBeatDivisor.GetDivisorForBeatIndex(beat, beatDivisor.Value), colours);
+
+                if (!availableLines.TryPop(out var line))
+                    line = new DrawableGridLine();
+
+                line.HitObject.StartTime = time;
+                line.Colour = colour;
+
+                lineContainer.Add(line);
+
+                beat++;
+                time += timingPoint.BeatLength / beatDivisor.Value;
+            }
+
+            // required to update ScrollingHitObjectContainer's cache.
+            lineContainer.UpdateSubTree();
+
+            foreach (var line in lineContainer.Objects.OfType<DrawableGridLine>())
+            {
+                time = line.HitObject.StartTime;
+
+                if (time >= range.start && time <= range.end)
+                    line.Alpha = 1;
+                else
+                {
+                    double timeSeparation = time < range.start ? range.start - time : time - range.end;
+                    line.Alpha = (float)Math.Max(0, 1 - timeSeparation / visible_range);
+                }
+            }
+        }
+
+        private partial class DrawableGridLine : DrawableHitObject
+        {
+            public DrawableGridLine()
+                : base(new HitObject())
+            {
+                RelativeSizeAxes = Axes.X;
+                Height = 2;
+
+                AddInternal(new Box { RelativeSizeAxes = Axes.Both });
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                Origin = Anchor.BottomLeft;
+                Anchor = Anchor.BottomLeft;
+            }
+
+            protected override void UpdateInitialTransforms()
+            {
+                // don't perform any fading – we are handling that ourselves.
+                LifetimeEnd = HitObject.StartTime + visible_range;
+            }
+        }
     }
 }

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

@@ -1,26 +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.Objects;
-using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Objects;
-
-namespace osu.Game.Rulesets.Catch.Edit
-{
-    public partial class CatchDistanceSnapProvider : ComposerDistanceSnapProvider
-    {
-        protected override double ReadCurrentDistanceSnap(HitObject before, HitObject after)
-        {
-            // osu!catch's distance snap implementation is limited, in that a custom spacing cannot be specified.
-            // Therefore this functionality is not currently used.
-            //
-            // The implementation below is probably correct but should be checked if/when exposed via controls.
-
-            float expectedDistance = DurationToDistance(before, after.StartTime - before.GetEndTime());
-            float actualDistance = Math.Abs(((CatchHitObject)before).EffectiveX - ((CatchHitObject)after).EffectiveX);
-
-            return actualDistance / expectedDistance;
-        }
-    }
-}

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

@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Catch.Edit
             {
                 base.Update();
 
-                Scale = new Vector2(Math.Min(Parent!.ChildSize.X / CatchPlayfield.WIDTH, Parent!.ChildSize.Y / CatchPlayfield.HEIGHT));
+                Scale = new Vector2(Math.Min(Parent.ChildSize.X / CatchPlayfield.WIDTH, Parent.ChildSize.Y / CatchPlayfield.HEIGHT));
                 Height = 1 / Scale.Y;
             }
         }

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

@@ -1,13 +1,14 @@
 // 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.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics;
-using osu.Framework.Input.Bindings;
+using osu.Framework.Input;
 using osu.Framework.Input.Events;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.UserInterface;
@@ -19,27 +20,27 @@ using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.UI;
-using osu.Game.Screens.Edit.Components.TernaryButtons;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Edit
 {
-    public partial class CatchHitObjectComposer : ScrollingHitObjectComposer<CatchHitObject>, IKeyBindingHandler<GlobalAction>
+    public partial class CatchHitObjectComposer : DistancedHitObjectComposer<CatchHitObject>
     {
         private const float distance_snap_radius = 50;
 
         private CatchDistanceSnapGrid distanceSnapGrid = null!;
 
+        private InputManager inputManager = null!;
+
+        private CatchBeatSnapGrid beatSnapGrid = null!;
+
         private readonly BindableDouble timeRangeMultiplier = new BindableDouble(1)
         {
             MinValue = 1,
             MaxValue = 10,
         };
 
-        [Cached(typeof(IDistanceSnapProvider))]
-        protected readonly CatchDistanceSnapProvider DistanceSnapProvider = new CatchDistanceSnapProvider();
-
         public CatchHitObjectComposer(CatchRuleset ruleset)
             : base(ruleset)
         {
@@ -48,11 +49,8 @@ namespace osu.Game.Rulesets.Catch.Edit
         [BackgroundDependencyLoader]
         private void load()
         {
-            AddInternal(DistanceSnapProvider);
-            DistanceSnapProvider.AttachToToolbox(RightToolbox);
-
             // todo: enable distance spacing once catch supports applying it to its existing distance snap grid implementation.
-            DistanceSnapProvider.DistanceSpacingMultiplier.Disabled = true;
+            DistanceSpacingMultiplier.Disabled = true;
 
             LayerBelowRuleset.Add(new PlayfieldBorder
             {
@@ -69,30 +67,61 @@ namespace osu.Game.Rulesets.Catch.Edit
                 Catcher.BASE_DASH_SPEED, -Catcher.BASE_DASH_SPEED,
                 Catcher.BASE_WALK_SPEED, -Catcher.BASE_WALK_SPEED,
             }));
+
+            AddInternal(beatSnapGrid = new CatchBeatSnapGrid());
         }
 
-        protected override IEnumerable<TernaryButton> CreateTernaryButtons()
-            => base.CreateTernaryButtons()
-                   .Concat(DistanceSnapProvider.CreateTernaryButtons());
-
-        protected override DrawableRuleset<CatchHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods) =>
-            new DrawableCatchEditorRuleset(ruleset, beatmap, mods)
-            {
-                TimeRangeMultiplier = { BindTarget = timeRangeMultiplier, }
-            };
-
-        protected override ComposeBlueprintContainer CreateBlueprintContainer() => new CatchBlueprintContainer(this);
-
-        protected override BeatSnapGrid CreateBeatSnapGrid() => new CatchBeatSnapGrid();
-
-        protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
+        protected override void LoadComplete()
         {
-            new FruitCompositionTool(),
-            new JuiceStreamCompositionTool(),
-            new BananaShowerCompositionTool()
-        };
+            base.LoadComplete();
 
-        public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
+            inputManager = GetContainingInputManager();
+        }
+
+        protected override void UpdateAfterChildren()
+        {
+            base.UpdateAfterChildren();
+
+            if (BlueprintContainer.CurrentTool is SelectTool)
+            {
+                if (EditorBeatmap.SelectedHitObjects.Any())
+                {
+                    beatSnapGrid.SelectionTimeRange = (EditorBeatmap.SelectedHitObjects.Min(h => h.StartTime), EditorBeatmap.SelectedHitObjects.Max(h => h.GetEndTime()));
+                }
+                else
+                    beatSnapGrid.SelectionTimeRange = null;
+            }
+            else
+            {
+                var result = FindSnappedPositionAndTime(inputManager.CurrentState.Mouse.Position);
+                if (result.Time is double time)
+                    beatSnapGrid.SelectionTimeRange = (time, time);
+                else
+                    beatSnapGrid.SelectionTimeRange = null;
+            }
+        }
+
+        protected override double ReadCurrentDistanceSnap(HitObject before, HitObject after)
+        {
+            // osu!catch's distance snap implementation is limited, in that a custom spacing cannot be specified.
+            // Therefore this functionality is not currently used.
+            //
+            // The implementation below is probably correct but should be checked if/when exposed via controls.
+
+            float expectedDistance = DurationToDistance(before, after.StartTime - before.GetEndTime());
+            float actualDistance = Math.Abs(((CatchHitObject)before).EffectiveX - ((CatchHitObject)after).EffectiveX);
+
+            return actualDistance / expectedDistance;
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            updateDistanceSnapGrid();
+        }
+
+        public override bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
         {
             switch (e.Action)
             {
@@ -101,19 +130,28 @@ namespace osu.Game.Rulesets.Catch.Edit
                 // May be worth considering standardising "zoom" behaviour with what the timeline uses (ie. alt-wheel) but that may cause new conflicts.
                 case GlobalAction.IncreaseScrollSpeed:
                     this.TransformBindableTo(timeRangeMultiplier, timeRangeMultiplier.Value - 1, 200, Easing.OutQuint);
-                    return true;
+                    break;
 
                 case GlobalAction.DecreaseScrollSpeed:
                     this.TransformBindableTo(timeRangeMultiplier, timeRangeMultiplier.Value + 1, 200, Easing.OutQuint);
-                    return true;
+                    break;
             }
 
-            return false;
+            return base.OnPressed(e);
         }
 
-        public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
+        protected override DrawableRuleset<CatchHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod>? mods = null) =>
+            new DrawableCatchEditorRuleset(ruleset, beatmap, mods)
+            {
+                TimeRangeMultiplier = { BindTarget = timeRangeMultiplier, }
+            };
+
+        protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
         {
-        }
+            new FruitCompositionTool(),
+            new JuiceStreamCompositionTool(),
+            new BananaShowerCompositionTool()
+        };
 
         public override SnapResult FindSnappedPositionAndTime(Vector2 screenSpacePosition, SnapType snapType = SnapType.All)
         {
@@ -133,6 +171,8 @@ namespace osu.Game.Rulesets.Catch.Edit
             return result;
         }
 
+        protected override ComposeBlueprintContainer CreateBlueprintContainer() => new CatchBlueprintContainer(this);
+
         private PalpableCatchHitObject? getLastSnappableHitObject(double time)
         {
             var hitObject = EditorBeatmap.HitObjects.OfType<CatchHitObject>().LastOrDefault(h => h.GetEndTime() < time && !(h is BananaShower));
@@ -173,7 +213,7 @@ namespace osu.Game.Rulesets.Catch.Edit
                             return null;
                     }
 
-                    double timeAtCursor = ((CatchPlayfield)Playfield).TimeAtScreenSpacePosition(InputManager.CurrentState.Mouse.Position);
+                    double timeAtCursor = ((CatchPlayfield)Playfield).TimeAtScreenSpacePosition(inputManager.CurrentState.Mouse.Position);
                     return getLastSnappableHitObject(timeAtCursor);
 
                 default:
@@ -181,16 +221,9 @@ namespace osu.Game.Rulesets.Catch.Edit
             }
         }
 
-        protected override void Update()
-        {
-            base.Update();
-
-            updateDistanceSnapGrid();
-        }
-
         private void updateDistanceSnapGrid()
         {
-            if (DistanceSnapProvider.DistanceSnapToggle.Value != TernaryState.True)
+            if (DistanceSnapToggle.Value != TernaryState.True)
             {
                 distanceSnapGrid.Hide();
                 return;

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

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Rulesets.Catch.Objects;
@@ -20,8 +21,10 @@ namespace osu.Game.Rulesets.Catch.Mods
 
         public void ApplyToDrawableRuleset(DrawableRuleset<CatchHitObject> drawableRuleset)
         {
+            drawableRuleset.PlayfieldAdjustmentContainer.Anchor = Anchor.Centre;
+            drawableRuleset.PlayfieldAdjustmentContainer.Origin = Anchor.Centre;
+
             drawableRuleset.PlayfieldAdjustmentContainer.Scale = new Vector2(1, -1);
-            drawableRuleset.PlayfieldAdjustmentContainer.Y = 1 - drawableRuleset.PlayfieldAdjustmentContainer.Y;
         }
     }
 }

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

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Beatmaps;
@@ -17,13 +16,5 @@ namespace osu.Game.Rulesets.Catch.Mods
             var catchProcessor = (CatchBeatmapProcessor)beatmapProcessor;
             catchProcessor.HardRockOffsets = true;
         }
-
-        public override void ApplyToDifficulty(BeatmapDifficulty difficulty)
-        {
-            base.ApplyToDifficulty(difficulty);
-
-            difficulty.CircleSize = Math.Min(difficulty.CircleSize * 1.3f, 10.0f); // CS uses a custom 1.3 ratio.
-            difficulty.ApproachRate = Math.Min(difficulty.ApproachRate * ADJUST_RATIO, 10.0f);
-        }
     }
 }

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

@@ -8,7 +8,6 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
 using osuTK;
@@ -152,7 +151,7 @@ namespace osu.Game.Rulesets.Catch.Objects
 
             TimePreempt = (float)IBeatmapDifficultyInfo.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450);
 
-            Scale = LegacyRulesetExtensions.CalculateScaleFromCircleSize(difficulty.CircleSize);
+            Scale = (1.0f - 0.7f * (difficulty.CircleSize - 5) / 5) / 2;
         }
 
         protected override HitWindows CreateHitWindows() => HitWindows.Empty;

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

@@ -28,17 +28,17 @@ namespace osu.Game.Rulesets.Catch.Objects
 
         public int RepeatCount { get; set; }
 
-        public BindableNumber<double> SliderVelocityMultiplierBindable { get; } = new BindableDouble(1)
+        public BindableNumber<double> SliderVelocityBindable { get; } = new BindableDouble(1)
         {
             Precision = 0.01,
             MinValue = 0.1,
             MaxValue = 10
         };
 
-        public double SliderVelocityMultiplier
+        public double SliderVelocity
         {
-            get => SliderVelocityMultiplierBindable.Value;
-            set => SliderVelocityMultiplierBindable.Value = value;
+            get => SliderVelocityBindable.Value;
+            set => SliderVelocityBindable.Value = value;
         }
 
         [JsonIgnore]
@@ -48,10 +48,10 @@ namespace osu.Game.Rulesets.Catch.Objects
         private double tickDistanceFactor;
 
         [JsonIgnore]
-        public double Velocity => velocityFactor * SliderVelocityMultiplier;
+        public double Velocity => velocityFactor * SliderVelocity;
 
         [JsonIgnore]
-        public double TickDistance => tickDistanceFactor * SliderVelocityMultiplier;
+        public double TickDistance => tickDistanceFactor * SliderVelocity;
 
         /// <summary>
         /// The length of one span of this <see cref="JuiceStream"/>.
@@ -77,7 +77,7 @@ namespace osu.Game.Rulesets.Catch.Objects
             int nodeIndex = 0;
             SliderEventDescriptor? lastEvent = null;
 
-            foreach (var e in SliderEventGenerator.Generate(StartTime, SpanDuration, Velocity, TickDistance, Path.Distance, this.SpanCount(), cancellationToken))
+            foreach (var e in SliderEventGenerator.Generate(StartTime, SpanDuration, Velocity, TickDistance, Path.Distance, this.SpanCount(), LegacyLastTickOffset, cancellationToken))
             {
                 // generate tiny droplets since the last point
                 if (lastEvent != null)
@@ -104,8 +104,8 @@ namespace osu.Game.Rulesets.Catch.Objects
                     }
                 }
 
-                // this also includes LastTick and this is used for TinyDroplet generation above.
-                // this means that the final segment of TinyDroplets are increasingly mistimed where LastTick is being applied.
+                // this also includes LegacyLastTick and this is used for TinyDroplet generation above.
+                // this means that the final segment of TinyDroplets are increasingly mistimed where LegacyLastTickOffset is being applied.
                 lastEvent = e;
 
                 switch (e.Type)
@@ -162,5 +162,7 @@ namespace osu.Game.Rulesets.Catch.Objects
         public double Distance => Path.Distance;
 
         public IList<IList<HitSampleInfo>> NodeSamples { get; set; } = new List<IList<HitSampleInfo>>();
+
+        public double? LegacyLastTickOffset { get; set; }
     }
 }

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

@@ -15,11 +15,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Argon
         [BackgroundDependencyLoader]
         private void load()
         {
-            Anchor = Anchor.TopCentre;
-            Origin = Anchor.Centre;
-
-            RelativeSizeAxes = Axes.X;
-            AutoSizeAxes = Axes.Y;
+            RelativeSizeAxes = Axes.Both;
 
             InternalChildren = new Drawable[]
             {

osu.Game.Rulesets.Catch/Skinning/Default/DefaultCatcher.cs

@@ -9,7 +9,6 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Rulesets.Catch.UI;
-using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Skinning.Default
 {
@@ -23,7 +22,6 @@ namespace osu.Game.Rulesets.Catch.Skinning.Default
 
         public DefaultCatcher()
         {
-            Anchor = Anchor.TopCentre;
             RelativeSizeAxes = Axes.Both;
             InternalChild = sprite = new Sprite
             {
@@ -34,15 +32,6 @@ namespace osu.Game.Rulesets.Catch.Skinning.Default
             };
         }
 
-        protected override void Update()
-        {
-            base.Update();
-
-            // matches stable's origin position since we're using the same catcher sprite.
-            // see LegacyCatcher for more information.
-            OriginPosition = new Vector2(DrawWidth / 2, 16f);
-        }
-
         [BackgroundDependencyLoader]
         private void load(TextureStore store, Bindable<CatcherAnimationState> currentState)
         {

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

@@ -2,21 +2,17 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics.Textures;
-using osu.Game.Skinning;
-using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Skinning.Legacy
 {
     public partial class LegacyBananaPiece : LegacyCatchHitObjectPiece
     {
-        private static readonly Vector2 banana_max_size = new Vector2(160);
-
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
-            Texture? texture = Skin.GetTexture("fruit-bananas")?.WithMaximumSize(banana_max_size);
-            Texture? overlayTexture = Skin.GetTexture("fruit-bananas-overlay")?.WithMaximumSize(banana_max_size);
+            Texture? texture = Skin.GetTexture("fruit-bananas");
+            Texture? overlayTexture = Skin.GetTexture("fruit-bananas-overlay");
 
             SetTexture(texture, overlayTexture);
         }

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

@@ -1,33 +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.Graphics;
-using osu.Framework.Graphics.Containers;
-using osuTK;
-
-namespace osu.Game.Rulesets.Catch.Skinning.Legacy
-{
-    public abstract partial class LegacyCatcher : CompositeDrawable
-    {
-        protected LegacyCatcher()
-        {
-            Anchor = Anchor.TopCentre;
-            Origin = Anchor.TopCentre;
-
-            // in stable, catcher sprites are displayed in their raw size. stable also has catcher sprites displayed with the following scale factors applied:
-            //  1. 0.5x, affecting all sprites in the playfield, computed here based on lazer's catch playfield dimensions (see WIDTH/HEIGHT constants in CatchPlayfield),
-            //           source: https://github.com/peppy/osu-stable-reference/blob/1531237b63392e82c003c712faa028406073aa8f/osu!/GameplayElements/HitObjectManager.cs#L483-L494
-            //  2. 0.7x, a constant scale applied to all catcher sprites on construction.
-            AutoSizeAxes = Axes.Both;
-            Scale = new Vector2(0.5f * 0.7f);
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-
-            // stable sets the Y origin position of the catcher to 16px in order for the catching range and OD scaling to align with the top of the catcher's plate in the default skin.
-            OriginPosition = new Vector2(DrawWidth / 2, 16f);
-        }
-    }
-}

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

@@ -7,12 +7,14 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
+using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Skinning;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Skinning.Legacy
 {
-    public partial class LegacyCatcherNew : LegacyCatcher
+    public partial class LegacyCatcherNew : CompositeDrawable
     {
         [Resolved]
         private Bindable<CatcherAnimationState> currentState { get; set; } = null!;
@@ -21,12 +23,25 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
 
         private Drawable currentDrawable = null!;
 
+        public LegacyCatcherNew()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
         [BackgroundDependencyLoader]
         private void load(ISkinSource skin)
         {
             foreach (var state in Enum.GetValues<CatcherAnimationState>())
             {
-                AddInternal(drawables[state] = getDrawableFor(state).With(d => d.Alpha = 0));
+                AddInternal(drawables[state] = getDrawableFor(state).With(d =>
+                {
+                    d.Anchor = Anchor.TopCentre;
+                    d.Origin = Anchor.TopCentre;
+                    d.RelativeSizeAxes = Axes.Both;
+                    d.Size = Vector2.One;
+                    d.FillMode = FillMode.Fit;
+                    d.Alpha = 0;
+                }));
             }
 
             currentDrawable = drawables[CatcherAnimationState.Idle];

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

@@ -3,21 +3,30 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Game.Skinning;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Skinning.Legacy
 {
-    public partial class LegacyCatcherOld : LegacyCatcher
+    public partial class LegacyCatcherOld : CompositeDrawable
     {
         public LegacyCatcherOld()
         {
-            AutoSizeAxes = Axes.Both;
+            RelativeSizeAxes = Axes.Both;
         }
 
         [BackgroundDependencyLoader]
         private void load(ISkinSource skin)
         {
-            InternalChild = skin.GetAnimation(@"fruit-ryuuta", true, true, true) ?? Empty();
+            InternalChild = (skin.GetAnimation(@"fruit-ryuuta", true, true, true) ?? Empty()).With(d =>
+            {
+                d.Anchor = Anchor.TopCentre;
+                d.Origin = Anchor.TopCentre;
+                d.RelativeSizeAxes = Axes.Both;
+                d.Size = Vector2.One;
+                d.FillMode = FillMode.Fit;
+            });
         }
     }
 }

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

@@ -2,15 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics.Textures;
-using osu.Game.Skinning;
 using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Skinning.Legacy
 {
     public partial class LegacyDropletPiece : LegacyCatchHitObjectPiece
     {
-        private static readonly Vector2 droplet_max_size = new Vector2(160);
-
         public LegacyDropletPiece()
         {
             Scale = new Vector2(0.8f);
@@ -20,8 +17,8 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
         {
             base.LoadComplete();
 
-            Texture? texture = Skin.GetTexture("fruit-drop")?.WithMaximumSize(droplet_max_size);
-            Texture? overlayTexture = Skin.GetTexture("fruit-drop-overlay")?.WithMaximumSize(droplet_max_size);
+            Texture? texture = Skin.GetTexture("fruit-drop");
+            Texture? overlayTexture = Skin.GetTexture("fruit-drop-overlay");
 
             SetTexture(texture, overlayTexture);
         }

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

@@ -2,15 +2,11 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Game.Rulesets.Catch.Objects;
-using osu.Game.Skinning;
-using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Skinning.Legacy
 {
     internal partial class LegacyFruitPiece : LegacyCatchHitObjectPiece
     {
-        private static readonly Vector2 fruit_max_size = new Vector2(160);
-
         protected override void LoadComplete()
         {
             base.LoadComplete();
@@ -26,26 +22,21 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
             switch (visualRepresentation)
             {
                 case FruitVisualRepresentation.Pear:
-                    setTextures("pear");
+                    SetTexture(Skin.GetTexture("fruit-pear"), Skin.GetTexture("fruit-pear-overlay"));
                     break;
 
                 case FruitVisualRepresentation.Grape:
-                    setTextures("grapes");
+                    SetTexture(Skin.GetTexture("fruit-grapes"), Skin.GetTexture("fruit-grapes-overlay"));
                     break;
 
                 case FruitVisualRepresentation.Pineapple:
-                    setTextures("apple");
+                    SetTexture(Skin.GetTexture("fruit-apple"), Skin.GetTexture("fruit-apple-overlay"));
                     break;
 
                 case FruitVisualRepresentation.Raspberry:
-                    setTextures("orange");
+                    SetTexture(Skin.GetTexture("fruit-orange"), Skin.GetTexture("fruit-orange-overlay"));
                     break;
             }
-
-            void setTextures(string fruitName) => SetTexture(
-                Skin.GetTexture($"fruit-{fruitName}")?.WithMaximumSize(fruit_max_size),
-                Skin.GetTexture($"fruit-{fruitName}-overlay")?.WithMaximumSize(fruit_max_size)
-            );
         }
     }
 }

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

@@ -17,13 +17,12 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public CatchPlayfieldAdjustmentContainer()
         {
-            Anchor = Anchor.TopCentre;
-            Origin = Anchor.TopCentre;
-
-            // playfields in stable are positioned vertically at three fourths the difference between the playfield height and the window height in stable.
-            // we can match that in lazer by using relative coordinates for Y and considering window height to be 1, and playfield height to be 0.8.
-            RelativePositionAxes = Axes.Y;
-            Y = (1 - playfield_size_adjust) / 4 * 3;
+            // because we are using centre anchor/origin, we will need to limit visibility in the future
+            // to ensure tall windows do not get a readability advantage.
+            // it may be possible to bake the catch-specific offsets (-100..340 mentioned below) into new values
+            // which are compatible with TopCentre alignment.
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
 
             Size = new Vector2(playfield_size_adjust);
 
@@ -43,28 +42,18 @@ namespace osu.Game.Rulesets.Catch.UI
         /// </summary>
         private partial class ScalingContainer : Container
         {
-            public ScalingContainer()
-            {
-                Anchor = Anchor.BottomCentre;
-                Origin = Anchor.BottomCentre;
-            }
-
             protected override void Update()
             {
                 base.Update();
 
-                // in stable, fruit fall vertically from 100 pixels above the playfield top down to the catcher's Y position (i.e. -100 to 340),
-                // see: https://github.com/peppy/osu-stable-reference/blob/1531237b63392e82c003c712faa028406073aa8f/osu!/GameplayElements/HitObjects/Fruits/HitCircleFruits.cs#L65
-                // we already have the playfield positioned similar to stable (see CatchPlayfieldAdjustmentContainer constructor),
-                // so we only need to increase this container's height 100 pixels above the playfield, and offset it to have the bottom at 340 rather than 384.
-                const float stable_fruit_start_position = -100;
-                const float stable_catcher_y_position = 340;
-                const float playfield_v_size_adjustment = (stable_catcher_y_position - stable_fruit_start_position) / CatchPlayfield.HEIGHT;
-                const float playfield_v_catcher_offset = stable_catcher_y_position - CatchPlayfield.HEIGHT;
+                // in stable, fruit fall vertically from -100 to 340.
+                // to emulate this, we want to make our playfield 440 gameplay pixels high.
+                // we then offset it -100 vertically in the position set below.
+                const float stable_v_offset_ratio = 440 / 384f;
 
-                Scale = new Vector2(Parent!.ChildSize.X / CatchPlayfield.WIDTH);
-                Position = new Vector2(0f, playfield_v_catcher_offset * Scale.Y);
-                Size = Vector2.Divide(new Vector2(1, playfield_v_size_adjustment), Scale);
+                Scale = new Vector2(Parent.ChildSize.X / CatchPlayfield.WIDTH);
+                Position = new Vector2(0, -100 * stable_v_offset_ratio + Scale.X);
+                Size = Vector2.Divide(new Vector2(1, stable_v_offset_ratio), Scale);
             }
         }
     }

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

@@ -17,7 +17,6 @@ using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.Skinning;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Skinning;
 using osuTK;
 using osuTK.Graphics;
@@ -30,13 +29,6 @@ namespace osu.Game.Rulesets.Catch.UI
         /// <summary>
         /// The size of the catcher at 1x scale.
         /// </summary>
-        /// <remarks>
-        /// This is mainly used to compute catching range, the actual catcher size may differ based on skin implementation and sprite textures.
-        /// This is also equivalent to the "catcherWidth" property in osu-stable when the game field and beatmap difficulty are set to default values.
-        /// </remarks>
-        /// <seealso cref="CatchPlayfield.WIDTH"/>
-        /// <seealso cref="CatchPlayfield.HEIGHT"/>
-        /// <seealso cref="IBeatmapDifficultyInfo.DEFAULT_DIFFICULTY"/>
         public const float BASE_SIZE = 106.75f;
 
         /// <summary>
@@ -183,6 +175,11 @@ namespace osu.Game.Rulesets.Catch.UI
         /// </summary>
         public Drawable CreateProxiedContent() => caughtObjectContainer.CreateProxy();
 
+        /// <summary>
+        /// Calculates the scale of the catcher based off the provided beatmap difficulty.
+        /// </summary>
+        private static Vector2 calculateScale(IBeatmapDifficultyInfo difficulty) => new Vector2(1.0f - 0.7f * (difficulty.CircleSize - 5) / 5);
+
         /// <summary>
         /// Calculates the width of the area used for attempting catches in gameplay.
         /// </summary>
@@ -467,11 +464,6 @@ namespace osu.Game.Rulesets.Catch.UI
             d.Expire();
         }
 
-        /// <summary>
-        /// Calculates the scale of the catcher based off the provided beatmap difficulty.
-        /// </summary>
-        private static Vector2 calculateScale(IBeatmapDifficultyInfo difficulty) => new Vector2(LegacyRulesetExtensions.CalculateScaleFromCircleSize(difficulty.CircleSize) * 2);
-
         private enum DroppedObjectAnimation
         {
             Drop,

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

@@ -21,6 +21,8 @@ namespace osu.Game.Rulesets.Catch.UI
 {
     public partial class DrawableCatchRuleset : DrawableScrollingRuleset<CatchHitObject>
     {
+        protected override ScrollVisualisationMethod VisualisationMethod => ScrollVisualisationMethod.Constant;
+
         protected override bool UserScrollSpeedAdjustment => false;
 
         public DrawableCatchRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod>? mods = null)
@@ -28,7 +30,6 @@ namespace osu.Game.Rulesets.Catch.UI
         {
             Direction.Value = ScrollingDirection.Down;
             TimeRange.Value = GetTimeRange(beatmap.Difficulty.ApproachRate);
-            VisualisationMethod = ScrollVisualisationMethod.Constant;
         }
 
         [BackgroundDependencyLoader]

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

@@ -6,6 +6,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Catch.Skinning.Default;
 using osu.Game.Skinning;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
@@ -25,8 +26,8 @@ namespace osu.Game.Rulesets.Catch.UI
             : base(new CatchSkinComponentLookup(CatchSkinComponents.Catcher), _ => new DefaultCatcher())
         {
             Anchor = Anchor.TopCentre;
-            Origin = Anchor.TopCentre;
-            CentreComponent = false;
+            // Sets the origin roughly to the centre of the catcher's plate to allow for correct scaling.
+            OriginPosition = new Vector2(0.5f, 0.06f) * Catcher.BASE_SIZE;
         }
     }
 }

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

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
             PassCondition = () =>
             {
                 var hitObject = Player.ChildrenOfType<DrawableManiaHitObject>().FirstOrDefault();
-                return hitObject?.Dependencies.Get<IScrollingInfo>().Algorithm.Value is ConstantScrollAlgorithm;
+                return hitObject?.Dependencies.Get<IScrollingInfo>().Algorithm is ConstantScrollAlgorithm;
             }
         });
     }

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

@@ -17,16 +17,12 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
     {
         private const double offset = 18;
 
-        protected override bool AllowFail => true;
-
         protected override Ruleset CreatePlayerRuleset() => new ManiaRuleset();
 
         [Test]
         public void TestHitWindowWithoutDoubleTime() => CreateModTest(new ModTestData
         {
-            PassCondition = () => Player.ScoreProcessor.JudgedHits > 0
-                                  && Player.ScoreProcessor.Accuracy.Value == 1
-                                  && Player.ScoreProcessor.TotalScore.Value == 1_000_000,
+            PassCondition = () => Player.ScoreProcessor.JudgedHits > 0 && Player.ScoreProcessor.Accuracy.Value != 1,
             Autoplay = false,
             Beatmap = new Beatmap
             {
@@ -44,31 +40,24 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
         });
 
         [Test]
-        public void TestHitWindowWithDoubleTime()
+        public void TestHitWindowWithDoubleTime() => CreateModTest(new ModTestData
         {
-            var doubleTime = new ManiaModDoubleTime();
-
-            CreateModTest(new ModTestData
+            Mod = new ManiaModDoubleTime(),
+            PassCondition = () => Player.ScoreProcessor.JudgedHits > 0 && Player.ScoreProcessor.Accuracy.Value == 1,
+            Autoplay = false,
+            Beatmap = new Beatmap
             {
-                Mod = doubleTime,
-                PassCondition = () => Player.ScoreProcessor.JudgedHits > 0
-                                      && Player.ScoreProcessor.Accuracy.Value == 1
-                                      && Player.ScoreProcessor.TotalScore.Value == (long)(1_000_010 * doubleTime.ScoreMultiplier),
-                Autoplay = false,
-                Beatmap = new Beatmap
+                BeatmapInfo = { Ruleset = new ManiaRuleset().RulesetInfo },
+                Difficulty = { OverallDifficulty = 10 },
+                HitObjects = new List<HitObject>
                 {
-                    BeatmapInfo = { Ruleset = new ManiaRuleset().RulesetInfo },
-                    Difficulty = { OverallDifficulty = 10 },
-                    HitObjects = new List<HitObject>
-                    {
-                        new Note { StartTime = 1000 }
-                    },
+                    new Note { StartTime = 1000 }
                 },
-                ReplayFrames = new List<ReplayFrame>
-                {
-                    new ManiaReplayFrame(1000 + offset, ManiaAction.Key1)
-                }
-            });
-        }
+            },
+            ReplayFrames = new List<ReplayFrame>
+            {
+                new ManiaReplayFrame(1000 + offset, ManiaAction.Key1)
+            }
+        });
     }
 }

osu.Game.Rulesets.Mania.Tests/Resources/special-skin/skin.ini

@@ -4,7 +4,6 @@ Version: 2.5
 [Mania]
 Keys: 4
 ColumnLineWidth: 3,1,3,1,1
-LightFramePerSecond: 15
 // some skins found in the wild had configuration keys where the @2x suffix was included in the values.
 // the expected compatibility behaviour is that the presence of the @2x suffix shouldn't change anything
 // if @2x assets are present.
@@ -16,6 +15,5 @@ Hit300: mania/hit300@2x
 Hit300g: mania/hit300g@2x
 StageLeft: mania/stage-left
 StageRight: mania/stage-right
-StageLight: mania/stage-light
 NoteImage0L: LongNoteTailWang
 NoteImage1L: LongNoteTailWang

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

@@ -58,7 +58,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
 
             IBindable<ScrollingDirection> IScrollingInfo.Direction => Direction;
             IBindable<double> IScrollingInfo.TimeRange { get; } = new Bindable<double>(5000);
-            IBindable<IScrollAlgorithm> IScrollingInfo.Algorithm { get; } = new Bindable<IScrollAlgorithm>(new ConstantScrollAlgorithm());
+            IScrollAlgorithm IScrollingInfo.Algorithm { get; } = new ConstantScrollAlgorithm();
         }
     }
 }

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

@@ -39,7 +39,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
                 {
                     c.Add(hitExplosionPools[poolIndex].Get(e =>
                     {
-                        e.Apply(new JudgementResult(new HitObject(), new ManiaJudgement()));
+                        e.Apply(new JudgementResult(new HitObject(), runCount % 6 == 0 ? new HoldNoteTickJudgement() : new ManiaJudgement()));
 
                         e.Anchor = Anchor.Centre;
                         e.Origin = Anchor.Centre;

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

@@ -54,6 +54,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Miss);
+            assertTickJudgement(HitResult.LargeTickMiss);
             assertTailJudgement(HitResult.Miss);
             assertNoteJudgement(HitResult.IgnoreMiss);
         }
@@ -72,6 +73,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Perfect);
+            assertTickJudgement(HitResult.LargeTickHit);
             assertTailJudgement(HitResult.Perfect);
             assertNoteJudgement(HitResult.IgnoreHit);
         }
@@ -90,6 +92,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Perfect);
+            assertTickJudgement(HitResult.LargeTickHit);
             assertTailJudgement(HitResult.Miss);
             assertNoteJudgement(HitResult.IgnoreMiss);
         }
@@ -108,6 +111,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Miss);
+            assertTickJudgement(HitResult.LargeTickMiss);
             assertTailJudgement(HitResult.Miss);
         }
 
@@ -125,6 +129,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Miss);
+            assertTickJudgement(HitResult.LargeTickMiss);
             assertTailJudgement(HitResult.Miss);
         }
 
@@ -144,6 +149,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Perfect);
+            assertTickJudgement(HitResult.LargeTickHit);
             assertTailJudgement(HitResult.Miss);
         }
 
@@ -163,6 +169,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Perfect);
+            assertTickJudgement(HitResult.LargeTickHit);
             assertTailJudgement(HitResult.Perfect);
         }
 
@@ -181,33 +188,10 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Perfect);
+            assertTickJudgement(HitResult.LargeTickMiss);
             assertTailJudgement(HitResult.Miss);
         }
 
-        /// <summary>
-        ///     -----[           ]-----
-        ///          xox         o
-        /// </summary>
-        [Test]
-        public void TestPressAtStartThenReleaseAndImmediatelyRepress()
-        {
-            performTest(new List<ReplayFrame>
-            {
-                new ManiaReplayFrame(time_head, ManiaAction.Key1),
-                new ManiaReplayFrame(time_head + 1),
-                new ManiaReplayFrame(time_head + 2, ManiaAction.Key1),
-                new ManiaReplayFrame(time_tail),
-            });
-
-            assertHeadJudgement(HitResult.Perfect);
-            // judgement combo offset by perfect bonus judgement. see logic in DrawableNote.CheckForResult.
-            assertComboAtJudgement(1, 1);
-            assertTailJudgement(HitResult.Meh);
-            assertComboAtJudgement(2, 0);
-            // judgement combo offset by perfect bonus judgement. see logic in DrawableNote.CheckForResult.
-            assertComboAtJudgement(4, 1);
-        }
-
         /// <summary>
         ///     -----[           ]-----
         ///          xo  x               o
@@ -224,6 +208,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Perfect);
+            assertTickJudgement(HitResult.LargeTickHit);
             assertTailJudgement(HitResult.Miss);
         }
 
@@ -243,6 +228,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Perfect);
+            assertTickJudgement(HitResult.LargeTickHit);
             assertTailJudgement(HitResult.Meh);
         }
 
@@ -260,6 +246,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Miss);
+            assertTickJudgement(HitResult.LargeTickHit);
             assertTailJudgement(HitResult.Miss);
         }
 
@@ -277,6 +264,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Miss);
+            assertTickJudgement(HitResult.LargeTickHit);
             assertTailJudgement(HitResult.Meh);
         }
 
@@ -370,6 +358,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             }, beatmap);
 
             assertHeadJudgement(HitResult.Miss);
+            assertTickJudgement(HitResult.LargeTickMiss);
             assertTailJudgement(HitResult.Miss);
 
             assertHitObjectJudgement(note, HitResult.Good);
@@ -382,8 +371,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         [Test]
         public void TestPressAndReleaseJustAfterTailWithNearbyNote()
         {
-            // Next note within tail lenience
-            Note note = new Note { StartTime = time_tail + 50 };
+            Note note;
 
             var beatmap = new Beatmap<ManiaHitObject>
             {
@@ -395,7 +383,13 @@ namespace osu.Game.Rulesets.Mania.Tests
                         Duration = time_tail - time_head,
                         Column = 0,
                     },
-                    note
+                    {
+                        // Next note within tail lenience
+                        note = new Note
+                        {
+                            StartTime = time_tail + 50
+                        }
+                    }
                 },
                 BeatmapInfo =
                 {
@@ -411,6 +405,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             }, beatmap);
 
             assertHeadJudgement(HitResult.Miss);
+            assertTickJudgement(HitResult.LargeTickMiss);
             assertTailJudgement(HitResult.Miss);
 
             assertHitObjectJudgement(note, HitResult.Great);
@@ -430,6 +425,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Miss);
+            assertTickJudgement(HitResult.LargeTickMiss);
             assertTailJudgement(HitResult.Meh);
         }
 
@@ -480,6 +476,42 @@ namespace osu.Game.Rulesets.Mania.Tests
                                                                        .All(j => j.Type.IsHit()));
         }
 
+        [Test]
+        public void TestHitTailBeforeLastTick()
+        {
+            const int tick_rate = 8;
+            const double tick_spacing = TimingControlPoint.DEFAULT_BEAT_LENGTH / tick_rate;
+            const double time_last_tick = time_head + tick_spacing * (int)((time_tail - time_head) / tick_spacing - 1);
+
+            var beatmap = new Beatmap<ManiaHitObject>
+            {
+                HitObjects =
+                {
+                    new HoldNote
+                    {
+                        StartTime = time_head,
+                        Duration = time_tail - time_head,
+                        Column = 0,
+                    }
+                },
+                BeatmapInfo =
+                {
+                    Difficulty = new BeatmapDifficulty { SliderTickRate = tick_rate },
+                    Ruleset = new ManiaRuleset().RulesetInfo
+                },
+            };
+
+            performTest(new List<ReplayFrame>
+            {
+                new ManiaReplayFrame(time_head, ManiaAction.Key1),
+                new ManiaReplayFrame(time_last_tick - 5)
+            }, beatmap);
+
+            assertHeadJudgement(HitResult.Perfect);
+            assertLastTickJudgement(HitResult.LargeTickMiss);
+            assertTailJudgement(HitResult.Ok);
+        }
+
         [Test]
         public void TestZeroLength()
         {
@@ -519,8 +551,11 @@ namespace osu.Game.Rulesets.Mania.Tests
         private void assertNoteJudgement(HitResult result)
             => AddAssert($"hold note judged as {result}", () => judgementResults.Single(j => j.HitObject is HoldNote).Type, () => Is.EqualTo(result));
 
-        private void assertComboAtJudgement(int judgementIndex, int combo)
-            => AddAssert($"combo at judgement {judgementIndex} is {combo}", () => judgementResults.ElementAt(judgementIndex).ComboAfterJudgement, () => Is.EqualTo(combo));
+        private void assertTickJudgement(HitResult result)
+            => AddAssert($"any tick judged as {result}", () => judgementResults.Where(j => j.HitObject is HoldNoteTick).Select(j => j.Type), () => Does.Contain(result));
+
+        private void assertLastTickJudgement(HitResult result)
+            => AddAssert($"last tick judged as {result}", () => judgementResults.Last(j => j.HitObject is HoldNoteTick).Type, () => Is.EqualTo(result));
 
         private ScoreAccessibleReplayPlayer currentPlayer = null!;
 

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

@@ -54,7 +54,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             AddAssert("all objects perfectly judged",
                 () => judgementResults.Select(result => result.Type),
                 () => Is.EquivalentTo(judgementResults.Select(result => result.Judgement.MaxResult)));
-            AddAssert("score is correct", () => currentPlayer.ScoreProcessor.TotalScore.Value, () => Is.EqualTo(1_000_030));
+            AddAssert("score is 1 million", () => currentPlayer.ScoreProcessor.TotalScore.Value, () => Is.EqualTo(1_000_000));
         }
 
         [Test]
@@ -87,7 +87,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             AddAssert("all objects perfectly judged",
                 () => judgementResults.Select(result => result.Type),
                 () => Is.EquivalentTo(judgementResults.Select(result => result.Judgement.MaxResult)));
-            AddAssert("score is correct", () => currentPlayer.ScoreProcessor.TotalScore.Value, () => Is.EqualTo(1_000_040));
+            AddAssert("score is 1 million", () => currentPlayer.ScoreProcessor.TotalScore.Value, () => Is.EqualTo(1_000_000));
         }
 
         private void performTest(List<ManiaHitObject> hitObjects, List<ReplayFrame> frames)

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

@@ -1,175 +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 NUnit.Framework;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Mania.Beatmaps;
-using osu.Game.Rulesets.Mania.Judgements;
-using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.Mania.Scoring;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Tests.Visual.Gameplay;
-
-namespace osu.Game.Rulesets.Mania.Tests
-{
-    [TestFixture]
-    public partial class TestSceneScoring : ScoringTestScene
-    {
-        protected override IBeatmap CreateBeatmap(int maxCombo)
-        {
-            var beatmap = new ManiaBeatmap(new StageDefinition(5));
-            for (int i = 0; i < maxCombo; ++i)
-                beatmap.HitObjects.Add(new Note());
-            return beatmap;
-        }
-
-        protected override IScoringAlgorithm CreateScoreV1() => new ScoreV1(MaxCombo.Value);
-        protected override IScoringAlgorithm CreateScoreV2(int maxCombo) => new ScoreV2(maxCombo);
-        protected override ProcessorBasedScoringAlgorithm CreateScoreAlgorithm(IBeatmap beatmap, ScoringMode mode) => new ManiaProcessorBasedScoringAlgorithm(beatmap, mode);
-
-        [Test]
-        public void TestBasicScenarios()
-        {
-            AddStep("set max combo to 100", () => MaxCombo.Value = 100);
-            AddStep("set perfect score", () =>
-            {
-                NonPerfectLocations.Clear();
-                MissLocations.Clear();
-            });
-            AddStep("set score with misses", () =>
-            {
-                NonPerfectLocations.Clear();
-                MissLocations.Clear();
-                MissLocations.AddRange(new[] { 24d, 49 });
-            });
-            AddStep("set score with misses and OKs", () =>
-            {
-                NonPerfectLocations.Clear();
-                MissLocations.Clear();
-
-                NonPerfectLocations.AddRange(new[] { 9d, 19, 29, 39, 59, 69, 79, 89, 99 });
-                MissLocations.AddRange(new[] { 24d, 49 });
-            });
-        }
-
-        private class ScoreV1 : IScoringAlgorithm
-        {
-            private int currentCombo;
-            private double comboAddition = 100;
-            private double totalScoreDouble;
-            private readonly double scoreMultiplier;
-
-            public ScoreV1(int maxCombo)
-            {
-                scoreMultiplier = 500000d / maxCombo;
-            }
-
-            public void ApplyHit() => applyHitV1(320, add => add + 2, 32);
-            public void ApplyNonPerfect() => applyHitV1(100, add => add - 24, 8);
-            public void ApplyMiss() => applyHitV1(0, _ => -56, 0);
-
-            private void applyHitV1(int scoreIncrease, Func<double, double> comboAdditionFunc, int delta)
-            {
-                comboAddition = comboAdditionFunc(comboAddition);
-                if (currentCombo != 0 && currentCombo % 384 == 0)
-                    comboAddition = 100;
-                comboAddition = Math.Max(0, Math.Min(comboAddition, 100));
-                double scoreIncreaseD = Math.Sqrt(comboAddition) * delta * scoreMultiplier / 320;
-
-                TotalScore = (long)totalScoreDouble;
-
-                scoreIncreaseD += scoreIncrease * scoreMultiplier / 320;
-                scoreIncrease = (int)scoreIncreaseD;
-
-                TotalScore += scoreIncrease;
-                totalScoreDouble += scoreIncreaseD;
-
-                if (scoreIncrease > 0)
-                    currentCombo++;
-            }
-
-            public long TotalScore { get; private set; }
-        }
-
-        private class ScoreV2 : IScoringAlgorithm
-        {
-            private int currentCombo;
-            private double comboPortion;
-            private double currentBaseScore;
-            private double maxBaseScore;
-            private int currentHits;
-
-            private readonly double comboPortionMax;
-            private readonly int maxCombo;
-
-            private const double combo_base = 4;
-
-            public ScoreV2(int maxCombo)
-            {
-                this.maxCombo = maxCombo;
-
-                for (int i = 0; i < this.maxCombo; i++)
-                    ApplyHit();
-
-                comboPortionMax = comboPortion;
-
-                currentCombo = 0;
-                comboPortion = 0;
-                currentBaseScore = 0;
-                maxBaseScore = 0;
-                currentHits = 0;
-            }
-
-            public void ApplyHit() => applyHitV2(305, 300);
-            public void ApplyNonPerfect() => applyHitV2(100, 100);
-
-            private void applyHitV2(int hitValue, int baseHitValue)
-            {
-                maxBaseScore += 305;
-                currentBaseScore += hitValue;
-                comboPortion += baseHitValue * Math.Min(Math.Max(0.5, Math.Log(++currentCombo, combo_base)), Math.Log(400, combo_base));
-
-                currentHits++;
-            }
-
-            public void ApplyMiss()
-            {
-                currentHits++;
-                maxBaseScore += 305;
-                currentCombo = 0;
-            }
-
-            public long TotalScore
-            {
-                get
-                {
-                    float accuracy = (float)(currentBaseScore / maxBaseScore);
-
-                    return (int)Math.Round
-                    (
-                        200000 * comboPortion / comboPortionMax +
-                        800000 * Math.Pow(accuracy, 2 + 2 * accuracy) * ((double)currentHits / maxCombo)
-                    );
-                }
-            }
-        }
-
-        private class ManiaProcessorBasedScoringAlgorithm : ProcessorBasedScoringAlgorithm
-        {
-            public ManiaProcessorBasedScoringAlgorithm(IBeatmap beatmap, ScoringMode mode)
-                : base(beatmap, mode)
-            {
-            }
-
-            protected override ScoreProcessor CreateScoreProcessor() => new ManiaScoreProcessor();
-
-            protected override JudgementResult CreatePerfectJudgementResult() => new JudgementResult(new Note(), new ManiaJudgement()) { Type = HitResult.Perfect };
-
-            protected override JudgementResult CreateNonPerfectJudgementResult() => new JudgementResult(new Note(), new ManiaJudgement()) { Type = HitResult.Ok };
-
-            protected override JudgementResult CreateMissJudgementResult() => new JudgementResult(new Note(), new ManiaJudgement()) { Type = HitResult.Miss };
-        }
-    }
-}

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

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

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

@@ -14,7 +14,6 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Mania.Beatmaps.Patterns;
 using osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy;
-using osu.Game.Rulesets.Scoring.Legacy;
 using osu.Game.Utils;
 using osuTK;
 
@@ -44,41 +43,39 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             : base(beatmap, ruleset)
         {
             IsForCurrentRuleset = beatmap.BeatmapInfo.Ruleset.Equals(ruleset.RulesetInfo);
-            TargetColumns = GetColumnCount(LegacyBeatmapConversionDifficultyInfo.FromBeatmap(beatmap));
 
-            if (IsForCurrentRuleset && TargetColumns > ManiaRuleset.MAX_STAGE_KEYS)
+            double roundedCircleSize = Math.Round(beatmap.Difficulty.CircleSize);
+            double roundedOverallDifficulty = Math.Round(beatmap.Difficulty.OverallDifficulty);
+
+            if (IsForCurrentRuleset)
             {
-                TargetColumns /= 2;
-                Dual = true;
+                TargetColumns = GetColumnCountForNonConvert(beatmap.BeatmapInfo);
+
+                if (TargetColumns > ManiaRuleset.MAX_STAGE_KEYS)
+                {
+                    TargetColumns /= 2;
+                    Dual = true;
+                }
+            }
+            else
+            {
+                float percentSliderOrSpinner = (float)beatmap.HitObjects.Count(h => h is IHasDuration) / beatmap.HitObjects.Count;
+                if (percentSliderOrSpinner < 0.2)
+                    TargetColumns = 7;
+                else if (percentSliderOrSpinner < 0.3 || roundedCircleSize >= 5)
+                    TargetColumns = roundedOverallDifficulty > 5 ? 7 : 6;
+                else if (percentSliderOrSpinner > 0.6)
+                    TargetColumns = roundedOverallDifficulty > 4 ? 5 : 4;
+                else
+                    TargetColumns = Math.Max(4, Math.Min((int)roundedOverallDifficulty + 1, 7));
             }
 
             originalTargetColumns = TargetColumns;
         }
 
-        public static int GetColumnCount(LegacyBeatmapConversionDifficultyInfo difficulty)
+        public static int GetColumnCountForNonConvert(BeatmapInfo beatmapInfo)
         {
-            if (new ManiaRuleset().RulesetInfo.Equals(difficulty.SourceRuleset))
-                return GetColumnCountForNonConvert(difficulty);
-
-            double roundedCircleSize = Math.Round(difficulty.CircleSize);
-            double roundedOverallDifficulty = Math.Round(difficulty.OverallDifficulty);
-
-            int countSliderOrSpinner = difficulty.TotalObjectCount - difficulty.CircleCount;
-            float percentSpecialObjects = (float)countSliderOrSpinner / difficulty.TotalObjectCount;
-
-            if (percentSpecialObjects < 0.2)
-                return 7;
-            if (percentSpecialObjects < 0.3 || roundedCircleSize >= 5)
-                return roundedOverallDifficulty > 5 ? 7 : 6;
-            if (percentSpecialObjects > 0.6)
-                return roundedOverallDifficulty > 4 ? 5 : 4;
-
-            return Math.Max(4, Math.Min((int)roundedOverallDifficulty + 1, 7));
-        }
-
-        public static int GetColumnCountForNonConvert(IBeatmapDifficultyInfo difficulty)
-        {
-            double roundedCircleSize = Math.Round(difficulty.CircleSize);
+            double roundedCircleSize = Math.Round(beatmapInfo.Difficulty.CircleSize);
             return (int)Math.Max(1, roundedCircleSize);
         }
 

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

@@ -10,11 +10,10 @@ using System.Linq;
 using osu.Framework.Extensions.EnumExtensions;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Utils;
 
 namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
@@ -51,9 +50,10 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(hitObject.StartTime);
 
             double beatLength;
-
-            if (hitObject is IHasSliderVelocity hasSliderVelocity)
-                beatLength = LegacyRulesetExtensions.GetPrecisionAdjustedBeatLength(hasSliderVelocity, timingPoint, ManiaRuleset.SHORT_NAME);
+            if (hitObject.LegacyBpmMultiplier.HasValue)
+                beatLength = timingPoint.BeatLength * hitObject.LegacyBpmMultiplier.Value;
+            else if (hitObject is IHasSliderVelocity hasSliderVelocity)
+                beatLength = timingPoint.BeatLength / hasSliderVelocity.SliderVelocity;
             else
                 beatLength = timingPoint.BeatLength;
 

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

@@ -31,9 +31,13 @@ namespace osu.Game.Rulesets.Mania.Difficulty
 
         public override int Version => 20220902;
 
+        private readonly IWorkingBeatmap workingBeatmap;
+
         public ManiaDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
+            workingBeatmap = beatmap;
+
             isForCurrentRuleset = beatmap.BeatmapInfo.Ruleset.MatchesOnlineID(ruleset);
             originalOverallDifficulty = beatmap.BeatmapInfo.Difficulty.OverallDifficulty;
         }
@@ -56,6 +60,15 @@ namespace osu.Game.Rulesets.Mania.Difficulty
                 MaxCombo = beatmap.HitObjects.Sum(maxComboForObject),
             };
 
+            if (ComputeLegacyScoringValues)
+            {
+                ManiaLegacyScoreSimulator sv1Simulator = new ManiaLegacyScoreSimulator();
+                sv1Simulator.Simulate(workingBeatmap, beatmap, mods);
+                attributes.LegacyAccuracyScore = sv1Simulator.AccuracyScore;
+                attributes.LegacyComboScore = sv1Simulator.ComboScore;
+                attributes.LegacyBonusScoreRatio = sv1Simulator.BonusScoreRatio;
+            }
+
             return attributes;
         }
 

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

@@ -4,63 +4,25 @@
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Scoring.Legacy;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Difficulty
 {
     internal class ManiaLegacyScoreSimulator : ILegacyScoreSimulator
     {
-        public LegacyScoreAttributes Simulate(IWorkingBeatmap workingBeatmap, IBeatmap playableBeatmap)
+        public int AccuracyScore => 0;
+        public int ComboScore { get; private set; }
+        public double BonusScoreRatio => 0;
+
+        public void Simulate(IWorkingBeatmap workingBeatmap, IBeatmap playableBeatmap, IReadOnlyList<Mod> mods)
         {
-            return new LegacyScoreAttributes { ComboScore = 1000000 };
-        }
+            double multiplier = mods.Where(m => m is not (ModHidden or ModHardRock or ModDoubleTime or ModFlashlight or ManiaModFadeIn))
+                                    .Select(m => m.ScoreMultiplier)
+                                    .Aggregate(1.0, (c, n) => c * n);
 
-        public double GetLegacyScoreMultiplier(IReadOnlyList<Mod> mods, LegacyBeatmapConversionDifficultyInfo difficulty)
-        {
-            bool scoreV2 = mods.Any(m => m is ModScoreV2);
-
-            double multiplier = 1.0;
-
-            foreach (var mod in mods)
-            {
-                switch (mod)
-                {
-                    case ManiaModNoFail:
-                        multiplier *= scoreV2 ? 1.0 : 0.5;
-                        break;
-
-                    case ManiaModEasy:
-                        multiplier *= 0.5;
-                        break;
-
-                    case ManiaModHalfTime:
-                    case ManiaModDaycore:
-                        multiplier *= 0.5;
-                        break;
-                }
-            }
-
-            if (new ManiaRuleset().RulesetInfo.Equals(difficulty.SourceRuleset))
-                return multiplier;
-
-            // Apply key mod multipliers.
-
-            int originalColumns = ManiaBeatmapConverter.GetColumnCount(difficulty);
-            int actualColumns = originalColumns;
-
-            actualColumns = mods.OfType<ManiaKeyMod>().SingleOrDefault()?.KeyCount ?? actualColumns;
-            if (mods.Any(m => m is ManiaModDualStages))
-                actualColumns *= 2;
-
-            if (actualColumns > originalColumns)
-                multiplier *= 0.9;
-            else if (actualColumns < originalColumns)
-                multiplier *= 0.9 - 0.04 * (originalColumns - actualColumns);
-
-            return multiplier;
+            ComboScore = (int)(1000000 * multiplier);
         }
     }
 }

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

@@ -44,8 +44,8 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 
             if (Column != null)
             {
-                headPiece.Y = Parent!.ToLocalSpace(Column.ScreenSpacePositionAtTime(HitObject.StartTime)).Y;
-                tailPiece.Y = Parent!.ToLocalSpace(Column.ScreenSpacePositionAtTime(HitObject.EndTime)).Y;
+                headPiece.Y = Parent.ToLocalSpace(Column.ScreenSpacePositionAtTime(HitObject.StartTime)).Y;
+                tailPiece.Y = Parent.ToLocalSpace(Column.ScreenSpacePositionAtTime(HitObject.EndTime)).Y;
 
                 switch (scrollingInfo.Direction.Value)
                 {

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

@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             foreach (var child in InternalChildren)
                 child.Anchor = child.Origin = anchor;
 
-            Position = Parent!.ToLocalSpace(HitObjectContainer.ScreenSpacePositionAtTime(HitObject.StartTime)) - AnchorPosition;
+            Position = Parent.ToLocalSpace(HitObjectContainer.ScreenSpacePositionAtTime(HitObject.StartTime)) - AnchorPosition;
             Width = HitObjectContainer.DrawWidth;
         }
     }

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

@@ -2,22 +2,18 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osuTK;
 using osu.Game.Beatmaps;
-using osu.Game.Configuration;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
-using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
-    public partial class DrawableManiaEditorRuleset : DrawableManiaRuleset, ISupportConstantAlgorithmToggle
+    public partial class DrawableManiaEditorRuleset : DrawableManiaRuleset
     {
-        public BindableBool ShowSpeedChanges { get; } = new BindableBool();
-
         public new IScrollingInfo ScrollingInfo => base.ScrollingInfo;
 
         public DrawableManiaEditorRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod>? mods)
@@ -25,13 +21,6 @@ namespace osu.Game.Rulesets.Mania.Edit
         {
         }
 
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            ShowSpeedChanges.BindValueChanged(showChanges => VisualisationMethod = showChanges.NewValue ? ScrollVisualisationMethod.Sequential : ScrollVisualisationMethod.Constant, true);
-        }
-
         protected override Playfield CreatePlayfield() => new ManiaEditorPlayfield(Beatmap.Stages)
         {
             Anchor = Anchor.Centre,

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

@@ -1,23 +1,204 @@
 // 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.Graphics.Containers;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Caching;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.UI;
-using osu.Game.Screens.Edit.Compose.Components;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Screens.Edit;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
-    public partial class ManiaBeatSnapGrid : BeatSnapGrid
+    /// <summary>
+    /// A grid which displays coloured beat divisor lines in proximity to the selection or placement cursor.
+    /// </summary>
+    public partial class ManiaBeatSnapGrid : Component
     {
-        protected override IEnumerable<Container> GetTargetContainers(HitObjectComposer composer)
+        private const double visible_range = 750;
+
+        /// <summary>
+        /// The range of time values of the current selection.
+        /// </summary>
+        public (double start, double end)? SelectionTimeRange
         {
-            return ((ManiaPlayfield)composer.Playfield)
-                   .Stages
-                   .SelectMany(stage => stage.Columns)
-                   .Select(column => column.UnderlayElements);
+            set
+            {
+                if (value == selectionTimeRange)
+                    return;
+
+                selectionTimeRange = value;
+                lineCache.Invalidate();
+            }
+        }
+
+        [Resolved]
+        private EditorBeatmap beatmap { get; set; } = null!;
+
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
+        [Resolved]
+        private BindableBeatDivisor beatDivisor { get; set; } = null!;
+
+        private readonly List<ScrollingHitObjectContainer> grids = new List<ScrollingHitObjectContainer>();
+
+        private readonly Cached lineCache = new Cached();
+
+        private (double start, double end)? selectionTimeRange;
+
+        [BackgroundDependencyLoader]
+        private void load(HitObjectComposer composer)
+        {
+            foreach (var stage in ((ManiaPlayfield)composer.Playfield).Stages)
+            {
+                foreach (var column in stage.Columns)
+                {
+                    var lineContainer = new ScrollingHitObjectContainer();
+
+                    grids.Add(lineContainer);
+                    column.UnderlayElements.Add(lineContainer);
+                }
+            }
+
+            beatDivisor.BindValueChanged(_ => createLines(), true);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (!lineCache.IsValid)
+            {
+                lineCache.Validate();
+                createLines();
+            }
+        }
+
+        private readonly Stack<DrawableGridLine> availableLines = new Stack<DrawableGridLine>();
+
+        private void createLines()
+        {
+            foreach (var grid in grids)
+            {
+                foreach (var line in grid.Objects.OfType<DrawableGridLine>())
+                    availableLines.Push(line);
+
+                grid.Clear();
+            }
+
+            if (selectionTimeRange == null)
+                return;
+
+            var range = selectionTimeRange.Value;
+
+            var timingPoint = beatmap.ControlPointInfo.TimingPointAt(range.start - visible_range);
+
+            double time = timingPoint.Time;
+            int beat = 0;
+
+            // progress time until in the visible range.
+            while (time < range.start - visible_range)
+            {
+                time += timingPoint.BeatLength / beatDivisor.Value;
+                beat++;
+            }
+
+            while (time < range.end + visible_range)
+            {
+                var nextTimingPoint = beatmap.ControlPointInfo.TimingPointAt(time);
+
+                // switch to the next timing point if we have reached it.
+                if (nextTimingPoint.Time > timingPoint.Time)
+                {
+                    beat = 0;
+                    time = nextTimingPoint.Time;
+                    timingPoint = nextTimingPoint;
+                }
+
+                Color4 colour = BindableBeatDivisor.GetColourFor(
+                    BindableBeatDivisor.GetDivisorForBeatIndex(beat, beatDivisor.Value), colours);
+
+                foreach (var grid in grids)
+                {
+                    if (!availableLines.TryPop(out var line))
+                        line = new DrawableGridLine();
+
+                    line.HitObject.StartTime = time;
+                    line.Colour = colour;
+
+                    grid.Add(line);
+                }
+
+                beat++;
+                time += timingPoint.BeatLength / beatDivisor.Value;
+            }
+
+            foreach (var grid in grids)
+            {
+                // required to update ScrollingHitObjectContainer's cache.
+                grid.UpdateSubTree();
+
+                foreach (var line in grid.Objects.OfType<DrawableGridLine>())
+                {
+                    time = line.HitObject.StartTime;
+
+                    if (time >= range.start && time <= range.end)
+                        line.Alpha = 1;
+                    else
+                    {
+                        double timeSeparation = time < range.start ? range.start - time : time - range.end;
+                        line.Alpha = (float)Math.Max(0, 1 - timeSeparation / visible_range);
+                    }
+                }
+            }
+        }
+
+        private partial class DrawableGridLine : DrawableHitObject
+        {
+            [Resolved]
+            private IScrollingInfo scrollingInfo { get; set; } = null!;
+
+            private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
+
+            public DrawableGridLine()
+                : base(new HitObject())
+            {
+                RelativeSizeAxes = Axes.X;
+                Height = 2;
+
+                AddInternal(new Box { RelativeSizeAxes = Axes.Both });
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                direction.BindTo(scrollingInfo.Direction);
+                direction.BindValueChanged(onDirectionChanged, true);
+            }
+
+            private void onDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
+            {
+                Origin = Anchor = direction.NewValue == ScrollingDirection.Up
+                    ? Anchor.TopLeft
+                    : Anchor.BottomLeft;
+            }
+
+            protected override void UpdateInitialTransforms()
+            {
+                // don't perform any fading – we are handling that ourselves.
+                LifetimeEnd = HitObject.StartTime + visible_range;
+            }
         }
     }
 }

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

@@ -5,12 +5,15 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Screens.Edit.Compose.Components;
@@ -18,15 +21,35 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
-    public partial class ManiaHitObjectComposer : ScrollingHitObjectComposer<ManiaHitObject>
+    public partial class ManiaHitObjectComposer : HitObjectComposer<ManiaHitObject>
     {
         private DrawableManiaEditorRuleset drawableRuleset;
+        private ManiaBeatSnapGrid beatSnapGrid;
+        private InputManager inputManager;
 
         public ManiaHitObjectComposer(Ruleset ruleset)
             : base(ruleset)
         {
         }
 
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            AddInternal(beatSnapGrid = new ManiaBeatSnapGrid());
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            inputManager = GetContainingInputManager();
+        }
+
+        private DependencyContainer dependencies;
+
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+            => dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
+
         public new ManiaPlayfield Playfield => ((ManiaPlayfield)drawableRuleset.Playfield);
 
         public IScrollingInfo ScrollingInfo => drawableRuleset.ScrollingInfo;
@@ -34,20 +57,48 @@ namespace osu.Game.Rulesets.Mania.Edit
         protected override Playfield PlayfieldAtScreenSpacePosition(Vector2 screenSpacePosition) =>
             Playfield.GetColumnByPosition(screenSpacePosition);
 
-        protected override DrawableRuleset<ManiaHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods) =>
+        protected override DrawableRuleset<ManiaHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods = null)
+        {
             drawableRuleset = new DrawableManiaEditorRuleset(ruleset, beatmap, mods);
 
+            // This is the earliest we can cache the scrolling info to ourselves, before masks are added to the hierarchy and inject it
+            dependencies.CacheAs(drawableRuleset.ScrollingInfo);
+
+            return drawableRuleset;
+        }
+
         protected override ComposeBlueprintContainer CreateBlueprintContainer()
             => new ManiaBlueprintContainer(this);
 
-        protected override BeatSnapGrid CreateBeatSnapGrid() => new ManiaBeatSnapGrid();
-
         protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
         {
             new NoteCompositionTool(),
             new HoldNoteCompositionTool()
         };
 
+        protected override void UpdateAfterChildren()
+        {
+            base.UpdateAfterChildren();
+
+            if (BlueprintContainer.CurrentTool is SelectTool)
+            {
+                if (EditorBeatmap.SelectedHitObjects.Any())
+                {
+                    beatSnapGrid.SelectionTimeRange = (EditorBeatmap.SelectedHitObjects.Min(h => h.StartTime), EditorBeatmap.SelectedHitObjects.Max(h => h.GetEndTime()));
+                }
+                else
+                    beatSnapGrid.SelectionTimeRange = null;
+            }
+            else
+            {
+                var result = FindSnappedPositionAndTime(inputManager.CurrentState.Mouse.Position);
+                if (result.Time is double time)
+                    beatSnapGrid.SelectionTimeRange = (time, time);
+                else
+                    beatSnapGrid.SelectionTimeRange = null;
+            }
+        }
+
         public override string ConvertSelectionToString()
             => string.Join(',', EditorBeatmap.SelectedHitObjects.Cast<ManiaHitObject>().OrderBy(h => h.StartTime).Select(h => $"{h.StartTime}|{h.Column}"));
     }

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

@@ -1,13 +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.Game.Rulesets.Scoring;
-
-namespace osu.Game.Rulesets.Mania.Judgements
-{
-    public class HoldNoteBodyJudgement : ManiaJudgement
-    {
-        public override HitResult MaxResult => HitResult.IgnoreHit;
-        public override HitResult MinResult => HitResult.ComboBreak;
-    }
-}

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

@@ -0,0 +1,12 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Mania.Judgements
+{
+    public class HoldNoteTickJudgement : ManiaJudgement
+    {
+        public override HitResult MaxResult => HitResult.LargeTickHit;
+    }
+}

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

@@ -12,6 +12,12 @@ namespace osu.Game.Rulesets.Mania.Judgements
         {
             switch (result)
             {
+                case HitResult.LargeTickHit:
+                    return DEFAULT_MAX_HEALTH_INCREASE * 0.1;
+
+                case HitResult.LargeTickMiss:
+                    return -DEFAULT_MAX_HEALTH_INCREASE * 0.1;
+
                 case HitResult.Meh:
                     return -DEFAULT_MAX_HEALTH_INCREASE * 0.5;
 

osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs

@@ -15,7 +15,7 @@ namespace osu.Game.Rulesets.Mania
 
         public bool Matches(BeatmapInfo beatmapInfo)
         {
-            return !keys.HasFilter || (beatmapInfo.Ruleset.OnlineID == new ManiaRuleset().LegacyID && keys.IsInRange(ManiaBeatmapConverter.GetColumnCountForNonConvert(beatmapInfo.Difficulty)));
+            return !keys.HasFilter || (beatmapInfo.Ruleset.OnlineID == new ManiaRuleset().LegacyID && keys.IsInRange(ManiaBeatmapConverter.GetColumnCountForNonConvert(beatmapInfo)));
         }
 
         public bool TryParseCustomKeywordCriteria(string key, Operator op, string value)

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -33,7 +33,6 @@ using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.Scoring.Legacy;
 using osu.Game.Rulesets.UI;
 using osu.Game.Scoring;
 using osu.Game.Screens.Edit.Setup;
@@ -255,6 +254,16 @@ namespace osu.Game.Rulesets.Mania
                 case ModType.Conversion:
                     return new Mod[]
                     {
+                        new MultiMod(new ManiaModKey4(),
+                            new ManiaModKey5(),
+                            new ManiaModKey6(),
+                            new ManiaModKey7(),
+                            new ManiaModKey8(),
+                            new ManiaModKey9(),
+                            new ManiaModKey10(),
+                            new ManiaModKey1(),
+                            new ManiaModKey2(),
+                            new ManiaModKey3()),
                         new ManiaModRandom(),
                         new ManiaModDualStages(),
                         new ManiaModMirror(),
@@ -262,19 +271,7 @@ namespace osu.Game.Rulesets.Mania
                         new ManiaModClassic(),
                         new ManiaModInvert(),
                         new ManiaModConstantSpeed(),
-                        new ManiaModHoldOff(),
-                        new MultiMod(
-                            new ManiaModKey1(),
-                            new ManiaModKey2(),
-                            new ManiaModKey3(),
-                            new ManiaModKey4(),
-                            new ManiaModKey5(),
-                            new ManiaModKey6(),
-                            new ManiaModKey7(),
-                            new ManiaModKey8(),
-                            new ManiaModKey9(),
-                            new ManiaModKey10()
-                        ),
+                        new ManiaModHoldOff()
                     };
 
                 case ModType.Automation:
@@ -388,11 +385,21 @@ namespace osu.Game.Rulesets.Mania
                 HitResult.Ok,
                 HitResult.Meh,
 
-                // HitResult.SmallBonus is used for awarding perfect bonus score but is not included here as
-                // it would be a bit redundant to show this to the user.
+                HitResult.LargeTickHit,
             };
         }
 
+        public override LocalisableString GetDisplayNameForHitResult(HitResult result)
+        {
+            switch (result)
+            {
+                case HitResult.LargeTickHit:
+                    return "hold tick";
+            }
+
+            return base.GetDisplayNameForHitResult(result);
+        }
+
         public override StatisticItem[] CreateStatisticsForScore(ScoreInfo score, IBeatmap playableBeatmap) => new[]
         {
             new StatisticItem("Performance Breakdown", () => new PerformanceBreakdownChart(score, playableBeatmap)

osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs

@@ -41,7 +41,6 @@ namespace osu.Game.Rulesets.Mania
                 },
                 new SettingsCheckbox
                 {
-                    Keywords = new[] { "color" },
                     LabelText = RulesetSettingsStrings.TimingBasedColouring,
                     Current = config.GetBindable<bool>(ManiaRulesetSetting.TimingBasedNoteColouring),
                 }

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

@@ -28,7 +28,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public void ApplyToDrawableRuleset(DrawableRuleset<ManiaHitObject> drawableRuleset)
         {
             var maniaRuleset = (DrawableManiaRuleset)drawableRuleset;
-            maniaRuleset.VisualisationMethod = ScrollVisualisationMethod.Constant;
+            maniaRuleset.ScrollMethod = ScrollVisualisationMethod.Constant;
         }
     }
 }

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

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

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

@@ -35,11 +35,10 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
         public DrawableHoldNoteHead Head => headContainer.Child;
         public DrawableHoldNoteTail Tail => tailContainer.Child;
-        public DrawableHoldNoteBody Body => bodyContainer.Child;
 
         private Container<DrawableHoldNoteHead> headContainer;
         private Container<DrawableHoldNoteTail> tailContainer;
-        private Container<DrawableHoldNoteBody> bodyContainer;
+        private Container<DrawableHoldNoteTick> tickContainer;
 
         private PausableSkinnableSound slidingSample;
 
@@ -61,7 +60,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         public double? HoldStartTime { get; private set; }
 
         /// <summary>
-        /// Used to decide whether to visually clamp the hold note to the judgement line.
+        /// Time at which the hold note has been broken, i.e. released too early, resulting in a reduced score.
+        /// </summary>
+        public double? HoldBrokenTime { get; private set; }
+
+        /// <summary>
+        /// Whether the hold note has been released potentially without having caused a break.
         /// </summary>
         private double? releaseTime;
 
@@ -99,7 +103,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                         headContainer = new Container<DrawableHoldNoteHead> { RelativeSizeAxes = Axes.Both }
                     }
                 },
-                bodyContainer = new Container<DrawableHoldNoteBody> { RelativeSizeAxes = Axes.Both },
                 bodyPiece = new SkinnableDrawable(new ManiaSkinComponentLookup(ManiaSkinComponents.HoldNoteBody), _ => new DefaultBodyPiece
                 {
                     RelativeSizeAxes = Axes.Both,
@@ -107,17 +110,15 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 {
                     RelativeSizeAxes = Axes.X
                 },
+                tickContainer = new Container<DrawableHoldNoteTick> { RelativeSizeAxes = Axes.Both },
                 tailContainer = new Container<DrawableHoldNoteTail> { RelativeSizeAxes = Axes.Both },
-                slidingSample = new PausableSkinnableSound
-                {
-                    Looping = true,
-                    MinimumSampleVolume = MINIMUM_SAMPLE_VOLUME,
-                }
+                slidingSample = new PausableSkinnableSound { Looping = true }
             });
 
             maskedContents.AddRange(new[]
             {
                 bodyPiece.CreateProxy(),
+                tickContainer.CreateProxy(),
                 tailContainer.CreateProxy(),
             });
         }
@@ -135,6 +136,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
             sizingContainer.Size = Vector2.One;
             HoldStartTime = null;
+            HoldBrokenTime = null;
             releaseTime = null;
         }
 
@@ -152,8 +154,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                     tailContainer.Child = tail;
                     break;
 
-                case DrawableHoldNoteBody body:
-                    bodyContainer.Child = body;
+                case DrawableHoldNoteTick tick:
+                    tickContainer.Add(tick);
                     break;
             }
         }
@@ -163,7 +165,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             base.ClearNestedHitObjects();
             headContainer.Clear(false);
             tailContainer.Clear(false);
-            bodyContainer.Clear(false);
+            tickContainer.Clear(false);
         }
 
         protected override DrawableHitObject CreateNestedHitObject(HitObject hitObject)
@@ -176,8 +178,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 case HeadNote head:
                     return new DrawableHoldNoteHead(head);
 
-                case HoldNoteBody body:
-                    return new DrawableHoldNoteBody(body);
+                case HoldNoteTick tick:
+                    return new DrawableHoldNoteTick(tick);
             }
 
             return base.CreateNestedHitObject(hitObject);
@@ -264,15 +266,20 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
             if (Tail.AllJudged)
             {
+                foreach (var tick in tickContainer)
+                {
+                    if (!tick.Judged)
+                        tick.MissForcefully();
+                }
+
                 if (Tail.IsHit)
                     ApplyResult(r => r.Type = r.Judgement.MaxResult);
                 else
                     MissForcefully();
             }
 
-            // Make sure that the hold note is fully judged by giving the body a judgement.
-            if (Tail.AllJudged && !Body.AllJudged)
-                Body.TriggerResult(Tail.IsHit);
+            if (Tail.Judged && !Tail.IsHit)
+                HoldBrokenTime = Time.Current;
         }
 
         public override void MissForcefully()
@@ -326,22 +333,22 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             if (e.Action != Action.Value)
                 return;
 
+            // Make sure a hold was started
+            if (HoldStartTime == null)
+                return;
+
             // do not run any of this logic when rewinding, as it inverts order of presses/releases.
             if ((Clock as IGameplayClock)?.IsRewinding == true)
                 return;
 
-            // When our action is released and we are in the middle of a hold, there's a chance that
-            // the user has released too early (before the tail).
-            //
-            // In such a case, we want to record this against the DrawableHoldNoteBody.
-            if (HoldStartTime != null)
-            {
-                Tail.UpdateResult();
-                Body.TriggerResult(Tail.IsHit);
+            Tail.UpdateResult();
+            endHold();
 
-                endHold();
-                releaseTime = Time.Current;
-            }
+            // If the key has been released too early, the user should not receive full score for the release
+            if (!Tail.IsHit)
+                HoldBrokenTime = Time.Current;
+
+            releaseTime = Time.Current;
         }
 
         private void endHold()

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

@@ -1,31 +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.
-
-#nullable disable
-
-namespace osu.Game.Rulesets.Mania.Objects.Drawables
-{
-    public partial class DrawableHoldNoteBody : DrawableManiaHitObject<HoldNoteBody>
-    {
-        public bool HasHoldBreak => AllJudged && !IsHit;
-
-        public override bool DisplayResult => false;
-
-        public DrawableHoldNoteBody()
-            : this(null)
-        {
-        }
-
-        public DrawableHoldNoteBody(HoldNoteBody hitObject)
-            : base(hitObject)
-        {
-        }
-
-        internal void TriggerResult(bool hit)
-        {
-            if (AllJudged) return;
-
-            ApplyResult(r => r.Type = hit ? r.Judgement.MaxResult : r.Judgement.MinResult);
-        }
-    }
-}

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

@@ -3,6 +3,7 @@
 
 #nullable disable
 
+using System.Diagnostics;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Scoring;
@@ -32,19 +33,33 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
         public void UpdateResult() => base.UpdateResult(true);
 
-        protected override void CheckForResult(bool userTriggered, double timeOffset) =>
-            // Factor in the release lenience
-            base.CheckForResult(userTriggered, timeOffset / TailNote.RELEASE_WINDOW_LENIENCE);
-
-        protected override HitResult GetCappedResult(HitResult result)
+        protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
-            // If the head wasn't hit or the hold note was broken, cap the max score to Meh.
-            bool hasComboBreak = !HoldNote.Head.IsHit || HoldNote.Body.HasHoldBreak;
+            Debug.Assert(HitObject.HitWindows != null);
 
-            if (result > HitResult.Meh && hasComboBreak)
-                return HitResult.Meh;
+            // Factor in the release lenience
+            timeOffset /= TailNote.RELEASE_WINDOW_LENIENCE;
 
-            return result;
+            if (!userTriggered)
+            {
+                if (!HitObject.HitWindows.CanBeHit(timeOffset))
+                    ApplyResult(r => r.Type = r.Judgement.MinResult);
+
+                return;
+            }
+
+            var result = HitObject.HitWindows.ResultFor(timeOffset);
+            if (result == HitResult.None)
+                return;
+
+            ApplyResult(r =>
+            {
+                // If the head wasn't hit or the hold note was broken, cap the max score to Meh.
+                if (result > HitResult.Meh && (!HoldNote.Head.IsHit || HoldNote.HoldBrokenTime != null))
+                    result = HitResult.Meh;
+
+                r.Type = result;
+            });
         }
 
         public override bool OnPressed(KeyBindingPressEvent<ManiaAction> e) => false; // Handled by the hold note

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

@@ -0,0 +1,110 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable disable
+
+using System;
+using System.Diagnostics;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
+using osu.Framework.Graphics.Shapes;
+
+namespace osu.Game.Rulesets.Mania.Objects.Drawables
+{
+    /// <summary>
+    /// Visualises a <see cref="HoldNoteTick"/> hit object.
+    /// </summary>
+    public partial class DrawableHoldNoteTick : DrawableManiaHitObject<HoldNoteTick>
+    {
+        /// <summary>
+        /// References the time at which the user started holding the hold note.
+        /// </summary>
+        private Func<double?> holdStartTime;
+
+        private Container glowContainer;
+
+        public DrawableHoldNoteTick()
+            : this(null)
+        {
+        }
+
+        public DrawableHoldNoteTick(HoldNoteTick hitObject)
+            : base(hitObject)
+        {
+            Anchor = Anchor.TopCentre;
+            Origin = Anchor.TopCentre;
+
+            RelativeSizeAxes = Axes.X;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            AddInternal(glowContainer = new CircularContainer
+            {
+                Anchor = Anchor.TopCentre,
+                Origin = Anchor.TopCentre,
+                RelativeSizeAxes = Axes.Both,
+                Masking = true,
+                Children = new[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Alpha = 0,
+                        AlwaysPresent = true
+                    }
+                }
+            });
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            AccentColour.BindValueChanged(colour =>
+            {
+                glowContainer.EdgeEffect = new EdgeEffectParameters
+                {
+                    Type = EdgeEffectType.Glow,
+                    Radius = 2f,
+                    Roundness = 15f,
+                    Colour = colour.NewValue.Opacity(0.3f)
+                };
+            }, true);
+        }
+
+        protected override void OnApply()
+        {
+            base.OnApply();
+
+            Debug.Assert(ParentHitObject != null);
+
+            var holdNote = (DrawableHoldNote)ParentHitObject;
+            holdStartTime = () => holdNote.HoldStartTime;
+        }
+
+        protected override void OnFree()
+        {
+            base.OnFree();
+
+            holdStartTime = null;
+        }
+
+        protected override void CheckForResult(bool userTriggered, double timeOffset)
+        {
+            if (Time.Current < HitObject.StartTime)
+                return;
+
+            double? startTime = holdStartTime?.Invoke();
+
+            if (startTime == null || startTime > HitObject.StartTime)
+                ApplyResult(r => r.Type = r.Judgement.MinResult);
+            else
+                ApplyResult(r => r.Type = r.Judgement.MaxResult);
+        }
+    }
+}

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

@@ -13,8 +13,6 @@ using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.Skinning.Default;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Screens.Edit;
@@ -40,8 +38,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
         private Drawable headPiece;
 
-        private DrawableNotePerfectBonus perfectBonus;
-
         public DrawableNote()
             : this(null)
         {
@@ -93,11 +89,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             if (!userTriggered)
             {
                 if (!HitObject.HitWindows.CanBeHit(timeOffset))
-                {
-                    perfectBonus.TriggerResult(false);
                     ApplyResult(r => r.Type = r.Judgement.MinResult);
-                }
-
                 return;
             }
 
@@ -105,23 +97,9 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             if (result == HitResult.None)
                 return;
 
-            result = GetCappedResult(result);
-
-            perfectBonus.TriggerResult(result == HitResult.Perfect);
             ApplyResult(r => r.Type = result);
         }
 
-        public override void MissForcefully()
-        {
-            perfectBonus.TriggerResult(false);
-            base.MissForcefully();
-        }
-
-        /// <summary>
-        /// Some objects in mania may want to limit the max result.
-        /// </summary>
-        protected virtual HitResult GetCappedResult(HitResult result) => result;
-
         public virtual bool OnPressed(KeyBindingPressEvent<ManiaAction> e)
         {
             if (e.Action != Action.Value)
@@ -137,32 +115,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
         }
 
-        protected override void AddNestedHitObject(DrawableHitObject hitObject)
-        {
-            switch (hitObject)
-            {
-                case DrawableNotePerfectBonus bonus:
-                    AddInternal(perfectBonus = bonus);
-                    break;
-            }
-        }
-
-        protected override void ClearNestedHitObjects()
-        {
-            RemoveInternal(perfectBonus, false);
-        }
-
-        protected override DrawableHitObject CreateNestedHitObject(HitObject hitObject)
-        {
-            switch (hitObject)
-            {
-                case NotePerfectBonus bonus:
-                    return new DrawableNotePerfectBonus(bonus);
-            }
-
-            return base.CreateNestedHitObject(hitObject);
-        }
-
         private void updateSnapColour()
         {
             if (beatmap == null || HitObject == null) return;

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

@@ -1,26 +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.
-
-namespace osu.Game.Rulesets.Mania.Objects.Drawables
-{
-    public partial class DrawableNotePerfectBonus : DrawableManiaHitObject<NotePerfectBonus>
-    {
-        public override bool DisplayResult => false;
-
-        public DrawableNotePerfectBonus()
-            : this(null!)
-        {
-        }
-
-        public DrawableNotePerfectBonus(NotePerfectBonus hitObject)
-            : base(hitObject)
-        {
-        }
-
-        /// <summary>
-        /// Apply a judgement result.
-        /// </summary>
-        /// <param name="hit">Whether this tick was reached.</param>
-        internal void TriggerResult(bool hit) => ApplyResult(r => r.Type = hit ? r.Judgement.MaxResult : r.Judgement.MinResult);
-    }
-}

osu.Game.Rulesets.Mania/Objects/HeadNote.cs

@@ -3,9 +3,6 @@
 
 namespace osu.Game.Rulesets.Mania.Objects
 {
-    /// <summary>
-    /// The head note of a <see cref="HoldNote"/>.
-    /// </summary>
     public class HeadNote : Note
     {
     }

osu.Game.Rulesets.Mania/Objects/HoldNote.cs

@@ -6,6 +6,8 @@
 using System.Collections.Generic;
 using System.Threading;
 using osu.Game.Audio;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
@@ -79,18 +81,27 @@ namespace osu.Game.Rulesets.Mania.Objects
         /// </summary>
         public TailNote Tail { get; private set; }
 
-        /// <summary>
-        /// The body of the hold.
-        /// This is an invisible and silent object that tracks the holding state of the <see cref="HoldNote"/>.
-        /// </summary>
-        public HoldNoteBody Body { get; private set; }
-
         public override double MaximumJudgementOffset => Tail.MaximumJudgementOffset;
 
+        /// <summary>
+        /// The time between ticks of this hold.
+        /// </summary>
+        private double tickSpacing = 50;
+
+        protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, IBeatmapDifficultyInfo difficulty)
+        {
+            base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
+
+            TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
+            tickSpacing = timingPoint.BeatLength / difficulty.SliderTickRate;
+        }
+
         protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
         {
             base.CreateNestedHitObjects(cancellationToken);
 
+            createTicks(cancellationToken);
+
             AddNested(Head = new HeadNote
             {
                 StartTime = StartTime,
@@ -104,12 +115,23 @@ namespace osu.Game.Rulesets.Mania.Objects
                 Column = Column,
                 Samples = GetNodeSamples((NodeSamples?.Count - 1) ?? 1),
             });
+        }
 
-            AddNested(Body = new HoldNoteBody
+        private void createTicks(CancellationToken cancellationToken)
+        {
+            if (tickSpacing == 0)
+                return;
+
+            for (double t = StartTime + tickSpacing; t <= EndTime - tickSpacing; t += tickSpacing)
             {
-                StartTime = StartTime,
-                Column = Column
-            });
+                cancellationToken.ThrowIfCancellationRequested();
+
+                AddNested(new HoldNoteTick
+                {
+                    StartTime = t,
+                    Column = Column
+                });
+            }
         }
 
         public override Judgement CreateJudgement() => new IgnoreJudgement();

osu.Game.Rulesets.Mania/Objects/HoldNoteBody.cs

@@ -1,21 +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.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Mania.Judgements;
-using osu.Game.Rulesets.Scoring;
-
-namespace osu.Game.Rulesets.Mania.Objects
-{
-    /// <summary>
-    /// The body of a <see cref="HoldNote"/>.
-    /// Mostly a dummy hitobject that provides the judgement for the "holding" state.<br />
-    /// On hit - the hold note was held correctly for the full duration.<br />
-    /// On miss - the hold note was released at some point during its judgement period.
-    /// </summary>
-    public class HoldNoteBody : ManiaHitObject
-    {
-        public override Judgement CreateJudgement() => new HoldNoteBodyJudgement();
-        protected override HitWindows CreateHitWindows() => HitWindows.Empty;
-    }
-}

osu.Game.Rulesets.Mania/Objects/HoldNoteTick.cs

@@ -0,0 +1,19 @@
+// 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.Judgements;
+using osu.Game.Rulesets.Mania.Judgements;
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Mania.Objects
+{
+    /// <summary>
+    /// A scoring tick of a hold note.
+    /// </summary>
+    public class HoldNoteTick : ManiaHitObject
+    {
+        public override Judgement CreateJudgement() => new HoldNoteTickJudgement();
+
+        protected override HitWindows CreateHitWindows() => HitWindows.Empty;
+    }
+}

osu.Game.Rulesets.Mania/Objects/Note.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.Threading;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Judgements;
 
@@ -13,12 +12,5 @@ namespace osu.Game.Rulesets.Mania.Objects
     public class Note : ManiaHitObject
     {
         public override Judgement CreateJudgement() => new ManiaJudgement();
-
-        protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
-        {
-            base.CreateNestedHitObjects(cancellationToken);
-
-            AddNested(new NotePerfectBonus { StartTime = StartTime });
-        }
     }
 }

osu.Game.Rulesets.Mania/Objects/NotePerfectBonus.cs

@@ -1,20 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Mania.Judgements;
-using osu.Game.Rulesets.Scoring;
-
-namespace osu.Game.Rulesets.Mania.Objects
-{
-    public class NotePerfectBonus : ManiaHitObject
-    {
-        public override Judgement CreateJudgement() => new NotePerfectBonusJudgement();
-        protected override HitWindows CreateHitWindows() => HitWindows.Empty;
-
-        public class NotePerfectBonusJudgement : ManiaJudgement
-        {
-            public override HitResult MaxResult => HitResult.SmallBonus;
-        }
-    }
-}

osu.Game.Rulesets.Mania/Objects/TailNote.cs

@@ -6,9 +6,6 @@ using osu.Game.Rulesets.Mania.Judgements;
 
 namespace osu.Game.Rulesets.Mania.Objects
 {
-    /// <summary>
-    /// The tail note of a <see cref="HoldNote"/>.
-    /// </summary>
     public class TailNote : Note
     {
         /// <summary>

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

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using osu.Framework;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
@@ -100,18 +99,9 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
                         return SkinUtils.As<TValue>(new Bindable<float>(30));
 
                     case LegacyManiaSkinConfigurationLookups.ColumnWidth:
-
-                        float width;
-
-                        bool isSpecialColumn = stage.IsSpecialColumn(columnIndex);
-
-                        // Best effort until we have better mobile support.
-                        if (RuntimeInfo.IsMobile)
-                            width = 170 * Math.Min(1, 7f / beatmap.TotalColumns) * (isSpecialColumn ? 1.8f : 1);
-                        else
-                            width = 60 * (isSpecialColumn ? 2 : 1);
-
-                        return SkinUtils.As<TValue>(new Bindable<float>(width));
+                        return SkinUtils.As<TValue>(new Bindable<float>(
+                            stage.IsSpecialColumn(columnIndex) ? 120 : 60
+                        ));
 
                     case LegacyManiaSkinConfigurationLookups.ColumnBackgroundColour:
 

osu.Game.Rulesets.Mania/Skinning/Default/DefaultBarLine.cs

@@ -4,7 +4,6 @@
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
@@ -26,42 +25,33 @@ namespace osu.Game.Rulesets.Mania.Skinning.Default
         {
             RelativeSizeAxes = Axes.Both;
 
-            // Avoid flickering due to no anti-aliasing of boxes by default.
-            var edgeSmoothness = new Vector2(0.3f);
-
             AddInternal(mainLine = new Box
             {
                 Name = "Bar line",
-                EdgeSmoothness = edgeSmoothness,
                 Anchor = Anchor.BottomCentre,
                 Origin = Anchor.BottomCentre,
                 RelativeSizeAxes = Axes.Both,
             });
 
-            const float major_extension = 10;
+            Vector2 size = new Vector2(22, 6);
+            const float line_offset = 4;
 
-            AddInternal(leftAnchor = new Box
+            AddInternal(leftAnchor = new Circle
             {
                 Name = "Left anchor",
-                EdgeSmoothness = edgeSmoothness,
-                Blending = BlendingParameters.Additive,
                 Anchor = Anchor.CentreLeft,
                 Origin = Anchor.CentreRight,
-                Width = major_extension,
-                RelativeSizeAxes = Axes.Y,
-                Colour = ColourInfo.GradientHorizontal(Colour4.Transparent, Colour4.White),
+                Size = size,
+                X = -line_offset,
             });
 
-            AddInternal(rightAnchor = new Box
+            AddInternal(rightAnchor = new Circle
             {
                 Name = "Right anchor",
-                EdgeSmoothness = edgeSmoothness,
-                Blending = BlendingParameters.Additive,
                 Anchor = Anchor.CentreRight,
                 Origin = Anchor.CentreLeft,
-                Width = major_extension,
-                RelativeSizeAxes = Axes.Y,
-                Colour = ColourInfo.GradientHorizontal(Colour4.White, Colour4.Transparent),
+                Size = size,
+                X = line_offset,
             });
 
             major = ((DrawableBarLine)drawableHitObject).Major.GetBoundCopy();
@@ -76,7 +66,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Default
         private void updateMajor(ValueChangedEvent<bool> major)
         {
             mainLine.Alpha = major.NewValue ? 0.5f : 0.2f;
-            leftAnchor.Alpha = rightAnchor.Alpha = major.NewValue ? mainLine.Alpha * 0.3f : 0;
+            leftAnchor.Alpha = rightAnchor.Alpha = major.NewValue ? 1 : 0;
         }
     }
 }

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

@@ -91,7 +91,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
             direction.BindTo(scrollingInfo.Direction);
             isHitting.BindTo(holdNote.IsHitting);
 
-            bodySprite = skin.GetAnimation(imageName, wrapMode, wrapMode, true, true, frameLength: 30).With(d =>
+            bodySprite = skin.GetAnimation(imageName, wrapMode, wrapMode, true, true).With(d =>
             {
                 if (d == null)
                     return;
@@ -123,18 +123,9 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 
         private void applyCustomUpdateState(DrawableHitObject hitObject, ArmedState state)
         {
-            switch (hitObject)
-            {
-                // Ensure that the hold note is also faded out when the head/tail/body is missed.
-                // Importantly, we filter out unrelated objects like DrawableNotePerfectBonus.
-                case DrawableHoldNoteTail:
-                case DrawableHoldNoteHead:
-                case DrawableHoldNoteBody:
-                    if (state == ArmedState.Miss)
-                        missFadeTime.Value ??= hitObject.HitStateUpdateTime;
-
-                    break;
-            }
+            // ensure that the hold note is also faded out when the head/tail/any tick is missed.
+            if (state == ArmedState.Miss)
+                missFadeTime.Value ??= hitObject.HitStateUpdateTime;
         }
 
         private void onIsHittingChanged(ValueChangedEvent<bool> isHitting)
@@ -218,9 +209,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
         protected override void Update()
         {
             base.Update();
-
-            if (holdNote.Body.HasHoldBreak)
-                missFadeTime.Value = holdNote.Body.Result.TimeAbsolute;
+            missFadeTime.Value ??= holdNote.HoldBrokenTime;
 
             int scaleDirection = (direction.Value == ScrollingDirection.Down ? 1 : -1);
 

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

@@ -5,6 +5,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.UI.Scrolling;
@@ -19,7 +20,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
         private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
 
         private Container lightContainer = null!;
-        private Drawable light = null!;
+        private Sprite light = null!;
 
         public LegacyColumnBackground()
         {
@@ -38,8 +39,6 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
             Color4 lightColour = GetColumnSkinConfig<Color4>(skin, LegacyManiaSkinConfigurationLookups.ColumnLightColour)?.Value
                                  ?? Color4.White;
 
-            int lightFramePerSecond = skin.GetManiaSkinConfig<int>(LegacyManiaSkinConfigurationLookups.LightFramePerSecond)?.Value ?? 60;
-
             InternalChildren = new[]
             {
                 lightContainer = new Container
@@ -47,15 +46,16 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
                     Origin = Anchor.BottomCentre,
                     RelativeSizeAxes = Axes.Both,
                     Padding = new MarginPadding { Bottom = lightPosition },
-                    Child = light = skin.GetAnimation(lightImage, true, true, frameLength: 1000d / lightFramePerSecond)?.With(l =>
+                    Child = light = new Sprite
                     {
-                        l.Anchor = Anchor.BottomCentre;
-                        l.Origin = Anchor.BottomCentre;
-                        l.Colour = LegacyColourCompatibility.DisallowZeroAlpha(lightColour);
-                        l.RelativeSizeAxes = Axes.X;
-                        l.Width = 1;
-                        l.Alpha = 0;
-                    }) ?? Empty(),
+                        Anchor = Anchor.BottomCentre,
+                        Origin = Anchor.BottomCentre,
+                        Colour = LegacyColourCompatibility.DisallowZeroAlpha(lightColour),
+                        Texture = skin.GetTexture(lightImage),
+                        RelativeSizeAxes = Axes.X,
+                        Width = 1,
+                        Alpha = 0
+                    }
                 }
             };