Merge branch 'master' into fix-rewind-bug

.editorconfig

@@ -191,6 +191,8 @@ csharp_style_prefer_index_operator = false:silent
 csharp_style_prefer_range_operator = false:silent
 csharp_style_prefer_switch_expression = false:none
 
+csharp_style_namespace_declarations = block_scoped:warning
+
 [*.{yaml,yml}]
 insert_final_newline = true
 indent_style = space

.github/ISSUE_TEMPLATE/config.yml

@@ -2,7 +2,7 @@ blank_issues_enabled: false
 contact_links:
     - name: Help
       url: https://github.com/ppy/osu/discussions/categories/q-a
-      about: osu! not working as you'd expect? Not sure it's a bug? Check the Q&A section!
+      about: osu! not working or performing as you'd expect? Not sure it's a bug? Check the Q&A section!
     - name: Suggestions or feature request
       url: https://github.com/ppy/osu/discussions/categories/ideas
       about: Got something you think should change or be added? Search for or start a new discussion!

.github/workflows/ci.yml

@@ -121,12 +121,24 @@ jobs:
 
   build-only-ios:
     name: Build only (iOS)
-    runs-on: macos-latest
+    # `macos-13` is required, because Xcode 14.3 is required (see below).
+    # TODO: can be changed to `macos-latest` once `macos-13` becomes latest (currently in beta)
+    runs-on: macos-13
     timeout-minutes: 60
     steps:
       - name: Checkout
         uses: actions/checkout@v3
 
+      # newest Microsoft.iOS.Sdk versions require Xcode 14.3.
+      # 14.3 is currently not the default Xcode version (https://github.com/actions/runner-images/blob/main/images/macos/macos-13-Readme.md#xcode),
+      # so set it manually.
+      # TODO: remove when 14.3 becomes the default Xcode version.
+      - name: Set Xcode version
+        shell: bash
+        run: |
+          sudo xcode-select -s "/Applications/Xcode_14.3.app"
+          echo "MD_APPLE_SDK_ROOT=/Applications/Xcode_14.3.app" >> $GITHUB_ENV
+
       - name: Install .NET 6.0.x
         uses: actions/setup-dotnet@v3
         with:

.github/workflows/update-web-mod-definitions.yml

@@ -0,0 +1,53 @@
+name: Update osu-web mod definitions
+on:
+  push:
+    tags:
+      - '*'
+
+permissions:
+  contents: read # to fetch code (actions/checkout)
+
+jobs:
+  update-mod-definitions:
+    name: Update osu-web mod definitions
+    runs-on: ubuntu-latest
+    steps:
+    - name: Install .NET 6.0.x
+      uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: "6.0.x"
+
+    - name: Checkout ppy/osu
+      uses: actions/checkout@v3
+      with:
+        path: osu
+
+    - name: Checkout ppy/osu-tools
+      uses: actions/checkout@v3
+      with:
+        repository: ppy/osu-tools
+        path: osu-tools
+
+    - name: Checkout ppy/osu-web
+      uses: actions/checkout@v3
+      with:
+        repository: ppy/osu-web
+        path: osu-web
+
+    - name: Setup local game checkout for tools
+      run: ./UseLocalOsu.sh
+      working-directory: ./osu-tools
+
+    - name: Regenerate mod definitions
+      run: dotnet run --project PerformanceCalculator -- mods > ../osu-web/database/mods.json
+      working-directory: ./osu-tools
+
+    - name: Create pull request with changes
+      uses: peter-evans/create-pull-request@v5
+      with:
+        title: Update mod definitions
+        body: "This PR has been auto-generated to update the mod definitions to match ppy/osu@${{ github.ref_name }}."
+        branch: update-mod-definitions
+        commit-message: Update mod definitions
+        path: osu-web
+        token: ${{ secrets.OSU_WEB_PULL_REQUEST_PAT }}

README.md

@@ -16,21 +16,20 @@ The future of [osu!](https://osu.ppy.sh) and the beginning of an open era! Curre
 
 ## Status
 
-This project is under heavy development, but is in a stable state. Users are encouraged to try it out and keep it installed alongside the stable *osu!* client. It will continue to evolve to the point of eventually replacing the existing stable client as an update.
+This project is under constant development, but we aim to keep things in a stable state. Users are encouraged to try it out and keep it installed alongside the stable *osu!* client. It will continue to evolve to the point of eventually replacing the existing stable client as an update.
 
-**IMPORTANT:** Gameplay mechanics (and other features which you may have come to know and love) are in a constant state of flux. Game balance and final quality-of-life passes come at the end of development, preceded by experimentation and changes which may potentially **reduce playability or usability**. This is done in order to allow us to move forward as developers and designers more efficiently. If this offends you, please consider sticking to the stable releases of osu! (found on the website). We are not yet open to heated discussion over game mechanics and will not be using github as a forum for such discussions just yet.
+**IMPORTANT:** Gameplay mechanics (and other features which you may have come to know and love) are in a constant state of flux. Game balance and final quality-of-life passes come at the end of development, preceded by experimentation and changes which may potentially **reduce playability or usability**. This is done in order to allow us to move forward as developers and designers more efficiently. If this offends you, please consider sticking to a [stable release](https://osu.ppy.sh/home/download) of osu!. We are not yet open to heated discussion over game mechanics and will not be using github as a forum for such discussions just yet.
 
 We are accepting bug reports (please report with as much detail as possible and follow the existing issue templates). Feature requests are also welcome, but understand that our focus is on completing the game to feature parity before adding new features. A few resources are available as starting points to getting involved and understanding the project:
 
 - Detailed release changelogs are available on the [official osu! site](https://osu.ppy.sh/home/changelog/lazer).
 - You can learn more about our approach to [project management](https://github.com/ppy/osu/wiki/Project-management).
-- Read peppy's [blog post](https://blog.ppy.sh/a-definitive-lazer-faq/) exploring where the project is currently and the roadmap going forward.
 
 ## Running osu!
 
-If you are looking to install or test osu! without setting up a development environment, you can consume our [binary releases](https://github.com/ppy/osu/releases). Handy links below will download the latest version for your operating system of choice:
+If you are looking to install or test osu! without setting up a development environment, you can consume our [releases](https://github.com/ppy/osu/releases). You can also generally download a version for your current device from the [osu! site](https://osu.ppy.sh/home/download). Failing that, you may use the links below to download the latest version for your operating system of choice:
 
-**Latest build:**
+**Latest release:**
 
 | [Windows 8.1+ (x64)](https://github.com/ppy/osu/releases/latest/download/install.exe) | macOS 10.15+ ([Intel](https://github.com/ppy/osu/releases/latest/download/osu.app.Intel.zip), [Apple Silicon](https://github.com/ppy/osu/releases/latest/download/osu.app.Apple.Silicon.zip)) | [Linux (x64)](https://github.com/ppy/osu/releases/latest/download/osu.AppImage) | [iOS 13.4+](https://osu.ppy.sh/home/testflight) | [Android 5+](https://github.com/ppy/osu/releases/latest/download/sh.ppy.osulazer.apk) |
 | ------------- | ------------- | ------------- | ------------- | ------------- |
@@ -50,9 +49,8 @@ You can see some examples of custom rulesets by visiting the [custom ruleset dir
 Please make sure you have the following prerequisites:
 
 - A desktop platform with the [.NET 6.0 SDK](https://dotnet.microsoft.com/download) installed.
-- When developing with mobile, [Xamarin](https://docs.microsoft.com/en-us/xamarin/) is required, which is shipped together with Visual Studio or [Visual Studio for Mac](https://visualstudio.microsoft.com/vs/mac/).
-- 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/).
-- When running on Linux, please have a system-wide FFmpeg installation available to support video decoding.
+
+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/).
 
 ### Downloading the source code
 
@@ -89,7 +87,29 @@ _Due to a historical feature gap between .NET Core and Xamarin, running `dotnet`
 
 ### Testing with resource/framework modifications
 
-Sometimes it may be necessary to cross-test changes in [osu-resources](https://github.com/ppy/osu-resources) or [osu-framework](https://github.com/ppy/osu-framework). This can be achieved by running some commands as documented on the [osu-resources](https://github.com/ppy/osu-resources/wiki/Testing-local-resources-checkout-with-other-projects) and [osu-framework](https://github.com/ppy/osu-framework/wiki/Testing-local-framework-checkout-with-other-projects) wiki pages.
+Sometimes it may be necessary to cross-test changes in [osu-resources](https://github.com/ppy/osu-resources) or [osu-framework](https://github.com/ppy/osu-framework). This can be quickly achieved using included commands:
+
+Windows:
+
+```ps
+UseLocalFramework.ps1
+UseLocalResources.ps1
+```
+
+macOS / Linux:
+
+```ps
+UseLocalFramework.sh
+UseLocalResources.sh
+```
+
+Note that these commands assume you have the relevant project(s) checked out in adjacent directories:
+
+```
+|- osu            // this repository
+|- osu-framework
+|- osu-resources
+```
 
 ### Code analysis
 

Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon/Objects/Drawables/DrawablePippidonHitObject.cs

@@ -8,7 +8,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Audio;
-using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
 using osuTK;
@@ -44,7 +43,7 @@ namespace osu.Game.Rulesets.Pippidon.Objects.Drawables
 
         public override IEnumerable<HitSampleInfo> GetSamples() => new[]
         {
-            new HitSampleInfo(HitSampleInfo.HIT_NORMAL, SampleControlPoint.DEFAULT_BANK)
+            new HitSampleInfo(HitSampleInfo.HIT_NORMAL)
         };
 
         protected override void CheckForResult(bool userTriggered, double timeOffset)

Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/Objects/Drawables/DrawablePippidonHitObject.cs

@@ -8,7 +8,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Audio;
-using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Pippidon.UI;
 using osu.Game.Rulesets.Scoring;
@@ -44,7 +43,7 @@ namespace osu.Game.Rulesets.Pippidon.Objects.Drawables
 
         public override IEnumerable<HitSampleInfo> GetSamples() => new[]
         {
-            new HitSampleInfo(HitSampleInfo.HIT_NORMAL, SampleControlPoint.DEFAULT_BANK)
+            new HitSampleInfo(HitSampleInfo.HIT_NORMAL)
         };
 
         protected override void CheckForResult(bool userTriggered, double timeOffset)

global.json

@@ -0,0 +1,7 @@
+{
+  "sdk": {
+    "version": "6.0.100",
+    "rollForward": "latestFeature"
+  }
+}
+

osu.Android.props

@@ -11,7 +11,7 @@
     <AndroidManifestMerger>manifestmerger.jar</AndroidManifestMerger>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2023.418.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2023.608.0" />
   </ItemGroup>
   <ItemGroup>
     <AndroidManifestOverlay Include="$(MSBuildThisFileDirectory)osu.Android\Properties\AndroidManifestOverlay.xml" />

osu.Desktop/Updater/SquirrelUpdateManager.cs

@@ -9,6 +9,7 @@ using osu.Framework.Logging;
 using osu.Game;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
+using osu.Game.Screens.Play;
 using Squirrel;
 using Squirrel.SimpleSplat;
 using LogLevel = Squirrel.SimpleSplat.LogLevel;
@@ -36,6 +37,9 @@ namespace osu.Desktop.Updater
         [Resolved]
         private OsuGameBase game { get; set; } = null!;
 
+        [Resolved]
+        private ILocalUserPlayInfo? localUserInfo { get; set; }
+
         [BackgroundDependencyLoader]
         private void load(INotificationOverlay notifications)
         {
@@ -55,6 +59,10 @@ namespace osu.Desktop.Updater
 
             try
             {
+                // Avoid any kind of update checking while gameplay is running.
+                if (localUserInfo?.IsPlaying.Value == true)
+                    return false;
+
                 updateManager ??= new GithubUpdateManager(@"https://github.com/ppy/osu", false, github_token, @"osulazer");
 
                 var info = await updateManager.CheckForUpdate(!useDeltaPatching).ConfigureAwait(false);

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

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

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

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

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

@@ -45,7 +45,7 @@ namespace osu.Game.Rulesets.Catch.Tests
                     NewCombo = i % 8 == 0,
                     Samples = new List<HitSampleInfo>(new[]
                     {
-                        new HitSampleInfo(HitSampleInfo.HIT_NORMAL, "normal", volume: 100)
+                        new HitSampleInfo(HitSampleInfo.HIT_NORMAL)
                     })
                 });
             }

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

@@ -26,6 +26,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
             var xPositionData = obj as IHasXPosition;
             var yPositionData = obj as IHasYPosition;
             var comboData = obj as IHasCombo;
+            var sliderVelocityData = obj as IHasSliderVelocity;
 
             switch (obj)
             {
@@ -41,7 +42,8 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                         NewCombo = comboData?.NewCombo ?? false,
                         ComboOffset = comboData?.ComboOffset ?? 0,
                         LegacyLastTickOffset = (obj as IHasLegacyLastTickOffset)?.LegacyLastTickOffset ?? 0,
-                        LegacyConvertedY = yPositionData?.Y ?? CatchHitObject.DEFAULT_LEGACY_CONVERT_Y
+                        LegacyConvertedY = yPositionData?.Y ?? CatchHitObject.DEFAULT_LEGACY_CONVERT_Y,
+                        SliderVelocity = sliderVelocityData?.SliderVelocity ?? 1
                     }.Yield();
 
                 case IHasDuration endTime:

osu.Game.Rulesets.Catch/Edit/Blueprints/BananaShowerPlacementBlueprint.cs

@@ -17,6 +17,8 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
         private double placementStartTime;
         private double placementEndTime;
 
+        protected override bool IsValidForPlacement => HitObject.Duration > 0;
+
         public BananaShowerPlacementBlueprint()
         {
             InternalChild = outline = new TimeSpanOutline();
@@ -49,7 +51,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
                 case PlacementState.Active:
                     if (e.Button != MouseButton.Right) break;
 
-                    EndPlacement(HitObject.Duration > 0);
+                    EndPlacement(true);
                     return true;
             }
 

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

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

osu.Game.Rulesets.Catch/Edit/Blueprints/JuiceStreamPlacementBlueprint.cs

@@ -24,6 +24,8 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
 
         private InputManager inputManager = null!;
 
+        protected override bool IsValidForPlacement => HitObject.Duration > 0;
+
         public JuiceStreamPlacementBlueprint()
         {
             InternalChildren = new Drawable[]
@@ -70,7 +72,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
                             return true;
 
                         case MouseButton.Right:
-                            EndPlacement(HitObject.Duration > 0);
+                            EndPlacement(true);
                             return true;
                     }
 

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

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

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

@@ -33,6 +33,8 @@ namespace osu.Game.Rulesets.Catch.Edit
 
         private InputManager inputManager = null!;
 
+        private CatchBeatSnapGrid beatSnapGrid = null!;
+
         private readonly BindableDouble timeRangeMultiplier = new BindableDouble(1)
         {
             MinValue = 1,
@@ -65,6 +67,8 @@ namespace osu.Game.Rulesets.Catch.Edit
                 Catcher.BASE_DASH_SPEED, -Catcher.BASE_DASH_SPEED,
                 Catcher.BASE_WALK_SPEED, -Catcher.BASE_WALK_SPEED,
             }));
+
+            AddInternal(beatSnapGrid = new CatchBeatSnapGrid());
         }
 
         protected override void LoadComplete()
@@ -74,6 +78,29 @@ namespace osu.Game.Rulesets.Catch.Edit
             inputManager = GetContainingInputManager();
         }
 
+        protected override void UpdateAfterChildren()
+        {
+            base.UpdateAfterChildren();
+
+            if (BlueprintContainer.CurrentTool is SelectTool)
+            {
+                if (EditorBeatmap.SelectedHitObjects.Any())
+                {
+                    beatSnapGrid.SelectionTimeRange = (EditorBeatmap.SelectedHitObjects.Min(h => h.StartTime), EditorBeatmap.SelectedHitObjects.Max(h => h.GetEndTime()));
+                }
+                else
+                    beatSnapGrid.SelectionTimeRange = null;
+            }
+            else
+            {
+                var result = FindSnappedPositionAndTime(inputManager.CurrentState.Mouse.Position);
+                if (result.Time is double time)
+                    beatSnapGrid.SelectionTimeRange = (time, time);
+                else
+                    beatSnapGrid.SelectionTimeRange = null;
+            }
+        }
+
         protected override double ReadCurrentDistanceSnap(HitObject before, HitObject after)
         {
             // osu!catch's distance snap implementation is limited, in that a custom spacing cannot be specified.
@@ -132,7 +159,7 @@ namespace osu.Game.Rulesets.Catch.Edit
 
             result.ScreenSpacePosition.X = screenSpacePosition.X;
 
-            if (snapType.HasFlagFast(SnapType.Grids))
+            if (snapType.HasFlagFast(SnapType.RelativeGrids))
             {
                 if (distanceSnapGrid.IsPresent && distanceSnapGrid.GetSnappedPosition(result.ScreenSpacePosition) is SnapResult snapResult &&
                     Vector2.Distance(snapResult.ScreenSpacePosition, result.ScreenSpacePosition) < distance_snap_radius)

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

@@ -22,11 +22,11 @@ namespace osu.Game.Rulesets.Catch.Objects
 
         public override Judgement CreateJudgement() => new CatchBananaJudgement();
 
-        private static readonly List<HitSampleInfo> samples = new List<HitSampleInfo> { new BananaHitSampleInfo() };
+        private static readonly IList<HitSampleInfo> default_banana_samples = new List<HitSampleInfo> { new BananaHitSampleInfo() }.AsReadOnly();
 
         public Banana()
         {
-            Samples = samples;
+            Samples = default_banana_samples;
         }
 
         // override any external colour changes with banananana
@@ -47,18 +47,18 @@ namespace osu.Game.Rulesets.Catch.Objects
             }
         }
 
-        private class BananaHitSampleInfo : HitSampleInfo, IEquatable<BananaHitSampleInfo>
+        public class BananaHitSampleInfo : HitSampleInfo, IEquatable<BananaHitSampleInfo>
         {
             private static readonly string[] lookup_names = { "Gameplay/metronomelow", "Gameplay/catch-banana" };
 
             public override IEnumerable<string> LookupNames => lookup_names;
 
-            public BananaHitSampleInfo(int volume = 0)
+            public BananaHitSampleInfo(int volume = 100)
                 : base(string.Empty, volume: volume)
             {
             }
 
-            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)
                 => new BananaHitSampleInfo(newVolume.GetOr(Volume));
 
             public bool Equals(BananaHitSampleInfo? other)

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

@@ -1,7 +1,9 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
 using System.Threading;
+using osu.Game.Audio;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Types;
 
@@ -39,6 +41,7 @@ namespace osu.Game.Rulesets.Catch.Objects
                 {
                     StartTime = time,
                     BananaIndex = i,
+                    Samples = new List<HitSampleInfo> { new Banana.BananaHitSampleInfo(CreateHitSampleInfo().Volume) }
                 });
 
                 time += spacing;

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

@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using Newtonsoft.Json;
+using osu.Framework.Bindables;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
@@ -16,7 +17,7 @@ using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Rulesets.Catch.Objects
 {
-    public class JuiceStream : CatchHitObject, IHasPathWithRepeats
+    public class JuiceStream : CatchHitObject, IHasPathWithRepeats, IHasSliderVelocity
     {
         /// <summary>
         /// Positional distance that results in a duration of one second, before any speed adjustments.
@@ -27,6 +28,19 @@ namespace osu.Game.Rulesets.Catch.Objects
 
         public int RepeatCount { get; set; }
 
+        public BindableNumber<double> SliderVelocityBindable { get; } = new BindableDouble(1)
+        {
+            Precision = 0.01,
+            MinValue = 0.1,
+            MaxValue = 10
+        };
+
+        public double SliderVelocity
+        {
+            get => SliderVelocityBindable.Value;
+            set => SliderVelocityBindable.Value = value;
+        }
+
         [JsonIgnore]
         private double velocityFactor;
 
@@ -34,10 +48,10 @@ namespace osu.Game.Rulesets.Catch.Objects
         private double tickDistanceFactor;
 
         [JsonIgnore]
-        public double Velocity => velocityFactor * DifficultyControlPoint.SliderVelocity;
+        public double Velocity => velocityFactor * SliderVelocity;
 
         [JsonIgnore]
-        public double TickDistance => tickDistanceFactor * DifficultyControlPoint.SliderVelocity;
+        public double TickDistance => tickDistanceFactor * SliderVelocity;
 
         /// <summary>
         /// The length of one span of this <see cref="JuiceStream"/>.

osu.Game.Rulesets.Catch/Scoring/CatchScoreProcessor.cs

@@ -1,17 +1,30 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Catch.Scoring
 {
     public partial class CatchScoreProcessor : ScoreProcessor
     {
+        private const int combo_cap = 200;
+        private const double combo_base = 4;
+
         public CatchScoreProcessor()
             : base(new CatchRuleset())
         {
         }
 
-        protected override double ClassicScoreMultiplier => 28;
+        protected override double ComputeTotalScore(double comboProgress, double accuracyProgress, double bonusPortion)
+        {
+            return 600000 * comboProgress
+                   + 400000 * Accuracy.Value * accuracyProgress
+                   + bonusPortion;
+        }
+
+        protected override double GetComboScoreChange(JudgementResult result)
+            => Judgement.ToNumericResult(result.Type) * Math.Min(Math.Max(0.5, Math.Log(result.ComboAfterJudgement, combo_base)), Math.Log(combo_cap, combo_base));
     }
 }

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

@@ -3,6 +3,7 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
@@ -41,6 +42,8 @@ namespace osu.Game.Rulesets.Catch.UI
 
         internal CatcherArea CatcherArea { get; private set; } = null!;
 
+        public Container UnderlayElements { get; private set; } = null!;
+
         private readonly IBeatmapDifficultyInfo difficulty;
 
         public CatchPlayfield(IBeatmapDifficultyInfo difficulty)
@@ -62,6 +65,10 @@ namespace osu.Game.Rulesets.Catch.UI
 
             AddRangeInternal(new[]
             {
+                UnderlayElements = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                },
                 droppedObjectContainer,
                 Catcher.CreateProxiedContent(),
                 HitObjectContainer.CreateProxy(),

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

@@ -418,10 +418,13 @@ namespace osu.Game.Rulesets.Catch.UI
 
         private void clearPlate(DroppedObjectAnimation animation)
         {
-            var droppedObjects = caughtObjectContainer.Children.Select(getDroppedObject).ToArray();
+            var caughtObjects = caughtObjectContainer.Children.ToArray();
 
             caughtObjectContainer.Clear(false);
 
+            // Use the already returned PoolableDrawables for new objects
+            var droppedObjects = caughtObjects.Select(getDroppedObject).ToArray();
+
             droppedObjectTarget.AddRange(droppedObjects);
 
             foreach (var droppedObject in droppedObjects)
@@ -430,10 +433,10 @@ namespace osu.Game.Rulesets.Catch.UI
 
         private void removeFromPlate(CaughtObject caughtObject, DroppedObjectAnimation animation)
         {
-            var droppedObject = getDroppedObject(caughtObject);
-
             caughtObjectContainer.Remove(caughtObject, false);
 
+            var droppedObject = getDroppedObject(caughtObject);
+
             droppedObjectTarget.Add(droppedObject);
 
             applyDropAnimation(droppedObject, animation);
@@ -456,6 +459,8 @@ namespace osu.Game.Rulesets.Catch.UI
                     break;
             }
 
+            // Define lifetime start for dropped objects to be disposed correctly when rewinding replay
+            d.LifetimeStart = Clock.CurrentTime;
             d.Expire();
         }
 

osu.Game.Rulesets.Mania.Tests/TestSceneHoldNoteInput.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 System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
@@ -40,7 +38,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         private const double time_tail = 4000;
         private const double time_after_tail = 5250;
 
-        private List<JudgementResult> judgementResults;
+        private List<JudgementResult> judgementResults = new List<JudgementResult>();
 
         /// <summary>
         ///     -----[           ]-----
@@ -61,6 +59,44 @@ namespace osu.Game.Rulesets.Mania.Tests
             assertNoteJudgement(HitResult.IgnoreMiss);
         }
 
+        /// <summary>
+        ///     -----[           ]-----
+        ///          x           o
+        /// </summary>
+        [Test]
+        public void TestCorrectInput()
+        {
+            performTest(new List<ReplayFrame>
+            {
+                new ManiaReplayFrame(time_head, ManiaAction.Key1),
+                new ManiaReplayFrame(time_tail),
+            });
+
+            assertHeadJudgement(HitResult.Perfect);
+            assertTickJudgement(HitResult.LargeTickHit);
+            assertTailJudgement(HitResult.Perfect);
+            assertNoteJudgement(HitResult.IgnoreHit);
+        }
+
+        /// <summary>
+        ///     -----[           ]-----
+        ///          x                   o
+        /// </summary>
+        [Test]
+        public void TestLateRelease()
+        {
+            performTest(new List<ReplayFrame>
+            {
+                new ManiaReplayFrame(time_head, ManiaAction.Key1),
+                new ManiaReplayFrame(time_after_tail),
+            });
+
+            assertHeadJudgement(HitResult.Perfect);
+            assertTickJudgement(HitResult.LargeTickHit);
+            assertTailJudgement(HitResult.Miss);
+            assertNoteJudgement(HitResult.IgnoreMiss);
+        }
+
         /// <summary>
         ///     -----[           ]-----
         ///  x                           o
@@ -521,9 +557,9 @@ namespace osu.Game.Rulesets.Mania.Tests
         private void assertLastTickJudgement(HitResult result)
             => AddAssert($"last tick judged as {result}", () => judgementResults.Last(j => j.HitObject is HoldNoteTick).Type, () => Is.EqualTo(result));
 
-        private ScoreAccessibleReplayPlayer currentPlayer;
+        private ScoreAccessibleReplayPlayer currentPlayer = null!;
 
-        private void performTest(List<ReplayFrame> frames, Beatmap<ManiaHitObject> beatmap = null)
+        private void performTest(List<ReplayFrame> frames, Beatmap<ManiaHitObject>? beatmap = null)
         {
             if (beatmap == null)
             {
@@ -569,15 +605,13 @@ namespace osu.Game.Rulesets.Mania.Tests
             AddUntilStep("Beatmap at 0", () => Beatmap.Value.Track.CurrentTime == 0);
             AddUntilStep("Wait until player is loaded", () => currentPlayer.IsCurrentScreen());
 
-            AddUntilStep("Wait for completion", () => currentPlayer.ScoreProcessor?.HasCompleted.Value == true);
+            AddUntilStep("Wait for completion", () => currentPlayer.ScoreProcessor.HasCompleted.Value);
         }
 
         private partial class ScoreAccessibleReplayPlayer : ReplayPlayer
         {
             public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
 
-            public new GameplayClockContainer GameplayClockContainer => base.GameplayClockContainer;
-
             protected override bool PauseOnFocusLost => false;
 
             public ScoreAccessibleReplayPlayer(Score score)

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

@@ -14,7 +14,6 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Beatmaps.Formats;
 using osu.Game.Utils;
 
 namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
@@ -49,15 +48,14 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             Debug.Assert(distanceData != null);
 
             TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(hitObject.StartTime);
-            DifficultyControlPoint difficultyPoint = hitObject.DifficultyControlPoint;
 
             double beatLength;
-#pragma warning disable 618
-            if (difficultyPoint is LegacyBeatmapDecoder.LegacyDifficultyControlPoint legacyDifficultyPoint)
-#pragma warning restore 618
-                beatLength = timingPoint.BeatLength * legacyDifficultyPoint.BpmMultiplier;
+            if (hitObject.LegacyBpmMultiplier.HasValue)
+                beatLength = timingPoint.BeatLength * hitObject.LegacyBpmMultiplier.Value;
+            else if (hitObject is IHasSliderVelocity hasSliderVelocity)
+                beatLength = timingPoint.BeatLength / hasSliderVelocity.SliderVelocity;
             else
-                beatLength = timingPoint.BeatLength / difficultyPoint.SliderVelocity;
+                beatLength = timingPoint.BeatLength;
 
             SpanCount = repeatsData?.SpanCount() ?? 1;
             StartTime = (int)Math.Round(hitObject.StartTime);

osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs

@@ -21,18 +21,29 @@ namespace osu.Game.Rulesets.Mania.Configuration
         {
             base.InitialiseDefaults();
 
-            SetDefault(ManiaRulesetSetting.ScrollTime, 1500.0, DrawableManiaRuleset.MIN_TIME_RANGE, DrawableManiaRuleset.MAX_TIME_RANGE, 5);
+            SetDefault(ManiaRulesetSetting.ScrollSpeed, 8, 1, 40);
             SetDefault(ManiaRulesetSetting.ScrollDirection, ManiaScrollingDirection.Down);
             SetDefault(ManiaRulesetSetting.TimingBasedNoteColouring, false);
+
+#pragma warning disable CS0618
+            // Although obsolete, this is still required to populate the bindable from the database in case migration is required.
+            SetDefault<double?>(ManiaRulesetSetting.ScrollTime, null);
+
+            if (Get<double?>(ManiaRulesetSetting.ScrollTime) is double scrollTime)
+            {
+                SetValue(ManiaRulesetSetting.ScrollSpeed, (int)Math.Round(DrawableManiaRuleset.MAX_TIME_RANGE / scrollTime));
+                SetValue<double?>(ManiaRulesetSetting.ScrollTime, null);
+            }
+#pragma warning restore CS0618
         }
 
         public override TrackedSettings CreateTrackedSettings() => new TrackedSettings
         {
-            new TrackedSetting<double>(ManiaRulesetSetting.ScrollTime,
-                scrollTime => new SettingDescription(
-                    rawValue: scrollTime,
+            new TrackedSetting<int>(ManiaRulesetSetting.ScrollSpeed,
+                speed => new SettingDescription(
+                    rawValue: speed,
                     name: RulesetSettingsStrings.ScrollSpeed,
-                    value: RulesetSettingsStrings.ScrollSpeedTooltip(scrollTime, (int)Math.Round(DrawableManiaRuleset.MAX_TIME_RANGE / scrollTime))
+                    value: RulesetSettingsStrings.ScrollSpeedTooltip((int)DrawableManiaRuleset.ComputeScrollTime(speed), speed)
                 )
             )
         };
@@ -40,7 +51,9 @@ namespace osu.Game.Rulesets.Mania.Configuration
 
     public enum ManiaRulesetSetting
     {
+        [Obsolete("Use ScrollSpeed instead.")] // Can be removed 2023-11-30
         ScrollTime,
+        ScrollSpeed,
         ScrollDirection,
         TimingBasedNoteColouring
     }

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

@@ -25,6 +25,8 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
         [Resolved]
         private IScrollingInfo scrollingInfo { get; set; }
 
+        protected override bool IsValidForPlacement => HitObject.Duration > 0;
+
         public HoldNotePlacementBlueprint()
             : base(new HoldNote())
         {
@@ -75,7 +77,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
                 return;
 
             base.OnMouseUp(e);
-            EndPlacement(HitObject.Duration > 0);
+            EndPlacement(true);
         }
 
         private double originalStartTime;

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

@@ -129,7 +129,7 @@ namespace osu.Game.Rulesets.Mania.Edit
                 }
 
                 Color4 colour = BindableBeatDivisor.GetColourFor(
-                    BindableBeatDivisor.GetDivisorForBeatIndex(Math.Max(1, beat), beatDivisor.Value), colours);
+                    BindableBeatDivisor.GetDivisorForBeatIndex(beat, beatDivisor.Value), colours);
 
                 foreach (var grid in grids)
                 {

osu.Game.Rulesets.Mania/Edit/Setup/ManiaSetupSection.cs

@@ -27,7 +27,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Setup
                 specialStyle = new LabelledSwitchButton
                 {
                     Label = "Use special (N+1) style",
-                    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 5k (4+1) or 8key (7+1) configurations.",
+                    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.",
                     Current = { Value = Beatmap.BeatmapInfo.SpecialStyle }
                 }
             };

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -389,41 +389,23 @@ namespace osu.Game.Rulesets.Mania
             return base.GetDisplayNameForHitResult(result);
         }
 
-        public override StatisticRow[] CreateStatisticsForScore(ScoreInfo score, IBeatmap playableBeatmap) => new[]
+        public override StatisticItem[] CreateStatisticsForScore(ScoreInfo score, IBeatmap playableBeatmap) => new[]
         {
-            new StatisticRow
+            new StatisticItem("Performance Breakdown", () => new PerformanceBreakdownChart(score, playableBeatmap)
             {
-                Columns = new[]
-                {
-                    new StatisticItem("Performance Breakdown", () => new PerformanceBreakdownChart(score, playableBeatmap)
-                    {
-                        RelativeSizeAxes = Axes.X,
-                        AutoSizeAxes = Axes.Y
-                    }),
-                }
-            },
-            new StatisticRow
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y
+            }),
+            new StatisticItem("Timing Distribution", () => new HitEventTimingDistributionGraph(score.HitEvents)
             {
-                Columns = new[]
-                {
-                    new StatisticItem("Timing Distribution", () => new HitEventTimingDistributionGraph(score.HitEvents)
-                    {
-                        RelativeSizeAxes = Axes.X,
-                        Height = 250
-                    }, true),
-                }
-            },
-            new StatisticRow
+                RelativeSizeAxes = Axes.X,
+                Height = 250
+            }, true),
+            new StatisticItem(string.Empty, () => new SimpleStatisticTable(3, new SimpleStatisticItem[]
             {
-                Columns = new[]
-                {
-                    new StatisticItem(string.Empty, () => new SimpleStatisticTable(3, new SimpleStatisticItem[]
-                    {
-                        new AverageHitError(score.HitEvents),
-                        new UnstableRate(score.HitEvents)
-                    }), true)
-                }
-            }
+                new AverageHitError(score.HitEvents),
+                new UnstableRate(score.HitEvents)
+            }), true)
         };
 
         public override IRulesetFilterCriteria CreateRulesetFilterCriteria()

osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Localisation;
@@ -34,10 +33,10 @@ namespace osu.Game.Rulesets.Mania
                     LabelText = RulesetSettingsStrings.ScrollingDirection,
                     Current = config.GetBindable<ManiaScrollingDirection>(ManiaRulesetSetting.ScrollDirection)
                 },
-                new SettingsSlider<double, ManiaScrollSlider>
+                new SettingsSlider<int, ManiaScrollSlider>
                 {
                     LabelText = RulesetSettingsStrings.ScrollSpeed,
-                    Current = config.GetBindable<double>(ManiaRulesetSetting.ScrollTime),
+                    Current = config.GetBindable<int>(ManiaRulesetSetting.ScrollSpeed),
                     KeyboardStep = 5
                 },
                 new SettingsCheckbox
@@ -48,9 +47,9 @@ namespace osu.Game.Rulesets.Mania
             };
         }
 
-        private partial class ManiaScrollSlider : RoundedSliderBar<double>
+        private partial class ManiaScrollSlider : RoundedSliderBar<int>
         {
-            public override LocalisableString TooltipText => RulesetSettingsStrings.ScrollSpeedTooltip(Current.Value, (int)Math.Round(DrawableManiaRuleset.MAX_TIME_RANGE / Current.Value));
+            public override LocalisableString TooltipText => RulesetSettingsStrings.ScrollSpeedTooltip((int)DrawableManiaRuleset.ComputeScrollTime(Current.Value), Current.Value);
         }
     }
 }

osu.Game.Rulesets.Mania/Objects/BarLine.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 osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
 

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

@@ -3,7 +3,6 @@
 
 #nullable disable
 
-using System;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -219,6 +218,9 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             if (Time.Current < releaseTime)
                 releaseTime = null;
 
+            if (Time.Current < HoldStartTime)
+                endHold();
+
             // Pad the full size container so its contents (i.e. the masking container) reach under the tail.
             // This is required for the tail to not be masked away, since it lies outside the bounds of the hold note.
             sizingContainer.Padding = new MarginPadding
@@ -243,11 +245,14 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             // As the note is being held, adjust the size of the sizing container. This has two effects:
             // 1. The contained masking container will mask the body and ticks.
             // 2. The head note will move along with the new "head position" in the container.
-            if (Head.IsHit && releaseTime == null && DrawHeight > 0)
+            //
+            // As per stable, this should not apply for early hits, waiting until the object starts to touch the
+            // judgement area first.
+            if (Head.IsHit && releaseTime == null && DrawHeight > 0 && Time.Current >= HitObject.StartTime)
             {
-                // How far past the hit target this hold note is. Always a positive value.
-                float yOffset = Math.Max(0, Direction.Value == ScrollingDirection.Up ? -Y : Y);
-                sizingContainer.Height = Math.Clamp(1 - yOffset / DrawHeight, 0, 1);
+                // How far past the hit target this hold note is.
+                float yOffset = Direction.Value == ScrollingDirection.Up ? -Y : Y;
+                sizingContainer.Height = 1 - yOffset / DrawHeight;
             }
         }
 
@@ -322,14 +327,14 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             if (e.Action != Action.Value)
                 return;
 
-            // do not run any of this logic when rewinding, as it inverts order of presses/releases.
-            if (Time.Elapsed < 0)
-                return;
-
             // Make sure a hold was started
             if (HoldStartTime == null)
                 return;
 
+            // do not run any of this logic when rewinding, as it inverts order of presses/releases.
+            if (Time.Elapsed < 0)
+                return;
+
             Tail.UpdateResult();
             endHold();
 
@@ -350,13 +355,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
             // Note: base.LoadSamples() isn't called since the slider plays the tail's hitsounds for the time being.
 
-            if (HitObject.SampleControlPoint == null)
-            {
-                throw new InvalidOperationException($"{nameof(HitObject)}s must always have an attached {nameof(HitObject.SampleControlPoint)}."
-                                                    + $" This is an indication that {nameof(HitObject.ApplyDefaults)} has not been invoked on {this}.");
-            }
-
-            slidingSample.Samples = HitObject.CreateSlidingSamples().Select(s => HitObject.SampleControlPoint.ApplyTo(s)).Cast<ISampleInfo>().ToArray();
+            slidingSample.Samples = HitObject.CreateSlidingSamples().Cast<ISampleInfo>().ToArray();
         }
 
         public override void StopAllSamples()

osu.Game.Rulesets.Mania/Objects/HeadNote.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
-
 namespace osu.Game.Rulesets.Mania.Objects
 {
     public class HeadNote : Note

osu.Game.Rulesets.Mania/Resources/Testing/Beatmaps/convert-samples-expected-conversion.json

@@ -10,7 +10,7 @@
         ["Gameplay/soft-hitnormal"],
         ["Gameplay/drum-hitnormal"]
       ],
-      "Samples": ["Gameplay/-hitnormal"]
+      "Samples": ["Gameplay/normal-hitnormal"]
     }, {
       "StartTime": 1875.0,
       "EndTime": 2750.0,
@@ -19,7 +19,7 @@
         ["Gameplay/soft-hitnormal"],
         ["Gameplay/drum-hitnormal"]
       ],
-      "Samples": ["Gameplay/-hitnormal"]
+      "Samples": ["Gameplay/normal-hitnormal"]
     }]
   }, {
     "StartTime": 3750.0,

osu.Game.Rulesets.Mania/Scoring/ManiaScoreProcessor.cs

@@ -1,23 +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.
 
-#nullable disable
-
+using System;
+using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Scoring
 {
-    internal partial class ManiaScoreProcessor : ScoreProcessor
+    public partial class ManiaScoreProcessor : ScoreProcessor
     {
+        private const double combo_base = 4;
+
         public ManiaScoreProcessor()
             : base(new ManiaRuleset())
         {
         }
 
-        protected override double DefaultAccuracyPortion => 0.99;
+        protected override double ComputeTotalScore(double comboProgress, double accuracyProgress, double bonusPortion)
+        {
+            return 10000 * comboProgress
+                   + 990000 * Math.Pow(Accuracy.Value, 2 + 2 * Accuracy.Value) * accuracyProgress
+                   + bonusPortion;
+        }
 
-        protected override double DefaultComboPortion => 0.01;
-
-        protected override double ClassicScoreMultiplier => 16;
+        protected override double GetComboScoreChange(JudgementResult result)
+            => Judgement.ToNumericResult(result.Type) * Math.Min(Math.Max(0.5, Math.Log(result.ComboAfterJudgement, combo_base)), Math.Log(400, combo_base));
     }
 }

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

@@ -139,11 +139,11 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
                 case 3:
                     switch (columnIndex)
                     {
-                        case 0: return colour_pink;
+                        case 0: return colour_green;
 
-                        case 1: return colour_orange;
+                        case 1: return colour_special_column;
 
-                        case 2: return colour_yellow;
+                        case 2: return colour_cyan;
 
                         default: throw new ArgumentOutOfRangeException();
                     }
@@ -185,11 +185,11 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
 
                         case 1: return colour_orange;
 
-                        case 2: return colour_yellow;
+                        case 2: return colour_green;
 
                         case 3: return colour_cyan;
 
-                        case 4: return colour_purple;
+                        case 4: return colour_orange;
 
                         case 5: return colour_pink;
 
@@ -201,17 +201,17 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
                     {
                         case 0: return colour_pink;
 
-                        case 1: return colour_cyan;
+                        case 1: return colour_orange;
 
                         case 2: return colour_pink;
 
                         case 3: return colour_special_column;
 
-                        case 4: return colour_green;
+                        case 4: return colour_pink;
 
-                        case 5: return colour_cyan;
+                        case 5: return colour_orange;
 
-                        case 6: return colour_green;
+                        case 6: return colour_pink;
 
                         default: throw new ArgumentOutOfRangeException();
                     }
@@ -225,9 +225,9 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
 
                         case 2: return colour_orange;
 
-                        case 3: return colour_yellow;
+                        case 3: return colour_green;
 
-                        case 4: return colour_yellow;
+                        case 4: return colour_cyan;
 
                         case 5: return colour_orange;
 
@@ -273,9 +273,9 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
 
                         case 3: return colour_yellow;
 
-                        case 4: return colour_cyan;
+                        case 4: return colour_green;
 
-                        case 5: return colour_green;
+                        case 5: return colour_cyan;
 
                         case 6: return colour_yellow;
 

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

@@ -11,6 +11,7 @@ using osu.Framework.Graphics.Pooling;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Framework.Platform;
+using osu.Game.Extensions;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
@@ -39,7 +40,11 @@ namespace osu.Game.Rulesets.Mania.UI
         public readonly Bindable<ManiaAction> Action = new Bindable<ManiaAction>();
 
         public readonly ColumnHitObjectArea HitObjectArea;
+
+        internal readonly Container BackgroundContainer = new Container { RelativeSizeAxes = Axes.Both };
+
         internal readonly Container TopLevelContainer = new Container { RelativeSizeAxes = Axes.Both };
+
         private DrawablePool<PoolableHitExplosion> hitExplosionPool;
         private readonly OrderedHitPolicy hitPolicy;
         public Container UnderlayElements => HitObjectArea.UnderlayElements;
@@ -76,30 +81,31 @@ namespace osu.Game.Rulesets.Mania.UI
             skin.SourceChanged += onSourceChanged;
             onSourceChanged();
 
-            Drawable background = new SkinnableDrawable(new ManiaSkinComponentLookup(ManiaSkinComponents.ColumnBackground), _ => new DefaultColumnBackground())
-            {
-                RelativeSizeAxes = Axes.Both,
-            };
-
-            InternalChildren = new[]
+            InternalChildren = new Drawable[]
             {
                 hitExplosionPool = new DrawablePool<PoolableHitExplosion>(5),
                 sampleTriggerSource = new GameplaySampleTriggerSource(HitObjectContainer),
-                // For input purposes, the background is added at the highest depth, but is then proxied back below all other elements
-                background.CreateProxy(),
                 HitObjectArea,
                 keyArea = new SkinnableDrawable(new ManiaSkinComponentLookup(ManiaSkinComponents.KeyArea), _ => new DefaultKeyArea())
                 {
                     RelativeSizeAxes = Axes.Both,
                 },
-                background,
+                // For input purposes, the background is added at the highest depth, but is then proxied back below all other elements externally
+                // (see `Stage.columnBackgrounds`).
+                BackgroundContainer,
                 TopLevelContainer,
                 new ColumnTouchInputArea(this)
             };
 
-            applyGameWideClock(background);
-            applyGameWideClock(keyArea);
+            var background = new SkinnableDrawable(new ManiaSkinComponentLookup(ManiaSkinComponents.ColumnBackground), _ => new DefaultColumnBackground())
+            {
+                RelativeSizeAxes = Axes.Both,
+            };
 
+            background.ApplyGameWideClock(host);
+            keyArea.ApplyGameWideClock(host);
+
+            BackgroundContainer.Add(background);
             TopLevelContainer.Add(HitObjectArea.Explosions.CreateProxy());
 
             RegisterPool<Note, DrawableNote>(10, 50);
@@ -107,18 +113,6 @@ namespace osu.Game.Rulesets.Mania.UI
             RegisterPool<HeadNote, DrawableHoldNoteHead>(10, 50);
             RegisterPool<TailNote, DrawableHoldNoteTail>(10, 50);
             RegisterPool<HoldNoteTick, DrawableHoldNoteTick>(50, 250);
-
-            // Some elements don't handle rewind correctly and fixing them is non-trivial.
-            // In the future we need a better solution to this, but as a temporary work-around, give these components the game-wide
-            // clock so they don't need to worry about rewind.
-            // This only works because they handle OnPressed/OnReleased which results in a correct state while rewinding.
-            //
-            // This is kinda dodgy (and will cause weirdness when pausing gameplay) but is better than completely broken rewind.
-            void applyGameWideClock(Drawable drawable)
-            {
-                drawable.Clock = host.UpdateThread.Clock;
-                drawable.ProcessCustomClock = false;
-            }
         }
 
         private void onSourceChanged()

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

@@ -33,12 +33,12 @@ namespace osu.Game.Rulesets.Mania.UI
     public partial class DrawableManiaRuleset : DrawableScrollingRuleset<ManiaHitObject>
     {
         /// <summary>
-        /// The minimum time range. This occurs at a <see cref="relativeTimeRange"/> of 40.
+        /// The minimum time range. This occurs at a <see cref="ManiaRulesetSetting.ScrollSpeed"/> of 40.
         /// </summary>
         public const double MIN_TIME_RANGE = 290;
 
         /// <summary>
-        /// The maximum time range. This occurs at a <see cref="relativeTimeRange"/> of 1.
+        /// The maximum time range. This occurs with a <see cref="ManiaRulesetSetting.ScrollSpeed"/> of 1.
         /// </summary>
         public const double MAX_TIME_RANGE = 11485;
 
@@ -69,7 +69,8 @@ namespace osu.Game.Rulesets.Mania.UI
         protected override ScrollVisualisationMethod VisualisationMethod => scrollMethod;
 
         private readonly Bindable<ManiaScrollingDirection> configDirection = new Bindable<ManiaScrollingDirection>();
-        private readonly BindableDouble configTimeRange = new BindableDouble();
+        private readonly BindableInt configScrollSpeed = new BindableInt();
+        private double smoothTimeRange;
 
         // Stores the current speed adjustment active in gameplay.
         private readonly Track speedAdjustmentTrack = new TrackVirtual(0);
@@ -78,6 +79,9 @@ namespace osu.Game.Rulesets.Mania.UI
             : base(ruleset, beatmap, mods)
         {
             BarLines = new BarLineGenerator<BarLine>(Beatmap).BarLines;
+
+            TimeRange.MinValue = 1;
+            TimeRange.MaxValue = MAX_TIME_RANGE;
         }
 
         [BackgroundDependencyLoader]
@@ -104,30 +108,28 @@ namespace osu.Game.Rulesets.Mania.UI
             Config.BindWith(ManiaRulesetSetting.ScrollDirection, configDirection);
             configDirection.BindValueChanged(direction => Direction.Value = (ScrollingDirection)direction.NewValue, true);
 
-            Config.BindWith(ManiaRulesetSetting.ScrollTime, configTimeRange);
-            TimeRange.MinValue = configTimeRange.MinValue;
-            TimeRange.MaxValue = configTimeRange.MaxValue;
+            Config.BindWith(ManiaRulesetSetting.ScrollSpeed, configScrollSpeed);
+            configScrollSpeed.BindValueChanged(speed => this.TransformTo(nameof(smoothTimeRange), ComputeScrollTime(speed.NewValue), 200, Easing.OutQuint));
+
+            TimeRange.Value = smoothTimeRange = ComputeScrollTime(configScrollSpeed.Value);
         }
 
-        protected override void AdjustScrollSpeed(int amount)
-        {
-            this.TransformTo(nameof(relativeTimeRange), relativeTimeRange + amount, 200, Easing.OutQuint);
-        }
-
-        private double relativeTimeRange
-        {
-            get => MAX_TIME_RANGE / configTimeRange.Value;
-            set => configTimeRange.Value = MAX_TIME_RANGE / value;
-        }
+        protected override void AdjustScrollSpeed(int amount) => configScrollSpeed.Value += amount;
 
         protected override void Update()
         {
             base.Update();
-
             updateTimeRange();
         }
 
-        private void updateTimeRange() => TimeRange.Value = configTimeRange.Value * speedAdjustmentTrack.AggregateTempo.Value * speedAdjustmentTrack.AggregateFrequency.Value;
+        private void updateTimeRange() => TimeRange.Value = smoothTimeRange * speedAdjustmentTrack.AggregateTempo.Value * speedAdjustmentTrack.AggregateFrequency.Value;
+
+        /// <summary>
+        /// Computes a scroll time (in milliseconds) from a scroll speed in the range of 1-40.
+        /// </summary>
+        /// <param name="scrollSpeed">The scroll speed.</param>
+        /// <returns>The scroll time.</returns>
+        public static double ComputeScrollTime(int scrollSpeed) => MAX_TIME_RANGE / scrollSpeed;
 
         public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new ManiaPlayfieldAdjustmentContainer();
 

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

@@ -60,6 +60,7 @@ namespace osu.Game.Rulesets.Mania.UI
             RelativeSizeAxes = Axes.Y;
             AutoSizeAxes = Axes.X;
 
+            Container columnBackgrounds;
             Container topLevelContainer;
 
             InternalChildren = new Drawable[]
@@ -77,9 +78,10 @@ namespace osu.Game.Rulesets.Mania.UI
                         {
                             RelativeSizeAxes = Axes.Both
                         },
-                        columnFlow = new ColumnFlow<Column>(definition)
+                        columnBackgrounds = new Container
                         {
-                            RelativeSizeAxes = Axes.Y,
+                            Name = "Column backgrounds",
+                            RelativeSizeAxes = Axes.Both,
                         },
                         new Container
                         {
@@ -98,6 +100,10 @@ namespace osu.Game.Rulesets.Mania.UI
                                 RelativeSizeAxes = Axes.Y,
                             }
                         },
+                        columnFlow = new ColumnFlow<Column>(definition)
+                        {
+                            RelativeSizeAxes = Axes.Y,
+                        },
                         new SkinnableDrawable(new ManiaSkinComponentLookup(ManiaSkinComponents.StageForeground), _ => null)
                         {
                             RelativeSizeAxes = Axes.Both
@@ -126,6 +132,7 @@ namespace osu.Game.Rulesets.Mania.UI
                 };
 
                 topLevelContainer.Add(column.TopLevelContainer.CreateProxy());
+                columnBackgrounds.Add(column.BackgroundContainer.CreateProxy());
                 columnFlow.SetContentForColumn(i, column);
                 AddNested(column);
             }

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

@@ -138,8 +138,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                 var mergedSlider = (Slider)EditorBeatmap.SelectedHitObjects.First();
                 return slider1 is not null && mergedSlider.HeadCircle.Samples.SequenceEqual(slider1.HeadCircle.Samples)
                                            && mergedSlider.TailCircle.Samples.SequenceEqual(slider1.TailCircle.Samples)
-                                           && mergedSlider.Samples.SequenceEqual(slider1.Samples)
-                                           && mergedSlider.SampleControlPoint.IsRedundant(slider1.SampleControlPoint);
+                                           && mergedSlider.Samples.SequenceEqual(slider1.Samples);
             });
 
             AddAssert("slider end is at same completion for last slider", () =>

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

@@ -43,7 +43,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
 
             AddStep("place first object", () => InputManager.Click(MouseButton.Left));
 
-            AddStep("move mouse slightly", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * 0.02f, 0)));
+            AddStep("move mouse slightly", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * 0.01f, 0)));
 
             AddStep("place second object", () => InputManager.Click(MouseButton.Left));
 
@@ -75,7 +75,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
 
             AddStep("enter circle placement mode", () => InputManager.Key(Key.Number2));
 
-            AddStep("move mouse slightly", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * 0.235f, 0)));
+            AddStep("move mouse slightly", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * 0.205f, 0)));
 
             AddStep("place second object", () => InputManager.Click(MouseButton.Left));
 
@@ -122,7 +122,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
 
             AddStep("begin drag", () => InputManager.PressButton(MouseButton.Left));
 
-            AddStep("move mouse slightly off centre", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * 0.02f, 0)));
+            AddStep("move mouse slightly off centre", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * 0.01f, 0)));
 
             AddAssert("object 3 snapped to 1", () =>
             {
@@ -134,7 +134,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                 return Precision.AlmostEquals(first.EndPosition, third.Position);
             });
 
-            AddStep("move mouse slightly off centre", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * -0.22f, playfield.ScreenSpaceDrawQuad.Width * 0.21f)));
+            AddStep("move mouse slightly off centre", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * -0.21f, playfield.ScreenSpaceDrawQuad.Width * 0.205f)));
 
             AddAssert("object 2 snapped to 1", () =>
             {

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

@@ -181,10 +181,8 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             {
                 if (slider is null) return;
 
-                slider.SampleControlPoint.SampleBank = "soft";
-                slider.SampleControlPoint.SampleVolume = 70;
-                sample = new HitSampleInfo("hitwhistle");
-                slider.Samples.Add(sample);
+                sample = new HitSampleInfo("hitwhistle", HitSampleInfo.BANK_SOFT, volume: 70);
+                slider.Samples.Add(sample.With());
             });
 
             AddStep("select added slider", () =>
@@ -207,9 +205,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             AddAssert("sliders have hitsounds", hasHitsounds);
 
             bool hasHitsounds() => sample is not null &&
-                                   EditorBeatmap.HitObjects.All(o => o.SampleControlPoint.SampleBank == "soft" &&
-                                                                     o.SampleControlPoint.SampleVolume == 70 &&
-                                                                     o.Samples.Contains(sample));
+                                   EditorBeatmap.HitObjects.All(o => o.Samples.Contains(sample));
         }
 
         private bool sliderCreatedFor(Slider s, double startTime, double endTime, params (Vector2 pos, PathType? pathType)[] expectedControlPoints)

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

@@ -199,8 +199,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                 Precision.AlmostEquals(circle.StartTime, time, 1)
                 && Precision.AlmostEquals(circle.Position, position, 0.01f)
                 && circle.NewCombo == startsNewCombo
-                && circle.Samples.SequenceEqual(slider.HeadCircle.Samples)
-                && circle.SampleControlPoint.IsRedundant(slider.SampleControlPoint);
+                && circle.Samples.SequenceEqual(slider.HeadCircle.Samples);
         }
 
         private bool sliderRestored(Slider slider)

osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModAutoplay.cs

@@ -1,22 +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.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Skinning.Default;
 using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.Scoring;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests.Mods
 {
     public partial class TestSceneOsuModAutoplay : OsuModTestScene
     {
+        protected override bool AllowFail => true;
+
+        [Test]
+        public void TestCursorPositionStoredToJudgement()
+        {
+            CreateModTest(new ModTestData
+            {
+                Autoplay = true,
+                PassCondition = () =>
+                    Player.ScoreProcessor.JudgedHits >= 1
+                    && Player.ScoreProcessor.HitEvents.Any(e => e.Position != null)
+            });
+        }
+
         [Test]
         public void TestSpmUnaffectedByRateAdjust()
             => runSpmTest(new OsuModDaycore
@@ -32,6 +51,36 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
                 FinalRate = { Value = 1.3 }
             });
 
+        [Test]
+        public void TestPerfectScoreOnShortSliderWithRepeat()
+        {
+            AddStep("set score to standardised", () => LocalConfig.SetValue(OsuSetting.ScoreDisplayMode, ScoringMode.Standardised));
+
+            CreateModTest(new ModTestData
+            {
+                Autoplay = true,
+                Beatmap = new Beatmap
+                {
+                    HitObjects = new List<HitObject>
+                    {
+                        new Slider
+                        {
+                            StartTime = 500,
+                            Position = new Vector2(256, 192),
+                            Path = new SliderPath(new[]
+                            {
+                                new PathControlPoint(),
+                                new PathControlPoint(new Vector2(0, 6.25f))
+                            }),
+                            RepeatCount = 1,
+                            SliderVelocity = 10
+                        }
+                    }
+                },
+                PassCondition = () => Player.ScoreProcessor.TotalScore.Value == 1_000_000
+            });
+        }
+
         private void runSpmTest(Mod mod)
         {
             SpinnerSpmCalculator? spmCalculator = null;

osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModBubbles.cs

@@ -0,0 +1,19 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Rulesets.Osu.Mods;
+
+namespace osu.Game.Rulesets.Osu.Tests.Mods
+{
+    public partial class TestSceneOsuModBubbles : OsuModTestScene
+    {
+        [Test]
+        public void TestOsuModBubbles() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModBubbles(),
+            Autoplay = true,
+            PassCondition = () => true
+        });
+    }
+}

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

@@ -8,6 +8,7 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -18,6 +19,7 @@ using osu.Framework.Testing.Input;
 using osu.Framework.Utils;
 using osu.Game.Audio;
 using osu.Game.Configuration;
+using osu.Game.Rulesets.Osu.Configuration;
 using osu.Game.Rulesets.Osu.Skinning;
 using osu.Game.Rulesets.Osu.UI.Cursor;
 using osu.Game.Screens.Play;
@@ -40,6 +42,8 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         private Drawable background;
 
+        private readonly Bindable<bool> ripples = new Bindable<bool>();
+
         public TestSceneGameplayCursor()
         {
             var ruleset = new OsuRuleset();
@@ -57,6 +61,8 @@ namespace osu.Game.Rulesets.Osu.Tests
                 });
             });
 
+            AddToggleStep("ripples", v => ripples.Value = v);
+
             AddSliderStep("circle size", 0f, 10f, 0f, val =>
             {
                 config.SetValue(OsuSetting.AutoCursorSize, true);
@@ -67,6 +73,13 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddStep("test cursor container", () => loadContent(false));
         }
 
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            var rulesetConfig = (OsuRulesetConfigManager)RulesetConfigs.GetConfigFor(Ruleset.Value.CreateInstance()).AsNonNull();
+            rulesetConfig.BindWith(OsuRulesetSetting.ShowCursorRipples, ripples);
+        }
+
         [TestCase(1, 1)]
         [TestCase(5, 1)]
         [TestCase(10, 1)]

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

@@ -439,7 +439,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             public TestSlider()
             {
-                DifficultyControlPoint = new DifficultyControlPoint { SliderVelocity = 0.1f };
+                SliderVelocity = 0.1f;
 
                 DefaultsApplied += _ =>
                 {

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

@@ -15,6 +15,10 @@ using osuTK.Graphics;
 using osu.Game.Rulesets.Mods;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
@@ -22,6 +26,7 @@ using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Configuration;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
@@ -30,6 +35,27 @@ namespace osu.Game.Rulesets.Osu.Tests
     {
         private int depthIndex;
 
+        private readonly BindableBool snakingIn = new BindableBool();
+        private readonly BindableBool snakingOut = new BindableBool();
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddToggleStep("toggle snaking", v =>
+            {
+                snakingIn.Value = v;
+                snakingOut.Value = v;
+            });
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            var config = (OsuRulesetConfigManager)RulesetConfigs.GetConfigFor(Ruleset.Value.CreateInstance()).AsNonNull();
+            config.BindWith(OsuRulesetSetting.SnakingInSliders, snakingIn);
+            config.BindWith(OsuRulesetSetting.SnakingOutSliders, snakingOut);
+        }
+
         [Test]
         public void TestVariousSliders()
         {

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

@@ -7,7 +7,6 @@ using NUnit.Framework;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
@@ -47,7 +46,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                     {
                         StartTime = time_slider_start,
                         Position = new Vector2(0, 0),
-                        DifficultyControlPoint = new DifficultyControlPoint { SliderVelocity = velocity },
+                        SliderVelocity = velocity,
                         Path = new SliderPath(PathType.Linear, new[]
                         {
                             Vector2.Zero,

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

@@ -8,7 +8,6 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Screens;
 using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
@@ -350,7 +349,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                         {
                             StartTime = time_slider_start,
                             Position = new Vector2(0, 0),
-                            DifficultyControlPoint = new DifficultyControlPoint { SliderVelocity = 0.1f },
+                            SliderVelocity = 0.1f,
                             Path = new SliderPath(PathType.PerfectCurve, new[]
                             {
                                 Vector2.Zero,

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

@@ -74,7 +74,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 EndTime = Time.Current + delay + length,
                 Samples = new List<HitSampleInfo>
                 {
-                    new HitSampleInfo("hitnormal")
+                    new HitSampleInfo(HitSampleInfo.HIT_NORMAL)
                 }
             };
 

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

@@ -399,7 +399,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             public TestSlider()
             {
-                DifficultyControlPoint = new DifficultyControlPoint { SliderVelocity = 0.1f };
+                SliderVelocity = 0.1f;
 
                 DefaultsApplied += _ =>
                 {

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

@@ -30,6 +30,8 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
         {
             var positionData = original as IHasPosition;
             var comboData = original as IHasCombo;
+            var sliderVelocityData = original as IHasSliderVelocity;
+            var generateTicksData = original as IHasGenerateTicks;
 
             switch (original)
             {
@@ -47,7 +49,9 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                         LegacyLastTickOffset = (original as IHasLegacyLastTickOffset)?.LegacyLastTickOffset,
                         // prior to v8, speed multipliers don't adjust for how many ticks are generated over the same distance.
                         // this results in more (or less) ticks being generated in <v8 maps for the same time duration.
-                        TickDistanceMultiplier = beatmap.BeatmapInfo.BeatmapVersion < 8 ? 1f / ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(original.StartTime).SliderVelocity : 1
+                        TickDistanceMultiplier = beatmap.BeatmapInfo.BeatmapVersion < 8 ? 1f / ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(original.StartTime).SliderVelocity : 1,
+                        GenerateTicks = generateTicksData?.GenerateTicks ?? true,
+                        SliderVelocity = sliderVelocityData?.SliderVelocity ?? 1,
                     }.Yield();
 
                 case IHasDuration endTimeData:

osu.Game.Rulesets.Osu/Configuration/OsuRulesetConfigManager.cs

@@ -22,6 +22,7 @@ namespace osu.Game.Rulesets.Osu.Configuration
             SetDefault(OsuRulesetSetting.SnakingInSliders, true);
             SetDefault(OsuRulesetSetting.SnakingOutSliders, true);
             SetDefault(OsuRulesetSetting.ShowCursorTrail, true);
+            SetDefault(OsuRulesetSetting.ShowCursorRipples, false);
             SetDefault(OsuRulesetSetting.PlayfieldBorderStyle, PlayfieldBorderStyle.None);
         }
     }
@@ -31,6 +32,7 @@ namespace osu.Game.Rulesets.Osu.Configuration
         SnakingInSliders,
         SnakingOutSliders,
         ShowCursorTrail,
+        ShowCursorRipples,
         PlayfieldBorderStyle,
     }
 }

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

@@ -309,7 +309,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
             }
             else
             {
-                var result = snapProvider?.FindSnappedPositionAndTime(Parent.ToScreenSpace(e.MousePosition));
+                var result = snapProvider?.FindSnappedPositionAndTime(Parent.ToScreenSpace(e.MousePosition), SnapType.GlobalGrids);
 
                 Vector2 movementDelta = Parent.ToLocalSpace(result?.ScreenSpacePosition ?? Parent.ToScreenSpace(e.MousePosition)) - dragStartPositions[draggedControlPointIndex] - hitObject.Position;
 

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs

@@ -10,7 +10,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Input;
 using osu.Framework.Input.Events;
-using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
@@ -42,6 +41,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
         [Resolved(CanBeNull = true)]
         private IDistanceSnapProvider snapProvider { get; set; }
 
+        protected override bool IsValidForPlacement => HitObject.Path.HasValidLength;
+
         public SliderPlacementBlueprint()
             : base(new Slider())
         {
@@ -83,11 +84,10 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                 case SliderPlacementState.Initial:
                     BeginPlacement();
 
-                    var nearestDifficultyPoint = editorBeatmap.HitObjects
-                                                              .LastOrDefault(h => h is Slider && h.GetEndTime() < HitObject.StartTime)?
-                                                              .DifficultyControlPoint?.DeepClone() as DifficultyControlPoint;
+                    double? nearestSliderVelocity = (editorBeatmap.HitObjects
+                                                                  .LastOrDefault(h => h is Slider && h.GetEndTime() < HitObject.StartTime) as Slider)?.SliderVelocity;
 
-                    HitObject.DifficultyControlPoint = nearestDifficultyPoint ?? new DifficultyControlPoint();
+                    HitObject.SliderVelocity = nearestSliderVelocity ?? 1;
                     HitObject.Position = ToLocalSpace(result.ScreenSpacePosition);
 
                     // Replacing the DifficultyControlPoint above doesn't trigger any kind of invalidation.
@@ -152,7 +152,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
         private void endCurve()
         {
             updateSlider();
-            EndPlacement(HitObject.Path.HasValidLength);
+            EndPlacement(true);
         }
 
         protected override void Update()
@@ -198,7 +198,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                 }
 
                 // Update the cursor position.
-                var result = snapProvider?.FindSnappedPositionAndTime(inputManager.CurrentState.Mouse.Position);
+                var result = snapProvider?.FindSnappedPositionAndTime(inputManager.CurrentState.Mouse.Position, state == SliderPlacementState.Body ? SnapType.GlobalGrids : SnapType.All);
                 cursor.Position = ToLocalSpace(result?.ScreenSpacePosition ?? inputManager.CurrentState.Mouse.Position) - HitObject.Position;
             }
             else if (cursor != null)

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPosition.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
-
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 {
     public enum SliderPosition

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs

@@ -14,7 +14,6 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
 using osu.Framework.Utils;
 using osu.Game.Audio;
-using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
@@ -311,17 +310,11 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                 var splitControlPoints = controlPoints.Take(index + 1).ToList();
                 controlPoints.RemoveRange(0, index);
 
-                // Turn the control points which were split off into a new slider.
-                var samplePoint = (SampleControlPoint)HitObject.SampleControlPoint.DeepClone();
-                var difficultyPoint = (DifficultyControlPoint)HitObject.DifficultyControlPoint.DeepClone();
-
                 var newSlider = new Slider
                 {
                     StartTime = HitObject.StartTime,
                     Position = HitObject.Position + splitControlPoints[0].Position,
                     NewCombo = HitObject.NewCombo,
-                    SampleControlPoint = samplePoint,
-                    DifficultyControlPoint = difficultyPoint,
                     LegacyLastTickOffset = HitObject.LegacyLastTickOffset,
                     Samples = HitObject.Samples.Select(s => s.With()).ToList(),
                     RepeatCount = HitObject.RepeatCount,
@@ -378,15 +371,11 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 
                 Vector2 position = HitObject.Position + HitObject.Path.PositionAt(pathPosition);
 
-                var samplePoint = (SampleControlPoint)HitObject.SampleControlPoint.DeepClone();
-                samplePoint.Time = time;
-
                 editorBeatmap.Add(new HitCircle
                 {
                     StartTime = time,
                     Position = position,
                     NewCombo = i == 0 && HitObject.NewCombo,
-                    SampleControlPoint = samplePoint,
                     Samples = HitObject.HeadCircle.Samples.Select(s => s.With()).ToList()
                 });
 

osu.Game.Rulesets.Osu/Edit/Blueprints/Spinners/SpinnerPlacementBlueprint.cs

@@ -1,10 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
-using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Events;
@@ -24,9 +21,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners
 
         private bool isPlacingEnd;
 
-        [Resolved(CanBeNull = true)]
-        [CanBeNull]
-        private IBeatSnapProvider beatSnapProvider { get; set; }
+        [Resolved]
+        private IBeatSnapProvider? beatSnapProvider { get; set; }
 
         public SpinnerPlacementBlueprint()
             : base(new Spinner { Position = OsuPlayfield.BASE_SIZE / 2 })

osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs

@@ -13,8 +13,8 @@ using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Utils;
 using osu.Framework.Input.Events;
+using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Input.Bindings;
@@ -62,7 +62,12 @@ namespace osu.Game.Rulesets.Osu.Edit
         private void load()
         {
             // Give a bit of breathing room around the playfield content.
-            PlayfieldContentContainer.Padding = new MarginPadding(10);
+            PlayfieldContentContainer.Padding = new MarginPadding
+            {
+                Vertical = 10,
+                Left = TOOLBOX_CONTRACTED_SIZE_LEFT + 10,
+                Right = TOOLBOX_CONTRACTED_SIZE_RIGHT + 10,
+            };
 
             LayerBelowRuleset.AddRange(new Drawable[]
             {
@@ -138,7 +143,7 @@ namespace osu.Game.Rulesets.Osu.Edit
                 // We want to ensure that in this particular case, the time-snapping component of distance snap is still applied.
                 // The easiest way to ensure this is to attempt application of distance snap after a nearby object is found, and copy over
                 // the time value if the proposed positions are roughly the same.
-                if (snapType.HasFlagFast(SnapType.Grids) && DistanceSnapToggle.Value == TernaryState.True && distanceSnapGrid != null)
+                if (snapType.HasFlagFast(SnapType.RelativeGrids) && DistanceSnapToggle.Value == TernaryState.True && distanceSnapGrid != null)
                 {
                     (Vector2 distanceSnappedPosition, double distanceSnappedTime) = distanceSnapGrid.GetSnappedPosition(distanceSnapGrid.ToLocalSpace(snapResult.ScreenSpacePosition));
                     if (Precision.AlmostEquals(distanceSnapGrid.ToScreenSpace(distanceSnappedPosition), snapResult.ScreenSpacePosition, 1))
@@ -150,7 +155,7 @@ namespace osu.Game.Rulesets.Osu.Edit
 
             SnapResult result = base.FindSnappedPositionAndTime(screenSpacePosition, snapType);
 
-            if (snapType.HasFlagFast(SnapType.Grids))
+            if (snapType.HasFlagFast(SnapType.RelativeGrids))
             {
                 if (DistanceSnapToggle.Value == TernaryState.True && distanceSnapGrid != null)
                 {
@@ -159,7 +164,10 @@ namespace osu.Game.Rulesets.Osu.Edit
                     result.ScreenSpacePosition = distanceSnapGrid.ToScreenSpace(pos);
                     result.Time = time;
                 }
+            }
 
+            if (snapType.HasFlagFast(SnapType.GlobalGrids))
+            {
                 if (rectangularGridSnapToggle.Value == TernaryState.True)
                 {
                     Vector2 pos = rectangularPositionSnapGrid.GetSnappedPosition(rectangularPositionSnapGrid.ToLocalSpace(result.ScreenSpacePosition));
@@ -179,7 +187,7 @@ namespace osu.Game.Rulesets.Osu.Edit
             var playfield = PlayfieldAtScreenSpacePosition(screenSpacePosition);
 
             float snapRadius =
-                playfield.GamefieldToScreenSpace(new Vector2(OsuHitObject.OBJECT_RADIUS / 5)).X -
+                playfield.GamefieldToScreenSpace(new Vector2(OsuHitObject.OBJECT_RADIUS * 0.10f)).X -
                 playfield.GamefieldToScreenSpace(Vector2.Zero).X;
 
             foreach (var b in blueprints)

osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs

@@ -362,7 +362,6 @@ namespace osu.Game.Rulesets.Osu.Edit
                 StartTime = firstHitObject.StartTime,
                 Position = firstHitObject.Position,
                 NewCombo = firstHitObject.NewCombo,
-                SampleControlPoint = firstHitObject.SampleControlPoint,
                 Samples = firstHitObject.Samples,
             };
 

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

@@ -24,7 +24,17 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override ModType Type => ModType.Automation;
         public override LocalisableString Description => @"Automatic cursor movement - just follow the rhythm.";
         public override double ScoreMultiplier => 0.1;
-        public override Type[] IncompatibleMods => new[] { typeof(OsuModSpunOut), typeof(ModRelax), typeof(ModFailCondition), typeof(ModNoFail), typeof(ModAutoplay), typeof(OsuModMagnetised), typeof(OsuModRepel) };
+
+        public override Type[] IncompatibleMods => new[]
+        {
+            typeof(OsuModSpunOut),
+            typeof(ModRelax),
+            typeof(ModFailCondition),
+            typeof(ModNoFail),
+            typeof(ModAutoplay),
+            typeof(OsuModMagnetised),
+            typeof(OsuModRepel)
+        };
 
         public bool PerformFail() => false;
 
@@ -34,7 +44,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         private List<OsuReplayFrame> replayFrames = null!;
 
-        private int currentFrame;
+        private int currentFrame = -1;
 
         public void Update(Playfield playfield)
         {
@@ -43,8 +53,9 @@ namespace osu.Game.Rulesets.Osu.Mods
             double time = playfield.Clock.CurrentTime;
 
             // Very naive implementation of autopilot based on proximity to replay frames.
+            // Special case for the first frame is required to ensure the mouse is in a sane position until the actual time of the first frame is hit.
             // TODO: this needs to be based on user interactions to better match stable (pausing until judgement is registered).
-            if (Math.Abs(replayFrames[currentFrame + 1].Time - time) <= Math.Abs(replayFrames[currentFrame].Time - time))
+            if (currentFrame < 0 || Math.Abs(replayFrames[currentFrame + 1].Time - time) <= Math.Abs(replayFrames[currentFrame].Time - time))
             {
                 currentFrame++;
                 new MousePositionAbsoluteInput { Position = playfield.ToScreenSpace(replayFrames[currentFrame].Position) }.Apply(inputManager.CurrentState, inputManager);

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

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
@@ -10,6 +11,8 @@ namespace osu.Game.Rulesets.Osu.Mods
 {
     public class OsuModBarrelRoll : ModBarrelRoll<OsuHitObject>, IApplicableToDrawableHitObject
     {
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModBubbles) };
+
         public void ApplyToDrawableHitObject(DrawableHitObject d)
         {
             d.OnUpdate += _ =>

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

@@ -0,0 +1,215 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Diagnostics;
+using System.Linq;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
+using osu.Framework.Graphics.Pooling;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Localisation;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI;
+using osu.Game.Scoring;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    public partial class OsuModBubbles : Mod, IApplicableToDrawableRuleset<OsuHitObject>, IApplicableToDrawableHitObject, IApplicableToScoreProcessor
+    {
+        public override string Name => "Bubbles";
+
+        public override string Acronym => "BU";
+
+        public override LocalisableString Description => "Don't let their popping distract you!";
+
+        public override double ScoreMultiplier => 1;
+
+        public override ModType Type => ModType.Fun;
+
+        // Compatibility with these seems potentially feasible in the future, blocked for now because they don't work as one would expect
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModBarrelRoll), typeof(OsuModMagnetised), typeof(OsuModRepel) };
+
+        private PlayfieldAdjustmentContainer bubbleContainer = null!;
+
+        private DrawablePool<BubbleDrawable> bubblePool = null!;
+
+        private readonly Bindable<int> currentCombo = new BindableInt();
+
+        private float maxSize;
+        private float bubbleSize;
+        private double bubbleFade;
+
+        public ScoreRank AdjustRank(ScoreRank rank, double accuracy) => rank;
+
+        public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor)
+        {
+            currentCombo.BindTo(scoreProcessor.Combo);
+            currentCombo.BindValueChanged(combo =>
+                maxSize = Math.Min(1.75f, (float)(1.25 + 0.005 * combo.NewValue)), true);
+        }
+
+        public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
+        {
+            // Multiplying by 2 results in an initial size that is too large, hence 1.90 has been chosen
+            // Also avoids the HitObject bleeding around the edges of the bubble drawable at minimum size
+            bubbleSize = (float)(drawableRuleset.Beatmap.HitObjects.OfType<HitCircle>().First().Radius * 1.90f);
+            bubbleFade = drawableRuleset.Beatmap.HitObjects.OfType<HitCircle>().First().TimePreempt * 2;
+
+            // We want to hide the judgements since they are obscured by the BubbleDrawable (due to layering)
+            drawableRuleset.Playfield.DisplayJudgements.Value = false;
+
+            bubbleContainer = drawableRuleset.CreatePlayfieldAdjustmentContainer();
+
+            drawableRuleset.Overlays.Add(bubbleContainer);
+            drawableRuleset.Overlays.Add(bubblePool = new DrawablePool<BubbleDrawable>(100));
+        }
+
+        public void ApplyToDrawableHitObject(DrawableHitObject drawableObject)
+        {
+            drawableObject.OnNewResult += (drawable, _) =>
+            {
+                if (drawable is not DrawableOsuHitObject drawableOsuHitObject) return;
+
+                switch (drawableOsuHitObject.HitObject)
+                {
+                    case Slider:
+                    case SpinnerTick:
+                        break;
+
+                    default:
+                        addBubble();
+                        break;
+                }
+
+                void addBubble()
+                {
+                    BubbleDrawable bubble = bubblePool.Get();
+
+                    bubble.DrawableOsuHitObject = drawableOsuHitObject;
+                    bubble.InitialSize = new Vector2(bubbleSize);
+                    bubble.FadeTime = bubbleFade;
+                    bubble.MaxSize = maxSize;
+
+                    bubbleContainer.Add(bubble);
+                }
+            };
+
+            drawableObject.OnRevertResult += (drawable, _) =>
+            {
+                if (drawable.HitObject is SpinnerTick or Slider) return;
+
+                BubbleDrawable? lastBubble = bubbleContainer.OfType<BubbleDrawable>().LastOrDefault();
+
+                lastBubble?.ClearTransforms();
+                lastBubble?.Expire(true);
+            };
+        }
+
+        #region Pooled Bubble drawable
+
+        private partial class BubbleDrawable : PoolableDrawable
+        {
+            public DrawableOsuHitObject? DrawableOsuHitObject { get; set; }
+
+            public Vector2 InitialSize { get; set; }
+
+            public float MaxSize { get; set; }
+
+            public double FadeTime { get; set; }
+
+            private readonly Box colourBox;
+            private readonly CircularContainer content;
+
+            public BubbleDrawable()
+            {
+                Origin = Anchor.Centre;
+                InternalChild = content = new CircularContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    MaskingSmoothness = 2,
+                    BorderThickness = 0,
+                    BorderColour = Colour4.White,
+                    Masking = true,
+                    EdgeEffect = new EdgeEffectParameters
+                    {
+                        Type = EdgeEffectType.Shadow,
+                        Radius = 3,
+                        Colour = Colour4.Black.Opacity(0.05f),
+                    },
+                    Child = colourBox = new Box { RelativeSizeAxes = Axes.Both, }
+                };
+            }
+
+            protected override void PrepareForUse()
+            {
+                Debug.Assert(DrawableOsuHitObject.IsNotNull());
+
+                Colour = DrawableOsuHitObject.IsHit ? Colour4.White : Colour4.Black;
+                Scale = new Vector2(1);
+                Position = getPosition(DrawableOsuHitObject);
+                Size = InitialSize;
+
+                //We want to fade to a darker colour to avoid colours such as white hiding the "ripple" effect.
+                ColourInfo colourDarker = DrawableOsuHitObject.AccentColour.Value.Darken(0.1f);
+
+                // The absolute length of the bubble's animation, can be used in fractions for animations of partial length
+                double duration = 1700 + Math.Pow(FadeTime, 1.07f);
+
+                // Main bubble scaling based on combo
+                this.FadeTo(1)
+                    .ScaleTo(MaxSize, duration * 0.8f)
+                    .Then()
+                    // Pop at the end of the bubbles life time
+                    .ScaleTo(MaxSize * 1.5f, duration * 0.2f, Easing.OutQuint)
+                    .FadeOut(duration * 0.2f, Easing.OutCirc).Expire();
+
+                if (!DrawableOsuHitObject.IsHit) return;
+
+                content.BorderThickness = InitialSize.X / 3.5f;
+                content.BorderColour = Colour4.White;
+
+                colourBox.FadeColour(colourDarker);
+
+                content.TransformTo(nameof(BorderColour), colourDarker, duration * 0.3f, Easing.OutQuint);
+                // Ripple effect utilises the border to reduce drawable count
+                content.TransformTo(nameof(BorderThickness), 2f, duration * 0.3f, Easing.OutQuint)
+                       .Then()
+                       // Avoids transparency overlap issues during the bubble "pop"
+                       .TransformTo(nameof(BorderThickness), 0f);
+            }
+
+            private Vector2 getPosition(DrawableOsuHitObject drawableObject)
+            {
+                switch (drawableObject)
+                {
+                    // SliderHeads are derived from HitCircles,
+                    // so we must handle them before to avoid them using the wrong positioning logic
+                    case DrawableSliderHead:
+                        return drawableObject.HitObject.Position;
+
+                    // Using hitobject position will cause issues with HitCircle placement due to stack leniency.
+                    case DrawableHitCircle:
+                        return drawableObject.Position;
+
+                    default:
+                        return drawableObject.HitObject.Position;
+                }
+            }
+        }
+
+        #endregion
+    }
+}

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

@@ -27,7 +27,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "No need to chase the circles – your cursor is a magnet!";
         public override double ScoreMultiplier => 0.5;
-        public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay), typeof(OsuModRelax), typeof(OsuModRepel) };
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay), typeof(OsuModRelax), typeof(OsuModRepel), typeof(OsuModBubbles) };
 
         [SettingSource("Attraction strength", "How strong the pull is.", 0)]
         public BindableFloat AttractionStrength { get; } = new BindableFloat(0.5f)

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

@@ -9,7 +9,6 @@ using osu.Framework.Localisation;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
-using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Beatmaps;
@@ -28,7 +27,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(OsuModTargetPractice)).ToArray();
 
-        [SettingSource("Angle sharpness", "How sharp angles should be", SettingControlType = typeof(SettingsSlider<float>))]
+        [SettingSource("Angle sharpness", "How sharp angles should be")]
         public BindableFloat AngleSharpness { get; } = new BindableFloat(7)
         {
             MinValue = 1,

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

@@ -18,7 +18,7 @@ using static osu.Game.Input.Handlers.ReplayInputHandler;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModRelax : ModRelax, IUpdatableByPlayfield, IApplicableToDrawableRuleset<OsuHitObject>, IApplicableToPlayer
+    public class OsuModRelax : ModRelax, IUpdatableByPlayfield, IApplicableToDrawableRuleset<OsuHitObject>, IApplicableToPlayer, IHasNoTimedInputs
     {
         public override LocalisableString Description => @"You don't need to click. Give your clicking/tapping fingers a break from the heat of things.";
 

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

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "Hit objects run away!";
         public override double ScoreMultiplier => 1;
-        public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay), typeof(OsuModMagnetised) };
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay), typeof(OsuModMagnetised), typeof(OsuModBubbles) };
 
         [SettingSource("Repulsion strength", "How strong the repulsion is.", 0)]
         public BindableFloat RepulsionStrength { get; } = new BindableFloat(0.5f)

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

@@ -98,6 +98,7 @@ namespace osu.Game.Rulesets.Osu.Mods
                 ComboOffset = original.ComboOffset;
                 LegacyLastTickOffset = original.LegacyLastTickOffset;
                 TickDistanceMultiplier = original.TickDistanceMultiplier;
+                SliderVelocity = original.SliderVelocity;
             }
 
             protected override void CreateNestedHitObjects(CancellationToken cancellationToken)

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

@@ -75,18 +75,24 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         [BackgroundDependencyLoader]
         private void load()
         {
+            tailContainer = new Container<DrawableSliderTail> { RelativeSizeAxes = Axes.Both };
+
             AddRangeInternal(new Drawable[]
             {
                 shakeContainer = new ShakeContainer
                 {
                     ShakeDuration = 30,
                     RelativeSizeAxes = Axes.Both,
-                    Children = new Drawable[]
+                    Children = new[]
                     {
                         Body = new SkinnableDrawable(new OsuSkinComponentLookup(OsuSkinComponents.SliderBody), _ => new DefaultSliderBody(), confineMode: ConfineMode.NoScaling),
-                        tailContainer = new Container<DrawableSliderTail> { RelativeSizeAxes = Axes.Both },
+                        // proxied here so that the tail is drawn under repeats/ticks - legacy skins rely on this
+                        tailContainer.CreateProxy(),
                         tickContainer = new Container<DrawableSliderTick> { RelativeSizeAxes = Axes.Both },
                         repeatContainer = new Container<DrawableSliderRepeat> { RelativeSizeAxes = Axes.Both },
+                        // actual tail container is placed here to ensure that tail hitobjects are processed after ticks/repeats.
+                        // this is required for the correct operation of Score V2.
+                        tailContainer,
                     }
                 },
                 // slider head is not included in shake as it handles hit detection, and handles its own shaking.
@@ -133,14 +139,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
             // Note: base.LoadSamples() isn't called since the slider plays the tail's hitsounds for the time being.
 
-            if (HitObject.SampleControlPoint == null)
-            {
-                throw new InvalidOperationException($"{nameof(HitObject)}s must always have an attached {nameof(HitObject.SampleControlPoint)}."
-                                                    + $" This is an indication that {nameof(HitObject.ApplyDefaults)} has not been invoked on {this}.");
-            }
-
-            Samples.Samples = HitObject.TailSamples.Select(s => HitObject.SampleControlPoint.ApplyTo(s)).Cast<ISampleInfo>().ToArray();
-            slidingSample.Samples = HitObject.CreateSlidingSamples().Select(s => HitObject.SampleControlPoint.ApplyTo(s)).Cast<ISampleInfo>().ToArray();
+            Samples.Samples = HitObject.TailSamples.Cast<ISampleInfo>().ToArray();
+            slidingSample.Samples = HitObject.CreateSlidingSamples().Cast<ISampleInfo>().ToArray();
         }
 
         public override void StopAllSamples()

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

@@ -87,12 +87,15 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         protected override void UpdateInitialTransforms()
         {
+            // When snaking in is enabled, the first end circle needs to be delayed until the snaking completes.
+            bool delayFadeIn = DrawableSlider.SliderBody?.SnakingIn.Value == true && HitObject.RepeatIndex == 0;
+
             animDuration = Math.Min(300, HitObject.SpanDuration);
 
-            this.Animate(
-                d => d.FadeIn(animDuration),
-                d => d.ScaleTo(0.5f).ScaleTo(1f, animDuration * 2, Easing.OutElasticHalf)
-            );
+            this
+                .FadeOut()
+                .Delay(delayFadeIn ? (Slider?.TimePreempt ?? 0) / 3 : 0)
+                .FadeIn(HitObject.RepeatIndex == 0 ? HitObject.TimeFadeIn : animDuration);
         }
 
         protected override void UpdateHitStateTransforms(ArmedState state)

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

@@ -91,7 +91,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
             base.UpdateInitialTransforms();
 
-            CirclePiece.FadeInFromZero(HitObject.TimeFadeIn);
+            // When snaking in is enabled, the first end circle needs to be delayed until the snaking completes.
+            bool delayFadeIn = DrawableSlider.SliderBody?.SnakingIn.Value == true && HitObject.RepeatIndex == 0;
+
+            CirclePiece
+                .FadeOut()
+                .Delay(delayFadeIn ? (Slider?.TimePreempt ?? 0) / 3 : 0)
+                .FadeIn(HitObject.TimeFadeIn);
         }
 
         protected override void UpdateHitStateTransforms(ArmedState state)

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

@@ -126,7 +126,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
             base.LoadSamples();
 
-            spinningSample.Samples = HitObject.CreateSpinningSamples().Select(s => HitObject.SampleControlPoint.ApplyTo(s)).Cast<ISampleInfo>().ToArray();
+            spinningSample.Samples = HitObject.CreateSpinningSamples().Cast<ISampleInfo>().ToArray();
             spinningSample.Frequency.Value = spinning_sample_initial_frequency;
         }
 

osu.Game.Rulesets.Osu/Objects/Drawables/IRequireTracking.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
-
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
     public interface IRequireTracking

osu.Game.Rulesets.Osu/Objects/ISliderProgress.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
-
 namespace osu.Game.Rulesets.Osu.Objects
 {
     public interface ISliderProgress

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

@@ -10,18 +10,18 @@ using osu.Game.Rulesets.Objects;
 using System.Linq;
 using System.Threading;
 using Newtonsoft.Json;
+using osu.Framework.Bindables;
 using osu.Framework.Caching;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Beatmaps.Formats;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {
-    public class Slider : OsuHitObject, IHasPathWithRepeats
+    public class Slider : OsuHitObject, IHasPathWithRepeats, IHasSliderVelocity, IHasGenerateTicks
     {
         public double EndTime => StartTime + this.SpanCount() * Path.Distance / Velocity;
 
@@ -134,6 +134,21 @@ namespace osu.Game.Rulesets.Osu.Objects
         /// </summary>
         public bool OnlyJudgeNestedObjects = true;
 
+        public BindableNumber<double> SliderVelocityBindable { get; } = new BindableDouble(1)
+        {
+            Precision = 0.01,
+            MinValue = 0.1,
+            MaxValue = 10
+        };
+
+        public double SliderVelocity
+        {
+            get => SliderVelocityBindable.Value;
+            set => SliderVelocityBindable.Value = value;
+        }
+
+        public bool GenerateTicks { get; set; } = true;
+
         [JsonIgnore]
         public SliderHeadCircle HeadCircle { get; protected set; }
 
@@ -151,15 +166,11 @@ namespace osu.Game.Rulesets.Osu.Objects
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
 
             TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
-#pragma warning disable 618
-            var legacyDifficultyPoint = DifficultyControlPoint as LegacyBeatmapDecoder.LegacyDifficultyControlPoint;
-#pragma warning restore 618
 
-            double scoringDistance = BASE_SCORING_DISTANCE * difficulty.SliderMultiplier * DifficultyControlPoint.SliderVelocity;
-            bool generateTicks = legacyDifficultyPoint?.GenerateTicks ?? true;
+            double scoringDistance = BASE_SCORING_DISTANCE * difficulty.SliderMultiplier * SliderVelocity;
 
             Velocity = scoringDistance / timingPoint.BeatLength;
-            TickDistance = generateTicks ? (scoringDistance / difficulty.SliderTickRate * TickDistanceMultiplier) : double.PositiveInfinity;
+            TickDistance = GenerateTicks ? (scoringDistance / difficulty.SliderTickRate * TickDistanceMultiplier) : double.PositiveInfinity;
         }
 
         protected override void CreateNestedHitObjects(CancellationToken cancellationToken)

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

@@ -39,11 +39,8 @@ namespace osu.Game.Rulesets.Osu.Objects
             }
             else
             {
-                // taken from osu-stable
-                const float first_end_circle_preempt_adjust = 2 / 3f;
-
                 // The first end circle should fade in with the slider.
-                TimePreempt = (StartTime - slider.StartTime) + slider.TimePreempt * first_end_circle_preempt_adjust;
+                TimePreempt += StartTime - slider.StartTime;
             }
         }
 

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

@@ -72,7 +72,7 @@ namespace osu.Game.Rulesets.Osu.Objects
 
                 AddNested(i < SpinsRequired
                     ? new SpinnerTick { StartTime = startTime, SpinnerDuration = Duration }
-                    : new SpinnerBonusTick { StartTime = startTime, SpinnerDuration = Duration });
+                    : new SpinnerBonusTick { StartTime = startTime, SpinnerDuration = Duration, Samples = new[] { CreateHitSampleInfo("spinnerbonus") } });
             }
         }
 
@@ -91,7 +91,7 @@ namespace osu.Game.Rulesets.Osu.Objects
 
             return new[]
             {
-                SampleControlPoint.ApplyTo(referenceSample).With("spinnerspin")
+                referenceSample.With("spinnerspin")
             };
         }
     }

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

@@ -3,7 +3,6 @@
 
 #nullable disable
 
-using osu.Game.Audio;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Scoring;
 
@@ -11,11 +10,6 @@ namespace osu.Game.Rulesets.Osu.Objects
 {
     public class SpinnerBonusTick : SpinnerTick
     {
-        public SpinnerBonusTick()
-        {
-            Samples.Add(new HitSampleInfo("spinnerbonus"));
-        }
-
         public override Judgement CreateJudgement() => new OsuSpinnerBonusTickJudgement();
 
         public class OsuSpinnerBonusTickJudgement : OsuSpinnerTickJudgement

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -203,7 +203,8 @@ namespace osu.Game.Rulesets.Osu
                         new OsuModNoScope(),
                         new MultiMod(new OsuModMagnetised(), new OsuModRepel()),
                         new ModAdaptiveSpeed(),
-                        new OsuModFreezeFrame()
+                        new OsuModFreezeFrame(),
+                        new OsuModBubbles()
                     };
 
                 case ModType.System:
@@ -290,56 +291,32 @@ namespace osu.Game.Rulesets.Osu
             return base.GetDisplayNameForHitResult(result);
         }
 
-        public override StatisticRow[] CreateStatisticsForScore(ScoreInfo score, IBeatmap playableBeatmap)
+        public override StatisticItem[] CreateStatisticsForScore(ScoreInfo score, IBeatmap playableBeatmap)
         {
             var timedHitEvents = score.HitEvents.Where(e => e.HitObject is HitCircle && !(e.HitObject is SliderTailCircle)).ToList();
 
             return new[]
             {
-                new StatisticRow
+                new StatisticItem("Performance Breakdown", () => new PerformanceBreakdownChart(score, playableBeatmap)
                 {
-                    Columns = new[]
-                    {
-                        new StatisticItem("Performance Breakdown", () => new PerformanceBreakdownChart(score, playableBeatmap)
-                        {
-                            RelativeSizeAxes = Axes.X,
-                            AutoSizeAxes = Axes.Y
-                        }),
-                    }
-                },
-                new StatisticRow
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y
+                }),
+                new StatisticItem("Timing Distribution", () => new HitEventTimingDistributionGraph(timedHitEvents)
                 {
-                    Columns = new[]
-                    {
-                        new StatisticItem("Timing Distribution", () => new HitEventTimingDistributionGraph(timedHitEvents)
-                        {
-                            RelativeSizeAxes = Axes.X,
-                            Height = 250
-                        }, true),
-                    }
-                },
-                new StatisticRow
+                    RelativeSizeAxes = Axes.X,
+                    Height = 250
+                }, true),
+                new StatisticItem("Accuracy Heatmap", () => new AccuracyHeatmap(score, playableBeatmap)
                 {
-                    Columns = new[]
-                    {
-                        new StatisticItem("Accuracy Heatmap", () => new AccuracyHeatmap(score, playableBeatmap)
-                        {
-                            RelativeSizeAxes = Axes.X,
-                            Height = 250
-                        }, true),
-                    }
-                },
-                new StatisticRow
+                    RelativeSizeAxes = Axes.X,
+                    Height = 250
+                }, true),
+                new StatisticItem(string.Empty, () => new SimpleStatisticTable(3, new SimpleStatisticItem[]
                 {
-                    Columns = new[]
-                    {
-                        new StatisticItem(string.Empty, () => new SimpleStatisticTable(3, new SimpleStatisticItem[]
-                        {
-                            new AverageHitError(timedHitEvents),
-                            new UnstableRate(timedHitEvents)
-                        }), true)
-                    }
-                }
+                    new AverageHitError(timedHitEvents),
+                    new UnstableRate(timedHitEvents)
+                }), true)
             };
         }
 

osu.Game.Rulesets.Osu/OsuSkinComponents.cs

@@ -10,6 +10,7 @@ namespace osu.Game.Rulesets.Osu
         Cursor,
         CursorTrail,
         CursorParticles,
+        CursorRipple,
         SliderScorePoint,
         ReverseArrow,
         HitCircleText,

osu.Game.Rulesets.Osu/Scoring/OsuScoreProcessor.cs

@@ -1,12 +1,9 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
+using System;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Judgements;
-using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Scoring
@@ -18,21 +15,14 @@ namespace osu.Game.Rulesets.Osu.Scoring
         {
         }
 
-        protected override double ClassicScoreMultiplier => 36;
-
         protected override HitEvent CreateHitEvent(JudgementResult result)
             => base.CreateHitEvent(result).With((result as OsuHitCircleJudgementResult)?.CursorPositionAtHit);
 
-        protected override JudgementResult CreateResult(HitObject hitObject, Judgement judgement)
+        protected override double ComputeTotalScore(double comboProgress, double accuracyProgress, double bonusPortion)
         {
-            switch (hitObject)
-            {
-                case HitCircle:
-                    return new OsuHitCircleJudgementResult(hitObject, judgement);
-
-                default:
-                    return new OsuJudgementResult(hitObject, judgement);
-            }
+            return 700000 * comboProgress
+                   + 300000 * Math.Pow(Accuracy.Value, 10) * accuracyProgress
+                   + bonusPortion;
         }
     }
 }

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

@@ -48,21 +48,26 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
 
         private Bindable<bool> configHitLighting = null!;
 
+        private static readonly Vector2 circle_size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+
         [Resolved]
         private DrawableHitObject drawableObject { get; set; } = null!;
 
         public ArgonMainCirclePiece(bool withOuterFill)
         {
-            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+            Size = circle_size;
 
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
 
             InternalChildren = new Drawable[]
             {
-                outerFill = new Circle // renders white outer border and dark fill
+                outerFill = new Circle // renders dark fill
                 {
-                    Size = Size,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    // Slightly inset to prevent bleeding outside the ring
+                    Size = circle_size - new Vector2(1),
                     Alpha = withOuterFill ? 1 : 0,
                 },
                 outerGradient = new Circle // renders the outer bright gradient
@@ -88,7 +93,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
                     Masking = true,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Size = Size,
+                    Size = circle_size,
                     Child = new KiaiFlash
                     {
                         RelativeSizeAxes = Axes.Both,

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

@@ -98,7 +98,8 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
 
             using (BeginAbsoluteSequence(drawableObject.HitStateUpdateTime))
             {
-                this.FadeOut(duration, Easing.OutQuint);
+                // intentionally pile on an extra FadeOut to make it happen much faster
+                this.FadeOut(duration / 4, Easing.OutQuint);
                 icon.ScaleTo(defaultIconScale * icon_scale, duration, Easing.OutQuint);
             }
         }

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

@@ -3,11 +3,13 @@
 
 using System.Diagnostics;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Skinning;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 {
@@ -18,6 +20,12 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 
         private Drawable proxy = null!;
 
+        private Bindable<Color4> accentColour = null!;
+
+        private bool textureIsDefaultSkin;
+
+        private Drawable arrow = null!;
+
         [BackgroundDependencyLoader]
         private void load(ISkinSource skinSource)
         {
@@ -26,7 +34,9 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
             string lookupName = new OsuSkinComponentLookup(OsuSkinComponents.ReverseArrow).LookupName;
 
             var skin = skinSource.FindProvider(s => s.GetTexture(lookupName) != null);
-            InternalChild = skin?.GetAnimation(lookupName, true, true) ?? Empty();
+
+            InternalChild = arrow = (skin?.GetAnimation(lookupName, true, true) ?? Empty());
+            textureIsDefaultSkin = skin is ISkinTransformer transformer && transformer.Skin is DefaultLegacySkin;
         }
 
         protected override void LoadComplete()
@@ -39,6 +49,12 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
             {
                 drawableHitObject.HitObjectApplied += onHitObjectApplied;
                 onHitObjectApplied(drawableHitObject);
+
+                accentColour = drawableHitObject.AccentColour.GetBoundCopy();
+                accentColour.BindValueChanged(c =>
+                {
+                    arrow.Colour = textureIsDefaultSkin && c.NewValue.R + c.NewValue.G + c.NewValue.B > (600 / 255f) ? Color4.Black : Color4.White;
+                }, true);
             }
         }
 

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

@@ -100,6 +100,28 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 
                         return null;
 
+                    case OsuSkinComponents.CursorRipple:
+                        if (GetTexture("cursor-ripple") != null)
+                        {
+                            var ripple = this.GetAnimation("cursor-ripple", false, false);
+
+                            // In stable this element was scaled down to 50% and opacity 20%, but this makes the elements WAY too big and inflexible.
+                            // If anyone complains about these not being applied, this can be uncommented.
+                            //
+                            // But if no one complains I'd rather fix this in lazer. Wiki documentation doesn't mention size,
+                            // so we might be okay.
+                            //
+                            // if (ripple != null)
+                            // {
+                            //     ripple.Scale = new Vector2(0.5f);
+                            //     ripple.Alpha = 0.2f;
+                            // }
+
+                            return ripple;
+                        }
+
+                        return null;
+
                     case OsuSkinComponents.CursorParticles:
                         if (GetTexture("star2") != null)
                             return new LegacyCursorParticles();

osu.Game.Rulesets.Osu/Statistics/AccuracyHeatmap.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 System;
 using System.Diagnostics;
 using System.Linq;
@@ -13,6 +11,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Scoring;
 using osuTK;
@@ -36,8 +35,8 @@ namespace osu.Game.Rulesets.Osu.Statistics
 
         private const float rotation = 45;
 
-        private BufferedContainer bufferedGrid;
-        private GridContainer pointGrid;
+        private BufferedContainer bufferedGrid = null!;
+        private GridContainer pointGrid = null!;
 
         private readonly ScoreInfo score;
         private readonly IBeatmap playableBeatmap;
@@ -58,6 +57,8 @@ namespace osu.Game.Rulesets.Osu.Statistics
         [BackgroundDependencyLoader]
         private void load()
         {
+            const float line_extension = 0.2f;
+
             InternalChild = new Container
             {
                 Anchor = Anchor.Centre,
@@ -66,76 +67,99 @@ namespace osu.Game.Rulesets.Osu.Statistics
                 FillMode = FillMode.Fit,
                 Children = new Drawable[]
                 {
-                    new CircularContainer
-                    {
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        RelativeSizeAxes = Axes.Both,
-                        Size = new Vector2(inner_portion),
-                        Masking = true,
-                        BorderThickness = line_thickness,
-                        BorderColour = Color4.White,
-                        Child = new Box
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            Colour = Color4Extensions.FromHex("#202624")
-                        }
-                    },
                     new Container
                     {
                         RelativeSizeAxes = Axes.Both,
                         Children = new Drawable[]
                         {
+                            new CircularContainer
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                RelativeSizeAxes = Axes.Both,
+                                Size = new Vector2(inner_portion),
+                                Masking = true,
+                                BorderThickness = line_thickness,
+                                BorderColour = Color4.White,
+                                Child = new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = Color4Extensions.FromHex("#202624")
+                                }
+                            },
                             new Container
                             {
                                 RelativeSizeAxes = Axes.Both,
                                 Padding = new MarginPadding(1),
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Rotation = rotation,
                                 Child = new Container
                                 {
                                     RelativeSizeAxes = Axes.Both,
-                                    Masking = true,
                                     Children = new Drawable[]
                                     {
-                                        new Box
+                                        new Circle
                                         {
                                             Anchor = Anchor.Centre,
                                             Origin = Anchor.Centre,
-                                            EdgeSmoothness = new Vector2(1),
                                             RelativeSizeAxes = Axes.Y,
-                                            Height = 2, // We're rotating along a diagonal - we don't really care how big this is.
-                                            Width = line_thickness / 2,
-                                            Rotation = -rotation,
-                                            Alpha = 0.3f,
+                                            Width = line_thickness,
+                                            Height = inner_portion + line_extension,
+                                            Rotation = -rotation * 2,
+                                            Alpha = 0.6f,
                                         },
-                                        new Box
+                                        new Circle
                                         {
                                             Anchor = Anchor.Centre,
                                             Origin = Anchor.Centre,
-                                            EdgeSmoothness = new Vector2(1),
                                             RelativeSizeAxes = Axes.Y,
-                                            Height = 2, // We're rotating along a diagonal - we don't really care how big this is.
-                                            Width = line_thickness / 2, // adjust for edgesmoothness
-                                            Rotation = rotation
+                                            Width = line_thickness,
+                                            Height = inner_portion + line_extension,
                                         },
+                                        new OsuSpriteText
+                                        {
+                                            Text = "Overshoot",
+                                            Anchor = Anchor.Centre,
+                                            Origin = Anchor.BottomCentre,
+                                            Padding = new MarginPadding(3),
+                                            RelativePositionAxes = Axes.Both,
+                                            Y = -(inner_portion + line_extension) / 2,
+                                        },
+                                        new OsuSpriteText
+                                        {
+                                            Text = "Undershoot",
+                                            Anchor = Anchor.Centre,
+                                            Origin = Anchor.TopCentre,
+                                            Padding = new MarginPadding(3),
+                                            RelativePositionAxes = Axes.Both,
+                                            Y = (inner_portion + line_extension) / 2,
+                                        },
+                                        new Circle
+                                        {
+                                            Anchor = Anchor.Centre,
+                                            Origin = Anchor.TopCentre,
+                                            RelativePositionAxes = Axes.Both,
+                                            Y = -(inner_portion + line_extension) / 2,
+                                            Margin = new MarginPadding(-line_thickness / 2),
+                                            Width = line_thickness,
+                                            Height = 10,
+                                            Rotation = 45,
+                                        },
+                                        new Circle
+                                        {
+                                            Anchor = Anchor.Centre,
+                                            Origin = Anchor.TopCentre,
+                                            RelativePositionAxes = Axes.Both,
+                                            Y = -(inner_portion + line_extension) / 2,
+                                            Margin = new MarginPadding(-line_thickness / 2),
+                                            Width = line_thickness,
+                                            Height = 10,
+                                            Rotation = -45,
+                                        }
                                     }
                                 },
                             },
-                            new Box
-                            {
-                                Anchor = Anchor.TopRight,
-                                Origin = Anchor.TopRight,
-                                Width = 10,
-                                EdgeSmoothness = new Vector2(1),
-                                Height = line_thickness / 2, // adjust for edgesmoothness
-                            },
-                            new Box
-                            {
-                                Anchor = Anchor.TopRight,
-                                Origin = Anchor.TopRight,
-                                EdgeSmoothness = new Vector2(1),
-                                Width = line_thickness / 2, // adjust for edgesmoothness
-                                Height = 10,
-                            }
                         }
                     },
                     bufferedGrid = new BufferedContainer(cachedFrameBuffer: true)

osu.Game.Rulesets.Osu/UI/Cursor/CursorRippleVisualiser.cs

@@ -0,0 +1,105 @@
+// 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.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Pooling;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Game.Rulesets.Osu.Configuration;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Skinning.Default;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.UI.Cursor
+{
+    public partial class CursorRippleVisualiser : CompositeDrawable, IKeyBindingHandler<OsuAction>
+    {
+        private readonly Bindable<bool> showRipples = new Bindable<bool>(true);
+
+        private readonly DrawablePool<CursorRipple> ripplePool = new DrawablePool<CursorRipple>(20);
+
+        public CursorRippleVisualiser()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        public Vector2 CursorScale { get; set; } = Vector2.One;
+
+        [BackgroundDependencyLoader(true)]
+        private void load(OsuRulesetConfigManager? rulesetConfig)
+        {
+            rulesetConfig?.BindWith(OsuRulesetSetting.ShowCursorRipples, showRipples);
+        }
+
+        public bool OnPressed(KeyBindingPressEvent<OsuAction> e)
+        {
+            if (showRipples.Value)
+            {
+                AddInternal(ripplePool.Get(r =>
+                {
+                    r.Position = e.MousePosition;
+                    r.Scale = CursorScale;
+                }));
+            }
+
+            return false;
+        }
+
+        public void OnReleased(KeyBindingReleaseEvent<OsuAction> e)
+        {
+        }
+
+        private partial class CursorRipple : PoolableDrawable
+        {
+            private Drawable ripple = null!;
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                AutoSizeAxes = Axes.Both;
+                Origin = Anchor.Centre;
+
+                InternalChild = ripple = new SkinnableDrawable(new OsuSkinComponentLookup(OsuSkinComponents.CursorRipple), _ => new DefaultCursorRipple())
+                {
+                    Blending = BlendingParameters.Additive,
+                };
+            }
+
+            protected override void PrepareForUse()
+            {
+                base.PrepareForUse();
+
+                ClearTransforms(true);
+
+                ripple.ScaleTo(0.1f)
+                      .ScaleTo(1, 700, Easing.Out);
+
+                this
+                    .FadeOutFromOne(700)
+                    .Expire(true);
+            }
+        }
+
+        public partial class DefaultCursorRipple : CompositeDrawable
+        {
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                AutoSizeAxes = Axes.Both;
+
+                InternalChildren = new Drawable[]
+                {
+                    new RingPiece(3)
+                    {
+                        Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2),
+                        Alpha = 0.1f,
+                    }
+                };
+            }
+        }
+    }
+}

osu.Game.Rulesets.Osu/UI/Cursor/OsuCursorContainer.cs

@@ -40,6 +40,8 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
         private Bindable<float> userCursorScale;
         private Bindable<bool> autoCursorScale;
 
+        private readonly CursorRippleVisualiser rippleVisualiser;
+
         public OsuCursorContainer()
         {
             InternalChild = fadeContainer = new Container
@@ -48,6 +50,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                 Children = new[]
                 {
                     cursorTrail = new SkinnableDrawable(new OsuSkinComponentLookup(OsuSkinComponents.CursorTrail), _ => new DefaultCursorTrail(), confineMode: ConfineMode.NoScaling),
+                    rippleVisualiser = new CursorRippleVisualiser(),
                     new SkinnableDrawable(new OsuSkinComponentLookup(OsuSkinComponents.CursorParticles), confineMode: ConfineMode.NoScaling),
                 }
             };
@@ -82,6 +85,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                 var newScale = new Vector2(e.NewValue);
 
                 ActiveCursor.Scale = newScale;
+                rippleVisualiser.CursorScale = newScale;
                 cursorTrail.Scale = newScale;
             }, true);
 

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

@@ -64,7 +64,7 @@ namespace osu.Game.Rulesets.Osu.UI
 
             localCursorContainer?.Expire();
             localCursorContainer = null;
-            GameplayCursor?.ActiveCursor?.Show();
+            GameplayCursor?.ActiveCursor.Show();
         }
 
         protected override bool OnHover(HoverEvent e) => true;

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

@@ -43,6 +43,11 @@ namespace osu.Game.Rulesets.Osu.UI
                     LabelText = RulesetSettingsStrings.CursorTrail,
                     Current = config.GetBindable<bool>(OsuRulesetSetting.ShowCursorTrail)
                 },
+                new SettingsCheckbox
+                {
+                    LabelText = RulesetSettingsStrings.CursorRipples,
+                    Current = config.GetBindable<bool>(OsuRulesetSetting.ShowCursorRipples)
+                },
                 new SettingsEnumDropdown<PlayfieldBorderStyle>
                 {
                     LabelText = RulesetSettingsStrings.PlayfieldBorderStyle,

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

@@ -15,187 +15,175 @@ namespace osu.Game.Rulesets.Taiko.Tests.Judgements
         [Test]
         public void TestHitAllDrumRoll()
         {
-            const double hit_time = 1000;
-
             PerformTest(new List<ReplayFrame>
             {
                 new TaikoReplayFrame(0),
                 new TaikoReplayFrame(1000, TaikoAction.LeftCentre),
                 new TaikoReplayFrame(1001),
+                new TaikoReplayFrame(1250, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1251),
+                new TaikoReplayFrame(1500, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1501),
+                new TaikoReplayFrame(1750, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1751),
                 new TaikoReplayFrame(2000, TaikoAction.LeftCentre),
                 new TaikoReplayFrame(2001),
-            }, CreateBeatmap(new DrumRoll
-            {
-                StartTime = hit_time,
-                Duration = 1000
-            }));
+            }, CreateBeatmap(createDrumRoll(false)));
 
-            AssertJudgementCount(3);
+            AssertJudgementCount(6);
             AssertResult<DrumRollTick>(0, HitResult.SmallBonus);
             AssertResult<DrumRollTick>(1, HitResult.SmallBonus);
+            AssertResult<DrumRollTick>(2, HitResult.SmallBonus);
+            AssertResult<DrumRollTick>(3, HitResult.SmallBonus);
+            AssertResult<DrumRollTick>(4, HitResult.SmallBonus);
             AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
         }
 
         [Test]
         public void TestHitSomeDrumRoll()
         {
-            const double hit_time = 1000;
-
             PerformTest(new List<ReplayFrame>
             {
                 new TaikoReplayFrame(0),
                 new TaikoReplayFrame(2000, TaikoAction.LeftCentre),
                 new TaikoReplayFrame(2001),
-            }, CreateBeatmap(new DrumRoll
-            {
-                StartTime = hit_time,
-                Duration = 1000
-            }));
+            }, CreateBeatmap(createDrumRoll(false)));
 
-            AssertJudgementCount(3);
+            AssertJudgementCount(6);
             AssertResult<DrumRollTick>(0, HitResult.IgnoreMiss);
-            AssertResult<DrumRollTick>(1, HitResult.SmallBonus);
+            AssertResult<DrumRollTick>(1, HitResult.IgnoreMiss);
+            AssertResult<DrumRollTick>(2, HitResult.IgnoreMiss);
+            AssertResult<DrumRollTick>(3, HitResult.IgnoreMiss);
+            AssertResult<DrumRollTick>(4, HitResult.SmallBonus);
             AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
         }
 
         [Test]
         public void TestHitNoneDrumRoll()
         {
-            const double hit_time = 1000;
-
             PerformTest(new List<ReplayFrame>
             {
                 new TaikoReplayFrame(0),
-            }, CreateBeatmap(new DrumRoll
-            {
-                StartTime = hit_time,
-                Duration = 1000
-            }));
+            }, CreateBeatmap(createDrumRoll(false)));
 
-            AssertJudgementCount(3);
+            AssertJudgementCount(6);
             AssertResult<DrumRollTick>(0, HitResult.IgnoreMiss);
             AssertResult<DrumRollTick>(1, HitResult.IgnoreMiss);
+            AssertResult<DrumRollTick>(2, HitResult.IgnoreMiss);
+            AssertResult<DrumRollTick>(3, HitResult.IgnoreMiss);
+            AssertResult<DrumRollTick>(4, HitResult.IgnoreMiss);
             AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
         }
 
         [Test]
         public void TestHitAllStrongDrumRollWithOneKey()
         {
-            const double hit_time = 1000;
-
             PerformTest(new List<ReplayFrame>
             {
                 new TaikoReplayFrame(0),
                 new TaikoReplayFrame(1000, TaikoAction.LeftCentre),
                 new TaikoReplayFrame(1001),
+                new TaikoReplayFrame(1250, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1251),
+                new TaikoReplayFrame(1500, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1501),
+                new TaikoReplayFrame(1750, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1751),
                 new TaikoReplayFrame(2000, TaikoAction.LeftCentre),
                 new TaikoReplayFrame(2001),
-            }, CreateBeatmap(new DrumRoll
+            }, CreateBeatmap(createDrumRoll(true)));
+
+            AssertJudgementCount(12);
+
+            for (int i = 0; i < 5; i++)
             {
-                StartTime = hit_time,
-                Duration = 1000,
-                IsStrong = true
-            }));
-
-            AssertJudgementCount(6);
-
-            AssertResult<DrumRollTick>(0, HitResult.SmallBonus);
-            AssertResult<StrongNestedHitObject>(0, HitResult.LargeBonus);
-
-            AssertResult<DrumRollTick>(1, HitResult.SmallBonus);
-            AssertResult<StrongNestedHitObject>(1, HitResult.LargeBonus);
+                AssertResult<DrumRollTick>(i, HitResult.SmallBonus);
+                AssertResult<StrongNestedHitObject>(i, HitResult.LargeBonus);
+            }
 
             AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
-            AssertResult<StrongNestedHitObject>(2, HitResult.IgnoreHit);
+            AssertResult<StrongNestedHitObject>(5, HitResult.IgnoreHit);
         }
 
         [Test]
         public void TestHitSomeStrongDrumRollWithOneKey()
         {
-            const double hit_time = 1000;
-
             PerformTest(new List<ReplayFrame>
             {
                 new TaikoReplayFrame(0),
                 new TaikoReplayFrame(2000, TaikoAction.LeftCentre),
                 new TaikoReplayFrame(2001),
-            }, CreateBeatmap(new DrumRoll
-            {
-                StartTime = hit_time,
-                Duration = 1000,
-                IsStrong = true
-            }));
+            }, CreateBeatmap(createDrumRoll(true)));
 
-            AssertJudgementCount(6);
+            AssertJudgementCount(12);
 
             AssertResult<DrumRollTick>(0, HitResult.IgnoreMiss);
             AssertResult<StrongNestedHitObject>(0, HitResult.IgnoreMiss);
 
-            AssertResult<DrumRollTick>(1, HitResult.SmallBonus);
-            AssertResult<StrongNestedHitObject>(1, HitResult.LargeBonus);
+            AssertResult<DrumRollTick>(4, HitResult.SmallBonus);
+            AssertResult<StrongNestedHitObject>(4, HitResult.LargeBonus);
 
             AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
-            AssertResult<StrongNestedHitObject>(2, HitResult.IgnoreHit);
+            AssertResult<StrongNestedHitObject>(5, HitResult.IgnoreHit);
         }
 
         [Test]
         public void TestHitAllStrongDrumRollWithBothKeys()
         {
-            const double hit_time = 1000;
-
             PerformTest(new List<ReplayFrame>
             {
                 new TaikoReplayFrame(0),
                 new TaikoReplayFrame(1000, TaikoAction.LeftCentre, TaikoAction.RightCentre),
                 new TaikoReplayFrame(1001),
+                new TaikoReplayFrame(1250, TaikoAction.LeftCentre, TaikoAction.RightCentre),
+                new TaikoReplayFrame(1251),
+                new TaikoReplayFrame(1500, TaikoAction.LeftCentre, TaikoAction.RightCentre),
+                new TaikoReplayFrame(1501),
+                new TaikoReplayFrame(1750, TaikoAction.LeftCentre, TaikoAction.RightCentre),
+                new TaikoReplayFrame(1751),
                 new TaikoReplayFrame(2000, TaikoAction.LeftCentre, TaikoAction.RightCentre),
                 new TaikoReplayFrame(2001),
-            }, CreateBeatmap(new DrumRoll
+            }, CreateBeatmap(createDrumRoll(true)));
+
+            AssertJudgementCount(12);
+
+            for (int i = 0; i < 5; i++)
             {
-                StartTime = hit_time,
-                Duration = 1000,
-                IsStrong = true
-            }));
-
-            AssertJudgementCount(6);
-
-            AssertResult<DrumRollTick>(0, HitResult.SmallBonus);
-            AssertResult<StrongNestedHitObject>(0, HitResult.LargeBonus);
-
-            AssertResult<DrumRollTick>(1, HitResult.SmallBonus);
-            AssertResult<StrongNestedHitObject>(1, HitResult.LargeBonus);
+                AssertResult<DrumRollTick>(i, HitResult.SmallBonus);
+                AssertResult<StrongNestedHitObject>(i, HitResult.LargeBonus);
+            }
 
             AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
-            AssertResult<StrongNestedHitObject>(2, HitResult.IgnoreHit);
+            AssertResult<StrongNestedHitObject>(5, HitResult.IgnoreHit);
         }
 
         [Test]
         public void TestHitSomeStrongDrumRollWithBothKeys()
         {
-            const double hit_time = 1000;
-
             PerformTest(new List<ReplayFrame>
             {
                 new TaikoReplayFrame(0),
                 new TaikoReplayFrame(2000, TaikoAction.LeftCentre, TaikoAction.RightCentre),
                 new TaikoReplayFrame(2001),
-            }, CreateBeatmap(new DrumRoll
-            {
-                StartTime = hit_time,
-                Duration = 1000,
-                IsStrong = true
-            }));
+            }, CreateBeatmap(createDrumRoll(true)));
 
-            AssertJudgementCount(6);
+            AssertJudgementCount(12);
 
             AssertResult<DrumRollTick>(0, HitResult.IgnoreMiss);
             AssertResult<StrongNestedHitObject>(0, HitResult.IgnoreMiss);
 
-            AssertResult<DrumRollTick>(1, HitResult.SmallBonus);
-            AssertResult<StrongNestedHitObject>(1, HitResult.LargeBonus);
+            AssertResult<DrumRollTick>(4, HitResult.SmallBonus);
+            AssertResult<StrongNestedHitObject>(4, HitResult.LargeBonus);
 
             AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
-            AssertResult<StrongNestedHitObject>(2, HitResult.IgnoreHit);
+            AssertResult<StrongNestedHitObject>(5, HitResult.IgnoreHit);
         }
+
+        private DrumRoll createDrumRoll(bool strong) => new DrumRoll
+        {
+            StartTime = 1000,
+            Duration = 1000,
+            IsStrong = strong
+        };
     }
 }

osu.Game.Rulesets.Taiko.Tests/Skinning/TestSceneDrawableTaikoMascot.cs

@@ -91,8 +91,9 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
         {
             prepareDrawableRulesetAndBeatmap(false);
 
-            assertStateAfterResult(new JudgementResult(new Hit(), new TaikoJudgement()) { Type = HitResult.Great }, TaikoMascotAnimationState.Idle);
-            assertStateAfterResult(new JudgementResult(new Hit.StrongNestedHit(), new TaikoStrongJudgement()) { Type = HitResult.IgnoreMiss }, TaikoMascotAnimationState.Idle);
+            var hit = new Hit();
+            assertStateAfterResult(new JudgementResult(hit, new TaikoJudgement()) { Type = HitResult.Great }, TaikoMascotAnimationState.Idle);
+            assertStateAfterResult(new JudgementResult(new Hit.StrongNestedHit(hit), new TaikoStrongJudgement()) { Type = HitResult.IgnoreMiss }, TaikoMascotAnimationState.Idle);
         }
 
         [Test]

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

@@ -0,0 +1,337 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Timing;
+using osu.Game.Audio;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Objects.Drawables;
+using osu.Game.Rulesets.Taiko.UI;
+using osu.Game.Rulesets.UI;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Taiko.Tests
+{
+    public partial class TestSceneDrumSampleTriggerSource : OsuTestScene
+    {
+        private readonly ManualClock manualClock = new ManualClock();
+
+        [Cached(typeof(IScrollingInfo))]
+        private ScrollingTestContainer.TestScrollingInfo info = new ScrollingTestContainer.TestScrollingInfo
+        {
+            Direction = { Value = ScrollingDirection.Left },
+            TimeRange = { Value = 200 },
+        };
+
+        private ScrollingHitObjectContainer hitObjectContainer = null!;
+        private TestDrumSampleTriggerSource triggerSource = null!;
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            hitObjectContainer = new ScrollingHitObjectContainer();
+            manualClock.CurrentTime = 0;
+
+            Child = new Container
+            {
+                Clock = new FramedClock(manualClock),
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
+                {
+                    hitObjectContainer,
+                    triggerSource = new TestDrumSampleTriggerSource(hitObjectContainer)
+                }
+            };
+        });
+
+        [Test]
+        public void TestNormalHit()
+        {
+            AddStep("add hit with normal samples", () =>
+            {
+                var hit = new Hit
+                {
+                    StartTime = 100,
+                    Samples = new List<HitSampleInfo>
+                    {
+                        new HitSampleInfo(HitSampleInfo.HIT_NORMAL)
+                    }
+                };
+                hit.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+                var drawableHit = new DrawableHit(hit);
+                hitObjectContainer.Add(drawableHit);
+            });
+
+            AddAssert("most valid object is hit", () => triggerSource.GetMostValidObject(), Is.InstanceOf<Hit>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, SampleControlPoint.DEFAULT_BANK);
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, SampleControlPoint.DEFAULT_BANK);
+
+            AddStep("seek past hit", () => manualClock.CurrentTime = 200);
+            AddAssert("most valid object is hit", () => triggerSource.GetMostValidObject(), Is.InstanceOf<Hit>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, SampleControlPoint.DEFAULT_BANK);
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, SampleControlPoint.DEFAULT_BANK);
+        }
+
+        [Test]
+        public void TestSoftHit()
+        {
+            AddStep("add hit with soft samples", () =>
+            {
+                var hit = new Hit
+                {
+                    StartTime = 100,
+                    Samples = new List<HitSampleInfo>
+                    {
+                        new HitSampleInfo(HitSampleInfo.HIT_NORMAL, HitSampleInfo.BANK_SOFT)
+                    }
+                };
+                hit.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+                var drawableHit = new DrawableHit(hit);
+                hitObjectContainer.Add(drawableHit);
+            });
+
+            AddAssert("most valid object is hit", () => triggerSource.GetMostValidObject(), Is.InstanceOf<Hit>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, HitSampleInfo.BANK_SOFT);
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, HitSampleInfo.BANK_SOFT);
+
+            AddStep("seek past hit", () => manualClock.CurrentTime = 200);
+            AddAssert("most valid object is hit", () => triggerSource.GetMostValidObject(), Is.InstanceOf<Hit>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, HitSampleInfo.BANK_SOFT);
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, HitSampleInfo.BANK_SOFT);
+        }
+
+        [Test]
+        public void TestDrumStrongHit()
+        {
+            AddStep("add strong hit with drum samples", () =>
+            {
+                var hit = new Hit
+                {
+                    StartTime = 100,
+                    Samples = new List<HitSampleInfo>
+                    {
+                        new HitSampleInfo(HitSampleInfo.HIT_NORMAL, "drum"),
+                        new HitSampleInfo(HitSampleInfo.HIT_FINISH, "drum") // implies strong
+                    }
+                };
+                hit.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+                var drawableHit = new DrawableHit(hit);
+                hitObjectContainer.Add(drawableHit);
+            });
+
+            AddAssert("most valid object is strong nested hit", () => triggerSource.GetMostValidObject(), Is.InstanceOf<Hit.StrongNestedHit>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, "drum");
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, "drum");
+
+            AddStep("seek past hit", () => manualClock.CurrentTime = 200);
+            AddAssert("most valid object is hit", () => triggerSource.GetMostValidObject(), Is.InstanceOf<Hit>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, "drum");
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, "drum");
+        }
+
+        [Test]
+        public void TestNormalDrumRoll()
+        {
+            AddStep("add drum roll with normal samples", () =>
+            {
+                var drumRoll = new DrumRoll
+                {
+                    StartTime = 100,
+                    EndTime = 1100,
+                    Samples = new List<HitSampleInfo>
+                    {
+                        new HitSampleInfo(HitSampleInfo.HIT_NORMAL)
+                    }
+                };
+                drumRoll.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+                var drawableDrumRoll = new DrawableDrumRoll(drumRoll);
+                hitObjectContainer.Add(drawableDrumRoll);
+            });
+
+            AddAssert("most valid object is drum roll tick", () => triggerSource.GetMostValidObject(), Is.InstanceOf<DrumRollTick>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, SampleControlPoint.DEFAULT_BANK);
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, SampleControlPoint.DEFAULT_BANK);
+
+            AddStep("seek to middle of drum roll", () => manualClock.CurrentTime = 600);
+            AddAssert("most valid object is drum roll tick", () => triggerSource.GetMostValidObject(), Is.InstanceOf<DrumRollTick>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, SampleControlPoint.DEFAULT_BANK);
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, SampleControlPoint.DEFAULT_BANK);
+
+            AddStep("seek past drum roll", () => manualClock.CurrentTime = 1200);
+            AddAssert("most valid object is drum roll", () => triggerSource.GetMostValidObject(), Is.InstanceOf<DrumRoll>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, SampleControlPoint.DEFAULT_BANK);
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, SampleControlPoint.DEFAULT_BANK);
+        }
+
+        [Test]
+        public void TestSoftDrumRoll()
+        {
+            AddStep("add drum roll with soft samples", () =>
+            {
+                var drumRoll = new DrumRoll
+                {
+                    StartTime = 100,
+                    EndTime = 1100,
+                    Samples = new List<HitSampleInfo>
+                    {
+                        new HitSampleInfo(HitSampleInfo.HIT_NORMAL, HitSampleInfo.BANK_SOFT)
+                    }
+                };
+                drumRoll.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+                var drawableDrumRoll = new DrawableDrumRoll(drumRoll);
+                hitObjectContainer.Add(drawableDrumRoll);
+            });
+
+            AddAssert("most valid object is drum roll tick", () => triggerSource.GetMostValidObject(), Is.InstanceOf<DrumRollTick>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, HitSampleInfo.BANK_SOFT);
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, HitSampleInfo.BANK_SOFT);
+
+            AddStep("seek to middle of drum roll", () => manualClock.CurrentTime = 600);
+            AddAssert("most valid object is drum roll tick", () => triggerSource.GetMostValidObject(), Is.InstanceOf<DrumRollTick>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, HitSampleInfo.BANK_SOFT);
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, HitSampleInfo.BANK_SOFT);
+
+            AddStep("seek past drum roll", () => manualClock.CurrentTime = 1200);
+            AddAssert("most valid object is drum roll", () => triggerSource.GetMostValidObject(), Is.InstanceOf<DrumRoll>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, HitSampleInfo.BANK_SOFT);
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, HitSampleInfo.BANK_SOFT);
+        }
+
+        [Test]
+        public void TestDrumStrongDrumRoll()
+        {
+            AddStep("add strong drum roll with drum samples", () =>
+            {
+                var drumRoll = new DrumRoll
+                {
+                    StartTime = 100,
+                    EndTime = 1100,
+                    Samples = new List<HitSampleInfo>
+                    {
+                        new HitSampleInfo(HitSampleInfo.HIT_NORMAL, "drum"),
+                        new HitSampleInfo(HitSampleInfo.HIT_FINISH, "drum") // implies strong
+                    }
+                };
+                drumRoll.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+                var drawableDrumRoll = new DrawableDrumRoll(drumRoll);
+                hitObjectContainer.Add(drawableDrumRoll);
+            });
+
+            AddAssert("most valid object is drum roll tick's nested strong hit", () => triggerSource.GetMostValidObject(), Is.InstanceOf<DrumRollTick.StrongNestedHit>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, "drum");
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, "drum");
+
+            AddStep("seek to middle of drum roll", () => manualClock.CurrentTime = 600);
+            AddAssert("most valid object is drum roll tick's nested strong hit", () => triggerSource.GetMostValidObject(), Is.InstanceOf<DrumRollTick.StrongNestedHit>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, "drum");
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, "drum");
+
+            AddStep("seek past drum roll", () => manualClock.CurrentTime = 1200);
+            AddAssert("most valid object is drum roll", () => triggerSource.GetMostValidObject(), Is.InstanceOf<DrumRoll>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, "drum");
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, "drum");
+        }
+
+        [Test]
+        public void TestNormalSwell()
+        {
+            AddStep("add swell with normal samples", () =>
+            {
+                var swell = new Swell
+                {
+                    StartTime = 100,
+                    EndTime = 1100,
+                    Samples = new List<HitSampleInfo>
+                    {
+                        new HitSampleInfo(HitSampleInfo.HIT_NORMAL)
+                    }
+                };
+                swell.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+                var drawableSwell = new DrawableSwell(swell);
+                hitObjectContainer.Add(drawableSwell);
+            });
+
+            AddAssert("most valid object is swell tick", () => triggerSource.GetMostValidObject(), Is.InstanceOf<SwellTick>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, SampleControlPoint.DEFAULT_BANK);
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, SampleControlPoint.DEFAULT_BANK);
+
+            AddStep("seek to middle of swell", () => manualClock.CurrentTime = 600);
+            AddAssert("most valid object is swell tick", () => triggerSource.GetMostValidObject(), Is.InstanceOf<SwellTick>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, SampleControlPoint.DEFAULT_BANK);
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, SampleControlPoint.DEFAULT_BANK);
+
+            AddStep("seek past swell", () => manualClock.CurrentTime = 1200);
+            AddAssert("most valid object is swell", () => triggerSource.GetMostValidObject(), Is.InstanceOf<Swell>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, SampleControlPoint.DEFAULT_BANK);
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, SampleControlPoint.DEFAULT_BANK);
+        }
+
+        [Test]
+        public void TestDrumSwell()
+        {
+            AddStep("add swell with drum samples", () =>
+            {
+                var swell = new Swell
+                {
+                    StartTime = 100,
+                    EndTime = 1100,
+                    Samples = new List<HitSampleInfo>
+                    {
+                        new HitSampleInfo(HitSampleInfo.HIT_NORMAL, "drum")
+                    }
+                };
+                swell.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+                var drawableSwell = new DrawableSwell(swell);
+                hitObjectContainer.Add(drawableSwell);
+            });
+
+            AddAssert("most valid object is swell tick", () => triggerSource.GetMostValidObject(), Is.InstanceOf<SwellTick>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, "drum");
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, "drum");
+
+            AddStep("seek to middle of swell", () => manualClock.CurrentTime = 600);
+            AddAssert("most valid object is swell tick", () => triggerSource.GetMostValidObject(), Is.InstanceOf<SwellTick>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, "drum");
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, "drum");
+
+            AddStep("seek past swell", () => manualClock.CurrentTime = 1200);
+            AddAssert("most valid object is swell", () => triggerSource.GetMostValidObject(), Is.InstanceOf<Swell>);
+            checkSound(HitType.Centre, HitSampleInfo.HIT_NORMAL, "drum");
+            checkSound(HitType.Rim, HitSampleInfo.HIT_CLAP, "drum");
+        }
+
+        private void checkSound(HitType hitType, string expectedName, string expectedBank)
+        {
+            AddStep($"hit {hitType}", () => triggerSource.Play(hitType));
+            AddAssert($"last played sample is {expectedName}", () => triggerSource.LastPlayedSamples!.OfType<HitSampleInfo>().Single().Name, () => Is.EqualTo(expectedName));
+            AddAssert($"last played sample has {expectedBank} bank", () => triggerSource.LastPlayedSamples!.OfType<HitSampleInfo>().Single().Bank, () => Is.EqualTo(expectedBank));
+        }
+
+        private partial class TestDrumSampleTriggerSource : DrumSampleTriggerSource
+        {
+            public ISampleInfo[]? LastPlayedSamples { get; private set; }
+
+            public TestDrumSampleTriggerSource(HitObjectContainer hitObjectContainer)
+                : base(hitObjectContainer)
+            {
+            }
+
+            protected override void PlaySamples(ISampleInfo[] samples)
+            {
+                base.PlaySamples(samples);
+                LastPlayedSamples = samples;
+            }
+
+            public new HitObject GetMostValidObject() => base.GetMostValidObject();
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs

@@ -64,7 +64,9 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
 
                 foreach (HitObject hitObject in original.HitObjects)
                 {
-                    double nextScrollSpeed = hitObject.DifficultyControlPoint.SliderVelocity;
+                    if (hitObject is not IHasSliderVelocity hasSliderVelocity) continue;
+
+                    double nextScrollSpeed = hasSliderVelocity.SliderVelocity;
                     EffectControlPoint currentEffectPoint = converted.ControlPointInfo.EffectPointAt(hitObject.StartTime);
 
                     if (!Precision.AlmostEquals(lastScrollSpeed, nextScrollSpeed, acceptableDifference: currentEffectPoint.ScrollSpeedBindable.Precision))
@@ -90,6 +92,14 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                 }).ToList();
             }
 
+            // TODO: stable makes the last tick of a drumroll non-required when the next object is too close.
+            // This probably needs to be reimplemented:
+            //
+            // List<HitObject> hitobjects = hitObjectManager.hitObjects;
+            // int ind = hitobjects.IndexOf(this);
+            // if (i < hitobjects.Count - 1 && hitobjects[i + 1].HittableStartTime - (EndTime + (int)TickSpacing) <= (int)TickSpacing)
+            //     lastTickHittable = false;
+
             return converted;
         }
 
@@ -131,7 +141,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                             StartTime = obj.StartTime,
                             Samples = obj.Samples,
                             Duration = taikoDuration,
-                            TickRate = beatmap.Difficulty.SliderTickRate == 3 ? 3 : 4
+                            SliderVelocity = obj is IHasSliderVelocity velocityData ? velocityData.SliderVelocity : 1
                         };
                     }
 
@@ -177,15 +187,14 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
             double distance = distanceData.Distance * spans * LegacyBeatmapEncoder.LEGACY_TAIKO_VELOCITY_MULTIPLIER;
 
             TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(obj.StartTime);
-            DifficultyControlPoint difficultyPoint = obj.DifficultyControlPoint;
 
             double beatLength;
-#pragma warning disable 618
-            if (difficultyPoint is LegacyBeatmapDecoder.LegacyDifficultyControlPoint legacyDifficultyPoint)
-#pragma warning restore 618
-                beatLength = timingPoint.BeatLength * legacyDifficultyPoint.BpmMultiplier;
+            if (obj.LegacyBpmMultiplier.HasValue)
+                beatLength = timingPoint.BeatLength * obj.LegacyBpmMultiplier.Value;
+            else if (obj is IHasSliderVelocity hasSliderVelocity)
+                beatLength = timingPoint.BeatLength / hasSliderVelocity.SliderVelocity;
             else
-                beatLength = timingPoint.BeatLength / difficultyPoint.SliderVelocity;
+                beatLength = timingPoint.BeatLength;
 
             double sliderScoringPointDistance = osu_base_scoring_distance * beatmap.Difficulty.SliderMultiplier / beatmap.Difficulty.SliderTickRate;
 

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

@@ -25,6 +25,8 @@ namespace osu.Game.Rulesets.Taiko.Edit.Blueprints
 
         private readonly IHasDuration spanPlacementObject;
 
+        protected override bool IsValidForPlacement => spanPlacementObject.Duration > 0;
+
         public TaikoSpanPlacementBlueprint(HitObject hitObject)
             : base(hitObject)
         {
@@ -73,7 +75,7 @@ namespace osu.Game.Rulesets.Taiko.Edit.Blueprints
                 return;
 
             base.OnMouseUp(e);
-            EndPlacement(spanPlacementObject.Duration > 0);
+            EndPlacement(true);
         }
 
         public override void UpdateTimeAndPosition(SnapResult result)