Merge branch 'master' into legacy-tick-test-coverage

.github/workflows/diffcalc.yml

@@ -1,206 +1,365 @@
-# Listens for new PR comments containing !pp check [id], and runs a diffcalc comparison against master.
+# ## Description
-# Usage:
-#   !pp check 0        | Runs only the osu! ruleset.
-#   !pp check 0 2      | Runs only the osu! and catch rulesets.
 #
+# Uses [diffcalc-sheet-generator](https://github.com/smoogipoo/diffcalc-sheet-generator) to run two builds of osu and generate an SR/PP/Score comparison spreadsheet.
+#
+# ## Requirements
+#
+# Self-hosted runner with installed:
+# - `docker >= 20.10.16`
+# - `docker-compose >= 2.5.1`
+# - `lbzip2`
+# - `jq`
+#
+# ## Usage
+#
+# The workflow can be run in two ways:
+# 1. Via workflow dispatch.
+# 2. By an owner of the repository posting a pull request or issue comment containing `!diffcalc`.  
+# For pull requests, the workflow will assume the pull request as the target to compare against (i.e. the `OSU_B` variable).  
+# Any lines in the comment of the form `KEY=VALUE` are treated as variables for the generator.
+#
+# ## Google Service Account
+#
+# Spreadsheets are uploaded to a Google Service Account, and exposed with read-only permissions to the wider audience.
+#
+# 1. Create a project at https://console.cloud.google.com
+# 2. Enable the `Google Sheets` and `Google Drive` APIs.
+# 3. Create a Service Account
+# 4. Generate a key in the JSON format.
+# 5. Encode the key as base64 and store as an **actions secret** with name **`DIFFCALC_GOOGLE_CREDENTIALS`**
+#
+# ## Environment variables
+#
+# The default environment may be configured via **actions variables**.
+#
+# Refer to [the sample environment](https://github.com/smoogipoo/diffcalc-sheet-generator/blob/master/.env.sample), and prefix each variable with `DIFFCALC_` (e.g. `DIFFCALC_THREADS`, `DIFFCALC_INNODB_BUFFER_SIZE`, etc...).
+
+name: Run difficulty calculation comparison
+
+run-name: "${{ github.event_name == 'workflow_dispatch' && format('Manual run: {0}', inputs.osu-b) || 'Automatic comment trigger' }}"
 
-name: Difficulty Calculation
 on:
   issue_comment:
     types: [ created ]
+  workflow_dispatch:
+    inputs:
+      osu-b:
+        description: "The target build of ppy/osu"
+        type: string
+        required: true
+      ruleset:
+        description: "The ruleset to process"
+        type: choice
+        required: true
+        options:
+          - osu
+          - taiko
+          - catch
+          - mania
+      converts:
+        description: "Include converted beatmaps"
+        type: boolean
+        required: false
+        default: true
+      ranked-only:
+        description: "Only ranked beatmaps"
+        type: boolean
+        required: false
+        default: true
+      generators:
+        description: "Comma-separated list of generators (available: [sr, pp, score])"
+        type: string
+        required: false
+        default: 'pp,sr'
+      osu-a:
+        description: "The source build of ppy/osu"
+        type: string
+        required: false
+        default: 'latest'
+      difficulty-calculator-a:
+        description: "The source build of ppy/osu-difficulty-calculator"
+        type: string
+        required: false
+        default: 'latest'
+      difficulty-calculator-b:
+        description: "The target build of ppy/osu-difficulty-calculator"
+        type: string
+        required: false
+        default: 'latest'
+      score-processor-a:
+        description: "The source build of ppy/osu-queue-score-statistics"
+        type: string
+        required: false
+        default: 'latest'
+      score-processor-b:
+        description: "The target build of ppy/osu-queue-score-statistics"
+        type: string
+        required: false
+        default: 'latest'
+
+permissions:
+  pull-requests: write
 
 env:
-  CONCURRENCY: 4
+  COMMENT_TAG: execution-${{ github.run_id }}-${{ github.run_number }}-${{ github.run_attempt }}
-  ALLOW_DOWNLOAD: 1
-  SAVE_DOWNLOADED: 1
-  SKIP_INSERT_ATTRIBUTES: 1
 
 jobs:
-  metadata:
+  wait-for-queue:
-    name: Check for requests
+    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 }}
+      GENERATOR_DIR: ${{ steps.set-outputs.outputs.GENERATOR_DIR }}
-      continue: ${{ steps.generate-matrix.outputs.continue }}
+      GENERATOR_ENV: ${{ steps.set-outputs.outputs.GENERATOR_ENV }}
+      GOOGLE_CREDS_FILE: ${{ steps.set-outputs.outputs.GOOGLE_CREDS_FILE }}
     steps:
-      - name: Construct build matrix
+      - name: Checkout
-        id: generate-matrix
+        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
+          echo "GENERATOR_DIR=${{ github.workspace }}/diffcalc-sheet-generator" >> "${GITHUB_OUTPUT}"
-            MATRIX_PROJECTS_JSON+='{ "name": "osu", "id": 0 },'
+          echo "GENERATOR_ENV=${{ github.workspace }}/diffcalc-sheet-generator/.env" >> "${GITHUB_OUTPUT}"
-          fi
+          echo "GOOGLE_CREDS_FILE=${{ github.workspace }}/diffcalc-sheet-generator/google-credentials.json" >> "${GITHUB_OUTPUT}"
-          if [[ "${{ github.event.comment.body }}" =~ "taiko" ]] ; then
-            MATRIX_PROJECTS_JSON+='{ "name": "taiko", "id": 1 },'
-          fi
-          if [[ "${{ github.event.comment.body }}" =~ "catch" ]] ; then
-            MATRIX_PROJECTS_JSON+='{ "name": "catch", "id": 2 },'
-          fi
-          if [[ "${{ github.event.comment.body }}" =~ "mania" ]] ; then
-            MATRIX_PROJECTS_JSON+='{ "name": "mania", "id": 3 },'
-          fi
 
-          if [[ "${MATRIX_PROJECTS_JSON}" != "" ]]; then
+  environment:
-            MATRIX_JSON="{ \"ruleset\": [ ${MATRIX_PROJECTS_JSON} ] }"
+    name: Setup environment
-            echo "${MATRIX_JSON}"
+    needs: directory
-            CONTINUE="yes"
-          else
-            CONTINUE="no"
-          fi
-
-          echo "continue=${CONTINUE}" >> $GITHUB_OUTPUT
-          echo "matrix=${MATRIX_JSON}" >> $GITHUB_OUTPUT
-  diffcalc:
-    name: Run
     runs-on: self-hosted
-    timeout-minutes: 1440
+    if: ${{ !cancelled() && needs.directory.result == 'success' }}
-    if: needs.metadata.outputs.continue == 'yes'
+    env:
-    needs: metadata
+      VARS_JSON: ${{ toJSON(vars) }}
-    strategy:
-      matrix: ${{ fromJson(needs.metadata.outputs.matrix) }}
     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
+          # Add Google credentials
-        run: |
+          echo '${{ secrets.DIFFCALC_GOOGLE_CREDENTIALS }}' | base64 -d > "${{ needs.directory.outputs.GOOGLE_CREDS_FILE }}"
-          for db in osu_master osu_pr
+
-          do
+          # Add repository variables
-            mysql -e "DROP DATABASE IF EXISTS $db"
+          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/
+          sed -i "s;^OSU_B=.*$;OSU_B=${{ github.event.issue.pull_request.url }};" "${{ needs.directory.outputs.GENERATOR_ENV }}"
-          mkdir -p $GITHUB_WORKSPACE/pr/
 
-      - name: Get upstream branch # https://akaimo.hatenablog.jp/entry/2020/05/16/101251
+      - name: Add comment environment
-        id: upstreambranch
+        if: ${{ github.event_name == 'issue_comment' }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
-          echo "branchname=$(curl -H "Authorization: token ${GITHUB_TOKEN}" ${{ github.event.issue.pull_request.url }} | jq '.head.ref' | sed 's/\"//g')" >> $GITHUB_OUTPUT
+          # Add comment environment
-          echo "repo=$(curl -H "Authorization: token ${GITHUB_TOKEN}" ${{ github.event.issue.pull_request.url }} | jq '.head.repo.full_name' | sed 's/\"//g')" >> $GITHUB_OUTPUT
+          echo '${{ github.event.comment.body }}' | sed -r 's/\r$//' | grep -E '^\w+=' | while read -r line; do
-
+              opt=$(echo ${line} | cut -d '=' -f1)
-      # Checkout osu
+              sed -i "s;^${opt}=.*$;${line};" "${{ needs.directory.outputs.GENERATOR_ENV }}"
-      - 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;'
           done
 
-      - name: Run diffcalc (master)
+      - name: Add dispatch environment
-        env:
+        if: ${{ github.event_name == 'workflow_dispatch' }}
-          DB_NAME: osu_master
         run: |
-          cd $GITHUB_WORKSPACE/master/osu-difficulty-calculator/osu.Server.DifficultyCalculator
+          sed -i 's;^OSU_B=.*$;OSU_B=${{ inputs.osu-b }};' "${{ needs.directory.outputs.GENERATOR_ENV }}"
-          dotnet run -c:Release -- all -m ${{ matrix.ruleset.id }} -ac -c ${{ env.CONCURRENCY }}
+          sed -i 's/^RULESET=.*$/RULESET=${{ inputs.ruleset }}/' "${{ needs.directory.outputs.GENERATOR_ENV }}"
-      - name: Run diffcalc (pr)
+          sed -i 's/^GENERATORS=.*$/GENERATORS=${{ inputs.generators }}/' "${{ needs.directory.outputs.GENERATOR_ENV }}"
-        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 }}
 
-      - name: Print diffs
+          if [[ '${{ inputs.osu-a }}' != 'latest' ]]; then
-        run: |
+              sed -i 's;^OSU_A=.*$;OSU_A=${{ inputs.osu-a }};' "${{ needs.directory.outputs.GENERATOR_ENV }}"
-          mysql -e "
+          fi
-            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;"
 
-      # 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 }}

osu.Android.props

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

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

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

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

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

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -54,7 +54,7 @@ namespace osu.Game.Rulesets.Catch
             new KeyBinding(InputKey.X, CatchAction.MoveRight),
             new KeyBinding(InputKey.Right, CatchAction.MoveRight),
             new KeyBinding(InputKey.Shift, CatchAction.Dash),
-            new KeyBinding(InputKey.Shift, CatchAction.Dash),
+            new KeyBinding(InputKey.MouseLeft, CatchAction.Dash),
         };
 
         public override IEnumerable<Mod> ConvertFromLegacyMods(LegacyMods mods)

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

@@ -2,10 +2,13 @@
 // 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.Mods;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
@@ -137,5 +140,53 @@ namespace osu.Game.Rulesets.Catch.Difficulty
             if (increaseCombo)
                 combo++;
         }
+
+        public double GetLegacyScoreMultiplier(IReadOnlyList<Mod> mods, LegacyBeatmapConversionDifficultyInfo difficulty)
+        {
+            bool scoreV2 = mods.Any(m => m is ModScoreV2);
+
+            double multiplier = 1.0;
+
+            foreach (var mod in mods)
+            {
+                switch (mod)
+                {
+                    case CatchModNoFail:
+                        multiplier *= scoreV2 ? 1.0 : 0.5;
+                        break;
+
+                    case CatchModEasy:
+                        multiplier *= 0.5;
+                        break;
+
+                    case CatchModHalfTime:
+                    case CatchModDaycore:
+                        multiplier *= 0.3;
+                        break;
+
+                    case CatchModHidden:
+                        multiplier *= scoreV2 ? 1.0 : 1.06;
+                        break;
+
+                    case CatchModHardRock:
+                        multiplier *= 1.12;
+                        break;
+
+                    case CatchModDoubleTime:
+                    case CatchModNightcore:
+                        multiplier *= 1.06;
+                        break;
+
+                    case CatchModFlashlight:
+                        multiplier *= 1.12;
+                        break;
+
+                    case CatchModRelax:
+                        return 0;
+                }
+            }
+
+            return multiplier;
+        }
     }
 }

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

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

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

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

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

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

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

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

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

@@ -9,7 +9,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
 {
     public partial class LegacyBananaPiece : LegacyCatchHitObjectPiece
     {
-        private static readonly Vector2 banana_max_size = new Vector2(128);
+        private static readonly Vector2 banana_max_size = new Vector2(160);
 
         protected override void LoadComplete()
         {

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

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

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

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

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

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

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

@@ -9,7 +9,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
 {
     public partial class LegacyDropletPiece : LegacyCatchHitObjectPiece
     {
-        private static readonly Vector2 droplet_max_size = new Vector2(82, 103);
+        private static readonly Vector2 droplet_max_size = new Vector2(160);
 
         public LegacyDropletPiece()
         {

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

@@ -9,7 +9,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
 {
     internal partial class LegacyFruitPiece : LegacyCatchHitObjectPiece
     {
-        private static readonly Vector2 fruit_max_size = new Vector2(128);
+        private static readonly Vector2 fruit_max_size = new Vector2(160);
 
         protected override void LoadComplete()
         {

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

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

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

@@ -29,6 +29,13 @@ namespace osu.Game.Rulesets.Catch.UI
         /// <summary>
         /// The size of the catcher at 1x scale.
         /// </summary>
+        /// <remarks>
+        /// This is mainly used to compute catching range, the actual catcher size may differ based on skin implementation and sprite textures.
+        /// This is also equivalent to the "catcherWidth" property in osu-stable when the game field and beatmap difficulty are set to default values.
+        /// </remarks>
+        /// <seealso cref="CatchPlayfield.WIDTH"/>
+        /// <seealso cref="CatchPlayfield.HEIGHT"/>
+        /// <seealso cref="IBeatmapDifficultyInfo.DEFAULT_DIFFICULTY"/>
         public const float BASE_SIZE = 106.75f;
 
         /// <summary>

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,7 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Mods;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring.Legacy;
 
 namespace osu.Game.Rulesets.Mania.Difficulty
@@ -12,5 +17,50 @@ namespace osu.Game.Rulesets.Mania.Difficulty
         {
             return new LegacyScoreAttributes { ComboScore = 1000000 };
         }
+
+        public double GetLegacyScoreMultiplier(IReadOnlyList<Mod> mods, LegacyBeatmapConversionDifficultyInfo difficulty)
+        {
+            bool scoreV2 = mods.Any(m => m is ModScoreV2);
+
+            double multiplier = 1.0;
+
+            foreach (var mod in mods)
+            {
+                switch (mod)
+                {
+                    case ManiaModNoFail:
+                        multiplier *= scoreV2 ? 1.0 : 0.5;
+                        break;
+
+                    case ManiaModEasy:
+                        multiplier *= 0.5;
+                        break;
+
+                    case ManiaModHalfTime:
+                    case ManiaModDaycore:
+                        multiplier *= 0.5;
+                        break;
+                }
+            }
+
+            if (new ManiaRuleset().RulesetInfo.Equals(difficulty.SourceRuleset))
+                return multiplier;
+
+            // Apply key mod multipliers.
+
+            int originalColumns = ManiaBeatmapConverter.GetColumnCount(difficulty);
+            int actualColumns = originalColumns;
+
+            actualColumns = mods.OfType<ManiaKeyMod>().SingleOrDefault()?.KeyCount ?? actualColumns;
+            if (mods.Any(m => m is ManiaModDualStages))
+                actualColumns *= 2;
+
+            if (actualColumns > originalColumns)
+                multiplier *= 0.9;
+            else if (actualColumns < originalColumns)
+                multiplier *= 0.9 - 0.04 * (originalColumns - actualColumns);
+
+            return multiplier;
+        }
     }
 }

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

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

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

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

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

@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Mania.Edit
 {
     public partial class DrawableManiaEditorRuleset : DrawableManiaRuleset, ISupportConstantAlgorithmToggle
     {
-        public BindableBool ShowSpeedChanges { get; set; } = new BindableBool();
+        public BindableBool ShowSpeedChanges { get; } = new BindableBool();
 
         public new IScrollingInfo ScrollingInfo => base.ScrollingInfo;
 

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

@@ -8,6 +8,8 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Caching;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Pooling;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Edit;
@@ -23,7 +25,7 @@ namespace osu.Game.Rulesets.Mania.Edit
     /// <summary>
     /// A grid which displays coloured beat divisor lines in proximity to the selection or placement cursor.
     /// </summary>
-    public partial class ManiaBeatSnapGrid : Component
+    public partial class ManiaBeatSnapGrid : CompositeComponent
     {
         private const double visible_range = 750;
 
@@ -53,6 +55,8 @@ namespace osu.Game.Rulesets.Mania.Edit
 
         private readonly List<ScrollingHitObjectContainer> grids = new List<ScrollingHitObjectContainer>();
 
+        private readonly DrawablePool<DrawableGridLine> linesPool = new DrawablePool<DrawableGridLine>(50);
+
         private readonly Cached lineCache = new Cached();
 
         private (double start, double end)? selectionTimeRange;
@@ -60,6 +64,8 @@ namespace osu.Game.Rulesets.Mania.Edit
         [BackgroundDependencyLoader]
         private void load(HitObjectComposer composer)
         {
+            AddInternal(linesPool);
+
             foreach (var stage in ((ManiaPlayfield)composer.Playfield).Stages)
             {
                 foreach (var column in stage.Columns)
@@ -85,17 +91,10 @@ namespace osu.Game.Rulesets.Mania.Edit
             }
         }
 
-        private readonly Stack<DrawableGridLine> availableLines = new Stack<DrawableGridLine>();
-
         private void createLines()
         {
             foreach (var grid in grids)
-            {
-                foreach (var line in grid.Objects.OfType<DrawableGridLine>())
-                    availableLines.Push(line);
-
                 grid.Clear();
-            }
 
             if (selectionTimeRange == null)
                 return;
@@ -131,10 +130,13 @@ namespace osu.Game.Rulesets.Mania.Edit
 
                 foreach (var grid in grids)
                 {
-                    if (!availableLines.TryPop(out var line))
+                    var line = linesPool.Get();
-                        line = new DrawableGridLine();
+
+                    line.Apply(new HitObject
+                    {
+                        StartTime = time
+                    });
 
-                    line.HitObject.StartTime = time;
                     line.Colour = colour;
 
                     grid.Add(line);

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

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

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

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

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

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

osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs

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

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -386,21 +386,11 @@ namespace osu.Game.Rulesets.Mania
                 HitResult.Ok,
                 HitResult.Meh,
 
-                HitResult.LargeTickHit,
+                // HitResult.SmallBonus is used for awarding perfect bonus score but is not included here as
+                // it would be a bit redundant to show this to the user.
             };
         }
 
-        public override LocalisableString GetDisplayNameForHitResult(HitResult result)
-        {
-            switch (result)
-            {
-                case HitResult.LargeTickHit:
-                    return "hold tick";
-            }
-
-            return base.GetDisplayNameForHitResult(result);
-        }
-
         public override StatisticItem[] CreateStatisticsForScore(ScoreInfo score, IBeatmap playableBeatmap) => new[]
         {
             new StatisticItem("Performance Breakdown", () => new PerformanceBreakdownChart(score, playableBeatmap)

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

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

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

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

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

@@ -0,0 +1,31 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable disable
+
+namespace osu.Game.Rulesets.Mania.Objects.Drawables
+{
+    public partial class DrawableHoldNoteBody : DrawableManiaHitObject<HoldNoteBody>
+    {
+        public bool HasHoldBreak => AllJudged && !IsHit;
+
+        public override bool DisplayResult => false;
+
+        public DrawableHoldNoteBody()
+            : this(null)
+        {
+        }
+
+        public DrawableHoldNoteBody(HoldNoteBody hitObject)
+            : base(hitObject)
+        {
+        }
+
+        internal void TriggerResult(bool hit)
+        {
+            if (AllJudged) return;
+
+            ApplyResult(r => r.Type = hit ? r.Judgement.MaxResult : r.Judgement.MinResult);
+        }
+    }
+}

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

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

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

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

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

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

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

@@ -0,0 +1,26 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Game.Rulesets.Mania.Objects.Drawables
+{
+    public partial class DrawableNotePerfectBonus : DrawableManiaHitObject<NotePerfectBonus>
+    {
+        public override bool DisplayResult => false;
+
+        public DrawableNotePerfectBonus()
+            : this(null!)
+        {
+        }
+
+        public DrawableNotePerfectBonus(NotePerfectBonus hitObject)
+            : base(hitObject)
+        {
+        }
+
+        /// <summary>
+        /// Apply a judgement result.
+        /// </summary>
+        /// <param name="hit">Whether this tick was reached.</param>
+        internal void TriggerResult(bool hit) => ApplyResult(r => r.Type = hit ? r.Judgement.MaxResult : r.Judgement.MinResult);
+    }
+}

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

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

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

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

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

@@ -0,0 +1,21 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mania.Judgements;
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Mania.Objects
+{
+    /// <summary>
+    /// The body of a <see cref="HoldNote"/>.
+    /// Mostly a dummy hitobject that provides the judgement for the "holding" state.<br />
+    /// On hit - the hold note was held correctly for the full duration.<br />
+    /// On miss - the hold note was released at some point during its judgement period.
+    /// </summary>
+    public class HoldNoteBody : ManiaHitObject
+    {
+        public override Judgement CreateJudgement() => new HoldNoteBodyJudgement();
+        protected override HitWindows CreateHitWindows() => HitWindows.Empty;
+    }
+}

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

@@ -1,19 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Mania.Judgements;
-using osu.Game.Rulesets.Scoring;
-
-namespace osu.Game.Rulesets.Mania.Objects
-{
-    /// <summary>
-    /// A scoring tick of a hold note.
-    /// </summary>
-    public class HoldNoteTick : ManiaHitObject
-    {
-        public override Judgement CreateJudgement() => new HoldNoteTickJudgement();
-
-        protected override HitWindows CreateHitWindows() => HitWindows.Empty;
-    }
-}

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

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Threading;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Judgements;
 
@@ -12,5 +13,12 @@ namespace osu.Game.Rulesets.Mania.Objects
     public class Note : ManiaHitObject
     {
         public override Judgement CreateJudgement() => new ManiaJudgement();
+
+        protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
+        {
+            base.CreateNestedHitObjects(cancellationToken);
+
+            AddNested(new NotePerfectBonus { StartTime = StartTime });
+        }
     }
 }

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

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

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

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

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

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

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

@@ -7,7 +7,6 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
@@ -69,9 +68,6 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 
         public void Animate(JudgementResult result)
         {
-            if (result.Judgement is HoldNoteTickJudgement)
-                return;
-
             (explosion as IFramedAnimation)?.GotoFrame(0);
 
             explosion?.FadeInFromZero(FADE_IN_DURATION)

osu.Game.Rulesets.Mania/UI/Column.cs

@@ -109,10 +109,11 @@ namespace osu.Game.Rulesets.Mania.UI
             TopLevelContainer.Add(HitObjectArea.Explosions.CreateProxy());
 
             RegisterPool<Note, DrawableNote>(10, 50);
+            RegisterPool<NotePerfectBonus, DrawableNotePerfectBonus>(10, 50);
             RegisterPool<HoldNote, DrawableHoldNote>(10, 50);
             RegisterPool<HeadNote, DrawableHoldNoteHead>(10, 50);
             RegisterPool<TailNote, DrawableHoldNoteTail>(10, 50);
-            RegisterPool<HoldNoteTick, DrawableHoldNoteTick>(50, 250);
+            RegisterPool<HoldNoteBody, DrawableHoldNoteBody>(10, 50);
         }
 
         private void onSourceChanged()

osu.Game.Rulesets.Mania/UI/DefaultHitExplosion.cs

@@ -11,7 +11,6 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Utils;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Mania.Skinning.Default;
 using osu.Game.Rulesets.UI.Scrolling;
 using osuTK;
@@ -150,9 +149,6 @@ namespace osu.Game.Rulesets.Mania.UI
             // scale roughly in-line with visual appearance of notes
             Vector2 scale = new Vector2(1, 0.6f);
 
-            if (result.Judgement is HoldNoteTickJudgement)
-                scale *= 0.5f;
-
             this.ScaleTo(scale);
 
             largeFaint

osu.Game.Rulesets.Mania/UI/Stage.cs

@@ -195,10 +195,6 @@ namespace osu.Game.Rulesets.Mania.UI
             if (!judgedObject.DisplayResult || !DisplayJudgements.Value)
                 return;
 
-            // Tick judgements should not display text.
-            if (judgedObject is DrawableHoldNoteTick)
-                return;
-
             judgements.Clear(false);
             judgements.Add(judgementPool.Get(j =>
             {

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneObjectMerging.cs

@@ -34,7 +34,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             });
 
             moveMouseToHitObject(1);
-            AddAssert("merge option available", () => selectionHandler.ContextMenuItems.Any(o => o.Text.Value == "Merge selection"));
+            AddAssert("merge option available", () => selectionHandler.ContextMenuItems?.Any(o => o.Text.Value == "Merge selection") == true);
 
             mergeSelection();
 
@@ -198,7 +198,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             });
 
             moveMouseToHitObject(1);
-            AddAssert("merge option not available", () => selectionHandler.ContextMenuItems.Length > 0 && selectionHandler.ContextMenuItems.All(o => o.Text.Value != "Merge selection"));
+            AddAssert("merge option not available", () => selectionHandler.ContextMenuItems?.Length > 0 && selectionHandler.ContextMenuItems.All(o => o.Text.Value != "Merge selection"));
             mergeSelection();
             AddAssert("circles not merged", () => circle1 is not null && circle2 is not null
                                                                       && EditorBeatmap.HitObjects.Contains(circle1) && EditorBeatmap.HitObjects.Contains(circle2));
@@ -222,7 +222,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             });
 
             moveMouseToHitObject(1);
-            AddAssert("merge option available", () => selectionHandler.ContextMenuItems.Any(o => o.Text.Value == "Merge selection"));
+            AddAssert("merge option available", () => selectionHandler.ContextMenuItems?.Any(o => o.Text.Value == "Merge selection") == true);
 
             mergeSelection();
 

osu.Game.Rulesets.Osu.Tests/Editor/TestScenePathControlPointVisualiser.cs

@@ -169,7 +169,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             AddStep($"move mouse to control point {index}", () =>
             {
                 Vector2 position = slider.Path.ControlPoints[index].Position;
-                InputManager.MoveMouseTo(visualiser.Pieces[0].Parent.ToScreenSpace(position));
+                InputManager.MoveMouseTo(visualiser.Pieces[0].Parent!.ToScreenSpace(position));
             });
         }
 

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderControlPointPiece.cs

@@ -169,7 +169,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             AddStep($"move mouse to {relativePosition}", () =>
             {
                 Vector2 position = slider.Position + relativePosition;
-                InputManager.MoveMouseTo(drawableObject.Parent.ToScreenSpace(position));
+                InputManager.MoveMouseTo(drawableObject.Parent!.ToScreenSpace(position));
             });
 
         [Test]
@@ -331,7 +331,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             AddStep($"move mouse to {relativePosition}", () =>
             {
                 Vector2 position = slider.Position + relativePosition;
-                InputManager.MoveMouseTo(drawableObject.Parent.ToScreenSpace(position));
+                InputManager.MoveMouseTo(drawableObject.Parent!.ToScreenSpace(position));
             });
         }
 
@@ -340,7 +340,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             AddStep($"move mouse to control point {index}", () =>
             {
                 Vector2 position = slider.Position + slider.Path.ControlPoints[index].Position;
-                InputManager.MoveMouseTo(drawableObject.Parent.ToScreenSpace(position));
+                InputManager.MoveMouseTo(drawableObject.Parent!.ToScreenSpace(position));
             });
         }
 

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderSelectionBlueprint.cs

@@ -187,7 +187,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             AddStep($"move mouse to control point {index}", () =>
             {
                 Vector2 position = slider.Position + slider.Path.ControlPoints[index].Position;
-                InputManager.MoveMouseTo(drawableObject.Parent.ToScreenSpace(position));
+                InputManager.MoveMouseTo(drawableObject.Parent!.ToScreenSpace(position));
             });
         }
 

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderSnapping.cs

@@ -101,7 +101,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             {
                 var firstPiece = this.ChildrenOfType<PathControlPointPiece<Slider>>().Single(piece => piece.ControlPoint == slider.Path.ControlPoints[0]);
                 var pos = slider.Path.PositionAt(0.25d) + slider.Position;
-                InputManager.MoveMouseTo(firstPiece.Parent.ToScreenSpace(pos));
+                InputManager.MoveMouseTo(firstPiece.Parent!.ToScreenSpace(pos));
             });
             AddStep("move slider end", () =>
             {

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderSplitting.cs

@@ -231,7 +231,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                 if (slider is null || visualiser is null) return;
 
                 Vector2 position = slider.Path.ControlPoints[index].Position + slider.Position;
-                InputManager.MoveMouseTo(visualiser.Pieces[0].Parent.ToScreenSpace(position));
+                InputManager.MoveMouseTo(visualiser.Pieces[0].Parent!.ToScreenSpace(position));
             });
         }
 
@@ -241,7 +241,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             {
                 if (visualiser is null) return;
 
-                MenuItem? item = visualiser.ContextMenuItems.FirstOrDefault(menuItem => menuItem.Text.Value == contextMenuText);
+                MenuItem? item = visualiser.ContextMenuItems?.FirstOrDefault(menuItem => menuItem.Text.Value == contextMenuText);
 
                 item?.Action.Value?.Invoke();
             });

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

@@ -0,0 +1,111 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Replays;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class SpinFramesGenerator
+    {
+        /// <summary>
+        /// A small amount to spin beyond a given angle to mitigate floating-point precision errors.
+        /// </summary>
+        public const float SPIN_ERROR = MathF.PI / 8;
+
+        /// <summary>
+        /// The offset from the centre of the spinner at which to spin.
+        /// </summary>
+        private const float centre_spin_offset = 50;
+
+        private readonly double startTime;
+        private readonly float startAngle;
+        private readonly List<(float deltaAngle, double duration)> sequences = new List<(float deltaAngle, double duration)>();
+
+        /// <summary>
+        /// Creates a new <see cref="SpinFramesGenerator"/> that can be used to generate spinner spin frames.
+        /// </summary>
+        /// <param name="startTime">The time at which to start spinning.</param>
+        /// <param name="startAngle">The angle, in radians, at which to start spinning from. Defaults to the positive-y-axis.</param>
+        public SpinFramesGenerator(double startTime, float startAngle = -MathF.PI / 2f)
+        {
+            this.startTime = startTime;
+            this.startAngle = startAngle;
+        }
+
+        /// <summary>
+        /// Performs a single spin.
+        /// </summary>
+        /// <param name="delta">The amount of degrees to spin.</param>
+        /// <param name="duration">The time to spend to perform the spin.</param>
+        /// <returns>This <see cref="SpinFramesGenerator"/>.</returns>
+        public SpinFramesGenerator Spin(float delta, double duration)
+        {
+            sequences.Add((delta / 360 * 2 * MathF.PI, duration));
+            return this;
+        }
+
+        /// <summary>
+        /// Constructs the replay frames.
+        /// </summary>
+        /// <returns>The replay frames.</returns>
+        public List<ReplayFrame> Build()
+        {
+            List<ReplayFrame> frames = new List<ReplayFrame>();
+
+            double lastTime = startTime;
+            float lastAngle = startAngle;
+            int lastDirection = 0;
+
+            for (int i = 0; i < sequences.Count; i++)
+            {
+                var seq = sequences[i];
+
+                int seqDirection = Math.Sign(seq.deltaAngle);
+                float seqError = SPIN_ERROR * seqDirection;
+
+                if (seqDirection == lastDirection)
+                {
+                    // Spinning in the same direction, but the error was already added in the last rotation.
+                    seqError = 0;
+                }
+                else if (lastDirection != 0)
+                {
+                    // Spinning in a different direction, we need to account for the error of the start angle, so double it.
+                    seqError *= 2;
+                }
+
+                double seqStartTime = lastTime;
+                double seqEndTime = lastTime + seq.duration;
+                float seqStartAngle = lastAngle;
+                float seqEndAngle = seqStartAngle + seq.deltaAngle + seqError;
+
+                // Intermediate spin frames.
+                for (; lastTime < seqEndTime; lastTime += 10)
+                    frames.Add(new OsuReplayFrame(lastTime, calcOffsetAt((lastTime - seqStartTime) / (seqEndTime - seqStartTime), seqStartAngle, seqEndAngle), OsuAction.LeftButton));
+
+                // Final frame at the end of the current spin.
+                frames.Add(new OsuReplayFrame(seqEndTime, calcOffsetAt(1, seqStartAngle, seqEndAngle), OsuAction.LeftButton));
+
+                lastTime = seqEndTime;
+                lastAngle = seqEndAngle;
+                lastDirection = seqDirection;
+            }
+
+            // Key release frame.
+            if (frames.Count > 0)
+                frames.Add(new OsuReplayFrame(frames[^1].Time, ((OsuReplayFrame)frames[^1]).Position));
+
+            return frames;
+        }
+
+        private static Vector2 calcOffsetAt(double p, float startAngle, float endAngle)
+        {
+            float angle = startAngle + (endAngle - startAngle) * (float)p;
+            return new Vector2(256, 192) + centre_spin_offset * new Vector2(MathF.Cos(angle), MathF.Sin(angle));
+        }
+    }
+}

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

@@ -75,7 +75,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                         pool = pools[poolIndex];
 
                         // We need to make sure neither the pool nor the judgement get disposed when new content is set, and they both share the same parent.
-                        ((Container)pool.Parent).Clear(false);
+                        ((Container)pool.Parent!).Clear(false);
                     }
 
                     var container = new Container

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

@@ -356,15 +356,16 @@ namespace osu.Game.Rulesets.Osu.Tests
                 },
             };
 
-            performTest(hitObjects, new List<ReplayFrame>
+            List<ReplayFrame> frames = new List<ReplayFrame>
             {
                 new OsuReplayFrame { Time = time_spinner - 90, Position = positionCircle, Actions = { OsuAction.LeftButton } },
-                new OsuReplayFrame { Time = time_spinner + 10, Position = new Vector2(236, 192), Actions = { OsuAction.RightButton } },
+            };
-                new OsuReplayFrame { Time = time_spinner + 20, Position = new Vector2(256, 172), Actions = { OsuAction.RightButton } },
+
-                new OsuReplayFrame { Time = time_spinner + 30, Position = new Vector2(276, 192), Actions = { OsuAction.RightButton } },
+            frames.AddRange(new SpinFramesGenerator(time_spinner + 10)
-                new OsuReplayFrame { Time = time_spinner + 40, Position = new Vector2(256, 212), Actions = { OsuAction.RightButton } },
+                            .Spin(360, 500)
-                new OsuReplayFrame { Time = time_spinner + 50, Position = new Vector2(236, 192), Actions = { OsuAction.RightButton } },
+                            .Build());
-            });
+
+            performTest(hitObjects, frames);
 
             addJudgementAssert(hitObjects[0], HitResult.Great);
             addJudgementAssert(hitObjects[1], HitResult.Meh);

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

@@ -32,7 +32,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             });
 
             AddStep("rotate some", () => dho.RotationTracker.AddRotation(180));
-            AddAssert("rotation is set", () => dho.Result.RateAdjustedRotation == 180);
+            AddAssert("rotation is set", () => dho.Result.TotalRotation == 180);
 
             AddStep("apply new spinner", () => dho.Apply(prepareObject(new Spinner
             {
@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 Duration = 1000,
             })));
 
-            AddAssert("rotation is reset", () => dho.Result.RateAdjustedRotation == 0);
+            AddAssert("rotation is reset", () => dho.Result.TotalRotation == 0);
         }
 
         private Spinner prepareObject(Spinner circle)

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

@@ -0,0 +1,290 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI;
+using osu.Game.Scoring;
+using osu.Game.Screens.Play;
+using osu.Game.Storyboards;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public partial class TestSceneSpinnerInput : RateAdjustedBeatmapTestScene
+    {
+        private const int centre_x = 256;
+        private const int centre_y = 192;
+        private const double time_spinner_start = 1500;
+        private const double time_spinner_end = 8000;
+
+        private readonly List<JudgementResult> judgementResults = new List<JudgementResult>();
+
+        private ScoreAccessibleReplayPlayer currentPlayer = null!;
+        private ManualClock? manualClock;
+
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard? storyboard = null)
+        {
+            return manualClock == null
+                ? base.CreateWorkingBeatmap(beatmap, storyboard)
+                : new ClockBackedTestWorkingBeatmap(beatmap, storyboard, new FramedClock(manualClock), Audio);
+        }
+
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            manualClock = null;
+        });
+
+        /// <summary>
+        /// While off-centre, vibrates backwards and forwards on the x-axis, from centre-50 to centre+50, every 50ms.
+        /// </summary>
+        [Test]
+        [Ignore("An upcoming implementation will fix this case")]
+        public void TestVibrateWithoutSpinningOffCentre()
+        {
+            List<ReplayFrame> frames = new List<ReplayFrame>();
+
+            const int vibrate_time = 50;
+            const float y_pos = centre_y - 50;
+
+            int direction = -1;
+
+            for (double i = time_spinner_start; i <= time_spinner_end; i += vibrate_time)
+            {
+                frames.Add(new OsuReplayFrame(i, new Vector2(centre_x + direction * 50, y_pos), OsuAction.LeftButton));
+                frames.Add(new OsuReplayFrame(i + vibrate_time, new Vector2(centre_x - direction * 50, y_pos), OsuAction.LeftButton));
+
+                direction *= -1;
+            }
+
+            performTest(frames);
+
+            assertTicksHit(0);
+            assertSpinnerHit(false);
+        }
+
+        /// <summary>
+        /// While centred on the slider, vibrates backwards and forwards on the x-axis, from centre-50 to centre+50, every 50ms.
+        /// </summary>
+        [Test]
+        [Ignore("An upcoming implementation will fix this case")]
+        public void TestVibrateWithoutSpinningOnCentre()
+        {
+            List<ReplayFrame> frames = new List<ReplayFrame>();
+
+            const int vibrate_time = 50;
+
+            int direction = -1;
+
+            for (double i = time_spinner_start; i <= time_spinner_end; i += vibrate_time)
+            {
+                frames.Add(new OsuReplayFrame(i, new Vector2(centre_x + direction * 50, centre_y), OsuAction.LeftButton));
+                frames.Add(new OsuReplayFrame(i + vibrate_time, new Vector2(centre_x - direction * 50, centre_y), OsuAction.LeftButton));
+
+                direction *= -1;
+            }
+
+            performTest(frames);
+
+            assertTicksHit(0);
+            assertSpinnerHit(false);
+        }
+
+        /// <summary>
+        /// Spins in a single direction.
+        /// </summary>
+        [TestCase(180, 0)]
+        [TestCase(-180, 0)]
+        [TestCase(360, 1)]
+        [TestCase(-360, 1)]
+        [TestCase(540, 1)]
+        [TestCase(-540, 1)]
+        [TestCase(720, 2)]
+        [TestCase(-720, 2)]
+        public void TestSpinSingleDirection(float amount, int expectedTicks)
+        {
+            performTest(new SpinFramesGenerator(time_spinner_start)
+                        .Spin(amount, 500)
+                        .Build());
+
+            assertTicksHit(expectedTicks);
+            assertSpinnerHit(false);
+        }
+
+        /// <summary>
+        /// Spin half-way clockwise then perform one full spin counter-clockwise.
+        /// No ticks should be hit since the total rotation is -0.5 (0.5 CW + 1 CCW = 0.5 CCW).
+        /// </summary>
+        [Test]
+        [Ignore("An upcoming implementation will fix this case")]
+        public void TestSpinHalfBothDirections()
+        {
+            performTest(new SpinFramesGenerator(time_spinner_start)
+                        .Spin(180, 500) // Rotate to +0.5.
+                        .Spin(-360, 500) // Rotate to -0.5
+                        .Build());
+
+            assertTicksHit(0);
+            assertSpinnerHit(false);
+        }
+
+        /// <summary>
+        /// Spin in one direction then spin in the other.
+        /// </summary>
+        [TestCase(180, -540, 1)]
+        [TestCase(-180, 540, 1)]
+        [TestCase(180, -900, 2)]
+        [TestCase(-180, 900, 2)]
+        [Ignore("An upcoming implementation will fix this case")]
+        public void TestSpinOneDirectionThenChangeDirection(float direction1, float direction2, int expectedTicks)
+        {
+            performTest(new SpinFramesGenerator(time_spinner_start)
+                        .Spin(direction1, 500)
+                        .Spin(direction2, 500)
+                        .Build());
+
+            assertTicksHit(expectedTicks);
+            assertSpinnerHit(false);
+        }
+
+        [Test]
+        [Ignore("An upcoming implementation will fix this case")]
+        public void TestRewind()
+        {
+            AddStep("set manual clock", () => manualClock = new ManualClock { Rate = 1 });
+
+            List<ReplayFrame> frames = new SpinFramesGenerator(time_spinner_start)
+                                       .Spin(360, 500) // 2000ms -> 1 full CW spin
+                                       .Spin(-180, 500) // 2500ms -> 0.5 CCW spins
+                                       .Spin(90, 500) // 3000ms -> 0.25 CW spins
+                                       .Spin(450, 500) // 3500ms -> 1 full CW spin
+                                       .Spin(180, 500) // 4000ms -> 0.5 CW spins
+                                       .Build();
+
+            loadPlayer(frames);
+
+            GameplayClockContainer clock = null!;
+            DrawableRuleset drawableRuleset = null!;
+            AddStep("get gameplay objects", () =>
+            {
+                clock = currentPlayer.ChildrenOfType<GameplayClockContainer>().Single();
+                drawableRuleset = currentPlayer.ChildrenOfType<DrawableRuleset>().Single();
+            });
+
+            addSeekStep(frames.Last().Time);
+
+            DrawableSpinner drawableSpinner = null!;
+            AddUntilStep("get spinner", () => (drawableSpinner = currentPlayer.ChildrenOfType<DrawableSpinner>().Single()) != null);
+
+            assertTotalRotation(4000, 900);
+            assertTotalRotation(3750, 810);
+            assertTotalRotation(3500, 720);
+            assertTotalRotation(3250, 530);
+            assertTotalRotation(3000, 540);
+            assertTotalRotation(2750, 540);
+            assertTotalRotation(2500, 540);
+            assertTotalRotation(2250, 360);
+            assertTotalRotation(2000, 180);
+            assertTotalRotation(1500, 0);
+
+            void assertTotalRotation(double time, float expected)
+            {
+                addSeekStep(time);
+                AddAssert($"total rotation @ {time} is {expected}", () => drawableSpinner.Result.TotalRotation,
+                    () => Is.EqualTo(expected).Within(MathHelper.RadiansToDegrees(SpinFramesGenerator.SPIN_ERROR * 2)));
+            }
+
+            void addSeekStep(double time)
+            {
+                AddStep($"seek to {time}", () => clock.Seek(time));
+                AddUntilStep("wait for seek to finish", () => drawableRuleset.FrameStableClock.CurrentTime, () => Is.EqualTo(time));
+            }
+        }
+
+        private void assertTicksHit(int count)
+        {
+            AddAssert($"{count} ticks hit", () => judgementResults.Where(r => r.HitObject is SpinnerTick).Count(r => r.IsHit), () => Is.EqualTo(count));
+        }
+
+        private void assertSpinnerHit(bool shouldBeHit)
+        {
+            AddAssert($"spinner is {(shouldBeHit ? "hit" : "missed")}", () => judgementResults.Single(r => r.HitObject is Spinner).IsHit, () => Is.EqualTo(shouldBeHit));
+        }
+
+        private void loadPlayer(List<ReplayFrame> frames)
+        {
+            AddStep("load player", () =>
+            {
+                Beatmap.Value = CreateWorkingBeatmap(new Beatmap<OsuHitObject>
+                {
+                    HitObjects =
+                    {
+                        new Spinner
+                        {
+                            StartTime = time_spinner_start,
+                            EndTime = time_spinner_end,
+                            Position = new Vector2(centre_x, centre_y)
+                        }
+                    },
+                    BeatmapInfo =
+                    {
+                        Difficulty = new BeatmapDifficulty(),
+                        Ruleset = new OsuRuleset().RulesetInfo
+                    },
+                });
+
+                var p = new ScoreAccessibleReplayPlayer(new Score { Replay = new Replay { Frames = frames } });
+
+                p.OnLoadComplete += _ =>
+                {
+                    p.ScoreProcessor.NewJudgement += result =>
+                    {
+                        if (currentPlayer == p) judgementResults.Add(result);
+                    };
+                };
+
+                LoadScreen(currentPlayer = p);
+                judgementResults.Clear();
+            });
+
+            AddUntilStep("Beatmap at 0", () => Beatmap.Value.Track.CurrentTime == 0);
+            AddUntilStep("Wait until player is loaded", () => currentPlayer.IsCurrentScreen());
+        }
+
+        private void performTest(List<ReplayFrame> frames)
+        {
+            loadPlayer(frames);
+            AddUntilStep("Wait for completion", () => currentPlayer.ScoreProcessor.HasCompleted.Value);
+        }
+
+        private partial class ScoreAccessibleReplayPlayer : ReplayPlayer
+        {
+            public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
+
+            protected override bool PauseOnFocusLost => false;
+
+            public ScoreAccessibleReplayPlayer(Score score)
+                : base(score, new PlayerConfiguration
+                {
+                    AllowPause = false,
+                    ShowResults = false,
+                })
+            {
+            }
+        }
+    }
+}

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

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
@@ -11,14 +10,12 @@ using osu.Game.Beatmaps;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play;
 using osu.Game.Tests.Visual;
-using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
@@ -59,26 +56,9 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddAssert("all max judgements", () => judgementResults.All(result => result.Type == result.Judgement.MaxResult));
         }
 
-        private static List<ReplayFrame> generateReplay(int spins)
+        private static List<ReplayFrame> generateReplay(int spins) => new SpinFramesGenerator(time_spinner_start)
-        {
+                                                                      .Spin(spins * 360, time_spinner_end - time_spinner_start)
-            var replayFrames = new List<ReplayFrame>();
+                                                                      .Build();
-
-            const int frames_per_spin = 30;
-
-            for (int i = 0; i < spins * frames_per_spin; ++i)
-            {
-                float totalProgress = i / (float)(spins * frames_per_spin);
-                float spinProgress = (i % frames_per_spin) / (float)frames_per_spin;
-                double time = time_spinner_start + (time_spinner_end - time_spinner_start) * totalProgress;
-                float posX = MathF.Cos(2 * MathF.PI * spinProgress);
-                float posY = MathF.Sin(2 * MathF.PI * spinProgress);
-                Vector2 finalPos = OsuPlayfield.BASE_SIZE / 2 + new Vector2(posX, posY) * 50;
-
-                replayFrames.Add(new OsuReplayFrame(time, finalPos, OsuAction.LeftButton));
-            }
-
-            return replayFrames;
-        }
 
         private void performTest(List<ReplayFrame> frames)
         {

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

@@ -63,11 +63,11 @@ namespace osu.Game.Rulesets.Osu.Tests
                 trackerRotationTolerance = Math.Abs(drawableSpinner.RotationTracker.Rotation * 0.1f);
             });
             AddAssert("is disc rotation not almost 0", () => drawableSpinner.RotationTracker.Rotation, () => Is.Not.EqualTo(0).Within(100));
-            AddAssert("is disc rotation absolute not almost 0", () => drawableSpinner.Result.RateAdjustedRotation, () => Is.Not.EqualTo(0).Within(100));
+            AddAssert("is disc rotation absolute not almost 0", () => drawableSpinner.Result.TotalRotation, () => Is.Not.EqualTo(0).Within(100));
 
             addSeekStep(0);
             AddAssert("is disc rotation almost 0", () => drawableSpinner.RotationTracker.Rotation, () => Is.EqualTo(0).Within(trackerRotationTolerance));
-            AddAssert("is disc rotation absolute almost 0", () => drawableSpinner.Result.RateAdjustedRotation, () => Is.EqualTo(0).Within(100));
+            AddAssert("is disc rotation absolute almost 0", () => drawableSpinner.Result.TotalRotation, () => Is.EqualTo(0).Within(100));
         }
 
         [Test]
@@ -82,7 +82,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 finalTrackerRotation = drawableSpinner.RotationTracker.Rotation;
                 trackerRotationTolerance = Math.Abs(finalTrackerRotation * 0.05f);
             });
-            AddStep("retrieve cumulative disc rotation", () => finalCumulativeTrackerRotation = drawableSpinner.Result.RateAdjustedRotation);
+            AddStep("retrieve cumulative disc rotation", () => finalCumulativeTrackerRotation = drawableSpinner.Result.TotalRotation);
 
             addSeekStep(spinner_start_time + 2500);
             AddAssert("disc rotation rewound",
@@ -92,13 +92,13 @@ namespace osu.Game.Rulesets.Osu.Tests
                 () => drawableSpinner.RotationTracker.Rotation, () => Is.EqualTo(finalTrackerRotation / 2).Within(trackerRotationTolerance));
             AddAssert("is cumulative rotation rewound",
                 // cumulative rotation is not damped, so we're treating it as the "ground truth" and allowing a comparatively smaller margin of error.
-                () => drawableSpinner.Result.RateAdjustedRotation, () => Is.EqualTo(finalCumulativeTrackerRotation / 2).Within(100));
+                () => drawableSpinner.Result.TotalRotation, () => Is.EqualTo(finalCumulativeTrackerRotation / 2).Within(100));
 
             addSeekStep(spinner_start_time + 5000);
             AddAssert("is disc rotation almost same",
                 () => drawableSpinner.RotationTracker.Rotation, () => Is.EqualTo(finalTrackerRotation).Within(trackerRotationTolerance));
             AddAssert("is cumulative rotation almost same",
-                () => drawableSpinner.Result.RateAdjustedRotation, () => Is.EqualTo(finalCumulativeTrackerRotation).Within(100));
+                () => drawableSpinner.Result.TotalRotation, () => Is.EqualTo(finalCumulativeTrackerRotation).Within(100));
         }
 
         [Test]
@@ -135,7 +135,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
                 // multipled by 2 to nullify the score multiplier. (autoplay mod selected)
                 long totalScore = ((ScoreExposedPlayer)Player).ScoreProcessor.TotalScore.Value * 2;
-                return totalScore == (int)(drawableSpinner.Result.RateAdjustedRotation / 360) * new SpinnerTick().CreateJudgement().MaxNumericResult;
+                return totalScore == (int)(drawableSpinner.Result.TotalRotation / 360) * new SpinnerTick().CreateJudgement().MaxNumericResult;
             });
 
             addSeekStep(0);

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

@@ -284,15 +284,16 @@ namespace osu.Game.Rulesets.Osu.Tests
                 },
             };
 
-            performTest(hitObjects, new List<ReplayFrame>
+            List<ReplayFrame> frames = new List<ReplayFrame>
             {
                 new OsuReplayFrame { Time = time_spinner - 100, Position = positionCircle, Actions = { OsuAction.LeftButton } },
-                new OsuReplayFrame { Time = time_spinner + 10, Position = new Vector2(236, 192), Actions = { OsuAction.RightButton } },
+            };
-                new OsuReplayFrame { Time = time_spinner + 20, Position = new Vector2(256, 172), Actions = { OsuAction.RightButton } },
+
-                new OsuReplayFrame { Time = time_spinner + 30, Position = new Vector2(276, 192), Actions = { OsuAction.RightButton } },
+            frames.AddRange(new SpinFramesGenerator(time_spinner + 10)
-                new OsuReplayFrame { Time = time_spinner + 40, Position = new Vector2(256, 212), Actions = { OsuAction.RightButton } },
+                            .Spin(360, 500)
-                new OsuReplayFrame { Time = time_spinner + 50, Position = new Vector2(236, 192), Actions = { OsuAction.RightButton } },
+                            .Build());
-            });
+
+            performTest(hitObjects, frames);
 
             addJudgementAssert(hitObjects[0], HitResult.Great);
             addJudgementAssert(hitObjects[1], HitResult.Great);

osu.Game.Rulesets.Osu/Difficulty/OsuLegacyScoreSimulator.cs

@@ -2,11 +2,14 @@
 // 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.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Scoring.Legacy;
@@ -174,5 +177,58 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             if (increaseCombo)
                 combo++;
         }
+
+        public double GetLegacyScoreMultiplier(IReadOnlyList<Mod> mods, LegacyBeatmapConversionDifficultyInfo difficulty)
+        {
+            bool scoreV2 = mods.Any(m => m is ModScoreV2);
+
+            double multiplier = 1.0;
+
+            foreach (var mod in mods)
+            {
+                switch (mod)
+                {
+                    case OsuModNoFail:
+                        multiplier *= scoreV2 ? 1.0 : 0.5;
+                        break;
+
+                    case OsuModEasy:
+                        multiplier *= 0.5;
+                        break;
+
+                    case OsuModHalfTime:
+                    case OsuModDaycore:
+                        multiplier *= 0.3;
+                        break;
+
+                    case OsuModHidden:
+                        multiplier *= 1.06;
+                        break;
+
+                    case OsuModHardRock:
+                        multiplier *= scoreV2 ? 1.10 : 1.06;
+                        break;
+
+                    case OsuModDoubleTime:
+                    case OsuModNightcore:
+                        multiplier *= scoreV2 ? 1.20 : 1.12;
+                        break;
+
+                    case OsuModFlashlight:
+                        multiplier *= 1.12;
+                        break;
+
+                    case OsuModSpunOut:
+                        multiplier *= 0.9;
+                        break;
+
+                    case OsuModRelax:
+                    case OsuModAutopilot:
+                        return 0;
+                }
+            }
+
+            return multiplier;
+        }
     }
 }

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs

@@ -288,10 +288,10 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
             if (selectedControlPoints.Contains(hitObject.Path.ControlPoints[0]))
             {
                 // Special handling for selections containing head control point - the position of the hit object changes which means the snapped position and time have to be taken into account
-                Vector2 newHeadPosition = Parent.ToScreenSpace(e.MousePosition + (dragStartPositions[0] - dragStartPositions[draggedControlPointIndex]));
+                Vector2 newHeadPosition = Parent!.ToScreenSpace(e.MousePosition + (dragStartPositions[0] - dragStartPositions[draggedControlPointIndex]));
                 var result = snapProvider?.FindSnappedPositionAndTime(newHeadPosition);
 
-                Vector2 movementDelta = Parent.ToLocalSpace(result?.ScreenSpacePosition ?? newHeadPosition) - hitObject.Position;
+                Vector2 movementDelta = Parent!.ToLocalSpace(result?.ScreenSpacePosition ?? newHeadPosition) - hitObject.Position;
 
                 hitObject.Position += movementDelta;
                 hitObject.StartTime = result?.Time ?? hitObject.StartTime;
@@ -309,9 +309,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
             }
             else
             {
-                var result = snapProvider?.FindSnappedPositionAndTime(Parent.ToScreenSpace(e.MousePosition), SnapType.GlobalGrids);
+                var result = snapProvider?.FindSnappedPositionAndTime(Parent!.ToScreenSpace(e.MousePosition), SnapType.GlobalGrids);
 
-                Vector2 movementDelta = Parent.ToLocalSpace(result?.ScreenSpacePosition ?? Parent.ToScreenSpace(e.MousePosition)) - dragStartPositions[draggedControlPointIndex] - hitObject.Position;
+                Vector2 movementDelta = Parent!.ToLocalSpace(result?.ScreenSpacePosition ?? Parent!.ToScreenSpace(e.MousePosition)) - dragStartPositions[draggedControlPointIndex] - hitObject.Position;
 
                 for (int i = 0; i < controlPoints.Count; ++i)
                 {

osu.Game.Rulesets.Osu/Judgements/OsuSpinnerJudgementResult.cs

@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Osu.Judgements
         /// If Double Time is active instead (with a speed multiplier of 1.5x),
         /// in the same scenario the property will return 720 * 1.5 = 1080.
         /// </example>
-        public float RateAdjustedRotation;
+        public float TotalRotation;
 
         /// <summary>
         /// Time instant at which the spin was started (the first user input which caused an increase in spin).

osu.Game.Rulesets.Osu/Mods/OsuModBlinds.cs

@@ -139,12 +139,12 @@ namespace osu.Game.Rulesets.Osu.Mods
 
                 if (Precision.AlmostEquals(restrictTo.Rotation, 0))
                 {
-                    start = Parent.ToLocalSpace(restrictTo.ScreenSpaceDrawQuad.TopLeft).X;
+                    start = Parent!.ToLocalSpace(restrictTo.ScreenSpaceDrawQuad.TopLeft).X;
-                    end = Parent.ToLocalSpace(restrictTo.ScreenSpaceDrawQuad.TopRight).X;
+                    end = Parent!.ToLocalSpace(restrictTo.ScreenSpaceDrawQuad.TopRight).X;
                 }
                 else
                 {
-                    float center = restrictTo.ToSpaceOfOtherDrawable(restrictTo.OriginPosition, Parent).X;
+                    float center = restrictTo.ToSpaceOfOtherDrawable(restrictTo.OriginPosition, Parent!).X;
                     float halfDiagonal = (restrictTo.DrawSize / 2).LengthFast;
 
                     start = center - halfDiagonal;

osu.Game.Rulesets.Osu/Mods/OsuModHardRock.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Linq;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;
@@ -22,5 +23,13 @@ namespace osu.Game.Rulesets.Osu.Mods
 
             OsuHitObjectGenerationUtils.ReflectVerticallyAlongPlayfield(osuObject);
         }
+
+        public override void ApplyToDifficulty(BeatmapDifficulty difficulty)
+        {
+            base.ApplyToDifficulty(difficulty);
+
+            difficulty.CircleSize = Math.Min(difficulty.CircleSize * 1.3f, 10.0f); // CS uses a custom 1.3 ratio.
+            difficulty.ApproachRate = Math.Min(difficulty.ApproachRate * ADJUST_RATIO, 10.0f);
+        }
     }
 }

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs

@@ -102,7 +102,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         /// </summary>
         public void MissForcefully() => ApplyResult(r => r.Type = r.Judgement.MinResult);
 
-        private RectangleF parentScreenSpaceRectangle => ((DrawableOsuHitObject)ParentHitObject)?.parentScreenSpaceRectangle ?? Parent.ScreenSpaceDrawQuad.AABBFloat;
+        private RectangleF parentScreenSpaceRectangle => ((DrawableOsuHitObject)ParentHitObject)?.parentScreenSpaceRectangle ?? Parent!.ScreenSpaceDrawQuad.AABBFloat;
 
         /// <summary>
         /// Calculates the position of the given <paramref name="drawable"/> relative to the playfield area.

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs

@@ -218,7 +218,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     // these become implicitly hit.
                     return 1;
 
-                return Math.Clamp(Result.RateAdjustedRotation / 360 / HitObject.SpinsRequired, 0, 1);
+                return Math.Clamp(Result.TotalRotation / 360 / HitObject.SpinsRequired, 0, 1);
             }
         }
 
@@ -279,7 +279,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             // don't update after end time to avoid the rate display dropping during fade out.
             // this shouldn't be limited to StartTime as it causes weirdness with the underlying calculation, which is expecting updates during that period.
             if (Time.Current <= HitObject.EndTime)
-                spmCalculator.SetRotation(Result.RateAdjustedRotation);
+                spmCalculator.SetRotation(Result.TotalRotation);
 
             updateBonusScore();
         }
@@ -293,7 +293,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             if (ticks.Count == 0)
                 return;
 
-            int spins = (int)(Result.RateAdjustedRotation / 360);
+            int spins = (int)(Result.TotalRotation / 360);
 
             if (spins < completedFullSpins)
             {

osu.Game.Rulesets.Osu/Objects/Spinner.cs

@@ -70,8 +70,11 @@ namespace osu.Game.Rulesets.Osu.Objects
 
             double secondsDuration = Duration / 1000;
 
-            SpinsRequired = (int)(minRps * secondsDuration);
+            // Allow a 0.1ms floating point precision error in the calculation of the duration.
-            MaximumBonusSpins = Math.Max(0, (int)(maxRps * secondsDuration) - SpinsRequired - bonus_spins_gap);
+            const double duration_error = 0.0001;
+
+            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)

osu.Game.Rulesets.Osu/Skinning/Argon/ArgonSliderBall.cs

@@ -109,7 +109,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
             base.Update();
 
             //undo rotation on layers which should not be rotated.
-            float appliedRotation = Parent.Rotation;
+            float appliedRotation = Parent!.Rotation;
 
             fill.Rotation = -appliedRotation;
         }

osu.Game.Rulesets.Osu/Skinning/Argon/ArgonSpinnerDisc.cs

@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
         {
             get
             {
-                int rotations = (int)(drawableSpinner.Result.RateAdjustedRotation / 360);
+                int rotations = (int)(drawableSpinner.Result.TotalRotation / 360);
 
                 if (wholeRotationCount == rotations) return false;
 

osu.Game.Rulesets.Osu/Skinning/Default/DefaultSpinnerDisc.cs

@@ -200,7 +200,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
         {
             get
             {
-                int rotations = (int)(drawableSpinner.Result.RateAdjustedRotation / 360);
+                int rotations = (int)(drawableSpinner.Result.TotalRotation / 360);
 
                 if (wholeRotationCount == rotations) return false;
 

osu.Game.Rulesets.Osu/Skinning/Default/SpinnerRotationTracker.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Diagnostics;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.ObjectExtensions;
@@ -22,11 +23,10 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
 
         private readonly DrawableSpinner drawableSpinner;
 
-        private Vector2 mousePosition;
+        private Vector2? mousePosition;
+        private float? lastAngle;
 
-        private float lastAngle;
         private float currentRotation;
-
         private bool rotationTransferred;
 
         [Resolved(canBeNull: true)]
@@ -56,24 +56,30 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
 
         protected override bool OnMouseMove(MouseMoveEvent e)
         {
-            mousePosition = Parent.ToLocalSpace(e.ScreenSpaceMousePosition);
+            mousePosition = Parent!.ToLocalSpace(e.ScreenSpaceMousePosition);
             return base.OnMouseMove(e);
         }
 
         protected override void Update()
         {
             base.Update();
-            float thisAngle = -MathUtils.RadiansToDegrees(MathF.Atan2(mousePosition.X - DrawSize.X / 2, mousePosition.Y - DrawSize.Y / 2));
 
-            float delta = thisAngle - lastAngle;
+            if (mousePosition is Vector2 pos)
+            {
+                float thisAngle = -MathUtils.RadiansToDegrees(MathF.Atan2(pos.X - DrawSize.X / 2, pos.Y - DrawSize.Y / 2));
+                float delta = lastAngle == null ? 0 : thisAngle - lastAngle.Value;
 
-            if (Tracking)
+                // Normalise the delta to -180 .. 180
-                AddRotation(delta);
+                if (delta > 180) delta -= 360;
+                if (delta < -180) delta += 360;
 
-            lastAngle = thisAngle;
+                if (Tracking)
+                    AddRotation(delta);
+
+                lastAngle = thisAngle;
+            }
 
             IsSpinning.Value = isSpinnableTime && Math.Abs(currentRotation - Rotation) > 10f;
-
             Rotation = (float)Interpolation.Damp(Rotation, currentRotation, 0.99, Math.Abs(Time.Elapsed));
         }
 
@@ -83,41 +89,37 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
         /// <remarks>
         /// Will be a no-op if not a valid time to spin.
         /// </remarks>
-        /// <param name="angle">The delta angle.</param>
+        /// <param name="delta">The delta angle.</param>
-        public void AddRotation(float angle)
+        public void AddRotation(float delta)
         {
             if (!isSpinnableTime)
                 return;
 
             if (!rotationTransferred)
             {
-                currentRotation = Rotation * 2;
+                currentRotation = Rotation;
                 rotationTransferred = true;
             }
 
-            if (angle > 180)
+            currentRotation += delta;
-            {
+
-                lastAngle += 360;
+            double rate = gameplayClock?.GetTrueGameplayRate() ?? Clock.Rate;
-                angle -= 360;
+
-            }
+            Debug.Assert(Math.Abs(delta) <= 180);
-            else if (-angle > 180)
-            {
-                lastAngle -= 360;
-                angle += 360;
-            }
 
-            currentRotation += angle;
             // rate has to be applied each frame, because it's not guaranteed to be constant throughout playback
             // (see: ModTimeRamp)
-            drawableSpinner.Result.RateAdjustedRotation += (float)(Math.Abs(angle) * (gameplayClock?.GetTrueGameplayRate() ?? Clock.Rate));
+            drawableSpinner.Result.TotalRotation += (float)(Math.Abs(delta) * rate);
         }
 
         private void resetState(DrawableHitObject obj)
         {
             Tracking = false;
             IsSpinning.Value = false;
-            mousePosition = default;
+            mousePosition = null;
-            lastAngle = currentRotation = Rotation = 0;
+            lastAngle = null;
+            currentRotation = 0;
+            Rotation = 0;
             rotationTransferred = false;
         }
 

osu.Game.Rulesets.Osu/Skinning/Legacy/LegacyApproachCircle.cs

@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
         private DrawableHitObject drawableObject { get; set; } = null!;
 
         public LegacyApproachCircle()
-            : base("Gameplay/osu/approachcircle", OsuHitObject.OBJECT_DIMENSIONS)
+            : base("Gameplay/osu/approachcircle", OsuHitObject.OBJECT_DIMENSIONS * 2)
         {
         }
 

osu.Game.Rulesets.Osu/Skinning/Legacy/LegacyMainCirclePiece.cs

@@ -67,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)?.WithMaximumSize(OsuHitObject.OBJECT_DIMENSIONS) })
+                CircleSprite = new LegacyKiaiFlashingDrawable(() => new Sprite { Texture = skin.GetTexture(circleName)?.WithMaximumSize(OsuHitObject.OBJECT_DIMENSIONS * 2) })
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -76,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, maxSize: OsuHitObject.OBJECT_DIMENSIONS))
+                    Child = OverlaySprite = new LegacyKiaiFlashingDrawable(() => skin.GetAnimation(@$"{circleName}overlay", true, true, frameLength: 1000 / 2d, maxSize: OsuHitObject.OBJECT_DIMENSIONS * 2))
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,

osu.Game.Rulesets.Osu/Skinning/Legacy/LegacyReverseArrow.cs

@@ -39,7 +39,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 
             var skin = skinSource.FindProvider(s => s.GetTexture(lookupName) != null);
 
-            InternalChild = arrow = (skin?.GetAnimation(lookupName, true, true, maxSize: OsuHitObject.OBJECT_DIMENSIONS) ?? Empty()).With(d =>
+            InternalChild = arrow = (skin?.GetAnimation(lookupName, true, true, maxSize: OsuHitObject.OBJECT_DIMENSIONS * 2) ?? Empty()).With(d =>
             {
                 d.Anchor = Anchor.Centre;
                 d.Origin = Anchor.Centre;

osu.Game.Rulesets.Osu/Skinning/Legacy/LegacySliderBall.cs

@@ -7,7 +7,6 @@ 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 osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Skinning;
 using osuTK.Graphics;
@@ -47,7 +46,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Texture = skin.GetTexture("sliderb-nd")?.WithMaximumSize(OsuHitObject.OBJECT_DIMENSIONS),
+                    Texture = skin.GetTexture("sliderb-nd")?.WithMaximumSize(OsuLegacySkinTransformer.MAX_FOLLOW_CIRCLE_AREA_SIZE),
                     Colour = new Color4(5, 5, 5, 255),
                 },
                 LegacyColourCompatibility.ApplyWithDoubledAlpha(animationContent.With(d =>
@@ -59,7 +58,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Texture = skin.GetTexture("sliderb-spec")?.WithMaximumSize(OsuHitObject.OBJECT_DIMENSIONS),
+                    Texture = skin.GetTexture("sliderb-spec")?.WithMaximumSize(OsuLegacySkinTransformer.MAX_FOLLOW_CIRCLE_AREA_SIZE),
                     Blending = BlendingParameters.Additive,
                 },
             };
@@ -89,7 +88,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
             base.UpdateAfterChildren();
 
             //undo rotation on layers which should not be rotated.
-            float appliedRotation = Parent.Rotation;
+            float appliedRotation = Parent!.Rotation;
 
             layerNd.Rotation = -appliedRotation;
             layerSpec.Rotation = -appliedRotation;

osu.Game.Rulesets.Osu/Skinning/Legacy/OsuLegacySkinTransformer.cs

@@ -23,6 +23,16 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
         /// </summary>
         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)
         {
@@ -36,20 +46,20 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                 switch (osuComponent.Component)
                 {
                     case OsuSkinComponents.FollowPoint:
-                        return this.GetAnimation("followpoint", true, true, true, startAtCurrentTime: false);
+                        return this.GetAnimation("followpoint", true, true, true, startAtCurrentTime: false, maxSize: new Vector2(OsuHitObject.OBJECT_RADIUS * 2, OsuHitObject.OBJECT_RADIUS));
 
                     case OsuSkinComponents.SliderScorePoint:
-                        return this.GetAnimation("sliderscorepoint", false, false);
+                        return this.GetAnimation("sliderscorepoint", false, false, maxSize: OsuHitObject.OBJECT_DIMENSIONS);
 
                     case OsuSkinComponents.SliderFollowCircle:
-                        var followCircleContent = this.GetAnimation("sliderfollowcircle", true, true, true, maxSize: new Vector2(308f));
+                        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: "", maxSize: OsuHitObject.OBJECT_DIMENSIONS);
+                        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);
@@ -139,10 +149,11 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                         if (!this.HasFont(LegacyFont.HitCircle))
                             return null;
 
-                        return new LegacySpriteText(LegacyFont.HitCircle, OsuHitObject.OBJECT_DIMENSIONS)
+                        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:

osu.Game.Rulesets.Osu/UI/OsuPlayfieldAdjustmentContainer.cs

@@ -60,12 +60,12 @@ namespace osu.Game.Rulesets.Osu.UI
                 // game_size = DrawSizePreservingFillContainer.TargetSize = new Vector2(1024, 768)
                 //
                 // Parent is a 4:3 aspect enforced, using height as the constricting dimension
-                // Parent.ChildSize.X = min(game_size.X, game_size.Y * (4 / 3)) * playfield_size_adjust
+                // Parent!.ChildSize.X = min(game_size.X, game_size.Y * (4 / 3)) * playfield_size_adjust
-                // Parent.ChildSize.X = 819.2
+                // Parent!.ChildSize.X = 819.2
                 //
                 // Scale = 819.2 / 512
                 // Scale = 1.6
-                Scale = new Vector2(Parent.ChildSize.X / OsuPlayfield.BASE_SIZE.X);
+                Scale = new Vector2(Parent!.ChildSize.X / OsuPlayfield.BASE_SIZE.X);
                 Position = new Vector2(0, (PlayfieldShift ? 8f : 0f) * Scale.X);
                 // Size = 0.625
                 Size = Vector2.Divide(Vector2.One, Scale);

osu.Game.Rulesets.Taiko.Tests/Judgements/TestSceneSwellJudgements.cs

@@ -115,6 +115,48 @@ namespace osu.Game.Rulesets.Taiko.Tests.Judgements
             AddAssert("all tick offsets are 0", () => JudgementResults.Where(r => r.HitObject is SwellTick).All(r => r.TimeOffset == 0));
         }
 
+        [Test]
+        public void TestAtMostOneSwellTickJudgedPerFrame()
+        {
+            const double swell_time = 1000;
+
+            Swell swell = new Swell
+            {
+                StartTime = swell_time,
+                Duration = 1000,
+                RequiredHits = 10
+            };
+
+            List<ReplayFrame> frames = new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(1000),
+                new TaikoReplayFrame(1250, TaikoAction.LeftCentre, TaikoAction.LeftRim),
+                new TaikoReplayFrame(1251),
+                new TaikoReplayFrame(1500, TaikoAction.LeftCentre, TaikoAction.LeftRim, TaikoAction.RightCentre, TaikoAction.RightRim),
+                new TaikoReplayFrame(1501),
+                new TaikoReplayFrame(2000),
+            };
+
+            PerformTest(frames, CreateBeatmap(swell));
+
+            AssertJudgementCount(11);
+
+            // this is a charitable interpretation of the inputs.
+            //
+            // for the frame at time 1250, we only count either one of the input actions - simple.
+            //
+            // for the frame at time 1500, we give the user the benefit of the doubt,
+            // and we ignore actions that wouldn't otherwise cause a hit due to not alternating,
+            // but we still count one (just one) of the actions that _would_ normally cause a hit.
+            // this is done as a courtesy to avoid stuff like key chattering after press blocking legitimate inputs.
+            for (int i = 0; i < 2; i++)
+                AssertResult<SwellTick>(i, HitResult.IgnoreHit);
+            for (int i = 2; i < swell.RequiredHits; i++)
+                AssertResult<SwellTick>(i, HitResult.IgnoreMiss);
+
+            AssertResult<Swell>(0, HitResult.IgnoreMiss);
+        }
+
         /// <summary>
         /// Ensure input is correctly sent to subsequent hits if a swell is fully completed.
         /// </summary>

osu.Game.Rulesets.Taiko.Tests/TestSceneDrumSampleTriggerSource.cs

@@ -38,7 +38,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
         [SetUp]
         public void SetUp() => Schedule(() =>
         {
-            gameplayClock = new GameplayClockContainer(manualClock)
+            gameplayClock = new GameplayClockContainer(manualClock, false, false)
             {
                 RelativeSizeAxes = Axes.Both,
                 Children = new Drawable[]

osu.Game.Rulesets.Taiko/Difficulty/TaikoLegacyScoreSimulator.cs

@@ -2,13 +2,16 @@
 // 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.Scoring;
 using osu.Game.Rulesets.Scoring.Legacy;
+using osu.Game.Rulesets.Taiko.Mods;
 using osu.Game.Rulesets.Taiko.Objects;
 
 namespace osu.Game.Rulesets.Taiko.Difficulty
@@ -194,5 +197,47 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
             if (increaseCombo)
                 combo++;
         }
+
+        public double GetLegacyScoreMultiplier(IReadOnlyList<Mod> mods, LegacyBeatmapConversionDifficultyInfo difficulty)
+        {
+            bool scoreV2 = mods.Any(m => m is ModScoreV2);
+
+            double multiplier = 1.0;
+
+            foreach (var mod in mods)
+            {
+                switch (mod)
+                {
+                    case TaikoModNoFail:
+                        multiplier *= scoreV2 ? 1.0 : 0.5;
+                        break;
+
+                    case TaikoModEasy:
+                        multiplier *= 0.5;
+                        break;
+
+                    case TaikoModHalfTime:
+                    case TaikoModDaycore:
+                        multiplier *= 0.3;
+                        break;
+
+                    case TaikoModHidden:
+                    case TaikoModHardRock:
+                        multiplier *= 1.06;
+                        break;
+
+                    case TaikoModDoubleTime:
+                    case TaikoModNightcore:
+                    case TaikoModFlashlight:
+                        multiplier *= 1.12;
+                        break;
+
+                    case TaikoModRelax:
+                        return 0;
+                }
+            }
+
+            return multiplier;
+        }
     }
 }

osu.Game.Rulesets.Taiko/Edit/Blueprints/TaikoSelectionBlueprint.cs

@@ -30,8 +30,8 @@ namespace osu.Game.Rulesets.Taiko.Edit.Blueprints
             var topLeft = new Vector2(float.MaxValue, float.MaxValue);
             var bottomRight = new Vector2(float.MinValue, float.MinValue);
 
-            topLeft = Vector2.ComponentMin(topLeft, Parent.ToLocalSpace(DrawableObject.ScreenSpaceDrawQuad.TopLeft));
+            topLeft = Vector2.ComponentMin(topLeft, Parent!.ToLocalSpace(DrawableObject.ScreenSpaceDrawQuad.TopLeft));
-            bottomRight = Vector2.ComponentMax(bottomRight, Parent.ToLocalSpace(DrawableObject.ScreenSpaceDrawQuad.BottomRight));
+            bottomRight = Vector2.ComponentMax(bottomRight, Parent!.ToLocalSpace(DrawableObject.ScreenSpaceDrawQuad.BottomRight));
 
             Size = bottomRight - topLeft;
             Position = topLeft;

osu.Game.Rulesets.Taiko/Edit/DrawableTaikoEditorRuleset.cs

@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Taiko.Edit
 {
     public partial class DrawableTaikoEditorRuleset : DrawableTaikoRuleset, ISupportConstantAlgorithmToggle
     {
-        public BindableBool ShowSpeedChanges { get; set; } = new BindableBool();
+        public BindableBool ShowSpeedChanges { get; } = new BindableBool();
 
         public DrawableTaikoEditorRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods)
             : base(ruleset, beatmap, mods)

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwell.cs

@@ -17,6 +17,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Taiko.Skinning.Default;
+using osu.Game.Screens.Play;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
@@ -38,6 +39,8 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         private readonly CircularContainer targetRing;
         private readonly CircularContainer expandingRing;
 
+        private double? lastPressHandleTime;
+
         public override bool DisplayResult => false;
 
         public DrawableSwell()
@@ -140,6 +143,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             UnproxyContent();
 
             lastWasCentre = null;
+            lastPressHandleTime = null;
         }
 
         protected override void AddNestedHitObject(DrawableHitObject hitObject)
@@ -257,7 +261,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         {
             base.Update();
 
-            Size = BaseSize * Parent.RelativeChildSize;
+            Size = BaseSize * Parent!.RelativeChildSize;
 
             // Make the swell stop at the hit target
             X = Math.Max(0, X);
@@ -266,6 +270,9 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                 ProxyContent();
             else
                 UnproxyContent();
+
+            if ((Clock as IGameplayClock)?.IsRewinding == true)
+                lastPressHandleTime = null;
         }
 
         private bool? lastWasCentre;
@@ -285,7 +292,14 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             if (lastWasCentre == isCentre)
                 return false;
 
+            // If we've already successfully judged a tick this frame, do not judge more.
+            // Note that the ordering is important here - this is intentionally placed after the alternating check.
+            // That is done to prevent accidental double inputs blocking simultaneous but legitimate hits from registering.
+            if (lastPressHandleTime == Time.Current)
+                return true;
+
             lastWasCentre = isCentre;
+            lastPressHandleTime = Time.Current;
 
             UpdateResult(true);
 

osu.Game.Rulesets.Taiko/Skinning/Argon/ArgonElongatedCirclePiece.cs

@@ -27,7 +27,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Argon
         protected override void Update()
         {
             base.Update();
-            Width = Parent.DrawSize.X + DrawHeight;
+            Width = Parent!.DrawSize.X + DrawHeight;
         }
     }
 }