Revert "Block input to objects lying under already-hit hitcircles when classic note lock is active"

This reverts commit 03c61a573e.

The goal here was to handle an edge case discovered during work on note
lock, wherein it was determined that on stable hit circles would block
input from reaching objects underneath them. However, the change
mentioned above did that _too_ hard and caused overlaps to also be
blocked even long past a hit circle has been faded out.

Revert the change pending further (and more careful) investigation.

README.md

@@ -12,43 +12,40 @@
 
 A free-to-win rhythm game. Rhythm is just a *click* away!
 
-This is the future – and final – iteration of the [osu!](https://osu.ppy.sh) game client which marks the beginning of an open era! Currently known by and released under the release codename "*lazer*". As in sharper than cutting-edge.
+The future of [osu!](https://osu.ppy.sh) and the beginning of an open era! Currently known by and released under the release codename "*lazer*". As in sharper than cutting-edge.
 
 ## Status
 
-This project is under constant development, but we do our best to keep things in a stable state. Players are encouraged to install from a release alongside their stable *osu!* client. This project will continue to evolve until we eventually reach the point where most users prefer it over the previous "osu!stable" release.
+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.
 
-A few resources are available as starting points to getting involved and understanding the project:
+**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).
-- Track our current efforts [towards full "ranked play" support](https://github.com/orgs/ppy/projects/13?query=is%3Aopen+sort%3Aupdated-desc).
 
 ## Running osu!
 
-If you are just looking to give the game a whirl, you can grab the latest release for your platform:
+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 release:
+**Latest release:**
 
 | [Windows 8.1+ (x64)](https://github.com/ppy/osu/releases/latest/download/install.exe) | macOS 10.15+ ([Intel](https://github.com/ppy/osu/releases/latest/download/osu.app.Intel.zip), [Apple Silicon](https://github.com/ppy/osu/releases/latest/download/osu.app.Apple.Silicon.zip)) | [Linux (x64)](https://github.com/ppy/osu/releases/latest/download/osu.AppImage) | [iOS 13.4+](https://osu.ppy.sh/home/testflight) | [Android 5+](https://github.com/ppy/osu/releases/latest/download/sh.ppy.osulazer.apk) |
 | ------------- | ------------- | ------------- | ------------- | ------------- |
 
-You can also generally download a version for your current device from the [osu! site](https://osu.ppy.sh/home/download).
+- The iOS testflight link may fill up (Apple has a hard limit of 10,000 users). We reset it occasionally when this happens. Please do not ask about this. Check back regularly for link resets or follow [peppy](https://twitter.com/ppy) on twitter for announcements of link resets.
 
 If your platform is not listed above, there is still a chance you can manually build it by following the instructions below.
 
-**For iOS/iPadOS users**: The iOS testflight link fills up very fast (Apple has a hard limit of 10,000 users). We reset it occasionally. Please do not ask about this. Check back regularly for link resets or follow [peppy](https://twitter.com/ppy) on twitter for announcements. Our goal is to get the game on mobile app stores in early 2024.
-
 ## Developing a custom ruleset
 
-osu! is designed to allow user-created gameplay variations, called "rulesets". Building one of these allows a developer to harness the power of the osu! beatmap library, game engine, and general UX for a new style of gameplay. To get started working on a ruleset, we have some templates available [here](https://github.com/ppy/osu/tree/master/Templates).
+osu! is designed to have extensible modular gameplay modes, called "rulesets". Building one of these allows a developer to harness the power of osu! for their own game style. To get started working on a ruleset, we have some templates available [here](https://github.com/ppy/osu/tree/master/Templates).
 
 You can see some examples of custom rulesets by visiting the [custom ruleset directory](https://github.com/ppy/osu/discussions/13096).
 
 ## Developing osu!
 
-### Prerequisites
-
 Please make sure you have the following prerequisites:
 
 - A desktop platform with the [.NET 6.0 SDK](https://dotnet.microsoft.com/download) installed.
@@ -72,19 +69,9 @@ git pull
 
 ### Building
 
-#### From an IDE
+Build configurations for the recommended IDEs (listed above) are included. You should use the provided Build/Run functionality of your IDE to get things going. When testing or building new components, it's highly encouraged you use the `VisualTests` project/configuration. More information on this is provided [below](#contributing).
 
-You should load the solution via one of the platform-specific `.slnf` files, rather than the main `.sln`. This will reduce dependencies and hide platforms that you don't care about. Valid `.slnf` files are:
-
-- `osu.Desktop.slnf` (most common)
-- `osu.Android.slnf`
-- `osu.iOS.slnf`
-
-Run configurations for the recommended IDEs (listed above) are included. You should use the provided Build/Run functionality of your IDE to get things going. When testing or building new components, it's highly encouraged you use the `osu! (Tests)` project/configuration. More information on this is provided [below](#contributing).
-
-To build for mobile platforms, you will likely need to run `sudo dotnet workload restore` if you haven't done so previously. This will install Android/iOS tooling required to complete the build.
-
-#### From CLI
+- Visual Studio / Rider users should load the project via one of the platform-specific `.slnf` files, rather than the main `.sln`. This will allow access to template run configurations.
 
 You can also build and run *osu!* from the command-line with a single command:
 
@@ -92,10 +79,12 @@ You can also build and run *osu!* from the command-line with a single command:
 dotnet run --project osu.Desktop
 ```
 
-When running locally to do any kind of performance testing, make sure to add `-c Release` to the build command, as the overhead of running with the default `Debug` configuration can be large (especially when testing with local framework modifications as below).
+If you are not interested in debugging *osu!*, you can add `-c Release` to gain performance. In this case, you must replace `Debug` with `Release` in any commands mentioned in this document.
 
 If the build fails, try to restore NuGet packages with `dotnet restore`.
 
+_Due to a historical feature gap between .NET Core and Xamarin, running `dotnet` CLI from the root directory will not work for most commands. This can be resolved by specifying a target `.csproj` or the helper project at `build/Desktop.proj`. Configurations have been provided to work around this issue for all supported IDEs mentioned above._
+
 ### Testing with resource/framework modifications
 
 Sometimes it may be necessary to cross-test changes in [osu-resources](https://github.com/ppy/osu-resources) or [osu-framework](https://github.com/ppy/osu-framework). This can be quickly achieved using included commands:

Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform.Tests/osu.Game.Rulesets.EmptyFreeform.Tests.csproj

@@ -9,9 +9,9 @@
       <GenerateProgramFile>false</GenerateProgramFile>
     </PropertyGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
     <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\osu.Game.Rulesets.EmptyFreeform\osu.Game.Rulesets.EmptyFreeform.csproj" />

Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon.Tests/osu.Game.Rulesets.Pippidon.Tests.csproj

@@ -9,9 +9,9 @@
     <GenerateProgramFile>false</GenerateProgramFile>
   </PropertyGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
     <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj" />

Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling.Tests/osu.Game.Rulesets.EmptyScrolling.Tests.csproj

@@ -9,9 +9,9 @@
     <GenerateProgramFile>false</GenerateProgramFile>
   </PropertyGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
     <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\osu.Game.Rulesets.EmptyScrolling\osu.Game.Rulesets.EmptyScrolling.csproj" />

Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon.Tests/osu.Game.Rulesets.Pippidon.Tests.csproj

@@ -9,9 +9,9 @@
     <GenerateProgramFile>false</GenerateProgramFile>
   </PropertyGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
     <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj" />

osu.Android.props

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

osu.Desktop/osu.Desktop.csproj

@@ -26,7 +26,7 @@
     <PackageReference Include="Clowd.Squirrel" Version="2.9.42" />
     <PackageReference Include="Mono.Posix.NETStandard" Version="1.0.0" />
     <PackageReference Include="System.IO.Packaging" Version="7.0.0" />
-    <PackageReference Include="DiscordRichPresence" Version="1.2.1.24" />
+    <PackageReference Include="DiscordRichPresence" Version="1.1.4.20" />
   </ItemGroup>
   <ItemGroup Label="Resources">
     <EmbeddedResource Include="lazer.ico" />

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

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

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.SliderVelocityMultiplierBindable.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.SliderVelocityMultiplierBindable.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.SliderVelocityMultiplierBindable.IsDefault);
+            AddAssert("default slider velocity", () => hitObject.SliderVelocityBindable.IsDefault);
 
             addDragStartStep(times[1], positions[1]);
             AddMouseMoveStep(times[1], 400);
-            AddAssert("slider velocity changed", () => !hitObject.SliderVelocityMultiplierBindable.IsDefault);
+            AddAssert("slider velocity changed", () => !hitObject.SliderVelocityBindable.IsDefault);
         }
 
         [Test]

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

@@ -1,157 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using NUnit.Framework;
-using osu.Framework.Bindables;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Catch.Beatmaps;
-using osu.Game.Rulesets.Catch.Judgements;
-using osu.Game.Rulesets.Catch.Objects;
-using osu.Game.Rulesets.Catch.Scoring;
-using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Tests.Visual.Gameplay;
-
-namespace osu.Game.Rulesets.Catch.Tests
-{
-    [TestFixture]
-    public partial class TestSceneScoring : ScoringTestScene
-    {
-        public TestSceneScoring()
-            : base(supportsNonPerfectJudgements: false)
-        {
-        }
-
-        private Bindable<double> scoreMultiplier { get; } = new BindableDouble
-        {
-            Default = 4,
-            Value = 4
-        };
-
-        protected override IBeatmap CreateBeatmap(int maxCombo)
-        {
-            var beatmap = new CatchBeatmap();
-            for (int i = 0; i < maxCombo; ++i)
-                beatmap.HitObjects.Add(new Fruit());
-            return beatmap;
-        }
-
-        protected override IScoringAlgorithm CreateScoreV1() => new ScoreV1 { ScoreMultiplier = { BindTarget = scoreMultiplier } };
-
-        protected override IScoringAlgorithm CreateScoreV2(int maxCombo) => new ScoreV2(maxCombo);
-
-        protected override ProcessorBasedScoringAlgorithm CreateScoreAlgorithm(IBeatmap beatmap, ScoringMode mode) => new CatchProcessorBasedScoringAlgorithm(beatmap, mode);
-
-        [Test]
-        public void TestBasicScenarios()
-        {
-            AddStep("set up score multiplier", () =>
-            {
-                scoreMultiplier.BindValueChanged(_ => Rerun());
-            });
-            AddStep("set max combo to 100", () => MaxCombo.Value = 100);
-            AddStep("set perfect score", () =>
-            {
-                NonPerfectLocations.Clear();
-                MissLocations.Clear();
-            });
-            AddStep("set score with misses", () =>
-            {
-                NonPerfectLocations.Clear();
-                MissLocations.Clear();
-                MissLocations.AddRange(new[] { 24d, 49 });
-            });
-            AddSliderStep("adjust score multiplier", 0, 10, (int)scoreMultiplier.Default, multiplier => scoreMultiplier.Value = multiplier);
-        }
-
-        private const int base_great = 300;
-
-        private class ScoreV1 : IScoringAlgorithm
-        {
-            private int currentCombo;
-
-            public BindableDouble ScoreMultiplier { get; } = new BindableDouble();
-
-            public void ApplyHit() => applyHitV1(base_great);
-
-            public void ApplyNonPerfect() => throw new NotSupportedException("catch does not have \"non-perfect\" judgements.");
-
-            public void ApplyMiss() => applyHitV1(0);
-
-            private void applyHitV1(int baseScore)
-            {
-                if (baseScore == 0)
-                {
-                    currentCombo = 0;
-                    return;
-                }
-
-                TotalScore += baseScore;
-
-                // combo multiplier
-                // ReSharper disable once PossibleLossOfFraction
-                TotalScore += (int)(Math.Max(0, currentCombo - 1) * (baseScore / 25 * ScoreMultiplier.Value));
-
-                currentCombo++;
-            }
-
-            public long TotalScore { get; private set; }
-        }
-
-        private class ScoreV2 : IScoringAlgorithm
-        {
-            private int currentCombo;
-            private double comboPortion;
-
-            private readonly double comboPortionMax;
-
-            private const double combo_base = 4;
-            private const int combo_cap = 200;
-
-            public ScoreV2(int maxCombo)
-            {
-                for (int i = 0; i < maxCombo; i++)
-                    ApplyHit();
-
-                comboPortionMax = comboPortion;
-
-                currentCombo = 0;
-                comboPortion = 0;
-            }
-
-            public void ApplyHit() => applyHitV2(base_great);
-
-            public void ApplyNonPerfect() => throw new NotSupportedException("catch does not have \"non-perfect\" judgements.");
-
-            private void applyHitV2(int baseScore)
-            {
-                comboPortion += baseScore * Math.Min(Math.Max(0.5, Math.Log(++currentCombo, combo_base)), Math.Log(combo_cap, combo_base));
-            }
-
-            public void ApplyMiss()
-            {
-                currentCombo = 0;
-            }
-
-            public long TotalScore
-                => (int)Math.Round(1000000 * comboPortion / comboPortionMax); // vast simplification, as we're not doing ticks here.
-        }
-
-        private class CatchProcessorBasedScoringAlgorithm : ProcessorBasedScoringAlgorithm
-        {
-            public CatchProcessorBasedScoringAlgorithm(IBeatmap beatmap, ScoringMode mode)
-                : base(beatmap, mode)
-            {
-            }
-
-            protected override ScoreProcessor CreateScoreProcessor() => new CatchScoreProcessor();
-
-            protected override JudgementResult CreatePerfectJudgementResult() => new CatchJudgementResult(new Fruit(), new CatchJudgement()) { Type = HitResult.Great };
-
-            protected override JudgementResult CreateNonPerfectJudgementResult() => throw new NotSupportedException("catch does not have \"non-perfect\" judgements.");
-
-            protected override JudgementResult CreateMissJudgementResult() => new CatchJudgementResult(new Fruit(), new CatchJudgement()) { Type = HitResult.Miss };
-        }
-    }
-}

osu.Game.Rulesets.Catch.Tests/osu.Game.Rulesets.Catch.Tests.csproj

@@ -1,9 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
     <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
   </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>

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

@@ -43,7 +43,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                         ComboOffset = comboData?.ComboOffset ?? 0,
                         LegacyLastTickOffset = (obj as IHasLegacyLastTickOffset)?.LegacyLastTickOffset ?? 0,
                         LegacyConvertedY = yPositionData?.Y ?? CatchHitObject.DEFAULT_LEGACY_CONVERT_Y,
-                        SliderVelocityMultiplier = sliderVelocityData?.SliderVelocityMultiplier ?? 1
+                        SliderVelocity = sliderVelocityData?.SliderVelocity ?? 1
                     }.Yield();
 
                 case IHasDuration endTime:

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -25,7 +25,6 @@ using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.Scoring.Legacy;
 using osu.Game.Rulesets.UI;
 using osu.Game.Scoring;
 using osu.Game.Screens.Ranking.Statistics;

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

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

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

@@ -2,26 +2,33 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.Scoring.Legacy;
 
 namespace osu.Game.Rulesets.Catch.Difficulty
 {
     internal class CatchLegacyScoreSimulator : ILegacyScoreSimulator
     {
+        public int AccuracyScore { get; private set; }
+
+        public int ComboScore { get; private set; }
+
+        public double BonusScoreRatio => legacyBonusScore == 0 ? 0 : (double)modernBonusScore / legacyBonusScore;
+
         private int legacyBonusScore;
-        private int standardisedBonusScore;
+        private int modernBonusScore;
         private int combo;
 
         private double scoreMultiplier;
 
-        public LegacyScoreAttributes Simulate(IWorkingBeatmap workingBeatmap, IBeatmap playableBeatmap)
+        public void Simulate(IWorkingBeatmap workingBeatmap, IBeatmap playableBeatmap, IReadOnlyList<Mod> mods)
         {
             IBeatmap baseBeatmap = workingBeatmap.Beatmap;
 
@@ -63,19 +70,13 @@ namespace osu.Game.Rulesets.Catch.Difficulty
                  + baseBeatmap.Difficulty.CircleSize
                  + Math.Clamp((float)objectCount / drainLength * 8, 0, 16)) / 38 * 5);
 
-            scoreMultiplier = difficultyPeppyStars;
-
-            LegacyScoreAttributes attributes = new LegacyScoreAttributes();
+            scoreMultiplier = difficultyPeppyStars * mods.Aggregate(1.0, (current, mod) => current * mod.ScoreMultiplier);
 
             foreach (var obj in playableBeatmap.HitObjects)
-                simulateHit(obj, ref attributes);
-
-            attributes.BonusScoreRatio = legacyBonusScore == 0 ? 0 : (double)standardisedBonusScore / legacyBonusScore;
-
-            return attributes;
+                simulateHit(obj);
         }
 
-        private void simulateHit(HitObject hitObject, ref LegacyScoreAttributes attributes)
+        private void simulateHit(HitObject hitObject)
         {
             bool increaseCombo = true;
             bool addScoreComboMultiplier = false;
@@ -111,28 +112,28 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
                 case JuiceStream:
                     foreach (var nested in hitObject.NestedHitObjects)
-                        simulateHit(nested, ref attributes);
+                        simulateHit(nested);
                     return;
 
                 case BananaShower:
                     foreach (var nested in hitObject.NestedHitObjects)
-                        simulateHit(nested, ref attributes);
+                        simulateHit(nested);
                     return;
             }
 
             if (addScoreComboMultiplier)
             {
                 // ReSharper disable once PossibleLossOfFraction (intentional to match osu-stable...)
-                attributes.ComboScore += (int)(Math.Max(0, combo - 1) * (scoreIncrease / 25 * scoreMultiplier));
+                ComboScore += (int)(Math.Max(0, combo - 1) * (scoreIncrease / 25 * scoreMultiplier));
             }
 
             if (isBonus)
             {
                 legacyBonusScore += scoreIncrease;
-                standardisedBonusScore += Judgement.ToNumericResult(bonusResult);
+                modernBonusScore += Judgement.ToNumericResult(bonusResult);
             }
             else
-                attributes.AccuracyScore += scoreIncrease;
+                AccuracyScore += scoreIncrease;
 
             if (increaseCombo)
                 combo++;

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

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

@@ -25,7 +25,6 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Edit
 {
-    // we're also a ScrollingHitObjectComposer candidate, but can't be everything can we?
     public partial class CatchHitObjectComposer : DistancedHitObjectComposer<CatchHitObject>
     {
         private const float distance_snap_radius = 50;
@@ -141,7 +140,7 @@ namespace osu.Game.Rulesets.Catch.Edit
             return base.OnPressed(e);
         }
 
-        protected override DrawableRuleset<CatchHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods) =>
+        protected override DrawableRuleset<CatchHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod>? mods = null) =>
             new DrawableCatchEditorRuleset(ruleset, beatmap, mods)
             {
                 TimeRangeMultiplier = { BindTarget = timeRangeMultiplier, }

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

@@ -28,17 +28,17 @@ namespace osu.Game.Rulesets.Catch.Objects
 
         public int RepeatCount { get; set; }
 
-        public BindableNumber<double> SliderVelocityMultiplierBindable { get; } = new BindableDouble(1)
+        public BindableNumber<double> SliderVelocityBindable { get; } = new BindableDouble(1)
         {
             Precision = 0.01,
             MinValue = 0.1,
             MaxValue = 10
         };
 
-        public double SliderVelocityMultiplier
+        public double SliderVelocity
         {
-            get => SliderVelocityMultiplierBindable.Value;
-            set => SliderVelocityMultiplierBindable.Value = value;
+            get => SliderVelocityBindable.Value;
+            set => SliderVelocityBindable.Value = value;
         }
 
         [JsonIgnore]
@@ -48,10 +48,10 @@ namespace osu.Game.Rulesets.Catch.Objects
         private double tickDistanceFactor;
 
         [JsonIgnore]
-        public double Velocity => velocityFactor * SliderVelocityMultiplier;
+        public double Velocity => velocityFactor * SliderVelocity;
 
         [JsonIgnore]
-        public double TickDistance => tickDistanceFactor * SliderVelocityMultiplier;
+        public double TickDistance => tickDistanceFactor * SliderVelocity;
 
         /// <summary>
         /// The length of one span of this <see cref="JuiceStream"/>.

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

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

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

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

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

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

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

@@ -21,6 +21,8 @@ namespace osu.Game.Rulesets.Catch.UI
 {
     public partial class DrawableCatchRuleset : DrawableScrollingRuleset<CatchHitObject>
     {
+        protected override ScrollVisualisationMethod VisualisationMethod => ScrollVisualisationMethod.Constant;
+
         protected override bool UserScrollSpeedAdjustment => false;
 
         public DrawableCatchRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod>? mods = null)
@@ -28,7 +30,6 @@ namespace osu.Game.Rulesets.Catch.UI
         {
             Direction.Value = ScrollingDirection.Down;
             TimeRange.Value = GetTimeRange(beatmap.Difficulty.ApproachRate);
-            VisualisationMethod = ScrollVisualisationMethod.Constant;
         }
 
         [BackgroundDependencyLoader]

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

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
             PassCondition = () =>
             {
                 var hitObject = Player.ChildrenOfType<DrawableManiaHitObject>().FirstOrDefault();
-                return hitObject?.Dependencies.Get<IScrollingInfo>().Algorithm.Value is ConstantScrollAlgorithm;
+                return hitObject?.Dependencies.Get<IScrollingInfo>().Algorithm is ConstantScrollAlgorithm;
             }
         });
     }

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

@@ -58,7 +58,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
 
             IBindable<ScrollingDirection> IScrollingInfo.Direction => Direction;
             IBindable<double> IScrollingInfo.TimeRange { get; } = new Bindable<double>(5000);
-            IBindable<IScrollAlgorithm> IScrollingInfo.Algorithm { get; } = new Bindable<IScrollAlgorithm>(new ConstantScrollAlgorithm());
+            IScrollAlgorithm IScrollingInfo.Algorithm { get; } = new ConstantScrollAlgorithm();
         }
     }
 }

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

@@ -1,175 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using NUnit.Framework;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Mania.Beatmaps;
-using osu.Game.Rulesets.Mania.Judgements;
-using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.Mania.Scoring;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Tests.Visual.Gameplay;
-
-namespace osu.Game.Rulesets.Mania.Tests
-{
-    [TestFixture]
-    public partial class TestSceneScoring : ScoringTestScene
-    {
-        protected override IBeatmap CreateBeatmap(int maxCombo)
-        {
-            var beatmap = new ManiaBeatmap(new StageDefinition(5));
-            for (int i = 0; i < maxCombo; ++i)
-                beatmap.HitObjects.Add(new Note());
-            return beatmap;
-        }
-
-        protected override IScoringAlgorithm CreateScoreV1() => new ScoreV1(MaxCombo.Value);
-        protected override IScoringAlgorithm CreateScoreV2(int maxCombo) => new ScoreV2(maxCombo);
-        protected override ProcessorBasedScoringAlgorithm CreateScoreAlgorithm(IBeatmap beatmap, ScoringMode mode) => new ManiaProcessorBasedScoringAlgorithm(beatmap, mode);
-
-        [Test]
-        public void TestBasicScenarios()
-        {
-            AddStep("set max combo to 100", () => MaxCombo.Value = 100);
-            AddStep("set perfect score", () =>
-            {
-                NonPerfectLocations.Clear();
-                MissLocations.Clear();
-            });
-            AddStep("set score with misses", () =>
-            {
-                NonPerfectLocations.Clear();
-                MissLocations.Clear();
-                MissLocations.AddRange(new[] { 24d, 49 });
-            });
-            AddStep("set score with misses and OKs", () =>
-            {
-                NonPerfectLocations.Clear();
-                MissLocations.Clear();
-
-                NonPerfectLocations.AddRange(new[] { 9d, 19, 29, 39, 59, 69, 79, 89, 99 });
-                MissLocations.AddRange(new[] { 24d, 49 });
-            });
-        }
-
-        private class ScoreV1 : IScoringAlgorithm
-        {
-            private int currentCombo;
-            private double comboAddition = 100;
-            private double totalScoreDouble;
-            private readonly double scoreMultiplier;
-
-            public ScoreV1(int maxCombo)
-            {
-                scoreMultiplier = 500000d / maxCombo;
-            }
-
-            public void ApplyHit() => applyHitV1(320, add => add + 2, 32);
-            public void ApplyNonPerfect() => applyHitV1(100, add => add - 24, 8);
-            public void ApplyMiss() => applyHitV1(0, _ => -56, 0);
-
-            private void applyHitV1(int scoreIncrease, Func<double, double> comboAdditionFunc, int delta)
-            {
-                comboAddition = comboAdditionFunc(comboAddition);
-                if (currentCombo != 0 && currentCombo % 384 == 0)
-                    comboAddition = 100;
-                comboAddition = Math.Max(0, Math.Min(comboAddition, 100));
-                double scoreIncreaseD = Math.Sqrt(comboAddition) * delta * scoreMultiplier / 320;
-
-                TotalScore = (long)totalScoreDouble;
-
-                scoreIncreaseD += scoreIncrease * scoreMultiplier / 320;
-                scoreIncrease = (int)scoreIncreaseD;
-
-                TotalScore += scoreIncrease;
-                totalScoreDouble += scoreIncreaseD;
-
-                if (scoreIncrease > 0)
-                    currentCombo++;
-            }
-
-            public long TotalScore { get; private set; }
-        }
-
-        private class ScoreV2 : IScoringAlgorithm
-        {
-            private int currentCombo;
-            private double comboPortion;
-            private double currentBaseScore;
-            private double maxBaseScore;
-            private int currentHits;
-
-            private readonly double comboPortionMax;
-            private readonly int maxCombo;
-
-            private const double combo_base = 4;
-
-            public ScoreV2(int maxCombo)
-            {
-                this.maxCombo = maxCombo;
-
-                for (int i = 0; i < this.maxCombo; i++)
-                    ApplyHit();
-
-                comboPortionMax = comboPortion;
-
-                currentCombo = 0;
-                comboPortion = 0;
-                currentBaseScore = 0;
-                maxBaseScore = 0;
-                currentHits = 0;
-            }
-
-            public void ApplyHit() => applyHitV2(305, 300);
-            public void ApplyNonPerfect() => applyHitV2(100, 100);
-
-            private void applyHitV2(int hitValue, int baseHitValue)
-            {
-                maxBaseScore += 305;
-                currentBaseScore += hitValue;
-                comboPortion += baseHitValue * Math.Min(Math.Max(0.5, Math.Log(++currentCombo, combo_base)), Math.Log(400, combo_base));
-
-                currentHits++;
-            }
-
-            public void ApplyMiss()
-            {
-                currentHits++;
-                maxBaseScore += 305;
-                currentCombo = 0;
-            }
-
-            public long TotalScore
-            {
-                get
-                {
-                    float accuracy = (float)(currentBaseScore / maxBaseScore);
-
-                    return (int)Math.Round
-                    (
-                        200000 * comboPortion / comboPortionMax +
-                        800000 * Math.Pow(accuracy, 2 + 2 * accuracy) * ((double)currentHits / maxCombo)
-                    );
-                }
-            }
-        }
-
-        private class ManiaProcessorBasedScoringAlgorithm : ProcessorBasedScoringAlgorithm
-        {
-            public ManiaProcessorBasedScoringAlgorithm(IBeatmap beatmap, ScoringMode mode)
-                : base(beatmap, mode)
-            {
-            }
-
-            protected override ScoreProcessor CreateScoreProcessor() => new ManiaScoreProcessor();
-
-            protected override JudgementResult CreatePerfectJudgementResult() => new JudgementResult(new Note(), new ManiaJudgement()) { Type = HitResult.Perfect };
-
-            protected override JudgementResult CreateNonPerfectJudgementResult() => new JudgementResult(new Note(), new ManiaJudgement()) { Type = HitResult.Ok };
-
-            protected override JudgementResult CreateMissJudgementResult() => new JudgementResult(new Note(), new ManiaJudgement()) { Type = HitResult.Miss };
-        }
-    }
-}

osu.Game.Rulesets.Mania.Tests/osu.Game.Rulesets.Mania.Tests.csproj

@@ -1,9 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
     <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
   </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>

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

@@ -10,11 +10,10 @@ using System.Linq;
 using osu.Framework.Extensions.EnumExtensions;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Utils;
 
 namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
@@ -51,9 +50,10 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(hitObject.StartTime);
 
             double beatLength;
-
-            if (hitObject is IHasSliderVelocity hasSliderVelocity)
-                beatLength = LegacyRulesetExtensions.GetPrecisionAdjustedBeatLength(hasSliderVelocity, timingPoint, ManiaRuleset.SHORT_NAME);
+            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;
 

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

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

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

@@ -1,16 +1,28 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Scoring.Legacy;
+using osu.Game.Rulesets.Mania.Mods;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Difficulty
 {
     internal class ManiaLegacyScoreSimulator : ILegacyScoreSimulator
     {
-        public LegacyScoreAttributes Simulate(IWorkingBeatmap workingBeatmap, IBeatmap playableBeatmap)
+        public int AccuracyScore => 0;
+        public int ComboScore { get; private set; }
+        public double BonusScoreRatio => 0;
+
+        public void Simulate(IWorkingBeatmap workingBeatmap, IBeatmap playableBeatmap, IReadOnlyList<Mod> mods)
         {
-            return new LegacyScoreAttributes { ComboScore = 1000000 };
+            double multiplier = mods.Where(m => m is not (ModHidden or ModHardRock or ModDoubleTime or ModFlashlight or ManiaModFadeIn))
+                                    .Select(m => m.ScoreMultiplier)
+                                    .Aggregate(1.0, (c, n) => c * n);
+
+            ComboScore = (int)(1000000 * multiplier);
         }
     }
 }

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

@@ -2,22 +2,18 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osuTK;
 using osu.Game.Beatmaps;
-using osu.Game.Configuration;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
-using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
-    public partial class DrawableManiaEditorRuleset : DrawableManiaRuleset, ISupportConstantAlgorithmToggle
+    public partial class DrawableManiaEditorRuleset : DrawableManiaRuleset
     {
-        public BindableBool ShowSpeedChanges { get; set; } = new BindableBool();
-
         public new IScrollingInfo ScrollingInfo => base.ScrollingInfo;
 
         public DrawableManiaEditorRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod>? mods)
@@ -25,13 +21,6 @@ namespace osu.Game.Rulesets.Mania.Edit
         {
         }
 
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            ShowSpeedChanges.BindValueChanged(showChanges => VisualisationMethod = showChanges.NewValue ? ScrollVisualisationMethod.Sequential : ScrollVisualisationMethod.Constant, true);
-        }
-
         protected override Playfield CreatePlayfield() => new ManiaEditorPlayfield(Beatmap.Stages)
         {
             Anchor = Anchor.Centre,

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

@@ -21,7 +21,7 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
-    public partial class ManiaHitObjectComposer : ScrollingHitObjectComposer<ManiaHitObject>
+    public partial class ManiaHitObjectComposer : HitObjectComposer<ManiaHitObject>
     {
         private DrawableManiaEditorRuleset drawableRuleset;
         private ManiaBeatSnapGrid beatSnapGrid;
@@ -57,7 +57,7 @@ namespace osu.Game.Rulesets.Mania.Edit
         protected override Playfield PlayfieldAtScreenSpacePosition(Vector2 screenSpacePosition) =>
             Playfield.GetColumnByPosition(screenSpacePosition);
 
-        protected override DrawableRuleset<ManiaHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods)
+        protected override DrawableRuleset<ManiaHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods = null)
         {
             drawableRuleset = new DrawableManiaEditorRuleset(ruleset, beatmap, mods);
 

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -33,7 +33,6 @@ using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.Scoring.Legacy;
 using osu.Game.Rulesets.UI;
 using osu.Game.Scoring;
 using osu.Game.Screens.Edit.Setup;

osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs

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

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

@@ -28,7 +28,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public void ApplyToDrawableRuleset(DrawableRuleset<ManiaHitObject> drawableRuleset)
         {
             var maniaRuleset = (DrawableManiaRuleset)drawableRuleset;
-            maniaRuleset.VisualisationMethod = ScrollVisualisationMethod.Constant;
+            maniaRuleset.ScrollMethod = ScrollVisualisationMethod.Constant;
         }
     }
 }

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

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

osu.Game.Rulesets.Mania/Skinning/ManiaSkinConfigurationLookup.cs

@@ -30,7 +30,5 @@ namespace osu.Game.Rulesets.Mania.Skinning
             Lookup = lookup;
             ColumnIndex = columnIndex;
         }
-
-        public override string ToString() => $"[{nameof(ManiaSkinConfigurationLookup)} lookup:{Lookup} col:{ColumnIndex}]";
     }
 }

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

@@ -3,6 +3,7 @@
 
 #nullable disable
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
@@ -13,6 +14,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Configuration;
 using osu.Game.Input.Handlers;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Mania.Beatmaps;
@@ -50,6 +52,22 @@ namespace osu.Game.Rulesets.Mania.UI
 
         protected new ManiaRulesetConfigManager Config => (ManiaRulesetConfigManager)base.Config;
 
+        public ScrollVisualisationMethod ScrollMethod
+        {
+            get => scrollMethod;
+            set
+            {
+                if (IsLoaded)
+                    throw new InvalidOperationException($"Can't alter {nameof(ScrollMethod)} after ruleset is already loaded");
+
+                scrollMethod = value;
+            }
+        }
+
+        private ScrollVisualisationMethod scrollMethod = ScrollVisualisationMethod.Sequential;
+
+        protected override ScrollVisualisationMethod VisualisationMethod => scrollMethod;
+
         private readonly Bindable<ManiaScrollingDirection> configDirection = new Bindable<ManiaScrollingDirection>();
         private readonly BindableInt configScrollSpeed = new BindableInt();
         private double smoothTimeRange;

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

@@ -73,7 +73,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
                                 new PathControlPoint(new Vector2(0, 6.25f))
                             }),
                             RepeatCount = 1,
-                            SliderVelocityMultiplier = 10
+                            SliderVelocity = 10
                         }
                     }
                 },

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

@@ -19,8 +19,6 @@ namespace osu.Game.Rulesets.Osu.Tests
         [TestCase("basic")]
         [TestCase("colinear-perfect-curve")]
         [TestCase("slider-ticks")]
-        [TestCase("slider-ticks-edge-case")]
-        [TestCase("slider-paths-edge-case")]
         [TestCase("repeat-slider")]
         [TestCase("uneven-repeat-slider")]
         [TestCase("old-stacking")]

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

@@ -506,6 +506,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         }
 
         [Test]
+        [Ignore("Currently broken, first attempt at fixing broke even harder. See https://github.com/ppy/osu/issues/24743.")]
         public void TestInputDoesNotFallThroughOverlappingSliders()
         {
             const double time_first_slider = 1000;
@@ -549,103 +550,12 @@ namespace osu.Game.Rulesets.Osu.Tests
             addJudgementOffsetAssert("first slider head", () => ((Slider)hitObjects[0]).HeadCircle, 0);
             addJudgementAssert(hitObjects[1], HitResult.Miss);
             // the slider head of the first slider prevents the second slider's head from being hit, so the judgement offset should be very late.
-            // this is not strictly done by the hit policy implementation itself (see `OsuModClassic.blockInputToObjectsUnderSliderHead()`),
-            // but we're testing this here anyways to just keep everything related to input handling and note lock in one place.
             addJudgementOffsetAssert("second slider head", () => ((Slider)hitObjects[1]).HeadCircle, referenceHitWindows.WindowFor(HitResult.Meh));
             addClickActionAssert(0, ClickAction.Hit);
         }
 
         [Test]
-        public void TestOverlappingSlidersDontBlockEachOtherWhenFullyJudged()
-        {
-            const double time_first_slider = 1000;
-            const double time_second_slider = 1600;
-            Vector2 positionFirstSlider = new Vector2(100, 50);
-            Vector2 positionSecondSlider = new Vector2(100, 80);
-            var midpoint = (positionFirstSlider + positionSecondSlider) / 2;
-
-            var hitObjects = new List<OsuHitObject>
-            {
-                new Slider
-                {
-                    StartTime = time_first_slider,
-                    Position = positionFirstSlider,
-                    Path = new SliderPath(PathType.Linear, new[]
-                    {
-                        Vector2.Zero,
-                        new Vector2(25, 0),
-                    })
-                },
-                new Slider
-                {
-                    StartTime = time_second_slider,
-                    Position = positionSecondSlider,
-                    Path = new SliderPath(PathType.Linear, new[]
-                    {
-                        Vector2.Zero,
-                        new Vector2(25, 0),
-                    })
-                }
-            };
-
-            performTest(hitObjects, new List<ReplayFrame>
-            {
-                new OsuReplayFrame { Time = time_first_slider, Position = midpoint, Actions = { OsuAction.RightButton } },
-                new OsuReplayFrame { Time = time_first_slider + 25, Position = midpoint },
-                // this frame doesn't do anything on lazer, but is REQUIRED for correct playback on stable,
-                // because stable during replay playback only updates game state _when it encounters a replay frame_
-                new OsuReplayFrame { Time = 1250, Position = midpoint },
-                new OsuReplayFrame { Time = time_second_slider + 50, Position = midpoint, Actions = { OsuAction.LeftButton } },
-                new OsuReplayFrame { Time = time_second_slider + 75, Position = midpoint },
-            });
-
-            addJudgementAssert(hitObjects[0], HitResult.Ok);
-            addJudgementOffsetAssert("first slider head", () => ((Slider)hitObjects[0]).HeadCircle, 0);
-            addJudgementAssert(hitObjects[1], HitResult.Ok);
-            addJudgementOffsetAssert("second slider head", () => ((Slider)hitObjects[1]).HeadCircle, 50);
-            addClickActionAssert(0, ClickAction.Hit);
-            addClickActionAssert(1, ClickAction.Hit);
-        }
-
-        [Test]
-        public void TestOverlappingHitCirclesDontBlockEachOtherWhenBothVisible()
-        {
-            const double time_first_circle = 1000;
-            const double time_second_circle = 1200;
-            Vector2 positionFirstCircle = new Vector2(100);
-            Vector2 positionSecondCircle = new Vector2(120);
-            var midpoint = (positionFirstCircle + positionSecondCircle) / 2;
-
-            var hitObjects = new List<OsuHitObject>
-            {
-                new HitCircle
-                {
-                    StartTime = time_first_circle,
-                    Position = positionFirstCircle,
-                },
-                new HitCircle
-                {
-                    StartTime = time_second_circle,
-                    Position = positionSecondCircle,
-                },
-            };
-
-            performTest(hitObjects, new List<ReplayFrame>
-            {
-                new OsuReplayFrame { Time = time_first_circle, Position = midpoint, Actions = { OsuAction.LeftButton } },
-                new OsuReplayFrame { Time = time_first_circle + 25, Position = midpoint },
-                new OsuReplayFrame { Time = time_first_circle + 50, Position = midpoint, Actions = { OsuAction.RightButton } },
-            });
-
-            addJudgementAssert(hitObjects[0], HitResult.Great);
-            addJudgementOffsetAssert(hitObjects[0], 0);
-
-            addJudgementAssert(hitObjects[1], HitResult.Meh);
-            addJudgementOffsetAssert(hitObjects[1], -150);
-        }
-
-        [Test]
-        public void TestOverlappingHitCirclesDontBlockEachOtherWhenFullyFadedOut()
+        public void TestOverlappingObjectsDontBlockEachOtherWhenFullyFadedOut()
         {
             const double time_first_circle = 1000;
             const double time_second_circle = 1200;
@@ -676,10 +586,8 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
                 new OsuReplayFrame { Time = time_first_circle, Position = positionFirstCircle, Actions = { OsuAction.LeftButton } },
                 new OsuReplayFrame { Time = time_first_circle + 50, Position = positionFirstCircle },
-                new OsuReplayFrame { Time = time_second_circle - 50, Position = positionSecondCircle },
                 new OsuReplayFrame { Time = time_second_circle, Position = positionSecondCircle, Actions = { OsuAction.LeftButton } },
                 new OsuReplayFrame { Time = time_second_circle + 50, Position = positionSecondCircle },
-                new OsuReplayFrame { Time = time_third_circle - 50, Position = positionFirstCircle },
                 new OsuReplayFrame { Time = time_third_circle, Position = positionFirstCircle, Actions = { OsuAction.LeftButton } },
                 new OsuReplayFrame { Time = time_third_circle + 50, Position = positionFirstCircle },
             });

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

@@ -1,176 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using NUnit.Framework;
-using osu.Framework.Bindables;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Osu.Beatmaps;
-using osu.Game.Rulesets.Osu.Judgements;
-using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.Scoring;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Tests.Visual.Gameplay;
-
-namespace osu.Game.Rulesets.Osu.Tests
-{
-    [TestFixture]
-    public partial class TestSceneScoring : ScoringTestScene
-    {
-        private Bindable<double> scoreMultiplier { get; } = new BindableDouble
-        {
-            Default = 4,
-            Value = 4
-        };
-
-        protected override IBeatmap CreateBeatmap(int maxCombo)
-        {
-            var beatmap = new OsuBeatmap();
-            for (int i = 0; i < maxCombo; i++)
-                beatmap.HitObjects.Add(new HitCircle());
-            return beatmap;
-        }
-
-        protected override IScoringAlgorithm CreateScoreV1() => new ScoreV1 { ScoreMultiplier = { BindTarget = scoreMultiplier } };
-        protected override IScoringAlgorithm CreateScoreV2(int maxCombo) => new ScoreV2(maxCombo);
-        protected override ProcessorBasedScoringAlgorithm CreateScoreAlgorithm(IBeatmap beatmap, ScoringMode mode) => new OsuProcessorBasedScoringAlgorithm(beatmap, mode);
-
-        [Test]
-        public void TestBasicScenarios()
-        {
-            AddStep("set up score multiplier", () =>
-            {
-                scoreMultiplier.BindValueChanged(_ => Rerun());
-            });
-            AddStep("set max combo to 100", () => MaxCombo.Value = 100);
-            AddStep("set perfect score", () =>
-            {
-                NonPerfectLocations.Clear();
-                MissLocations.Clear();
-            });
-            AddStep("set score with misses", () =>
-            {
-                NonPerfectLocations.Clear();
-                MissLocations.Clear();
-                MissLocations.AddRange(new[] { 24d, 49 });
-            });
-            AddStep("set score with misses and OKs", () =>
-            {
-                NonPerfectLocations.Clear();
-                MissLocations.Clear();
-
-                NonPerfectLocations.AddRange(new[] { 9d, 19, 29, 39, 59, 69, 79, 89, 99 });
-                MissLocations.AddRange(new[] { 24d, 49 });
-            });
-            AddSliderStep("adjust score multiplier", 0, 10, (int)scoreMultiplier.Default, multiplier => scoreMultiplier.Value = multiplier);
-        }
-
-        private const int base_great = 300;
-        private const int base_ok = 100;
-
-        private class ScoreV1 : IScoringAlgorithm
-        {
-            private int currentCombo;
-
-            public BindableDouble ScoreMultiplier { get; } = new BindableDouble();
-
-            public void ApplyHit() => applyHitV1(base_great);
-            public void ApplyNonPerfect() => applyHitV1(base_ok);
-            public void ApplyMiss() => applyHitV1(0);
-
-            private void applyHitV1(int baseScore)
-            {
-                if (baseScore == 0)
-                {
-                    currentCombo = 0;
-                    return;
-                }
-
-                TotalScore += baseScore;
-
-                // combo multiplier
-                // ReSharper disable once PossibleLossOfFraction
-                TotalScore += (int)(Math.Max(0, currentCombo - 1) * (baseScore / 25 * ScoreMultiplier.Value));
-
-                currentCombo++;
-            }
-
-            public long TotalScore { get; private set; }
-        }
-
-        private class ScoreV2 : IScoringAlgorithm
-        {
-            private int currentCombo;
-            private double comboPortion;
-            private double currentBaseScore;
-            private double maxBaseScore;
-            private int currentHits;
-
-            private readonly double comboPortionMax;
-            private readonly int maxCombo;
-
-            public ScoreV2(int maxCombo)
-            {
-                this.maxCombo = maxCombo;
-
-                for (int i = 0; i < this.maxCombo; i++)
-                    ApplyHit();
-
-                comboPortionMax = comboPortion;
-
-                currentCombo = 0;
-                comboPortion = 0;
-                currentBaseScore = 0;
-                maxBaseScore = 0;
-                currentHits = 0;
-            }
-
-            public void ApplyHit() => applyHitV2(base_great);
-            public void ApplyNonPerfect() => applyHitV2(base_ok);
-
-            private void applyHitV2(int baseScore)
-            {
-                maxBaseScore += base_great;
-                currentBaseScore += baseScore;
-                comboPortion += baseScore * (1 + ++currentCombo / 10.0);
-
-                currentHits++;
-            }
-
-            public void ApplyMiss()
-            {
-                currentHits++;
-                maxBaseScore += base_great;
-                currentCombo = 0;
-            }
-
-            public long TotalScore
-            {
-                get
-                {
-                    double accuracy = currentBaseScore / maxBaseScore;
-
-                    return (int)Math.Round
-                    (
-                        700000 * comboPortion / comboPortionMax +
-                        300000 * Math.Pow(accuracy, 10) * ((double)currentHits / maxCombo)
-                    );
-                }
-            }
-        }
-
-        private class OsuProcessorBasedScoringAlgorithm : ProcessorBasedScoringAlgorithm
-        {
-            public OsuProcessorBasedScoringAlgorithm(IBeatmap beatmap, ScoringMode mode)
-                : base(beatmap, mode)
-            {
-            }
-
-            protected override ScoreProcessor CreateScoreProcessor() => new OsuScoreProcessor();
-            protected override JudgementResult CreatePerfectJudgementResult() => new OsuJudgementResult(new HitCircle(), new OsuJudgement()) { Type = HitResult.Great };
-            protected override JudgementResult CreateNonPerfectJudgementResult() => new OsuJudgementResult(new HitCircle(), new OsuJudgement()) { Type = HitResult.Ok };
-            protected override JudgementResult CreateMissJudgementResult() => new OsuJudgementResult(new HitCircle(), new OsuJudgement()) { Type = HitResult.Miss };
-        }
-    }
-}

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

@@ -3,7 +3,6 @@
 
 #nullable disable
 
-using System;
 using System.Collections.Generic;
 using osu.Framework.Graphics;
 using osu.Game.Audio;
@@ -20,6 +19,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Testing;
+using osu.Game.Beatmaps.Legacy;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Judgements;
@@ -35,24 +35,16 @@ namespace osu.Game.Rulesets.Osu.Tests
     {
         private int depthIndex;
 
-        private readonly BindableBool snakingIn = new BindableBool(true);
-        private readonly BindableBool snakingOut = new BindableBool(true);
+        private readonly BindableBool snakingIn = new BindableBool();
+        private readonly BindableBool snakingOut = new BindableBool();
 
-        private float progressToHit;
-
-        protected override void LoadComplete()
+        [SetUpSteps]
+        public void SetUpSteps()
         {
-            base.LoadComplete();
-
-            AddToggleStep("disable snaking", v =>
+            AddToggleStep("toggle snaking", v =>
             {
-                snakingIn.Value = !v;
-                snakingOut.Value = !v;
-            });
-
-            AddSliderStep("hit at", 0f, 1f, 0f, v =>
-            {
-                progressToHit = v;
+                snakingIn.Value = v;
+                snakingOut.Value = v;
             });
         }
 
@@ -64,18 +56,6 @@ namespace osu.Game.Rulesets.Osu.Tests
             config.BindWith(OsuRulesetSetting.SnakingOutSliders, snakingOut);
         }
 
-        protected override void Update()
-        {
-            base.Update();
-
-            foreach (var slider in this.ChildrenOfType<DrawableSlider>())
-            {
-                double completionProgress = Math.Clamp((Time.Current - slider.HitObject.StartTime) / slider.HitObject.Duration, 0, 1);
-                if (completionProgress > progressToHit && !slider.IsHit)
-                    slider.HeadCircle.HitArea.Hit();
-            }
-        }
-
         [Test]
         public void TestVariousSliders()
         {
@@ -226,7 +206,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 StackHeight = 10
             };
 
-            return createDrawable(slider, 2);
+            return createDrawable(slider, 2, 2);
         }
 
         private Drawable testSimpleMedium(int repeats = 0) => createSlider(5, repeats: repeats);
@@ -249,7 +229,6 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             var slider = new Slider
             {
-                SliderVelocityMultiplier = speedMultiplier,
                 StartTime = Time.Current + time_offset,
                 Position = new Vector2(0, -(distance / 2)),
                 Path = new SliderPath(PathType.PerfectCurve, new[]
@@ -261,7 +240,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 StackHeight = stackHeight
             };
 
-            return createDrawable(slider, circleSize);
+            return createDrawable(slider, circleSize, speedMultiplier);
         }
 
         private Drawable testPerfect(int repeats = 0)
@@ -279,7 +258,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 RepeatCount = repeats,
             };
 
-            return createDrawable(slider, 2);
+            return createDrawable(slider, 2, 3);
         }
 
         private Drawable testLinear(int repeats = 0) => createLinear(repeats);
@@ -302,7 +281,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 RepeatCount = repeats,
             };
 
-            return createDrawable(slider, 2);
+            return createDrawable(slider, 2, 3);
         }
 
         private Drawable testBezier(int repeats = 0) => createBezier(repeats);
@@ -324,7 +303,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 RepeatCount = repeats,
             };
 
-            return createDrawable(slider, 2);
+            return createDrawable(slider, 2, 3);
         }
 
         private Drawable testLinearOverlapping(int repeats = 0) => createOverlapping(repeats);
@@ -347,7 +326,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 RepeatCount = repeats,
             };
 
-            return createDrawable(slider, 2);
+            return createDrawable(slider, 2, 3);
         }
 
         private Drawable testCatmull(int repeats = 0) => createCatmull(repeats);
@@ -373,12 +352,15 @@ namespace osu.Game.Rulesets.Osu.Tests
                 NodeSamples = repeatSamples
             };
 
-            return createDrawable(slider, 3);
+            return createDrawable(slider, 3, 1);
         }
 
-        private Drawable createDrawable(Slider slider, float circleSize)
+        private Drawable createDrawable(Slider slider, float circleSize, double speedMultiplier)
         {
-            slider.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty
+            var cpi = new LegacyControlPointInfo();
+            cpi.Add(0, new DifficultyControlPoint { SliderVelocity = speedMultiplier });
+
+            slider.ApplyDefaults(cpi, new BeatmapDifficulty
             {
                 CircleSize = circleSize,
                 SliderTickRate = 3

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

@@ -46,7 +46,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                     {
                         StartTime = time_slider_start,
                         Position = new Vector2(0, 0),
-                        SliderVelocityMultiplier = velocity,
+                        SliderVelocity = velocity,
                         Path = new SliderPath(PathType.Linear, new[]
                         {
                             Vector2.Zero,

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

@@ -349,7 +349,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                         {
                             StartTime = time_slider_start,
                             Position = new Vector2(0, 0),
-                            SliderVelocityMultiplier = 0.1f,
+                            SliderVelocity = 0.1f,
                             Path = new SliderPath(PathType.PerfectCurve, new[]
                             {
                                 Vector2.Zero,

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

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+#nullable disable
+
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -31,7 +33,7 @@ namespace osu.Game.Rulesets.Osu.Tests
     public partial class TestSceneSliderSnaking : TestSceneOsuPlayer
     {
         [Resolved]
-        private AudioManager audioManager { get; set; } = null!;
+        private AudioManager audioManager { get; set; }
 
         protected override bool Autoplay => autoplay;
         private bool autoplay;
@@ -39,12 +41,12 @@ namespace osu.Game.Rulesets.Osu.Tests
         private readonly BindableBool snakingIn = new BindableBool();
         private readonly BindableBool snakingOut = new BindableBool();
 
-        private IBeatmap beatmap = null!;
+        private IBeatmap beatmap;
 
         private const double duration_of_span = 3605;
         private const double fade_in_modifier = -1200;
 
-        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard? storyboard = null)
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null)
             => new ClockBackedTestWorkingBeatmap(this.beatmap = beatmap, storyboard, new FramedClock(new ManualClock { Rate = 1 }), audioManager);
 
         [BackgroundDependencyLoader]
@@ -55,8 +57,15 @@ namespace osu.Game.Rulesets.Osu.Tests
             config.BindWith(OsuRulesetSetting.SnakingOutSliders, snakingOut);
         }
 
-        private Slider slider = null!;
-        private DrawableSlider? drawableSlider;
+        private Slider slider;
+        private DrawableSlider drawableSlider;
+
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            slider = null;
+            drawableSlider = null;
+        });
 
         protected override bool HasCustomSteps => true;
 
@@ -126,9 +135,9 @@ namespace osu.Game.Rulesets.Osu.Tests
         }
 
         [Test]
-        public void TestRepeatArrowDoesNotMove([Values] bool useAutoplay)
+        public void TestRepeatArrowDoesNotMoveWhenHit()
         {
-            AddStep($"set autoplay to {useAutoplay}", () => autoplay = useAutoplay);
+            AddStep("enable autoplay", () => autoplay = true);
             setSnaking(true);
             CreateTest();
             // repeat might have a chance to update its position depending on where in the frame its hit,
@@ -136,12 +145,21 @@ namespace osu.Game.Rulesets.Osu.Tests
             addCheckPositionChangeSteps(() => 16600, getSliderRepeat, positionAlmostSame);
         }
 
+        [Test]
+        public void TestRepeatArrowMovesWhenNotHit()
+        {
+            AddStep("disable autoplay", () => autoplay = false);
+            setSnaking(true);
+            CreateTest();
+            addCheckPositionChangeSteps(() => 16600, getSliderRepeat, positionDecreased);
+        }
+
         private void retrieveSlider(int index)
         {
             AddStep("retrieve slider at index", () => slider = (Slider)beatmap.HitObjects[index]);
             addSeekStep(() => slider.StartTime);
             AddUntilStep("retrieve drawable slider", () =>
-                (drawableSlider = (DrawableSlider?)Player.DrawableRuleset.Playfield.AllHitObjects.SingleOrDefault(d => d.HitObject == slider)) != null);
+                (drawableSlider = (DrawableSlider)Player.DrawableRuleset.Playfield.AllHitObjects.SingleOrDefault(d => d.HitObject == slider)) != null);
         }
 
         private void addEnsureSnakingInSteps(Func<double> startTime) => addCheckPositionChangeSteps(startTime, getSliderEnd, positionIncreased);
@@ -161,7 +179,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         private Func<double> timeAtRepeat(Func<double> startTime, int repeatIndex) => () => startTime() + 100 + duration_of_span * repeatIndex;
         private Func<Vector2> positionAtRepeat(int repeatIndex) => repeatIndex % 2 == 0 ? getSliderStart : getSliderEnd;
 
-        private List<Vector2> getSliderCurve() => ((PlaySliderBody)drawableSlider!.Body.Drawable).CurrentCurve;
+        private List<Vector2> getSliderCurve() => ((PlaySliderBody)drawableSlider.Body.Drawable).CurrentCurve;
         private Vector2 getSliderStart() => getSliderCurve().First();
         private Vector2 getSliderEnd() => getSliderCurve().Last();
 

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

@@ -43,8 +43,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddUntilStep("Pitch starts low", () => getSpinningSample().Frequency.Value < 0.8);
             AddUntilStep("Pitch increases", () => getSpinningSample().Frequency.Value > 0.8);
 
-            PausableSkinnableSound getSpinningSample() =>
-                drawableSpinner.ChildrenOfType<PausableSkinnableSound>().FirstOrDefault(s => s.Samples.Any(i => i.LookupNames.Any(l => l.Contains("spinnerspin"))));
+            PausableSkinnableSound getSpinningSample() => drawableSpinner.ChildrenOfType<PausableSkinnableSound>().FirstOrDefault(s => s.Samples.Any(i => i.LookupNames.Any(l => l.Contains("spinnerspin"))));
         }
 
         [TestCase(false)]
@@ -65,39 +64,6 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddUntilStep("Short spinner implicitly completes", () => drawableSpinner.Progress == 1);
         }
 
-        [TestCase(0, 4, 6)]
-        [TestCase(5, 7, 10)]
-        [TestCase(10, 11, 8)]
-        public void TestSpinnerSpinRequirements(int od, int normalTicks, int bonusTicks)
-        {
-            Spinner spinner = null;
-
-            AddStep("add spinner", () => SetContents(_ =>
-            {
-                spinner = new Spinner
-                {
-                    StartTime = Time.Current,
-                    EndTime = Time.Current + 3000,
-                    Samples = new List<HitSampleInfo>
-                    {
-                        new HitSampleInfo(HitSampleInfo.HIT_NORMAL)
-                    }
-                };
-
-                spinner.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty { OverallDifficulty = od });
-
-                return drawableSpinner = new TestDrawableSpinner(spinner, true)
-                {
-                    Anchor = Anchor.Centre,
-                    Depth = depthIndex++,
-                    Scale = new Vector2(0.75f)
-                };
-            }));
-
-            AddAssert("number of normal ticks matches", () => spinner.SpinsRequired, () => Is.EqualTo(normalTicks));
-            AddAssert("number of bonus ticks matches", () => spinner.MaximumBonusSpins, () => Is.EqualTo(bonusTicks));
-        }
-
         private Drawable testSingle(float circleSize, bool auto = false, double length = 3000)
         {
             const double delay = 2000;

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

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

osu.Game.Rulesets.Osu.Tests/osu.Game.Rulesets.Osu.Tests.csproj

@@ -1,10 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
     <PackageReference Include="Moq" Version="4.18.4" />
     <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
   </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>

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

@@ -49,7 +49,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                         // this results in more (or less) ticks being generated in <v8 maps for the same time duration.
                         TickDistanceMultiplier = beatmap.BeatmapInfo.BeatmapVersion < 8 ? 1f / ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(original.StartTime).SliderVelocity : 1,
                         GenerateTicks = generateTicksData?.GenerateTicks ?? true,
-                        SliderVelocityMultiplier = sliderVelocityData?.SliderVelocityMultiplier ?? 1,
+                        SliderVelocity = sliderVelocityData?.SliderVelocity ?? 1,
                     }.Yield();
 
                 case IHasDuration endTimeData:

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

@@ -26,9 +26,12 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
         public override int Version => 20220902;
 
+        private readonly IWorkingBeatmap workingBeatmap;
+
         public OsuDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
+            workingBeatmap = beatmap;
         }
 
         protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
@@ -106,6 +109,15 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                 SpinnerCount = spinnerCount,
             };
 
+            if (ComputeLegacyScoringValues)
+            {
+                OsuLegacyScoreSimulator sv1Simulator = new OsuLegacyScoreSimulator();
+                sv1Simulator.Simulate(workingBeatmap, beatmap, mods);
+                attributes.LegacyAccuracyScore = sv1Simulator.AccuracyScore;
+                attributes.LegacyComboScore = sv1Simulator.ComboScore;
+                attributes.LegacyBonusScoreRatio = sv1Simulator.BonusScoreRatio;
+            }
+
             return attributes;
         }
 

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

@@ -2,27 +2,37 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.Scoring.Legacy;
 
 namespace osu.Game.Rulesets.Osu.Difficulty
 {
     internal class OsuLegacyScoreSimulator : ILegacyScoreSimulator
     {
+        public int AccuracyScore { get; private set; }
+
+        public int ComboScore { get; private set; }
+
+        public double BonusScoreRatio => legacyBonusScore == 0 ? 0 : (double)modernBonusScore / legacyBonusScore;
+
         private int legacyBonusScore;
-        private int standardisedBonusScore;
+        private int modernBonusScore;
         private int combo;
 
         private double scoreMultiplier;
+        private IBeatmap playableBeatmap = null!;
 
-        public LegacyScoreAttributes Simulate(IWorkingBeatmap workingBeatmap, IBeatmap playableBeatmap)
+        public void Simulate(IWorkingBeatmap workingBeatmap, IBeatmap playableBeatmap, IReadOnlyList<Mod> mods)
         {
+            this.playableBeatmap = playableBeatmap;
+
             IBeatmap baseBeatmap = workingBeatmap.Beatmap;
 
             int countNormal = 0;
@@ -63,19 +73,13 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                  + baseBeatmap.Difficulty.CircleSize
                  + Math.Clamp((float)objectCount / drainLength * 8, 0, 16)) / 38 * 5);
 
-            scoreMultiplier = difficultyPeppyStars;
-
-            LegacyScoreAttributes attributes = new LegacyScoreAttributes();
+            scoreMultiplier = difficultyPeppyStars * mods.Aggregate(1.0, (current, mod) => current * mod.ScoreMultiplier);
 
             foreach (var obj in playableBeatmap.HitObjects)
-                simulateHit(obj, ref attributes);
-
-            attributes.BonusScoreRatio = legacyBonusScore == 0 ? 0 : (double)standardisedBonusScore / legacyBonusScore;
-
-            return attributes;
+                simulateHit(obj);
         }
 
-        private void simulateHit(HitObject hitObject, ref LegacyScoreAttributes attributes)
+        private void simulateHit(HitObject hitObject)
         {
             bool increaseCombo = true;
             bool addScoreComboMultiplier = false;
@@ -118,7 +122,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
                 case Slider:
                     foreach (var nested in hitObject.NestedHitObjects)
-                        simulateHit(nested, ref attributes);
+                        simulateHit(nested);
 
                     scoreIncrease = 300;
                     increaseCombo = false;
@@ -129,27 +133,22 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                     // The spinner object applies a lenience because gameplay mechanics differ from osu-stable.
                     // We'll redo the calculations to match osu-stable here...
                     const double maximum_rotations_per_second = 477.0 / 60;
-
-                    // Normally, this value depends on the final overall difficulty. For simplicity, we'll only consider the worst case that maximises bonus score.
-                    // As we're primarily concerned with computing the maximum theoretical final score,
-                    // this will have the final effect of slightly underestimating bonus score achieved on stable when converting from score V1.
-                    const double minimum_rotations_per_second = 3;
-
+                    double minimumRotationsPerSecond = IBeatmapDifficultyInfo.DifficultyRange(playableBeatmap.Difficulty.OverallDifficulty, 3, 5, 7.5);
                     double secondsDuration = spinner.Duration / 1000;
 
                     // The total amount of half spins possible for the entire spinner.
                     int totalHalfSpinsPossible = (int)(secondsDuration * maximum_rotations_per_second * 2);
                     // The amount of half spins that are required to successfully complete the spinner (i.e. get a 300).
-                    int halfSpinsRequiredForCompletion = (int)(secondsDuration * minimum_rotations_per_second);
+                    int halfSpinsRequiredForCompletion = (int)(secondsDuration * minimumRotationsPerSecond);
                     // To be able to receive bonus points, the spinner must be rotated another 1.5 times.
                     int halfSpinsRequiredBeforeBonus = halfSpinsRequiredForCompletion + 3;
 
                     for (int i = 0; i <= totalHalfSpinsPossible; i++)
                     {
                         if (i > halfSpinsRequiredBeforeBonus && (i - halfSpinsRequiredBeforeBonus) % 2 == 0)
-                            simulateHit(new SpinnerBonusTick(), ref attributes);
+                            simulateHit(new SpinnerBonusTick());
                         else if (i > 1 && i % 2 == 0)
-                            simulateHit(new SpinnerTick(), ref attributes);
+                            simulateHit(new SpinnerTick());
                     }
 
                     scoreIncrease = 300;
@@ -160,16 +159,16 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             if (addScoreComboMultiplier)
             {
                 // ReSharper disable once PossibleLossOfFraction (intentional to match osu-stable...)
-                attributes.ComboScore += (int)(Math.Max(0, combo - 1) * (scoreIncrease / 25 * scoreMultiplier));
+                ComboScore += (int)(Math.Max(0, combo - 1) * (scoreIncrease / 25 * scoreMultiplier));
             }
 
             if (isBonus)
             {
                 legacyBonusScore += scoreIncrease;
-                standardisedBonusScore += Judgement.ToNumericResult(bonusResult);
+                modernBonusScore += Judgement.ToNumericResult(bonusResult);
             }
             else
-                attributes.AccuracyScore += scoreIncrease;
+                AccuracyScore += scoreIncrease;
 
             if (increaseCombo)
                 combo++;

osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/Components/HitCircleOverlapMarker.cs

@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components
         {
             Origin = Anchor.Centre;
 
-            Size = OsuHitObject.OBJECT_DIMENSIONS;
+            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
 
             InternalChild = content = new Container
             {

osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/Components/HitCirclePiece.cs

@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components
         {
             Origin = Anchor.Centre;
 
-            Size = OsuHitObject.OBJECT_DIMENSIONS;
+            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
 
             CornerRadius = Size.X / 2;
             CornerExponent = 2;

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

@@ -85,9 +85,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                     BeginPlacement();
 
                     double? nearestSliderVelocity = (editorBeatmap.HitObjects
-                                                                  .LastOrDefault(h => h is Slider && h.GetEndTime() < HitObject.StartTime) as Slider)?.SliderVelocityMultiplier;
+                                                                  .LastOrDefault(h => h is Slider && h.GetEndTime() < HitObject.StartTime) as Slider)?.SliderVelocity;
 
-                    HitObject.SliderVelocityMultiplier = nearestSliderVelocity ?? 1;
+                    HitObject.SliderVelocity = nearestSliderVelocity ?? 1;
                     HitObject.Position = ToLocalSpace(result.ScreenSpacePosition);
 
                     // Replacing the DifficultyControlPoint above doesn't trigger any kind of invalidation.

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

@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.Edit
         {
         }
 
-        protected override DrawableRuleset<OsuHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods)
+        protected override DrawableRuleset<OsuHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods = null)
             => new DrawableOsuEditorRuleset(ruleset, beatmap, mods);
 
         protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]

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

@@ -61,12 +61,10 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
         {
-            OsuHitObject firstObject = drawableRuleset.Beatmap.HitObjects.First();
-
             // Multiplying by 2 results in an initial size that is too large, hence 1.90 has been chosen
             // Also avoids the HitObject bleeding around the edges of the bubble drawable at minimum size
-            bubbleSize = (float)firstObject.Radius * 1.90f;
-            bubbleFade = firstObject.TimePreempt * 2;
+            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;

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

@@ -25,6 +25,9 @@ namespace osu.Game.Rulesets.Osu.Mods
         [SettingSource("No slider head accuracy requirement", "Scores sliders proportionally to the number of ticks hit.")]
         public Bindable<bool> NoSliderHeadAccuracy { get; } = new BindableBool(true);
 
+        [SettingSource("No slider head movement", "Pins slider heads at their starting position, regardless of time.")]
+        public Bindable<bool> NoSliderHeadMovement { get; } = new BindableBool(true);
+
         [SettingSource("Apply classic note lock", "Applies note lock to the full hit window.")]
         public Bindable<bool> ClassicNoteLock { get; } = new BindableBool(true);
 
@@ -68,12 +71,9 @@ namespace osu.Game.Rulesets.Osu.Mods
             switch (obj)
             {
                 case DrawableSliderHead head:
+                    head.TrackFollowCircle = !NoSliderHeadMovement.Value;
                     if (FadeHitCircleEarly.Value && !usingHiddenFading)
                         applyEarlyFading(head);
-
-                    if (ClassicNoteLock.Value)
-                        blockInputToObjectsUnderSliderHead(head);
-
                     break;
 
                 case DrawableSliderTail tail:
@@ -83,27 +83,10 @@ namespace osu.Game.Rulesets.Osu.Mods
                 case DrawableHitCircle circle:
                     if (FadeHitCircleEarly.Value && !usingHiddenFading)
                         applyEarlyFading(circle);
-
                     break;
             }
         }
 
-        /// <summary>
-        /// On stable, slider heads that have already been hit block input from reaching objects that may be underneath them
-        /// until the sliders they're part of have been fully judged.
-        /// The purpose of this method is to restore that behaviour.
-        /// In order to avoid introducing yet another confusing config option, this behaviour is roped into the general notion of "note lock".
-        /// </summary>
-        private static void blockInputToObjectsUnderSliderHead(DrawableSliderHead slider)
-        {
-            var oldHitAction = slider.HitArea.Hit;
-            slider.HitArea.Hit = () =>
-            {
-                oldHitAction?.Invoke();
-                return !slider.DrawableSlider.AllJudged;
-            };
-        }
-
         private void applyEarlyFading(DrawableHitCircle circle)
         {
             circle.ApplyCustomUpdateState += (dho, state) =>

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

@@ -2,19 +2,13 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Linq;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Configuration;
-using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public partial class OsuModDifficultyAdjust : ModDifficultyAdjust
+    public class OsuModDifficultyAdjust : ModDifficultyAdjust
     {
         [SettingSource("Circle Size", "Override a beatmap's set CS.", FIRST_SETTING_ORDER - 1, SettingControlType = typeof(DifficultyAdjustSettingsControl))]
         public DifficultyBindable CircleSize { get; } = new DifficultyBindable
@@ -26,13 +20,12 @@ namespace osu.Game.Rulesets.Osu.Mods
             ReadCurrentFromDifficulty = diff => diff.CircleSize,
         };
 
-        [SettingSource("Approach Rate", "Override a beatmap's set AR.", LAST_SETTING_ORDER + 1, SettingControlType = typeof(ApproachRateSettingsControl))]
+        [SettingSource("Approach Rate", "Override a beatmap's set AR.", LAST_SETTING_ORDER + 1, SettingControlType = typeof(DifficultyAdjustSettingsControl))]
         public DifficultyBindable ApproachRate { get; } = new DifficultyBindable
         {
             Precision = 0.1f,
             MinValue = 0,
             MaxValue = 10,
-            ExtendedMinValue = -10,
             ExtendedMaxValue = 11,
             ReadCurrentFromDifficulty = diff => diff.ApproachRate,
         };
@@ -60,34 +53,5 @@ namespace osu.Game.Rulesets.Osu.Mods
             if (CircleSize.Value != null) difficulty.CircleSize = CircleSize.Value.Value;
             if (ApproachRate.Value != null) difficulty.ApproachRate = ApproachRate.Value.Value;
         }
-
-        private partial class ApproachRateSettingsControl : DifficultyAdjustSettingsControl
-        {
-            protected override RoundedSliderBar<float> CreateSlider(BindableNumber<float> current) =>
-                new ApproachRateSlider
-                {
-                    RelativeSizeAxes = Axes.X,
-                    Current = current,
-                    KeyboardStep = 0.1f,
-                };
-
-            /// <summary>
-            /// A slider bar with more detailed approach rate info for its given value
-            /// </summary>
-            public partial class ApproachRateSlider : RoundedSliderBar<float>
-            {
-                public override LocalisableString TooltipText =>
-                    (Current as BindableNumber<float>)?.MinValue < 0
-                        ? $"{base.TooltipText} ({getPreemptTime(Current.Value):0} ms)"
-                        : base.TooltipText;
-
-                private double getPreemptTime(float approachRate)
-                {
-                    var hitCircle = new HitCircle();
-                    hitCircle.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty { ApproachRate = approachRate });
-                    return hitCircle.TimePreempt;
-                }
-            }
-        }
     }
 }

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

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

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

@@ -244,7 +244,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             public HitReceptor()
             {
-                Size = OsuHitObject.OBJECT_DIMENSIONS;
+                Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
 
                 Anchor = Anchor.Centre;
                 Origin = Anchor.Centre;
@@ -261,7 +261,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     case OsuAction.RightButton:
                         if (IsHovered && (Hit?.Invoke() ?? false))
                         {
-                            HitAction ??= e.Action;
+                            HitAction = e.Action;
                             return true;
                         }
 

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

@@ -228,7 +228,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             double completionProgress = Math.Clamp((Time.Current - HitObject.StartTime) / HitObject.Duration, 0, 1);
 
             Ball.UpdateProgress(completionProgress);
-            SliderBody?.UpdateProgress(HeadCircle.IsHit ? completionProgress : 0);
+            SliderBody?.UpdateProgress(completionProgress);
 
             foreach (DrawableHitObject hitObject in NestedHitObjects)
             {
@@ -317,7 +317,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             switch (state)
             {
                 case ArmedState.Hit:
-                    if (HeadCircle.IsHit && SliderBody?.SnakingOut.Value == true)
+                    if (SliderBody?.SnakingOut.Value == true)
                         Body.FadeOut(40); // short fade to allow for any body colour to smoothly disappear.
                     break;
             }

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

@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             Origin = Anchor.Centre;
 
-            Size = OsuHitObject.OBJECT_DIMENSIONS;
+            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
 
             Children = new[]
             {

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

@@ -3,9 +3,11 @@
 
 #nullable disable
 
+using System;
 using System.Diagnostics;
 using JetBrains.Annotations;
 using osu.Framework.Bindables;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Scoring;
 
@@ -22,6 +24,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         public override bool DisplayResult => HitObject?.JudgeAsNormalHitCircle ?? base.DisplayResult;
 
+        /// <summary>
+        /// Makes this <see cref="DrawableSliderHead"/> track the follow circle when the start time is reached.
+        /// If <c>false</c>, this <see cref="DrawableSliderHead"/> will be pinned to its initial position in the slider.
+        /// </summary>
+        public bool TrackFollowCircle = true;
+
         private readonly IBindable<int> pathVersion = new Bindable<int>();
 
         protected override OsuSkinComponents CirclePieceComponent => OsuSkinComponents.SliderHeadHitCircle;
@@ -56,6 +64,23 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             CheckHittable = (d, t, r) => DrawableSlider.CheckHittable?.Invoke(d, t, r) ?? ClickAction.Hit;
         }
 
+        protected override void Update()
+        {
+            base.Update();
+
+            Debug.Assert(Slider != null);
+            Debug.Assert(HitObject != null);
+
+            if (TrackFollowCircle)
+            {
+                double completionProgress = Math.Clamp((Time.Current - Slider.StartTime) / Slider.Duration, 0, 1);
+
+                //todo: we probably want to reconsider this before adding scoring, but it looks and feels nice.
+                if (!IsHit)
+                    Position = Slider.CurvePositionAt(completionProgress);
+            }
+        }
+
         protected override HitResult ResultFor(double timeOffset)
         {
             Debug.Assert(HitObject != null);

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

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

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

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

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

@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         [BackgroundDependencyLoader]
         private void load()
         {
-            Size = OsuHitObject.OBJECT_DIMENSIONS;
+            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
             Origin = Anchor.Centre;
 
             AddInternal(scaleContainer = new SkinnableDrawable(new OsuSkinComponentLookup(OsuSkinComponents.SliderScorePoint), _ => new CircularContainer

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

@@ -286,7 +286,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         private static readonly int score_per_tick = new SpinnerBonusTick.OsuSpinnerBonusTickJudgement().MaxNumericResult;
 
-        private int completedFullSpins;
+        private int wholeSpins;
 
         private void updateBonusScore()
         {
@@ -295,14 +295,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             int spins = (int)(Result.RateAdjustedRotation / 360);
 
-            if (spins < completedFullSpins)
+            if (spins < wholeSpins)
             {
                 // rewinding, silently handle
-                completedFullSpins = spins;
+                wholeSpins = spins;
                 return;
             }
 
-            while (completedFullSpins != spins)
+            while (wholeSpins != spins)
             {
                 var tick = ticks.FirstOrDefault(t => !t.Result.HasResult);
 
@@ -312,10 +312,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     tick.TriggerResult(true);
 
                     if (tick is DrawableSpinnerBonusTick)
-                        gainedBonus.Value = score_per_tick * (spins - HitObject.SpinsRequiredForBonus);
+                        gainedBonus.Value = score_per_tick * (spins - HitObject.SpinsRequired);
                 }
 
-                completedFullSpins++;
+                wholeSpins++;
             }
         }
     }

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

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

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

@@ -16,7 +16,6 @@ using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
 
@@ -114,7 +113,7 @@ namespace osu.Game.Rulesets.Osu.Objects
         public double SpanDuration => Duration / this.SpanCount();
 
         /// <summary>
-        /// The computed velocity of this <see cref="Slider"/>. This is the amount of path distance travelled in 1 ms.
+        /// Velocity of this <see cref="Slider"/>.
         /// </summary>
         public double Velocity { get; private set; }
 
@@ -135,16 +134,17 @@ namespace osu.Game.Rulesets.Osu.Objects
         /// </summary>
         public bool OnlyJudgeNestedObjects = true;
 
-        public BindableNumber<double> SliderVelocityMultiplierBindable { get; } = new BindableDouble(1)
+        public BindableNumber<double> SliderVelocityBindable { get; } = new BindableDouble(1)
         {
+            Precision = 0.01,
             MinValue = 0.1,
             MaxValue = 10
         };
 
-        public double SliderVelocityMultiplier
+        public double SliderVelocity
         {
-            get => SliderVelocityMultiplierBindable.Value;
-            set => SliderVelocityMultiplierBindable.Value = value;
+            get => SliderVelocityBindable.Value;
+            set => SliderVelocityBindable.Value = value;
         }
 
         public bool GenerateTicks { get; set; } = true;
@@ -167,11 +167,9 @@ namespace osu.Game.Rulesets.Osu.Objects
 
             TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
 
-            Velocity = BASE_SCORING_DISTANCE * difficulty.SliderMultiplier / LegacyRulesetExtensions.GetPrecisionAdjustedBeatLength(this, timingPoint, OsuRuleset.SHORT_NAME);
-            // WARNING: this is intentionally not computed as `BASE_SCORING_DISTANCE * difficulty.SliderMultiplier`
-            // for backwards compatibility reasons (intentionally introducing floating point errors to match stable).
-            double scoringDistance = Velocity * timingPoint.BeatLength;
+            double scoringDistance = BASE_SCORING_DISTANCE * difficulty.SliderMultiplier * SliderVelocity;
 
+            Velocity = scoringDistance / timingPoint.BeatLength;
             TickDistance = GenerateTicks ? (scoringDistance / difficulty.SliderTickRate * TickDistanceMultiplier) : double.PositiveInfinity;
         }
 

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

@@ -18,16 +18,6 @@ namespace osu.Game.Rulesets.Osu.Objects
 {
     public class Spinner : OsuHitObject, IHasDuration
     {
-        /// <summary>
-        /// The RPM required to clear the spinner at ODs [ 0, 5, 10 ].
-        /// </summary>
-        private static readonly (int min, int mid, int max) clear_rpm_range = (90, 150, 225);
-
-        /// <summary>
-        /// The RPM required to complete the spinner and receive full score at ODs [ 0, 5, 10 ].
-        /// </summary>
-        private static readonly (int min, int mid, int max) complete_rpm_range = (250, 380, 430);
-
         public double EndTime
         {
             get => StartTime + Duration;
@@ -41,16 +31,6 @@ namespace osu.Game.Rulesets.Osu.Objects
         /// </summary>
         public int SpinsRequired { get; protected set; } = 1;
 
-        /// <summary>
-        /// The number of spins required to start receiving bonus score. The first bonus is awarded on this spin count.
-        /// </summary>
-        public int SpinsRequiredForBonus => SpinsRequired + bonus_spins_gap;
-
-        /// <summary>
-        /// The gap between spinner completion and the first bonus-awarding spin.
-        /// </summary>
-        private const int bonus_spins_gap = 2;
-
         /// <summary>
         /// Number of spins available to give bonus, beyond <see cref="SpinsRequired"/>.
         /// </summary>
@@ -62,23 +42,25 @@ namespace osu.Game.Rulesets.Osu.Objects
         {
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
 
-            // The average RPS required over the length of the spinner to clear the spinner.
-            double minRps = IBeatmapDifficultyInfo.DifficultyRange(difficulty.OverallDifficulty, clear_rpm_range) / 60;
+            // spinning doesn't match 1:1 with stable, so let's fudge them easier for the time being.
+            const double stable_matching_fudge = 0.6;
 
-            // The RPS required over the length of the spinner to receive full score (all normal + bonus ticks).
-            double maxRps = IBeatmapDifficultyInfo.DifficultyRange(difficulty.OverallDifficulty, complete_rpm_range) / 60;
+            // close to 477rpm
+            const double maximum_rotations_per_second = 8;
 
             double secondsDuration = Duration / 1000;
 
-            SpinsRequired = (int)(minRps * secondsDuration);
-            MaximumBonusSpins = Math.Max(0, (int)(maxRps * secondsDuration) - SpinsRequired - bonus_spins_gap);
+            double minimumRotationsPerSecond = stable_matching_fudge * IBeatmapDifficultyInfo.DifficultyRange(difficulty.OverallDifficulty, 3, 5, 7.5);
+
+            SpinsRequired = (int)(secondsDuration * minimumRotationsPerSecond);
+            MaximumBonusSpins = (int)((maximum_rotations_per_second - minimumRotationsPerSecond) * secondsDuration);
         }
 
         protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
         {
             base.CreateNestedHitObjects(cancellationToken);
 
-            int totalSpins = MaximumBonusSpins + SpinsRequired + bonus_spins_gap;
+            int totalSpins = MaximumBonusSpins + SpinsRequired;
 
             for (int i = 0; i < totalSpins; i++)
             {
@@ -86,7 +68,7 @@ namespace osu.Game.Rulesets.Osu.Objects
 
                 double startTime = StartTime + (float)(i + 1) / totalSpins * Duration;
 
-                AddNested(i < SpinsRequiredForBonus
+                AddNested(i < SpinsRequired
                     ? new SpinnerTick { StartTime = startTime, SpinnerDuration = Duration }
                     : new SpinnerBonusTick { StartTime = startTime, SpinnerDuration = Duration, Samples = new[] { CreateHitSampleInfo("spinnerbonus") } });
             }

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -33,7 +33,6 @@ using osu.Game.Rulesets.Osu.Statistics;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.Scoring.Legacy;
 using osu.Game.Rulesets.UI;
 using osu.Game.Scoring;
 using osu.Game.Screens.Edit.Setup;

osu.Game.Rulesets.Osu/Resources/Testing/Beatmaps/slider-paths-edge-case-expected-conversion.json

@@ -1,94 +0,0 @@
-{
-  "Mappings": [
-    {
-      "StartTime": 46060.0,
-      "Objects": [
-        {
-          "StartTime": 46060.0,
-          "EndTime": 46060.0,
-          "X": 160.0,
-          "Y": 208.0,
-          "StackOffset": {
-            "X": 0.0,
-            "Y": 0.0
-          }
-        },
-        {
-          "StartTime": 46398.0,
-          "EndTime": 46398.0,
-          "X": 160.980164,
-          "Y": 317.779083,
-          "StackOffset": {
-            "X": 0.0,
-            "Y": 0.0
-          }
-        },
-        {
-          "StartTime": 46737.0,
-          "EndTime": 46737.0,
-          "X": 268.887268,
-          "Y": 320.0,
-          "StackOffset": {
-            "X": 0.0,
-            "Y": 0.0
-          }
-        },
-        {
-          "StartTime": 47040.0,
-          "EndTime": 47040.0,
-          "X": 378.995544,
-          "Y": 320.0,
-          "StackOffset": {
-            "X": 0.0,
-            "Y": 0.0
-          }
-        }
-      ]
-    },
-    {
-      "StartTime": 123348.0,
-      "Objects": [
-        {
-          "StartTime": 123348.0,
-          "EndTime": 123348.0,
-          "X": 352.0,
-          "Y": 160.0,
-          "StackOffset": {
-            "X": 0.0,
-            "Y": 0.0
-          }
-        },
-        {
-          "StartTime": 123686.0,
-          "EndTime": 123686.0,
-          "X": 351.019836,
-          "Y": 50.2209129,
-          "StackOffset": {
-            "X": 0.0,
-            "Y": 0.0
-          }
-        },
-        {
-          "StartTime": 124025.0,
-          "EndTime": 124025.0,
-          "X": 243.112747,
-          "Y": 48.0,
-          "StackOffset": {
-            "X": 0.0,
-            "Y": 0.0
-          }
-        },
-        {
-          "StartTime": 124328.0,
-          "EndTime": 124328.0,
-          "X": 133.004471,
-          "Y": 48.0,
-          "StackOffset": {
-            "X": 0.0,
-            "Y": 0.0
-          }
-        }
-      ]
-    }
-  ]
-}

osu.Game.Rulesets.Osu/Resources/Testing/Beatmaps/slider-paths-edge-case.osu

@@ -1,19 +0,0 @@
-osu file format v6
-
-[General]
-StackLeniency: 0.7
-
-[Difficulty]
-HPDrainRate:1
-CircleSize:3
-OverallDifficulty:1
-SliderMultiplier:1.1
-SliderTickRate:1
-
-[TimingPoints]
--41,338.983050847458,4,1,0,70,1,0
-93648,-100,4,1,0,70,0,0
-
-[HitObjects]
-160,208,46060,6,0,B|161:320|161:320|271:320|271:320,1,330,8|0
-352,160,123348,6,0,B|351:48|351:48|241:48|241:48,1,330,8|0

osu.Game.Rulesets.Osu/Resources/Testing/Beatmaps/slider-ticks-edge-case-expected-conversion.json

@@ -1,39 +0,0 @@
-{
-  "Mappings": [
-    {
-      "StartTime": 7493.0,
-      "Objects": [
-        {
-          "StartTime": 7493.0,
-          "EndTime": 7493.0,
-          "X": 130.0,
-          "Y": 232.0,
-          "StackOffset": {
-            "X": 0.0,
-            "Y": 0.0
-          }
-        },
-        {
-          "StartTime": 7817.0,
-          "EndTime": 7817.0,
-          "X": 30.9946651,
-          "Y": 208.5157,
-          "StackOffset": {
-            "X": 0.0,
-            "Y": 0.0
-          }
-        },
-        {
-          "StartTime": 7843.0,
-          "EndTime": 7843.0,
-          "X": 33.7820168,
-          "Y": 208.9957,
-          "StackOffset": {
-            "X": 0.0,
-            "Y": 0.0
-          }
-        }
-      ]
-    }
-  ]
-}

osu.Game.Rulesets.Osu/Resources/Testing/Beatmaps/slider-ticks-edge-case.osu

@@ -1,31 +0,0 @@
-osu file format v14
-
-[General]
-StackLeniency: 0.7
-
-[Difficulty]
-HPDrainRate:3
-CircleSize:3.4
-OverallDifficulty:4
-ApproachRate:5.5
-SliderMultiplier:1.1
-SliderTickRate:1
-
-[Events]
-//Background and Video events
-0,0,"aa.jpg",0,0
-//Break Periods
-//Storyboard Layer 0 (Background)
-//Storyboard Layer 1 (Fail)
-//Storyboard Layer 2 (Pass)
-//Storyboard Layer 3 (Foreground)
-//Storyboard Layer 4 (Overlay)
-//Storyboard Sound Samples
-
-[TimingPoints]
-6967,350.877192982456,6,2,1,55,1,0
-6967,-100,3,2,1,55,0,0
-7493,-111.111111111111,3,2,1,55,0,0
-
-[HitObjects]
-130,232,7493,6,0,P|78:218|28:208,1,101.82149697876,0|0,3:2|2:0,2:0:0:0:

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

@@ -48,7 +48,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
 
         private Bindable<bool> configHitLighting = null!;
 
-        private static readonly Vector2 circle_size = OsuHitObject.OBJECT_DIMENSIONS;
+        private static readonly Vector2 circle_size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
 
         [Resolved]
         private DrawableHitObject drawableObject { get; set; } = null!;

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

@@ -27,7 +27,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
 
-            Size = OsuHitObject.OBJECT_DIMENSIONS;
+            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
 
             InternalChildren = new Drawable[]
             {

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

@@ -9,6 +9,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Skinning.Default
 {
@@ -21,7 +22,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
 
         public CirclePiece()
         {
-            Size = OsuHitObject.OBJECT_DIMENSIONS;
+            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
             Masking = true;
 
             CornerRadius = Size.X / 2;

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

@@ -7,6 +7,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Skinning.Default
 {
@@ -19,7 +20,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
 
         public ExplodePiece()
         {
-            Size = OsuHitObject.OBJECT_DIMENSIONS;
+            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
 
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;

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

@@ -5,6 +5,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Rulesets.Osu.Objects;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Skinning.Default
 {
@@ -12,7 +13,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
     {
         public FlashPiece()
         {
-            Size = OsuHitObject.OBJECT_DIMENSIONS;
+            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
 
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;

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

@@ -9,6 +9,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Skinning.Default
@@ -24,7 +25,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
 
         public MainCirclePiece()
         {
-            Size = OsuHitObject.OBJECT_DIMENSIONS;
+            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
 
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;

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

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

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

@@ -27,7 +27,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
 
-            Size = OsuHitObject.OBJECT_DIMENSIONS;
+            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
 
             Child = new SkinnableDrawable(new OsuSkinComponentLookup(OsuSkinComponents.ReverseArrow), _ => new SpriteIcon
             {

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

@@ -5,6 +5,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Rulesets.Osu.Objects;
+using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Skinning.Default
@@ -13,7 +14,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
     {
         public RingPiece(float thickness = 9)
         {
-            Size = OsuHitObject.OBJECT_DIMENSIONS;
+            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
 
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;

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

@@ -5,14 +5,12 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Skinning;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 {
-    // todo: this should probably not be a SkinnableSprite, as this is always created for legacy skins and is recreated on skin change.
     public partial class LegacyApproachCircle : SkinnableSprite
     {
         private readonly IBindable<Color4> accentColour = new Bindable<Color4>();
@@ -21,7 +19,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
         private DrawableHitObject drawableObject { get; set; } = null!;
 
         public LegacyApproachCircle()
-            : base("Gameplay/osu/approachcircle", OsuHitObject.OBJECT_DIMENSIONS)
+            : base("Gameplay/osu/approachcircle")
         {
         }
 

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

@@ -14,6 +14,7 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Skinning;
+using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Skinning.Legacy
@@ -50,7 +51,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
             this.priorityLookupPrefix = priorityLookupPrefix;
             this.hasNumber = hasNumber;
 
-            Size = OsuHitObject.OBJECT_DIMENSIONS;
+            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
         }
 
         [BackgroundDependencyLoader]
@@ -67,7 +68,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
             // expected behaviour in this scenario is not showing the overlay, rather than using hitcircleoverlay.png.
             InternalChildren = new[]
             {
-                CircleSprite = new LegacyKiaiFlashingDrawable(() => new Sprite { Texture = skin.GetTexture(circleName)?.WithMaximumSize(OsuHitObject.OBJECT_DIMENSIONS) })
+                CircleSprite = new LegacyKiaiFlashingDrawable(() => new Sprite { Texture = skin.GetTexture(circleName) })
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -76,7 +77,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Child = OverlaySprite = new LegacyKiaiFlashingDrawable(() => skin.GetAnimation(@$"{circleName}overlay", true, true, frameLength: 1000 / 2d, maxSize: OsuHitObject.OBJECT_DIMENSIONS))
+                    Child = OverlaySprite = new LegacyKiaiFlashingDrawable(() => skin.GetAnimation(@$"{circleName}overlay", true, true, frameLength: 1000 / 2d))
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,

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

@@ -7,7 +7,6 @@ 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;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Skinning;
 using osuTK.Graphics;
@@ -36,7 +35,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 
             var skin = skinSource.FindProvider(s => s.GetTexture(lookupName) != null);
 
-            InternalChild = arrow = (skin?.GetAnimation(lookupName, true, true, maxSize: OsuHitObject.OBJECT_DIMENSIONS) ?? Empty());
+            InternalChild = arrow = (skin?.GetAnimation(lookupName, true, true) ?? Empty());
             textureIsDefaultSkin = skin is ISkinTransformer transformer && transformer.Skin is DefaultLegacySkin;
         }
 

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

@@ -7,7 +7,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Skinning;
 using osuTK.Graphics;
@@ -47,7 +46,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Texture = skin.GetTexture("sliderb-nd")?.WithMaximumSize(OsuHitObject.OBJECT_DIMENSIONS),
+                    Texture = skin.GetTexture("sliderb-nd"),
                     Colour = new Color4(5, 5, 5, 255),
                 },
                 LegacyColourCompatibility.ApplyWithDoubledAlpha(animationContent.With(d =>
@@ -59,7 +58,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Texture = skin.GetTexture("sliderb-spec")?.WithMaximumSize(OsuHitObject.OBJECT_DIMENSIONS),
+                    Texture = skin.GetTexture("sliderb-spec"),
                     Blending = BlendingParameters.Additive,
                 },
             };

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

@@ -4,7 +4,6 @@
 using System;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Skinning;
 using osuTK;
 
@@ -21,7 +20,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
         /// Their hittable area is 128px, but the actual circle portion is 118px.
         /// We must account for some gameplay elements such as slider bodies, where this padding is not present.
         /// </summary>
-        public const float LEGACY_CIRCLE_RADIUS = OsuHitObject.OBJECT_RADIUS - 5;
+        public const float LEGACY_CIRCLE_RADIUS = 64 - 5;
 
         public OsuLegacySkinTransformer(ISkin skin)
             : base(skin)
@@ -42,14 +41,14 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                         return this.GetAnimation("sliderscorepoint", false, false);
 
                     case OsuSkinComponents.SliderFollowCircle:
-                        var followCircleContent = this.GetAnimation("sliderfollowcircle", true, true, true, maxSize: new Vector2(308f));
+                        var followCircleContent = this.GetAnimation("sliderfollowcircle", true, true, true);
                         if (followCircleContent != null)
                             return new LegacyFollowCircle(followCircleContent);
 
                         return null;
 
                     case OsuSkinComponents.SliderBall:
-                        var sliderBallContent = this.GetAnimation("sliderb", true, true, animationSeparator: "", maxSize: OsuHitObject.OBJECT_DIMENSIONS);
+                        var sliderBallContent = this.GetAnimation("sliderb", true, true, animationSeparator: "");
 
                         // todo: slider ball has a custom frame delay based on velocity
                         // Math.Max((150 / Velocity) * GameBase.SIXTY_FRAME_TIME, GameBase.SIXTY_FRAME_TIME);
@@ -139,7 +138,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                         if (!this.HasFont(LegacyFont.HitCircle))
                             return null;
 
-                        return new LegacySpriteText(LegacyFont.HitCircle, OsuHitObject.OBJECT_DIMENSIONS)
+                        return new LegacySpriteText(LegacyFont.HitCircle)
                         {
                             // stable applies a blanket 0.8x scale to hitcircle fonts
                             Scale = new Vector2(0.8f),

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

@@ -95,7 +95,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                 {
                     new RingPiece(3)
                     {
-                        Size = OsuHitObject.OBJECT_DIMENSIONS,
+                        Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2),
                         Alpha = 0.1f,
                     }
                 };

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

@@ -286,7 +286,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                     if (time - part.Time >= 1)
                         continue;
 
-                    vertexBatch.Add(new TexturedTrailVertex
+                    vertexBatch.Add(new TexturedTrailVertex(renderer)
                     {
                         Position = new Vector2(part.Position.X - size.X * originPosition.X, part.Position.Y + size.Y * (1 - originPosition.Y)),
                         TexturePosition = textureRect.BottomLeft,
@@ -295,7 +295,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                         Time = part.Time
                     });
 
-                    vertexBatch.Add(new TexturedTrailVertex
+                    vertexBatch.Add(new TexturedTrailVertex(renderer)
                     {
                         Position = new Vector2(part.Position.X + size.X * (1 - originPosition.X), part.Position.Y + size.Y * (1 - originPosition.Y)),
                         TexturePosition = textureRect.BottomRight,
@@ -304,7 +304,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                         Time = part.Time
                     });
 
-                    vertexBatch.Add(new TexturedTrailVertex
+                    vertexBatch.Add(new TexturedTrailVertex(renderer)
                     {
                         Position = new Vector2(part.Position.X + size.X * (1 - originPosition.X), part.Position.Y - size.Y * originPosition.Y),
                         TexturePosition = textureRect.TopRight,
@@ -313,7 +313,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                         Time = part.Time
                     });
 
-                    vertexBatch.Add(new TexturedTrailVertex
+                    vertexBatch.Add(new TexturedTrailVertex(renderer)
                     {
                         Position = new Vector2(part.Position.X - size.X * originPosition.X, part.Position.Y - size.Y * originPosition.Y),
                         TexturePosition = textureRect.TopLeft,
@@ -362,12 +362,22 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
             [VertexMember(1, VertexAttribPointerType.Float)]
             public float Time;
 
+            [VertexMember(1, VertexAttribPointerType.Int)]
+            private readonly int maskingIndex;
+
+            public TexturedTrailVertex(IRenderer renderer)
+            {
+                this = default;
+                maskingIndex = renderer.CurrentMaskingIndex;
+            }
+
             public bool Equals(TexturedTrailVertex other)
             {
                 return Position.Equals(other.Position)
                        && TexturePosition.Equals(other.TexturePosition)
                        && Colour.Equals(other.Colour)
-                       && Time.Equals(other.Time);
+                       && Time.Equals(other.Time)
+                       && maskingIndex == other.maskingIndex;
             }
         }
     }

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

@@ -1,185 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using NUnit.Framework;
-using osu.Framework.Bindables;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.Taiko.Beatmaps;
-using osu.Game.Rulesets.Taiko.Judgements;
-using osu.Game.Rulesets.Taiko.Objects;
-using osu.Game.Rulesets.Taiko.Scoring;
-using osu.Game.Tests.Visual.Gameplay;
-
-namespace osu.Game.Rulesets.Taiko.Tests
-{
-    [TestFixture]
-    public partial class TestSceneScoring : ScoringTestScene
-    {
-        private Bindable<double> scoreMultiplier { get; } = new BindableDouble
-        {
-            Default = 4,
-            Value = 4
-        };
-
-        protected override IBeatmap CreateBeatmap(int maxCombo)
-        {
-            var beatmap = new TaikoBeatmap();
-            for (int i = 0; i < maxCombo; ++i)
-                beatmap.HitObjects.Add(new Hit());
-            return beatmap;
-        }
-
-        protected override IScoringAlgorithm CreateScoreV1() => new ScoreV1 { ScoreMultiplier = { BindTarget = scoreMultiplier } };
-        protected override IScoringAlgorithm CreateScoreV2(int maxCombo) => new ScoreV2(maxCombo);
-
-        protected override ProcessorBasedScoringAlgorithm CreateScoreAlgorithm(IBeatmap beatmap, ScoringMode mode) => new TaikoProcessorBasedScoringAlgorithm(beatmap, mode);
-
-        [Test]
-        public void TestBasicScenarios()
-        {
-            AddStep("set up score multiplier", () =>
-            {
-                scoreMultiplier.BindValueChanged(_ => Rerun());
-            });
-            AddStep("set max combo to 100", () => MaxCombo.Value = 100);
-            AddStep("set perfect score", () =>
-            {
-                NonPerfectLocations.Clear();
-                MissLocations.Clear();
-            });
-            AddStep("set score with misses", () =>
-            {
-                NonPerfectLocations.Clear();
-                MissLocations.Clear();
-                MissLocations.AddRange(new[] { 24d, 49 });
-            });
-            AddStep("set score with misses and OKs", () =>
-            {
-                NonPerfectLocations.Clear();
-                MissLocations.Clear();
-
-                NonPerfectLocations.AddRange(new[] { 9d, 19, 29, 39, 59, 69, 79, 89, 99 });
-                MissLocations.AddRange(new[] { 24d, 49 });
-            });
-            AddSliderStep("adjust score multiplier", 0, 10, (int)scoreMultiplier.Default, multiplier => scoreMultiplier.Value = multiplier);
-        }
-
-        private const int base_great = 300;
-        private const int base_ok = 150;
-
-        private class ScoreV1 : IScoringAlgorithm
-        {
-            private int currentCombo;
-
-            public BindableDouble ScoreMultiplier { get; } = new BindableDouble();
-
-            public void ApplyHit() => applyHitV1(base_great);
-
-            public void ApplyNonPerfect() => applyHitV1(base_ok);
-
-            public void ApplyMiss() => applyHitV1(0);
-
-            private void applyHitV1(int baseScore)
-            {
-                if (baseScore == 0)
-                {
-                    currentCombo = 0;
-                    return;
-                }
-
-                TotalScore += baseScore;
-
-                // combo multiplier
-                // ReSharper disable once PossibleLossOfFraction
-                TotalScore += (int)((baseScore / 35) * 2 * (ScoreMultiplier.Value + 1)) * (Math.Min(100, currentCombo) / 10);
-
-                currentCombo++;
-            }
-
-            public long TotalScore { get; private set; }
-        }
-
-        private class ScoreV2 : IScoringAlgorithm
-        {
-            private int currentCombo;
-            private double comboPortion;
-            private double currentBaseScore;
-            private double maxBaseScore;
-            private int currentHits;
-
-            private readonly double comboPortionMax;
-            private readonly int maxCombo;
-
-            private const double combo_base = 4;
-
-            public ScoreV2(int maxCombo)
-            {
-                this.maxCombo = maxCombo;
-
-                for (int i = 0; i < this.maxCombo; i++)
-                    ApplyHit();
-
-                comboPortionMax = comboPortion;
-
-                currentCombo = 0;
-                comboPortion = 0;
-                currentBaseScore = 0;
-                maxBaseScore = 0;
-                currentHits = 0;
-            }
-
-            public void ApplyHit() => applyHitV2(base_great);
-
-            public void ApplyNonPerfect() => applyHitV2(base_ok);
-
-            private void applyHitV2(int baseScore)
-            {
-                maxBaseScore += base_great;
-                currentBaseScore += baseScore;
-
-                currentHits++;
-
-                // `base_great` is INTENTIONALLY used above here instead of `baseScore`
-                // see `BaseHitValue` override in `ScoreChangeTaiko` on stable
-                comboPortion += base_great * Math.Min(Math.Max(0.5, Math.Log(++currentCombo, combo_base)), Math.Log(400, combo_base));
-            }
-
-            public void ApplyMiss()
-            {
-                currentHits++;
-                maxBaseScore += base_great;
-                currentCombo = 0;
-            }
-
-            public long TotalScore
-            {
-                get
-                {
-                    double accuracy = currentBaseScore / maxBaseScore;
-
-                    return (int)Math.Round
-                    (
-                        250000 * comboPortion / comboPortionMax +
-                        750000 * Math.Pow(accuracy, 3.6) * ((double)currentHits / maxCombo)
-                    );
-                }
-            }
-        }
-
-        private class TaikoProcessorBasedScoringAlgorithm : ProcessorBasedScoringAlgorithm
-        {
-            public TaikoProcessorBasedScoringAlgorithm(IBeatmap beatmap, ScoringMode mode)
-                : base(beatmap, mode)
-            {
-            }
-
-            protected override ScoreProcessor CreateScoreProcessor() => new TaikoScoreProcessor();
-            protected override JudgementResult CreatePerfectJudgementResult() => new JudgementResult(new Hit(), new TaikoJudgement()) { Type = HitResult.Great };
-            protected override JudgementResult CreateNonPerfectJudgementResult() => new JudgementResult(new Hit(), new TaikoJudgement()) { Type = HitResult.Ok };
-            protected override JudgementResult CreateMissJudgementResult() => new JudgementResult(new Hit(), new TaikoJudgement()) { Type = HitResult.Miss };
-        }
-    }
-}

osu.Game.Rulesets.Taiko.Tests/osu.Game.Rulesets.Taiko.Tests.csproj

@@ -1,9 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
     <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
   </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>

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

@@ -14,7 +14,6 @@ using JetBrains.Annotations;
 using osu.Game.Audio;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Beatmaps.Formats;
-using osu.Game.Rulesets.Objects.Legacy;
 
 namespace osu.Game.Rulesets.Taiko.Beatmaps
 {
@@ -65,7 +64,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                 {
                     if (hitObject is not IHasSliderVelocity hasSliderVelocity) continue;
 
-                    double nextScrollSpeed = hasSliderVelocity.SliderVelocityMultiplier;
+                    double nextScrollSpeed = hasSliderVelocity.SliderVelocity;
                     EffectControlPoint currentEffectPoint = converted.ControlPointInfo.EffectPointAt(hitObject.StartTime);
 
                     if (!Precision.AlmostEquals(lastScrollSpeed, nextScrollSpeed, acceptableDifference: currentEffectPoint.ScrollSpeedBindable.Precision))
@@ -187,9 +186,10 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
             TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(obj.StartTime);
 
             double beatLength;
-
-            if (obj is IHasSliderVelocity hasSliderVelocity)
-                beatLength = LegacyRulesetExtensions.GetPrecisionAdjustedBeatLength(hasSliderVelocity, timingPoint, TaikoRuleset.SHORT_NAME);
+            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;
 

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

@@ -25,9 +25,12 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
 
         public override int Version => 20220902;
 
+        private readonly IWorkingBeatmap workingBeatmap;
+
         public TaikoDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
+            workingBeatmap = beatmap;
         }
 
         protected override Skill[] CreateSkills(IBeatmap beatmap, Mod[] mods, double clockRate)
@@ -96,6 +99,15 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
                 MaxCombo = beatmap.HitObjects.Count(h => h is Hit),
             };
 
+            if (ComputeLegacyScoringValues)
+            {
+                TaikoLegacyScoreSimulator sv1Simulator = new TaikoLegacyScoreSimulator();
+                sv1Simulator.Simulate(workingBeatmap, beatmap, mods);
+                attributes.LegacyAccuracyScore = sv1Simulator.AccuracyScore;
+                attributes.LegacyComboScore = sv1Simulator.ComboScore;
+                attributes.LegacyBonusScoreRatio = sv1Simulator.BonusScoreRatio;
+            }
+
             return attributes;
         }
 

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

@@ -2,29 +2,39 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.Scoring.Legacy;
 using osu.Game.Rulesets.Taiko.Objects;
 
 namespace osu.Game.Rulesets.Taiko.Difficulty
 {
     internal class TaikoLegacyScoreSimulator : ILegacyScoreSimulator
     {
+        public int AccuracyScore { get; private set; }
+
+        public int ComboScore { get; private set; }
+
+        public double BonusScoreRatio => legacyBonusScore == 0 ? 0 : (double)modernBonusScore / legacyBonusScore;
+
         private int legacyBonusScore;
-        private int standardisedBonusScore;
+        private int modernBonusScore;
         private int combo;
 
+        private double modMultiplier;
         private int difficultyPeppyStars;
         private IBeatmap playableBeatmap = null!;
+        private IReadOnlyList<Mod> mods = null!;
 
-        public LegacyScoreAttributes Simulate(IWorkingBeatmap workingBeatmap, IBeatmap playableBeatmap)
+        public void Simulate(IWorkingBeatmap workingBeatmap, IBeatmap playableBeatmap, IReadOnlyList<Mod> mods)
         {
             this.playableBeatmap = playableBeatmap;
+            this.mods = mods;
 
             IBeatmap baseBeatmap = workingBeatmap.Beatmap;
 
@@ -66,17 +76,13 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
                  + baseBeatmap.Difficulty.CircleSize
                  + Math.Clamp((float)objectCount / drainLength * 8, 0, 16)) / 38 * 5);
 
-            LegacyScoreAttributes attributes = new LegacyScoreAttributes();
+            modMultiplier = mods.Aggregate(1.0, (current, mod) => current * mod.ScoreMultiplier);
 
             foreach (var obj in playableBeatmap.HitObjects)
-                simulateHit(obj, ref attributes);
-
-            attributes.BonusScoreRatio = legacyBonusScore == 0 ? 0 : (double)standardisedBonusScore / legacyBonusScore;
-
-            return attributes;
+                simulateHit(obj);
         }
 
-        private void simulateHit(HitObject hitObject, ref LegacyScoreAttributes attributes)
+        private void simulateHit(HitObject hitObject)
         {
             bool increaseCombo = true;
             bool addScoreComboMultiplier = false;
@@ -103,24 +109,21 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
                 case Swell swell:
                     // The taiko swell generally does not match the osu-stable implementation in any way.
                     // We'll redo the calculations to match osu-stable here...
-
-                    // Normally, this value depends on the final overall difficulty. For simplicity, we'll only consider the worst case that maximises rotations.
-                    const double minimum_rotations_per_second = 7.5;
+                    double minimumRotationsPerSecond = IBeatmapDifficultyInfo.DifficultyRange(playableBeatmap.Difficulty.OverallDifficulty, 3, 5, 7.5);
+                    double secondsDuration = swell.Duration / 1000;
 
                     // The amount of half spins that are required to successfully complete the spinner (i.e. get a 300).
-                    int halfSpinsRequiredForCompletion = (int)(swell.Duration / 1000 * minimum_rotations_per_second);
+                    int halfSpinsRequiredForCompletion = (int)(secondsDuration * minimumRotationsPerSecond);
+
                     halfSpinsRequiredForCompletion = (int)Math.Max(1, halfSpinsRequiredForCompletion * 1.65f);
 
-                    //
-                    // Normally, this multiplier depends on the active mods (DT = 0.75, HT = 1.5). For simplicity, we'll only consider the worst case that maximises rotations.
-                    // This way, scores remain beatable at the cost of the conversion being slightly inaccurate.
-                    //   - A perfect DT/NM score will have less than 1M total score (excluding bonus).
-                    //   - A perfect HT score will have 1M total score (excluding bonus).
-                    //
-                    halfSpinsRequiredForCompletion = Math.Max(1, (int)(halfSpinsRequiredForCompletion * 1.5f));
+                    if (mods.Any(m => m is ModDoubleTime))
+                        halfSpinsRequiredForCompletion = Math.Max(1, (int)(halfSpinsRequiredForCompletion * 0.75f));
+                    if (mods.Any(m => m is ModHalfTime))
+                        halfSpinsRequiredForCompletion = Math.Max(1, (int)(halfSpinsRequiredForCompletion * 1.5f));
 
                     for (int i = 0; i <= halfSpinsRequiredForCompletion; i++)
-                        simulateHit(new SwellTick(), ref attributes);
+                        simulateHit(new SwellTick());
 
                     scoreIncrease = 300;
                     addScoreComboMultiplier = true;
@@ -136,7 +139,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
 
                 case DrumRoll:
                     foreach (var nested in hitObject.NestedHitObjects)
-                        simulateHit(nested, ref attributes);
+                        simulateHit(nested);
                     return;
             }
 
@@ -156,7 +159,8 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
             {
                 int oldScoreIncrease = scoreIncrease;
 
-                scoreIncrease += scoreIncrease / 35 * 2 * (difficultyPeppyStars + 1) * (Math.Min(100, combo) / 10);
+                // ReSharper disable once PossibleLossOfFraction (intentional to match osu-stable...)
+                scoreIncrease += (int)(scoreIncrease / 35 * 2 * (difficultyPeppyStars + 1) * modMultiplier) * (Math.Min(100, combo) / 10);
 
                 if (hitObject is Swell)
                 {
@@ -181,15 +185,15 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
             scoreIncrease -= comboScoreIncrease;
 
             if (addScoreComboMultiplier)
-                attributes.ComboScore += comboScoreIncrease;
+                ComboScore += comboScoreIncrease;
 
             if (isBonus)
             {
                 legacyBonusScore += scoreIncrease;
-                standardisedBonusScore += Judgement.ToNumericResult(bonusResult);
+                modernBonusScore += Judgement.ToNumericResult(bonusResult);
             }
             else
-                attributes.AccuracyScore += scoreIncrease;
+                AccuracyScore += scoreIncrease;
 
             if (increaseCombo)
                 combo++;

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

@@ -1,37 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Collections.Generic;
-using osu.Framework.Bindables;
-using osu.Game.Beatmaps;
-using osu.Game.Configuration;
-using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Taiko.UI;
-using osu.Game.Rulesets.UI.Scrolling;
-
-namespace osu.Game.Rulesets.Taiko.Edit
-{
-    public partial class DrawableTaikoEditorRuleset : DrawableTaikoRuleset, ISupportConstantAlgorithmToggle
-    {
-        public BindableBool ShowSpeedChanges { get; set; } = new BindableBool();
-
-        public DrawableTaikoEditorRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods)
-            : base(ruleset, beatmap, mods)
-        {
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            ShowSpeedChanges.BindValueChanged(showChanges => VisualisationMethod = showChanges.NewValue ? ScrollVisualisationMethod.Overlapping : ScrollVisualisationMethod.Constant, true);
-        }
-
-        protected override double ComputeTimeRange()
-        {
-            // Adjust when we're using constant algorithm to not be sluggish.
-            double multiplier = ShowSpeedChanges.Value ? 1 : 4;
-            return base.ComputeTimeRange() / multiplier;
-        }
-    }
-}

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

@@ -2,17 +2,14 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
-using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Taiko.Objects;
-using osu.Game.Rulesets.UI;
 using osu.Game.Screens.Edit.Compose.Components;
 
 namespace osu.Game.Rulesets.Taiko.Edit
 {
-    public partial class TaikoHitObjectComposer : ScrollingHitObjectComposer<TaikoHitObject>
+    public partial class TaikoHitObjectComposer : HitObjectComposer<TaikoHitObject>
     {
         protected override bool ApplyHorizontalCentering => false;
 
@@ -28,9 +25,6 @@ namespace osu.Game.Rulesets.Taiko.Edit
             new SwellCompositionTool()
         };
 
-        protected override DrawableRuleset<TaikoHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods) =>
-            new DrawableTaikoEditorRuleset(ruleset, beatmap, mods);
-
         protected override ComposeBlueprintContainer CreateBlueprintContainer()
             => new TaikoBlueprintContainer(this);
     }

osu.Game.Rulesets.Taiko/Skinning/Legacy/LegacyCirclePiece.cs

@@ -22,8 +22,6 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
 {
     public partial class LegacyCirclePiece : CompositeDrawable, IHasAccentColour
     {
-        private static readonly Vector2 circle_piece_size = new Vector2(128);
-
         private Drawable backgroundLayer = null!;
         private Drawable? foregroundLayer;
 
@@ -54,9 +52,9 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
 
                 string prefix = ((drawableHitObject.HitObject as TaikoStrongableHitObject)?.IsStrong ?? false) ? big_hit : normal_hit;
 
-                return skin.GetAnimation($"{prefix}{lookup}", true, false, maxSize: circle_piece_size) ??
+                return skin.GetAnimation($"{prefix}{lookup}", true, false) ??
                        // fallback to regular size if "big" version doesn't exist.
-                       skin.GetAnimation($"{normal_hit}{lookup}", true, false, maxSize: circle_piece_size);
+                       skin.GetAnimation($"{normal_hit}{lookup}", true, false);
             }
 
             // backgroundLayer is guaranteed to exist due to the pre-check in TaikoLegacySkinTransformer.
@@ -98,7 +96,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
             // Not all skins (including the default osu-stable) have similar sizes for "hitcircle" and "hitcircleoverlay".
             // This ensures they are scaled relative to each other but also match the expected DrawableHit size.
             foreach (var c in InternalChildren)
-                c.Scale = new Vector2(DrawHeight / circle_piece_size.Y);
+                c.Scale = new Vector2(DrawHeight / 128);
 
             if (foregroundLayer is IFramedAnimation animatableForegroundLayer)
                 animateForegroundLayer(animatableForegroundLayer);