Merge branch 'master' into beatmap-info-purge

2024-12-05 10:33:22 +08:00 · 2024-11-22 18:47:32 +09:00 · 2024-11-22 18:47:32 +09:00 · 086a34f5c0
commit 086a34f5c0
parent 58fe502af4 479ff7eb41
715 changed files with 16876 additions and 6225 deletions
--- a/.github/workflows/_diffcalc_processor.yml
+++ b/.github/workflows/_diffcalc_processor.yml
@ -0,0 +1,228 @@
+name: "🔒diffcalc (do not use)"
+
+on:
+  workflow_call:
+    inputs:
+      id:
+        type: string
+      head-sha:
+        type: string
+      pr-url:
+        type: string
+      pr-text:
+        type: string
+      dispatch-inputs:
+        type: string
+    outputs:
+      target:
+        description: The comparison target.
+        value: ${{ jobs.generator.outputs.target }}
+      sheet:
+        description: The comparison spreadsheet.
+        value: ${{ jobs.generator.outputs.sheet }}
+    secrets:
+      DIFFCALC_GOOGLE_CREDENTIALS:
+        required: true
+
+env:
+  GENERATOR_DIR: ${{ github.workspace }}/${{ inputs.id }}
+  GENERATOR_ENV: ${{ github.workspace }}/${{ inputs.id }}/.env
+
+defaults:
+  run:
+    shell: bash -euo pipefail {0}
+
+jobs:
+  generator:
+    name: Run
+    runs-on: self-hosted
+    timeout-minutes: 720
+
+    outputs:
+      target: ${{ steps.run.outputs.target }}
+      sheet: ${{ steps.run.outputs.sheet }}
+
+    steps:
+      - name: Checkout diffcalc-sheet-generator
+        uses: actions/checkout@v4
+        with:
+          path: ${{ inputs.id }}
+          repository: 'smoogipoo/diffcalc-sheet-generator'
+
+      - name: Add base environment
+        env:
+          GOOGLE_CREDS_FILE: ${{ github.workspace }}/${{ inputs.id }}/google-credentials.json
+          VARS_JSON: ${{ (vars != null && toJSON(vars)) || '' }}
+        run: |
+          # Required by diffcalc-sheet-generator
+          cp '${{ env.GENERATOR_DIR }}/.env.sample' "${{ env.GENERATOR_ENV }}"
+
+          # Add Google credentials
+          echo '${{ secrets.DIFFCALC_GOOGLE_CREDENTIALS }}' | base64 -d > "${{ env.GOOGLE_CREDS_FILE }}"
+
+          # Add repository variables
+          echo "${VARS_JSON}" | jq -c '. | to_entries | .[]' | while read -r line; do
+              opt=$(jq -r '.key' <<< ${line})
+              val=$(jq -r '.value' <<< ${line})
+
+              if [[ "${opt}" =~ ^DIFFCALC_ ]]; then
+                optNoPrefix=$(echo "${opt}" | cut -d '_' -f2-)
+                sed -i "s;^${optNoPrefix}=.*$;${optNoPrefix}=${val};" "${{ env.GENERATOR_ENV }}"
+              fi
+          done
+
+      - name: Add HEAD environment
+        run: |
+          sed -i "s;^OSU_A=.*$;OSU_A=${{ inputs.head-sha }};" "${{ env.GENERATOR_ENV }}"
+
+      - name: Add pull-request environment
+        if: ${{ inputs.pr-url != '' }}
+        run: |
+          sed -i "s;^OSU_B=.*$;OSU_B=${{ inputs.pr-url }};" "${{ env.GENERATOR_ENV }}"
+
+      - name: Add comment environment
+        if: ${{ inputs.pr-text != '' }}
+        env:
+          PR_TEXT: ${{ inputs.pr-text }}
+        run: |
+          # Add comment environment
+          echo "${PR_TEXT}" | sed -r 's/\r$//' | { grep -E '^\w+=' || true; } | while read -r line; do
+              opt=$(echo "${line}" | cut -d '=' -f1)
+              sed -i "s;^${opt}=.*$;${line};" "${{ env.GENERATOR_ENV }}"
+          done
+
+      - name: Add dispatch environment
+        if: ${{ inputs.dispatch-inputs != '' }}
+        env:
+          DISPATCH_INPUTS_JSON: ${{ inputs.dispatch-inputs }}
+        run: |
+          function get_input() {
+            echo "${DISPATCH_INPUTS_JSON}" | jq -r ".\"$1\""
+          }
+
+          osu_a=$(get_input 'osu-a')
+          osu_b=$(get_input 'osu-b')
+          ruleset=$(get_input 'ruleset')
+          generators=$(get_input 'generators')
+          difficulty_calculator_a=$(get_input 'difficulty-calculator-a')
+          difficulty_calculator_b=$(get_input 'difficulty-calculator-b')
+          score_processor_a=$(get_input 'score-processor-a')
+          score_processor_b=$(get_input 'score-processor-b')
+          converts=$(get_input 'converts')
+          ranked_only=$(get_input 'ranked-only')
+
+          sed -i "s;^OSU_B=.*$;OSU_B=${osu_b};" "${{ env.GENERATOR_ENV }}"
+          sed -i "s/^RULESET=.*$/RULESET=${ruleset}/" "${{ env.GENERATOR_ENV }}"
+          sed -i "s/^GENERATORS=.*$/GENERATORS=${generators}/" "${{ env.GENERATOR_ENV }}"
+
+          if [[ "${osu_a}" != 'latest' ]]; then
+              sed -i "s;^OSU_A=.*$;OSU_A=${osu_a};" "${{ env.GENERATOR_ENV }}"
+          fi
+
+          if [[ "${difficulty_calculator_a}" != 'latest' ]]; then
+              sed -i "s;^DIFFICULTY_CALCULATOR_A=.*$;DIFFICULTY_CALCULATOR_A=${difficulty_calculator_a};" "${{ env.GENERATOR_ENV }}"
+          fi
+
+          if [[ "${difficulty_calculator_b}" != 'latest' ]]; then
+              sed -i "s;^DIFFICULTY_CALCULATOR_B=.*$;DIFFICULTY_CALCULATOR_B=${difficulty_calculator_b};" "${{ env.GENERATOR_ENV }}"
+          fi
+
+          if [[ "${score_processor_a}" != 'latest' ]]; then
+              sed -i "s;^SCORE_PROCESSOR_A=.*$;SCORE_PROCESSOR_A=${score_processor_a};" "${{ env.GENERATOR_ENV }}"
+          fi
+
+          if [[ "${score_processor_b}" != 'latest' ]]; then
+              sed -i "s;^SCORE_PROCESSOR_B=.*$;SCORE_PROCESSOR_B=${score_processor_b};" "${{ env.GENERATOR_ENV }}"
+          fi
+
+          if [[ "${converts}" == 'true' ]]; then
+              sed -i 's/^NO_CONVERTS=.*$/NO_CONVERTS=0/' "${{ env.GENERATOR_ENV }}"
+          else
+              sed -i 's/^NO_CONVERTS=.*$/NO_CONVERTS=1/' "${{ env.GENERATOR_ENV }}"
+          fi
+
+          if [[ "${ranked_only}" == 'true' ]]; then
+              sed -i 's/^RANKED_ONLY=.*$/RANKED_ONLY=1/' "${{ env.GENERATOR_ENV }}"
+          else
+              sed -i 's/^RANKED_ONLY=.*$/RANKED_ONLY=0/' "${{ env.GENERATOR_ENV }}"
+          fi
+
+      - name: Query latest scores
+        id: query-scores
+        run: |
+          ruleset=$(cat ${{ env.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=${{ env.GENERATOR_DIR }}/sql/${ruleset}" >> "${GITHUB_OUTPUT}"
+          echo "DATA_NAME=${performance_data_name}" >> "${GITHUB_OUTPUT}"
+          echo "DATA_PKG=${performance_data_name}.tar.bz2" >> "${GITHUB_OUTPUT}"
+
+      - name: Restore score cache
+        id: restore-score-cache
+        uses: maxnowack/local-cache@720e69c948191660a90aa1cf6a42fc4d2dacdf30 # v2
+        with:
+          path: ${{ steps.query-scores.outputs.DATA_PKG }}
+          key: ${{ steps.query-scores.outputs.DATA_NAME }}
+
+      - name: Download scores
+        if: steps.restore-score-cache.outputs.cache-hit != 'true'
+        run: |
+          wget -q -O "${{ steps.query-scores.outputs.DATA_PKG }}" "https://data.ppy.sh/${{ steps.query-scores.outputs.DATA_PKG }}"
+
+      - name: Extract scores
+        run: |
+          tar -I lbzip2 -xf "${{ steps.query-scores.outputs.DATA_PKG }}"
+          rm -r "${{ steps.query-scores.outputs.TARGET_DIR }}"
+          mv "${{ steps.query-scores.outputs.DATA_NAME }}" "${{ steps.query-scores.outputs.TARGET_DIR }}"
+
+      - name: Query latest beatmaps
+        id: query-beatmaps
+        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=${{ env.GENERATOR_DIR }}/beatmaps" >> "${GITHUB_OUTPUT}"
+          echo "DATA_NAME=${beatmaps_data_name}" >> "${GITHUB_OUTPUT}"
+          echo "DATA_PKG=${beatmaps_data_name}.tar.bz2" >> "${GITHUB_OUTPUT}"
+
+      - name: Restore beatmap cache
+        id: restore-beatmap-cache
+        uses: maxnowack/local-cache@720e69c948191660a90aa1cf6a42fc4d2dacdf30 # v2
+        with:
+          path: ${{ steps.query-beatmaps.outputs.DATA_PKG }}
+          key: ${{ steps.query-beatmaps.outputs.DATA_NAME }}
+
+      - name: Download beatmap
+        if: steps.restore-beatmap-cache.outputs.cache-hit != 'true'
+        run: |
+          wget -q -O "${{ steps.query-beatmaps.outputs.DATA_PKG }}" "https://data.ppy.sh/${{ steps.query-beatmaps.outputs.DATA_PKG }}"
+
+      - name: Extract beatmap
+        run: |
+          tar -I lbzip2 -xf "${{ steps.query-beatmaps.outputs.DATA_PKG }}"
+          rm -r "${{ steps.query-beatmaps.outputs.TARGET_DIR }}"
+          mv "${{ steps.query-beatmaps.outputs.DATA_NAME }}" "${{ steps.query-beatmaps.outputs.TARGET_DIR }}"
+
+      - 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 }}/' "${{ env.GENERATOR_ENV }}"
+
+          cd "${{ env.GENERATOR_DIR }}"
+
+          docker compose up --build --detach
+          docker compose logs --follow &
+          docker compose wait generator
+
+          link=$(docker compose logs --tail 10 generator | grep 'http' | sed -E 's/^.*(http.*)$/\1/')
+          target=$(cat "${{ env.GENERATOR_ENV }}" | grep -E '^OSU_B=' | cut -d '=' -f2-)
+
+          echo "target=${target}" >> "${GITHUB_OUTPUT}"
+          echo "sheet=${link}" >> "${GITHUB_OUTPUT}"
+
+      - name: Shutdown
+        if: ${{ always() }}
+        run: |
+          cd "${{ env.GENERATOR_DIR }}"
+          docker compose down --volumes
+          rm -rf "${{ env.GENERATOR_DIR }}"
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -88,7 +88,7 @@ jobs:
      # Attempt to upload results even if test fails.
      # https://docs.github.com/en/actions/reference/context-and-expression-syntax-for-github-actions#always
      - name: Upload Test Results
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
        if: ${{ always() }}
        with:
          name: osu-test-results-${{matrix.os.prettyname}}-${{matrix.threadingMode}}
@ -114,7 +114,7 @@ jobs:
          dotnet-version: "8.0.x"

      - name: Install .NET workloads
-        run: dotnet workload install maui-android
+        run: dotnet workload install android

      - name: Compile
        run: dotnet build -c Debug osu.Android.slnf
@ -133,7 +133,7 @@ jobs:
          dotnet-version: "8.0.x"

      - name: Install .NET Workloads
-        run: dotnet workload install maui-ios
+        run: dotnet workload install ios --from-rollback-file https://raw.githubusercontent.com/ppy/osu-framework/refs/heads/master/workloads.json

      - name: Build
        run: dotnet build -c Debug osu.iOS
--- a/.github/workflows/diffcalc.yml
+++ b/.github/workflows/diffcalc.yml
@ -103,6 +103,10 @@ permissions:
 env:
  EXECUTION_ID: execution-${{ github.run_id }}-${{ github.run_number }}-${{ github.run_attempt }}

+defaults:
+  run:
+    shell: bash -euo pipefail {0}
+
 jobs:
  check-permissions:
    name: Check permissions
@ -119,6 +123,20 @@ jobs:
          done
          exit 1

+  run-diffcalc:
+    name: Run spreadsheet generator
+    needs: check-permissions
+    uses: ./.github/workflows/_diffcalc_processor.yml
+    with:
+      # Can't reference env... Why GitHub, WHY?
+      id: execution-${{ github.run_id }}-${{ github.run_number }}-${{ github.run_attempt }}
+      head-sha: https://github.com/${{ github.repository }}/commit/${{ github.event.pull_request.head.sha || github.sha }}
+      pr-url: ${{ github.event.issue.pull_request.html_url || '' }}
+      pr-text: ${{ github.event.comment.body || '' }}
+      dispatch-inputs: ${{ (github.event.type == 'workflow_dispatch' && toJSON(inputs)) || '' }}
+    secrets:
+      DIFFCALC_GOOGLE_CREDENTIALS: ${{ secrets.DIFFCALC_GOOGLE_CREDENTIALS }}
+
  create-comment:
    name: Create PR comment
    needs: check-permissions
@ -134,251 +152,43 @@ jobs:

            *This comment will update on completion*

-  directory:
-    name: Prepare directory
-    needs: check-permissions
-    runs-on: self-hosted
-    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 }}
-    steps:
-      - name: Checkout diffcalc-sheet-generator
-        uses: actions/checkout@v4
-        with:
-          path: ${{ env.EXECUTION_ID }}
-          repository: 'smoogipoo/diffcalc-sheet-generator'
-
-      - name: Set outputs
-        id: set-outputs
-        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
-        run: |
-          # Required by diffcalc-sheet-generator
-          cp '${{ needs.directory.outputs.GENERATOR_DIR }}/.env.sample' "${{ needs.directory.outputs.GENERATOR_ENV }}"
-
-          # Add Google credentials
-          echo '${{ secrets.DIFFCALC_GOOGLE_CREDENTIALS }}' | base64 -d > "${{ needs.directory.outputs.GOOGLE_CREDS_FILE }}"
-
-          # Add repository variables
-          echo "${VARS_JSON}" | jq -c '. | to_entries | .[]' | while read -r line; do
-              opt=$(jq -r '.key' <<< ${line})
-              val=$(jq -r '.value' <<< ${line})
-
-              if [[ "${opt}" =~ ^DIFFCALC_ ]]; then
-                optNoPrefix=$(echo "${opt}" | cut -d '_' -f2-)
-                sed -i "s;^${optNoPrefix}=.*$;${optNoPrefix}=${val};" "${{ needs.directory.outputs.GENERATOR_ENV }}"
-              fi
-          done
-
-      - name: Add pull-request environment
-        if: ${{ github.event_name == 'issue_comment' && github.event.issue.pull_request }}
-        run: |
-          sed -i "s;^OSU_B=.*$;OSU_B=${{ github.event.issue.pull_request.html_url }};" "${{ needs.directory.outputs.GENERATOR_ENV }}"
-
-      - name: Add comment environment
-        if: ${{ github.event_name == 'issue_comment' }}
-        env:
-          COMMENT_BODY: ${{ github.event.comment.body }}
-        run: |
-          # Add comment environment
-          echo "$COMMENT_BODY" | sed -r 's/\r$//' | grep -E '^\w+=' | while read -r line; do
-              opt=$(echo "${line}" | cut -d '=' -f1)
-              sed -i "s;^${opt}=.*$;${line};" "${{ needs.directory.outputs.GENERATOR_ENV }}"
-          done
-
-      - name: Add dispatch environment
-        if: ${{ github.event_name == 'workflow_dispatch' }}
-        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 }}"
-
-          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@720e69c948191660a90aa1cf6a42fc4d2dacdf30 # v2
-        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@720e69c948191660a90aa1cf6a42fc4d2dacdf30 # v2
-        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
+    name: Info
+    needs: run-diffcalc
    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 }}"
+          echo "Target: ${{ needs.run-diffcalc.outputs.target }}"
+          echo "Spreadsheet: ${{ needs.run-diffcalc.outputs.sheet }}"

  update-comment:
    name: Update PR comment
-    needs: [ create-comment, generator ]
+    needs: [ create-comment, run-diffcalc ]
    runs-on: ubuntu-latest
    if: ${{ always() && needs.create-comment.result == 'success' }}
    steps:
      - name: Update comment on success
-        if: ${{ needs.generator.result == 'success' }}
+        if: ${{ needs.run-diffcalc.result == 'success' }}
        uses: thollander/actions-comment-pull-request@fabd468d3a1a0b97feee5f6b9e499eab0dd903f6 # v2.5.0
        with:
          comment_tag: ${{ env.EXECUTION_ID }}
-          mode: upsert
-          create_if_not_exists: false
+          mode: recreate
          message: |
-            Target: ${{ needs.generator.outputs.TARGET }}
-            Spreadsheet: ${{ needs.generator.outputs.SPREADSHEET_LINK }}
+            Target: ${{ needs.run-diffcalc.outputs.target }}
+            Spreadsheet: ${{ needs.run-diffcalc.outputs.sheet }}

      - name: Update comment on failure
-        if: ${{ needs.generator.result == 'failure' }}
+        if: ${{ needs.run-diffcalc.result == 'failure' }}
        uses: thollander/actions-comment-pull-request@fabd468d3a1a0b97feee5f6b9e499eab0dd903f6 # v2.5.0
        with:
          comment_tag: ${{ env.EXECUTION_ID }}
-          mode: upsert
-          create_if_not_exists: false
+          mode: recreate
          message: |
            Difficulty calculation failed: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}

      - name: Update comment on cancellation
-        if: ${{ needs.generator.result == 'cancelled' }}
+        if: ${{ needs.run-diffcalc.result == 'cancelled' }}
        uses: thollander/actions-comment-pull-request@fabd468d3a1a0b97feee5f6b9e499eab0dd903f6 # v2.5.0
        with:
          comment_tag: ${{ env.EXECUTION_ID }}
--- a/.github/workflows/report-nunit.yml
+++ b/.github/workflows/report-nunit.yml
@ -5,33 +5,40 @@
 name: Annotate CI run with test results
 on:
  workflow_run:
-    workflows: ["Continuous Integration"]
+    workflows: [ "Continuous Integration" ]
    types:
      - completed
-permissions: {}
+
+permissions:
+  contents: read
+  actions: read
+  checks: write
+
 jobs:
  annotate:
-    permissions:
-      checks: write # to create checks (dorny/test-reporter)
-
    name: Annotate CI run with test results
    runs-on: ubuntu-latest
    if: ${{ github.event.workflow_run.conclusion != 'cancelled' }}
-    strategy:
-       fail-fast: false
-       matrix:
-          os:
-            - { prettyname: Windows }
-            - { prettyname: macOS }
-            - { prettyname: Linux }
-          threadingMode: ['SingleThread', 'MultiThreaded']
    timeout-minutes: 5
    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ github.event.workflow_run.repository.full_name }}
+          ref: ${{ github.event.workflow_run.head_sha }}
+
+      - name: Download results
+        uses: actions/download-artifact@v4
+        with:
+          pattern: osu-test-results-*
+          merge-multiple: true
+          run-id: ${{ github.event.workflow_run.id }}
+          github-token: ${{ github.token }}
+
      - name: Annotate CI run with test results
        uses: dorny/test-reporter@v1.8.0
        with:
-          artifact: osu-test-results-${{matrix.os.prettyname}}-${{matrix.threadingMode}}
-          name: Test Results (${{matrix.os.prettyname}}, ${{matrix.threadingMode}})
+          name: Results
          path: "*.trx"
          reporter: dotnet-trx
          list-suites: 'failed'
--- a/.vscode/extensions.json
+++ b/.vscode/extensions.json
@ -1,5 +1,6 @@
 {
    "recommendations": [
-        "ms-dotnettools.csharp"
+        "editorconfig.editorconfig",
+        "ms-dotnettools.csdevkit"
    ]
 }
--- a/README.md
+++ b/README.md
@ -53,7 +53,7 @@ Please make sure you have the following prerequisites:

 - A desktop platform with the [.NET 8.0 SDK](https://dotnet.microsoft.com/download) installed.

-When working with the codebase, we recommend using an IDE with intelligent code completion and syntax highlighting, such as the latest version of [Visual Studio](https://visualstudio.microsoft.com/vs/), [JetBrains Rider](https://www.jetbrains.com/rider/), or [Visual Studio Code](https://code.visualstudio.com/) with the [EditorConfig](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) and [C#](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.csharp) plugin installed.
+When working with the codebase, we recommend using an IDE with intelligent code completion and syntax highlighting, such as the latest version of [Visual Studio](https://visualstudio.microsoft.com/vs/), [JetBrains Rider](https://www.jetbrains.com/rider/), or [Visual Studio Code](https://code.visualstudio.com/) with the [EditorConfig](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) and [C# Dev Kit](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.csdevkit) plugin installed.

 ### Downloading the source code

--- a/Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform.Tests/osu.Game.Rulesets.EmptyFreeform.Tests.csproj
+++ b/Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform.Tests/osu.Game.Rulesets.EmptyFreeform.Tests.csproj
@ -9,7 +9,7 @@
      <GenerateProgramFile>false</GenerateProgramFile>
    </PropertyGroup>
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
    <PackageReference Include="NUnit" Version="3.14.0" />
    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
  </ItemGroup>
--- a/Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon.Tests/osu.Game.Rulesets.Pippidon.Tests.csproj
+++ b/Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon.Tests/osu.Game.Rulesets.Pippidon.Tests.csproj
@ -9,7 +9,7 @@
    <GenerateProgramFile>false</GenerateProgramFile>
  </PropertyGroup>
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
    <PackageReference Include="NUnit" Version="3.14.0" />
    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
  </ItemGroup>
--- a/Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling.Tests/osu.Game.Rulesets.EmptyScrolling.Tests.csproj
+++ b/Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling.Tests/osu.Game.Rulesets.EmptyScrolling.Tests.csproj
@ -9,7 +9,7 @@
    <GenerateProgramFile>false</GenerateProgramFile>
  </PropertyGroup>
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
    <PackageReference Include="NUnit" Version="3.14.0" />
    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
  </ItemGroup>
--- a/Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon.Tests/osu.Game.Rulesets.Pippidon.Tests.csproj
+++ b/Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon.Tests/osu.Game.Rulesets.Pippidon.Tests.csproj
@ -9,7 +9,7 @@
    <GenerateProgramFile>false</GenerateProgramFile>
  </PropertyGroup>
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
    <PackageReference Include="NUnit" Version="3.14.0" />
    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
  </ItemGroup>
--- a/osu.Android.props
+++ b/osu.Android.props
@ -10,7 +10,7 @@
    <EmbedAssembliesIntoApk>true</EmbedAssembliesIntoApk>
  </PropertyGroup>
  <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2024.912.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2024.1118.0" />
  </ItemGroup>
  <PropertyGroup>
    <!-- Fody does not handle Android build well, and warns when unchanged.
--- a/osu.Android/GameplayScreenRotationLocker.cs
+++ b/osu.Android/GameplayScreenRotationLocker.cs
@ -5,29 +5,29 @@ using Android.Content.PM;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Game;
+using osu.Game.Screens.Play;

 namespace osu.Android
 {
    public partial class GameplayScreenRotationLocker : Component
    {
-        private Bindable<bool> localUserPlaying = null!;
+        private IBindable<LocalUserPlayingState> localUserPlaying = null!;

        [Resolved]
        private OsuGameActivity gameActivity { get; set; } = null!;

        [BackgroundDependencyLoader]
-        private void load(OsuGame game)
+        private void load(ILocalUserPlayInfo localUserPlayInfo)
        {
-            localUserPlaying = game.LocalUserPlaying.GetBoundCopy();
+            localUserPlaying = localUserPlayInfo.PlayingState.GetBoundCopy();
            localUserPlaying.BindValueChanged(updateLock, true);
        }

-        private void updateLock(ValueChangedEvent<bool> userPlaying)
+        private void updateLock(ValueChangedEvent<LocalUserPlayingState> userPlaying)
        {
            gameActivity.RunOnUiThread(() =>
            {
-                gameActivity.RequestedOrientation = userPlaying.NewValue ? ScreenOrientation.Locked : gameActivity.DefaultOrientation;
+                gameActivity.RequestedOrientation = userPlaying.NewValue == LocalUserPlayingState.Playing ? ScreenOrientation.Locked : gameActivity.DefaultOrientation;
            });
        }
    }
--- a/osu.Desktop/DiscordRichPresence.cs
+++ b/osu.Desktop/DiscordRichPresence.cs
@ -279,10 +279,12 @@ namespace osu.Desktop

            // As above, discord decides that *non-empty* strings shorter than 2 characters cannot possibly be valid input, because... reasons?
            // And yes, that is two *characters*, or *codepoints*, not *bytes* as further down below (as determined by empirical testing).
-            // That seems very questionable, and isn't even documented anywhere. So to *make it* accept such valid input,
-            // just tack on enough of U+200B ZERO WIDTH SPACEs at the end.
-            if (str.Length < 2)
-                return str.PadRight(2, '\u200B');
+            // Also, spaces don't count. Because reasons, clearly.
+            // That all seems very questionable, and isn't even documented anywhere. So to *make it* accept such valid input,
+            // just tack on enough of U+200B ZERO WIDTH SPACEs at the end. After making sure to trim whitespace.
+            string trimmed = str.Trim();
+            if (trimmed.Length < 2)
+                return trimmed.PadRight(2, '\u200B');

            if (Encoding.UTF8.GetByteCount(str) <= 128)
                return str;
--- a/osu.Desktop/NVAPI.cs
+++ b/osu.Desktop/NVAPI.cs
@ -141,12 +141,12 @@ namespace osu.Desktop

                // Make sure that this is a laptop.
                IntPtr[] gpus = new IntPtr[64];
-                if (checkError(EnumPhysicalGPUs(gpus, out int gpuCount)))
+                if (checkError(EnumPhysicalGPUs(gpus, out int gpuCount), nameof(EnumPhysicalGPUs)))
                    return false;

                for (int i = 0; i < gpuCount; i++)
                {
-                    if (checkError(GetSystemType(gpus[i], out var type)))
+                    if (checkError(GetSystemType(gpus[i], out var type), nameof(GetSystemType)))
                        return false;

                    if (type == NvSystemType.LAPTOP)
@ -182,7 +182,7 @@ namespace osu.Desktop

                bool success = setSetting(NvSettingID.OGL_THREAD_CONTROL_ID, (uint)value);

-                Logger.Log(success ? $"Threaded optimizations set to \"{value}\"!" : "Threaded optimizations set failed!");
+                Logger.Log(success ? $"[NVAPI] Threaded optimizations set to \"{value}\"!" : "[NVAPI] Threaded optimizations set failed!");
            }
        }

@ -205,7 +205,7 @@ namespace osu.Desktop

            uint numApps = profile.NumOfApps;

-            if (checkError(EnumApplications(sessionHandle, profileHandle, 0, ref numApps, applications)))
+            if (checkError(EnumApplications(sessionHandle, profileHandle, 0, ref numApps, applications), nameof(EnumApplications)))
                return false;

            for (uint i = 0; i < numApps; i++)
@ -236,10 +236,10 @@ namespace osu.Desktop

            isApplicationSpecific = true;

-            if (checkError(FindApplicationByName(sessionHandle, osu_filename, out profileHandle, ref application)))
+            if (checkError(FindApplicationByName(sessionHandle, osu_filename, out profileHandle, ref application), nameof(FindApplicationByName)))
            {
                isApplicationSpecific = false;
-                if (checkError(GetCurrentGlobalProfile(sessionHandle, out profileHandle)))
+                if (checkError(GetCurrentGlobalProfile(sessionHandle, out profileHandle), nameof(GetCurrentGlobalProfile)))
                    return false;
            }

@ -258,12 +258,10 @@ namespace osu.Desktop
                Version = NvProfile.Stride,
                IsPredefined = 0,
                ProfileName = PROFILE_NAME,
-                GPUSupport = new uint[32]
+                GpuSupport = NvDrsGpuSupport.Geforce
            };

-            newProfile.GPUSupport[0] = 1;
-
-            if (checkError(CreateProfile(sessionHandle, ref newProfile, out profileHandle)))
+            if (checkError(CreateProfile(sessionHandle, ref newProfile, out profileHandle), nameof(CreateProfile)))
                return false;

            return true;
@ -284,7 +282,7 @@ namespace osu.Desktop
                SettingID = settingId
            };

-            if (checkError(GetSetting(sessionHandle, profileHandle, settingId, ref setting)))
+            if (checkError(GetSetting(sessionHandle, profileHandle, settingId, ref setting), nameof(GetSetting)))
                return false;

            return true;
@ -313,7 +311,7 @@ namespace osu.Desktop
            };

            // Set the thread state
-            if (checkError(SetSetting(sessionHandle, profileHandle, ref newSetting)))
+            if (checkError(SetSetting(sessionHandle, profileHandle, ref newSetting), nameof(SetSetting)))
                return false;

            // Get the profile (needed to check app count)
@ -321,7 +319,7 @@ namespace osu.Desktop
            {
                Version = NvProfile.Stride
            };
-            if (checkError(GetProfileInfo(sessionHandle, profileHandle, ref profile)))
+            if (checkError(GetProfileInfo(sessionHandle, profileHandle, ref profile), nameof(GetProfileInfo)))
                return false;

            if (!containsApplication(profileHandle, profile, out application))
@ -332,12 +330,12 @@ namespace osu.Desktop
                application.AppName = osu_filename;
                application.UserFriendlyName = APPLICATION_NAME;

-                if (checkError(CreateApplication(sessionHandle, profileHandle, ref application)))
+                if (checkError(CreateApplication(sessionHandle, profileHandle, ref application), nameof(CreateApplication)))
                    return false;
            }

            // Save!
-            return !checkError(SaveSettings(sessionHandle));
+            return !checkError(SaveSettings(sessionHandle), nameof(SaveSettings));
        }

        /// <summary>
@ -346,20 +344,25 @@ namespace osu.Desktop
        /// <returns>If the operation succeeded.</returns>
        private static bool createSession()
        {
-            if (checkError(CreateSession(out sessionHandle)))
+            if (checkError(CreateSession(out sessionHandle), nameof(CreateSession)))
                return false;

            // Load settings into session
-            if (checkError(LoadSettings(sessionHandle)))
+            if (checkError(LoadSettings(sessionHandle), nameof(LoadSettings)))
                return false;

            return true;
        }

-        private static bool checkError(NvStatus status)
+        private static bool checkError(NvStatus status, string caller)
        {
            Status = status;
-            return status != NvStatus.OK;
+
+            bool hasError = status != NvStatus.OK;
+            if (hasError)
+                Logger.Log($"[NVAPI] {caller} call failed with status code {status}");
+
+            return hasError;
        }

        static NVAPI()
@ -458,9 +461,7 @@ namespace osu.Desktop
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NVAPI.UNICODE_STRING_MAX)]
        public string ProfileName;

-        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
-        public uint[] GPUSupport;
-
+        public NvDrsGpuSupport GpuSupport;
        public uint IsPredefined;
        public uint NumOfApps;
        public uint NumOfSettings;
@ -606,6 +607,7 @@ namespace osu.Desktop
        SYNC_NOT_ACTIVE = -194, // The requested action cannot be performed without Sync being enabled.
        SYNC_MASTER_NOT_FOUND = -195, // The requested action cannot be performed without Sync Master being enabled.
        INVALID_SYNC_TOPOLOGY = -196, // Invalid displays passed in the NV_GSYNC_DISPLAY pointer.
+
        ECID_SIGN_ALGO_UNSUPPORTED = -197, // The specified signing algorithm is not supported. Either an incorrect value was entered or the current installed driver/hardware does not support the input value.
        ECID_KEY_VERIFICATION_FAILED = -198, // The encrypted public key verification has failed.
        FIRMWARE_OUT_OF_DATE = -199, // The device's firmware is out of date.
@ -744,4 +746,12 @@ namespace osu.Desktop
        OGL_THREAD_CONTROL_NUM_VALUES = 2,
        OGL_THREAD_CONTROL_DEFAULT = 0
    }
+
+    [Flags]
+    internal enum NvDrsGpuSupport : uint
+    {
+        Geforce = 1 << 0,
+        Quadro = 1 << 1,
+        Nvs = 1 << 2
+    }
 }
--- a/osu.Desktop/Updater/VelopackUpdateManager.cs
+++ b/osu.Desktop/Updater/VelopackUpdateManager.cs
@ -25,6 +25,8 @@ namespace osu.Desktop.Updater
        [Resolved]
        private ILocalUserPlayInfo? localUserInfo { get; set; }

+        private bool isInGameplay => localUserInfo?.PlayingState.Value != LocalUserPlayingState.NotPlaying;
+
        private UpdateInfo? pendingUpdate;

        public VelopackUpdateManager()
@ -43,7 +45,7 @@ namespace osu.Desktop.Updater

        protected override async Task<bool> PerformUpdateCheck() => await checkForUpdateAsync().ConfigureAwait(false);

-        private async Task<bool> checkForUpdateAsync(UpdateProgressNotification? notification = null)
+        private async Task<bool> checkForUpdateAsync()
        {
            // whether to check again in 30 minutes. generally only if there's an error or no update was found (yet).
            bool scheduleRecheck = false;
@ -51,10 +53,10 @@ namespace osu.Desktop.Updater
            try
            {
                // Avoid any kind of update checking while gameplay is running.
-                if (localUserInfo?.IsPlaying.Value == true)
+                if (isInGameplay)
                {
                    scheduleRecheck = true;
-                    return false;
+                    return true;
                }

                // TODO: we should probably be checking if there's a more recent update, rather than shortcutting here.
@ -66,7 +68,7 @@ namespace osu.Desktop.Updater
                    {
                        Activated = () =>
                        {
-                            restartToApplyUpdate();
+                            Task.Run(restartToApplyUpdate);
                            return true;
                        }
                    });
@ -84,23 +86,22 @@ namespace osu.Desktop.Updater
                }

                // An update is found, let's notify the user and start downloading it.
-                if (notification == null)
+                UpdateProgressNotification notification = new UpdateProgressNotification
                {
-                    notification = new UpdateProgressNotification
+                    CompletionClickAction = () =>
                    {
-                        CompletionClickAction = restartToApplyUpdate,
-                    };
-
-                    Schedule(() => notificationOverlay.Post(notification));
-                }
+                        Task.Run(restartToApplyUpdate);
+                        return true;
+                    },
+                };

+                runOutsideOfGameplay(() => notificationOverlay.Post(notification));
                notification.StartDownload();

                try
                {
                    await updateManager.DownloadUpdatesAsync(pendingUpdate, p => notification.Progress = p / 100f).ConfigureAwait(false);
-
-                    notification.State = ProgressNotificationState.Completed;
+                    runOutsideOfGameplay(() => notification.State = ProgressNotificationState.Completed);
                }
                catch (Exception e)
                {
@ -127,13 +128,21 @@ namespace osu.Desktop.Updater
            return true;
        }

-        private bool restartToApplyUpdate()
+        private void runOutsideOfGameplay(Action action)
        {
-            // TODO: Migrate this to async flow whenever available (see https://github.com/ppy/osu/pull/28743#discussion_r1740505665).
-            // Currently there's an internal Thread.Sleep(300) which will cause a stutter when the user clicks to restart.
-            updateManager.WaitExitThenApplyUpdates(pendingUpdate?.TargetFullRelease);
+            if (isInGameplay)
+            {
+                Scheduler.AddDelayed(() => runOutsideOfGameplay(action), 1000);
+                return;
+            }
+
+            action();
+        }
+
+        private async Task restartToApplyUpdate()
+        {
+            await updateManager.WaitExitThenApplyUpdatesAsync(pendingUpdate?.TargetFullRelease).ConfigureAwait(false);
            Schedule(() => game.AttemptExit());
-            return true;
        }
    }
 }
--- a/osu.Desktop/Windows/GameplayWinKeyBlocker.cs
+++ b/osu.Desktop/Windows/GameplayWinKeyBlocker.cs
@ -13,7 +13,7 @@ namespace osu.Desktop.Windows
    public partial class GameplayWinKeyBlocker : Component
    {
        private Bindable<bool> disableWinKey = null!;
-        private IBindable<bool> localUserPlaying = null!;
+        private IBindable<LocalUserPlayingState> localUserPlaying = null!;
        private IBindable<bool> isActive = null!;

        [Resolved]
@ -22,7 +22,7 @@ namespace osu.Desktop.Windows
        [BackgroundDependencyLoader]
        private void load(ILocalUserPlayInfo localUserInfo, OsuConfigManager config)
        {
-            localUserPlaying = localUserInfo.IsPlaying.GetBoundCopy();
+            localUserPlaying = localUserInfo.PlayingState.GetBoundCopy();
            localUserPlaying.BindValueChanged(_ => updateBlocking());

            isActive = host.IsActive.GetBoundCopy();
@ -34,7 +34,7 @@ namespace osu.Desktop.Windows

        private void updateBlocking()
        {
-            bool shouldDisable = isActive.Value && disableWinKey.Value && localUserPlaying.Value;
+            bool shouldDisable = isActive.Value && disableWinKey.Value && localUserPlaying.Value == LocalUserPlayingState.Playing;

            if (shouldDisable)
                host.InputThread.Scheduler.Add(WindowsKey.Disable);
--- a/osu.Desktop/osu.Desktop.csproj
+++ b/osu.Desktop/osu.Desktop.csproj
@ -24,9 +24,9 @@
    <ProjectReference Include="..\osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj" />
  </ItemGroup>
  <ItemGroup Label="Package References">
-    <PackageReference Include="System.IO.Packaging" Version="8.0.0" />
+    <PackageReference Include="System.IO.Packaging" Version="8.0.1" />
    <PackageReference Include="DiscordRichPresence" Version="1.2.1.24" />
-    <PackageReference Include="Velopack" Version="0.0.598-g933b2ab" />
+    <PackageReference Include="Velopack" Version="0.0.915" />
  </ItemGroup>
  <ItemGroup Label="Resources">
    <EmbeddedResource Include="lazer.ico" />
--- a/osu.Game.Benchmarks/BenchmarkGeometryUtils.cs
+++ b/osu.Game.Benchmarks/BenchmarkGeometryUtils.cs
@ -0,0 +1,29 @@
+// 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 BenchmarkDotNet.Attributes;
+using osu.Framework.Utils;
+using osu.Game.Utils;
+using osuTK;
+
+namespace osu.Game.Benchmarks
+{
+    public class BenchmarkGeometryUtils : BenchmarkTest
+    {
+        [Params(100, 1000, 2000, 4000, 8000, 10000)]
+        public int N;
+
+        private Vector2[] points = null!;
+
+        public override void SetUp()
+        {
+            points = new Vector2[N];
+
+            for (int i = 0; i < points.Length; ++i)
+                points[i] = new Vector2(RNG.Next(512), RNG.Next(384));
+        }
+
+        [Benchmark]
+        public void MinimumEnclosingCircle() => GeometryUtils.MinimumEnclosingCircle(points);
+    }
+}
--- a/osu.Game.Benchmarks/osu.Game.Benchmarks.csproj
+++ b/osu.Game.Benchmarks/osu.Game.Benchmarks.csproj
@ -7,7 +7,7 @@
  </PropertyGroup>

  <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.13.12" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.14.0" />
    <PackageReference Include="nunit" Version="3.14.0" />
    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
  </ItemGroup>
--- a/osu.Game.Rulesets.Catch.Tests/Editor/CatchPlacementBlueprintTestScene.cs
+++ b/osu.Game.Rulesets.Catch.Tests/Editor/CatchPlacementBlueprintTestScene.cs
@ -71,7 +71,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
            contentContainer.Playfield.HitObjectContainer.Add(hitObject);
        }

-        protected override SnapResult SnapForBlueprint(PlacementBlueprint blueprint)
+        protected override SnapResult SnapForBlueprint(HitObjectPlacementBlueprint blueprint)
        {
            var result = base.SnapForBlueprint(blueprint);
            result.Time = Math.Round(HitObjectContainer.TimeAtScreenSpacePosition(result.ScreenSpacePosition) / TIME_SNAP) * TIME_SNAP;
--- a/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneBananaShowerPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneBananaShowerPlacementBlueprint.cs
@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
    {
        protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableBananaShower((BananaShower)hitObject);

-        protected override PlacementBlueprint CreateBlueprint() => new BananaShowerPlacementBlueprint();
+        protected override HitObjectPlacementBlueprint CreateBlueprint() => new BananaShowerPlacementBlueprint();

        protected override void AddHitObject(DrawableHitObject hitObject)
        {
--- a/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneFruitPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneFruitPlacementBlueprint.cs
@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
    {
        protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableFruit((Fruit)hitObject);

-        protected override PlacementBlueprint CreateBlueprint() => new FruitPlacementBlueprint();
+        protected override HitObjectPlacementBlueprint CreateBlueprint() => new FruitPlacementBlueprint();

        [Test]
        public void TestFruitPlacementPosition()
--- a/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneJuiceStreamPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneJuiceStreamPlacementBlueprint.cs
@ -114,7 +114,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor

        protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableJuiceStream((JuiceStream)hitObject);

-        protected override PlacementBlueprint CreateBlueprint() => new JuiceStreamPlacementBlueprint();
+        protected override HitObjectPlacementBlueprint CreateBlueprint() => new JuiceStreamPlacementBlueprint();

        private void addMoveAndClickSteps(double time, float position, bool end = false)
        {
--- a/osu.Game.Rulesets.Catch.Tests/Mods/TestSceneCatchModNoScope.cs
+++ b/osu.Game.Rulesets.Catch.Tests/Mods/TestSceneCatchModNoScope.cs
@ -29,7 +29,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Mods
                },
                Autoplay = true,
                PassCondition = () => Player.ScoreProcessor.Combo.Value == 2,
-                Beatmap = new Beatmap
+                CreateBeatmap = () => new Beatmap
                {
                    HitObjects = new List<HitObject>
                    {
@ -59,7 +59,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Mods
                },
                Autoplay = true,
                PassCondition = () => true,
-                Beatmap = new Beatmap
+                CreateBeatmap = () => new Beatmap
                {
                    HitObjects = new List<HitObject>
                    {
@ -99,7 +99,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Mods
                },
                Autoplay = true,
                PassCondition = () => true,
-                Beatmap = new Beatmap
+                CreateBeatmap = () => new Beatmap
                {
                    HitObjects = new List<HitObject>
                    {
--- a/osu.Game.Rulesets.Catch.Tests/Mods/TestSceneCatchModRelax.cs
+++ b/osu.Game.Rulesets.Catch.Tests/Mods/TestSceneCatchModRelax.cs
@ -28,7 +28,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Mods
            Mod = new CatchModRelax(),
            Autoplay = false,
            PassCondition = passCondition,
-            Beatmap = new Beatmap
+            CreateBeatmap = () => new Beatmap
            {
                HitObjects = new List<HitObject>
                {
--- a/osu.Game.Rulesets.Catch.Tests/TestSceneCatchModHidden.cs
+++ b/osu.Game.Rulesets.Catch.Tests/TestSceneCatchModHidden.cs
@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Catch.Tests
        {
            CreateModTest(new ModTestData
            {
-                Beatmap = new Beatmap
+                CreateBeatmap = () => new Beatmap
                {
                    HitObjects = new List<HitObject>
                    {
--- a/osu.Game.Rulesets.Catch.Tests/osu.Game.Rulesets.Catch.Tests.csproj
+++ b/osu.Game.Rulesets.Catch.Tests/osu.Game.Rulesets.Catch.Tests.csproj
@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
  <Import Project="..\osu.TestProject.props" />
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
    <PackageReference Include="NUnit" Version="3.14.0" />
    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
  </ItemGroup>
--- a/osu.Game.Rulesets.Catch/CatchRuleset.cs
+++ b/osu.Game.Rulesets.Catch/CatchRuleset.cs
@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Localisation;
@ -31,6 +32,7 @@ using osu.Game.Scoring;
 using osu.Game.Screens.Edit.Setup;
 using osu.Game.Screens.Ranking.Statistics;
 using osu.Game.Skinning;
+using osuTK;

 namespace osu.Game.Rulesets.Catch
 {
@ -223,10 +225,28 @@ namespace osu.Game.Rulesets.Catch

        public override HitObjectComposer CreateHitObjectComposer() => new CatchHitObjectComposer(this);

-        public override IEnumerable<SetupSection> CreateEditorSetupSections() =>
+        public override IEnumerable<Drawable> CreateEditorSetupSections() =>
        [
+            new MetadataSection(),
            new DifficultySection(),
-            new ColoursSection(),
+            new FillFlowContainer
+            {
+                AutoSizeAxes = Axes.Y,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(SetupScreen.SPACING),
+                Children = new Drawable[]
+                {
+                    new ResourcesSection
+                    {
+                        RelativeSizeAxes = Axes.X,
+                    },
+                    new ColoursSection
+                    {
+                        RelativeSizeAxes = Axes.X,
+                    }
+                }
+            },
+            new DesignSection(),
        ];

        public override IBeatmapVerifier CreateBeatmapVerifier() => new CatchBeatmapVerifier();
--- a/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs
@ -3,7 +3,6 @@

 using System;
 using System.Collections.Generic;
-using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Difficulty.Preprocessing;
@ -44,7 +43,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty
                StarRating = Math.Sqrt(skills[0].DifficultyValue()) * difficulty_multiplier,
                Mods = mods,
                ApproachRate = preempt > 1200.0 ? -(preempt - 1800.0) / 120.0 : -(preempt - 1200.0) / 150.0 + 5.0,
-                MaxCombo = beatmap.HitObjects.Count(h => h is Fruit) + beatmap.HitObjects.OfType<JuiceStream>().SelectMany(j => j.NestedHitObjects).Count(h => !(h is TinyDroplet)),
+                MaxCombo = beatmap.GetMaxCombo(),
            };

            return attributes;
--- a/osu.Game.Rulesets.Catch/Edit/BananaShowerCompositionTool.cs
+++ b/osu.Game.Rulesets.Catch/Edit/BananaShowerCompositionTool.cs
@ -10,7 +10,7 @@ using osu.Game.Rulesets.Edit.Tools;

 namespace osu.Game.Rulesets.Catch.Edit
 {
-    public class BananaShowerCompositionTool : HitObjectCompositionTool
+    public class BananaShowerCompositionTool : CompositionTool
    {
        public BananaShowerCompositionTool()
            : base(nameof(BananaShower))
@ -19,6 +19,6 @@ namespace osu.Game.Rulesets.Catch.Edit

        public override Drawable CreateIcon() => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Spinners);

-        public override PlacementBlueprint CreatePlacementBlueprint() => new BananaShowerPlacementBlueprint();
+        public override HitObjectPlacementBlueprint CreatePlacementBlueprint() => new BananaShowerPlacementBlueprint();
    }
 }
--- a/osu.Game.Rulesets.Catch/Edit/Blueprints/CatchPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Catch/Edit/Blueprints/CatchPlacementBlueprint.cs
@ -9,7 +9,7 @@ using osu.Game.Rulesets.UI.Scrolling;

 namespace osu.Game.Rulesets.Catch.Edit.Blueprints
 {
-    public partial class CatchPlacementBlueprint<THitObject> : PlacementBlueprint
+    public partial class CatchPlacementBlueprint<THitObject> : HitObjectPlacementBlueprint
        where THitObject : CatchHitObject, new()
    {
        protected new THitObject HitObject => (THitObject)base.HitObject;
--- a/osu.Game.Rulesets.Catch/Edit/Blueprints/JuiceStreamSelectionBlueprint.cs
+++ b/osu.Game.Rulesets.Catch/Edit/Blueprints/JuiceStreamSelectionBlueprint.cs
@ -8,6 +8,7 @@ using osu.Framework.Caching;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Catch.Edit.Blueprints.Components;
@ -172,7 +173,10 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
            yield return new OsuMenuItem("Add vertex", MenuItemType.Standard, () =>
            {
                editablePath.AddVertex(rightMouseDownPosition);
-            });
+            })
+            {
+                Hotkey = new Hotkey(new KeyCombination(InputKey.Control, InputKey.MouseLeft))
+            };
        }

        protected override void Dispose(bool isDisposing)
--- a/osu.Game.Rulesets.Catch/Edit/CatchDistanceSnapProvider.cs
+++ b/osu.Game.Rulesets.Catch/Edit/CatchDistanceSnapProvider.cs
@ -10,7 +10,7 @@ namespace osu.Game.Rulesets.Catch.Edit
 {
    public partial class CatchDistanceSnapProvider : ComposerDistanceSnapProvider
    {
-        protected override double ReadCurrentDistanceSnap(HitObject before, HitObject after)
+        public 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.
--- a/osu.Game.Rulesets.Catch/Edit/CatchEditorPlayfield.cs
+++ b/osu.Game.Rulesets.Catch/Edit/CatchEditorPlayfield.cs
@ -8,7 +8,6 @@ namespace osu.Game.Rulesets.Catch.Edit
 {
    public partial class CatchEditorPlayfield : CatchPlayfield
    {
-        // TODO fixme: the size of the catcher is not changed when circle size is changed in setup screen.
        public CatchEditorPlayfield(IBeatmapDifficultyInfo difficulty)
            : base(difficulty)
        {
--- a/osu.Game.Rulesets.Catch/Edit/CatchHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Catch/Edit/CatchHitObjectComposer.cs
@ -70,6 +70,8 @@ namespace osu.Game.Rulesets.Catch.Edit
            }));
        }

+        protected override Drawable CreateHitObjectInspector() => new CatchHitObjectInspector(DistanceSnapProvider);
+
        protected override IEnumerable<TernaryButton> CreateTernaryButtons()
            => base.CreateTernaryButtons()
                   .Concat(DistanceSnapProvider.CreateTernaryButtons());
@ -84,7 +86,7 @@ namespace osu.Game.Rulesets.Catch.Edit

        protected override BeatSnapGrid CreateBeatSnapGrid() => new CatchBeatSnapGrid();

-        protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
+        protected override IReadOnlyList<CompositionTool> CompositionTools => new CompositionTool[]
        {
            new FruitCompositionTool(),
            new JuiceStreamCompositionTool(),
@ -114,6 +116,26 @@ namespace osu.Game.Rulesets.Catch.Edit
        {
        }

+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            if (e.Repeat)
+                return false;
+
+            handleToggleViaKey(e);
+            return base.OnKeyDown(e);
+        }
+
+        protected override void OnKeyUp(KeyUpEvent e)
+        {
+            handleToggleViaKey(e);
+            base.OnKeyUp(e);
+        }
+
+        private void handleToggleViaKey(KeyboardEvent key)
+        {
+            DistanceSnapProvider.HandleToggleViaKey(key);
+        }
+
        public override SnapResult FindSnappedPositionAndTime(Vector2 screenSpacePosition, SnapType snapType = SnapType.All)
        {
            var result = base.FindSnappedPositionAndTime(screenSpacePosition, snapType);
--- a/osu.Game.Rulesets.Catch/Edit/CatchHitObjectInspector.cs
+++ b/osu.Game.Rulesets.Catch/Edit/CatchHitObjectInspector.cs
@ -0,0 +1,41 @@
+// 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.Linq;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Screens.Edit.Compose.Components;
+
+namespace osu.Game.Rulesets.Catch.Edit
+{
+    public partial class CatchHitObjectInspector(CatchDistanceSnapProvider snapProvider) : HitObjectInspector
+    {
+        protected override void AddInspectorValues(HitObject[] objects)
+        {
+            base.AddInspectorValues(objects);
+
+            if (objects.Length > 0)
+            {
+                HitObject firstSelectedHitObject = objects.MinBy(ho => ho.StartTime)!;
+                HitObject lastSelectedHitObject = objects.MaxBy(ho => ho.GetEndTime())!;
+
+                HitObject? precedingObject = EditorBeatmap.HitObjects.LastOrDefault(ho => ho.GetEndTime() < firstSelectedHitObject.StartTime);
+                HitObject? nextObject = EditorBeatmap.HitObjects.FirstOrDefault(ho => ho.StartTime > lastSelectedHitObject.GetEndTime());
+
+                if (precedingObject != null && precedingObject is not BananaShower)
+                {
+                    double previousSnap = snapProvider.ReadCurrentDistanceSnap(precedingObject, firstSelectedHitObject);
+                    AddHeader("To previous");
+                    AddValue($"{previousSnap:#,0.##}x");
+                }
+
+                if (nextObject != null && nextObject is not BananaShower)
+                {
+                    double nextSnap = snapProvider.ReadCurrentDistanceSnap(lastSelectedHitObject, nextObject);
+                    AddHeader("To next");
+                    AddValue($"{nextSnap:#,0.##}x");
+                }
+            }
+        }
+    }
+}
--- a/osu.Game.Rulesets.Catch/Edit/DrawableCatchEditorRuleset.cs
+++ b/osu.Game.Rulesets.Catch/Edit/DrawableCatchEditorRuleset.cs
@ -2,16 +2,22 @@
 // See the LICENCE file in the repository root for full licence text.

 using System.Collections.Generic;
+using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Edit;

 namespace osu.Game.Rulesets.Catch.Edit
 {
    public partial class DrawableCatchEditorRuleset : DrawableCatchRuleset
    {
+        [Resolved]
+        private EditorBeatmap editorBeatmap { get; set; } = null!;
+
        public readonly BindableDouble TimeRangeMultiplier = new BindableDouble(1);

        public DrawableCatchEditorRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod>? mods = null)
@ -28,6 +34,30 @@ namespace osu.Game.Rulesets.Catch.Edit
            TimeRange.Value = gamePlayTimeRange * TimeRangeMultiplier.Value * playfieldStretch;
        }

+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            editorBeatmap.BeatmapReprocessed += onBeatmapReprocessed;
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (editorBeatmap.IsNotNull())
+                editorBeatmap.BeatmapReprocessed -= onBeatmapReprocessed;
+        }
+
+        private void onBeatmapReprocessed()
+        {
+            if (Playfield is CatchEditorPlayfield catchPlayfield)
+            {
+                catchPlayfield.Catcher.ApplyDifficulty(editorBeatmap.Difficulty);
+                catchPlayfield.CatcherArea.CatcherTrails.UpdateCatcherTrailsScale(catchPlayfield.Catcher.BodyScale);
+            }
+        }
+
        protected override Playfield CreatePlayfield() => new CatchEditorPlayfield(Beatmap.Difficulty);

        public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new CatchEditorPlayfieldAdjustmentContainer();
--- a/osu.Game.Rulesets.Catch/Edit/FruitCompositionTool.cs
+++ b/osu.Game.Rulesets.Catch/Edit/FruitCompositionTool.cs
@ -10,7 +10,7 @@ using osu.Game.Rulesets.Edit.Tools;

 namespace osu.Game.Rulesets.Catch.Edit
 {
-    public class FruitCompositionTool : HitObjectCompositionTool
+    public class FruitCompositionTool : CompositionTool
    {
        public FruitCompositionTool()
            : base(nameof(Fruit))
@ -19,6 +19,6 @@ namespace osu.Game.Rulesets.Catch.Edit

        public override Drawable CreateIcon() => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles);

-        public override PlacementBlueprint CreatePlacementBlueprint() => new FruitPlacementBlueprint();
+        public override HitObjectPlacementBlueprint CreatePlacementBlueprint() => new FruitPlacementBlueprint();
    }
 }
--- a/osu.Game.Rulesets.Catch/Edit/JuiceStreamCompositionTool.cs
+++ b/osu.Game.Rulesets.Catch/Edit/JuiceStreamCompositionTool.cs
@ -10,7 +10,7 @@ using osu.Game.Rulesets.Edit.Tools;

 namespace osu.Game.Rulesets.Catch.Edit
 {
-    public class JuiceStreamCompositionTool : HitObjectCompositionTool
+    public class JuiceStreamCompositionTool : CompositionTool
    {
        public JuiceStreamCompositionTool()
            : base(nameof(JuiceStream))
@ -19,6 +19,6 @@ namespace osu.Game.Rulesets.Catch.Edit

        public override Drawable CreateIcon() => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders);

-        public override PlacementBlueprint CreatePlacementBlueprint() => new JuiceStreamPlacementBlueprint();
+        public override HitObjectPlacementBlueprint CreatePlacementBlueprint() => new JuiceStreamPlacementBlueprint();
    }
 }
--- a/osu.Game.Rulesets.Catch/Objects/Banana.cs
+++ b/osu.Game.Rulesets.Catch/Objects/Banana.cs
@ -58,7 +58,7 @@ namespace osu.Game.Rulesets.Catch.Objects
            {
            }

-            public sealed override HitSampleInfo With(Optional<string> newName = default, Optional<string> newBank = default, Optional<string?> newSuffix = default, Optional<int> newVolume = default)
+            public sealed override HitSampleInfo With(Optional<string> newName = default, Optional<string> newBank = default, Optional<string?> newSuffix = default, Optional<int> newVolume = default, Optional<bool> newEditorAutoBank = default)
                => new BananaHitSampleInfo(newVolume.GetOr(Volume));

            public bool Equals(BananaHitSampleInfo? other)
--- a/osu.Game.Rulesets.Catch/Objects/Drawables/DrawableBanana.cs
+++ b/osu.Game.Rulesets.Catch/Objects/Drawables/DrawableBanana.cs
@ -1,10 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using System;
 using osu.Framework.Allocation;
-using osu.Framework.Graphics;
+using osu.Framework.Utils;
 using osu.Game.Rulesets.Catch.Skinning.Default;
 using osu.Game.Skinning;
+using osuTK;

 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
@ -36,23 +38,43 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
            StartTimeBindable.BindValueChanged(_ => UpdateComboColour());
        }

+        private float startScale;
+        private float endScale;
+
+        private float startAngle;
+        private float endAngle;
+
        protected override void UpdateInitialTransforms()
        {
            base.UpdateInitialTransforms();

+            // Important to have this in UpdateInitialTransforms() to it is re-triggered by RefreshStateTransforms().
            const float end_scale = 0.6f;
            const float random_scale_range = 1.6f;

-            ScalingContainer.ScaleTo(HitObject.Scale * (end_scale + random_scale_range * RandomSingle(3)))
-                            .Then().ScaleTo(HitObject.Scale * end_scale, HitObject.TimePreempt);
+            startScale = end_scale + random_scale_range * RandomSingle(3);
+            endScale = end_scale;

-            ScalingContainer.RotateTo(getRandomAngle(1))
-                            .Then()
-                            .RotateTo(getRandomAngle(2), HitObject.TimePreempt);
+            startAngle = getRandomAngle(1);
+            endAngle = getRandomAngle(2);

            float getRandomAngle(int series) => 180 * (RandomSingle(series) * 2 - 1);
        }

+        protected override void Update()
+        {
+            base.Update();
+
+            double preemptProgress = (Time.Current - (HitObject.StartTime - InitialLifetimeOffset)) / HitObject.TimePreempt;
+
+            // Clamp scale and rotation at the point of bananas being caught, else let them freely extrapolate.
+            if (Result.IsHit)
+                preemptProgress = Math.Min(1, preemptProgress);
+
+            ScalingContainer.Scale = new Vector2(HitObject.Scale * (float)Interpolation.Lerp(startScale, endScale, preemptProgress));
+            ScalingContainer.Rotation = (float)Interpolation.Lerp(startAngle, endAngle, preemptProgress);
+        }
+
        public override void PlaySamples()
        {
            base.PlaySamples();
--- a/osu.Game.Rulesets.Catch/Objects/Drawables/DrawableDroplet.cs
+++ b/osu.Game.Rulesets.Catch/Objects/Drawables/DrawableDroplet.cs
@ -2,7 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.

 using osu.Framework.Allocation;
-using osu.Framework.Graphics;
+using osu.Framework.Utils;
 using osu.Game.Rulesets.Catch.Skinning.Default;
 using osu.Game.Skinning;

@ -28,15 +28,24 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
                _ => new DropletPiece());
        }

+        private float startRotation;
+
        protected override void UpdateInitialTransforms()
        {
            base.UpdateInitialTransforms();

-            // roughly matches osu-stable
-            float startRotation = RandomSingle(1) * 20;
-            double duration = HitObject.TimePreempt + 2000;
+            // Important to have this in UpdateInitialTransforms() to it is re-triggered by RefreshStateTransforms().
+            startRotation = RandomSingle(1) * 20;
+        }

-            ScalingContainer.RotateTo(startRotation).RotateTo(startRotation + 720, duration);
+        protected override void Update()
+        {
+            base.Update();
+
+            // No clamping for droplets. They should be considered indefinitely spinning regardless of time.
+            // They also never end up on the plate, so they shouldn't stop spinning when caught.
+            double preemptProgress = (Time.Current - (HitObject.StartTime - InitialLifetimeOffset)) / (HitObject.TimePreempt + 2000);
+            ScalingContainer.Rotation = (float)Interpolation.Lerp(startRotation, startRotation + 720, preemptProgress);
        }
    }
 }
--- a/osu.Game.Rulesets.Catch/Objects/Drawables/DrawableFruit.cs
+++ b/osu.Game.Rulesets.Catch/Objects/Drawables/DrawableFruit.cs
@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.

 using osu.Framework.Allocation;
-using osu.Framework.Graphics;
 using osu.Game.Rulesets.Catch.Skinning.Default;
 using osu.Game.Skinning;

@ -32,7 +31,8 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
        {
            base.UpdateInitialTransforms();

-            ScalingContainer.RotateTo((RandomSingle(1) - 0.5f) * 40);
+            // Important to have this in UpdateInitialTransforms() to it is re-triggered by RefreshStateTransforms().
+            ScalingContainer.Rotation = (RandomSingle(1) - 0.5f) * 40;
        }
    }
 }
--- a/osu.Game.Rulesets.Catch/UI/Catcher.cs
+++ b/osu.Game.Rulesets.Catch/UI/Catcher.cs
@ -116,7 +116,7 @@ namespace osu.Game.Rulesets.Catch.UI
        /// <summary>
        /// Width of the area that can be used to attempt catches during gameplay.
        /// </summary>
-        public readonly float CatchWidth;
+        public float CatchWidth { get; private set; }

        private readonly SkinnableCatcher body;

@ -142,10 +142,7 @@ namespace osu.Game.Rulesets.Catch.UI

            Size = new Vector2(BASE_SIZE);

-            if (difficulty != null)
-                Scale = calculateScale(difficulty);
-
-            CatchWidth = CalculateCatchWidth(Scale);
+            ApplyDifficulty(difficulty);

            InternalChildren = new Drawable[]
            {
@ -312,6 +309,17 @@ namespace osu.Game.Rulesets.Catch.UI
            }
        }

+        /// <summary>
+        /// Set the scale and catch width.
+        /// </summary>
+        public void ApplyDifficulty(IBeatmapDifficultyInfo? difficulty)
+        {
+            if (difficulty != null)
+                Scale = calculateScale(difficulty);
+
+            CatchWidth = CalculateCatchWidth(Scale);
+        }
+
        /// <summary>
        /// Drop any fruit off the plate.
        /// </summary>
--- a/osu.Game.Rulesets.Catch/UI/CatcherArea.cs
+++ b/osu.Game.Rulesets.Catch/UI/CatcherArea.cs
@ -32,7 +32,7 @@ namespace osu.Game.Rulesets.Catch.UI

        private readonly CatchComboDisplay comboDisplay;

-        private readonly CatcherTrailDisplay catcherTrails;
+        public readonly CatcherTrailDisplay CatcherTrails;

        private Catcher catcher = null!;

@ -55,7 +55,7 @@ namespace osu.Game.Rulesets.Catch.UI
            Children = new Drawable[]
            {
                catcherContainer = new Container<Catcher> { RelativeSizeAxes = Axes.Both },
-                catcherTrails = new CatcherTrailDisplay(),
+                CatcherTrails = new CatcherTrailDisplay(),
                comboDisplay = new CatchComboDisplay
                {
                    RelativeSizeAxes = Axes.None,
@ -112,7 +112,7 @@ namespace osu.Game.Rulesets.Catch.UI
            {
                const double trail_generation_interval = 16;

-                if (Time.Current - catcherTrails.LastDashTrailTime >= trail_generation_interval)
+                if (Time.Current - CatcherTrails.LastDashTrailTime >= trail_generation_interval)
                    displayCatcherTrail(Catcher.HyperDashing ? CatcherTrailAnimation.HyperDashing : CatcherTrailAnimation.Dashing);
            }

@ -170,6 +170,6 @@ namespace osu.Game.Rulesets.Catch.UI
            }
        }

-        private void displayCatcherTrail(CatcherTrailAnimation animation) => catcherTrails.Add(new CatcherTrailEntry(Time.Current, Catcher.CurrentState, Catcher.X, Catcher.BodyScale, animation));
+        private void displayCatcherTrail(CatcherTrailAnimation animation) => CatcherTrails.Add(new CatcherTrailEntry(Time.Current, Catcher.CurrentState, Catcher.X, Catcher.BodyScale, animation));
    }
 }
--- a/osu.Game.Rulesets.Catch/UI/CatcherTrailDisplay.cs
+++ b/osu.Game.Rulesets.Catch/UI/CatcherTrailDisplay.cs
@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.

 using System;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
@ -10,6 +11,7 @@ using osu.Framework.Graphics.Pooling;
 using osu.Game.Rulesets.Catch.Skinning;
 using osu.Game.Rulesets.Objects.Pooling;
 using osu.Game.Skinning;
+using osuTK;
 using osuTK.Graphics;

 namespace osu.Game.Rulesets.Catch.UI
@ -55,6 +57,25 @@ namespace osu.Game.Rulesets.Catch.UI
            };
        }

+        /// <summary>
+        /// Update the scale of all trails.
+        /// </summary>
+        /// <param name="scale">The new body scale of the Catcher</param>
+        public void UpdateCatcherTrailsScale(Vector2 scale)
+        {
+            var oldEntries = Entries.ToList();
+
+            Clear();
+
+            foreach (var oldEntry in oldEntries)
+            {
+                // use magnitude of the new scale while preserving the sign of the old one in the X direction.
+                // the end effect is preserving the direction in which the trail sprites face, which is important.
+                var targetScale = new Vector2(Math.Abs(scale.X) * Math.Sign(oldEntry.Scale.X), Math.Abs(scale.Y));
+                Add(new CatcherTrailEntry(oldEntry.LifetimeStart, oldEntry.CatcherState, oldEntry.Position, targetScale, oldEntry.Animation));
+            }
+        }
+
        protected override void LoadComplete()
        {
            base.LoadComplete();
--- a/osu.Game.Rulesets.Mania.Tests/Editor/ManiaPlacementBlueprintTestScene.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/ManiaPlacementBlueprintTestScene.cs
@ -47,7 +47,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
            });
        }

-        protected override SnapResult SnapForBlueprint(PlacementBlueprint blueprint)
+        protected override SnapResult SnapForBlueprint(HitObjectPlacementBlueprint blueprint)
        {
            double time = column.TimeAtScreenSpacePosition(InputManager.CurrentState.Mouse.Position);
            var pos = column.ScreenSpacePositionAtTime(time);
--- a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneHoldNotePlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneHoldNotePlacementBlueprint.cs
@ -13,6 +13,6 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
    public partial class TestSceneHoldNotePlacementBlueprint : ManiaPlacementBlueprintTestScene
    {
        protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableHoldNote((HoldNote)hitObject);
-        protected override PlacementBlueprint CreateBlueprint() => new HoldNotePlacementBlueprint();
+        protected override HitObjectPlacementBlueprint CreateBlueprint() => new HoldNotePlacementBlueprint();
    }
 }
--- a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaEditorSaving.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaEditorSaving.cs
@ -20,10 +20,10 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
        [Test]
        public void TestKeyCountChange()
        {
-            LabelledSliderBar<float> keyCount = null!;
+            FormSliderBar<float> keyCount = null!;

            AddStep("go to setup screen", () => InputManager.Key(Key.F4));
-            AddUntilStep("retrieve key count slider", () => keyCount = Editor.ChildrenOfType<SetupScreen>().Single().ChildrenOfType<LabelledSliderBar<float>>().First(), () => Is.Not.Null);
+            AddUntilStep("retrieve key count slider", () => keyCount = Editor.ChildrenOfType<SetupScreen>().Single().ChildrenOfType<FormSliderBar<float>>().First(), () => Is.Not.Null);
            AddAssert("key count is 5", () => keyCount.Current.Value, () => Is.EqualTo(5));
            AddStep("change key count to 8", () =>
            {
--- a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaSelectionHandler.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaSelectionHandler.cs
@ -5,7 +5,9 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Edit.Blueprints;
 using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Screens.Edit.Compose.Components;
 using osu.Game.Tests.Beatmaps;
 using osu.Game.Tests.Visual;
@ -92,5 +94,70 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
            AddAssert("second object flipped", () => second.StartTime, () => Is.EqualTo(250));
            AddAssert("third object flipped", () => third.StartTime, () => Is.EqualTo(1250));
        }
+
+        [Test]
+        public void TestOffScreenObjectsRemainSelectedOnColumnChange()
+        {
+            AddStep("create objects", () =>
+            {
+                for (int i = 0; i < 20; ++i)
+                    EditorBeatmap.Add(new Note { StartTime = 1000 * i, Column = 0 });
+            });
+
+            AddStep("select everything", () => EditorBeatmap.SelectedHitObjects.AddRange(EditorBeatmap.HitObjects));
+            AddStep("start drag", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<NoteSelectionBlueprint>().Single(blueprint => blueprint.IsSelected && blueprint.HitObject.StartTime == 0));
+                InputManager.PressButton(MouseButton.Left);
+            });
+            AddStep("end drag", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<Column>().Last());
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            AddAssert("all objects in last column", () => EditorBeatmap.HitObjects.All(ho => ((ManiaHitObject)ho).Column == 3));
+            AddAssert("all objects remain selected", () => EditorBeatmap.SelectedHitObjects.SequenceEqual(EditorBeatmap.HitObjects));
+        }
+
+        [Test]
+        public void TestOffScreenObjectsRemainSelectedOnHorizontalFlip()
+        {
+            AddStep("create objects", () =>
+            {
+                for (int i = 0; i < 20; ++i)
+                    EditorBeatmap.Add(new Note { StartTime = 1000 * i, Column = i % 4 });
+            });
+
+            AddStep("select everything", () => EditorBeatmap.SelectedHitObjects.AddRange(EditorBeatmap.HitObjects));
+            AddStep("flip", () =>
+            {
+                InputManager.PressKey(Key.ControlLeft);
+                InputManager.Key(Key.H);
+                InputManager.ReleaseKey(Key.ControlLeft);
+            });
+
+            AddAssert("all objects remain selected", () => EditorBeatmap.SelectedHitObjects.SequenceEqual(EditorBeatmap.HitObjects));
+        }
+
+        [Test]
+        public void TestOffScreenObjectsRemainSelectedOnVerticalFlip()
+        {
+            AddStep("create objects", () =>
+            {
+                for (int i = 0; i < 20; ++i)
+                    EditorBeatmap.Add(new Note { StartTime = 1000 * i, Column = i % 4 });
+            });
+
+            AddStep("select everything", () => EditorBeatmap.SelectedHitObjects.AddRange(EditorBeatmap.HitObjects));
+            AddStep("flip", () =>
+            {
+                InputManager.PressKey(Key.ControlLeft);
+                InputManager.Key(Key.J);
+                InputManager.ReleaseKey(Key.ControlLeft);
+            });
+
+            AddAssert("all objects remain selected", () => EditorBeatmap.SelectedHitObjects.SequenceEqual(EditorBeatmap.HitObjects.Reverse()));
+        }
    }
 }
--- a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneNotePlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneNotePlacementBlueprint.cs
@ -64,6 +64,6 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
        private Note getNote() => this.ChildrenOfType<DrawableNote>().FirstOrDefault()?.HitObject;

        protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableNote((Note)hitObject);
-        protected override PlacementBlueprint CreateBlueprint() => new NotePlacementBlueprint();
+        protected override HitObjectPlacementBlueprint CreateBlueprint() => new NotePlacementBlueprint();
    }
 }
--- a/osu.Game.Rulesets.Mania.Tests/ManiaScoreProcessorTest.cs
+++ b/osu.Game.Rulesets.Mania.Tests/ManiaScoreProcessorTest.cs
@ -0,0 +1,39 @@
+// 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 NUnit.Framework;
+using osu.Game.Rulesets.Mania.Scoring;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [TestFixture]
+    public class ManiaScoreProcessorTest
+    {
+        [TestCase(ScoreRank.X, 1, HitResult.Perfect)]
+        [TestCase(ScoreRank.X, 0.99, HitResult.Great)]
+        [TestCase(ScoreRank.D, 0.1, HitResult.Great)]
+        [TestCase(ScoreRank.X, 0.99, HitResult.Perfect, HitResult.Great)]
+        [TestCase(ScoreRank.X, 0.99, HitResult.Great, HitResult.Great)]
+        [TestCase(ScoreRank.S, 0.99, HitResult.Perfect, HitResult.Good)]
+        [TestCase(ScoreRank.S, 0.99, HitResult.Perfect, HitResult.Ok)]
+        [TestCase(ScoreRank.S, 0.99, HitResult.Perfect, HitResult.Meh)]
+        [TestCase(ScoreRank.S, 0.99, HitResult.Perfect, HitResult.Miss)]
+        [TestCase(ScoreRank.S, 0.99, HitResult.Great, HitResult.Good)]
+        [TestCase(ScoreRank.S, 0.99, HitResult.Great, HitResult.Ok)]
+        [TestCase(ScoreRank.S, 0.99, HitResult.Great, HitResult.Meh)]
+        [TestCase(ScoreRank.S, 0.99, HitResult.Great, HitResult.Miss)]
+        public void TestRanks(ScoreRank expected, double accuracy, params HitResult[] results)
+        {
+            var scoreProcessor = new ManiaScoreProcessor();
+
+            Dictionary<HitResult, int> resultsDict = new Dictionary<HitResult, int>();
+            foreach (var result in results)
+                resultsDict[result] = resultsDict.GetValueOrDefault(result) + 1;
+
+            Assert.That(scoreProcessor.RankFromScore(accuracy, resultsDict), Is.EqualTo(expected));
+        }
+    }
+}
--- a/osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModAutoplay.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModAutoplay.cs
@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
            CreateModTest(new ModTestData
            {
                Autoplay = true,
-                Beatmap = new ManiaBeatmap(new StageDefinition(1))
+                CreateBeatmap = () => new ManiaBeatmap(new StageDefinition(1))
                {
                    HitObjects = new List<ManiaHitObject>
                    {
--- a/osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModDoubleTime.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModDoubleTime.cs
@ -29,7 +29,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
                                  && Precision.AlmostEquals(Player.ScoreProcessor.Accuracy.Value, 0.9836, 0.01)
                                  && Player.ScoreProcessor.TotalScore.Value == 946_049,
            Autoplay = false,
-            Beatmap = new Beatmap
+            CreateBeatmap = () => new Beatmap
            {
                BeatmapInfo = { Ruleset = new ManiaRuleset().RulesetInfo },
                Difficulty = { OverallDifficulty = 10 },
@ -56,7 +56,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
                                      && Player.ScoreProcessor.Accuracy.Value == 1
                                      && Player.ScoreProcessor.TotalScore.Value == (long)(1_000_000 * doubleTime.ScoreMultiplier),
                Autoplay = false,
-                Beatmap = new Beatmap
+                CreateBeatmap = () => new Beatmap
                {
                    BeatmapInfo = { Ruleset = new ManiaRuleset().RulesetInfo },
                    Difficulty = { OverallDifficulty = 10 },
--- a/osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModFadeIn.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModFadeIn.cs
@ -74,7 +74,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
            CreateModTest(new ModTestData
            {
                Mod = new ManiaModHidden(),
-                Beatmap = new Beatmap
+                CreateBeatmap = () => new Beatmap
                {
                    HitObjects = Enumerable.Range(1, 100).Select(i => (HitObject)new Note { StartTime = 1000 + 200 * i }).ToList(),
                    Breaks = { new BreakPeriod(2000, 28000) }
--- a/osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModHidden.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModHidden.cs
@ -74,7 +74,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
            CreateModTest(new ModTestData
            {
                Mod = new ManiaModHidden(),
-                Beatmap = new Beatmap
+                CreateBeatmap = () => new Beatmap
                {
                    HitObjects = Enumerable.Range(1, 100).Select(i => (HitObject)new Note { StartTime = 1000 + 200 * i }).ToList(),
                    Breaks = { new BreakPeriod(2000, 28000) }
--- a/osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModPerfect.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModPerfect.cs
@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
            Mod = new ManiaModPerfect(),
            PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(false),
            Autoplay = false,
-            Beatmap = new Beatmap
+            CreateBeatmap = () => new Beatmap
            {
                HitObjects = new List<HitObject>
                {
@ -59,7 +59,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
            Mod = new ManiaModPerfect(),
            PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(true) && Player.Results.Count == 2,
            Autoplay = false,
-            Beatmap = new Beatmap
+            CreateBeatmap = () => new Beatmap
            {
                HitObjects = new List<HitObject>
                {
--- a/osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModSuddenDeath.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModSuddenDeath.cs
@ -28,7 +28,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
            Mod = new ManiaModSuddenDeath(),
            PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(false),
            Autoplay = false,
-            Beatmap = new Beatmap
+            CreateBeatmap = () => new Beatmap
            {
                HitObjects = new List<HitObject>
                {
@ -51,7 +51,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
            Mod = new ManiaModSuddenDeath(),
            PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(true) && Player.Results.Count == 2,
            Autoplay = false,
-            Beatmap = new Beatmap
+            CreateBeatmap = () => new Beatmap
            {
                HitObjects = new List<HitObject>
                {
--- a/osu.Game.Rulesets.Mania.Tests/osu.Game.Rulesets.Mania.Tests.csproj
+++ b/osu.Game.Rulesets.Mania.Tests/osu.Game.Rulesets.Mania.Tests.csproj
@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
  <Import Project="..\osu.TestProject.props" />
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
    <PackageReference Include="NUnit" Version="3.14.0" />
    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
  </ItemGroup>
--- a/osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs
@ -29,7 +29,7 @@ namespace osu.Game.Rulesets.Mania.Difficulty
        private readonly bool isForCurrentRuleset;
        private readonly double originalOverallDifficulty;

-        public override int Version => 20230817;
+        public override int Version => 20241007;

        public ManiaDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
            : base(ruleset, beatmap)
--- a/osu.Game.Rulesets.Mania/Difficulty/Skills/Strain.cs
+++ b/osu.Game.Rulesets.Mania/Difficulty/Skills/Strain.cs
@ -5,6 +5,7 @@ using System;
 using osu.Framework.Utils;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Skills;
+using osu.Game.Rulesets.Difficulty.Utils;
 using osu.Game.Rulesets.Mania.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Mods;

@ -73,7 +74,7 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Skills
            // 0.0 +--------+-+---------------> Release Difference / ms
            //         release_threshold
            if (isOverlapping)
-                holdAddition = 1 / (1 + Math.Exp(0.27 * (release_threshold - closestEndTime)));
+                holdAddition = DifficultyCalculationUtils.Logistic(x: closestEndTime, multiplier: 0.27, midpointOffset: release_threshold);

            // Decay and increase individualStrains in own column
            individualStrains[column] = applyDecay(individualStrains[column], startTime - startTimes[column], individual_decay_base);
--- a/osu.Game.Rulesets.Mania/Edit/Blueprints/Components/EditBodyPiece.cs
+++ b/osu.Game.Rulesets.Mania/Edit/Blueprints/Components/EditBodyPiece.cs
@ -3,21 +3,39 @@

 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
-using osu.Game.Rulesets.Mania.Skinning.Default;

 namespace osu.Game.Rulesets.Mania.Edit.Blueprints.Components
 {
-    public partial class EditBodyPiece : DefaultBodyPiece
+    public partial class EditBodyPiece : CompositeDrawable
    {
+        private readonly Container border;
+
+        public EditBodyPiece()
+        {
+            InternalChildren = new Drawable[]
+            {
+                border = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    BorderThickness = 3,
+                    Child = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Alpha = 0,
+                        AlwaysPresent = true,
+                    },
+                },
+            };
+        }
+
        [BackgroundDependencyLoader]
        private void load(OsuColour colours)
        {
-            AccentColour.Value = colours.Yellow;
-
-            Background.Alpha = 0.5f;
+            border.BorderColour = colours.YellowDarker;
        }
-
-        protected override Drawable CreateForeground() => base.CreateForeground().With(d => d.Alpha = 0);
    }
 }
--- a/osu.Game.Rulesets.Mania/Edit/Blueprints/Components/EditHoldNoteEndPiece.cs
+++ b/osu.Game.Rulesets.Mania/Edit/Blueprints/Components/EditHoldNoteEndPiece.cs
@ -4,6 +4,7 @@
 using System;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Events;
 using osu.Game.Graphics;
@ -26,10 +27,11 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints.Components
        {
            Height = DefaultNotePiece.NOTE_HEIGHT;

-            CornerRadius = 5;
-            Masking = true;
-
-            InternalChild = new DefaultNotePiece();
+            InternalChild = new EditNotePiece
+            {
+                RelativeSizeAxes = Axes.Both,
+                Height = 1,
+            };
        }

        protected override void LoadComplete()
@ -60,19 +62,23 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints.Components
        {
            base.OnDrag(e);
            Dragging?.Invoke(e.ScreenSpaceMousePosition);
+            updateState();
        }

        protected override void OnDragEnd(DragEndEvent e)
        {
            base.OnDragEnd(e);
            DragEnded?.Invoke();
+            updateState();
        }

        private void updateState()
        {
+            InternalChild.Colour = Colour4.White;
+
            var colour = colours.Yellow;

-            if (IsHovered)
+            if (IsHovered || IsDragged)
                colour = colour.Lighten(1);

            Colour = colour;
--- a/osu.Game.Rulesets.Mania/Edit/Blueprints/Components/EditNotePiece.cs
+++ b/osu.Game.Rulesets.Mania/Edit/Blueprints/Components/EditNotePiece.cs
@ -2,28 +2,63 @@
 // See the LICENCE file in the repository root for full licence text.

 using osu.Framework.Allocation;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
-using osu.Game.Rulesets.Mania.Skinning.Default;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.UI.Scrolling;
+using osuTK;

 namespace osu.Game.Rulesets.Mania.Edit.Blueprints.Components
 {
    public partial class EditNotePiece : CompositeDrawable
    {
+        private readonly Container border;
+        private readonly Box box;
+
+        [Resolved]
+        private Column? column { get; set; }
+
        public EditNotePiece()
        {
-            Height = DefaultNotePiece.NOTE_HEIGHT;
-
-            CornerRadius = 5;
-            Masking = true;
-
-            InternalChild = new DefaultNotePiece();
+            InternalChildren = new Drawable[]
+            {
+                border = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    BorderThickness = 3,
+                    Child = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Alpha = 0,
+                        AlwaysPresent = true,
+                    },
+                },
+                box = new Box
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = 3,
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.BottomCentre,
+                },
+            };
        }

        [BackgroundDependencyLoader]
        private void load(OsuColour colours)
        {
-            Colour = colours.Yellow;
+            border.BorderColour = colours.YellowDark;
+            box.Colour = colours.YellowLight;
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (column != null)
+                Scale = new Vector2(1, column.ScrollingInfo.Direction.Value == ScrollingDirection.Down ? 1 : -1);
        }
    }
 }
--- a/osu.Game.Rulesets.Mania/Edit/Blueprints/HoldNotePlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Mania/Edit/Blueprints/HoldNotePlacementBlueprint.cs
@ -4,8 +4,10 @@
 using System;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
 using osu.Framework.Utils;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Mania.Objects;
@ -17,9 +19,9 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
    public partial class HoldNotePlacementBlueprint : ManiaPlacementBlueprint<HoldNote>
    {
-        private readonly EditBodyPiece bodyPiece;
-        private readonly EditNotePiece headPiece;
-        private readonly EditNotePiece tailPiece;
+        private EditBodyPiece bodyPiece = null!;
+        private Circle headPiece = null!;
+        private Circle tailPiece = null!;

        [Resolved]
        private IScrollingInfo scrollingInfo { get; set; } = null!;
@ -28,14 +30,29 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints

        public HoldNotePlacementBlueprint()
            : base(new HoldNote())
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
        {
            RelativeSizeAxes = Axes.Both;

            InternalChildren = new Drawable[]
            {
                bodyPiece = new EditBodyPiece { Origin = Anchor.TopCentre },
-                headPiece = new EditNotePiece { Origin = Anchor.Centre },
-                tailPiece = new EditNotePiece { Origin = Anchor.Centre }
+                headPiece = new Circle
+                {
+                    Origin = Anchor.Centre,
+                    Colour = colours.Yellow,
+                    Height = 10
+                },
+                tailPiece = new Circle
+                {
+                    Origin = Anchor.Centre,
+                    Colour = colours.Yellow,
+                    Height = 10
+                },
            };
        }

--- a/osu.Game.Rulesets.Mania/Edit/Blueprints/HoldNoteSelectionBlueprint.cs
+++ b/osu.Game.Rulesets.Mania/Edit/Blueprints/HoldNoteSelectionBlueprint.cs
@ -2,14 +2,14 @@
 // See the LICENCE file in the repository root for full licence text.

 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Screens.Edit;
 using osuTK;

@ -17,9 +17,6 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
    public partial class HoldNoteSelectionBlueprint : ManiaSelectionBlueprint<HoldNote>
    {
-        [Resolved]
-        private OsuColour colours { get; set; } = null!;
-
        [Resolved]
        private IEditorChangeHandler? changeHandler { get; set; }

@ -29,9 +26,12 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
        [Resolved]
        private IPositionSnapProvider? positionSnapProvider { get; set; }

+        private EditBodyPiece body = null!;
        private EditHoldNoteEndPiece head = null!;
        private EditHoldNoteEndPiece tail = null!;

+        protected new DrawableHoldNote DrawableObject => (DrawableHoldNote)base.DrawableObject;
+
        public HoldNoteSelectionBlueprint(HoldNote hold)
            : base(hold)
        {
@ -42,9 +42,17 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
        {
            InternalChildren = new Drawable[]
            {
+                body = new EditBodyPiece
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.BottomCentre,
+                },
                head = new EditHoldNoteEndPiece
                {
                    RelativeSizeAxes = Axes.X,
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.BottomCentre,
                    DragStarted = () => changeHandler?.BeginChange(),
                    Dragging = pos =>
                    {
@ -64,6 +72,8 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
                tail = new EditHoldNoteEndPiece
                {
                    RelativeSizeAxes = Axes.X,
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.BottomCentre,
                    DragStarted = () => changeHandler?.BeginChange(),
                    Dragging = pos =>
                    {
@ -79,19 +89,6 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
                    },
                    DragEnded = () => changeHandler?.EndChange(),
                },
-                new Container
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Masking = true,
-                    BorderThickness = 1,
-                    BorderColour = colours.Yellow,
-                    Child = new Box
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Alpha = 0,
-                        AlwaysPresent = true,
-                    }
-                }
            };
        }

@ -99,11 +96,23 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
        {
            base.Update();

+            head.Height = DrawableObject.Head.DrawHeight;
            head.Y = HitObjectContainer.PositionAtTime(HitObject.Head.StartTime, HitObject.StartTime);
+            tail.Height = DrawableObject.Tail.DrawHeight;
            tail.Y = HitObjectContainer.PositionAtTime(HitObject.Tail.StartTime, HitObject.StartTime);
            Height = HitObjectContainer.LengthAtTime(HitObject.StartTime, HitObject.EndTime) + tail.DrawHeight;
        }

+        protected override void OnDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
+        {
+            Origin = direction.NewValue == ScrollingDirection.Down ? Anchor.BottomCentre : Anchor.TopCentre;
+
+            foreach (var child in InternalChildren)
+                child.Anchor = Origin;
+
+            head.Scale = tail.Scale = body.Scale = new Vector2(1, direction.NewValue == ScrollingDirection.Down ? 1 : -1);
+        }
+
        public override Quad SelectionQuad => ScreenSpaceDrawQuad;

        public override Vector2 ScreenSpaceSelectionPoint => head.ScreenSpaceDrawQuad.Centre;
--- a/osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaPlacementBlueprint.cs
@ -15,7 +15,7 @@ using osuTK.Input;

 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
-    public abstract partial class ManiaPlacementBlueprint<T> : PlacementBlueprint
+    public abstract partial class ManiaPlacementBlueprint<T> : HitObjectPlacementBlueprint
        where T : ManiaHitObject
    {
        protected new T HitObject => (T)base.HitObject;
--- a/osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaSelectionBlueprint.cs
+++ b/osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaSelectionBlueprint.cs
@ -37,16 +37,10 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
        protected override void LoadComplete()
        {
            base.LoadComplete();
-            directionBindable.BindValueChanged(onDirectionChanged, true);
+            directionBindable.BindValueChanged(OnDirectionChanged, true);
        }

-        private void onDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
-        {
-            var anchor = direction.NewValue == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre;
-            Anchor = Origin = anchor;
-            foreach (var child in InternalChildren)
-                child.Anchor = child.Origin = anchor;
-        }
+        protected abstract void OnDirectionChanged(ValueChangedEvent<ScrollingDirection> direction);

        protected override void Update()
        {
--- a/osu.Game.Rulesets.Mania/Edit/Blueprints/NotePlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Mania/Edit/Blueprints/NotePlacementBlueprint.cs
@ -1,10 +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.Framework.Allocation;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Mania.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Mania.Objects;
 using osuTK.Input;

@ -12,14 +14,25 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
    public partial class NotePlacementBlueprint : ManiaPlacementBlueprint<Note>
    {
-        private readonly EditNotePiece piece;
+        private Circle piece = null!;

        public NotePlacementBlueprint()
            : base(new Note())
        {
-            RelativeSizeAxes = Axes.Both;
+        }

-            InternalChild = piece = new EditNotePiece { Origin = Anchor.Centre };
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            RelativeSizeAxes = Axes.Both;
+            Masking = true;
+
+            InternalChild = piece = new Circle
+            {
+                Origin = Anchor.Centre,
+                Colour = colours.Yellow,
+                Height = 10
+            };
        }

        public override void UpdateTimeAndPosition(SnapResult result)
--- a/osu.Game.Rulesets.Mania/Edit/Blueprints/NoteSelectionBlueprint.cs
+++ b/osu.Game.Rulesets.Mania/Edit/Blueprints/NoteSelectionBlueprint.cs
@ -1,18 +1,42 @@
 // 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.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Mania.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.UI.Scrolling;
+using osuTK;

 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
    public partial class NoteSelectionBlueprint : ManiaSelectionBlueprint<Note>
    {
+        private readonly EditNotePiece notePiece;
+
        public NoteSelectionBlueprint(Note note)
            : base(note)
        {
-            AddInternal(new EditNotePiece { RelativeSizeAxes = Axes.X });
+            Anchor = Anchor.BottomCentre;
+            Origin = Anchor.BottomCentre;
+            AddInternal(notePiece = new EditNotePiece
+            {
+                RelativeSizeAxes = Axes.X,
+                Anchor = Anchor.BottomCentre,
+                Origin = Anchor.BottomCentre,
+            });
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            notePiece.Height = DrawableObject.DrawHeight;
+        }
+
+        protected override void OnDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
+        {
+            notePiece.Scale = new Vector2(1, direction.NewValue == ScrollingDirection.Down ? 1 : -1);
        }
    }
 }
--- a/osu.Game.Rulesets.Mania/Edit/EditorColumn.cs
+++ b/osu.Game.Rulesets.Mania/Edit/EditorColumn.cs
@ -0,0 +1,45 @@
+// 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.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Mania.Edit
+{
+    public partial class EditorColumn : Column
+    {
+        public EditorColumn(int index, bool isSpecial)
+            : base(index, isSpecial)
+        {
+        }
+
+        protected override void OnNewDrawableHitObject(DrawableHitObject drawableHitObject)
+        {
+            base.OnNewDrawableHitObject(drawableHitObject);
+            drawableHitObject.ApplyCustomUpdateState += (dho, state) =>
+            {
+                switch (dho)
+                {
+                    // hold note heads are exempt from what follows due to the "freezing" mechanic
+                    // which already ensures they'll never fade away on their own.
+                    case DrawableHoldNoteHead:
+                        break;
+
+                    // mania features instantaneous hitobject fade-outs.
+                    // this means that without manual intervention stopping the clock at the precise time of hitting the object
+                    // means the object will fade out.
+                    // this is anti-user in editor contexts, as the user is expecting to continue the see the note on the receptor line.
+                    // therefore, apply a crude workaround to prevent it from going away.
+                    default:
+                    {
+                        if (state == ArmedState.Hit)
+                            dho.FadeTo(1).Delay(1).FadeOut().Expire();
+                        break;
+                    }
+                }
+            };
+        }
+    }
+}
--- a/osu.Game.Rulesets.Mania/Edit/EditorStage.cs
+++ b/osu.Game.Rulesets.Mania/Edit/EditorStage.cs
@ -0,0 +1,18 @@
+// 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.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.UI;
+
+namespace osu.Game.Rulesets.Mania.Edit
+{
+    public partial class EditorStage : Stage
+    {
+        public EditorStage(int firstColumnIndex, StageDefinition definition, ref ManiaAction columnStartAction)
+            : base(firstColumnIndex, definition, ref columnStartAction)
+        {
+        }
+
+        protected override Column CreateColumn(int index, bool isSpecial) => new EditorColumn(index, isSpecial);
+    }
+}
--- a/osu.Game.Rulesets.Mania/Edit/HoldNoteCompositionTool.cs
+++ b/osu.Game.Rulesets.Mania/Edit/HoldNoteCompositionTool.cs
@ -9,7 +9,7 @@ using osu.Game.Rulesets.Mania.Edit.Blueprints;

 namespace osu.Game.Rulesets.Mania.Edit
 {
-    public class HoldNoteCompositionTool : HitObjectCompositionTool
+    public class HoldNoteCompositionTool : CompositionTool
    {
        public HoldNoteCompositionTool()
            : base("Hold")
@ -18,6 +18,6 @@ namespace osu.Game.Rulesets.Mania.Edit

        public override Drawable CreateIcon() => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders);

-        public override PlacementBlueprint CreatePlacementBlueprint() => new HoldNotePlacementBlueprint();
+        public override HitObjectPlacementBlueprint CreatePlacementBlueprint() => new HoldNotePlacementBlueprint();
    }
 }
--- a/osu.Game.Rulesets.Mania/Edit/ManiaEditorPlayfield.cs
+++ b/osu.Game.Rulesets.Mania/Edit/ManiaEditorPlayfield.cs
@ -13,5 +13,8 @@ namespace osu.Game.Rulesets.Mania.Edit
            : base(stages)
        {
        }
+
+        protected override Stage CreateStage(int firstColumnIndex, StageDefinition stageDefinition, ref ManiaAction columnAction)
+            => new EditorStage(firstColumnIndex, stageDefinition, ref columnAction);
    }
 }
--- a/osu.Game.Rulesets.Mania/Edit/ManiaHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Mania/Edit/ManiaHitObjectComposer.cs
@ -46,7 +46,7 @@ namespace osu.Game.Rulesets.Mania.Edit

        protected override BeatSnapGrid CreateBeatSnapGrid() => new ManiaBeatSnapGrid();

-        protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
+        protected override IReadOnlyList<CompositionTool> CompositionTools => new CompositionTool[]
        {
            new NoteCompositionTool(),
            new HoldNoteCompositionTool()
@ -92,7 +92,7 @@ namespace osu.Game.Rulesets.Mania.Edit
            base.Update();

            if (screenWithTimeline?.TimelineArea.Timeline != null)
-                drawableRuleset.TimelineTimeRange = EditorClock.TrackLength / screenWithTimeline.TimelineArea.Timeline.CurrentZoom / 2;
+                drawableRuleset.TimelineTimeRange = EditorClock.TrackLength / screenWithTimeline.TimelineArea.Timeline.CurrentZoom.Value / 2;
        }
    }
 }
--- a/osu.Game.Rulesets.Mania/Edit/ManiaSelectionHandler.cs
+++ b/osu.Game.Rulesets.Mania/Edit/ManiaSelectionHandler.cs
@ -54,9 +54,8 @@ namespace osu.Game.Rulesets.Mania.Edit
                    int firstColumn = flipOverOrigin ? 0 : selectedObjects.Min(ho => ho.Column);
                    int lastColumn = flipOverOrigin ? (int)EditorBeatmap.BeatmapInfo.Difficulty.CircleSize - 1 : selectedObjects.Max(ho => ho.Column);

-                    EditorBeatmap.PerformOnSelection(hitObject =>
+                    performOnSelection(maniaObject =>
                    {
-                        var maniaObject = (ManiaHitObject)hitObject;
                        maniaPlayfield.Remove(maniaObject);
                        maniaObject.Column = firstColumn + (lastColumn - maniaObject.Column);
                        maniaPlayfield.Add(maniaObject);
@ -71,7 +70,7 @@ namespace osu.Game.Rulesets.Mania.Edit
                    double selectionStartTime = selectedObjects.Min(ho => ho.StartTime);
                    double selectionEndTime = selectedObjects.Max(ho => ho.GetEndTime());

-                    EditorBeatmap.PerformOnSelection(hitObject =>
+                    performOnSelection(hitObject =>
                    {
                        hitObject.StartTime = selectionStartTime + (selectionEndTime - hitObject.GetEndTime());
                    });
@ -104,8 +103,10 @@ namespace osu.Game.Rulesets.Mania.Edit
            int minColumn = int.MaxValue;
            int maxColumn = int.MinValue;

+            var selectedObjects = EditorBeatmap.SelectedHitObjects.OfType<ManiaHitObject>().ToArray();
+
            // find min/max in an initial pass before actually performing the movement.
-            foreach (var obj in EditorBeatmap.SelectedHitObjects.OfType<ManiaHitObject>())
+            foreach (var obj in selectedObjects)
            {
                if (obj.Column < minColumn)
                    minColumn = obj.Column;
@ -115,12 +116,26 @@ namespace osu.Game.Rulesets.Mania.Edit

            columnDelta = Math.Clamp(columnDelta, -minColumn, maniaPlayfield.TotalColumns - 1 - maxColumn);

-            EditorBeatmap.PerformOnSelection(h =>
+            performOnSelection(h =>
            {
                maniaPlayfield.Remove(h);
-                ((ManiaHitObject)h).Column += columnDelta;
+                h.Column += columnDelta;
                maniaPlayfield.Add(h);
            });
        }
+
+        private void performOnSelection(Action<ManiaHitObject> action)
+        {
+            var selectedObjects = EditorBeatmap.SelectedHitObjects.OfType<ManiaHitObject>().ToArray();
+
+            EditorBeatmap.PerformOnSelection(h => action.Invoke((ManiaHitObject)h));
+
+            // `HitObjectUsageEventBuffer`'s usage transferal flows and the playfield's `SetKeepAlive()` functionality do not combine well with mania's usage patterns,
+            // leading to selections being sometimes partially dropped if some of the objects being moved are off screen
+            // (check blame for detailed explanation).
+            // thus, ensure that selection is preserved manually.
+            EditorBeatmap.SelectedHitObjects.Clear();
+            EditorBeatmap.SelectedHitObjects.AddRange(selectedObjects);
+        }
    }
 }
--- a/osu.Game.Rulesets.Mania/Edit/NoteCompositionTool.cs
+++ b/osu.Game.Rulesets.Mania/Edit/NoteCompositionTool.cs
@ -10,7 +10,7 @@ using osu.Game.Rulesets.Mania.Objects;

 namespace osu.Game.Rulesets.Mania.Edit
 {
-    public class NoteCompositionTool : HitObjectCompositionTool
+    public class NoteCompositionTool : CompositionTool
    {
        public NoteCompositionTool()
            : base(nameof(Note))
@ -19,6 +19,6 @@ namespace osu.Game.Rulesets.Mania.Edit

        public override Drawable CreateIcon() => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles);

-        public override PlacementBlueprint CreatePlacementBlueprint() => new NotePlacementBlueprint();
+        public override HitObjectPlacementBlueprint CreatePlacementBlueprint() => new NotePlacementBlueprint();
    }
 }
--- a/osu.Game.Rulesets.Mania/Edit/Setup/ManiaDifficultySection.cs
+++ b/osu.Game.Rulesets.Mania/Edit/Setup/ManiaDifficultySection.cs
@ -19,12 +19,12 @@ namespace osu.Game.Rulesets.Mania.Edit.Setup
    {
        public override LocalisableString Title => EditorSetupStrings.DifficultyHeader;

-        private LabelledSliderBar<float> keyCountSlider { get; set; } = null!;
-        private LabelledSwitchButton specialStyle { get; set; } = null!;
-        private LabelledSliderBar<float> healthDrainSlider { get; set; } = null!;
-        private LabelledSliderBar<float> overallDifficultySlider { get; set; } = null!;
-        private LabelledSliderBar<double> baseVelocitySlider { get; set; } = null!;
-        private LabelledSliderBar<double> tickRateSlider { get; set; } = null!;
+        private FormSliderBar<float> keyCountSlider { get; set; } = null!;
+        private FormCheckBox specialStyle { get; set; } = null!;
+        private FormSliderBar<float> healthDrainSlider { get; set; } = null!;
+        private FormSliderBar<float> overallDifficultySlider { get; set; } = null!;
+        private FormSliderBar<double> baseVelocitySlider { get; set; } = null!;
+        private FormSliderBar<double> tickRateSlider { get; set; } = null!;

        [Resolved]
        private Editor? editor { get; set; }
@ -37,77 +37,81 @@ namespace osu.Game.Rulesets.Mania.Edit.Setup
        {
            Children = new Drawable[]
            {
-                keyCountSlider = new LabelledSliderBar<float>
+                keyCountSlider = new FormSliderBar<float>
                {
-                    Label = BeatmapsetsStrings.ShowStatsCsMania,
-                    FixedLabelWidth = LABEL_WIDTH,
-                    Description = "The number of columns in the beatmap",
+                    Caption = BeatmapsetsStrings.ShowStatsCsMania,
+                    HintText = "The number of columns in the beatmap",
                    Current = new BindableFloat(Beatmap.Difficulty.CircleSize)
                    {
                        Default = BeatmapDifficulty.DEFAULT_DIFFICULTY,
                        MinValue = 0,
                        MaxValue = 10,
                        Precision = 1,
-                    }
+                    },
+                    TransferValueOnCommit = true,
+                    TabbableContentContainer = this,
                },
-                specialStyle = new LabelledSwitchButton
+                specialStyle = new FormCheckBox
                {
-                    Label = "Use special (N+1) style",
-                    FixedLabelWidth = LABEL_WIDTH,
-                    Description = "Changes one column to act as a classic \"scratch\" or \"special\" column, which can be moved around by the user's skin (to the left/right/centre). Generally used in 6K (5+1) or 8K (7+1) configurations.",
+                    Caption = "Use special (N+1) style",
+                    HintText = "Changes one column to act as a classic \"scratch\" or \"special\" column, which can be moved around by the user's skin (to the left/right/centre). Generally used in 6K (5+1) or 8K (7+1) configurations.",
                    Current = { Value = Beatmap.SpecialStyle }
                },
-                healthDrainSlider = new LabelledSliderBar<float>
+                healthDrainSlider = new FormSliderBar<float>
                {
-                    Label = BeatmapsetsStrings.ShowStatsDrain,
-                    FixedLabelWidth = LABEL_WIDTH,
-                    Description = EditorSetupStrings.DrainRateDescription,
+                    Caption = BeatmapsetsStrings.ShowStatsDrain,
+                    HintText = EditorSetupStrings.DrainRateDescription,
                    Current = new BindableFloat(Beatmap.Difficulty.DrainRate)
                    {
                        Default = BeatmapDifficulty.DEFAULT_DIFFICULTY,
                        MinValue = 0,
                        MaxValue = 10,
                        Precision = 0.1f,
-                    }
+                    },
+                    TransferValueOnCommit = true,
+                    TabbableContentContainer = this,
                },
-                overallDifficultySlider = new LabelledSliderBar<float>
+                overallDifficultySlider = new FormSliderBar<float>
                {
-                    Label = BeatmapsetsStrings.ShowStatsAccuracy,
-                    FixedLabelWidth = LABEL_WIDTH,
-                    Description = EditorSetupStrings.OverallDifficultyDescription,
+                    Caption = BeatmapsetsStrings.ShowStatsAccuracy,
+                    HintText = EditorSetupStrings.OverallDifficultyDescription,
                    Current = new BindableFloat(Beatmap.Difficulty.OverallDifficulty)
                    {
                        Default = BeatmapDifficulty.DEFAULT_DIFFICULTY,
                        MinValue = 0,
                        MaxValue = 10,
                        Precision = 0.1f,
-                    }
+                    },
+                    TransferValueOnCommit = true,
+                    TabbableContentContainer = this,
                },
-                baseVelocitySlider = new LabelledSliderBar<double>
+                baseVelocitySlider = new FormSliderBar<double>
                {
-                    Label = EditorSetupStrings.BaseVelocity,
-                    FixedLabelWidth = LABEL_WIDTH,
-                    Description = EditorSetupStrings.BaseVelocityDescription,
+                    Caption = EditorSetupStrings.BaseVelocity,
+                    HintText = EditorSetupStrings.BaseVelocityDescription,
                    Current = new BindableDouble(Beatmap.Difficulty.SliderMultiplier)
                    {
                        Default = 1.4,
                        MinValue = 0.4,
                        MaxValue = 3.6,
                        Precision = 0.01f,
-                    }
+                    },
+                    TransferValueOnCommit = true,
+                    TabbableContentContainer = this,
                },
-                tickRateSlider = new LabelledSliderBar<double>
+                tickRateSlider = new FormSliderBar<double>
                {
-                    Label = EditorSetupStrings.TickRate,
-                    FixedLabelWidth = LABEL_WIDTH,
-                    Description = EditorSetupStrings.TickRateDescription,
+                    Caption = EditorSetupStrings.TickRate,
+                    HintText = EditorSetupStrings.TickRateDescription,
                    Current = new BindableDouble(Beatmap.Difficulty.SliderTickRate)
                    {
                        Default = 1,
                        MinValue = 1,
                        MaxValue = 4,
                        Precision = 1,
-                    }
+                    },
+                    TransferValueOnCommit = true,
+                    TabbableContentContainer = this,
                },
            };

--- a/osu.Game.Rulesets.Mania/ManiaRuleset.cs
+++ b/osu.Game.Rulesets.Mania/ManiaRuleset.cs
@ -419,9 +419,12 @@ namespace osu.Game.Rulesets.Mania
            return new ManiaFilterCriteria();
        }

-        public override IEnumerable<SetupSection> CreateEditorSetupSections() =>
+        public override IEnumerable<Drawable> CreateEditorSetupSections() =>
        [
+            new MetadataSection(),
            new ManiaDifficultySection(),
+            new ResourcesSection(),
+            new DesignSection(),
        ];

        public int GetKeyCount(IBeatmapInfo beatmapInfo, IReadOnlyList<Mod>? mods = null)
--- a/osu.Game.Rulesets.Mania/Scoring/ManiaScoreProcessor.cs
+++ b/osu.Game.Rulesets.Mania/Scoring/ManiaScoreProcessor.cs
@ -9,6 +9,7 @@ using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;

 namespace osu.Game.Rulesets.Mania.Scoring
 {
@ -58,6 +59,24 @@ namespace osu.Game.Rulesets.Mania.Scoring
            return GetBaseScoreForResult(result);
        }

+        public override ScoreRank RankFromScore(double accuracy, IReadOnlyDictionary<HitResult, int> results)
+        {
+            ScoreRank rank = base.RankFromScore(accuracy, results);
+
+            if (rank != ScoreRank.S)
+                return rank;
+
+            // SS is expected as long as all hitobjects have been hit with either a GREAT or PERFECT result.
+
+            bool anyImperfect =
+                results.GetValueOrDefault(HitResult.Good) > 0
+                || results.GetValueOrDefault(HitResult.Ok) > 0
+                || results.GetValueOrDefault(HitResult.Meh) > 0
+                || results.GetValueOrDefault(HitResult.Miss) > 0;
+
+            return anyImperfect ? rank : ScoreRank.X;
+        }
+
        private class JudgementOrderComparer : IComparer<HitObject>
        {
            public static readonly JudgementOrderComparer DEFAULT = new JudgementOrderComparer();
--- a/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyStageBackground.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyStageBackground.cs
@ -54,7 +54,8 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
                },
                columnBackgrounds = new ColumnFlow<Drawable>(stageDefinition)
                {
-                    RelativeSizeAxes = Axes.Y
+                    RelativeSizeAxes = Axes.Y,
+                    Masking = false,
                },
                new HitTargetInsetContainer
                {
@ -126,8 +127,8 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
                            },
                            new Container
                            {
+                                X = isLastColumn ? -0.16f : 0,
                                Anchor = Anchor.TopRight,
-                                Origin = Anchor.TopRight,
                                RelativeSizeAxes = Axes.Y,
                                Width = rightLineWidth,
                                Scale = new Vector2(0.740f, 1),
--- a/osu.Game.Rulesets.Mania/UI/ColumnFlow.cs
+++ b/osu.Game.Rulesets.Mania/UI/ColumnFlow.cs
@ -28,6 +28,12 @@ namespace osu.Game.Rulesets.Mania.UI
        private readonly FillFlowContainer<Container<TContent>> columns;
        private readonly StageDefinition stageDefinition;

+        public new bool Masking
+        {
+            get => base.Masking;
+            set => base.Masking = value;
+        }
+
        public ColumnFlow(StageDefinition stageDefinition)
        {
            this.stageDefinition = stageDefinition;
--- a/osu.Game.Rulesets.Mania/UI/ManiaPlayfield.cs
+++ b/osu.Game.Rulesets.Mania/UI/ManiaPlayfield.cs
@ -7,6 +7,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using System;
 using System.Collections.Generic;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics.Primitives;
 using osu.Game.Rulesets.Mania.Beatmaps;
@ -71,7 +72,7 @@ namespace osu.Game.Rulesets.Mania.UI

            for (int i = 0; i < stageDefinitions.Count; i++)
            {
-                var newStage = new Stage(firstColumnIndex, stageDefinitions[i], ref columnAction);
+                var newStage = CreateStage(firstColumnIndex, stageDefinitions[i], ref columnAction);

                playfieldGrid.Content[0][i] = newStage;

@ -82,6 +83,9 @@ namespace osu.Game.Rulesets.Mania.UI
            }
        }

+        [Pure]
+        protected virtual Stage CreateStage(int firstColumnIndex, StageDefinition stageDefinition, ref ManiaAction columnAction) => new Stage(firstColumnIndex, stageDefinition, ref columnAction);
+
        public override void Add(HitObject hitObject) => getStageByColumn(((ManiaHitObject)hitObject).Column).Add(hitObject);

        public override bool Remove(HitObject hitObject) => getStageByColumn(((ManiaHitObject)hitObject).Column).Remove(hitObject);
--- a/osu.Game.Rulesets.Mania/UI/Stage.cs
+++ b/osu.Game.Rulesets.Mania/UI/Stage.cs
@ -3,6 +3,7 @@

 using System;
 using System.Linq;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
@ -134,12 +135,14 @@ namespace osu.Game.Rulesets.Mania.UI
            {
                bool isSpecial = definition.IsSpecialColumn(i);

-                var column = new Column(firstColumnIndex + i, isSpecial)
+                var action = columnStartAction;
+                columnStartAction++;
+                var column = CreateColumn(firstColumnIndex + i, isSpecial).With(c =>
                {
-                    RelativeSizeAxes = Axes.Both,
-                    Width = 1,
-                    Action = { Value = columnStartAction++ }
-                };
+                    c.RelativeSizeAxes = Axes.Both;
+                    c.Width = 1;
+                    c.Action.Value = action;
+                });

                topLevelContainer.Add(column.TopLevelContainer.CreateProxy());
                columnBackgrounds.Add(column.BackgroundContainer.CreateProxy());
@ -154,6 +157,9 @@ namespace osu.Game.Rulesets.Mania.UI
            RegisterPool<BarLine, DrawableBarLine>(50, 200);
        }

+        [Pure]
+        protected virtual Column CreateColumn(int index, bool isSpecial) => new Column(index, isSpecial);
+
        [BackgroundDependencyLoader]
        private void load(ISkinSource skin)
        {
--- a/osu.Game.Rulesets.Osu.Tests.iOS/osu.Game.Rulesets.Osu.Tests.iOS.csproj
+++ b/osu.Game.Rulesets.Osu.Tests.iOS/osu.Game.Rulesets.Osu.Tests.iOS.csproj
@ -17,4 +17,8 @@
    <ProjectReference Include="..\osu.Game\osu.Game.csproj" />
    <ProjectReference Include="..\osu.Game.Rulesets.Osu\osu.Game.Rulesets.Osu.csproj" />
  </ItemGroup>
+  <ItemGroup Label="Package References">
+    <PackageReference Include="DeepEqual" Version="2.0.0" />
+    <PackageReference Include="Moq" Version="4.17.2" />
+  </ItemGroup>
 </Project>
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneHitCirclePlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneHitCirclePlacementBlueprint.cs
@ -14,6 +14,6 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
    public partial class TestSceneHitCirclePlacementBlueprint : PlacementBlueprintTestScene
    {
        protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableHitCircle((HitCircle)hitObject);
-        protected override PlacementBlueprint CreateBlueprint() => new HitCirclePlacementBlueprint();
+        protected override HitObjectPlacementBlueprint CreateBlueprint() => new HitCirclePlacementBlueprint();
    }
 }
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuEditorGrids.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuEditorGrids.cs
@ -9,6 +9,7 @@ using osu.Framework.Utils;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Osu.Edit;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles;
+using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Screens.Edit.Compose.Components;
 using osu.Game.Tests.Visual;
 using osu.Game.Utils;
@ -129,6 +130,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor

        private void gridActive<T>(bool active) where T : PositionSnapGrid
        {
+            AddAssert($"grid type is {typeof(T).Name}", () => this.ChildrenOfType<T>().Any());
            AddStep("choose placement tool", () => InputManager.Key(Key.Number2));
            AddStep("move cursor to spacing + (1, 1)", () =>
            {
@ -161,7 +163,8 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
            return grid switch
            {
                RectangularPositionSnapGrid rectangular => rectangular.StartPosition.Value + GeometryUtils.RotateVector(rectangular.Spacing.Value, -rectangular.GridLineRotation.Value),
-                TriangularPositionSnapGrid triangular => triangular.StartPosition.Value + GeometryUtils.RotateVector(new Vector2(triangular.Spacing.Value / 2, triangular.Spacing.Value / 2 * MathF.Sqrt(3)), -triangular.GridLineRotation.Value),
+                TriangularPositionSnapGrid triangular => triangular.StartPosition.Value + GeometryUtils.RotateVector(
+                    new Vector2(triangular.Spacing.Value / 2, triangular.Spacing.Value / 2 * MathF.Sqrt(3)), -triangular.GridLineRotation.Value),
                CircularPositionSnapGrid circular => circular.StartPosition.Value + GeometryUtils.RotateVector(new Vector2(circular.Spacing.Value, 0), -45),
                _ => Vector2.Zero
            };
@ -170,7 +173,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
        [Test]
        public void TestGridSizeToggling()
        {
-            AddStep("enable rectangular grid", () => InputManager.Key(Key.T));
+            AddStep("enable rectangular grid", () => InputManager.Key(Key.Y));
            AddUntilStep("rectangular grid visible", () => this.ChildrenOfType<RectangularPositionSnapGrid>().Any());
            gridSizeIs(4);

@ -189,5 +192,97 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
        private void gridSizeIs(int size)
            => AddAssert($"grid size is {size}", () => this.ChildrenOfType<RectangularPositionSnapGrid>().Single().Spacing.Value == new Vector2(size)
                                                       && EditorBeatmap.GridSize == size);
+
+        [Test]
+        public void TestGridTypeToggling()
+        {
+            AddStep("enable rectangular grid", () => InputManager.Key(Key.T));
+            AddUntilStep("rectangular grid visible", () => this.ChildrenOfType<RectangularPositionSnapGrid>().Any());
+            gridActive<RectangularPositionSnapGrid>(true);
+
+            nextGridTypeIs<TriangularPositionSnapGrid>();
+            nextGridTypeIs<CircularPositionSnapGrid>();
+            nextGridTypeIs<RectangularPositionSnapGrid>();
+        }
+
+        private void nextGridTypeIs<T>() where T : PositionSnapGrid
+        {
+            AddStep("toggle to next grid type", () =>
+            {
+                InputManager.PressKey(Key.ShiftLeft);
+                InputManager.Key(Key.G);
+                InputManager.ReleaseKey(Key.ShiftLeft);
+            });
+            gridActive<T>(true);
+        }
+
+        [Test]
+        public void TestGridPlacementTool()
+        {
+            AddStep("enable rectangular grid", () => InputManager.Key(Key.T));
+
+            AddStep("start grid placement", () => InputManager.Key(Key.Number5));
+            AddStep("move cursor to slider head + (1, 1)", () =>
+            {
+                var composer = Editor.ChildrenOfType<RectangularPositionSnapGrid>().Single();
+                InputManager.MoveMouseTo(composer.ToScreenSpace(((Slider)EditorBeatmap.HitObjects.First()).Position + new Vector2(1, 1)));
+            });
+            AddStep("left click", () => InputManager.Click(MouseButton.Left));
+            AddStep("move cursor to slider tail + (1, 1)", () =>
+            {
+                var composer = Editor.ChildrenOfType<RectangularPositionSnapGrid>().Single();
+                InputManager.MoveMouseTo(composer.ToScreenSpace(((Slider)EditorBeatmap.HitObjects.First()).EndPosition + new Vector2(1, 1)));
+            });
+            AddStep("left click", () => InputManager.Click(MouseButton.Left));
+
+            gridActive<RectangularPositionSnapGrid>(true);
+            AddAssert("grid position at slider head", () =>
+            {
+                var composer = Editor.ChildrenOfType<RectangularPositionSnapGrid>().Single();
+                return Precision.AlmostEquals(((Slider)EditorBeatmap.HitObjects.First()).Position, composer.StartPosition.Value);
+            });
+            AddAssert("grid spacing is distance to slider tail", () =>
+            {
+                var composer = Editor.ChildrenOfType<RectangularPositionSnapGrid>().Single();
+                return Precision.AlmostEquals(composer.Spacing.Value.X, 32.05, 0.01)
+                       && Precision.AlmostEquals(composer.Spacing.Value.X, composer.Spacing.Value.Y);
+            });
+            AddAssert("grid rotation points to slider tail", () =>
+            {
+                var composer = Editor.ChildrenOfType<RectangularPositionSnapGrid>().Single();
+                return Precision.AlmostEquals(composer.GridLineRotation.Value, 0.09, 0.01);
+            });
+
+            AddStep("start grid placement", () => InputManager.Key(Key.Number5));
+            AddStep("move cursor to slider tail + (1, 1)", () =>
+            {
+                var composer = Editor.ChildrenOfType<RectangularPositionSnapGrid>().Single();
+                InputManager.MoveMouseTo(composer.ToScreenSpace(((Slider)EditorBeatmap.HitObjects.First()).EndPosition + new Vector2(1, 1)));
+            });
+            AddStep("double click", () =>
+            {
+                InputManager.Click(MouseButton.Left);
+                InputManager.Click(MouseButton.Left);
+            });
+            AddStep("move cursor to (0, 0)", () =>
+            {
+                var composer = Editor.ChildrenOfType<RectangularPositionSnapGrid>().Single();
+                InputManager.MoveMouseTo(composer.ToScreenSpace(Vector2.Zero));
+            });
+
+            gridActive<RectangularPositionSnapGrid>(true);
+            AddAssert("grid position at slider tail", () =>
+            {
+                var composer = Editor.ChildrenOfType<RectangularPositionSnapGrid>().Single();
+                return Precision.AlmostEquals(((Slider)EditorBeatmap.HitObjects.First()).EndPosition, composer.StartPosition.Value);
+            });
+            AddAssert("grid spacing and rotation unchanged", () =>
+            {
+                var composer = Editor.ChildrenOfType<RectangularPositionSnapGrid>().Single();
+                return Precision.AlmostEquals(composer.Spacing.Value.X, 32.05, 0.01)
+                       && Precision.AlmostEquals(composer.Spacing.Value.X, composer.Spacing.Value.Y)
+                       && Precision.AlmostEquals(composer.GridLineRotation.Value, 0.09, 0.01);
+            });
+        }
    }
 }
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestScenePreciseRotation.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestScenePreciseRotation.cs
@ -116,7 +116,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                () => EditorBeatmap.HitObjects.OfType<HitCircle>().ElementAt(1).Position,
                () => Is.EqualTo(OsuPlayfield.BASE_SIZE - new Vector2(200)));

-            AddStep("change rotation origin", () => getPopover().ChildrenOfType<EditorRadioButton>().ElementAt(1).TriggerClick());
+            AddStep("change rotation origin", () => getPopover().ChildrenOfType<EditorRadioButton>().ElementAt(2).TriggerClick());
            AddAssert("first object rotated 90deg around selection centre",
                () => EditorBeatmap.HitObjects.OfType<HitCircle>().ElementAt(0).Position, () => Is.EqualTo(new Vector2(200, 200)));
            AddAssert("second object rotated 90deg around selection centre",
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderDrawing.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderDrawing.cs
@ -0,0 +1,150 @@
+// 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.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Input;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Edit.Components.RadioButtons;
+using osu.Game.Screens.Edit.Compose.Components;
+using osu.Game.Tests.Beatmaps;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Osu.Tests.Editor
+{
+    [TestFixture]
+    public partial class TestSceneSliderDrawing : TestSceneOsuEditor
+    {
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new TestBeatmap(ruleset, false);
+
+        [Test]
+        public void TestTouchInputPlaceHitCircleDirectly()
+        {
+            AddStep("tap circle", () => tap(this.ChildrenOfType<EditorRadioButton>().Single(b => b.Button.Label == "HitCircle")));
+
+            AddStep("tap to place circle", () => tap(this.ChildrenOfType<Playfield>().Single()));
+            AddAssert("circle placed correctly", () =>
+            {
+                var circle = (HitCircle)EditorBeatmap.HitObjects.Single(h => h.StartTime == EditorClock.CurrentTimeAccurate);
+                Assert.Multiple(() =>
+                {
+                    Assert.That(circle.Position.X, Is.EqualTo(256f).Within(0.01f));
+                    Assert.That(circle.Position.Y, Is.EqualTo(192f).Within(0.01f));
+                });
+
+                return true;
+            });
+        }
+
+        [Test]
+        public void TestTouchInputPlaceCircleAfterTouchingComposeArea()
+        {
+            AddStep("tap circle", () => tap(this.ChildrenOfType<EditorRadioButton>().Single(b => b.Button.Label == "HitCircle")));
+
+            AddStep("tap playfield", () => tap(this.ChildrenOfType<Playfield>().Single()));
+            AddAssert("circle placed", () => EditorBeatmap.HitObjects.Single(h => h.StartTime == EditorClock.CurrentTimeAccurate) is HitCircle);
+
+            AddStep("move forward", () => InputManager.Key(Key.Right));
+
+            AddStep("tap to place circle", () => tap(this.ChildrenOfType<Playfield>().Single()));
+            AddAssert("circle placed correctly", () =>
+            {
+                var circle = (HitCircle)EditorBeatmap.HitObjects.Single(h => h.StartTime == EditorClock.CurrentTimeAccurate);
+                Assert.Multiple(() =>
+                {
+                    Assert.That(circle.Position.X, Is.EqualTo(256f).Within(0.01f));
+                    Assert.That(circle.Position.Y, Is.EqualTo(192f).Within(0.01f));
+                });
+
+                return true;
+            });
+        }
+
+        [Test]
+        public void TestTouchInputPlaceSliderDirectly()
+        {
+            AddStep("tap slider", () => tap(this.ChildrenOfType<EditorRadioButton>().Single(b => b.Button.Label == "Slider")));
+
+            AddStep("hold to draw slider", () => InputManager.BeginTouch(new Touch(TouchSource.Touch1, this.ChildrenOfType<Playfield>().Single().ToScreenSpace(new Vector2(50, 20)))));
+            AddStep("drag to draw", () => InputManager.MoveTouchTo(new Touch(TouchSource.Touch1, this.ChildrenOfType<Playfield>().Single().ToScreenSpace(new Vector2(200, 50)))));
+            AddAssert("selection not initiated", () => this.ChildrenOfType<DragBox>().All(d => d.State == Visibility.Hidden));
+            AddAssert("blueprint visible", () => this.ChildrenOfType<SliderPlacementBlueprint>().Single().Alpha > 0);
+            AddStep("end", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, InputManager.CurrentState.Touch.GetTouchPosition(TouchSource.Touch1)!.Value)));
+            AddAssert("slider placed correctly", () =>
+            {
+                var slider = (Slider)EditorBeatmap.HitObjects.Single(h => h.StartTime == EditorClock.CurrentTimeAccurate);
+                Assert.Multiple(() =>
+                {
+                    Assert.That(slider.Position.X, Is.EqualTo(50f).Within(0.01f));
+                    Assert.That(slider.Position.Y, Is.EqualTo(20f).Within(0.01f));
+                    Assert.That(slider.Path.ControlPoints.Count, Is.EqualTo(2));
+                    Assert.That(slider.Path.ControlPoints[0].Position, Is.EqualTo(Vector2.Zero));
+
+                    // the final position may be slightly off from the mouse position when drawing, account for that.
+                    Assert.That(slider.Path.ControlPoints[1].Position.X, Is.EqualTo(150).Within(5));
+                    Assert.That(slider.Path.ControlPoints[1].Position.Y, Is.EqualTo(30).Within(5));
+                });
+
+                return true;
+            });
+        }
+
+        [Test]
+        public void TestTouchInputPlaceSliderAfterTouchingComposeArea()
+        {
+            AddStep("tap slider", () => tap(this.ChildrenOfType<EditorRadioButton>().Single(b => b.Button.Label == "Slider")));
+
+            AddStep("tap playfield", () => tap(this.ChildrenOfType<Playfield>().Single()));
+            AddStep("tap and hold another spot", () => hold(this.ChildrenOfType<Playfield>().Single(), new Vector2(50, 0)));
+            AddUntilStep("wait for slider placement", () => EditorBeatmap.HitObjects.SingleOrDefault(h => h.StartTime == EditorClock.CurrentTimeAccurate) is Slider);
+            AddStep("end", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, InputManager.CurrentState.Touch.GetTouchPosition(TouchSource.Touch1)!.Value)));
+
+            AddStep("move forward", () => InputManager.Key(Key.Right));
+
+            AddStep("hold to draw slider", () => InputManager.BeginTouch(new Touch(TouchSource.Touch1, this.ChildrenOfType<Playfield>().Single().ToScreenSpace(new Vector2(50, 20)))));
+            AddStep("drag to draw", () => InputManager.MoveTouchTo(new Touch(TouchSource.Touch1, this.ChildrenOfType<Playfield>().Single().ToScreenSpace(new Vector2(200, 50)))));
+            AddAssert("selection not initiated", () => this.ChildrenOfType<DragBox>().All(d => d.State == Visibility.Hidden));
+            AddAssert("blueprint visible", () => this.ChildrenOfType<SliderPlacementBlueprint>().Single().IsPresent);
+            AddStep("end", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, InputManager.CurrentState.Touch.GetTouchPosition(TouchSource.Touch1)!.Value)));
+            AddAssert("slider placed correctly", () =>
+            {
+                var slider = (Slider)EditorBeatmap.HitObjects.Single(h => h.StartTime == EditorClock.CurrentTimeAccurate);
+                Assert.Multiple(() =>
+                {
+                    Assert.That(slider.Position.X, Is.EqualTo(50f).Within(0.01f));
+                    Assert.That(slider.Position.Y, Is.EqualTo(20f).Within(0.01f));
+                    Assert.That(slider.Path.ControlPoints.Count, Is.EqualTo(2));
+                    Assert.That(slider.Path.ControlPoints[0].Position, Is.EqualTo(Vector2.Zero));
+
+                    // the final position may be slightly off from the mouse position when drawing, account for that.
+                    Assert.That(slider.Path.ControlPoints[1].Position.X, Is.EqualTo(150).Within(5));
+                    Assert.That(slider.Path.ControlPoints[1].Position.Y, Is.EqualTo(30).Within(5));
+                });
+
+                return true;
+            });
+        }
+
+        private void tap(Drawable drawable, Vector2 offset = default) => tap(drawable.ToScreenSpace(drawable.LayoutRectangle.Centre + offset));
+
+        private void tap(Vector2 position)
+        {
+            hold(position);
+            InputManager.EndTouch(new Touch(TouchSource.Touch1, position));
+        }
+
+        private void hold(Drawable drawable, Vector2 offset = default) => hold(drawable.ToScreenSpace(drawable.LayoutRectangle.Centre + offset));
+
+        private void hold(Vector2 position)
+        {
+            InputManager.BeginTouch(new Touch(TouchSource.Touch1, position));
+        }
+    }
+}
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderPlacementBlueprint.cs
@ -4,6 +4,7 @@
 using System;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Input;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Rulesets.Edit;
@ -392,6 +393,29 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
            assertFinalControlPointType(3, null);
        }

+        [Test]
+        public void TestSliderDrawingViaTouch()
+        {
+            Vector2 startPoint = new Vector2(200);
+
+            AddStep("move mouse to a random point", () => InputManager.MoveMouseTo(InputManager.ToScreenSpace(Vector2.Zero)));
+            AddStep("begin touch at start point", () => InputManager.BeginTouch(new Touch(TouchSource.Touch1, InputManager.ToScreenSpace(startPoint))));
+
+            for (int i = 1; i < 20; i++)
+                addTouchMovementStep(startPoint + new Vector2(i * 40, MathF.Sin(i * MathF.PI / 5) * 50));
+
+            AddStep("release touch at end point", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, InputManager.CurrentState.Touch.GetTouchPosition(TouchSource.Touch1)!.Value)));
+
+            assertPlaced(true);
+            assertLength(808, tolerance: 10);
+            assertControlPointCount(5);
+            assertFinalControlPointType(0, PathType.BSpline(4));
+            assertFinalControlPointType(1, null);
+            assertFinalControlPointType(2, null);
+            assertFinalControlPointType(3, null);
+            assertFinalControlPointType(4, null);
+        }
+
        [Test]
        public void TestPlacePerfectCurveSegmentAlmostLinearlyExterior()
        {
@ -492,6 +516,8 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor

        private void addMovementStep(Vector2 position) => AddStep($"move mouse to {position}", () => InputManager.MoveMouseTo(InputManager.ToScreenSpace(position)));

+        private void addTouchMovementStep(Vector2 position) => AddStep($"move touch1 to {position}", () => InputManager.MoveTouchTo(new Touch(TouchSource.Touch1, InputManager.ToScreenSpace(position))));
+
        private void addClickStep(MouseButton button)
        {
            AddStep($"click {button}", () => InputManager.Click(button));
@ -514,6 +540,6 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
        private Slider? getSlider() => HitObjectContainer.Count > 0 ? ((DrawableSlider)HitObjectContainer[0]).HitObject : null;

        protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableSlider((Slider)hitObject);
-        protected override PlacementBlueprint CreateBlueprint() => new SliderPlacementBlueprint();
+        protected override HitObjectPlacementBlueprint CreateBlueprint() => new SliderPlacementBlueprint();
    }
 }
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderSelectionBlueprint.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderSelectionBlueprint.cs
@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

-#nullable disable
-
 using NUnit.Framework;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
@ -22,9 +20,9 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
    public partial class TestSceneSliderSelectionBlueprint : SelectionBlueprintTestScene
    {
-        private Slider slider;
-        private DrawableSlider drawableObject;
-        private TestSliderBlueprint blueprint;
+        private Slider slider = null!;
+        private DrawableSlider drawableObject = null!;
+        private TestSliderBlueprint blueprint = null!;

        [SetUp]
        public void Setup() => Schedule(() =>
@ -218,6 +216,9 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor

            AddAssert("tail positioned correctly",
                () => Precision.AlmostEquals(blueprint.TailOverlay.CirclePiece.ScreenSpaceDrawQuad.Centre, drawableObject.TailCircle.ScreenSpaceDrawQuad.Centre));
+
+            AddAssert("end drag marker positioned correctly",
+                () => Precision.AlmostEquals(blueprint.TailOverlay.EndDragMarker!.ToScreenSpace(blueprint.TailOverlay.EndDragMarker.OriginPosition), drawableObject.TailCircle.ScreenSpaceDrawQuad.Centre, 2));
        }

        private void moveMouseToControlPoint(int index)
@ -230,14 +231,14 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
        }

        private void checkControlPointSelected(int index, bool selected)
-            => AddAssert($"control point {index} {(selected ? "selected" : "not selected")}", () => blueprint.ControlPointVisualiser.Pieces[index].IsSelected.Value == selected);
+            => AddAssert($"control point {index} {(selected ? "selected" : "not selected")}", () => blueprint.ControlPointVisualiser!.Pieces[index].IsSelected.Value == selected);

        private partial class TestSliderBlueprint : SliderSelectionBlueprint
        {
            public new SliderBodyPiece BodyPiece => base.BodyPiece;
            public new TestSliderCircleOverlay HeadOverlay => (TestSliderCircleOverlay)base.HeadOverlay;
            public new TestSliderCircleOverlay TailOverlay => (TestSliderCircleOverlay)base.TailOverlay;
-            public new PathControlPointVisualiser<Slider> ControlPointVisualiser => base.ControlPointVisualiser;
+            public new PathControlPointVisualiser<Slider>? ControlPointVisualiser => base.ControlPointVisualiser;

            public TestSliderBlueprint(Slider slider)
                : base(slider)
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderSplitting.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderSplitting.cs
@ -180,7 +180,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
            {
                if (slider == null) return;

-                sample = new HitSampleInfo("hitwhistle", HitSampleInfo.BANK_SOFT, volume: 70);
+                sample = new HitSampleInfo("hitwhistle", HitSampleInfo.BANK_SOFT, volume: 70, editorAutoBank: false);
                slider.Samples.Add(sample.With());
            });

--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSpinnerPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSpinnerPlacementBlueprint.cs
@ -15,6 +15,6 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
    {
        protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableSpinner((Spinner)hitObject);

-        protected override PlacementBlueprint CreateBlueprint() => new SpinnerPlacementBlueprint();
+        protected override HitObjectPlacementBlueprint CreateBlueprint() => new SpinnerPlacementBlueprint();
    }
 }
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneToolSwitching.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneToolSwitching.cs
@ -0,0 +1,55 @@
+// 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.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Tests.Visual;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Osu.Tests.Editor
+{
+    public partial class TestSceneToolSwitching : EditorTestScene
+    {
+        protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
+
+        [Test]
+        public void TestSliderAnchorMoveOperationEndsOnSwitchingTool()
+        {
+            var initialPosition = Vector2.Zero;
+
+            AddStep("store original anchor position", () => initialPosition = EditorBeatmap.HitObjects.OfType<Slider>().First().Path.ControlPoints.ElementAt(1).Position);
+            AddStep("select first slider", () => EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects.OfType<Slider>().First()));
+            AddStep("move to second anchor", () => InputManager.MoveMouseTo(this.ChildrenOfType<PathControlPointPiece<Slider>>().ElementAt(1)));
+            AddStep("start dragging", () => InputManager.PressButton(MouseButton.Left));
+            AddStep("drag away", () => InputManager.MoveMouseTo(InputManager.CurrentState.Mouse.Position + new Vector2(0, -200)));
+            AddStep("switch tool", () => InputManager.PressButton(MouseButton.Button1));
+            AddStep("undo", () => Editor.Undo());
+            AddAssert("anchor back at original position",
+                () => EditorBeatmap.HitObjects.OfType<Slider>().First().Path.ControlPoints.ElementAt(1).Position,
+                () => Is.EqualTo(initialPosition));
+        }
+
+        [Test]
+        public void TestSliderAnchorCreationOperationEndsOnSwitchingTool()
+        {
+            AddStep("select first slider", () => EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects.OfType<Slider>().First()));
+            AddStep("move to second anchor", () => InputManager.MoveMouseTo(this.ChildrenOfType<PathControlPointPiece<Slider>>().ElementAt(1), new Vector2(-50, 0)));
+            AddStep("quick-create anchor", () =>
+            {
+                InputManager.PressKey(Key.ControlLeft);
+                InputManager.PressButton(MouseButton.Left);
+                InputManager.ReleaseKey(Key.ControlLeft);
+            });
+            AddStep("drag away", () => InputManager.MoveMouseTo(InputManager.CurrentState.Mouse.Position + new Vector2(0, -200)));
+            AddStep("switch tool", () => InputManager.PressKey(Key.Number3));
+            AddStep("drag away further", () => InputManager.MoveMouseTo(InputManager.CurrentState.Mouse.Position + new Vector2(0, -200)));
+            AddStep("select first slider", () => EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects.OfType<Slider>().First()));
+            AddStep("undo", () => Editor.Undo());
+            AddAssert("slider has three anchors again", () => EditorBeatmap.HitObjects.OfType<Slider>().First().Path.ControlPoints, () => Has.Count.EqualTo(3));
+        }
+    }
+}
--- a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModAlternate.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModAlternate.cs
@ -23,7 +23,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
            Mod = new OsuModAlternate(),
            PassCondition = () => Player.ScoreProcessor.Combo.Value == 4,
            Autoplay = false,
-            Beatmap = new Beatmap
+            CreateBeatmap = () => new Beatmap
            {
                HitObjects = new List<HitObject>
                {
@ -68,7 +68,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
            Mod = new OsuModAlternate(),
            PassCondition = () => Player.ScoreProcessor.Combo.Value == 0 && Player.ScoreProcessor.HighestCombo.Value == 1,
            Autoplay = false,
-            Beatmap = new Beatmap
+            CreateBeatmap = () => new Beatmap
            {
                HitObjects = new List<HitObject>
                {
@ -101,7 +101,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
            Mod = new OsuModAlternate(),
            PassCondition = () => Player.ScoreProcessor.Combo.Value == 1,
            Autoplay = false,
-            Beatmap = new Beatmap
+            CreateBeatmap = () => new Beatmap
            {
                HitObjects = new List<HitObject>
                {
@ -131,7 +131,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
            Mod = new OsuModAlternate(),
            PassCondition = () => Player.ScoreProcessor.Combo.Value == 0 && Player.ScoreProcessor.HighestCombo.Value == 2,
            Autoplay = false,
-            Beatmap = new Beatmap
+            CreateBeatmap = () => new Beatmap
            {
                Breaks =
                {
--- a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModAutoplay.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModAutoplay.cs
@ -60,7 +60,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
            CreateModTest(new ModTestData
            {
                Autoplay = true,
-                Beatmap = new Beatmap
+                CreateBeatmap = () => new Beatmap
                {
                    HitObjects = new List<HitObject>
                    {
@ -90,7 +90,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
            {
                Autoplay = true,
                Mod = mod,
-                Beatmap = new Beatmap
+                CreateBeatmap = () => new Beatmap
                {
                    HitObjects =
                    {
--- a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModDifficultyAdjust.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModDifficultyAdjust.cs
@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
        public void TestNoAdjustment() => CreateModTest(new ModTestData
        {
            Mod = new OsuModDifficultyAdjust(),
-            Beatmap = new Beatmap
+            CreateBeatmap = () => new Beatmap
            {
                BeatmapInfo = new BeatmapInfo
                {
--- a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModFlashlight.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModFlashlight.cs
@ -68,7 +68,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
                        Player.GameplayClockContainer.CurrentTime < 1000 && Player.ChildrenOfType<ModFlashlight<OsuHitObject>.Flashlight>().Single().FlashlightDim > 0;
                    return Player.GameplayState.HasPassed && !sliderDimmedBeforeStartTime;
                },
-                Beatmap = new OsuBeatmap
+                CreateBeatmap = () => new OsuBeatmap
                {
                    HitObjects = new List<OsuHitObject>
                    {
@ -111,7 +111,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
                        Player.GameplayClockContainer.CurrentTime >= 1000 && Player.ChildrenOfType<ModFlashlight<OsuHitObject>.Flashlight>().Single().FlashlightDim > 0;
                    return Player.GameplayState.HasPassed && sliderDimmed;
                },
-                Beatmap = new OsuBeatmap
+                CreateBeatmap = () => new OsuBeatmap
                {
                    HitObjects = new List<OsuHitObject>
                    {
@ -150,7 +150,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
                        Player.GameplayClockContainer.CurrentTime >= 1000 && Player.ChildrenOfType<ModFlashlight<OsuHitObject>.Flashlight>().Single().FlashlightDim > 0;
                    return Player.GameplayState.HasPassed && sliderDimmed;
                },
-                Beatmap = new OsuBeatmap
+                CreateBeatmap = () => new OsuBeatmap
                {
                    HitObjects = new List<OsuHitObject>
                    {
--- a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModHidden.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModHidden.cs
@ -28,7 +28,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
        {
            Mod = new TestOsuModHidden(),
            Autoplay = true,
-            Beatmap = new Beatmap
+            CreateBeatmap = () => new Beatmap
            {
                HitObjects = new List<HitObject>
                {
@ -63,7 +63,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
        {
            Mod = new TestOsuModHidden(),
            Autoplay = true,
-            Beatmap = new Beatmap
+            CreateBeatmap = () => new Beatmap
            {
                HitObjects = new List<HitObject>
                {
@ -98,7 +98,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
        {
            Mod = new TestOsuModHidden(),
            Autoplay = true,
-            Beatmap = new Beatmap
+            CreateBeatmap = () => new Beatmap
            {
                HitObjects = new List<HitObject>
                {
@ -122,7 +122,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
        {
            Mod = new OsuModHidden { OnlyFadeApproachCircles = { Value = true } },
            Autoplay = true,
-            Beatmap = new Beatmap
+            CreateBeatmap = () => new Beatmap
            {
                HitObjects = new List<HitObject>
                {
--- a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModMirror.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModMirror.cs
@ -0,0 +1,64 @@
+// 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.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Osu.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests.Mods
+{
+    public partial class TestSceneOsuModMirror : OsuModTestScene
+    {
+        [Test]
+        public void TestCorrectReflections([Values] OsuModMirror.MirrorType type, [Values] bool withStrictTracking) => CreateModTest(new ModTestData
+        {
+            Autoplay = true,
+            CreateBeatmap = () => new OsuBeatmap
+            {
+                HitObjects =
+                {
+                    new Slider
+                    {
+                        Position = new Vector2(0),
+                        Path = new SliderPath
+                        {
+                            ControlPoints =
+                            {
+                                new PathControlPoint(),
+                                new PathControlPoint(new Vector2(100, 0))
+                            }
+                        },
+                        TickDistanceMultiplier = 0.5,
+                        RepeatCount = 1,
+                    }
+                }
+            },
+            Mods = withStrictTracking
+                ? [new OsuModMirror { Reflection = { Value = type } }, new OsuModStrictTracking()]
+                : [new OsuModMirror { Reflection = { Value = type } }],
+            PassCondition = () =>
+            {
+                var slider = this.ChildrenOfType<DrawableSlider>().SingleOrDefault();
+                var playfield = this.ChildrenOfType<OsuPlayfield>().Single();
+
+                if (slider == null)
+                    return false;
+
+                return Precision.AlmostEquals(playfield.ToLocalSpace(slider.HeadCircle.ScreenSpaceDrawQuad.Centre), slider.HitObject.Position)
+                       && Precision.AlmostEquals(playfield.ToLocalSpace(slider.TailCircle.ScreenSpaceDrawQuad.Centre), slider.HitObject.Position)
+                       && Precision.AlmostEquals(playfield.ToLocalSpace(slider.NestedHitObjects.OfType<DrawableSliderRepeat>().Single().ScreenSpaceDrawQuad.Centre),
+                           slider.HitObject.Position + slider.HitObject.Path.PositionAt(1))
+                       && Precision.AlmostEquals(playfield.ToLocalSpace(slider.NestedHitObjects.OfType<DrawableSliderTick>().First().ScreenSpaceDrawQuad.Centre),
+                           slider.HitObject.Position + slider.HitObject.Path.PositionAt(0.7f));
+            }
+        });
+    }
+}
--- a/Show More
+++ b/Show More