Hotfix approach circle cutoff

Hotfix multiplayer crashes
Rename FailAnimation to FailAnimationContainer
2026-05-17 18:13:18 +08:00 · 2023-10-09 04:02:02 +09:00 · 2023-10-09 03:58:31 +09:00 · 2023-10-08 00:39:30 +09:00 · 2023-10-07 10:31:34 +09:00 · 2023-10-06 22:31:30 +02:00
342 changed files with 7335 additions and 2547 deletions
@@ -1,206 +1,365 @@
-# 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.
+# ## Description
 #
+# 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:
-  CONCURRENCY: 4
-  ALLOW_DOWNLOAD: 1
-  SAVE_DOWNLOADED: 1
-  SKIP_INSERT_ATTRIBUTES: 1
+  COMMENT_TAG: execution-${{ github.run_id }}-${{ github.run_number }}-${{ github.run_attempt }}

 jobs:
-  metadata:
-    name: Check for requests
+  wait-for-queue:
+    name: "Wait for previous workflows"
+    runs-on: ubuntu-latest
+    if: ${{ !cancelled() && (github.event_name == 'workflow_dispatch' || contains(github.event.comment.body, '!diffcalc') && github.event.comment.author_association == 'OWNER') }}
+    timeout-minutes: 50400 # 35 days, the maximum for jobs.
+    steps:
+      - uses: ahmadnassri/action-workflow-queue@v1
+        with:
+          timeout: 2147483647 # Around 24 days, maximum supported.
+          delay: 120000 # Poll every 2 minutes. API seems fairly low on this one.
+
+  create-comment:
+    name: Create PR comment
+    runs-on: ubuntu-latest
+    if: ${{ github.event_name == 'issue_comment' && github.event.issue.pull_request && contains(github.event.comment.body, '!diffcalc') && github.event.comment.author_association == 'OWNER' }}
+    steps:
+      - name: Create comment
+        uses: thollander/actions-comment-pull-request@v2
+        with:
+          comment_tag: ${{ env.COMMENT_TAG }}
+          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: wait-for-queue
    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')
+    if: ${{ !cancelled() && (github.event_name == 'workflow_dispatch' || contains(github.event.comment.body, '!diffcalc') && github.event.comment.author_association == 'OWNER') }}
    outputs:
-      matrix: ${{ steps.generate-matrix.outputs.matrix }}
-      continue: ${{ steps.generate-matrix.outputs.continue }}
+      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 }}
    steps:
-      - name: Construct build matrix
-        id: generate-matrix
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Checkout diffcalc-sheet-generator
+        uses: actions/checkout@v3
+        with:
+          path: 'diffcalc-sheet-generator'
+          repository: 'smoogipoo/diffcalc-sheet-generator'
+
+      - name: Set outputs
+        id: set-outputs
        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
+          echo "GENERATOR_DIR=${{ github.workspace }}/diffcalc-sheet-generator" >> "${GITHUB_OUTPUT}"
+          echo "GENERATOR_ENV=${{ github.workspace }}/diffcalc-sheet-generator/.env" >> "${GITHUB_OUTPUT}"
+          echo "GOOGLE_CREDS_FILE=${{ github.workspace }}/diffcalc-sheet-generator/google-credentials.json" >> "${GITHUB_OUTPUT}"

-          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
+  environment:
+    name: Setup environment
+    needs: directory
    runs-on: self-hosted
-    timeout-minutes: 1440
-    if: needs.metadata.outputs.continue == 'yes'
-    needs: metadata
-    strategy:
-      matrix: ${{ fromJson(needs.metadata.outputs.matrix) }}
+    if: ${{ !cancelled() && needs.directory.result == 'success' }}
+    env:
+      VARS_JSON: ${{ toJSON(vars) }}
    steps:
-      - name: Verify MySQL connection from host
+      - name: Add base environment
        run: |
-          mysql -e "SHOW DATABASES"
+          # Required by diffcalc-sheet-generator
+          cp '${{ github.workspace }}/diffcalc-sheet-generator/.env.sample' "${{ needs.directory.outputs.GENERATOR_ENV }}"

-      - name: Drop previous databases
-        run: |
-          for db in osu_master osu_pr
-          do
-            mysql -e "DROP DATABASE IF EXISTS $db"
+          # Add Google credentials
+          echo '${{ secrets.DIFFCALC_GOOGLE_CREDENTIALS }}' | base64 -d > "${{ needs.directory.outputs.GOOGLE_CREDS_FILE }}"
+
+          # 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})
+
+              if [[ "${opt}" =~ ^DIFFCALC_ ]]; then
+                optNoPrefix=$(echo "${opt}" | cut -d '_' -f2-)
+                sed -i "s;^${optNoPrefix}=.*$;${optNoPrefix}=${val};" "${{ needs.directory.outputs.GENERATOR_ENV }}"
+              fi
          done

-      - name: Create directory structure
+      - name: Add pull-request environment
+        if: ${{ github.event_name == 'issue_comment' && github.event.issue.pull_request }}
        run: |
-          mkdir -p $GITHUB_WORKSPACE/master/
-          mkdir -p $GITHUB_WORKSPACE/pr/
+          sed -i "s;^OSU_B=.*$;OSU_B=${{ github.event.issue.pull_request.url }};" "${{ needs.directory.outputs.GENERATOR_ENV }}"

-      - name: Get upstream branch # https://akaimo.hatenablog.jp/entry/2020/05/16/101251
-        id: upstreambranch
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Add comment environment
+        if: ${{ github.event_name == 'issue_comment' }}
        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: '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: 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: |
-          cd $GITHUB_WORKSPACE/master/osu-difficulty-calculator
-          ./UseLocalOsu.sh
-          dotnet build
-      - name: Build diffcalc (pr)
-        run: |
-          cd $GITHUB_WORKSPACE/pr/osu-difficulty-calculator
-          ./UseLocalOsu.sh
-          dotnet build
-
-      - 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')
-
-          # Set env variable for further steps.
-          echo "BEATMAPS_PATH=$GITHUB_WORKSPACE/$BEATMAPS_DATA_NAME" >> $GITHUB_ENV
-
-          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;'
+          # Add comment environment
+          echo '${{ github.event.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: Run diffcalc (master)
-        env:
-          DB_NAME: osu_master
+      - name: Add dispatch environment
+        if: ${{ github.event_name == 'workflow_dispatch' }}
        run: |
-          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: |
-          cd $GITHUB_WORKSPACE/pr/osu-difficulty-calculator/osu.Server.DifficultyCalculator
-          dotnet run -c:Release -- all -m ${{ matrix.ruleset.id }} -ac -c ${{ env.CONCURRENCY }}
+          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 }}"

-      - name: Print diffs
-        run: |
-          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;"
+          if [[ '${{ inputs.osu-a }}' != 'latest' ]]; then
+              sed -i 's;^OSU_A=.*$;OSU_A=${{ inputs.osu-a }};' "${{ needs.directory.outputs.GENERATOR_ENV }}"
+          fi

-      # Todo: Run ppcalc
+          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
+    if: ${{ !cancelled() && needs.environment.result == 'success' }}
+    steps:
+      - name: Query latest data
+        id: query
+        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')
+
+          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@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
+    if: ${{ !cancelled() && needs.directory.result == 'success' }}
+    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@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
+    if: ${{ !cancelled() && needs.scores.result == 'success' && needs.beatmaps.result == 'success' }}
+    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
+
+      - name: Output info
+        if: ${{ success() }}
+        run: |
+          echo "Target: ${{ steps.run.outputs.TARGET }}"
+          echo "Spreadsheet: ${{ steps.run.outputs.SPREADSHEET_LINK }}"
+
+  update-comment:
+    name: Update PR comment
+    needs: [ create-comment, generator ]
+    runs-on: ubuntu-latest
+    if: ${{ github.event_name == 'issue_comment' && github.event.issue.pull_request && contains(github.event.comment.body, '!diffcalc') && github.event.comment.author_association == 'OWNER' }}
+    steps:
+      - name: Update comment on success
+        if: ${{ needs.generator.result == 'success' }}
+        uses: thollander/actions-comment-pull-request@v2
+        with:
+          comment_tag: ${{ env.COMMENT_TAG }}
+          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@v2
+        with:
+          comment_tag: ${{ env.COMMENT_TAG }}
+          mode: upsert
+          create_if_not_exists: false
+          message: |
+            Difficulty calculation failed: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
@@ -12,40 +12,43 @@

 A free-to-win rhythm game. Rhythm is just a *click* away!

-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.
+This is the future – and final – iteration of the [osu!](https://osu.ppy.sh) game client which marks the beginning of an open era! Currently known by and released under the release codename "*lazer*". As in sharper than cutting-edge.

 ## Status

-This project is under constant development, but we 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.
+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.

-**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:
+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 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:
+If you are just looking to give the game a whirl, you can grab the latest release for your platform:

-**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) |
 | ------------- | ------------- | ------------- | ------------- | ------------- |

- 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.
+You can also generally download a version for your current device from the [osu! site](https://osu.ppy.sh/home/download).

 If your platform is 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 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).
+osu! is designed to allow user-created gameplay variations, called "rulesets". Building one of these allows a developer to harness the power of the osu! beatmap library, game engine, and general UX for a new style of gameplay. To get started working on a ruleset, we have some templates available [here](https://github.com/ppy/osu/tree/master/Templates).

 You can see some examples of custom rulesets by visiting the [custom ruleset directory](https://github.com/ppy/osu/discussions/13096).

 ## Developing osu!

+### Prerequisites
+
 Please make sure you have the following prerequisites:

 - A desktop platform with the [.NET 6.0 SDK](https://dotnet.microsoft.com/download) installed.
@@ -69,9 +72,19 @@ git pull

 ### Building

-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).
+#### From an IDE

- 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 should load the solution via one of the platform-specific `.slnf` files, rather than the main `.sln`. This will reduce dependencies and hide platforms that you don't care about. Valid `.slnf` files are:
+
+- `osu.Desktop.slnf` (most common)
+- `osu.Android.slnf`
+- `osu.iOS.slnf`
+
+Run configurations for the recommended IDEs (listed above) are included. You should use the provided Build/Run functionality of your IDE to get things going. When testing or building new components, it's highly encouraged you use the `osu! (Tests)` project/configuration. More information on this is provided [below](#contributing).
+
+To build for mobile platforms, you will likely need to run `sudo dotnet workload restore` if you haven't done so previously. This will install Android/iOS tooling required to complete the build.
+
+#### From CLI

 You can also build and run *osu!* from the command-line with a single command:

@@ -79,12 +92,10 @@ You can also build and run *osu!* from the command-line with a single command:
 dotnet run --project osu.Desktop
 ```

-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.
+When running locally to do any kind of performance testing, make sure to add `-c Release` to the build command, as the overhead of running with the default `Debug` configuration can be large (especially when testing with local framework modifications as below).

 If the build fails, try to restore NuGet packages with `dotnet restore`.

-_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:
@@ -9,9 +9,9 @@
      <GenerateProgramFile>false</GenerateProgramFile>
    </PropertyGroup>
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
    <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\osu.Game.Rulesets.EmptyFreeform\osu.Game.Rulesets.EmptyFreeform.csproj" />
@@ -9,9 +9,9 @@
    <GenerateProgramFile>false</GenerateProgramFile>
  </PropertyGroup>
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
    <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj" />
@@ -9,9 +9,9 @@
    <GenerateProgramFile>false</GenerateProgramFile>
  </PropertyGroup>
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
    <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\osu.Game.Rulesets.EmptyScrolling\osu.Game.Rulesets.EmptyScrolling.csproj" />
@@ -9,9 +9,9 @@
    <GenerateProgramFile>false</GenerateProgramFile>
  </PropertyGroup>
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
    <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj" />
@@ -10,7 +10,7 @@
    <EmbedAssembliesIntoApk>true</EmbedAssembliesIntoApk>
  </PropertyGroup>
  <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2023.904.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2023.1006.0" />
  </ItemGroup>
  <PropertyGroup>
    <!-- Fody does not handle Android build well, and warns when unchanged.
@@ -26,7 +26,7 @@
    <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.1.4.20" />
+    <PackageReference Include="DiscordRichPresence" Version="1.2.1.24" />
  </ItemGroup>
  <ItemGroup Label="Resources">
    <EmbeddedResource Include="lazer.ico" />
@@ -7,9 +7,9 @@
  </PropertyGroup>

  <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.13.4" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.8" />
    <PackageReference Include="nunit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
  </ItemGroup>

  <ItemGroup>
@@ -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.SliderVelocityBindable.IsDefault);
+            AddAssert("default slider velocity", () => lastObject.SliderVelocityMultiplierBindable.IsDefault);
        }

        [Test]
@@ -76,7 +76,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
            addPlacementSteps(times, positions);
            addPathCheckStep(times, positions);

-            AddAssert("slider velocity changed", () => !lastObject.SliderVelocityBindable.IsDefault);
+            AddAssert("slider velocity changed", () => !lastObject.SliderVelocityMultiplierBindable.IsDefault);
        }

        [Test]
@@ -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.SliderVelocityBindable.IsDefault);
+            AddAssert("default slider velocity", () => hitObject.SliderVelocityMultiplierBindable.IsDefault);

            addDragStartStep(times[1], positions[1]);
            AddMouseMoveStep(times[1], 400);
-            AddAssert("slider velocity changed", () => !hitObject.SliderVelocityBindable.IsDefault);
+            AddAssert("slider velocity changed", () => !hitObject.SliderVelocityMultiplierBindable.IsDefault);
        }

        [Test]
@@ -0,0 +1,157 @@
+// 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 };
+        }
+    }
+}
@@ -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.4.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
    <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
  </ItemGroup>
  <PropertyGroup Label="Project">
    <OutputType>WinExe</OutputType>
@@ -41,9 +41,8 @@ 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,
-                        SliderVelocity = sliderVelocityData?.SliderVelocity ?? 1
+                        SliderVelocityMultiplier = sliderVelocityData?.SliderVelocityMultiplier ?? 1
                    }.Yield();

                case IHasDuration endTime:
@@ -25,6 +25,7 @@ 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;
@@ -25,12 +25,9 @@ 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)
@@ -49,15 +46,6 @@ 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;
        }

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

 using System;
-using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.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 modernBonusScore;
+        private int standardisedBonusScore;
        private int combo;

        private double scoreMultiplier;

-        public void Simulate(IWorkingBeatmap workingBeatmap, IBeatmap playableBeatmap, IReadOnlyList<Mod> mods)
+        public LegacyScoreAttributes Simulate(IWorkingBeatmap workingBeatmap, IBeatmap playableBeatmap)
        {
            IBeatmap baseBeatmap = workingBeatmap.Beatmap;

@@ -70,13 +63,19 @@ namespace osu.Game.Rulesets.Catch.Difficulty
                 + baseBeatmap.Difficulty.CircleSize
                 + Math.Clamp((float)objectCount / drainLength * 8, 0, 16)) / 38 * 5);

-            scoreMultiplier = difficultyPeppyStars * mods.Aggregate(1.0, (current, mod) => current * mod.ScoreMultiplier);
+            scoreMultiplier = difficultyPeppyStars;
+
+            LegacyScoreAttributes attributes = new LegacyScoreAttributes();

            foreach (var obj in playableBeatmap.HitObjects)
-                simulateHit(obj);
+                simulateHit(obj, ref attributes);
+
+            attributes.BonusScoreRatio = legacyBonusScore == 0 ? 0 : (double)standardisedBonusScore / legacyBonusScore;
+
+            return attributes;
        }

-        private void simulateHit(HitObject hitObject)
+        private void simulateHit(HitObject hitObject, ref LegacyScoreAttributes attributes)
        {
            bool increaseCombo = true;
            bool addScoreComboMultiplier = false;
@@ -112,28 +111,28 @@ namespace osu.Game.Rulesets.Catch.Difficulty

                case JuiceStream:
                    foreach (var nested in hitObject.NestedHitObjects)
-                        simulateHit(nested);
+                        simulateHit(nested, ref attributes);
                    return;

                case BananaShower:
                    foreach (var nested in hitObject.NestedHitObjects)
-                        simulateHit(nested);
+                        simulateHit(nested, ref attributes);
                    return;
            }

            if (addScoreComboMultiplier)
            {
                // ReSharper disable once PossibleLossOfFraction (intentional to match osu-stable...)
-                ComboScore += (int)(Math.Max(0, combo - 1) * (scoreIncrease / 25 * scoreMultiplier));
+                attributes.ComboScore += (int)(Math.Max(0, combo - 1) * (scoreIncrease / 25 * scoreMultiplier));
            }

            if (isBonus)
            {
                legacyBonusScore += scoreIncrease;
-                modernBonusScore += Judgement.ToNumericResult(bonusResult);
+                standardisedBonusScore += Judgement.ToNumericResult(bonusResult);
            }
            else
-                AccuracyScore += scoreIncrease;
+                attributes.AccuracyScore += scoreIncrease;

            if (increaseCombo)
                combo++;
@@ -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.SliderVelocityBindable;
+            var svBindable = hitObject.SliderVelocityMultiplierBindable;
            double svToVelocityFactor = hitObject.Velocity / svBindable.Value;
            double requiredVelocity = path.ComputeRequiredVelocity();

@@ -25,6 +25,7 @@ using osuTK;

 namespace osu.Game.Rulesets.Catch.Edit
 {
+    // we're also a ScrollingHitObjectComposer candidate, but can't be everything can we?
    public partial class CatchHitObjectComposer : DistancedHitObjectComposer<CatchHitObject>
    {
        private const float distance_snap_radius = 50;
@@ -140,7 +141,7 @@ namespace osu.Game.Rulesets.Catch.Edit
            return base.OnPressed(e);
        }

-        protected override DrawableRuleset<CatchHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod>? mods = null) =>
+        protected override DrawableRuleset<CatchHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods) =>
            new DrawableCatchEditorRuleset(ruleset, beatmap, mods)
            {
                TimeRangeMultiplier = { BindTarget = timeRangeMultiplier, }
@@ -28,17 +28,17 @@ namespace osu.Game.Rulesets.Catch.Objects

        public int RepeatCount { get; set; }

-        public BindableNumber<double> SliderVelocityBindable { get; } = new BindableDouble(1)
+        public BindableNumber<double> SliderVelocityMultiplierBindable { get; } = new BindableDouble(1)
        {
            Precision = 0.01,
            MinValue = 0.1,
            MaxValue = 10
        };

-        public double SliderVelocity
+        public double SliderVelocityMultiplier
        {
-            get => SliderVelocityBindable.Value;
-            set => SliderVelocityBindable.Value = value;
+            get => SliderVelocityMultiplierBindable.Value;
+            set => SliderVelocityMultiplierBindable.Value = value;
        }

        [JsonIgnore]
@@ -48,10 +48,10 @@ namespace osu.Game.Rulesets.Catch.Objects
        private double tickDistanceFactor;

        [JsonIgnore]
-        public double Velocity => velocityFactor * SliderVelocity;
+        public double Velocity => velocityFactor * SliderVelocityMultiplier;

        [JsonIgnore]
-        public double TickDistance => tickDistanceFactor * SliderVelocity;
+        public double TickDistance => tickDistanceFactor * SliderVelocityMultiplier;

        /// <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(), LegacyLastTickOffset, cancellationToken))
+            foreach (var e in SliderEventGenerator.Generate(StartTime, SpanDuration, Velocity, TickDistance, Path.Distance, this.SpanCount(), cancellationToken))
            {
                // generate tiny droplets since the last point
                if (lastEvent != null)
@@ -104,8 +104,8 @@ namespace osu.Game.Rulesets.Catch.Objects
                    }
                }

-                // 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.
+                // 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.
                lastEvent = e;

                switch (e.Type)
@@ -162,7 +162,5 @@ 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; }
    }
 }
@@ -2,17 +2,21 @@
 // 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");
-            Texture? overlayTexture = Skin.GetTexture("fruit-bananas-overlay");
+            Texture? texture = Skin.GetTexture("fruit-bananas")?.WithMaximumSize(banana_max_size);
+            Texture? overlayTexture = Skin.GetTexture("fruit-bananas-overlay")?.WithMaximumSize(banana_max_size);

            SetTexture(texture, overlayTexture);
        }
@@ -2,12 +2,15 @@
 // 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);
@@ -17,8 +20,8 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
        {
            base.LoadComplete();

-            Texture? texture = Skin.GetTexture("fruit-drop");
-            Texture? overlayTexture = Skin.GetTexture("fruit-drop-overlay");
+            Texture? texture = Skin.GetTexture("fruit-drop")?.WithMaximumSize(droplet_max_size);
+            Texture? overlayTexture = Skin.GetTexture("fruit-drop-overlay")?.WithMaximumSize(droplet_max_size);

            SetTexture(texture, overlayTexture);
        }
@@ -2,11 +2,15 @@
 // 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();
@@ -22,21 +26,26 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
            switch (visualRepresentation)
            {
                case FruitVisualRepresentation.Pear:
-                    SetTexture(Skin.GetTexture("fruit-pear"), Skin.GetTexture("fruit-pear-overlay"));
+                    setTextures("pear");
                    break;

                case FruitVisualRepresentation.Grape:
-                    SetTexture(Skin.GetTexture("fruit-grapes"), Skin.GetTexture("fruit-grapes-overlay"));
+                    setTextures("grapes");
                    break;

                case FruitVisualRepresentation.Pineapple:
-                    SetTexture(Skin.GetTexture("fruit-apple"), Skin.GetTexture("fruit-apple-overlay"));
+                    setTextures("apple");
                    break;

                case FruitVisualRepresentation.Raspberry:
-                    SetTexture(Skin.GetTexture("fruit-orange"), Skin.GetTexture("fruit-orange-overlay"));
+                    setTextures("orange");
                    break;
            }
+
+            void setTextures(string fruitName) => SetTexture(
+                Skin.GetTexture($"fruit-{fruitName}")?.WithMaximumSize(fruit_max_size),
+                Skin.GetTexture($"fruit-{fruitName}-overlay")?.WithMaximumSize(fruit_max_size)
+            );
        }
    }
 }
@@ -21,8 +21,6 @@ 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)
@@ -30,6 +28,7 @@ namespace osu.Game.Rulesets.Catch.UI
        {
            Direction.Value = ScrollingDirection.Down;
            TimeRange.Value = GetTimeRange(beatmap.Difficulty.ApproachRate);
+            VisualisationMethod = ScrollVisualisationMethod.Constant;
        }

        [BackgroundDependencyLoader]
@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
            PassCondition = () =>
            {
                var hitObject = Player.ChildrenOfType<DrawableManiaHitObject>().FirstOrDefault();
-                return hitObject?.Dependencies.Get<IScrollingInfo>().Algorithm is ConstantScrollAlgorithm;
+                return hitObject?.Dependencies.Get<IScrollingInfo>().Algorithm.Value is ConstantScrollAlgorithm;
            }
        });
    }
@@ -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);
-            IScrollAlgorithm IScrollingInfo.Algorithm { get; } = new ConstantScrollAlgorithm();
+            IBindable<IScrollAlgorithm> IScrollingInfo.Algorithm { get; } = new Bindable<IScrollAlgorithm>(new ConstantScrollAlgorithm());
        }
    }
 }
@@ -0,0 +1,175 @@
+// 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 };
+        }
+    }
+}
@@ -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.4.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
    <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
  </ItemGroup>
  <PropertyGroup Label="Project">
    <OutputType>WinExe</OutputType>
@@ -10,10 +10,11 @@ using System.Linq;
 using osu.Framework.Extensions.EnumExtensions;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Types;
-using osu.Game.Rulesets.Mania.Objects;
 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.Utils;

 namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
@@ -50,10 +51,9 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
            TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(hitObject.StartTime);

            double beatLength;
-            if (hitObject.LegacyBpmMultiplier.HasValue)
-                beatLength = timingPoint.BeatLength * hitObject.LegacyBpmMultiplier.Value;
-            else if (hitObject is IHasSliderVelocity hasSliderVelocity)
-                beatLength = timingPoint.BeatLength / hasSliderVelocity.SliderVelocity;
+
+            if (hitObject is IHasSliderVelocity hasSliderVelocity)
+                beatLength = LegacyRulesetExtensions.GetPrecisionAdjustedBeatLength(hasSliderVelocity, timingPoint, ManiaRuleset.SHORT_NAME);
            else
                beatLength = timingPoint.BeatLength;

@@ -31,13 +31,9 @@ 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;
        }
@@ -60,15 +56,6 @@ 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;
        }

@@ -1,28 +1,16 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

-using System.Collections.Generic;
-using System.Linq;
 using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Mania.Mods;
-using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Scoring.Legacy;

 namespace osu.Game.Rulesets.Mania.Difficulty
 {
    internal class ManiaLegacyScoreSimulator : ILegacyScoreSimulator
    {
-        public int AccuracyScore => 0;
-        public int ComboScore { get; private set; }
-        public double BonusScoreRatio => 0;
-
-        public void Simulate(IWorkingBeatmap workingBeatmap, IBeatmap playableBeatmap, IReadOnlyList<Mod> mods)
+        public LegacyScoreAttributes Simulate(IWorkingBeatmap workingBeatmap, IBeatmap playableBeatmap)
        {
-            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);
-
-            ComboScore = (int)(1000000 * multiplier);
+            return new LegacyScoreAttributes { ComboScore = 1000000 };
        }
    }
 }
@@ -2,18 +2,22 @@
 // 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
+    public partial class DrawableManiaEditorRuleset : DrawableManiaRuleset, ISupportConstantAlgorithmToggle
    {
+        public BindableBool ShowSpeedChanges { get; } = new BindableBool();
+
        public new IScrollingInfo ScrollingInfo => base.ScrollingInfo;

        public DrawableManiaEditorRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod>? mods)
@@ -21,6 +25,13 @@ 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,
@@ -21,7 +21,7 @@ using osuTK;

 namespace osu.Game.Rulesets.Mania.Edit
 {
-    public partial class ManiaHitObjectComposer : HitObjectComposer<ManiaHitObject>
+    public partial class ManiaHitObjectComposer : ScrollingHitObjectComposer<ManiaHitObject>
    {
        private DrawableManiaEditorRuleset drawableRuleset;
        private ManiaBeatSnapGrid beatSnapGrid;
@@ -57,7 +57,7 @@ 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 = null)
+        protected override DrawableRuleset<ManiaHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods)
        {
            drawableRuleset = new DrawableManiaEditorRuleset(ruleset, beatmap, mods);

@@ -33,6 +33,7 @@ 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;
@@ -41,6 +41,7 @@ namespace osu.Game.Rulesets.Mania
                },
                new SettingsCheckbox
                {
+                    Keywords = new[] { "color" },
                    LabelText = RulesetSettingsStrings.TimingBasedColouring,
                    Current = config.GetBindable<bool>(ManiaRulesetSetting.TimingBasedNoteColouring),
                }
@@ -28,7 +28,7 @@ namespace osu.Game.Rulesets.Mania.Mods
        public void ApplyToDrawableRuleset(DrawableRuleset<ManiaHitObject> drawableRuleset)
        {
            var maniaRuleset = (DrawableManiaRuleset)drawableRuleset;
-            maniaRuleset.ScrollMethod = ScrollVisualisationMethod.Constant;
+            maniaRuleset.VisualisationMethod = ScrollVisualisationMethod.Constant;
        }
    }
 }
@@ -4,6 +4,7 @@
 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;
@@ -25,33 +26,42 @@ 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,
            });

-            Vector2 size = new Vector2(22, 6);
-            const float line_offset = 4;
+            const float major_extension = 10;

-            AddInternal(leftAnchor = new Circle
+            AddInternal(leftAnchor = new Box
            {
                Name = "Left anchor",
+                EdgeSmoothness = edgeSmoothness,
+                Blending = BlendingParameters.Additive,
                Anchor = Anchor.CentreLeft,
                Origin = Anchor.CentreRight,
-                Size = size,
-                X = -line_offset,
+                Width = major_extension,
+                RelativeSizeAxes = Axes.Y,
+                Colour = ColourInfo.GradientHorizontal(Colour4.Transparent, Colour4.White),
            });

-            AddInternal(rightAnchor = new Circle
+            AddInternal(rightAnchor = new Box
            {
                Name = "Right anchor",
+                EdgeSmoothness = edgeSmoothness,
+                Blending = BlendingParameters.Additive,
                Anchor = Anchor.CentreRight,
                Origin = Anchor.CentreLeft,
-                Size = size,
-                X = line_offset,
+                Width = major_extension,
+                RelativeSizeAxes = Axes.Y,
+                Colour = ColourInfo.GradientHorizontal(Colour4.White, Colour4.Transparent),
            });

            major = ((DrawableBarLine)drawableHitObject).Major.GetBoundCopy();
@@ -66,7 +76,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 ? 1 : 0;
+            leftAnchor.Alpha = rightAnchor.Alpha = major.NewValue ? mainLine.Alpha * 0.3f : 0;
        }
    }
 }
@@ -30,5 +30,7 @@ namespace osu.Game.Rulesets.Mania.Skinning
            Lookup = lookup;
            ColumnIndex = columnIndex;
        }
+
+        public override string ToString() => $"[{nameof(ManiaSkinConfigurationLookup)} lookup:{Lookup} col:{ColumnIndex}]";
    }
 }
@@ -3,7 +3,6 @@

 #nullable disable

-using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
@@ -14,7 +13,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Configuration;
 using osu.Game.Input.Handlers;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Mania.Beatmaps;
@@ -52,22 +50,6 @@ namespace osu.Game.Rulesets.Mania.UI

        protected new ManiaRulesetConfigManager Config => (ManiaRulesetConfigManager)base.Config;

-        public ScrollVisualisationMethod ScrollMethod
-        {
-            get => scrollMethod;
-            set
-            {
-                if (IsLoaded)
-                    throw new InvalidOperationException($"Can't alter {nameof(ScrollMethod)} after ruleset is already loaded");
-
-                scrollMethod = value;
-            }
-        }
-
-        private ScrollVisualisationMethod scrollMethod = ScrollVisualisationMethod.Sequential;
-
-        protected override ScrollVisualisationMethod VisualisationMethod => scrollMethod;
-
        private readonly Bindable<ManiaScrollingDirection> configDirection = new Bindable<ManiaScrollingDirection>();
        private readonly BindableInt configScrollSpeed = new BindableInt();
        private double smoothTimeRange;
@@ -163,7 +163,6 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                slider = new Slider
                {
                    Position = new Vector2(0, 50),
-                    LegacyLastTickOffset = 36, // This is necessary for undo to retain the sample control point
                    Path = new SliderPath(new[]
                    {
                        new PathControlPoint(Vector2.Zero, PathType.PerfectCurve),
@@ -73,7 +73,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
                                new PathControlPoint(new Vector2(0, 6.25f))
                            }),
                            RepeatCount = 1,
-                            SliderVelocity = 10
+                            SliderVelocityMultiplier = 10
                        }
                    }
                },
@@ -19,6 +19,8 @@ namespace osu.Game.Rulesets.Osu.Tests
        [TestCase("basic")]
        [TestCase("colinear-perfect-curve")]
        [TestCase("slider-ticks")]
+        [TestCase("slider-ticks-edge-case")]
+        [TestCase("slider-paths-edge-case")]
        [TestCase("repeat-slider")]
        [TestCase("uneven-repeat-slider")]
        [TestCase("old-stacking")]
@@ -549,12 +549,151 @@ namespace osu.Game.Rulesets.Osu.Tests
            addJudgementOffsetAssert("first slider head", () => ((Slider)hitObjects[0]).HeadCircle, 0);
            addJudgementAssert(hitObjects[1], HitResult.Miss);
            // the slider head of the first slider prevents the second slider's head from being hit, so the judgement offset should be very late.
-            // this is not strictly done by the hit policy implementation itself (see `OsuModClassic.blockInputToUnderlyingObjects()`),
+            // this is not strictly done by the hit policy implementation itself (see `OsuModClassic.blockInputToObjectsUnderSliderHead()`),
            // but we're testing this here anyways to just keep everything related to input handling and note lock in one place.
            addJudgementOffsetAssert("second slider head", () => ((Slider)hitObjects[1]).HeadCircle, referenceHitWindows.WindowFor(HitResult.Meh));
            addClickActionAssert(0, ClickAction.Hit);
        }

+        [Test]
+        public void TestOverlappingSlidersDontBlockEachOtherWhenFullyJudged()
+        {
+            const double time_first_slider = 1000;
+            const double time_second_slider = 1600;
+            Vector2 positionFirstSlider = new Vector2(100, 50);
+            Vector2 positionSecondSlider = new Vector2(100, 80);
+            var midpoint = (positionFirstSlider + positionSecondSlider) / 2;
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new Slider
+                {
+                    StartTime = time_first_slider,
+                    Position = positionFirstSlider,
+                    Path = new SliderPath(PathType.Linear, new[]
+                    {
+                        Vector2.Zero,
+                        new Vector2(25, 0),
+                    })
+                },
+                new Slider
+                {
+                    StartTime = time_second_slider,
+                    Position = positionSecondSlider,
+                    Path = new SliderPath(PathType.Linear, new[]
+                    {
+                        Vector2.Zero,
+                        new Vector2(25, 0),
+                    })
+                }
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_first_slider, Position = midpoint, Actions = { OsuAction.RightButton } },
+                new OsuReplayFrame { Time = time_first_slider + 25, Position = midpoint },
+                // this frame doesn't do anything on lazer, but is REQUIRED for correct playback on stable,
+                // because stable during replay playback only updates game state _when it encounters a replay frame_
+                new OsuReplayFrame { Time = 1250, Position = midpoint },
+                new OsuReplayFrame { Time = time_second_slider + 50, Position = midpoint, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_second_slider + 75, Position = midpoint },
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Ok);
+            addJudgementOffsetAssert("first slider head", () => ((Slider)hitObjects[0]).HeadCircle, 0);
+            addJudgementAssert(hitObjects[1], HitResult.Ok);
+            addJudgementOffsetAssert("second slider head", () => ((Slider)hitObjects[1]).HeadCircle, 50);
+            addClickActionAssert(0, ClickAction.Hit);
+            addClickActionAssert(1, ClickAction.Hit);
+        }
+
+        [Test]
+        public void TestOverlappingHitCirclesDontBlockEachOtherWhenBothVisible()
+        {
+            const double time_first_circle = 1000;
+            const double time_second_circle = 1200;
+            Vector2 positionFirstCircle = new Vector2(100);
+            Vector2 positionSecondCircle = new Vector2(120);
+            var midpoint = (positionFirstCircle + positionSecondCircle) / 2;
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new HitCircle
+                {
+                    StartTime = time_first_circle,
+                    Position = positionFirstCircle,
+                },
+                new HitCircle
+                {
+                    StartTime = time_second_circle,
+                    Position = positionSecondCircle,
+                },
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_first_circle, Position = midpoint, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_first_circle + 25, Position = midpoint },
+                new OsuReplayFrame { Time = time_first_circle + 50, Position = midpoint, Actions = { OsuAction.RightButton } },
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Great);
+            addJudgementOffsetAssert(hitObjects[0], 0);
+
+            addJudgementAssert(hitObjects[1], HitResult.Meh);
+            addJudgementOffsetAssert(hitObjects[1], -150);
+        }
+
+        [Test]
+        public void TestOverlappingHitCirclesDontBlockEachOtherWhenFullyFadedOut()
+        {
+            const double time_first_circle = 1000;
+            const double time_second_circle = 1200;
+            const double time_third_circle = 1400;
+            Vector2 positionFirstCircle = new Vector2(100);
+            Vector2 positionSecondCircle = new Vector2(200);
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new HitCircle
+                {
+                    StartTime = time_first_circle,
+                    Position = positionFirstCircle,
+                },
+                new HitCircle
+                {
+                    StartTime = time_second_circle,
+                    Position = positionSecondCircle,
+                },
+                new HitCircle
+                {
+                    StartTime = time_third_circle,
+                    Position = positionFirstCircle,
+                },
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_first_circle, Position = positionFirstCircle, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_first_circle + 50, Position = positionFirstCircle },
+                new OsuReplayFrame { Time = time_second_circle - 50, Position = positionSecondCircle },
+                new OsuReplayFrame { Time = time_second_circle, Position = positionSecondCircle, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_second_circle + 50, Position = positionSecondCircle },
+                new OsuReplayFrame { Time = time_third_circle - 50, Position = positionFirstCircle },
+                new OsuReplayFrame { Time = time_third_circle, Position = positionFirstCircle, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_third_circle + 50, Position = positionFirstCircle },
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Great);
+            addJudgementOffsetAssert(hitObjects[0], 0);
+
+            addJudgementAssert(hitObjects[1], HitResult.Great);
+            addJudgementOffsetAssert(hitObjects[1], 0);
+
+            addJudgementAssert(hitObjects[2], HitResult.Great);
+            addJudgementOffsetAssert(hitObjects[2], 0);
+        }
+
        private void addJudgementAssert(OsuHitObject hitObject, HitResult result)
        {
            AddAssert($"({hitObject.GetType().ReadableName()} @ {hitObject.StartTime}) judgement is {result}",
@@ -0,0 +1,176 @@
+// 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.Judgements;
+using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Scoring;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Tests.Visual.Gameplay;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    [TestFixture]
+    public partial class TestSceneScoring : ScoringTestScene
+    {
+        private Bindable<double> scoreMultiplier { get; } = new BindableDouble
+        {
+            Default = 4,
+            Value = 4
+        };
+
+        protected override IBeatmap CreateBeatmap(int maxCombo)
+        {
+            var beatmap = new OsuBeatmap();
+            for (int i = 0; i < maxCombo; i++)
+                beatmap.HitObjects.Add(new HitCircle());
+            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 OsuProcessorBasedScoringAlgorithm(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 });
+            });
+            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 });
+            });
+            AddSliderStep("adjust score multiplier", 0, 10, (int)scoreMultiplier.Default, multiplier => scoreMultiplier.Value = multiplier);
+        }
+
+        private const int base_great = 300;
+        private const int base_ok = 100;
+
+        private class ScoreV1 : IScoringAlgorithm
+        {
+            private int currentCombo;
+
+            public BindableDouble ScoreMultiplier { get; } = new BindableDouble();
+
+            public void ApplyHit() => applyHitV1(base_great);
+            public void ApplyNonPerfect() => applyHitV1(base_ok);
+            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 double currentBaseScore;
+            private double maxBaseScore;
+            private int currentHits;
+
+            private readonly double comboPortionMax;
+            private readonly int maxCombo;
+
+            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(base_great);
+            public void ApplyNonPerfect() => applyHitV2(base_ok);
+
+            private void applyHitV2(int baseScore)
+            {
+                maxBaseScore += base_great;
+                currentBaseScore += baseScore;
+                comboPortion += baseScore * (1 + ++currentCombo / 10.0);
+
+                currentHits++;
+            }
+
+            public void ApplyMiss()
+            {
+                currentHits++;
+                maxBaseScore += base_great;
+                currentCombo = 0;
+            }
+
+            public long TotalScore
+            {
+                get
+                {
+                    double accuracy = currentBaseScore / maxBaseScore;
+
+                    return (int)Math.Round
+                    (
+                        700000 * comboPortion / comboPortionMax +
+                        300000 * Math.Pow(accuracy, 10) * ((double)currentHits / maxCombo)
+                    );
+                }
+            }
+        }
+
+        private class OsuProcessorBasedScoringAlgorithm : ProcessorBasedScoringAlgorithm
+        {
+            public OsuProcessorBasedScoringAlgorithm(IBeatmap beatmap, ScoringMode mode)
+                : base(beatmap, mode)
+            {
+            }
+
+            protected override ScoreProcessor CreateScoreProcessor() => new OsuScoreProcessor();
+            protected override JudgementResult CreatePerfectJudgementResult() => new OsuJudgementResult(new HitCircle(), new OsuJudgement()) { Type = HitResult.Great };
+            protected override JudgementResult CreateNonPerfectJudgementResult() => new OsuJudgementResult(new HitCircle(), new OsuJudgement()) { Type = HitResult.Ok };
+            protected override JudgementResult CreateMissJudgementResult() => new OsuJudgementResult(new HitCircle(), new OsuJudgement()) { Type = HitResult.Miss };
+        }
+    }
+}
@@ -3,6 +3,7 @@

 #nullable disable

+using System;
 using System.Collections.Generic;
 using osu.Framework.Graphics;
 using osu.Game.Audio;
@@ -19,7 +20,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Testing;
-using osu.Game.Beatmaps.Legacy;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Judgements;
@@ -35,16 +35,24 @@ namespace osu.Game.Rulesets.Osu.Tests
    {
        private int depthIndex;

-        private readonly BindableBool snakingIn = new BindableBool();
-        private readonly BindableBool snakingOut = new BindableBool();
+        private readonly BindableBool snakingIn = new BindableBool(true);
+        private readonly BindableBool snakingOut = new BindableBool(true);

-        [SetUpSteps]
-        public void SetUpSteps()
+        private float progressToHit;
+
+        protected override void LoadComplete()
        {
-            AddToggleStep("toggle snaking", v =>
+            base.LoadComplete();
+
+            AddToggleStep("disable snaking", v =>
            {
-                snakingIn.Value = v;
-                snakingOut.Value = v;
+                snakingIn.Value = !v;
+                snakingOut.Value = !v;
+            });
+
+            AddSliderStep("hit at", 0f, 1f, 0f, v =>
+            {
+                progressToHit = v;
            });
        }

@@ -56,6 +64,18 @@ namespace osu.Game.Rulesets.Osu.Tests
            config.BindWith(OsuRulesetSetting.SnakingOutSliders, snakingOut);
        }

+        protected override void Update()
+        {
+            base.Update();
+
+            foreach (var slider in this.ChildrenOfType<DrawableSlider>())
+            {
+                double completionProgress = Math.Clamp((Time.Current - slider.HitObject.StartTime) / slider.HitObject.Duration, 0, 1);
+                if (completionProgress > progressToHit && !slider.IsHit)
+                    slider.HeadCircle.HitArea.Hit();
+            }
+        }
+
        [Test]
        public void TestVariousSliders()
        {
@@ -206,7 +226,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                StackHeight = 10
            };

-            return createDrawable(slider, 2, 2);
+            return createDrawable(slider, 2);
        }

        private Drawable testSimpleMedium(int repeats = 0) => createSlider(5, repeats: repeats);
@@ -229,6 +249,7 @@ namespace osu.Game.Rulesets.Osu.Tests
        {
            var slider = new Slider
            {
+                SliderVelocityMultiplier = speedMultiplier,
                StartTime = Time.Current + time_offset,
                Position = new Vector2(0, -(distance / 2)),
                Path = new SliderPath(PathType.PerfectCurve, new[]
@@ -240,7 +261,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                StackHeight = stackHeight
            };

-            return createDrawable(slider, circleSize, speedMultiplier);
+            return createDrawable(slider, circleSize);
        }

        private Drawable testPerfect(int repeats = 0)
@@ -258,7 +279,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                RepeatCount = repeats,
            };

-            return createDrawable(slider, 2, 3);
+            return createDrawable(slider, 2);
        }

        private Drawable testLinear(int repeats = 0) => createLinear(repeats);
@@ -281,7 +302,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                RepeatCount = repeats,
            };

-            return createDrawable(slider, 2, 3);
+            return createDrawable(slider, 2);
        }

        private Drawable testBezier(int repeats = 0) => createBezier(repeats);
@@ -303,7 +324,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                RepeatCount = repeats,
            };

-            return createDrawable(slider, 2, 3);
+            return createDrawable(slider, 2);
        }

        private Drawable testLinearOverlapping(int repeats = 0) => createOverlapping(repeats);
@@ -326,7 +347,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                RepeatCount = repeats,
            };

-            return createDrawable(slider, 2, 3);
+            return createDrawable(slider, 2);
        }

        private Drawable testCatmull(int repeats = 0) => createCatmull(repeats);
@@ -352,15 +373,12 @@ namespace osu.Game.Rulesets.Osu.Tests
                NodeSamples = repeatSamples
            };

-            return createDrawable(slider, 3, 1);
+            return createDrawable(slider, 3);
        }

-        private Drawable createDrawable(Slider slider, float circleSize, double speedMultiplier)
+        private Drawable createDrawable(Slider slider, float circleSize)
        {
-            var cpi = new LegacyControlPointInfo();
-            cpi.Add(0, new DifficultyControlPoint { SliderVelocity = speedMultiplier });
-
-            slider.ApplyDefaults(cpi, new BeatmapDifficulty
+            slider.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty
            {
                CircleSize = circleSize,
                SliderTickRate = 3
@@ -46,7 +46,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                    {
                        StartTime = time_slider_start,
                        Position = new Vector2(0, 0),
-                        SliderVelocity = velocity,
+                        SliderVelocityMultiplier = velocity,
                        Path = new SliderPath(PathType.Linear, new[]
                        {
                            Vector2.Zero,
@@ -349,7 +349,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                        {
                            StartTime = time_slider_start,
                            Position = new Vector2(0, 0),
-                            SliderVelocity = 0.1f,
+                            SliderVelocityMultiplier = 0.1f,
                            Path = new SliderPath(PathType.PerfectCurve, new[]
                            {
                                Vector2.Zero,
@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -33,7 +31,7 @@ namespace osu.Game.Rulesets.Osu.Tests
    public partial class TestSceneSliderSnaking : TestSceneOsuPlayer
    {
        [Resolved]
-        private AudioManager audioManager { get; set; }
+        private AudioManager audioManager { get; set; } = null!;

        protected override bool Autoplay => autoplay;
        private bool autoplay;
@@ -41,12 +39,12 @@ namespace osu.Game.Rulesets.Osu.Tests
        private readonly BindableBool snakingIn = new BindableBool();
        private readonly BindableBool snakingOut = new BindableBool();

-        private IBeatmap beatmap;
+        private IBeatmap beatmap = null!;

        private const double duration_of_span = 3605;
        private const double fade_in_modifier = -1200;

-        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null)
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard? storyboard = null)
            => new ClockBackedTestWorkingBeatmap(this.beatmap = beatmap, storyboard, new FramedClock(new ManualClock { Rate = 1 }), audioManager);

        [BackgroundDependencyLoader]
@@ -57,15 +55,8 @@ namespace osu.Game.Rulesets.Osu.Tests
            config.BindWith(OsuRulesetSetting.SnakingOutSliders, snakingOut);
        }

-        private Slider slider;
-        private DrawableSlider drawableSlider;
-
-        [SetUp]
-        public void Setup() => Schedule(() =>
-        {
-            slider = null;
-            drawableSlider = null;
-        });
+        private Slider slider = null!;
+        private DrawableSlider? drawableSlider;

        protected override bool HasCustomSteps => true;

@@ -135,9 +126,9 @@ namespace osu.Game.Rulesets.Osu.Tests
        }

        [Test]
-        public void TestRepeatArrowDoesNotMoveWhenHit()
+        public void TestRepeatArrowDoesNotMove([Values] bool useAutoplay)
        {
-            AddStep("enable autoplay", () => autoplay = true);
+            AddStep($"set autoplay to {useAutoplay}", () => autoplay = useAutoplay);
            setSnaking(true);
            CreateTest();
            // repeat might have a chance to update its position depending on where in the frame its hit,
@@ -145,21 +136,12 @@ namespace osu.Game.Rulesets.Osu.Tests
            addCheckPositionChangeSteps(() => 16600, getSliderRepeat, positionAlmostSame);
        }

-        [Test]
-        public void TestRepeatArrowMovesWhenNotHit()
-        {
-            AddStep("disable autoplay", () => autoplay = false);
-            setSnaking(true);
-            CreateTest();
-            addCheckPositionChangeSteps(() => 16600, getSliderRepeat, positionDecreased);
-        }
-
        private void retrieveSlider(int index)
        {
            AddStep("retrieve slider at index", () => slider = (Slider)beatmap.HitObjects[index]);
            addSeekStep(() => slider.StartTime);
            AddUntilStep("retrieve drawable slider", () =>
-                (drawableSlider = (DrawableSlider)Player.DrawableRuleset.Playfield.AllHitObjects.SingleOrDefault(d => d.HitObject == slider)) != null);
+                (drawableSlider = (DrawableSlider?)Player.DrawableRuleset.Playfield.AllHitObjects.SingleOrDefault(d => d.HitObject == slider)) != null);
        }

        private void addEnsureSnakingInSteps(Func<double> startTime) => addCheckPositionChangeSteps(startTime, getSliderEnd, positionIncreased);
@@ -179,7 +161,7 @@ namespace osu.Game.Rulesets.Osu.Tests
        private Func<double> timeAtRepeat(Func<double> startTime, int repeatIndex) => () => startTime() + 100 + duration_of_span * repeatIndex;
        private Func<Vector2> positionAtRepeat(int repeatIndex) => repeatIndex % 2 == 0 ? getSliderStart : getSliderEnd;

-        private List<Vector2> getSliderCurve() => ((PlaySliderBody)drawableSlider.Body.Drawable).CurrentCurve;
+        private List<Vector2> getSliderCurve() => ((PlaySliderBody)drawableSlider!.Body.Drawable).CurrentCurve;
        private Vector2 getSliderStart() => getSliderCurve().First();
        private Vector2 getSliderEnd() => getSliderCurve().Last();

@@ -43,7 +43,8 @@ namespace osu.Game.Rulesets.Osu.Tests
            AddUntilStep("Pitch starts low", () => getSpinningSample().Frequency.Value < 0.8);
            AddUntilStep("Pitch increases", () => getSpinningSample().Frequency.Value > 0.8);

-            PausableSkinnableSound getSpinningSample() => drawableSpinner.ChildrenOfType<PausableSkinnableSound>().FirstOrDefault(s => s.Samples.Any(i => i.LookupNames.Any(l => l.Contains("spinnerspin"))));
+            PausableSkinnableSound getSpinningSample() =>
+                drawableSpinner.ChildrenOfType<PausableSkinnableSound>().FirstOrDefault(s => s.Samples.Any(i => i.LookupNames.Any(l => l.Contains("spinnerspin"))));
        }

        [TestCase(false)]
@@ -64,6 +65,39 @@ namespace osu.Game.Rulesets.Osu.Tests
            AddUntilStep("Short spinner implicitly completes", () => drawableSpinner.Progress == 1);
        }

+        [TestCase(0, 4, 6)]
+        [TestCase(5, 7, 10)]
+        [TestCase(10, 11, 8)]
+        public void TestSpinnerSpinRequirements(int od, int normalTicks, int bonusTicks)
+        {
+            Spinner spinner = null;
+
+            AddStep("add spinner", () => SetContents(_ =>
+            {
+                spinner = new Spinner
+                {
+                    StartTime = Time.Current,
+                    EndTime = Time.Current + 3000,
+                    Samples = new List<HitSampleInfo>
+                    {
+                        new HitSampleInfo(HitSampleInfo.HIT_NORMAL)
+                    }
+                };
+
+                spinner.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty { OverallDifficulty = od });
+
+                return drawableSpinner = new TestDrawableSpinner(spinner, true)
+                {
+                    Anchor = Anchor.Centre,
+                    Depth = depthIndex++,
+                    Scale = new Vector2(0.75f)
+                };
+            }));
+
+            AddAssert("number of normal ticks matches", () => spinner.SpinsRequired, () => Is.EqualTo(normalTicks));
+            AddAssert("number of bonus ticks matches", () => spinner.MaximumBonusSpins, () => Is.EqualTo(bonusTicks));
+        }
+
        private Drawable testSingle(float circleSize, bool auto = false, double length = 3000)
        {
            const double delay = 2000;
@@ -451,7 +451,7 @@ namespace osu.Game.Rulesets.Osu.Tests
        {
            public TestSlider()
            {
-                SliderVelocity = 0.1f;
+                SliderVelocityMultiplier = 0.1f;

                DefaultsApplied += _ =>
                {
@@ -1,10 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
  <Import Project="..\osu.TestProject.props" />
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
    <PackageReference Include="Moq" Version="4.18.4" />
    <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
  </ItemGroup>
  <PropertyGroup Label="Project">
    <OutputType>WinExe</OutputType>
@@ -44,12 +44,11 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                        Position = positionData?.Position ?? Vector2.Zero,
                        NewCombo = comboData?.NewCombo ?? false,
                        ComboOffset = comboData?.ComboOffset ?? 0,
-                        LegacyLastTickOffset = (original as IHasLegacyLastTickOffset)?.LegacyLastTickOffset,
                        // prior to v8, speed multipliers don't adjust for how many ticks are generated over the same distance.
                        // this results in more (or less) ticks being generated in <v8 maps for the same time duration.
                        TickDistanceMultiplier = beatmap.BeatmapInfo.BeatmapVersion < 8 ? 1f / ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(original.StartTime).SliderVelocity : 1,
                        GenerateTicks = generateTicksData?.GenerateTicks ?? true,
-                        SliderVelocity = sliderVelocityData?.SliderVelocity ?? 1,
+                        SliderVelocityMultiplier = sliderVelocityData?.SliderVelocityMultiplier ?? 1,
                    }.Yield();

                case IHasDuration endTimeData:
@@ -26,12 +26,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty

        public override int Version => 20220902;

-        private readonly IWorkingBeatmap workingBeatmap;
-
        public OsuDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
            : base(ruleset, beatmap)
        {
-            workingBeatmap = beatmap;
        }

        protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
@@ -109,15 +106,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                SpinnerCount = spinnerCount,
            };

-            if (ComputeLegacyScoringValues)
-            {
-                OsuLegacyScoreSimulator sv1Simulator = new OsuLegacyScoreSimulator();
-                sv1Simulator.Simulate(workingBeatmap, beatmap, mods);
-                attributes.LegacyAccuracyScore = sv1Simulator.AccuracyScore;
-                attributes.LegacyComboScore = sv1Simulator.ComboScore;
-                attributes.LegacyBonusScoreRatio = sv1Simulator.BonusScoreRatio;
-            }
-
            return attributes;
        }

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

 using System;
-using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Scoring.Legacy;

 namespace osu.Game.Rulesets.Osu.Difficulty
 {
    internal class OsuLegacyScoreSimulator : 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 modernBonusScore;
+        private int standardisedBonusScore;
        private int combo;

        private double scoreMultiplier;
-        private IBeatmap playableBeatmap = null!;

-        public void Simulate(IWorkingBeatmap workingBeatmap, IBeatmap playableBeatmap, IReadOnlyList<Mod> mods)
+        public LegacyScoreAttributes Simulate(IWorkingBeatmap workingBeatmap, IBeatmap playableBeatmap)
        {
-            this.playableBeatmap = playableBeatmap;
-
            IBeatmap baseBeatmap = workingBeatmap.Beatmap;

            int countNormal = 0;
@@ -73,13 +63,19 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                 + baseBeatmap.Difficulty.CircleSize
                 + Math.Clamp((float)objectCount / drainLength * 8, 0, 16)) / 38 * 5);

-            scoreMultiplier = difficultyPeppyStars * mods.Aggregate(1.0, (current, mod) => current * mod.ScoreMultiplier);
+            scoreMultiplier = difficultyPeppyStars;
+
+            LegacyScoreAttributes attributes = new LegacyScoreAttributes();

            foreach (var obj in playableBeatmap.HitObjects)
-                simulateHit(obj);
+                simulateHit(obj, ref attributes);
+
+            attributes.BonusScoreRatio = legacyBonusScore == 0 ? 0 : (double)standardisedBonusScore / legacyBonusScore;
+
+            return attributes;
        }

-        private void simulateHit(HitObject hitObject)
+        private void simulateHit(HitObject hitObject, ref LegacyScoreAttributes attributes)
        {
            bool increaseCombo = true;
            bool addScoreComboMultiplier = false;
@@ -122,7 +118,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty

                case Slider:
                    foreach (var nested in hitObject.NestedHitObjects)
-                        simulateHit(nested);
+                        simulateHit(nested, ref attributes);

                    scoreIncrease = 300;
                    increaseCombo = false;
@@ -133,22 +129,27 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                    // The spinner object applies a lenience because gameplay mechanics differ from osu-stable.
                    // We'll redo the calculations to match osu-stable here...
                    const double maximum_rotations_per_second = 477.0 / 60;
-                    double minimumRotationsPerSecond = IBeatmapDifficultyInfo.DifficultyRange(playableBeatmap.Difficulty.OverallDifficulty, 3, 5, 7.5);
+
+                    // Normally, this value depends on the final overall difficulty. For simplicity, we'll only consider the worst case that maximises bonus score.
+                    // As we're primarily concerned with computing the maximum theoretical final score,
+                    // this will have the final effect of slightly underestimating bonus score achieved on stable when converting from score V1.
+                    const double minimum_rotations_per_second = 3;
+
                    double secondsDuration = spinner.Duration / 1000;

                    // The total amount of half spins possible for the entire spinner.
                    int totalHalfSpinsPossible = (int)(secondsDuration * maximum_rotations_per_second * 2);
                    // The amount of half spins that are required to successfully complete the spinner (i.e. get a 300).
-                    int halfSpinsRequiredForCompletion = (int)(secondsDuration * minimumRotationsPerSecond);
+                    int halfSpinsRequiredForCompletion = (int)(secondsDuration * minimum_rotations_per_second);
                    // To be able to receive bonus points, the spinner must be rotated another 1.5 times.
                    int halfSpinsRequiredBeforeBonus = halfSpinsRequiredForCompletion + 3;

                    for (int i = 0; i <= totalHalfSpinsPossible; i++)
                    {
                        if (i > halfSpinsRequiredBeforeBonus && (i - halfSpinsRequiredBeforeBonus) % 2 == 0)
-                            simulateHit(new SpinnerBonusTick());
+                            simulateHit(new SpinnerBonusTick(), ref attributes);
                        else if (i > 1 && i % 2 == 0)
-                            simulateHit(new SpinnerTick());
+                            simulateHit(new SpinnerTick(), ref attributes);
                    }

                    scoreIncrease = 300;
@@ -159,16 +160,16 @@ namespace osu.Game.Rulesets.Osu.Difficulty
            if (addScoreComboMultiplier)
            {
                // ReSharper disable once PossibleLossOfFraction (intentional to match osu-stable...)
-                ComboScore += (int)(Math.Max(0, combo - 1) * (scoreIncrease / 25 * scoreMultiplier));
+                attributes.ComboScore += (int)(Math.Max(0, combo - 1) * (scoreIncrease / 25 * scoreMultiplier));
            }

            if (isBonus)
            {
                legacyBonusScore += scoreIncrease;
-                modernBonusScore += Judgement.ToNumericResult(bonusResult);
+                standardisedBonusScore += Judgement.ToNumericResult(bonusResult);
            }
            else
-                AccuracyScore += scoreIncrease;
+                attributes.AccuracyScore += scoreIncrease;

            if (increaseCombo)
                combo++;
@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components
        {
            Origin = Anchor.Centre;

-            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+            Size = OsuHitObject.OBJECT_DIMENSIONS;

            InternalChild = content = new Container
            {
@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components
        {
            Origin = Anchor.Centre;

-            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+            Size = OsuHitObject.OBJECT_DIMENSIONS;

            CornerRadius = Size.X / 2;
            CornerExponent = 2;
@@ -85,9 +85,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                    BeginPlacement();

                    double? nearestSliderVelocity = (editorBeatmap.HitObjects
-                                                                  .LastOrDefault(h => h is Slider && h.GetEndTime() < HitObject.StartTime) as Slider)?.SliderVelocity;
+                                                                  .LastOrDefault(h => h is Slider && h.GetEndTime() < HitObject.StartTime) as Slider)?.SliderVelocityMultiplier;

-                    HitObject.SliderVelocity = nearestSliderVelocity ?? 1;
+                    HitObject.SliderVelocityMultiplier = nearestSliderVelocity ?? 1;
                    HitObject.Position = ToLocalSpace(result.ScreenSpacePosition);

                    // Replacing the DifficultyControlPoint above doesn't trigger any kind of invalidation.
@@ -315,7 +315,6 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                    StartTime = HitObject.StartTime,
                    Position = HitObject.Position + splitControlPoints[0].Position,
                    NewCombo = HitObject.NewCombo,
-                    LegacyLastTickOffset = HitObject.LegacyLastTickOffset,
                    Samples = HitObject.Samples.Select(s => s.With()).ToList(),
                    RepeatCount = HitObject.RepeatCount,
                    NodeSamples = HitObject.NodeSamples.Select(n => (IList<HitSampleInfo>)n.Select(s => s.With()).ToList()).ToList(),
@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.Edit
        {
        }

-        protected override DrawableRuleset<OsuHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods = null)
+        protected override DrawableRuleset<OsuHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods)
            => new DrawableOsuEditorRuleset(ruleset, beatmap, mods);

        protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
@@ -61,10 +61,12 @@ namespace osu.Game.Rulesets.Osu.Mods

        public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
        {
+            OsuHitObject firstObject = drawableRuleset.Beatmap.HitObjects.First();
+
            // Multiplying by 2 results in an initial size that is too large, hence 1.90 has been chosen
            // Also avoids the HitObject bleeding around the edges of the bubble drawable at minimum size
-            bubbleSize = (float)(drawableRuleset.Beatmap.HitObjects.OfType<HitCircle>().First().Radius * 1.90f);
-            bubbleFade = drawableRuleset.Beatmap.HitObjects.OfType<HitCircle>().First().TimePreempt * 2;
+            bubbleSize = (float)firstObject.Radius * 1.90f;
+            bubbleFade = firstObject.TimePreempt * 2;

            // We want to hide the judgements since they are obscured by the BubbleDrawable (due to layering)
            drawableRuleset.Playfield.DisplayJudgements.Value = false;
@@ -25,9 +25,6 @@ namespace osu.Game.Rulesets.Osu.Mods
        [SettingSource("No slider head accuracy requirement", "Scores sliders proportionally to the number of ticks hit.")]
        public Bindable<bool> NoSliderHeadAccuracy { get; } = new BindableBool(true);

-        [SettingSource("No slider head movement", "Pins slider heads at their starting position, regardless of time.")]
-        public Bindable<bool> NoSliderHeadMovement { get; } = new BindableBool(true);
-
        [SettingSource("Apply classic note lock", "Applies note lock to the full hit window.")]
        public Bindable<bool> ClassicNoteLock { get; } = new BindableBool(true);

@@ -71,12 +68,11 @@ namespace osu.Game.Rulesets.Osu.Mods
            switch (obj)
            {
                case DrawableSliderHead head:
-                    head.TrackFollowCircle = !NoSliderHeadMovement.Value;
                    if (FadeHitCircleEarly.Value && !usingHiddenFading)
                        applyEarlyFading(head);

                    if (ClassicNoteLock.Value)
-                        blockInputToUnderlyingObjects(head);
+                        blockInputToObjectsUnderSliderHead(head);

                    break;

@@ -88,25 +84,23 @@ namespace osu.Game.Rulesets.Osu.Mods
                    if (FadeHitCircleEarly.Value && !usingHiddenFading)
                        applyEarlyFading(circle);

-                    if (ClassicNoteLock.Value)
-                        blockInputToUnderlyingObjects(circle);
-
                    break;
            }
        }

        /// <summary>
-        /// On stable, hitcircles that have already been hit block input from reaching objects that may be underneath them.
+        /// On stable, slider heads that have already been hit block input from reaching objects that may be underneath them
+        /// until the sliders they're part of have been fully judged.
        /// The purpose of this method is to restore that behaviour.
        /// In order to avoid introducing yet another confusing config option, this behaviour is roped into the general notion of "note lock".
        /// </summary>
-        private static void blockInputToUnderlyingObjects(DrawableHitCircle circle)
+        private static void blockInputToObjectsUnderSliderHead(DrawableSliderHead slider)
        {
-            var oldHitAction = circle.HitArea.Hit;
-            circle.HitArea.Hit = () =>
+            var oldHitAction = slider.HitArea.Hit;
+            slider.HitArea.Hit = () =>
            {
                oldHitAction?.Invoke();
-                return true;
+                return !slider.DrawableSlider.AllJudged;
            };
        }

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

 using System.Linq;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Configuration;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Objects;

 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModDifficultyAdjust : ModDifficultyAdjust
+    public partial class OsuModDifficultyAdjust : ModDifficultyAdjust
    {
        [SettingSource("Circle Size", "Override a beatmap's set CS.", FIRST_SETTING_ORDER - 1, SettingControlType = typeof(DifficultyAdjustSettingsControl))]
        public DifficultyBindable CircleSize { get; } = new DifficultyBindable
@@ -20,12 +26,13 @@ namespace osu.Game.Rulesets.Osu.Mods
            ReadCurrentFromDifficulty = diff => diff.CircleSize,
        };

-        [SettingSource("Approach Rate", "Override a beatmap's set AR.", LAST_SETTING_ORDER + 1, SettingControlType = typeof(DifficultyAdjustSettingsControl))]
+        [SettingSource("Approach Rate", "Override a beatmap's set AR.", LAST_SETTING_ORDER + 1, SettingControlType = typeof(ApproachRateSettingsControl))]
        public DifficultyBindable ApproachRate { get; } = new DifficultyBindable
        {
            Precision = 0.1f,
            MinValue = 0,
            MaxValue = 10,
+            ExtendedMinValue = -10,
            ExtendedMaxValue = 11,
            ReadCurrentFromDifficulty = diff => diff.ApproachRate,
        };
@@ -53,5 +60,34 @@ namespace osu.Game.Rulesets.Osu.Mods
            if (CircleSize.Value != null) difficulty.CircleSize = CircleSize.Value.Value;
            if (ApproachRate.Value != null) difficulty.ApproachRate = ApproachRate.Value.Value;
        }
+
+        private partial class ApproachRateSettingsControl : DifficultyAdjustSettingsControl
+        {
+            protected override RoundedSliderBar<float> CreateSlider(BindableNumber<float> current) =>
+                new ApproachRateSlider
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Current = current,
+                    KeyboardStep = 0.1f,
+                };
+
+            /// <summary>
+            /// A slider bar with more detailed approach rate info for its given value
+            /// </summary>
+            public partial class ApproachRateSlider : RoundedSliderBar<float>
+            {
+                public override LocalisableString TooltipText =>
+                    (Current as BindableNumber<float>)?.MinValue < 0
+                        ? $"{base.TooltipText} ({getPreemptTime(Current.Value):0} ms)"
+                        : base.TooltipText;
+
+                private double getPreemptTime(float approachRate)
+                {
+                    var hitCircle = new HitCircle();
+                    hitCircle.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty { ApproachRate = approachRate });
+                    return hitCircle.TimePreempt;
+                }
+            }
+        }
    }
 }
@@ -96,14 +96,13 @@ namespace osu.Game.Rulesets.Osu.Mods
                Position = original.Position;
                NewCombo = original.NewCombo;
                ComboOffset = original.ComboOffset;
-                LegacyLastTickOffset = original.LegacyLastTickOffset;
                TickDistanceMultiplier = original.TickDistanceMultiplier;
-                SliderVelocity = original.SliderVelocity;
+                SliderVelocityMultiplier = original.SliderVelocityMultiplier;
            }

            protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
            {
-                var sliderEvents = SliderEventGenerator.Generate(StartTime, SpanDuration, Velocity, TickDistance, Path.Distance, this.SpanCount(), LegacyLastTickOffset, cancellationToken);
+                var sliderEvents = SliderEventGenerator.Generate(StartTime, SpanDuration, Velocity, TickDistance, Path.Distance, this.SpanCount(), cancellationToken);

                foreach (var e in sliderEvents)
                {
@@ -130,7 +129,7 @@ namespace osu.Game.Rulesets.Osu.Mods
                            });
                            break;

-                        case SliderEventType.LegacyLastTick:
+                        case SliderEventType.LastTick:
                            AddNested(TailCircle = new StrictTrackingSliderTailCircle(this)
                            {
                                RepeatIndex = e.SpanIndex,
@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Osu.Mods

            d.HitObjectApplied += _ =>
            {
-                // slider tails are a painful edge case, as their start time is offset 36ms back (see `LegacyLastTick`).
+                // slider tails are a painful edge case, as their start time is offset 36ms back (see `LastTick`).
                // to work around this, look up the slider tail's parenting slider's end time instead to ensure proper snap.
                double snapTime = d is DrawableSliderTail tail
                    ? tail.Slider.GetEndTime()
@@ -4,6 +4,7 @@
 #nullable disable

 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
@@ -34,6 +35,11 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
        public HitReceptor HitArea { get; private set; }
        public SkinnableDrawable CirclePiece { get; private set; }

+        protected override IEnumerable<Drawable> DimmablePieces => new[]
+        {
+            CirclePiece,
+        };
+
        Drawable IHasApproachCircle.ApproachCircle => ApproachCircle;

        private Container scaleContainer;
@@ -191,7 +197,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables

            CirclePiece.FadeInFromZero(HitObject.TimeFadeIn);

-            ApproachCircle.FadeIn(Math.Min(HitObject.TimeFadeIn * 2, HitObject.TimePreempt));
+            ApproachCircle.FadeTo(0.9f, Math.Min(HitObject.TimeFadeIn * 2, HitObject.TimePreempt));
            ApproachCircle.ScaleTo(1f, HitObject.TimePreempt);
            ApproachCircle.Expire(true);
        }
@@ -244,7 +250,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables

            public HitReceptor()
            {
-                Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+                Size = OsuHitObject.OBJECT_DIMENSIONS;

                Anchor = Anchor.Centre;
                Origin = Anchor.Centre;
@@ -4,6 +4,8 @@
 #nullable disable

 using System;
+using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -71,20 +73,17 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
            ScaleBindable.UnbindFrom(HitObject.ScaleBindable);
        }

+        protected virtual IEnumerable<Drawable> DimmablePieces => Enumerable.Empty<Drawable>();
+
        protected override void UpdateInitialTransforms()
        {
            base.UpdateInitialTransforms();

-            // Dim should only be applied at a top level, as it will be implicitly applied to nested objects.
-            if (ParentHitObject == null)
+            foreach (var piece in DimmablePieces)
            {
-                // Of note, no one noticed this was missing for years, but it definitely feels like it should still exist.
-                // For now this is applied across all skins, and matches stable.
-                // For simplicity, dim colour is applied to the DrawableHitObject itself.
-                // We may need to make a nested container setup if this even causes a usage conflict (ie. with a mod).
-                this.FadeColour(new Color4(195, 195, 195, 255));
-                using (BeginDelayedSequence(InitialLifetimeOffset - OsuHitWindows.MISS_WINDOW))
-                    this.FadeColour(Color4.White, 100);
+                piece.FadeColour(new Color4(195, 195, 195, 255));
+                using (piece.BeginDelayedSequence(InitialLifetimeOffset - OsuHitWindows.MISS_WINDOW))
+                    piece.FadeColour(Color4.White, 100);
            }
        }

@@ -4,6 +4,7 @@
 #nullable disable

 using System;
+using System.Collections.Generic;
 using System.Linq;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
@@ -35,6 +36,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables

        private ShakeContainer shakeContainer;

+        protected override IEnumerable<Drawable> DimmablePieces => new Drawable[]
+        {
+            HeadCircle,
+            TailCircle,
+            Body,
+        };
+
        /// <summary>
        /// A target container which can be used to add top level elements to the slider's display.
        /// Intended to be used for proxy purposes only.
@@ -228,7 +236,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
            double completionProgress = Math.Clamp((Time.Current - HitObject.StartTime) / HitObject.Duration, 0, 1);

            Ball.UpdateProgress(completionProgress);
-            SliderBody?.UpdateProgress(completionProgress);
+            SliderBody?.UpdateProgress(HeadCircle.IsHit ? completionProgress : 0);

            foreach (DrawableHitObject hitObject in NestedHitObjects)
            {
@@ -288,7 +296,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
        public override void PlaySamples()
        {
            // rather than doing it this way, we should probably attach the sample to the tail circle.
-            // this can only be done after we stop using LegacyLastTick.
+            // this can only be done if we stop using LastTick.
            if (!TailCircle.SamplePlaysOnlyOnHit || TailCircle.IsHit)
                base.PlaySamples();
        }
@@ -317,7 +325,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
            switch (state)
            {
                case ArmedState.Hit:
-                    if (SliderBody?.SnakingOut.Value == true)
+                    if (HeadCircle.IsHit && SliderBody?.SnakingOut.Value == true)
                        Body.FadeOut(40); // short fade to allow for any body colour to smoothly disappear.
                    break;
            }
@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables

            Origin = Anchor.Centre;

-            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+            Size = OsuHitObject.OBJECT_DIMENSIONS;

            Children = new[]
            {
@@ -3,11 +3,9 @@

 #nullable disable

-using System;
 using System.Diagnostics;
 using JetBrains.Annotations;
 using osu.Framework.Bindables;
-using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Scoring;

@@ -24,12 +22,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables

        public override bool DisplayResult => HitObject?.JudgeAsNormalHitCircle ?? base.DisplayResult;

-        /// <summary>
-        /// Makes this <see cref="DrawableSliderHead"/> track the follow circle when the start time is reached.
-        /// If <c>false</c>, this <see cref="DrawableSliderHead"/> will be pinned to its initial position in the slider.
-        /// </summary>
-        public bool TrackFollowCircle = true;
-
        private readonly IBindable<int> pathVersion = new Bindable<int>();

        protected override OsuSkinComponents CirclePieceComponent => OsuSkinComponents.SliderHeadHitCircle;
@@ -64,23 +56,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
            CheckHittable = (d, t, r) => DrawableSlider.CheckHittable?.Invoke(d, t, r) ?? ClickAction.Hit;
        }

-        protected override void Update()
-        {
-            base.Update();
-
-            Debug.Assert(Slider != null);
-            Debug.Assert(HitObject != null);
-
-            if (TrackFollowCircle)
-            {
-                double completionProgress = Math.Clamp((Time.Current - Slider.StartTime) / Slider.Duration, 0, 1);
-
-                //todo: we probably want to reconsider this before adding scoring, but it looks and feels nice.
-                if (!IsHit)
-                    Position = Slider.CurvePositionAt(completionProgress);
-            }
-        }
-
        protected override HitResult ResultFor(double timeOffset)
        {
            Debug.Assert(HitObject != null);
@@ -30,7 +30,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables

        public SkinnableDrawable CirclePiece { get; private set; }

-        public ReverseArrowPiece Arrow { get; private set; }
+        public SkinnableDrawable Arrow { get; private set; }

        private Drawable scaleContainer;

@@ -50,7 +50,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
        private void load()
        {
            Origin = Anchor.Centre;
-            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+            Size = OsuHitObject.OBJECT_DIMENSIONS;

            AddInternal(scaleContainer = new Container
            {
@@ -65,7 +65,11 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                        Anchor = Anchor.Centre,
                        Origin = Anchor.Centre,
                    },
-                    Arrow = new ReverseArrowPiece(),
+                    Arrow = new SkinnableDrawable(new OsuSkinComponentLookup(OsuSkinComponents.ReverseArrow), _ => new DefaultReverseArrow())
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    },
                }
            });

@@ -55,7 +55,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
        private void load()
        {
            Origin = Anchor.Centre;
-            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+            Size = OsuHitObject.OBJECT_DIMENSIONS;

            AddRangeInternal(new Drawable[]
            {
@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
        [BackgroundDependencyLoader]
        private void load()
        {
-            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+            Size = OsuHitObject.OBJECT_DIMENSIONS;
            Origin = Anchor.Centre;

            AddInternal(scaleContainer = new SkinnableDrawable(new OsuSkinComponentLookup(OsuSkinComponents.SliderScorePoint), _ => new CircularContainer
@@ -286,7 +286,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables

        private static readonly int score_per_tick = new SpinnerBonusTick.OsuSpinnerBonusTickJudgement().MaxNumericResult;

-        private int wholeSpins;
+        private int completedFullSpins;

        private void updateBonusScore()
        {
@@ -295,14 +295,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables

            int spins = (int)(Result.RateAdjustedRotation / 360);

-            if (spins < wholeSpins)
+            if (spins < completedFullSpins)
            {
                // rewinding, silently handle
-                wholeSpins = spins;
+                completedFullSpins = spins;
                return;
            }

-            while (wholeSpins != spins)
+            while (completedFullSpins != spins)
            {
                var tick = ticks.FirstOrDefault(t => !t.Result.HasResult);

@@ -312,10 +312,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                    tick.TriggerResult(true);

                    if (tick is DrawableSpinnerBonusTick)
-                        gainedBonus.Value = score_per_tick * (spins - HitObject.SpinsRequired);
+                        gainedBonus.Value = score_per_tick * (spins - HitObject.SpinsRequiredForBonus);
                }

-                wholeSpins++;
+                completedFullSpins++;
            }
        }
    }
@@ -21,6 +21,11 @@ namespace osu.Game.Rulesets.Osu.Objects
        /// </summary>
        public const float OBJECT_RADIUS = 64;

+        /// <summary>
+        /// The width and height any element participating in display of a hitcircle (or similarly sized object) should be.
+        /// </summary>
+        public static readonly Vector2 OBJECT_DIMENSIONS = new Vector2(OBJECT_RADIUS * 2);
+
        /// <summary>
        /// Scoring distance with a speed-adjusted beat length of 1 second (ie. the speed slider balls move through their track).
        /// </summary>
@@ -16,6 +16,7 @@ using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;

@@ -70,8 +71,6 @@ namespace osu.Game.Rulesets.Osu.Objects
            }
        }

-        public double? LegacyLastTickOffset { get; set; }
-
        /// <summary>
        /// The position of the cursor at the point of completion of this <see cref="Slider"/> if it was hit
        /// with as few movements as possible. This is set and used by difficulty calculation.
@@ -113,7 +112,7 @@ namespace osu.Game.Rulesets.Osu.Objects
        public double SpanDuration => Duration / this.SpanCount();

        /// <summary>
-        /// Velocity of this <see cref="Slider"/>.
+        /// The computed velocity of this <see cref="Slider"/>. This is the amount of path distance travelled in 1 ms.
        /// </summary>
        public double Velocity { get; private set; }

@@ -134,17 +133,16 @@ namespace osu.Game.Rulesets.Osu.Objects
        /// </summary>
        public bool OnlyJudgeNestedObjects = true;

-        public BindableNumber<double> SliderVelocityBindable { get; } = new BindableDouble(1)
+        public BindableNumber<double> SliderVelocityMultiplierBindable { get; } = new BindableDouble(1)
        {
-            Precision = 0.01,
            MinValue = 0.1,
            MaxValue = 10
        };

-        public double SliderVelocity
+        public double SliderVelocityMultiplier
        {
-            get => SliderVelocityBindable.Value;
-            set => SliderVelocityBindable.Value = value;
+            get => SliderVelocityMultiplierBindable.Value;
+            set => SliderVelocityMultiplierBindable.Value = value;
        }

        public bool GenerateTicks { get; set; } = true;
@@ -167,9 +165,11 @@ namespace osu.Game.Rulesets.Osu.Objects

            TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);

-            double scoringDistance = BASE_SCORING_DISTANCE * difficulty.SliderMultiplier * SliderVelocity;
+            Velocity = BASE_SCORING_DISTANCE * difficulty.SliderMultiplier / LegacyRulesetExtensions.GetPrecisionAdjustedBeatLength(this, timingPoint, OsuRuleset.SHORT_NAME);
+            // WARNING: this is intentionally not computed as `BASE_SCORING_DISTANCE * difficulty.SliderMultiplier`
+            // for backwards compatibility reasons (intentionally introducing floating point errors to match stable).
+            double scoringDistance = Velocity * timingPoint.BeatLength;

-            Velocity = scoringDistance / timingPoint.BeatLength;
            TickDistance = GenerateTicks ? (scoringDistance / difficulty.SliderTickRate * TickDistanceMultiplier) : double.PositiveInfinity;
        }

@@ -177,7 +177,7 @@ namespace osu.Game.Rulesets.Osu.Objects
        {
            base.CreateNestedHitObjects(cancellationToken);

-            var sliderEvents = SliderEventGenerator.Generate(StartTime, SpanDuration, Velocity, TickDistance, Path.Distance, this.SpanCount(), LegacyLastTickOffset, cancellationToken);
+            var sliderEvents = SliderEventGenerator.Generate(StartTime, SpanDuration, Velocity, TickDistance, Path.Distance, this.SpanCount(), cancellationToken);

            foreach (var e in sliderEvents)
            {
@@ -204,10 +204,11 @@ namespace osu.Game.Rulesets.Osu.Objects
                        });
                        break;

-                    case SliderEventType.LegacyLastTick:
-                        // we need to use the LegacyLastTick here for compatibility reasons (difficulty).
-                        // it is *okay* to use this because the TailCircle is not used for any meaningful purpose in gameplay.
-                        // if this is to change, we should revisit this.
+                    case SliderEventType.LastTick:
+                        // Of note, we are directly mapping LastTick (instead of `SliderEventType.Tail`)  to SliderTailCircle.
+                        // It is required as difficulty calculation and gameplay relies on reading this value.
+                        // (although it is displayed in classic skins, which may be a concern).
+                        // If this is to change, we should revisit this.
                        AddNested(TailCircle = new SliderTailCircle(this)
                        {
                            RepeatIndex = e.SpanIndex,
@@ -262,7 +263,9 @@ namespace osu.Game.Rulesets.Osu.Objects
            if (HeadCircle != null)
                HeadCircle.Samples = this.GetNodeSamples(0);

-            // The samples should be attached to the slider tail, however this can only be done after LegacyLastTick is removed otherwise they would play earlier than they're intended to.
+            // The samples should be attached to the slider tail, however this can only be done if LastTick is removed otherwise they would play earlier than they're intended to.
+            // (see mapping logic in `CreateNestedHitObjects` above)
+            //
            // For now, the samples are played by the slider itself at the correct end time.
            TailSamples = this.GetNodeSamples(repeatCount + 1);
        }
@@ -10,7 +10,7 @@ namespace osu.Game.Rulesets.Osu.Objects
 {
    /// <summary>
    /// Note that this should not be used for timing correctness.
-    /// See <see cref="SliderEventType.LegacyLastTick"/> usage in <see cref="Slider"/> for more information.
+    /// See <see cref="SliderEventType.LastTick"/> usage in <see cref="Slider"/> for more information.
    /// </summary>
    public class SliderTailCircle : SliderEndCircle
    {
@@ -18,6 +18,16 @@ namespace osu.Game.Rulesets.Osu.Objects
 {
    public class Spinner : OsuHitObject, IHasDuration
    {
+        /// <summary>
+        /// The RPM required to clear the spinner at ODs [ 0, 5, 10 ].
+        /// </summary>
+        private static readonly (int min, int mid, int max) clear_rpm_range = (90, 150, 225);
+
+        /// <summary>
+        /// The RPM required to complete the spinner and receive full score at ODs [ 0, 5, 10 ].
+        /// </summary>
+        private static readonly (int min, int mid, int max) complete_rpm_range = (250, 380, 430);
+
        public double EndTime
        {
            get => StartTime + Duration;
@@ -31,6 +41,16 @@ namespace osu.Game.Rulesets.Osu.Objects
        /// </summary>
        public int SpinsRequired { get; protected set; } = 1;

+        /// <summary>
+        /// The number of spins required to start receiving bonus score. The first bonus is awarded on this spin count.
+        /// </summary>
+        public int SpinsRequiredForBonus => SpinsRequired + bonus_spins_gap;
+
+        /// <summary>
+        /// The gap between spinner completion and the first bonus-awarding spin.
+        /// </summary>
+        private const int bonus_spins_gap = 2;
+
        /// <summary>
        /// Number of spins available to give bonus, beyond <see cref="SpinsRequired"/>.
        /// </summary>
@@ -42,25 +62,26 @@ namespace osu.Game.Rulesets.Osu.Objects
        {
            base.ApplyDefaultsToSelf(controlPointInfo, difficulty);

-            // spinning doesn't match 1:1 with stable, so let's fudge them easier for the time being.
-            const double stable_matching_fudge = 0.6;
+            // The average RPS required over the length of the spinner to clear the spinner.
+            double minRps = IBeatmapDifficultyInfo.DifficultyRange(difficulty.OverallDifficulty, clear_rpm_range) / 60;

-            // close to 477rpm
-            const double maximum_rotations_per_second = 8;
+            // The RPS required over the length of the spinner to receive full score (all normal + bonus ticks).
+            double maxRps = IBeatmapDifficultyInfo.DifficultyRange(difficulty.OverallDifficulty, complete_rpm_range) / 60;

            double secondsDuration = Duration / 1000;

-            double minimumRotationsPerSecond = stable_matching_fudge * IBeatmapDifficultyInfo.DifficultyRange(difficulty.OverallDifficulty, 3, 5, 7.5);
+            // Allow a 0.1ms floating point precision error in the calculation of the duration.
+            const double duration_error = 0.0001;

-            SpinsRequired = (int)(secondsDuration * minimumRotationsPerSecond);
-            MaximumBonusSpins = (int)((maximum_rotations_per_second - minimumRotationsPerSecond) * secondsDuration);
+            SpinsRequired = (int)(minRps * secondsDuration + duration_error);
+            MaximumBonusSpins = Math.Max(0, (int)(maxRps * secondsDuration + duration_error) - SpinsRequired - bonus_spins_gap);
        }

        protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
        {
            base.CreateNestedHitObjects(cancellationToken);

-            int totalSpins = MaximumBonusSpins + SpinsRequired;
+            int totalSpins = MaximumBonusSpins + SpinsRequired + bonus_spins_gap;

            for (int i = 0; i < totalSpins; i++)
            {
@@ -68,7 +89,7 @@ namespace osu.Game.Rulesets.Osu.Objects

                double startTime = StartTime + (float)(i + 1) / totalSpins * Duration;

-                AddNested(i < SpinsRequired
+                AddNested(i < SpinsRequiredForBonus
                    ? new SpinnerTick { StartTime = startTime, SpinnerDuration = Duration }
                    : new SpinnerBonusTick { StartTime = startTime, SpinnerDuration = Duration, Samples = new[] { CreateHitSampleInfo("spinnerbonus") } });
            }
@@ -33,6 +33,7 @@ using osu.Game.Rulesets.Osu.Statistics;
 using osu.Game.Rulesets.Osu.UI;
 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;
@@ -0,0 +1,94 @@
+{
+  "Mappings": [
+    {
+      "StartTime": 46060.0,
+      "Objects": [
+        {
+          "StartTime": 46060.0,
+          "EndTime": 46060.0,
+          "X": 160.0,
+          "Y": 208.0,
+          "StackOffset": {
+            "X": 0.0,
+            "Y": 0.0
+          }
+        },
+        {
+          "StartTime": 46398.0,
+          "EndTime": 46398.0,
+          "X": 160.980164,
+          "Y": 317.779083,
+          "StackOffset": {
+            "X": 0.0,
+            "Y": 0.0
+          }
+        },
+        {
+          "StartTime": 46737.0,
+          "EndTime": 46737.0,
+          "X": 268.887268,
+          "Y": 320.0,
+          "StackOffset": {
+            "X": 0.0,
+            "Y": 0.0
+          }
+        },
+        {
+          "StartTime": 47040.0,
+          "EndTime": 47040.0,
+          "X": 378.995544,
+          "Y": 320.0,
+          "StackOffset": {
+            "X": 0.0,
+            "Y": 0.0
+          }
+        }
+      ]
+    },
+    {
+      "StartTime": 123348.0,
+      "Objects": [
+        {
+          "StartTime": 123348.0,
+          "EndTime": 123348.0,
+          "X": 352.0,
+          "Y": 160.0,
+          "StackOffset": {
+            "X": 0.0,
+            "Y": 0.0
+          }
+        },
+        {
+          "StartTime": 123686.0,
+          "EndTime": 123686.0,
+          "X": 351.019836,
+          "Y": 50.2209129,
+          "StackOffset": {
+            "X": 0.0,
+            "Y": 0.0
+          }
+        },
+        {
+          "StartTime": 124025.0,
+          "EndTime": 124025.0,
+          "X": 243.112747,
+          "Y": 48.0,
+          "StackOffset": {
+            "X": 0.0,
+            "Y": 0.0
+          }
+        },
+        {
+          "StartTime": 124328.0,
+          "EndTime": 124328.0,
+          "X": 133.004471,
+          "Y": 48.0,
+          "StackOffset": {
+            "X": 0.0,
+            "Y": 0.0
+          }
+        }
+      ]
+    }
+  ]
+}
@@ -0,0 +1,19 @@
+osu file format v6
+
+[General]
+StackLeniency: 0.7
+
+[Difficulty]
+HPDrainRate:1
+CircleSize:3
+OverallDifficulty:1
+SliderMultiplier:1.1
+SliderTickRate:1
+
+[TimingPoints]
+-41,338.983050847458,4,1,0,70,1,0
+93648,-100,4,1,0,70,0,0
+
+[HitObjects]
+160,208,46060,6,0,B|161:320|161:320|271:320|271:320,1,330,8|0
+352,160,123348,6,0,B|351:48|351:48|241:48|241:48,1,330,8|0
@@ -0,0 +1,39 @@
+{
+  "Mappings": [
+    {
+      "StartTime": 7493.0,
+      "Objects": [
+        {
+          "StartTime": 7493.0,
+          "EndTime": 7493.0,
+          "X": 130.0,
+          "Y": 232.0,
+          "StackOffset": {
+            "X": 0.0,
+            "Y": 0.0
+          }
+        },
+        {
+          "StartTime": 7817.0,
+          "EndTime": 7817.0,
+          "X": 30.9946651,
+          "Y": 208.5157,
+          "StackOffset": {
+            "X": 0.0,
+            "Y": 0.0
+          }
+        },
+        {
+          "StartTime": 7843.0,
+          "EndTime": 7843.0,
+          "X": 33.7820168,
+          "Y": 208.9957,
+          "StackOffset": {
+            "X": 0.0,
+            "Y": 0.0
+          }
+        }
+      ]
+    }
+  ]
+}
@@ -0,0 +1,31 @@
+osu file format v14
+
+[General]
+StackLeniency: 0.7
+
+[Difficulty]
+HPDrainRate:3
+CircleSize:3.4
+OverallDifficulty:4
+ApproachRate:5.5
+SliderMultiplier:1.1
+SliderTickRate:1
+
+[Events]
+//Background and Video events
+0,0,"aa.jpg",0,0
+//Break Periods
+//Storyboard Layer 0 (Background)
+//Storyboard Layer 1 (Fail)
+//Storyboard Layer 2 (Pass)
+//Storyboard Layer 3 (Foreground)
+//Storyboard Layer 4 (Overlay)
+//Storyboard Sound Samples
+
+[TimingPoints]
+6967,350.877192982456,6,2,1,55,1,0
+6967,-100,3,2,1,55,0,0
+7493,-111.111111111111,3,2,1,55,0,0
+
+[HitObjects]
+130,232,7493,6,0,P|78:218|28:208,1,101.82149697876,0|0,3:2|2:0,2:0:0:0:
@@ -48,7 +48,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon

        private Bindable<bool> configHitLighting = null!;

-        private static readonly Vector2 circle_size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+        private static readonly Vector2 circle_size = OsuHitObject.OBJECT_DIMENSIONS;

        [Resolved]
        private DrawableHitObject drawableObject { get; set; } = null!;
@@ -4,10 +4,12 @@
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
 using osuTK;
@@ -17,38 +19,92 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
 {
    public partial class ArgonReverseArrow : CompositeDrawable
    {
+        [Resolved]
+        private DrawableHitObject drawableObject { get; set; } = null!;
+
        private Bindable<Color4> accentColour = null!;

        private SpriteIcon icon = null!;
+        private Container main = null!;
+        private Sprite side = null!;

        [BackgroundDependencyLoader]
-        private void load(DrawableHitObject hitObject)
+        private void load(TextureStore textures)
        {
            Anchor = Anchor.Centre;
            Origin = Anchor.Centre;

-            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+            Size = OsuHitObject.OBJECT_DIMENSIONS;

            InternalChildren = new Drawable[]
            {
-                new Circle
+                main = new Container
                {
-                    Size = new Vector2(40, 20),
-                    Colour = Color4.White,
+                    RelativeSizeAxes = Axes.Both,
                    Anchor = Anchor.Centre,
                    Origin = Anchor.Centre,
+                    Children = new Drawable[]
+                    {
+                        new Circle
+                        {
+                            Size = new Vector2(40, 20),
+                            Colour = Color4.White,
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                        },
+                        icon = new SpriteIcon
+                        {
+                            Icon = FontAwesome.Solid.AngleDoubleRight,
+                            Size = new Vector2(16),
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                        },
+                    }
                },
-                icon = new SpriteIcon
+                side = new Sprite
                {
-                    Icon = FontAwesome.Solid.AngleDoubleRight,
-                    Size = new Vector2(16),
                    Anchor = Anchor.Centre,
                    Origin = Anchor.Centre,
-                },
+                    Texture = textures.Get("Gameplay/osu/repeat-edge-piece"),
+                    Size = new Vector2(ArgonMainCirclePiece.OUTER_GRADIENT_SIZE),
+                }
            };

-            accentColour = hitObject.AccentColour.GetBoundCopy();
+            accentColour = drawableObject.AccentColour.GetBoundCopy();
            accentColour.BindValueChanged(accent => icon.Colour = accent.NewValue.Darken(4), true);
+
+            drawableObject.ApplyCustomUpdateState += updateStateTransforms;
+        }
+
+        private void updateStateTransforms(DrawableHitObject hitObject, ArmedState state)
+        {
+            const float move_distance = -12;
+            const double move_out_duration = 35;
+            const double move_in_duration = 250;
+            const double total = 300;
+
+            switch (state)
+            {
+                case ArmedState.Idle:
+                    main.ScaleTo(1.3f, move_out_duration, Easing.Out)
+                        .Then()
+                        .ScaleTo(1f, move_in_duration, Easing.Out)
+                        .Loop(total - (move_in_duration + move_out_duration));
+                    side
+                        .MoveToX(move_distance, move_out_duration, Easing.Out)
+                        .Then()
+                        .MoveToX(0, move_in_duration, Easing.Out)
+                        .Loop(total - (move_in_duration + move_out_duration));
+                    break;
+            }
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (drawableObject.IsNotNull())
+                drawableObject.ApplyCustomUpdateState -= updateStateTransforms;
        }
    }
 }
@@ -9,7 +9,6 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
-using osuTK;

 namespace osu.Game.Rulesets.Osu.Skinning.Default
 {
@@ -22,7 +21,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default

        public CirclePiece()
        {
-            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+            Size = OsuHitObject.OBJECT_DIMENSIONS;
            Masking = true;

            CornerRadius = Size.X / 2;
@@ -0,0 +1,69 @@
+// 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.Allocation;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Skinning.Default
+{
+    public partial class DefaultReverseArrow : CompositeDrawable
+    {
+        [Resolved]
+        private DrawableHitObject drawableObject { get; set; } = null!;
+
+        public DefaultReverseArrow()
+        {
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            Size = OsuHitObject.OBJECT_DIMENSIONS;
+
+            InternalChild = new SpriteIcon
+            {
+                RelativeSizeAxes = Axes.Both,
+                Blending = BlendingParameters.Additive,
+                Icon = FontAwesome.Solid.ChevronRight,
+                Size = new Vector2(0.35f),
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            drawableObject.ApplyCustomUpdateState += updateStateTransforms;
+        }
+
+        private void updateStateTransforms(DrawableHitObject hitObject, ArmedState state)
+        {
+            const double move_out_duration = 35;
+            const double move_in_duration = 250;
+            const double total = 300;
+
+            switch (state)
+            {
+                case ArmedState.Idle:
+                    InternalChild.ScaleTo(1.3f, move_out_duration, Easing.Out)
+                                 .Then()
+                                 .ScaleTo(1f, move_in_duration, Easing.Out)
+                                 .Loop(total - (move_in_duration + move_out_duration));
+                    break;
+            }
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (drawableObject.IsNotNull())
+                drawableObject.ApplyCustomUpdateState -= updateStateTransforms;
+        }
+    }
+}
@@ -7,7 +7,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
-using osuTK;

 namespace osu.Game.Rulesets.Osu.Skinning.Default
 {
@@ -20,7 +19,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default

        public ExplodePiece()
        {
-            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+            Size = OsuHitObject.OBJECT_DIMENSIONS;

            Anchor = Anchor.Centre;
            Origin = Anchor.Centre;
@@ -5,7 +5,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Rulesets.Osu.Objects;
-using osuTK;

 namespace osu.Game.Rulesets.Osu.Skinning.Default
 {
@@ -13,7 +12,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
    {
        public FlashPiece()
        {
-            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+            Size = OsuHitObject.OBJECT_DIMENSIONS;

            Anchor = Anchor.Centre;
            Origin = Anchor.Centre;
@@ -9,7 +9,6 @@ using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osuTK;
 using osuTK.Graphics;

 namespace osu.Game.Rulesets.Osu.Skinning.Default
@@ -25,7 +24,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default

        public MainCirclePiece()
        {
-            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+            Size = OsuHitObject.OBJECT_DIMENSIONS;

            Anchor = Anchor.Centre;
            Origin = Anchor.Centre;
@@ -46,22 +46,6 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default

            BorderSize = skin.GetConfig<OsuSkinConfiguration, float>(OsuSkinConfiguration.SliderBorderSize)?.Value ?? 1;
            BorderColour = skin.GetConfig<OsuSkinColour, Color4>(OsuSkinColour.SliderBorder)?.Value ?? Color4.White;
-
-            drawableObject.HitObjectApplied += onHitObjectApplied;
-        }
-
-        private void onHitObjectApplied(DrawableHitObject obj)
-        {
-            var drawableSlider = (DrawableSlider)obj;
-            if (drawableSlider.HitObject == null)
-                return;
-
-            // When not tracking the follow circle, unbind from the config and forcefully disable snaking out - it looks better that way.
-            if (!drawableSlider.HeadCircle.TrackFollowCircle)
-            {
-                SnakingOut.UnbindFrom(configSnakingOut);
-                SnakingOut.Value = false;
-            }
        }

        protected virtual Color4 GetBodyAccentColour(ISkinSource skin, Color4 hitObjectAccentColour) =>
@@ -1,51 +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.Allocation;
-using osu.Framework.Audio.Track;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Sprites;
-using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Graphics.Containers;
-using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Skinning;
-using osuTK;
-
-namespace osu.Game.Rulesets.Osu.Skinning.Default
-{
-    public partial class ReverseArrowPiece : BeatSyncedContainer
-    {
-        [Resolved]
-        private DrawableHitObject drawableRepeat { get; set; } = null!;
-
-        public ReverseArrowPiece()
-        {
-            Divisor = 2;
-            MinimumBeatLength = 200;
-
-            Anchor = Anchor.Centre;
-            Origin = Anchor.Centre;
-
-            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
-
-            Child = new SkinnableDrawable(new OsuSkinComponentLookup(OsuSkinComponents.ReverseArrow), _ => new SpriteIcon
-            {
-                RelativeSizeAxes = Axes.Both,
-                Blending = BlendingParameters.Additive,
-                Icon = FontAwesome.Solid.ChevronRight,
-                Size = new Vector2(0.35f)
-            })
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-            };
-        }
-
-        protected override void OnNewBeat(int beatIndex, TimingControlPoint timingPoint, EffectControlPoint effectPoint, ChannelAmplitudes amplitudes)
-        {
-            if (!drawableRepeat.IsHit)
-                Child.ScaleTo(1.3f).ScaleTo(1f, timingPoint.BeatLength, Easing.Out);
-        }
-    }
-}
@@ -5,7 +5,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Rulesets.Osu.Objects;
-using osuTK;
 using osuTK.Graphics;

 namespace osu.Game.Rulesets.Osu.Skinning.Default
@@ -14,7 +13,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
    {
        public RingPiece(float thickness = 9)
        {
-            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+            Size = OsuHitObject.OBJECT_DIMENSIONS;

            Anchor = Anchor.Centre;
            Origin = Anchor.Centre;
@@ -5,12 +5,14 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Skinning;
 using osuTK;
 using osuTK.Graphics;

 namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 {
+    // todo: this should probably not be a SkinnableSprite, as this is always created for legacy skins and is recreated on skin change.
    public partial class LegacyApproachCircle : SkinnableSprite
    {
        private readonly IBindable<Color4> accentColour = new Bindable<Color4>();
@@ -19,7 +21,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
        private DrawableHitObject drawableObject { get; set; } = null!;

        public LegacyApproachCircle()
-            : base("Gameplay/osu/approachcircle")
+            : base("Gameplay/osu/approachcircle", OsuHitObject.OBJECT_DIMENSIONS * 2)
        {
        }

@@ -14,7 +14,6 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Skinning;
-using osuTK;
 using osuTK.Graphics;

 namespace osu.Game.Rulesets.Osu.Skinning.Legacy
@@ -51,7 +50,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
            this.priorityLookupPrefix = priorityLookupPrefix;
            this.hasNumber = hasNumber;

-            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+            Size = OsuHitObject.OBJECT_DIMENSIONS;
        }

        [BackgroundDependencyLoader]
@@ -68,7 +67,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
            // expected behaviour in this scenario is not showing the overlay, rather than using hitcircleoverlay.png.
            InternalChildren = new[]
            {
-                CircleSprite = new LegacyKiaiFlashingDrawable(() => new Sprite { Texture = skin.GetTexture(circleName) })
+                CircleSprite = new LegacyKiaiFlashingDrawable(() => new Sprite { Texture = skin.GetTexture(circleName)?.WithMaximumSize(OsuHitObject.OBJECT_DIMENSIONS * 2) })
                {
                    Anchor = Anchor.Centre,
                    Origin = Anchor.Centre,
@@ -77,7 +76,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                {
                    Anchor = Anchor.Centre,
                    Origin = Anchor.Centre,
-                    Child = OverlaySprite = new LegacyKiaiFlashingDrawable(() => skin.GetAnimation(@$"{circleName}overlay", true, true, frameLength: 1000 / 2d))
+                    Child = OverlaySprite = new LegacyKiaiFlashingDrawable(() => skin.GetAnimation(@$"{circleName}overlay", true, true, frameLength: 1000 / 2d, maxSize: OsuHitObject.OBJECT_DIMENSIONS * 2))
                    {
                        Anchor = Anchor.Centre,
                        Origin = Anchor.Centre,
@@ -4,9 +4,11 @@
 using System.Diagnostics;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Skinning;
 using osuTK.Graphics;
@@ -15,8 +17,8 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 {
    public partial class LegacyReverseArrow : CompositeDrawable
    {
-        [Resolved(canBeNull: true)]
-        private DrawableHitObject? drawableHitObject { get; set; }
+        [Resolved]
+        private DrawableHitObject drawableObject { get; set; } = null!;

        private Drawable proxy = null!;

@@ -26,6 +28,8 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy

        private Drawable arrow = null!;

+        private bool shouldRotate;
+
        [BackgroundDependencyLoader]
        private void load(ISkinSource skinSource)
        {
@@ -35,8 +39,17 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy

            var skin = skinSource.FindProvider(s => s.GetTexture(lookupName) != null);

-            InternalChild = arrow = (skin?.GetAnimation(lookupName, true, true) ?? Empty());
+            InternalChild = arrow = (skin?.GetAnimation(lookupName, true, true, maxSize: OsuHitObject.OBJECT_DIMENSIONS * 2) ?? Empty()).With(d =>
+            {
+                d.Anchor = Anchor.Centre;
+                d.Origin = Anchor.Centre;
+            });
+
            textureIsDefaultSkin = skin is ISkinTransformer transformer && transformer.Skin is DefaultLegacySkin;
+
+            drawableObject.ApplyCustomUpdateState += updateStateTransforms;
+
+            shouldRotate = skinSource.GetConfig<SkinConfiguration.LegacySetting, decimal>(SkinConfiguration.LegacySetting.Version)?.Value <= 1;
        }

        protected override void LoadComplete()
@@ -45,17 +58,14 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy

            proxy = CreateProxy();

-            if (drawableHitObject != null)
-            {
-                drawableHitObject.HitObjectApplied += onHitObjectApplied;
-                onHitObjectApplied(drawableHitObject);
+            drawableObject.HitObjectApplied += onHitObjectApplied;
+            onHitObjectApplied(drawableObject);

-                accentColour = drawableHitObject.AccentColour.GetBoundCopy();
-                accentColour.BindValueChanged(c =>
-                {
-                    arrow.Colour = textureIsDefaultSkin && c.NewValue.R + c.NewValue.G + c.NewValue.B > (600 / 255f) ? Color4.Black : Color4.White;
-                }, true);
-            }
+            accentColour = drawableObject.AccentColour.GetBoundCopy();
+            accentColour.BindValueChanged(c =>
+            {
+                arrow.Colour = textureIsDefaultSkin && c.NewValue.R + c.NewValue.G + c.NewValue.B > (600 / 255f) ? Color4.Black : Color4.White;
+            }, true);
        }

        private void onHitObjectApplied(DrawableHitObject drawableObject)
@@ -67,11 +77,43 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                                                    .OverlayElementContainer.Add(proxy);
        }

+        private void updateStateTransforms(DrawableHitObject hitObject, ArmedState state)
+        {
+            const double duration = 300;
+            const float rotation = 5.625f;
+
+            switch (state)
+            {
+                case ArmedState.Idle:
+                    if (shouldRotate)
+                    {
+                        InternalChild.ScaleTo(1.3f)
+                                     .RotateTo(rotation)
+                                     .Then()
+                                     .ScaleTo(1f, duration)
+                                     .RotateTo(-rotation, duration)
+                                     .Loop();
+                    }
+                    else
+                    {
+                        InternalChild.ScaleTo(1.3f).Then()
+                                     .ScaleTo(1f, duration, Easing.Out)
+                                     .Loop();
+                    }
+
+                    break;
+            }
+        }
+
        protected override void Dispose(bool isDisposing)
        {
            base.Dispose(isDisposing);
-            if (drawableHitObject != null)
-                drawableHitObject.HitObjectApplied -= onHitObjectApplied;
+
+            if (drawableObject.IsNotNull())
+            {
+                drawableObject.HitObjectApplied -= onHitObjectApplied;
+                drawableObject.ApplyCustomUpdateState -= updateStateTransforms;
+            }
        }
    }
 }
@@ -46,7 +46,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                {
                    Anchor = Anchor.Centre,
                    Origin = Anchor.Centre,
-                    Texture = skin.GetTexture("sliderb-nd"),
+                    Texture = skin.GetTexture("sliderb-nd")?.WithMaximumSize(OsuLegacySkinTransformer.MAX_FOLLOW_CIRCLE_AREA_SIZE),
                    Colour = new Color4(5, 5, 5, 255),
                },
                LegacyColourCompatibility.ApplyWithDoubledAlpha(animationContent.With(d =>
@@ -58,7 +58,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                {
                    Anchor = Anchor.Centre,
                    Origin = Anchor.Centre,
-                    Texture = skin.GetTexture("sliderb-spec"),
+                    Texture = skin.GetTexture("sliderb-spec")?.WithMaximumSize(OsuLegacySkinTransformer.MAX_FOLLOW_CIRCLE_AREA_SIZE),
                    Blending = BlendingParameters.Additive,
                },
            };
@@ -4,6 +4,7 @@
 using System;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Skinning;
 using osuTK;

@@ -20,7 +21,17 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
        /// Their hittable area is 128px, but the actual circle portion is 118px.
        /// We must account for some gameplay elements such as slider bodies, where this padding is not present.
        /// </summary>
-        public const float LEGACY_CIRCLE_RADIUS = 64 - 5;
+        public const float LEGACY_CIRCLE_RADIUS = OsuHitObject.OBJECT_RADIUS - 5;
+
+        /// <summary>
+        /// The maximum allowed size of sprites that reside in the follow circle area of a slider.
+        /// </summary>
+        /// <remarks>
+        /// The reason this is extracted out to a constant, rather than be inlined in the follow circle sprite retrieval,
+        /// is that some skins will use `sliderb` elements to emulate a slider follow circle with slightly different visual effects applied
+        /// (`sliderb` is always shown and doesn't pulsate; `sliderfollowcircle` isn't always shown and pulsates).
+        /// </remarks>
+        public static readonly Vector2 MAX_FOLLOW_CIRCLE_AREA_SIZE = OsuHitObject.OBJECT_DIMENSIONS * 3;

        public OsuLegacySkinTransformer(ISkin skin)
            : base(skin)
@@ -41,14 +52,14 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                        return this.GetAnimation("sliderscorepoint", false, false);

                    case OsuSkinComponents.SliderFollowCircle:
-                        var followCircleContent = this.GetAnimation("sliderfollowcircle", true, true, true);
+                        var followCircleContent = this.GetAnimation("sliderfollowcircle", true, true, true, maxSize: MAX_FOLLOW_CIRCLE_AREA_SIZE);
                        if (followCircleContent != null)
                            return new LegacyFollowCircle(followCircleContent);

                        return null;

                    case OsuSkinComponents.SliderBall:
-                        var sliderBallContent = this.GetAnimation("sliderb", true, true, animationSeparator: "");
+                        var sliderBallContent = this.GetAnimation("sliderb", true, true, animationSeparator: "", maxSize: MAX_FOLLOW_CIRCLE_AREA_SIZE);

                        // todo: slider ball has a custom frame delay based on velocity
                        // Math.Max((150 / Velocity) * GameBase.SIXTY_FRAME_TIME, GameBase.SIXTY_FRAME_TIME);
@@ -138,10 +149,11 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                        if (!this.HasFont(LegacyFont.HitCircle))
                            return null;

-                        return new LegacySpriteText(LegacyFont.HitCircle)
+                        const float hitcircle_text_scale = 0.8f;
+                        return new LegacySpriteText(LegacyFont.HitCircle, OsuHitObject.OBJECT_DIMENSIONS * 2 / hitcircle_text_scale)
                        {
                            // stable applies a blanket 0.8x scale to hitcircle fonts
-                            Scale = new Vector2(0.8f),
+                            Scale = new Vector2(hitcircle_text_scale),
                        };

                    case OsuSkinComponents.SpinnerBody:
@@ -95,7 +95,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                {
                    new RingPiece(3)
                    {
-                        Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2),
+                        Size = OsuHitObject.OBJECT_DIMENSIONS,
                        Alpha = 0.1f,
                    }
                };
@@ -286,7 +286,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                    if (time - part.Time >= 1)
                        continue;

-                    vertexBatch.Add(new TexturedTrailVertex(renderer)
+                    vertexBatch.Add(new TexturedTrailVertex
                    {
                        Position = new Vector2(part.Position.X - size.X * originPosition.X, part.Position.Y + size.Y * (1 - originPosition.Y)),
                        TexturePosition = textureRect.BottomLeft,
@@ -295,7 +295,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                        Time = part.Time
                    });

-                    vertexBatch.Add(new TexturedTrailVertex(renderer)
+                    vertexBatch.Add(new TexturedTrailVertex
                    {
                        Position = new Vector2(part.Position.X + size.X * (1 - originPosition.X), part.Position.Y + size.Y * (1 - originPosition.Y)),
                        TexturePosition = textureRect.BottomRight,
@@ -304,7 +304,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                        Time = part.Time
                    });

-                    vertexBatch.Add(new TexturedTrailVertex(renderer)
+                    vertexBatch.Add(new TexturedTrailVertex
                    {
                        Position = new Vector2(part.Position.X + size.X * (1 - originPosition.X), part.Position.Y - size.Y * originPosition.Y),
                        TexturePosition = textureRect.TopRight,
@@ -313,7 +313,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                        Time = part.Time
                    });

-                    vertexBatch.Add(new TexturedTrailVertex(renderer)
+                    vertexBatch.Add(new TexturedTrailVertex
                    {
                        Position = new Vector2(part.Position.X - size.X * originPosition.X, part.Position.Y - size.Y * originPosition.Y),
                        TexturePosition = textureRect.TopLeft,
@@ -362,22 +362,12 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
            [VertexMember(1, VertexAttribPointerType.Float)]
            public float Time;

-            [VertexMember(1, VertexAttribPointerType.Int)]
-            private readonly int maskingIndex;
-
-            public TexturedTrailVertex(IRenderer renderer)
-            {
-                this = default;
-                maskingIndex = renderer.CurrentMaskingIndex;
-            }
-
            public bool Equals(TexturedTrailVertex other)
            {
                return Position.Equals(other.Position)
                       && TexturePosition.Equals(other.TexturePosition)
                       && Colour.Equals(other.Colour)
-                       && Time.Equals(other.Time)
-                       && maskingIndex == other.maskingIndex;
+                       && Time.Equals(other.Time);
            }
        }
    }
--- a/Show More
+++ b/Show More