Update framework

.github/workflows/diffcalc.yml

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

osu.Android.props

@@ -10,7 +10,7 @@
     <EmbedAssembliesIntoApk>true</EmbedAssembliesIntoApk>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2023.1012.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2023.925.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.9" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.8" />
     <PackageReference Include="nunit" Version="3.13.3" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
   </ItemGroup>

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

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

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

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

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

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

osu.Game.Rulesets.Catch/CatchRuleset.cs

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

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

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

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

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

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

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

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

@@ -1,26 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using osu.Game.Rulesets.Catch.Objects;
-using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Objects;
-
-namespace osu.Game.Rulesets.Catch.Edit
-{
-    public partial class CatchDistanceSnapProvider : ComposerDistanceSnapProvider
-    {
-        protected override double ReadCurrentDistanceSnap(HitObject before, HitObject after)
-        {
-            // osu!catch's distance snap implementation is limited, in that a custom spacing cannot be specified.
-            // Therefore this functionality is not currently used.
-            //
-            // The implementation below is probably correct but should be checked if/when exposed via controls.
-
-            float expectedDistance = DurationToDistance(before, after.StartTime - before.GetEndTime());
-            float actualDistance = Math.Abs(((CatchHitObject)before).EffectiveX - ((CatchHitObject)after).EffectiveX);
-
-            return actualDistance / expectedDistance;
-        }
-    }
-}

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

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

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

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

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

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

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

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

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

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

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

@@ -77,7 +77,7 @@ namespace osu.Game.Rulesets.Catch.Objects
             int nodeIndex = 0;
             SliderEventDescriptor? lastEvent = null;
 
-            foreach (var e in SliderEventGenerator.Generate(StartTime, SpanDuration, Velocity, TickDistance, Path.Distance, this.SpanCount(), cancellationToken))
+            foreach (var e in SliderEventGenerator.Generate(StartTime, SpanDuration, Velocity, TickDistance, Path.Distance, this.SpanCount(), LegacyLastTickOffset, cancellationToken))
             {
                 // generate tiny droplets since the last point
                 if (lastEvent != null)
@@ -104,8 +104,8 @@ namespace osu.Game.Rulesets.Catch.Objects
                     }
                 }
 
-                // this also includes LastTick and this is used for TinyDroplet generation above.
-                // this means that the final segment of TinyDroplets are increasingly mistimed where LastTick is being applied.
+                // this also includes LegacyLastTick and this is used for TinyDroplet generation above.
+                // this means that the final segment of TinyDroplets are increasingly mistimed where LegacyLastTickOffset is being applied.
                 lastEvent = e;
 
                 switch (e.Type)
@@ -162,5 +162,7 @@ namespace osu.Game.Rulesets.Catch.Objects
         public double Distance => Path.Distance;
 
         public IList<IList<HitSampleInfo>> NodeSamples { get; set; } = new List<IList<HitSampleInfo>>();
+
+        public double? LegacyLastTickOffset { get; set; }
     }
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs

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

osu.Game.Rulesets.Mania/ManiaRuleset.cs

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

osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -7,6 +7,7 @@ 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;
@@ -68,6 +69,9 @@ 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,11 +109,10 @@ 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<HoldNoteBody, DrawableHoldNoteBody>(10, 50);
+            RegisterPool<HoldNoteTick, DrawableHoldNoteTick>(50, 250);
         }
 
         private void onSourceChanged()

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

@@ -11,6 +11,7 @@ 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;
@@ -149,6 +150,9 @@ 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,6 +195,10 @@ 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") == true);
+            AddAssert("merge option available", () => selectionHandler.ContextMenuItems.Any(o => o.Text.Value == "Merge selection"));
 
             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") == true);
+            AddAssert("merge option available", () => selectionHandler.ContextMenuItems.Any(o => o.Text.Value == "Merge selection"));
 
             mergeSelection();
 

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

@@ -47,7 +47,8 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
         [Cached]
         private readonly BindableBeatDivisor beatDivisor = new BindableBeatDivisor();
 
-        private readonly TestHitObjectComposer composer = new TestHitObjectComposer
+        [Cached(typeof(IDistanceSnapProvider))]
+        private readonly OsuHitObjectComposer snapProvider = new OsuHitObjectComposer(new OsuRuleset())
         {
             // Just used for the snap implementation, so let's hide from vision.
             AlwaysPresent = true,
@@ -70,18 +71,11 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             base.Content.Children = new Drawable[]
             {
                 editorClock = new EditorClock(editorBeatmap),
-                new PopoverContainer { Child = composer },
+                new PopoverContainer { Child = snapProvider },
                 Content
             };
         }
 
-        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
-        {
-            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
-            dependencies.CacheAs(composer.DistanceSnapProvider);
-            return dependencies;
-        }
-
         protected override Container<Drawable> Content { get; } = new PopoverContainer { RelativeSizeAxes = Axes.Both };
 
         [SetUp]
@@ -90,7 +84,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             editorBeatmap.Difficulty.SliderMultiplier = 1;
             editorBeatmap.ControlPointInfo.Clear();
             editorBeatmap.ControlPointInfo.Add(0, new TimingControlPoint { BeatLength = beat_length });
-            composer.DistanceSnapProvider.DistanceSpacingMultiplier.Value = 1;
+            snapProvider.DistanceSpacingMultiplier.Value = 1;
 
             Children = new Drawable[]
             {
@@ -122,7 +116,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
         [TestCase(0.5f)]
         public void TestDistanceSpacing(float multiplier)
         {
-            AddStep($"set distance spacing = {multiplier}", () => composer.DistanceSnapProvider.DistanceSpacingMultiplier.Value = multiplier);
+            AddStep($"set distance spacing = {multiplier}", () => snapProvider.DistanceSpacingMultiplier.Value = multiplier);
         }
 
         [Test]
@@ -159,7 +153,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
         [TestCase(2f, beat_length * 2)]
         public void TestDistanceSpacingAdjust(float multiplier, float expectedDistance)
         {
-            AddStep($"Set distance spacing to {multiplier}", () => composer.DistanceSnapProvider.DistanceSpacingMultiplier.Value = multiplier);
+            AddStep($"Set distance spacing to {multiplier}", () => snapProvider.DistanceSpacingMultiplier.Value = multiplier);
             AddStep("move mouse to point", () => InputManager.MoveMouseTo(grid.ToScreenSpace(grid_position + new Vector2(beat_length, 0) * 2)));
 
             assertSnappedDistance(expectedDistance);
@@ -272,15 +266,5 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                 cursor.Position = LastSnappedPosition = GetSnapPosition.Invoke(inputManager.CurrentState.Mouse.Position);
             }
         }
-
-        private partial class TestHitObjectComposer : OsuHitObjectComposer
-        {
-            public new IDistanceSnapProvider DistanceSnapProvider => base.DistanceSnapProvider;
-
-            public TestHitObjectComposer()
-                : base(new OsuRuleset())
-            {
-            }
-        }
     }
 }

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

@@ -163,6 +163,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                 slider = new Slider
                 {
                     Position = new Vector2(0, 50),
+                    LegacyLastTickOffset = 36, // This is necessary for undo to retain the sample control point
                     Path = new SliderPath(new[]
                     {
                         new PathControlPoint(Vector2.Zero, PathType.PerfectCurve),
@@ -231,7 +232,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 +242,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/Mods/TestSceneOsuModAutoplay.cs

@@ -51,9 +51,8 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
                 FinalRate = { Value = 1.3 }
             });
 
-        [TestCase(6.25f)]
-        [TestCase(20)]
-        public void TestPerfectScoreOnShortSliderWithRepeat(float pathLength)
+        [Test]
+        public void TestPerfectScoreOnShortSliderWithRepeat()
         {
             AddStep("set score to standardised", () => LocalConfig.SetValue(OsuSetting.ScoreDisplayMode, ScoringMode.Standardised));
 
@@ -71,7 +70,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
                             Path = new SliderPath(new[]
                             {
                                 new PathControlPoint(),
-                                new PathControlPoint(new Vector2(0, pathLength))
+                                new PathControlPoint(new Vector2(0, 6.25f))
                             }),
                             RepeatCount = 1,
                             SliderVelocityMultiplier = 10

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

@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Utils;
 using osu.Game.Rulesets.Objects;
@@ -34,21 +33,8 @@ namespace osu.Game.Rulesets.Osu.Tests
             switch (hitObject)
             {
                 case Slider slider:
-                    var objects = new List<ConvertValue>();
-
                     foreach (var nested in slider.NestedHitObjects)
-                        objects.Add(createConvertValue((OsuHitObject)nested, slider));
-
-                    // stable does slider tail leniency by offsetting the last tick 36ms back.
-                    // based on player feedback, we're doing this a little different in lazer,
-                    // and the lazer method does not require offsetting the last tick
-                    // (see `DrawableSliderTail.CheckForResult()`).
-                    // however, in conversion tests, just so the output matches, we're bringing
-                    // the 36ms offset back locally.
-                    // in particular, on some sliders, this may rearrange nested objects,
-                    // so we sort them again by start time to prevent test failures.
-                    foreach (var obj in objects.OrderBy(cv => cv.StartTime))
-                        yield return obj;
+                        yield return createConvertValue((OsuHitObject)nested);
 
                     break;
 
@@ -58,29 +44,13 @@ namespace osu.Game.Rulesets.Osu.Tests
                     break;
             }
 
-            static ConvertValue createConvertValue(OsuHitObject obj, OsuHitObject? parent = null)
+            static ConvertValue createConvertValue(OsuHitObject obj) => new ConvertValue
             {
-                double startTime = obj.StartTime;
-                double endTime = obj.GetEndTime();
-
-                // as stated in the inline comment above, this is locally bringing back
-                // the stable treatment of the "legacy last tick" just to make sure
-                // that the conversion output matches.
-                // compare: `SliderEventGenerator.Generate()`, and the calculation of `legacyLastTickTime`.
-                if (obj is SliderTailCircle && parent is Slider slider)
-                {
-                    startTime = Math.Max(startTime + SliderEventGenerator.TAIL_LENIENCY, slider.StartTime + slider.Duration / 2);
-                    endTime = Math.Max(endTime + SliderEventGenerator.TAIL_LENIENCY, slider.StartTime + slider.Duration / 2);
-                }
-
-                return new ConvertValue
-                {
-                    StartTime = startTime,
-                    EndTime = endTime,
-                    X = obj.StackedPosition.X,
-                    Y = obj.StackedPosition.Y
-                };
-            }
+                StartTime = obj.StartTime,
+                EndTime = obj.GetEndTime(),
+                X = obj.StackedPosition.X,
+                Y = obj.StackedPosition.Y
+            };
         }
 
         protected override Ruleset CreateRuleset() => new OsuRuleset();

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

@@ -15,22 +15,19 @@ namespace osu.Game.Rulesets.Osu.Tests
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Osu";
 
-        [TestCase(6.710442985146793d, 206, "diffcalc-test")]
-        [TestCase(1.4386882251130073d, 45, "zero-length-sliders")]
-        [TestCase(0.42506480230838789d, 2, "very-fast-slider")]
+        [TestCase(6.7115569159190587d, 206, "diffcalc-test")]
+        [TestCase(1.4391311903612753d, 45, "zero-length-sliders")]
         [TestCase(0.14102693012101306d, 1, "nan-slider")]
         public void Test(double expectedStarRating, int expectedMaxCombo, string name)
             => base.Test(expectedStarRating, expectedMaxCombo, name);
 
-        [TestCase(8.9742952703071666d, 206, "diffcalc-test")]
-        [TestCase(0.55071082800473514d, 2, "very-fast-slider")]
-        [TestCase(1.743180218215227d, 45, "zero-length-sliders")]
+        [TestCase(8.9757300665532966d, 206, "diffcalc-test")]
+        [TestCase(1.7437232654020756d, 45, "zero-length-sliders")]
         public void TestClockRateAdjusted(double expectedStarRating, int expectedMaxCombo, string name)
             => Test(expectedStarRating, expectedMaxCombo, name, new OsuModDoubleTime());
 
-        [TestCase(6.710442985146793d, 239, "diffcalc-test")]
-        [TestCase(0.42506480230838789d, 4, "very-fast-slider")]
-        [TestCase(1.4386882251130073d, 54, "zero-length-sliders")]
+        [TestCase(6.7115569159190587d, 239, "diffcalc-test")]
+        [TestCase(1.4391311903612753d, 54, "zero-length-sliders")]
         public void TestClassicMod(double expectedStarRating, int expectedMaxCombo, string name)
             => Test(expectedStarRating, expectedMaxCombo, name, new OsuModClassic());
 

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

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

@@ -1,135 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using NUnit.Framework;
-using osu.Game.Rulesets.Osu.Objects.Drawables;
-
-namespace osu.Game.Rulesets.Osu.Tests
-{
-    [TestFixture]
-    public class SpinnerSpinHistoryTest
-    {
-        private SpinnerSpinHistory history = null!;
-
-        [SetUp]
-        public void Setup()
-        {
-            history = new SpinnerSpinHistory();
-        }
-
-        [TestCase(0, 0)]
-        [TestCase(10, 10)]
-        [TestCase(180, 180)]
-        [TestCase(350, 350)]
-        [TestCase(360, 360)]
-        [TestCase(370, 370)]
-        [TestCase(540, 540)]
-        [TestCase(720, 720)]
-        // ---
-        [TestCase(-0, 0)]
-        [TestCase(-10, 10)]
-        [TestCase(-180, 180)]
-        [TestCase(-350, 350)]
-        [TestCase(-360, 360)]
-        [TestCase(-370, 370)]
-        [TestCase(-540, 540)]
-        [TestCase(-720, 720)]
-        public void TestSpinOneDirection(float spin, float expectedRotation)
-        {
-            history.ReportDelta(500, spin);
-            Assert.That(history.TotalRotation, Is.EqualTo(expectedRotation));
-        }
-
-        [TestCase(0, 0, 0, 0)]
-        // ---
-        [TestCase(10, -10, 0, 10)]
-        [TestCase(-10, 10, 0, 10)]
-        // ---
-        [TestCase(10, -20, 0, 10)]
-        [TestCase(-10, 20, 0, 10)]
-        // ---
-        [TestCase(20, -10, 0, 20)]
-        [TestCase(-20, 10, 0, 20)]
-        // ---
-        [TestCase(10, -360, 0, 350)]
-        [TestCase(-10, 360, 0, 350)]
-        // ---
-        [TestCase(360, -10, 0, 370)]
-        [TestCase(360, 10, 0, 370)]
-        [TestCase(-360, 10, 0, 370)]
-        [TestCase(-360, -10, 0, 370)]
-        // ---
-        [TestCase(10, 10, 10, 30)]
-        [TestCase(10, 10, -10, 20)]
-        [TestCase(10, -10, 10, 10)]
-        [TestCase(-10, -10, -10, 30)]
-        [TestCase(-10, -10, 10, 20)]
-        [TestCase(-10, 10, 10, 10)]
-        // ---
-        [TestCase(10, -20, -350, 360)]
-        [TestCase(10, -20, 350, 340)]
-        [TestCase(-10, 20, 350, 360)]
-        [TestCase(-10, 20, -350, 340)]
-        public void TestSpinMultipleDirections(float spin1, float spin2, float spin3, float expectedRotation)
-        {
-            history.ReportDelta(500, spin1);
-            history.ReportDelta(1000, spin2);
-            history.ReportDelta(1500, spin3);
-            Assert.That(history.TotalRotation, Is.EqualTo(expectedRotation));
-        }
-
-        // One spin
-        [TestCase(370, -50, 320)]
-        [TestCase(-370, 50, 320)]
-        // Two spins
-        [TestCase(740, -420, 320)]
-        [TestCase(-740, 420, 320)]
-        public void TestRemoveAndCrossFullSpin(float deltaToAdd, float deltaToRemove, float expectedRotation)
-        {
-            history.ReportDelta(1000, deltaToAdd);
-            history.ReportDelta(500, deltaToRemove);
-            Assert.That(history.TotalRotation, Is.EqualTo(expectedRotation));
-        }
-
-        // One spin + partial
-        [TestCase(400, -30, -50, 320)]
-        [TestCase(-400, 30, 50, 320)]
-        // Two spins + partial
-        [TestCase(800, -430, -50, 320)]
-        [TestCase(-800, 430, 50, 320)]
-        public void TestRemoveAndCrossFullAndPartialSpins(float deltaToAdd1, float deltaToAdd2, float deltaToRemove, float expectedRotation)
-        {
-            history.ReportDelta(1000, deltaToAdd1);
-            history.ReportDelta(1500, deltaToAdd2);
-            history.ReportDelta(500, deltaToRemove);
-            Assert.That(history.TotalRotation, Is.EqualTo(expectedRotation));
-        }
-
-        [Test]
-        public void TestRewindMultipleFullSpins()
-        {
-            history.ReportDelta(500, 360);
-            history.ReportDelta(1000, 720);
-
-            Assert.That(history.TotalRotation, Is.EqualTo(1080));
-
-            history.ReportDelta(250, -900);
-
-            Assert.That(history.TotalRotation, Is.EqualTo(180));
-        }
-
-        [Test]
-        public void TestRewindOverDirectionChange()
-        {
-            history.ReportDelta(1000, 40); // max is now CW 40 degrees
-            Assert.That(history.TotalRotation, Is.EqualTo(40));
-            history.ReportDelta(1100, -90); // max is now CCW 50 degrees
-            Assert.That(history.TotalRotation, Is.EqualTo(50));
-            history.ReportDelta(1200, 110); // max is now CW 60 degrees
-            Assert.That(history.TotalRotation, Is.EqualTo(60));
-
-            history.ReportDelta(1000, -20);
-            Assert.That(history.TotalRotation, Is.EqualTo(40));
-        }
-    }
-}

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

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

@@ -27,7 +27,6 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Configuration;
-using osu.Game.Rulesets.Osu.Mods;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
@@ -51,8 +50,6 @@ namespace osu.Game.Rulesets.Osu.Tests
                 snakingOut.Value = !v;
             });
 
-            AddToggleStep("toggle hidden", hiddenActive => SelectedMods.Value = hiddenActive ? new[] { new OsuModHidden() } : Array.Empty<Mod>());
-
             AddSliderStep("hit at", 0f, 1f, 0f, v =>
             {
                 progressToHit = v;

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

@@ -10,7 +10,6 @@ using osu.Game.Beatmaps;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Replays;
@@ -36,7 +35,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             const double time_slider_start = 1000;
 
-            float circleRadius = OsuHitObject.OBJECT_RADIUS * LegacyRulesetExtensions.CalculateScaleFromCircleSize(circleSize, true);
+            float circleRadius = OsuHitObject.OBJECT_RADIUS * (1.0f - 0.7f * (circleSize - 5) / 5) / 2;
             float followCircleRadius = circleRadius * 1.2f;
 
             performTest(new Beatmap<OsuHitObject>

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

@@ -1,12 +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.
 
+#nullable disable
+
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Screens;
 using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
@@ -32,100 +33,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         private const double time_during_slide_4 = 3800;
         private const double time_slider_end = 4000;
 
-        private ScoreAccessibleReplayPlayer currentPlayer = null!;
-
-        private const float slider_path_length = 25;
-
-        private readonly List<JudgementResult> judgementResults = new List<JudgementResult>();
-
-        // Making these too short causes breakage from frames not being processed fast enough.
-        // To keep things simple, these tests are crafted to always be >16ms length.
-        // If sliders shorter than this are ever used in gameplay it will probably break things and we can revisit.
-        [TestCase(30, 0)]
-        [TestCase(30, 1)]
-        [TestCase(40, 0)]
-        [TestCase(40, 1)]
-        [TestCase(50, 1)]
-        [TestCase(60, 1)]
-        [TestCase(70, 1)]
-        [TestCase(80, 1)]
-        [TestCase(80, 0)]
-        [TestCase(80, 10)]
-        [TestCase(90, 1)]
-        [Ignore("headless test doesn't run at high enough precision for this to always enter a tracking state in time.")]
-        public void TestVeryShortSlider(float sliderLength, int repeatCount)
-        {
-            Slider slider;
-
-            performTest(new List<ReplayFrame>
-            {
-                new OsuReplayFrame { Position = new Vector2(10, 0), Actions = { OsuAction.LeftButton, OsuAction.RightButton }, Time = time_slider_start - 10 },
-                new OsuReplayFrame { Position = new Vector2(10, 0), Actions = { OsuAction.LeftButton, OsuAction.RightButton }, Time = time_slider_start + 2000 },
-            }, slider = new Slider
-            {
-                StartTime = time_slider_start,
-                Position = new Vector2(0, 0),
-                SliderVelocityMultiplier = 10f,
-                RepeatCount = repeatCount,
-                Path = new SliderPath(PathType.Linear, new[]
-                {
-                    Vector2.Zero,
-                    new Vector2(sliderLength, 0),
-                }),
-            }, 240, 1);
-
-            assertAllMaxJudgements();
-
-            // Even if the last tick is hit early, the slider should always execute its final judgement at its endtime.
-            // If not, hitsounds will not play on time.
-            AddAssert("Judgement offset is zero", () => judgementResults.Last().TimeOffset == 0);
-            AddAssert("Slider judged at end time", () => judgementResults.Last().TimeAbsolute, () => Is.EqualTo(slider.EndTime));
-
-            AddAssert("Slider is last judgement", () => judgementResults[^1].HitObject, Is.TypeOf<Slider>);
-            AddAssert("Tail is second last judgement", () => judgementResults[^2].HitObject, Is.TypeOf<SliderTailCircle>);
-        }
-
-        [TestCase(300, false)]
-        [TestCase(200, true)]
-        [TestCase(150, true)]
-        [TestCase(120, true)]
-        [TestCase(60, true)]
-        [TestCase(10, true)]
-        [TestCase(0, true)]
-        [TestCase(-30, false)]
-        [Ignore("headless test doesn't run at high enough precision for this to always enter a tracking state in time.")]
-        public void TestTailLeniency(float finalPosition, bool hit)
-        {
-            Slider slider;
-
-            performTest(new List<ReplayFrame>
-            {
-                new OsuReplayFrame { Position = Vector2.Zero, Actions = { OsuAction.LeftButton, OsuAction.RightButton }, Time = time_slider_start },
-                new OsuReplayFrame { Position = new Vector2(finalPosition, slider_path_length * 3), Actions = { OsuAction.LeftButton, OsuAction.RightButton }, Time = time_slider_start + 20 },
-            }, slider = new Slider
-            {
-                StartTime = time_slider_start,
-                Position = new Vector2(0, 0),
-                SliderVelocityMultiplier = 10f,
-                Path = new SliderPath(PathType.Linear, new[]
-                {
-                    Vector2.Zero,
-                    new Vector2(slider_path_length * 10, 0),
-                    new Vector2(slider_path_length * 10, slider_path_length * 3),
-                    new Vector2(0, slider_path_length * 3),
-                }),
-            }, 240, 1);
-
-            if (hit)
-                assertAllMaxJudgements();
-            else
-                AddAssert("Tracking dropped", assertMidSliderJudgementFail);
-
-            // Even if the last tick is hit early, the slider should always execute its final judgement at its endtime.
-            // If not, hitsounds will not play on time.
-            AddAssert("Judgement offset is zero", () => judgementResults.Last().TimeOffset == 0);
-            AddAssert("Slider judged at end time", () => judgementResults.Last().TimeAbsolute, () => Is.EqualTo(slider.EndTime));
-        }
+        private List<JudgementResult> judgementResults;
 
         [Test]
         public void TestPressBothKeysSimultaneouslyAndReleaseOne()
@@ -136,7 +44,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 new OsuReplayFrame { Position = Vector2.Zero, Actions = { OsuAction.RightButton }, Time = time_during_slide_1 },
             });
 
-            assertAllMaxJudgements();
+            AddAssert("Tracking retained", assertMaxJudge);
         }
 
         /// <summary>
@@ -178,7 +86,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.RightButton }, Time = time_during_slide_2 },
             });
 
-            assertAllMaxJudgements();
+            AddAssert("Tracking retained", assertMaxJudge);
         }
 
         /// <summary>
@@ -199,7 +107,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.RightButton }, Time = time_during_slide_1 },
             });
 
-            assertAllMaxJudgements();
+            AddAssert("Tracking retained", assertMaxJudge);
         }
 
         /// <summary>
@@ -220,7 +128,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.RightButton }, Time = time_during_slide_1 },
             });
 
-            assertAllMaxJudgements();
+            AddAssert("Tracking retained", assertMaxJudge);
         }
 
         /// <summary>
@@ -393,7 +301,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 new OsuReplayFrame { Position = new Vector2(slider_path_length, OsuHitObject.OBJECT_RADIUS * 1.199f), Actions = { OsuAction.LeftButton }, Time = time_slider_end },
             });
 
-            assertAllMaxJudgements();
+            AddAssert("Tracking kept", assertMaxJudge);
         }
 
         /// <summary>
@@ -417,13 +325,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddAssert("Tracking dropped", assertMidSliderJudgementFail);
         }
 
-        private void assertAllMaxJudgements()
-        {
-            AddAssert("All judgements max", () =>
-            {
-                return judgementResults.Select(j => (j.HitObject, j.Type));
-            }, () => Is.EqualTo(judgementResults.Select(j => (j.HitObject, j.Judgement.MaxResult))));
-        }
+        private bool assertMaxJudge() => judgementResults.Any() && judgementResults.All(t => t.Type == t.Judgement.MaxResult);
 
         private bool assertHeadMissTailTracked() => judgementResults[^2].Type == HitResult.SmallTickHit && !judgementResults.First().IsHit;
 
@@ -431,36 +333,35 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         private bool assertMidSliderJudgementFail() => judgementResults[^2].Type == HitResult.SmallTickMiss;
 
-        private void performTest(List<ReplayFrame> frames, Slider? slider = null, double? bpm = null, int? tickRate = null)
-        {
-            slider ??= new Slider
-            {
-                StartTime = time_slider_start,
-                Position = new Vector2(0, 0),
-                SliderVelocityMultiplier = 0.1f,
-                Path = new SliderPath(PathType.PerfectCurve, new[]
-                {
-                    Vector2.Zero,
-                    new Vector2(slider_path_length, 0),
-                }, slider_path_length),
-            };
+        private ScoreAccessibleReplayPlayer currentPlayer;
 
+        private const float slider_path_length = 25;
+
+        private void performTest(List<ReplayFrame> frames)
+        {
             AddStep("load player", () =>
             {
-                var cpi = new ControlPointInfo();
-
-                if (bpm != null)
-                    cpi.Add(0, new TimingControlPoint { BeatLength = 60000 / bpm.Value });
-
                 Beatmap.Value = CreateWorkingBeatmap(new Beatmap<OsuHitObject>
                 {
-                    HitObjects = { slider },
+                    HitObjects =
+                    {
+                        new Slider
+                        {
+                            StartTime = time_slider_start,
+                            Position = new Vector2(0, 0),
+                            SliderVelocityMultiplier = 0.1f,
+                            Path = new SliderPath(PathType.PerfectCurve, new[]
+                            {
+                                Vector2.Zero,
+                                new Vector2(slider_path_length, 0),
+                            }, slider_path_length),
+                        }
+                    },
                     BeatmapInfo =
                     {
-                        Difficulty = new BeatmapDifficulty { SliderTickRate = tickRate ?? 3 },
-                        Ruleset = new OsuRuleset().RulesetInfo,
+                        Difficulty = new BeatmapDifficulty { SliderTickRate = 3 },
+                        Ruleset = new OsuRuleset().RulesetInfo
                     },
-                    ControlPointInfo = cpi,
                 });
 
                 var p = new ScoreAccessibleReplayPlayer(new Score { Replay = new Replay { Frames = frames } });
@@ -474,7 +375,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 };
 
                 LoadScreen(currentPlayer = p);
-                judgementResults.Clear();
+                judgementResults = new List<JudgementResult>();
             });
 
             AddUntilStep("Beatmap at 0", () => Beatmap.Value.Track.CurrentTime == 0);

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

@@ -6,7 +6,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Testing;
 using osu.Game.Audio;
@@ -27,15 +26,6 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         private TestDrawableSpinner drawableSpinner;
 
-        private readonly BindableDouble spinRate = new BindableDouble();
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            AddSliderStep("Spin rate", 0.5, 5, 1, val => spinRate.Value = val);
-        }
-
         [TestCase(true)]
         [TestCase(false)]
         public void TestVariousSpinners(bool autoplay)
@@ -53,8 +43,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddUntilStep("Pitch starts low", () => getSpinningSample().Frequency.Value < 0.8);
             AddUntilStep("Pitch increases", () => getSpinningSample().Frequency.Value > 0.8);
 
-            PausableSkinnableSound getSpinningSample() =>
-                drawableSpinner.ChildrenOfType<PausableSkinnableSound>().FirstOrDefault(s => s.Samples.Any(i => i.LookupNames.Any(l => l.Contains("spinnerspin"))));
+            PausableSkinnableSound getSpinningSample() => drawableSpinner.ChildrenOfType<PausableSkinnableSound>().FirstOrDefault(s => s.Samples.Any(i => i.LookupNames.Any(l => l.Contains("spinnerspin"))));
         }
 
         [TestCase(false)]
@@ -75,39 +64,6 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddUntilStep("Short spinner implicitly completes", () => drawableSpinner.Progress == 1);
         }
 
-        [TestCase(0, 4, 6)]
-        [TestCase(5, 7, 10)]
-        [TestCase(10, 11, 8)]
-        public void TestSpinnerSpinRequirements(int od, int normalTicks, int bonusTicks)
-        {
-            Spinner spinner = null;
-
-            AddStep("add spinner", () => SetContents(_ =>
-            {
-                spinner = new Spinner
-                {
-                    StartTime = Time.Current,
-                    EndTime = Time.Current + 3000,
-                    Samples = new List<HitSampleInfo>
-                    {
-                        new HitSampleInfo(HitSampleInfo.HIT_NORMAL)
-                    }
-                };
-
-                spinner.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty { OverallDifficulty = od });
-
-                return drawableSpinner = new TestDrawableSpinner(spinner, true, spinRate)
-                {
-                    Anchor = Anchor.Centre,
-                    Depth = depthIndex++,
-                    Scale = new Vector2(0.75f)
-                };
-            }));
-
-            AddAssert("number of normal ticks matches", () => spinner.SpinsRequired, () => Is.EqualTo(normalTicks));
-            AddAssert("number of bonus ticks matches", () => spinner.MaximumBonusSpins, () => Is.EqualTo(bonusTicks));
-        }
-
         private Drawable testSingle(float circleSize, bool auto = false, double length = 3000)
         {
             const double delay = 2000;
@@ -124,7 +80,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             spinner.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty { CircleSize = circleSize });
 
-            drawableSpinner = new TestDrawableSpinner(spinner, auto, spinRate)
+            drawableSpinner = new TestDrawableSpinner(spinner, auto)
             {
                 Anchor = Anchor.Centre,
                 Depth = depthIndex++,
@@ -140,20 +96,18 @@ namespace osu.Game.Rulesets.Osu.Tests
         private partial class TestDrawableSpinner : DrawableSpinner
         {
             private readonly bool auto;
-            private readonly BindableDouble spinRate;
 
-            public TestDrawableSpinner(Spinner s, bool auto, BindableDouble spinRate)
+            public TestDrawableSpinner(Spinner s, bool auto)
                 : base(s)
             {
                 this.auto = auto;
-                this.spinRate = spinRate;
             }
 
             protected override void Update()
             {
                 base.Update();
                 if (auto)
-                    RotationTracker.AddRotation((float)(Clock.ElapsedFrameTime * spinRate.Value));
+                    RotationTracker.AddRotation((float)(Clock.ElapsedFrameTime * 2));
             }
         }
     }

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.TotalRotation == 180);
+            AddAssert("rotation is set", () => dho.Result.RateAdjustedRotation == 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.TotalRotation == 0);
+            AddAssert("rotation is reset", () => dho.Result.RateAdjustedRotation == 0);
         }
 
         private Spinner prepareObject(Spinner circle)

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

@@ -1,319 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.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]
-        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]
-        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]
-        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)]
-        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]
-        public void TestRewind()
-        {
-            AddStep("set manual clock", () => manualClock = new ManualClock
-            {
-                // Avoids interpolation trying to run ahead during testing.
-                Rate = 0
-            });
-
-            List<ReplayFrame> frames =
-                new SpinFramesGenerator(time_spinner_start)
-                    // 1500ms start
-                    .Spin(360, 500)
-                    // 2000ms -> 1 full CW spin
-                    .Spin(-180, 500)
-                    // 2500ms -> 1 full CW spin + 0.5 CCW spins
-                    .Spin(90, 500)
-                    // 3000ms -> 1 full CW spin + 0.25 CCW spins
-                    .Spin(450, 500)
-                    // 3500ms -> 2 full CW spins
-                    .Spin(180, 500)
-                    // 4000ms -> 2 full CW spins + 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);
-
-            assertFinalRotationCorrect();
-            assertTotalRotation(3750, 810);
-            assertTotalRotation(3500, 720);
-            assertTotalRotation(3250, 530);
-            assertTotalRotation(3000, 450);
-            assertTotalRotation(2750, 540);
-            assertTotalRotation(2500, 540);
-            assertTotalRotation(2250, 450);
-            assertTotalRotation(2000, 360);
-            assertTotalRotation(1500, 0);
-
-            // same thing but always returning to final time to check.
-            assertFinalRotationCorrect();
-            assertTotalRotation(3750, 810);
-            assertFinalRotationCorrect();
-            assertTotalRotation(3500, 720);
-            assertFinalRotationCorrect();
-            assertTotalRotation(3250, 530);
-            assertFinalRotationCorrect();
-            assertTotalRotation(3000, 450);
-            assertFinalRotationCorrect();
-            assertTotalRotation(2750, 540);
-            assertFinalRotationCorrect();
-            assertTotalRotation(2500, 540);
-            assertFinalRotationCorrect();
-            assertTotalRotation(2250, 450);
-            assertFinalRotationCorrect();
-            assertTotalRotation(2000, 360);
-            assertFinalRotationCorrect();
-            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));
-                // Lenience is required due to interpolation running slightly ahead on a stalled clock.
-                AddUntilStep("wait for seek to finish", () => drawableRuleset.FrameStableClock.CurrentTime, () => Is.EqualTo(time));
-            }
-
-            void assertFinalRotationCorrect() => assertTotalRotation(4000, 900);
-        }
-
-        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,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
@@ -10,12 +11,14 @@ 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
 {
@@ -56,9 +59,26 @@ 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) => new SpinFramesGenerator(time_spinner_start)
-                                                                      .Spin(spins * 360, time_spinner_end - time_spinner_start)
-                                                                      .Build();
+        private static List<ReplayFrame> generateReplay(int spins)
+        {
+            var replayFrames = new List<ReplayFrame>();
+
+            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.TotalRotation, () => Is.Not.EqualTo(0).Within(100));
+            AddAssert("is disc rotation absolute not almost 0", () => drawableSpinner.Result.RateAdjustedRotation, () => 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.TotalRotation, () => Is.EqualTo(0).Within(100));
+            AddAssert("is disc rotation absolute almost 0", () => drawableSpinner.Result.RateAdjustedRotation, () => 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.TotalRotation);
+            AddStep("retrieve cumulative disc rotation", () => finalCumulativeTrackerRotation = drawableSpinner.Result.RateAdjustedRotation);
 
             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.TotalRotation, () => Is.EqualTo(finalCumulativeTrackerRotation / 2).Within(100));
+                () => drawableSpinner.Result.RateAdjustedRotation, () => 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.TotalRotation, () => Is.EqualTo(finalCumulativeTrackerRotation).Within(100));
+                () => drawableSpinner.Result.RateAdjustedRotation, () => 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.TotalRotation / 360) * new SpinnerTick().CreateJudgement().MaxNumericResult;
+                return totalScore == (int)(drawableSpinner.Result.RateAdjustedRotation / 360) * new SpinnerTick().CreateJudgement().MaxNumericResult;
             });
 
             addSeekStep(0);

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

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

osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapConverter.cs

@@ -44,6 +44,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                         Position = positionData?.Position ?? Vector2.Zero,
                         NewCombo = comboData?.NewCombo ?? false,
                         ComboOffset = comboData?.ComboOffset ?? 0,
+                        LegacyLastTickOffset = (original as IHasLegacyLastTickOffset)?.LegacyLastTickOffset,
                         // prior to v8, speed multipliers don't adjust for how many ticks are generated over the same distance.
                         // this results in more (or less) ticks being generated in <v8 maps for the same time duration.
                         TickDistanceMultiplier = beatmap.BeatmapInfo.BeatmapVersion < 8 ? 1f / ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(original.StartTime).SliderVelocity : 1,

osu.Game.Rulesets.Osu/Difficulty/Evaluators/AimEvaluator.cs

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
         /// <item><description>and slider difficulty.</description></item>
         /// </list>
         /// </summary>
-        public static double EvaluateDifficultyOf(DifficultyHitObject current, bool withSliderTravelDistance)
+        public static double EvaluateDifficultyOf(DifficultyHitObject current, bool withSliders)
         {
             if (current.BaseObject is Spinner || current.Index <= 1 || current.Previous(0).BaseObject is Spinner)
                 return 0;
@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
             double currVelocity = osuCurrObj.LazyJumpDistance / osuCurrObj.StrainTime;
 
             // But if the last object is a slider, then we extend the travel velocity through the slider into the current object.
-            if (osuLastObj.BaseObject is Slider && withSliderTravelDistance)
+            if (osuLastObj.BaseObject is Slider && withSliders)
             {
                 double travelVelocity = osuLastObj.TravelDistance / osuLastObj.TravelTime; // calculate the slider velocity from slider head to slider end.
                 double movementVelocity = osuCurrObj.MinimumJumpDistance / osuCurrObj.MinimumJumpTime; // calculate the movement velocity from slider end to current object
@@ -48,7 +48,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
             // As above, do the same for the previous hitobject.
             double prevVelocity = osuLastObj.LazyJumpDistance / osuLastObj.StrainTime;
 
-            if (osuLastLastObj.BaseObject is Slider && withSliderTravelDistance)
+            if (osuLastLastObj.BaseObject is Slider && withSliders)
             {
                 double travelVelocity = osuLastLastObj.TravelDistance / osuLastLastObj.TravelTime;
                 double movementVelocity = osuLastObj.MinimumJumpDistance / osuLastObj.MinimumJumpTime;
@@ -122,7 +122,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
             aimStrain += Math.Max(acuteAngleBonus * acute_angle_multiplier, wideAngleBonus * wide_angle_multiplier + velocityChangeBonus * velocity_change_multiplier);
 
             // Add in additional slider velocity bonus.
-            if (withSliderTravelDistance)
+            if (withSliders)
                 aimStrain += sliderBonus * slider_multiplier;
 
             return aimStrain;