Merge pull request #20045 from nekodex/textbox-invalid-sfx

Add audio feedback for invalid textbox input

.config/dotnet-tools.json

@@ -21,7 +21,7 @@
       ]
     },
     "ppy.localisationanalyser.tools": {
-      "version": "2022.607.0",
+      "version": "2022.809.0",
       "commands": [
         "localisation"
       ]

.globalconfig

@@ -53,3 +53,7 @@ dotnet_diagnostic.CA2225.severity = none
 
 # Banned APIs
 dotnet_diagnostic.RS0030.severity = error
+
+# Temporarily disable analysing CanBeNull = true in NRT contexts due to mobile issues.
+# See: https://github.com/ppy/osu/pull/19677
+dotnet_diagnostic.OSUF001.severity = none

Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform/EmptyFreeformRuleset.cs

@@ -77,5 +77,8 @@ namespace osu.Game.Rulesets.EmptyFreeform
                 };
             }
         }
+
+        // Leave this line intact. It will bake the correct version into the ruleset on each build/release.
+        public override string RulesetAPIVersionSupported => CURRENT_RULESET_API_VERSION;
     }
 }

Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon/PippidonRuleset.cs

@@ -49,5 +49,8 @@ namespace osu.Game.Rulesets.Pippidon
         };
 
         public override Drawable CreateIcon() => new PippidonRulesetIcon(this);
+
+        // Leave this line intact. It will bake the correct version into the ruleset on each build/release.
+        public override string RulesetAPIVersionSupported => CURRENT_RULESET_API_VERSION;
     }
 }

Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling/EmptyScrollingRuleset.cs

@@ -54,5 +54,8 @@ namespace osu.Game.Rulesets.EmptyScrolling
             Text = ShortName[0].ToString(),
             Font = OsuFont.Default.With(size: 18),
         };
+
+        // Leave this line intact. It will bake the correct version into the ruleset on each build/release.
+        public override string RulesetAPIVersionSupported => CURRENT_RULESET_API_VERSION;
     }
 }

Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/Beatmaps/PippidonBeatmapConverter.cs

@@ -21,8 +21,11 @@ namespace osu.Game.Rulesets.Pippidon.Beatmaps
         public PippidonBeatmapConverter(IBeatmap beatmap, Ruleset ruleset)
             : base(beatmap, ruleset)
         {
-            minPosition = beatmap.HitObjects.Min(getUsablePosition);
-            maxPosition = beatmap.HitObjects.Max(getUsablePosition);
+            if (beatmap.HitObjects.Any())
+            {
+                minPosition = beatmap.HitObjects.Min(getUsablePosition);
+                maxPosition = beatmap.HitObjects.Max(getUsablePosition);
+            }
         }
 
         public override bool CanConvert() => Beatmap.HitObjects.All(h => h is IHasXPosition && h is IHasYPosition);

Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/PippidonRuleset.cs

@@ -46,5 +46,8 @@ namespace osu.Game.Rulesets.Pippidon
         };
 
         public override Drawable CreateIcon() => new PippidonRulesetIcon(this);
+
+        // Leave this line intact. It will bake the correct version into the ruleset on each build/release.
+        public override string RulesetAPIVersionSupported => CURRENT_RULESET_API_VERSION;
     }
 }

osu.Android.props

@@ -51,11 +51,11 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2022.810.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2022.810.2" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2022.831.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2022.825.0" />
   </ItemGroup>
   <ItemGroup Label="Transitive Dependencies">
     <!-- Realm needs to be directly referenced in all Xamarin projects, as it will not pull in its transitive dependencies otherwise. -->
-    <PackageReference Include="Realm" Version="10.14.0" />
+    <PackageReference Include="Realm" Version="10.15.1" />
   </ItemGroup>
 </Project>

osu.Desktop/Security/ElevatedPrivilegesChecker.cs

@@ -76,7 +76,7 @@ namespace osu.Desktop.Security
             private void load(OsuColour colours)
             {
                 Icon = FontAwesome.Solid.ShieldAlt;
-                IconBackground.Colour = colours.YellowDark;
+                IconContent.Colour = colours.YellowDark;
             }
         }
     }

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

@@ -70,10 +70,17 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
             [Cached]
             private readonly BindableBeatDivisor beatDivisor;
 
+            protected override Container<Drawable> Content { get; } = new Container { RelativeSizeAxes = Axes.Both };
+
             public EditorBeatmapDependencyContainer(IBeatmap beatmap, BindableBeatDivisor beatDivisor)
             {
-                editorClock = new EditorClock(beatmap, beatDivisor);
                 this.beatDivisor = beatDivisor;
+
+                InternalChildren = new Drawable[]
+                {
+                    editorClock = new EditorClock(beatmap, beatDivisor),
+                    Content,
+                };
             }
         }
     }

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -3,29 +3,30 @@
 
 #nullable disable
 
-using osu.Game.Beatmaps;
-using osu.Game.Graphics;
-using osu.Game.Rulesets.Catch.Mods;
-using osu.Game.Rulesets.Catch.UI;
-using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.UI;
+using System;
 using System.Collections.Generic;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
-using osu.Game.Rulesets.Catch.Replays;
-using osu.Game.Rulesets.Replays.Types;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Legacy;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Difficulty;
-using osu.Game.Rulesets.Catch.Scoring;
-using osu.Game.Rulesets.Difficulty;
-using osu.Game.Rulesets.Scoring;
-using System;
-using osu.Framework.Extensions.EnumExtensions;
 using osu.Game.Rulesets.Catch.Edit;
+using osu.Game.Rulesets.Catch.Mods;
+using osu.Game.Rulesets.Catch.Replays;
+using osu.Game.Rulesets.Catch.Scoring;
 using osu.Game.Rulesets.Catch.Skinning.Legacy;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Difficulty;
 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.UI;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Catch
@@ -42,6 +43,8 @@ namespace osu.Game.Rulesets.Catch
 
         public const string SHORT_NAME = "fruits";
 
+        public override string RulesetAPIVersionSupported => CURRENT_RULESET_API_VERSION;
+
         public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0) => new[]
         {
             new KeyBinding(InputKey.Z, CatchAction.MoveLeft),
@@ -162,7 +165,7 @@ namespace osu.Game.Rulesets.Catch
             };
         }
 
-        public override string GetDisplayNameForHitResult(HitResult result)
+        public override LocalisableString GetDisplayNameForHitResult(HitResult result)
         {
             switch (result)
             {

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

@@ -1,12 +1,13 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Localisation;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Catch.Mods
 {
     public class CatchModEasy : ModEasyWithExtraLives
     {
-        public override string Description => @"Larger fruits, more forgiving HP drain, less accuracy required, and three lives!";
+        public override LocalisableString Description => @"Larger fruits, more forgiving HP drain, less accuracy required, and three lives!";
     }
 }

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

@@ -3,6 +3,7 @@
 
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
@@ -14,7 +15,7 @@ namespace osu.Game.Rulesets.Catch.Mods
     {
         public override string Name => "Floating Fruits";
         public override string Acronym => "FF";
-        public override string Description => "The fruits are... floating?";
+        public override LocalisableString Description => "The fruits are... floating?";
         public override double ScoreMultiplier => 1;
         public override IconUsage? Icon => FontAwesome.Solid.Cloud;
 

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

@@ -3,6 +3,7 @@
 
 using System.Linq;
 using osu.Framework.Graphics;
+using osu.Framework.Localisation;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.UI;
@@ -14,7 +15,7 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
     public class CatchModHidden : ModHidden, IApplicableToDrawableRuleset<CatchHitObject>
     {
-        public override string Description => @"Play with fading fruits.";
+        public override LocalisableString Description => @"Play with fading fruits.";
         public override double ScoreMultiplier => UsesDefaultConfiguration ? 1.06 : 1;
 
         private const double fade_out_offset_multiplier = 0.6;

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Linq;
+using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
@@ -14,7 +15,7 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
     public class CatchModMirror : ModMirror, IApplicableToBeatmap
     {
-        public override string Description => "Fruits are flipped horizontally.";
+        public override LocalisableString Description => "Fruits are flipped horizontally.";
 
         /// <remarks>
         /// <see cref="IApplicableToBeatmap"/> is used instead of <see cref="IApplicableToHitObject"/>,

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

@@ -3,6 +3,7 @@
 
 using System;
 using osu.Framework.Bindables;
+using osu.Framework.Localisation;
 using osu.Game.Rulesets.Mods;
 using osu.Framework.Utils;
 using osu.Game.Configuration;
@@ -14,7 +15,7 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
     public class CatchModNoScope : ModNoScope, IUpdatableByPlayfield
     {
-        public override string Description => "Where's the catcher?";
+        public override LocalisableString Description => "Where's the catcher?";
 
         [SettingSource(
             "Hidden at combo",

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

@@ -5,6 +5,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Mods;
@@ -16,7 +17,7 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
     public class CatchModRelax : ModRelax, IApplicableToDrawableRuleset<CatchHitObject>, IApplicableToPlayer
     {
-        public override string Description => @"Use the mouse to control the catcher.";
+        public override LocalisableString Description => @"Use the mouse to control the catcher.";
 
         private DrawableRuleset<CatchHitObject> drawableRuleset = null!;
 

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaComposeScreen.cs

@@ -10,6 +10,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Database;
 using osu.Game.Overlays;
 using osu.Game.Rulesets.Edit;
@@ -34,10 +35,14 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
         {
             AddStep("setup compose screen", () =>
             {
-                var editorBeatmap = new EditorBeatmap(new ManiaBeatmap(new StageDefinition { Columns = 4 })
+                var beatmap = new ManiaBeatmap(new StageDefinition { Columns = 4 })
                 {
                     BeatmapInfo = { Ruleset = new ManiaRuleset().RulesetInfo },
-                });
+                };
+
+                beatmap.ControlPointInfo.Add(0, new TimingControlPoint());
+
+                var editorBeatmap = new EditorBeatmap(beatmap, new LegacyBeatmapSkin(beatmap.BeatmapInfo, null));
 
                 Beatmap.Value = CreateWorkingBeatmap(editorBeatmap.PlayableBeatmap);
 
@@ -50,7 +55,11 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
                         (typeof(IBeatSnapProvider), editorBeatmap),
                         (typeof(OverlayColourProvider), new OverlayColourProvider(OverlayColourScheme.Green)),
                     },
-                    Child = new ComposeScreen { State = { Value = Visibility.Visible } },
+                    Children = new Drawable[]
+                    {
+                        editorBeatmap,
+                        new ComposeScreen { State = { Value = Visibility.Visible } },
+                    }
                 };
             });
 

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaHitObjectComposer.cs

@@ -35,7 +35,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
         public void Setup() => Schedule(() =>
         {
             BeatDivisor.Value = 8;
-            Clock.Seek(0);
+            EditorClock.Seek(0);
 
             Child = composer = new TestComposer { RelativeSizeAxes = Axes.Both };
         });
@@ -53,7 +53,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
             {
                 lastObject = this.ChildrenOfType<DrawableHitObject>().Single(d => d.HitObject == composer.EditorBeatmap.HitObjects.Last());
                 originalTime = lastObject.HitObject.StartTime;
-                Clock.Seek(composer.EditorBeatmap.HitObjects.Last().StartTime);
+                EditorClock.Seek(composer.EditorBeatmap.HitObjects.Last().StartTime);
             });
 
             AddStep("select all objects", () => composer.EditorBeatmap.SelectedHitObjects.AddRange(composer.EditorBeatmap.HitObjects));
@@ -90,7 +90,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
             {
                 lastObject = this.ChildrenOfType<DrawableHitObject>().Single(d => d.HitObject == composer.EditorBeatmap.HitObjects.Last());
                 originalTime = lastObject.HitObject.StartTime;
-                Clock.Seek(composer.EditorBeatmap.HitObjects.Last().StartTime);
+                EditorClock.Seek(composer.EditorBeatmap.HitObjects.Last().StartTime);
             });
 
             AddStep("select all objects", () => composer.EditorBeatmap.SelectedHitObjects.AddRange(composer.EditorBeatmap.HitObjects));
@@ -125,7 +125,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
             AddStep("seek to last object", () =>
             {
                 lastObject = this.ChildrenOfType<DrawableHitObject>().Single(d => d.HitObject == composer.EditorBeatmap.HitObjects.Last());
-                Clock.Seek(composer.EditorBeatmap.HitObjects.Last().StartTime);
+                EditorClock.Seek(composer.EditorBeatmap.HitObjects.Last().StartTime);
             });
 
             AddStep("select all objects", () => composer.EditorBeatmap.SelectedHitObjects.AddRange(composer.EditorBeatmap.HitObjects));

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

@@ -16,11 +16,11 @@ namespace osu.Game.Rulesets.Mania.Tests
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Mania";
 
-        [TestCase(2.3449735700206298d, 242, "diffcalc-test")]
+        [TestCase(2.3493769750220914d, 242, "diffcalc-test")]
         public void Test(double expectedStarRating, int expectedMaxCombo, string name)
             => base.Test(expectedStarRating, expectedMaxCombo, name);
 
-        [TestCase(2.7879104989252959d, 242, "diffcalc-test")]
+        [TestCase(2.797245912537965d, 242, "diffcalc-test")]
         public void TestClockRateAdjusted(double expectedStarRating, int expectedMaxCombo, string name)
             => Test(expectedStarRating, expectedMaxCombo, name, new ManiaModDoubleTime());
 

osu.Game.Rulesets.Mania/Difficulty/Skills/Strain.cs

@@ -21,7 +21,8 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Skills
         protected override double SkillMultiplier => 1;
         protected override double StrainDecayBase => 1;
 
-        private readonly double[] holdEndTimes;
+        private readonly double[] startTimes;
+        private readonly double[] endTimes;
         private readonly double[] individualStrains;
 
         private double individualStrain;
@@ -30,7 +31,8 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Skills
         public Strain(Mod[] mods, int totalColumns)
             : base(mods)
         {
-            holdEndTimes = new double[totalColumns];
+            startTimes = new double[totalColumns];
+            endTimes = new double[totalColumns];
             individualStrains = new double[totalColumns];
             overallStrain = 1;
         }
@@ -38,32 +40,27 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Skills
         protected override double StrainValueOf(DifficultyHitObject current)
         {
             var maniaCurrent = (ManiaDifficultyHitObject)current;
+            double startTime = maniaCurrent.StartTime;
             double endTime = maniaCurrent.EndTime;
             int column = maniaCurrent.BaseObject.Column;
-            double closestEndTime = Math.Abs(endTime - maniaCurrent.LastObject.StartTime); // Lowest value we can assume with the current information
-
-            double holdFactor = 1.0; // Factor to all additional strains in case something else is held
-            double holdAddition = 0; // Addition to the current note in case it's a hold and has to be released awkwardly
             bool isOverlapping = false;
 
-            // Fill up the holdEndTimes array
-            for (int i = 0; i < holdEndTimes.Length; ++i)
+            double closestEndTime = Math.Abs(endTime - startTime); // Lowest value we can assume with the current information
+            double holdFactor = 1.0; // Factor to all additional strains in case something else is held
+            double holdAddition = 0; // Addition to the current note in case it's a hold and has to be released awkwardly
+
+            for (int i = 0; i < endTimes.Length; ++i)
             {
                 // The current note is overlapped if a previous note or end is overlapping the current note body
-                isOverlapping |= Precision.DefinitelyBigger(holdEndTimes[i], maniaCurrent.StartTime, 1) && Precision.DefinitelyBigger(endTime, holdEndTimes[i], 1);
+                isOverlapping |= Precision.DefinitelyBigger(endTimes[i], startTime, 1) && Precision.DefinitelyBigger(endTime, endTimes[i], 1);
 
                 // We give a slight bonus to everything if something is held meanwhile
-                if (Precision.DefinitelyBigger(holdEndTimes[i], endTime, 1))
+                if (Precision.DefinitelyBigger(endTimes[i], endTime, 1))
                     holdFactor = 1.25;
 
-                closestEndTime = Math.Min(closestEndTime, Math.Abs(endTime - holdEndTimes[i]));
-
-                // Decay individual strains
-                individualStrains[i] = applyDecay(individualStrains[i], current.DeltaTime, individual_decay_base);
+                closestEndTime = Math.Min(closestEndTime, Math.Abs(endTime - endTimes[i]));
             }
 
-            holdEndTimes[column] = endTime;
-
             // The hold addition is given if there was an overlap, however it is only valid if there are no other note with a similar ending.
             // Releasing multiple notes is just as easy as releasing 1. Nerfs the hold addition by half if the closest release is release_threshold away.
             // holdAddition
@@ -77,12 +74,22 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Skills
             if (isOverlapping)
                 holdAddition = 1 / (1 + Math.Exp(0.5 * (release_threshold - closestEndTime)));
 
-            // Increase individual strain in own column
+            // Decay and increase individualStrains in own column
+            individualStrains[column] = applyDecay(individualStrains[column], startTime - startTimes[column], individual_decay_base);
             individualStrains[column] += 2.0 * holdFactor;
-            individualStrain = individualStrains[column];
 
-            overallStrain = applyDecay(overallStrain, current.DeltaTime, overall_decay_base) + (1 + holdAddition) * holdFactor;
+            // For notes at the same time (in a chord), the individualStrain should be the hardest individualStrain out of those columns
+            individualStrain = maniaCurrent.DeltaTime <= 1 ? Math.Max(individualStrain, individualStrains[column]) : individualStrains[column];
 
+            // Decay and increase overallStrain
+            overallStrain = applyDecay(overallStrain, current.DeltaTime, overall_decay_base);
+            overallStrain += (1 + holdAddition) * holdFactor;
+
+            // Update startTimes and endTimes arrays
+            startTimes[column] = startTime;
+            endTimes[column] = endTime;
+
+            // By subtracting CurrentStrain, this skill effectively only considers the maximum strain of any one hitobject within each strain section.
             return individualStrain + overallStrain - CurrentStrain;
         }
 

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

@@ -43,6 +43,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Setup
         private void updateBeatmap()
         {
             Beatmap.BeatmapInfo.SpecialStyle = specialStyle.Current.Value;
+            Beatmap.SaveState();
         }
     }
 }

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -4,22 +4,17 @@
 #nullable disable
 
 using System;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Mania.Mods;
-using osu.Game.Rulesets.Mania.UI;
-using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.UI;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
-using osu.Game.Graphics;
-using osu.Game.Rulesets.Mania.Replays;
-using osu.Game.Rulesets.Replays.Types;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Difficulty;
@@ -30,13 +25,19 @@ using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.Difficulty;
 using osu.Game.Rulesets.Mania.Edit;
 using osu.Game.Rulesets.Mania.Edit.Setup;
+using osu.Game.Rulesets.Mania.Mods;
+using osu.Game.Rulesets.Mania.Replays;
 using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mania.Skinning.Legacy;
+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.Skinning;
+using osu.Game.Rulesets.UI;
 using osu.Game.Scoring;
 using osu.Game.Screens.Edit.Setup;
 using osu.Game.Screens.Ranking.Statistics;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Mania
 {
@@ -59,6 +60,8 @@ namespace osu.Game.Rulesets.Mania
 
         public const string SHORT_NAME = "mania";
 
+        public override string RulesetAPIVersionSupported => CURRENT_RULESET_API_VERSION;
+
         public override HitObjectComposer CreateHitObjectComposer() => new ManiaHitObjectComposer(this);
 
         public override ISkin CreateLegacySkinProvider(ISkin skin, IBeatmap beatmap) => new ManiaLegacySkinTransformer(skin, beatmap);
@@ -311,7 +314,7 @@ namespace osu.Game.Rulesets.Mania
             return Array.Empty<KeyBinding>();
         }
 
-        public override string GetVariantName(int variant)
+        public override LocalisableString GetVariantName(int variant)
         {
             switch (getPlayfieldType(variant))
             {
@@ -356,7 +359,7 @@ namespace osu.Game.Rulesets.Mania
             };
         }
 
-        public override string GetDisplayNameForHitResult(HitResult result)
+        public override LocalisableString GetDisplayNameForHitResult(HitResult result)
         {
             switch (result)
             {

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.UI;
@@ -16,9 +17,9 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override string Acronym => "CS";
 
-        public override double ScoreMultiplier => 1;
+        public override double ScoreMultiplier => 0.9;
 
-        public override string Description => "No more tricky speed changes!";
+        public override LocalisableString Description => "No more tricky speed changes!";
 
         public override IconUsage? Icon => FontAwesome.Solid.Equals;
 

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

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mods;
@@ -11,7 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
     {
         public override string Name => "Dual Stages";
         public override string Acronym => "DS";
-        public override string Description => @"Double the stages, double the fun!";
+        public override LocalisableString Description => @"Double the stages, double the fun!";
         public override ModType Type => ModType.Conversion;
         public override double ScoreMultiplier => 1;
 

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

@@ -1,12 +1,13 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Localisation;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModEasy : ModEasyWithExtraLives
     {
-        public override string Description => @"More forgiving HP drain, less accuracy required, and three lives!";
+        public override LocalisableString Description => @"More forgiving HP drain, less accuracy required, and three lives!";
     }
 }

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

@@ -3,6 +3,7 @@
 
 using System;
 using System.Linq;
+using osu.Framework.Localisation;
 using osu.Game.Rulesets.Mania.UI;
 
 namespace osu.Game.Rulesets.Mania.Mods
@@ -11,7 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
     {
         public override string Name => "Fade In";
         public override string Acronym => "FI";
-        public override string Description => @"Keys appear out of nowhere!";
+        public override LocalisableString Description => @"Keys appear out of nowhere!";
         public override double ScoreMultiplier => 1;
 
         public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(ManiaModHidden)).ToArray();

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

@@ -3,13 +3,14 @@
 
 using System;
 using System.Linq;
+using osu.Framework.Localisation;
 using osu.Game.Rulesets.Mania.UI;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModHidden : ManiaModPlayfieldCover
     {
-        public override string Description => @"Keys fade out before you hit them!";
+        public override LocalisableString Description => @"Keys fade out before you hit them!";
         public override double ScoreMultiplier => 1;
 
         public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(ManiaModFadeIn)).ToArray();

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

@@ -8,6 +8,7 @@ using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;
 using osu.Framework.Graphics.Sprites;
 using System.Collections.Generic;
+using osu.Framework.Localisation;
 using osu.Game.Rulesets.Mania.Beatmaps;
 
 namespace osu.Game.Rulesets.Mania.Mods
@@ -20,7 +21,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override double ScoreMultiplier => 1;
 
-        public override string Description => @"Replaces all hold notes with normal notes.";
+        public override LocalisableString Description => @"Replaces all hold notes with normal notes.";
 
         public override IconUsage? Icon => FontAwesome.Solid.DotCircle;
 

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

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Beatmaps;
@@ -20,7 +21,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override string Acronym => "IN";
         public override double ScoreMultiplier => 1;
 
-        public override string Description => "Hold the keys. To the beat.";
+        public override LocalisableString Description => "Hold the keys. To the beat.";
 
         public override IconUsage? Icon => FontAwesome.Solid.YinYang;
 

osu.Game.Rulesets.Mania/Mods/ManiaModKey1.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.
 
+using osu.Framework.Localisation;
+
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModKey1 : ManiaKeyMod
@@ -8,6 +10,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 1;
         public override string Name => "One Key";
         public override string Acronym => "1K";
-        public override string Description => @"Play with one key.";
+        public override LocalisableString Description => @"Play with one key.";
     }
 }

osu.Game.Rulesets.Mania/Mods/ManiaModKey10.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.
 
+using osu.Framework.Localisation;
+
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModKey10 : ManiaKeyMod
@@ -8,6 +10,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 10;
         public override string Name => "Ten Keys";
         public override string Acronym => "10K";
-        public override string Description => @"Play with ten keys.";
+        public override LocalisableString Description => @"Play with ten keys.";
     }
 }

osu.Game.Rulesets.Mania/Mods/ManiaModKey2.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.
 
+using osu.Framework.Localisation;
+
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModKey2 : ManiaKeyMod
@@ -8,6 +10,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 2;
         public override string Name => "Two Keys";
         public override string Acronym => "2K";
-        public override string Description => @"Play with two keys.";
+        public override LocalisableString Description => @"Play with two keys.";
     }
 }

osu.Game.Rulesets.Mania/Mods/ManiaModKey3.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.
 
+using osu.Framework.Localisation;
+
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModKey3 : ManiaKeyMod
@@ -8,6 +10,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 3;
         public override string Name => "Three Keys";
         public override string Acronym => "3K";
-        public override string Description => @"Play with three keys.";
+        public override LocalisableString Description => @"Play with three keys.";
     }
 }

osu.Game.Rulesets.Mania/Mods/ManiaModKey4.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.
 
+using osu.Framework.Localisation;
+
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModKey4 : ManiaKeyMod
@@ -8,6 +10,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 4;
         public override string Name => "Four Keys";
         public override string Acronym => "4K";
-        public override string Description => @"Play with four keys.";
+        public override LocalisableString Description => @"Play with four keys.";
     }
 }

osu.Game.Rulesets.Mania/Mods/ManiaModKey5.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.
 
+using osu.Framework.Localisation;
+
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModKey5 : ManiaKeyMod
@@ -8,6 +10,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 5;
         public override string Name => "Five Keys";
         public override string Acronym => "5K";
-        public override string Description => @"Play with five keys.";
+        public override LocalisableString Description => @"Play with five keys.";
     }
 }

osu.Game.Rulesets.Mania/Mods/ManiaModKey6.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.
 
+using osu.Framework.Localisation;
+
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModKey6 : ManiaKeyMod
@@ -8,6 +10,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 6;
         public override string Name => "Six Keys";
         public override string Acronym => "6K";
-        public override string Description => @"Play with six keys.";
+        public override LocalisableString Description => @"Play with six keys.";
     }
 }

osu.Game.Rulesets.Mania/Mods/ManiaModKey7.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.
 
+using osu.Framework.Localisation;
+
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModKey7 : ManiaKeyMod
@@ -8,6 +10,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 7;
         public override string Name => "Seven Keys";
         public override string Acronym => "7K";
-        public override string Description => @"Play with seven keys.";
+        public override LocalisableString Description => @"Play with seven keys.";
     }
 }

osu.Game.Rulesets.Mania/Mods/ManiaModKey8.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.
 
+using osu.Framework.Localisation;
+
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModKey8 : ManiaKeyMod
@@ -8,6 +10,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 8;
         public override string Name => "Eight Keys";
         public override string Acronym => "8K";
-        public override string Description => @"Play with eight keys.";
+        public override LocalisableString Description => @"Play with eight keys.";
     }
 }

osu.Game.Rulesets.Mania/Mods/ManiaModKey9.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.
 
+using osu.Framework.Localisation;
+
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModKey9 : ManiaKeyMod
@@ -8,6 +10,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 9;
         public override string Name => "Nine Keys";
         public override string Acronym => "9K";
-        public override string Description => @"Play with nine keys.";
+        public override LocalisableString Description => @"Play with nine keys.";
     }
 }

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

@@ -5,6 +5,7 @@ using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;
 using System.Linq;
+using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Beatmaps;
 
@@ -12,7 +13,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModMirror : ModMirror, IApplicableToBeatmap
     {
-        public override string Description => "Notes are flipped horizontally.";
+        public override LocalisableString Description => "Notes are flipped horizontally.";
 
         public void ApplyToBeatmap(IBeatmap beatmap)
         {

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

@@ -4,6 +4,7 @@
 using System;
 using System.Linq;
 using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Localisation;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Beatmaps;
@@ -14,7 +15,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModRandom : ModRandom, IApplicableToBeatmap
     {
-        public override string Description => @"Shuffle around the keys!";
+        public override LocalisableString Description => @"Shuffle around the keys!";
 
         public void ApplyToBeatmap(IBeatmap beatmap)
         {

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

@@ -0,0 +1,272 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Edit;
+using osu.Game.Rulesets.Osu.Objects;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Osu.Tests.Editor
+{
+    public class TestSceneObjectMerging : TestSceneOsuEditor
+    {
+        private OsuSelectionHandler selectionHandler => Editor.ChildrenOfType<OsuSelectionHandler>().First();
+
+        [Test]
+        public void TestSimpleMerge()
+        {
+            HitCircle? circle1 = null;
+            HitCircle? circle2 = null;
+
+            AddStep("select first two circles", () =>
+            {
+                circle1 = (HitCircle)EditorBeatmap.HitObjects.First(h => h is HitCircle);
+                circle2 = (HitCircle)EditorBeatmap.HitObjects.First(h => h is HitCircle && h != circle1);
+                EditorClock.Seek(circle1.StartTime);
+                EditorBeatmap.SelectedHitObjects.Add(circle1);
+                EditorBeatmap.SelectedHitObjects.Add(circle2);
+            });
+
+            moveMouseToHitObject(1);
+            AddAssert("merge option available", () => selectionHandler.ContextMenuItems.Any(o => o.Text.Value == "Merge selection"));
+
+            mergeSelection();
+
+            AddAssert("slider created", () => circle1 is not null && circle2 is not null && sliderCreatedFor(
+                (pos: circle1.Position, pathType: PathType.Linear),
+                (pos: circle2.Position, pathType: null)));
+
+            AddStep("undo", () => Editor.Undo());
+            AddAssert("merged objects restored", () => circle1 is not null && circle2 is not null && objectsRestored(circle1, circle2));
+        }
+
+        [Test]
+        public void TestMergeCircleSlider()
+        {
+            HitCircle? circle1 = null;
+            Slider? slider = null;
+            HitCircle? circle2 = null;
+
+            AddStep("select a circle, slider, circle", () =>
+            {
+                circle1 = (HitCircle)EditorBeatmap.HitObjects.First(h => h is HitCircle);
+                slider = (Slider)EditorBeatmap.HitObjects.First(h => h is Slider && h.StartTime > circle1.StartTime);
+                circle2 = (HitCircle)EditorBeatmap.HitObjects.First(h => h is HitCircle && h.StartTime > slider.StartTime);
+                EditorClock.Seek(circle1.StartTime);
+                EditorBeatmap.SelectedHitObjects.Add(circle1);
+                EditorBeatmap.SelectedHitObjects.Add(slider);
+                EditorBeatmap.SelectedHitObjects.Add(circle2);
+            });
+
+            mergeSelection();
+
+            AddAssert("slider created", () =>
+            {
+                if (circle1 is null || circle2 is null || slider is null)
+                    return false;
+
+                var controlPoints = slider.Path.ControlPoints;
+                (Vector2, PathType?)[] args = new (Vector2, PathType?)[controlPoints.Count + 2];
+                args[0] = (circle1.Position, PathType.Linear);
+
+                for (int i = 0; i < controlPoints.Count; i++)
+                {
+                    args[i + 1] = (controlPoints[i].Position + slider.Position, i == controlPoints.Count - 1 ? PathType.Linear : controlPoints[i].Type);
+                }
+
+                args[^1] = (circle2.Position, null);
+                return sliderCreatedFor(args);
+            });
+
+            AddAssert("samples exist", sliderSampleExist);
+
+            AddStep("undo", () => Editor.Undo());
+            AddAssert("merged objects restored", () => circle1 is not null && circle2 is not null && slider is not null && objectsRestored(circle1, slider, circle2));
+        }
+
+        [Test]
+        public void TestMergeSliderSlider()
+        {
+            Slider? slider1 = null;
+            SliderPath? slider1Path = null;
+            Slider? slider2 = null;
+
+            AddStep("select two sliders", () =>
+            {
+                slider1 = (Slider)EditorBeatmap.HitObjects.First(h => h is Slider);
+                slider1Path = new SliderPath(slider1.Path.ControlPoints.Select(p => new PathControlPoint(p.Position, p.Type)).ToArray(), slider1.Path.ExpectedDistance.Value);
+                slider2 = (Slider)EditorBeatmap.HitObjects.First(h => h is Slider && h.StartTime > slider1.StartTime);
+                EditorClock.Seek(slider1.StartTime);
+                EditorBeatmap.SelectedHitObjects.Add(slider1);
+                EditorBeatmap.SelectedHitObjects.Add(slider2);
+            });
+
+            mergeSelection();
+
+            AddAssert("slider created", () =>
+            {
+                if (slider1 is null || slider2 is null || slider1Path is null)
+                    return false;
+
+                var controlPoints1 = slider1Path.ControlPoints;
+                var controlPoints2 = slider2.Path.ControlPoints;
+                (Vector2, PathType?)[] args = new (Vector2, PathType?)[controlPoints1.Count + controlPoints2.Count - 1];
+
+                for (int i = 0; i < controlPoints1.Count - 1; i++)
+                {
+                    args[i] = (controlPoints1[i].Position + slider1.Position, controlPoints1[i].Type);
+                }
+
+                for (int i = 0; i < controlPoints2.Count; i++)
+                {
+                    args[i + controlPoints1.Count - 1] = (controlPoints2[i].Position + controlPoints1[^1].Position + slider1.Position, controlPoints2[i].Type);
+                }
+
+                return sliderCreatedFor(args);
+            });
+
+            AddAssert("samples exist", sliderSampleExist);
+
+            AddAssert("merged slider matches first slider", () =>
+            {
+                var mergedSlider = (Slider)EditorBeatmap.SelectedHitObjects.First();
+                return slider1 is not null && mergedSlider.HeadCircle.Samples.SequenceEqual(slider1.HeadCircle.Samples)
+                                           && mergedSlider.TailCircle.Samples.SequenceEqual(slider1.TailCircle.Samples)
+                                           && mergedSlider.Samples.SequenceEqual(slider1.Samples)
+                                           && mergedSlider.SampleControlPoint.IsRedundant(slider1.SampleControlPoint);
+            });
+
+            AddAssert("slider end is at same completion for last slider", () =>
+            {
+                if (slider1Path is null || slider2 is null)
+                    return false;
+
+                var mergedSlider = (Slider)EditorBeatmap.SelectedHitObjects.First();
+                return Precision.AlmostEquals(mergedSlider.Path.Distance, slider1Path.CalculatedDistance + slider2.Path.Distance);
+            });
+        }
+
+        [Test]
+        public void TestNonMerge()
+        {
+            HitCircle? circle1 = null;
+            HitCircle? circle2 = null;
+            Spinner? spinner = null;
+
+            AddStep("select first two circles and spinner", () =>
+            {
+                circle1 = (HitCircle)EditorBeatmap.HitObjects.First(h => h is HitCircle);
+                circle2 = (HitCircle)EditorBeatmap.HitObjects.First(h => h is HitCircle && h != circle1);
+                spinner = (Spinner)EditorBeatmap.HitObjects.First(h => h is Spinner);
+                EditorClock.Seek(spinner.StartTime);
+                EditorBeatmap.SelectedHitObjects.Add(circle1);
+                EditorBeatmap.SelectedHitObjects.Add(circle2);
+                EditorBeatmap.SelectedHitObjects.Add(spinner);
+            });
+
+            mergeSelection();
+
+            AddAssert("slider created", () => circle1 is not null && circle2 is not null && sliderCreatedFor(
+                (pos: circle1.Position, pathType: PathType.Linear),
+                (pos: circle2.Position, pathType: null)));
+
+            AddAssert("samples exist", sliderSampleExist);
+
+            AddAssert("spinner not merged", () => EditorBeatmap.HitObjects.Contains(spinner));
+        }
+
+        [Test]
+        public void TestIllegalMerge()
+        {
+            HitCircle? circle1 = null;
+            HitCircle? circle2 = null;
+
+            AddStep("add two circles on the same position", () =>
+            {
+                circle1 = new HitCircle();
+                circle2 = new HitCircle { Position = circle1.Position + Vector2.UnitX, StartTime = 1 };
+                EditorClock.Seek(0);
+                EditorBeatmap.Add(circle1);
+                EditorBeatmap.Add(circle2);
+                EditorBeatmap.SelectedHitObjects.Add(circle1);
+                EditorBeatmap.SelectedHitObjects.Add(circle2);
+            });
+
+            moveMouseToHitObject(1);
+            AddAssert("merge option not available", () => selectionHandler.ContextMenuItems.Length > 0 && selectionHandler.ContextMenuItems.All(o => o.Text.Value != "Merge selection"));
+            mergeSelection();
+            AddAssert("circles not merged", () => circle1 is not null && circle2 is not null
+                                                                      && EditorBeatmap.HitObjects.Contains(circle1) && EditorBeatmap.HitObjects.Contains(circle2));
+        }
+
+        private void mergeSelection()
+        {
+            AddStep("merge selection", () =>
+            {
+                InputManager.PressKey(Key.LControl);
+                InputManager.PressKey(Key.LShift);
+                InputManager.Key(Key.M);
+                InputManager.ReleaseKey(Key.LShift);
+                InputManager.ReleaseKey(Key.LControl);
+            });
+        }
+
+        private bool sliderCreatedFor(params (Vector2 pos, PathType? pathType)[] expectedControlPoints)
+        {
+            if (EditorBeatmap.SelectedHitObjects.Count != 1)
+                return false;
+
+            var mergedSlider = (Slider)EditorBeatmap.SelectedHitObjects.First();
+            int i = 0;
+
+            foreach ((Vector2 pos, PathType? pathType) in expectedControlPoints)
+            {
+                var controlPoint = mergedSlider.Path.ControlPoints[i++];
+
+                if (!Precision.AlmostEquals(controlPoint.Position + mergedSlider.Position, pos) || controlPoint.Type != pathType)
+                    return false;
+            }
+
+            return true;
+        }
+
+        private bool objectsRestored(params HitObject[] objects)
+        {
+            foreach (var hitObject in objects)
+            {
+                if (EditorBeatmap.HitObjects.Contains(hitObject))
+                    return false;
+            }
+
+            return true;
+        }
+
+        private bool sliderSampleExist()
+        {
+            if (EditorBeatmap.SelectedHitObjects.Count != 1)
+                return false;
+
+            var mergedSlider = (Slider)EditorBeatmap.SelectedHitObjects.First();
+
+            return mergedSlider.Samples[0] is not null;
+        }
+
+        private void moveMouseToHitObject(int index)
+        {
+            AddStep($"hover mouse over hit object {index}", () =>
+            {
+                if (EditorBeatmap.HitObjects.Count <= index)
+                    return;
+
+                Vector2 position = ((OsuHitObject)EditorBeatmap.HitObjects[index]).Position;
+                InputManager.MoveMouseTo(selectionHandler.ToScreenSpace(position));
+            });
+        }
+    }
+}

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

@@ -59,10 +59,9 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                 }
             });
 
-            editorClock = new EditorClock(editorBeatmap);
-
             base.Content.Children = new Drawable[]
             {
+                editorClock = new EditorClock(editorBeatmap),
                 snapProvider,
                 Content
             };

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

@@ -182,7 +182,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
         {
             AddStep($"click context menu item \"{contextMenuText}\"", () =>
             {
-                MenuItem item = visualiser.ContextMenuItems[1].Items.FirstOrDefault(menuItem => menuItem.Text.Value == contextMenuText);
+                MenuItem item = visualiser.ContextMenuItems.FirstOrDefault(menuItem => menuItem.Text.Value == "Curve type")?.Items.FirstOrDefault(menuItem => menuItem.Text.Value == contextMenuText);
 
                 item?.Action?.Value();
             });

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

@@ -12,6 +12,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Input.Bindings;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Edit;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
 using osu.Game.Rulesets.Osu.Objects;
@@ -55,9 +56,9 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                 {
                     ControlPoints =
                     {
-                        new PathControlPoint(Vector2.Zero),
-                        new PathControlPoint(OsuPlayfield.BASE_SIZE * 2 / 5),
-                        new PathControlPoint(OsuPlayfield.BASE_SIZE * 3 / 5)
+                        new PathControlPoint(Vector2.Zero, PathType.PerfectCurve),
+                        new PathControlPoint(new Vector2(136, 205)),
+                        new PathControlPoint(new Vector2(-4, 226))
                     }
                 }
             }));
@@ -99,8 +100,8 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             AddStep("move mouse to new point location", () =>
             {
                 var firstPiece = this.ChildrenOfType<PathControlPointPiece>().Single(piece => piece.ControlPoint == slider.Path.ControlPoints[0]);
-                var secondPiece = this.ChildrenOfType<PathControlPointPiece>().Single(piece => piece.ControlPoint == slider.Path.ControlPoints[1]);
-                InputManager.MoveMouseTo((firstPiece.ScreenSpaceDrawQuad.Centre + secondPiece.ScreenSpaceDrawQuad.Centre) / 2);
+                var pos = slider.Path.PositionAt(0.25d) + slider.Position;
+                InputManager.MoveMouseTo(firstPiece.Parent.ToScreenSpace(pos));
             });
             AddStep("move slider end", () =>
             {
@@ -175,6 +176,23 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             assertSliderSnapped(false);
         }
 
+        [Test]
+        public void TestRotatingSliderRetainsPerfectControlPointType()
+        {
+            OsuSelectionHandler selectionHandler;
+
+            AddAssert("first control point perfect", () => slider.Path.ControlPoints[0].Type == PathType.PerfectCurve);
+
+            AddStep("select slider", () => EditorBeatmap.SelectedHitObjects.Add(slider));
+            AddStep("rotate 90 degrees ccw", () =>
+            {
+                selectionHandler = this.ChildrenOfType<OsuSelectionHandler>().Single();
+                selectionHandler.HandleRotation(-90);
+            });
+
+            AddAssert("first control point still perfect", () => slider.Path.ControlPoints[0].Type == PathType.PerfectCurve);
+        }
+
         [Test]
         public void TestFlippingSliderDoesNotSnap()
         {
@@ -200,6 +218,23 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             assertSliderSnapped(false);
         }
 
+        [Test]
+        public void TestFlippingSliderRetainsPerfectControlPointType()
+        {
+            OsuSelectionHandler selectionHandler;
+
+            AddAssert("first control point perfect", () => slider.Path.ControlPoints[0].Type == PathType.PerfectCurve);
+
+            AddStep("select slider", () => EditorBeatmap.SelectedHitObjects.Add(slider));
+            AddStep("flip slider horizontally", () =>
+            {
+                selectionHandler = this.ChildrenOfType<OsuSelectionHandler>().Single();
+                selectionHandler.OnPressed(new KeyBindingPressEvent<GlobalAction>(InputManager.CurrentState, GlobalAction.EditorFlipVertically));
+            });
+
+            AddAssert("first control point still perfect", () => slider.Path.ControlPoints[0].Type == PathType.PerfectCurve);
+        }
+
         [Test]
         public void TestReversingSliderDoesNotSnap()
         {

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

@@ -0,0 +1,255 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Audio;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit.Compose.Components;
+using osu.Game.Tests.Beatmaps;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests.Editor
+{
+    public class TestSceneSliderSplitting : EditorTestScene
+    {
+        protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new TestBeatmap(ruleset, false);
+
+        private ComposeBlueprintContainer blueprintContainer
+            => Editor.ChildrenOfType<ComposeBlueprintContainer>().First();
+
+        private Slider? slider;
+        private PathControlPointVisualiser? visualiser;
+
+        private const double split_gap = 100;
+
+        [Test]
+        public void TestBasicSplit()
+        {
+            double endTime = 0;
+
+            AddStep("add slider", () =>
+            {
+                slider = new Slider
+                {
+                    Position = new Vector2(0, 50),
+                    Path = new SliderPath(new[]
+                    {
+                        new PathControlPoint(Vector2.Zero, PathType.PerfectCurve),
+                        new PathControlPoint(new Vector2(150, 150)),
+                        new PathControlPoint(new Vector2(300, 0), PathType.PerfectCurve),
+                        new PathControlPoint(new Vector2(400, 0)),
+                        new PathControlPoint(new Vector2(400, 150))
+                    })
+                };
+
+                EditorBeatmap.Add(slider);
+
+                endTime = slider.EndTime;
+            });
+
+            AddStep("select added slider", () =>
+            {
+                EditorBeatmap.SelectedHitObjects.Add(slider);
+                visualiser = blueprintContainer.SelectionBlueprints.First(o => o.Item == slider).ChildrenOfType<PathControlPointVisualiser>().First();
+            });
+
+            moveMouseToControlPoint(2);
+            AddStep("select control point", () =>
+            {
+                if (visualiser is not null) visualiser.Pieces[2].IsSelected.Value = true;
+            });
+            addContextMenuItemStep("Split control point");
+
+            AddAssert("slider split", () => slider is not null && EditorBeatmap.HitObjects.Count == 2 &&
+                                            sliderCreatedFor((Slider)EditorBeatmap.HitObjects[0], 0, EditorBeatmap.HitObjects[1].StartTime - split_gap,
+                                                (new Vector2(0, 50), PathType.PerfectCurve),
+                                                (new Vector2(150, 200), null),
+                                                (new Vector2(300, 50), null)
+                                            ) && sliderCreatedFor((Slider)EditorBeatmap.HitObjects[1], slider.StartTime, endTime + split_gap,
+                                                (new Vector2(300, 50), PathType.PerfectCurve),
+                                                (new Vector2(400, 50), null),
+                                                (new Vector2(400, 200), null)
+                                            ));
+
+            AddStep("undo", () => Editor.Undo());
+            AddAssert("original slider restored", () => EditorBeatmap.HitObjects.Count == 1 && sliderCreatedFor((Slider)EditorBeatmap.HitObjects[0], 0, endTime,
+                (new Vector2(0, 50), PathType.PerfectCurve),
+                (new Vector2(150, 200), null),
+                (new Vector2(300, 50), PathType.PerfectCurve),
+                (new Vector2(400, 50), null),
+                (new Vector2(400, 200), null)
+            ));
+        }
+
+        [Test]
+        public void TestDoubleSplit()
+        {
+            double endTime = 0;
+
+            AddStep("add slider", () =>
+            {
+                slider = new Slider
+                {
+                    Position = new Vector2(0, 50),
+                    Path = new SliderPath(new[]
+                    {
+                        new PathControlPoint(Vector2.Zero, PathType.PerfectCurve),
+                        new PathControlPoint(new Vector2(150, 150)),
+                        new PathControlPoint(new Vector2(300, 0), PathType.Bezier),
+                        new PathControlPoint(new Vector2(400, 0)),
+                        new PathControlPoint(new Vector2(400, 150), PathType.Catmull),
+                        new PathControlPoint(new Vector2(300, 200)),
+                        new PathControlPoint(new Vector2(400, 250))
+                    })
+                };
+
+                EditorBeatmap.Add(slider);
+
+                endTime = slider.EndTime;
+            });
+
+            AddStep("select added slider", () =>
+            {
+                EditorBeatmap.SelectedHitObjects.Add(slider);
+                visualiser = blueprintContainer.SelectionBlueprints.First(o => o.Item == slider).ChildrenOfType<PathControlPointVisualiser>().First();
+            });
+
+            moveMouseToControlPoint(2);
+            AddStep("select first control point", () =>
+            {
+                if (visualiser is not null) visualiser.Pieces[2].IsSelected.Value = true;
+            });
+            moveMouseToControlPoint(4);
+            AddStep("select second control point", () =>
+            {
+                if (visualiser is not null) visualiser.Pieces[4].IsSelected.Value = true;
+            });
+            addContextMenuItemStep("Split 2 control points");
+
+            AddAssert("slider split", () => slider is not null && EditorBeatmap.HitObjects.Count == 3 &&
+                                            sliderCreatedFor((Slider)EditorBeatmap.HitObjects[0], 0, EditorBeatmap.HitObjects[1].StartTime - split_gap,
+                                                (new Vector2(0, 50), PathType.PerfectCurve),
+                                                (new Vector2(150, 200), null),
+                                                (new Vector2(300, 50), null)
+                                            ) && sliderCreatedFor((Slider)EditorBeatmap.HitObjects[1], EditorBeatmap.HitObjects[0].GetEndTime() + split_gap, slider.StartTime - split_gap,
+                                                (new Vector2(300, 50), PathType.Bezier),
+                                                (new Vector2(400, 50), null),
+                                                (new Vector2(400, 200), null)
+                                            ) && sliderCreatedFor((Slider)EditorBeatmap.HitObjects[2], EditorBeatmap.HitObjects[1].GetEndTime() + split_gap, endTime + split_gap * 2,
+                                                (new Vector2(400, 200), PathType.Catmull),
+                                                (new Vector2(300, 250), null),
+                                                (new Vector2(400, 300), null)
+                                            ));
+        }
+
+        [Test]
+        public void TestSplitRetainsHitsounds()
+        {
+            HitSampleInfo? sample = null;
+
+            AddStep("add slider", () =>
+            {
+                slider = new Slider
+                {
+                    Position = new Vector2(0, 50),
+                    LegacyLastTickOffset = 36, // This is necessary for undo to retain the sample control point
+                    Path = new SliderPath(new[]
+                    {
+                        new PathControlPoint(Vector2.Zero, PathType.PerfectCurve),
+                        new PathControlPoint(new Vector2(150, 150)),
+                        new PathControlPoint(new Vector2(300, 0), PathType.PerfectCurve),
+                        new PathControlPoint(new Vector2(400, 0)),
+                        new PathControlPoint(new Vector2(400, 150))
+                    })
+                };
+
+                EditorBeatmap.Add(slider);
+            });
+
+            AddStep("add hitsounds", () =>
+            {
+                if (slider is null) return;
+
+                slider.SampleControlPoint.SampleBank = "soft";
+                slider.SampleControlPoint.SampleVolume = 70;
+                sample = new HitSampleInfo("hitwhistle");
+                slider.Samples.Add(sample);
+            });
+
+            AddStep("select added slider", () =>
+            {
+                EditorBeatmap.SelectedHitObjects.Add(slider);
+                visualiser = blueprintContainer.SelectionBlueprints.First(o => o.Item == slider).ChildrenOfType<PathControlPointVisualiser>().First();
+            });
+
+            moveMouseToControlPoint(2);
+            AddStep("select control point", () =>
+            {
+                if (visualiser is not null) visualiser.Pieces[2].IsSelected.Value = true;
+            });
+            addContextMenuItemStep("Split control point");
+            AddAssert("sliders have hitsounds", hasHitsounds);
+
+            AddStep("select first slider", () => EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects[0]));
+            AddStep("remove first slider", () => EditorBeatmap.RemoveAt(0));
+            AddStep("undo", () => Editor.Undo());
+            AddAssert("sliders have hitsounds", hasHitsounds);
+
+            bool hasHitsounds() => sample is not null &&
+                                   EditorBeatmap.HitObjects.All(o => o.SampleControlPoint.SampleBank == "soft" &&
+                                                                     o.SampleControlPoint.SampleVolume == 70 &&
+                                                                     o.Samples.Contains(sample));
+        }
+
+        private bool sliderCreatedFor(Slider s, double startTime, double endTime, params (Vector2 pos, PathType? pathType)[] expectedControlPoints)
+        {
+            if (!Precision.AlmostEquals(s.StartTime, startTime, 1) || !Precision.AlmostEquals(s.EndTime, endTime, 1)) return false;
+
+            int i = 0;
+
+            foreach ((Vector2 pos, PathType? pathType) in expectedControlPoints)
+            {
+                var controlPoint = s.Path.ControlPoints[i++];
+
+                if (!Precision.AlmostEquals(controlPoint.Position + s.Position, pos) || controlPoint.Type != pathType)
+                    return false;
+            }
+
+            return true;
+        }
+
+        private void moveMouseToControlPoint(int index)
+        {
+            AddStep($"move mouse to control point {index}", () =>
+            {
+                if (slider is null || visualiser is null) return;
+
+                Vector2 position = slider.Path.ControlPoints[index].Position + slider.Position;
+                InputManager.MoveMouseTo(visualiser.Pieces[0].Parent.ToScreenSpace(position));
+            });
+        }
+
+        private void addContextMenuItemStep(string contextMenuText)
+        {
+            AddStep($"click context menu item \"{contextMenuText}\"", () =>
+            {
+                if (visualiser is null) return;
+
+                MenuItem? item = visualiser.ContextMenuItems.FirstOrDefault(menuItem => menuItem.Text.Value == contextMenuText);
+
+                item?.Action?.Value();
+            });
+        }
+    }
+}

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

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
             {
                 Mod = mod,
                 PassCondition = () => Player.ScoreProcessor.JudgedHits >= 2 &&
-                                      Precision.AlmostEquals(Player.GameplayClockContainer.GameplayClock.Rate, mod.SpeedChange.Value)
+                                      Precision.AlmostEquals(Player.GameplayClockContainer.Rate, mod.SpeedChange.Value)
             });
         }
     }

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

@@ -17,18 +17,18 @@ namespace osu.Game.Rulesets.Osu.Tests
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Osu";
 
-        [TestCase(6.6369583000323935d, 206, "diffcalc-test")]
-        [TestCase(1.4476531024675374d, 45, "zero-length-sliders")]
+        [TestCase(6.7115569159190587d, 206, "diffcalc-test")]
+        [TestCase(1.4391311903612753d, 45, "zero-length-sliders")]
         public void Test(double expectedStarRating, int expectedMaxCombo, string name)
             => base.Test(expectedStarRating, expectedMaxCombo, name);
 
-        [TestCase(8.8816128335486386d, 206, "diffcalc-test")]
-        [TestCase(1.7540389962596916d, 45, "zero-length-sliders")]
+        [TestCase(8.9757300665532966d, 206, "diffcalc-test")]
+        [TestCase(1.7437232654020756d, 45, "zero-length-sliders")]
         public void TestClockRateAdjusted(double expectedStarRating, int expectedMaxCombo, string name)
             => Test(expectedStarRating, expectedMaxCombo, name, new OsuModDoubleTime());
 
-        [TestCase(6.6369583000323935d, 239, "diffcalc-test")]
-        [TestCase(1.4476531024675374d, 54, "zero-length-sliders")]
+        [TestCase(6.7115569159190587d, 239, "diffcalc-test")]
+        [TestCase(1.4391311903612753d, 54, "zero-length-sliders")]
         public void TestClassicMod(double expectedStarRating, int expectedMaxCombo, string name)
             => Test(expectedStarRating, expectedMaxCombo, name, new OsuModClassic());
 

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -12,7 +10,6 @@ using osu.Framework.Audio;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Testing;
 using osu.Framework.Timing;
-using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Objects;
@@ -36,16 +33,16 @@ namespace osu.Game.Rulesets.Osu.Tests
         private const double spinner_duration = 6000;
 
         [Resolved]
-        private AudioManager audioManager { get; set; }
+        private AudioManager audioManager { get; set; } = null!;
 
         protected override bool Autoplay => true;
 
         protected override TestPlayer CreatePlayer(Ruleset ruleset) => new ScoreExposedPlayer();
 
-        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null)
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard? storyboard = null)
             => new ClockBackedTestWorkingBeatmap(beatmap, storyboard, new FramedClock(new ManualClock { Rate = 1 }), audioManager);
 
-        private DrawableSpinner drawableSpinner;
+        private DrawableSpinner drawableSpinner = null!;
         private SpriteIcon spinnerSymbol => drawableSpinner.ChildrenOfType<SpriteIcon>().Single();
 
         [SetUpSteps]
@@ -67,12 +64,12 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
                 trackerRotationTolerance = Math.Abs(drawableSpinner.RotationTracker.Rotation * 0.1f);
             });
-            AddAssert("is disc rotation not almost 0", () => !Precision.AlmostEquals(drawableSpinner.RotationTracker.Rotation, 0, 100));
-            AddAssert("is disc rotation absolute not almost 0", () => !Precision.AlmostEquals(drawableSpinner.Result.RateAdjustedRotation, 0, 100));
+            AddAssert("is disc rotation not almost 0", () => drawableSpinner.RotationTracker.Rotation, () => Is.Not.EqualTo(0).Within(100));
+            AddAssert("is disc rotation absolute not almost 0", () => drawableSpinner.Result.RateAdjustedRotation, () => Is.Not.EqualTo(0).Within(100));
 
             addSeekStep(0);
-            AddAssert("is disc rotation almost 0", () => Precision.AlmostEquals(drawableSpinner.RotationTracker.Rotation, 0, trackerRotationTolerance));
-            AddAssert("is disc rotation absolute almost 0", () => Precision.AlmostEquals(drawableSpinner.Result.RateAdjustedRotation, 0, 100));
+            AddAssert("is disc rotation almost 0", () => drawableSpinner.RotationTracker.Rotation, () => Is.EqualTo(0).Within(trackerRotationTolerance));
+            AddAssert("is disc rotation absolute almost 0", () => drawableSpinner.Result.RateAdjustedRotation, () => Is.EqualTo(0).Within(100));
         }
 
         [Test]
@@ -100,20 +97,20 @@ namespace osu.Game.Rulesets.Osu.Tests
                 // we want to make sure that the rotation at time 2500 is in the same direction as at time 5000, but about half-way in.
                 // due to the exponential damping applied we're allowing a larger margin of error of about 10%
                 // (5% relative to the final rotation value, but we're half-way through the spin).
-                () => Precision.AlmostEquals(drawableSpinner.RotationTracker.Rotation, finalTrackerRotation / 2, trackerRotationTolerance));
+                () => drawableSpinner.RotationTracker.Rotation, () => Is.EqualTo(finalTrackerRotation / 2).Within(trackerRotationTolerance));
             AddAssert("symbol rotation rewound",
-                () => Precision.AlmostEquals(spinnerSymbol.Rotation, finalSpinnerSymbolRotation / 2, spinnerSymbolRotationTolerance));
+                () => spinnerSymbol.Rotation, () => Is.EqualTo(finalSpinnerSymbolRotation / 2).Within(spinnerSymbolRotationTolerance));
             AddAssert("is cumulative rotation rewound",
                 // cumulative rotation is not damped, so we're treating it as the "ground truth" and allowing a comparatively smaller margin of error.
-                () => Precision.AlmostEquals(drawableSpinner.Result.RateAdjustedRotation, finalCumulativeTrackerRotation / 2, 100));
+                () => drawableSpinner.Result.RateAdjustedRotation, () => Is.EqualTo(finalCumulativeTrackerRotation / 2).Within(100));
 
             addSeekStep(spinner_start_time + 5000);
             AddAssert("is disc rotation almost same",
-                () => Precision.AlmostEquals(drawableSpinner.RotationTracker.Rotation, finalTrackerRotation, trackerRotationTolerance));
+                () => drawableSpinner.RotationTracker.Rotation, () => Is.EqualTo(finalTrackerRotation).Within(trackerRotationTolerance));
             AddAssert("is symbol rotation almost same",
-                () => Precision.AlmostEquals(spinnerSymbol.Rotation, finalSpinnerSymbolRotation, spinnerSymbolRotationTolerance));
+                () => spinnerSymbol.Rotation, () => Is.EqualTo(finalSpinnerSymbolRotation).Within(spinnerSymbolRotationTolerance));
             AddAssert("is cumulative rotation almost same",
-                () => Precision.AlmostEquals(drawableSpinner.Result.RateAdjustedRotation, finalCumulativeTrackerRotation, 100));
+                () => drawableSpinner.Result.RateAdjustedRotation, () => Is.EqualTo(finalCumulativeTrackerRotation).Within(100));
         }
 
         [Test]
@@ -177,10 +174,10 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddStep("retrieve spm", () => estimatedSpm = drawableSpinner.SpinsPerMinute.Value);
 
             addSeekStep(2000);
-            AddAssert("spm still valid", () => Precision.AlmostEquals(drawableSpinner.SpinsPerMinute.Value, estimatedSpm, 1.0));
+            AddAssert("spm still valid", () => drawableSpinner.SpinsPerMinute.Value, () => Is.EqualTo(estimatedSpm).Within(1.0));
 
             addSeekStep(1000);
-            AddAssert("spm still valid", () => Precision.AlmostEquals(drawableSpinner.SpinsPerMinute.Value, estimatedSpm, 1.0));
+            AddAssert("spm still valid", () => drawableSpinner.SpinsPerMinute.Value, () => Is.EqualTo(estimatedSpm).Within(1.0));
         }
 
         [TestCase(0.5)]
@@ -202,14 +199,14 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddStep("adjust track rate", () => ((MasterGameplayClockContainer)Player.GameplayClockContainer).UserPlaybackRate.Value = rate);
 
             addSeekStep(1000);
-            AddAssert("progress almost same", () => Precision.AlmostEquals(expectedProgress, drawableSpinner.Progress, 0.05));
-            AddAssert("spm almost same", () => Precision.AlmostEquals(expectedSpm, drawableSpinner.SpinsPerMinute.Value, 2.0));
+            AddAssert("progress almost same", () => drawableSpinner.Progress, () => Is.EqualTo(expectedProgress).Within(0.05));
+            AddAssert("spm almost same", () => drawableSpinner.SpinsPerMinute.Value, () => Is.EqualTo(expectedSpm).Within(2.0));
         }
 
         private void addSeekStep(double time)
         {
             AddStep($"seek to {time}", () => Player.GameplayClockContainer.Seek(time));
-            AddUntilStep("wait for seek to finish", () => Precision.AlmostEquals(time, Player.DrawableRuleset.FrameStableClock.CurrentTime, 100));
+            AddUntilStep("wait for seek to finish", () => Player.DrawableRuleset.FrameStableClock.CurrentTime, () => Is.EqualTo(time).Within(100));
         }
 
         private void transformReplay(Func<Replay, Replay> replayTransformation) => AddStep("set replay", () =>

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

@@ -2,7 +2,7 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
-    <PackageReference Include="Moq" Version="4.18.1" />
+    <PackageReference Include="Moq" Version="4.18.2" />
     <PackageReference Include="NUnit" Version="3.13.3" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

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

@@ -13,8 +13,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
     public static class AimEvaluator
     {
         private const double wide_angle_multiplier = 1.5;
-        private const double acute_angle_multiplier = 2.0;
-        private const double slider_multiplier = 1.5;
+        private const double acute_angle_multiplier = 1.95;
+        private const double slider_multiplier = 1.35;
         private const double velocity_change_multiplier = 0.75;
 
         /// <summary>
@@ -114,7 +114,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
                 velocityChangeBonus *= Math.Pow(Math.Min(osuCurrObj.StrainTime, osuLastObj.StrainTime) / Math.Max(osuCurrObj.StrainTime, osuLastObj.StrainTime), 2);
             }
 
-            if (osuLastObj.TravelTime != 0)
+            if (osuLastObj.BaseObject is Slider)
             {
                 // Reward sliders based on velocity.
                 sliderBonus = osuLastObj.TravelDistance / osuLastObj.TravelTime;

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

@@ -15,11 +15,18 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
         private const double max_opacity_bonus = 0.4;
         private const double hidden_bonus = 0.2;
 
+        private const double min_velocity = 0.5;
+        private const double slider_multiplier = 1.3;
+
+        private const double min_angle_multiplier = 0.2;
+
         /// <summary>
         /// Evaluates the difficulty of memorising and hitting an object, based on:
         /// <list type="bullet">
-        /// <item><description>distance between the previous and current object,</description></item>
+        /// <item><description>distance between a number of previous objects and the current object,</description></item>
         /// <item><description>the visual opacity of the current object,</description></item>
+        /// <item><description>the angle made by the current object,</description></item>
+        /// <item><description>length and speed of the current object (for sliders),</description></item>
         /// <item><description>and whether the hidden mod is enabled.</description></item>
         /// </list>
         /// </summary>
@@ -39,6 +46,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
 
             OsuDifficultyHitObject lastObj = osuCurrent;
 
+            double angleRepeatCount = 0.0;
+
             // This is iterating backwards in time from the current object.
             for (int i = 0; i < Math.Min(current.Index, 10); i++)
             {
@@ -62,6 +71,13 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
                     double opacityBonus = 1.0 + max_opacity_bonus * (1.0 - osuCurrent.OpacityAt(currentHitObject.StartTime, hidden));
 
                     result += stackNerf * opacityBonus * scalingFactor * jumpDistance / cumulativeStrainTime;
+
+                    if (currentObj.Angle != null && osuCurrent.Angle != null)
+                    {
+                        // Objects further back in time should count less for the nerf.
+                        if (Math.Abs(currentObj.Angle.Value - osuCurrent.Angle.Value) < 0.02)
+                            angleRepeatCount += Math.Max(1.0 - 0.1 * i, 0.0);
+                    }
                 }
 
                 lastObj = currentObj;
@@ -73,6 +89,29 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
             if (hidden)
                 result *= 1.0 + hidden_bonus;
 
+            // Nerf patterns with repeated angles.
+            result *= min_angle_multiplier + (1.0 - min_angle_multiplier) / (angleRepeatCount + 1.0);
+
+            double sliderBonus = 0.0;
+
+            if (osuCurrent.BaseObject is Slider osuSlider)
+            {
+                // Invert the scaling factor to determine the true travel distance independent of circle size.
+                double pixelTravelDistance = osuSlider.LazyTravelDistance / scalingFactor;
+
+                // Reward sliders based on velocity.
+                sliderBonus = Math.Pow(Math.Max(0.0, pixelTravelDistance / osuCurrent.TravelTime - min_velocity), 0.5);
+
+                // Longer sliders require more memorisation.
+                sliderBonus *= pixelTravelDistance;
+
+                // Nerf sliders with repeats, as less memorisation is required.
+                if (osuSlider.RepeatCount > 0)
+                    sliderBonus /= (osuSlider.RepeatCount + 1);
+            }
+
+            result += sliderBonus * slider_multiplier;
+
             return result;
         }
     }

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

@@ -46,7 +46,11 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             double sliderFactor = aimRating > 0 ? aimRatingNoSliders / aimRating : 1;
 
             if (mods.Any(h => h is OsuModRelax))
+            {
+                aimRating *= 0.9;
                 speedRating = 0.0;
+                flashlightRating *= 0.7;
+            }
 
             double baseAimPerformance = Math.Pow(5 * Math.Max(1, aimRating / 0.0675) - 4, 3) / 100000;
             double baseSpeedPerformance = Math.Pow(5 * Math.Max(1, speedRating / 0.0675) - 4, 3) / 100000;
@@ -62,7 +66,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                     Math.Pow(baseFlashlightPerformance, 1.1), 1.0 / 1.1
                 );
 
-            double starRating = basePerformance > 0.00001 ? Math.Cbrt(1.12) * 0.027 * (Math.Cbrt(100000 / Math.Pow(2, 1 / 1.1) * basePerformance) + 4) : 0;
+            double starRating = basePerformance > 0.00001 ? Math.Cbrt(OsuPerformanceCalculator.PERFORMANCE_BASE_MULTIPLIER) * 0.027 * (Math.Cbrt(100000 / Math.Pow(2, 1 / 1.1) * basePerformance) + 4) : 0;
 
             double preempt = IBeatmapDifficultyInfo.DifficultyRange(beatmap.Difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
             double drainRate = beatmap.Difficulty.DrainRate;

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

@@ -15,6 +15,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 {
     public class OsuPerformanceCalculator : PerformanceCalculator
     {
+        public const double PERFORMANCE_BASE_MULTIPLIER = 1.14; // This is being adjusted to keep the final pp value scaled around what it used to be when changing things.
+
         private double accuracy;
         private int scoreMaxCombo;
         private int countGreat;
@@ -41,7 +43,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
             effectiveMissCount = calculateEffectiveMissCount(osuAttributes);
 
-            double multiplier = 1.12; // This is being adjusted to keep the final pp value scaled around what it used to be when changing things.
+            double multiplier = PERFORMANCE_BASE_MULTIPLIER;
 
             if (score.Mods.Any(m => m is OsuModNoFail))
                 multiplier *= Math.Max(0.90, 1.0 - 0.02 * effectiveMissCount);
@@ -51,10 +53,14 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
             if (score.Mods.Any(h => h is OsuModRelax))
             {
-                // As we're adding Oks and Mehs to an approximated number of combo breaks the result can be higher than total hits in specific scenarios (which breaks some calculations) so we need to clamp it.
-                effectiveMissCount = Math.Min(effectiveMissCount + countOk + countMeh, totalHits);
+                // https://www.desmos.com/calculator/bc9eybdthb
+                // we use OD13.3 as maximum since it's the value at which great hitwidow becomes 0
+                // this is well beyond currently maximum achievable OD which is 12.17 (DTx2 + DA with OD11)
+                double okMultiplier = Math.Max(0.0, osuAttributes.OverallDifficulty > 0.0 ? 1 - Math.Pow(osuAttributes.OverallDifficulty / 13.33, 1.8) : 1.0);
+                double mehMultiplier = Math.Max(0.0, osuAttributes.OverallDifficulty > 0.0 ? 1 - Math.Pow(osuAttributes.OverallDifficulty / 13.33, 5) : 1.0);
 
-                multiplier *= 0.6;
+                // As we're adding Oks and Mehs to an approximated number of combo breaks the result can be higher than total hits in specific scenarios (which breaks some calculations) so we need to clamp it.
+                effectiveMissCount = Math.Min(effectiveMissCount + countOk * okMultiplier + countMeh * mehMultiplier, totalHits);
             }
 
             double aimValue = computeAimValue(score, osuAttributes);
@@ -103,7 +109,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             if (attributes.ApproachRate > 10.33)
                 approachRateFactor = 0.3 * (attributes.ApproachRate - 10.33);
             else if (attributes.ApproachRate < 8.0)
-                approachRateFactor = 0.1 * (8.0 - attributes.ApproachRate);
+                approachRateFactor = 0.05 * (8.0 - attributes.ApproachRate);
+
+            if (score.Mods.Any(h => h is OsuModRelax))
+                approachRateFactor = 0.0;
 
             aimValue *= 1.0 + approachRateFactor * lengthBonus; // Buff for longer maps with high AR.
 
@@ -134,6 +143,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
         private double computeSpeedValue(ScoreInfo score, OsuDifficultyAttributes attributes)
         {
+            if (score.Mods.Any(h => h is OsuModRelax))
+                return 0.0;
+
             double speedValue = Math.Pow(5.0 * Math.Max(1.0, attributes.SpeedDifficulty / 0.0675) - 4.0, 3.0) / 100000.0;
 
             double lengthBonus = 0.95 + 0.4 * Math.Min(1.0, totalHits / 2000.0) +
@@ -174,7 +186,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             speedValue *= (0.95 + Math.Pow(attributes.OverallDifficulty, 2) / 750) * Math.Pow((accuracy + relevantAccuracy) / 2.0, (14.5 - Math.Max(attributes.OverallDifficulty, 8)) / 2);
 
             // Scale the speed value with # of 50s to punish doubletapping.
-            speedValue *= Math.Pow(0.98, countMeh < totalHits / 500.0 ? 0 : countMeh - totalHits / 500.0);
+            speedValue *= Math.Pow(0.99, countMeh < totalHits / 500.0 ? 0 : countMeh - totalHits / 500.0);
 
             return speedValue;
         }
@@ -258,14 +270,13 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                     comboBasedMissCount = fullComboThreshold / Math.Max(1.0, scoreMaxCombo);
             }
 
-            // Clamp miss count since it's derived from combo and can be higher than total hits and that breaks some calculations
-            comboBasedMissCount = Math.Min(comboBasedMissCount, totalHits);
+            // Clamp miss count to maximum amount of possible breaks
+            comboBasedMissCount = Math.Min(comboBasedMissCount, countOk + countMeh + countMiss);
 
             return Math.Max(countMiss, comboBasedMissCount);
         }
 
         private double getComboScalingFactor(OsuDifficultyAttributes attributes) => attributes.MaxCombo <= 0 ? 1.0 : Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(attributes.MaxCombo, 0.8), 1.0);
         private int totalHits => countGreat + countOk + countMeh + countMiss;
-        private int totalSuccessfulHits => countGreat + countOk + countMeh;
     }
 }

osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs

@@ -15,10 +15,14 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
 {
     public class OsuDifficultyHitObject : DifficultyHitObject
     {
-        private const int normalised_radius = 50; // Change radius to 50 to make 100 the diameter. Easier for mental maths.
+        /// <summary>
+        /// A distance by which all distances should be scaled in order to assume a uniform circle size.
+        /// </summary>
+        public const int NORMALISED_RADIUS = 50; // Change radius to 50 to make 100 the diameter. Easier for mental maths.
+
         private const int min_delta_time = 25;
-        private const float maximum_slider_radius = normalised_radius * 2.4f;
-        private const float assumed_slider_radius = normalised_radius * 1.8f;
+        private const float maximum_slider_radius = NORMALISED_RADIUS * 2.4f;
+        private const float assumed_slider_radius = NORMALISED_RADIUS * 1.8f;
 
         protected new OsuHitObject BaseObject => (OsuHitObject)base.BaseObject;
 
@@ -64,7 +68,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
         public double TravelDistance { get; private set; }
 
         /// <summary>
-        /// The time taken to travel through <see cref="TravelDistance"/>, with a minimum value of 25ms for a non-zero distance.
+        /// The time taken to travel through <see cref="TravelDistance"/>, with a minimum value of 25ms for <see cref="Slider"/> objects.
         /// </summary>
         public double TravelTime { get; private set; }
 
@@ -123,7 +127,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
             if (BaseObject is Slider currentSlider)
             {
                 computeSliderCursorPosition(currentSlider);
-                TravelDistance = currentSlider.LazyTravelDistance;
+                // Bonus for repeat sliders until a better per nested object strain system can be achieved.
+                TravelDistance = currentSlider.LazyTravelDistance * (float)Math.Pow(1 + currentSlider.RepeatCount / 2.5, 1.0 / 2.5);
                 TravelTime = Math.Max(currentSlider.LazyTravelTime / clockRate, min_delta_time);
             }
 
@@ -132,7 +137,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
                 return;
 
             // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
-            float scalingFactor = normalised_radius / (float)BaseObject.Radius;
+            float scalingFactor = NORMALISED_RADIUS / (float)BaseObject.Radius;
 
             if (BaseObject.Radius < 30)
             {
@@ -206,7 +211,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
 
             slider.LazyEndPosition = slider.StackedPosition + slider.Path.PositionAt(endTimeMin); // temporary lazy end position until a real result can be derived.
             var currCursorPosition = slider.StackedPosition;
-            double scalingFactor = normalised_radius / slider.Radius; // lazySliderDistance is coded to be sensitive to scaling, this makes the maths easier with the thresholds being used.
+            double scalingFactor = NORMALISED_RADIUS / slider.Radius; // lazySliderDistance is coded to be sensitive to scaling, this makes the maths easier with the thresholds being used.
 
             for (int i = 1; i < slider.NestedHitObjects.Count; i++)
             {
@@ -234,7 +239,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
                 else if (currMovementObj is SliderRepeat)
                 {
                     // For a slider repeat, assume a tighter movement threshold to better assess repeat sliders.
-                    requiredMovement = normalised_radius;
+                    requiredMovement = NORMALISED_RADIUS;
                 }
 
                 if (currMovementLength > requiredMovement)
@@ -248,8 +253,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
                 if (i == slider.NestedHitObjects.Count - 1)
                     slider.LazyEndPosition = currCursorPosition;
             }
-
-            slider.LazyTravelDistance *= (float)Math.Pow(1 + slider.RepeatCount / 2.5, 1.0 / 2.5); // Bonus for repeat sliders until a better per nested object strain system can be achieved.
         }
 
         private Vector2 getEndCursorPosition(OsuHitObject hitObject)

osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs

@@ -25,7 +25,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
 
         private double currentStrain;
 
-        private double skillMultiplier => 23.25;
+        private double skillMultiplier => 23.55;
         private double strainDecayBase => 0.15;
 
         private double strainDecay(double ms) => Math.Pow(strainDecayBase, ms / 1000);

osu.Game.Rulesets.Osu/Difficulty/Skills/Flashlight.cs

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
             hasHiddenMod = mods.Any(m => m is OsuModHidden);
         }
 
-        private double skillMultiplier => 0.05;
+        private double skillMultiplier => 0.052;
         private double strainDecayBase => 0.15;
 
         private double currentStrain;

osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs

@@ -64,7 +64,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
             if (maxStrain == 0)
                 return 0;
 
-            return objectStrains.Aggregate((total, next) => total + (1.0 / (1.0 + Math.Exp(-(next / maxStrain * 12.0 - 6.0)))));
+            return objectStrains.Sum(strain => 1.0 / (1.0 + Math.Exp(-(strain / maxStrain * 12.0 - 6.0))));
         }
     }
 }

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

@@ -43,6 +43,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
         private InputManager inputManager;
 
         public Action<List<PathControlPoint>> RemoveControlPointsRequested;
+        public Action<List<PathControlPoint>> SplitControlPointsRequested;
 
         [Resolved(CanBeNull = true)]
         private IDistanceSnapProvider snapProvider { get; set; }
@@ -104,6 +105,29 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
             return true;
         }
 
+        private bool splitSelected()
+        {
+            List<PathControlPoint> controlPointsToSplitAt = Pieces.Where(p => p.IsSelected.Value && isSplittable(p)).Select(p => p.ControlPoint).ToList();
+
+            // Ensure that there are any points to be split
+            if (controlPointsToSplitAt.Count == 0)
+                return false;
+
+            changeHandler?.BeginChange();
+            SplitControlPointsRequested?.Invoke(controlPointsToSplitAt);
+            changeHandler?.EndChange();
+
+            // Since pieces are re-used, they will not point to the deleted control points while remaining selected
+            foreach (var piece in Pieces)
+                piece.IsSelected.Value = false;
+
+            return true;
+        }
+
+        private bool isSplittable(PathControlPointPiece p) =>
+            // A slider can only be split on control points which connect two different slider segments.
+            p.ControlPoint.Type.HasValue && p != Pieces.FirstOrDefault() && p != Pieces.LastOrDefault();
+
         private void onControlPointsChanged(object sender, NotifyCollectionChangedEventArgs e)
         {
             switch (e.Action)
@@ -142,8 +166,10 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
                 case NotifyCollectionChangedAction.Remove:
                     foreach (var point in e.OldItems.Cast<PathControlPoint>())
                     {
-                        Pieces.RemoveAll(p => p.ControlPoint == point);
-                        Connections.RemoveAll(c => c.ControlPoint == point);
+                        foreach (var piece in Pieces.Where(p => p.ControlPoint == point).ToArray())
+                            piece.RemoveAndDisposeImmediately();
+                        foreach (var connection in Connections.Where(c => c.ControlPoint == point).ToArray())
+                            connection.RemoveAndDisposeImmediately();
                     }
 
                     // If removing before the end of the path,
@@ -322,25 +348,42 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
                 if (count == 0)
                     return null;
 
-                List<MenuItem> items = new List<MenuItem>();
+                var splittablePieces = selectedPieces.Where(isSplittable).ToList();
+                int splittableCount = splittablePieces.Count;
+
+                List<MenuItem> curveTypeItems = new List<MenuItem>();
 
                 if (!selectedPieces.Contains(Pieces[0]))
-                    items.Add(createMenuItemForPathType(null));
+                    curveTypeItems.Add(createMenuItemForPathType(null));
 
                 // todo: hide/disable items which aren't valid for selected points
-                items.Add(createMenuItemForPathType(PathType.Linear));
-                items.Add(createMenuItemForPathType(PathType.PerfectCurve));
-                items.Add(createMenuItemForPathType(PathType.Bezier));
-                items.Add(createMenuItemForPathType(PathType.Catmull));
+                curveTypeItems.Add(createMenuItemForPathType(PathType.Linear));
+                curveTypeItems.Add(createMenuItemForPathType(PathType.PerfectCurve));
+                curveTypeItems.Add(createMenuItemForPathType(PathType.Bezier));
+                curveTypeItems.Add(createMenuItemForPathType(PathType.Catmull));
 
-                return new MenuItem[]
+                var menuItems = new List<MenuItem>
                 {
-                    new OsuMenuItem($"Delete {"control point".ToQuantity(count, count > 1 ? ShowQuantityAs.Numeric : ShowQuantityAs.None)}", MenuItemType.Destructive, () => DeleteSelected()),
                     new OsuMenuItem("Curve type")
                     {
-                        Items = items
+                        Items = curveTypeItems
                     }
                 };
+
+                if (splittableCount > 0)
+                {
+                    menuItems.Add(new OsuMenuItem($"Split {"control point".ToQuantity(splittableCount, splittableCount > 1 ? ShowQuantityAs.Numeric : ShowQuantityAs.None)}",
+                        MenuItemType.Destructive,
+                        () => splitSelected()));
+                }
+
+                menuItems.Add(
+                    new OsuMenuItem($"Delete {"control point".ToQuantity(count, count > 1 ? ShowQuantityAs.Numeric : ShowQuantityAs.None)}",
+                        MenuItemType.Destructive,
+                        () => DeleteSelected())
+                );
+
+                return menuItems.ToArray();
             }
         }
 

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

@@ -13,6 +13,7 @@ using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
 using osu.Framework.Utils;
+using osu.Game.Audio;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
@@ -111,7 +112,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
         {
             AddInternal(ControlPointVisualiser = new PathControlPointVisualiser(HitObject, true)
             {
-                RemoveControlPointsRequested = removeControlPoints
+                RemoveControlPointsRequested = removeControlPoints,
+                SplitControlPointsRequested = splitControlPoints
             });
 
             base.OnSelected();
@@ -249,15 +251,83 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             HitObject.Position += first;
         }
 
+        private void splitControlPoints(List<PathControlPoint> controlPointsToSplitAt)
+        {
+            // Arbitrary gap in milliseconds to put between split slider pieces
+            const double split_gap = 100;
+
+            // Ensure that there are any points to be split
+            if (controlPointsToSplitAt.Count == 0)
+                return;
+
+            editorBeatmap.SelectedHitObjects.Clear();
+
+            foreach (var splitPoint in controlPointsToSplitAt)
+            {
+                if (splitPoint == controlPoints[0] || splitPoint == controlPoints[^1] || splitPoint.Type is null)
+                    continue;
+
+                // Split off the section of slider before this control point so the remaining control points to split are in the latter part of the slider.
+                int index = controlPoints.IndexOf(splitPoint);
+
+                if (index <= 0)
+                    continue;
+
+                // Extract the split portion and remove from the original slider.
+                var splitControlPoints = controlPoints.Take(index + 1).ToList();
+                controlPoints.RemoveRange(0, index);
+
+                // Turn the control points which were split off into a new slider.
+                var samplePoint = (SampleControlPoint)HitObject.SampleControlPoint.DeepClone();
+                var difficultyPoint = (DifficultyControlPoint)HitObject.DifficultyControlPoint.DeepClone();
+
+                var newSlider = new Slider
+                {
+                    StartTime = HitObject.StartTime,
+                    Position = HitObject.Position + splitControlPoints[0].Position,
+                    NewCombo = HitObject.NewCombo,
+                    SampleControlPoint = samplePoint,
+                    DifficultyControlPoint = difficultyPoint,
+                    LegacyLastTickOffset = HitObject.LegacyLastTickOffset,
+                    Samples = HitObject.Samples.Select(s => s.With()).ToList(),
+                    RepeatCount = HitObject.RepeatCount,
+                    NodeSamples = HitObject.NodeSamples.Select(n => (IList<HitSampleInfo>)n.Select(s => s.With()).ToList()).ToList(),
+                    Path = new SliderPath(splitControlPoints.Select(o => new PathControlPoint(o.Position - splitControlPoints[0].Position, o == splitControlPoints[^1] ? null : o.Type)).ToArray())
+                };
+
+                // Increase the start time of the slider before adding the new slider so the new slider is immediately inserted at the correct index and internal state remains valid.
+                HitObject.StartTime += split_gap;
+
+                editorBeatmap.Add(newSlider);
+
+                HitObject.NewCombo = false;
+                HitObject.Path.ExpectedDistance.Value -= newSlider.Path.CalculatedDistance;
+                HitObject.StartTime += newSlider.SpanDuration;
+
+                // In case the remainder of the slider has no length left over, give it length anyways so we don't get a 0 length slider.
+                if (HitObject.Path.ExpectedDistance.Value <= Precision.DOUBLE_EPSILON)
+                {
+                    HitObject.Path.ExpectedDistance.Value = null;
+                }
+            }
+
+            // Once all required pieces have been split off, the original slider has the final split.
+            // As a final step, we must reset its control points to have an origin of (0,0).
+            Vector2 first = controlPoints[0].Position;
+            foreach (var c in controlPoints)
+                c.Position -= first;
+            HitObject.Position += first;
+        }
+
         private void convertToStream()
         {
-            if (editorBeatmap == null || changeHandler == null || beatDivisor == null)
+            if (editorBeatmap == null || beatDivisor == null)
                 return;
 
             var timingPoint = editorBeatmap.ControlPointInfo.TimingPointAt(HitObject.StartTime);
             double streamSpacing = timingPoint.BeatLength / beatDivisor.Value;
 
-            changeHandler.BeginChange();
+            changeHandler?.BeginChange();
 
             int i = 0;
             double time = HitObject.StartTime;
@@ -292,7 +362,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 
             editorBeatmap.Remove(HitObject);
 
-            changeHandler.EndChange();
+            changeHandler?.EndChange();
         }
 
         public override MenuItem[] ContextMenuItems => new MenuItem[]

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

@@ -6,8 +6,11 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input.Events;
 using osu.Framework.Utils;
 using osu.Game.Extensions;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
@@ -15,6 +18,7 @@ using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Rulesets.Osu.Edit
 {
@@ -53,6 +57,17 @@ namespace osu.Game.Rulesets.Osu.Edit
             referencePathTypes = null;
         }
 
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            if (e.Key == Key.M && e.ControlPressed && e.ShiftPressed)
+            {
+                mergeSelection();
+                return true;
+            }
+
+            return false;
+        }
+
         public override bool HandleMovement(MoveSelectionEvent<HitObject> moveEvent)
         {
             var hitObjects = selectedMovableObjects;
@@ -112,13 +127,16 @@ namespace osu.Game.Rulesets.Osu.Edit
                 {
                     didFlip = true;
 
-                    foreach (var point in slider.Path.ControlPoints)
-                    {
-                        point.Position = new Vector2(
-                            (direction == Direction.Horizontal ? -1 : 1) * point.Position.X,
-                            (direction == Direction.Vertical ? -1 : 1) * point.Position.Y
-                        );
-                    }
+                    var controlPoints = slider.Path.ControlPoints.Select(p =>
+                        new PathControlPoint(new Vector2(
+                            (direction == Direction.Horizontal ? -1 : 1) * p.Position.X,
+                            (direction == Direction.Vertical ? -1 : 1) * p.Position.Y
+                        ), p.Type)).ToArray();
+
+                    // Importantly, update as a single operation so automatic adjustment of control points to different
+                    // curve types does not unexpectedly trigger and change the slider's shape.
+                    slider.Path.ControlPoints.Clear();
+                    slider.Path.ControlPoints.AddRange(controlPoints);
                 }
             }
 
@@ -168,8 +186,13 @@ namespace osu.Game.Rulesets.Osu.Edit
 
                 if (h is IHasPath path)
                 {
-                    foreach (var point in path.Path.ControlPoints)
-                        point.Position = RotatePointAroundOrigin(point.Position, Vector2.Zero, delta);
+                    var controlPoints = path.Path.ControlPoints.Select(p =>
+                        new PathControlPoint(RotatePointAroundOrigin(p.Position, Vector2.Zero, delta), p.Type)).ToArray();
+
+                    // Importantly, update as a single operation so automatic adjustment of control points to different
+                    // curve types does not unexpectedly trigger and change the slider's shape.
+                    path.Path.ControlPoints.Clear();
+                    path.Path.ControlPoints.AddRange(controlPoints);
                 }
             }
 
@@ -320,7 +343,115 @@ namespace osu.Game.Rulesets.Osu.Edit
         /// All osu! hitobjects which can be moved/rotated/scaled.
         /// </summary>
         private OsuHitObject[] selectedMovableObjects => SelectedItems.OfType<OsuHitObject>()
-                                                                      .Where(h => !(h is Spinner))
+                                                                      .Where(h => h is not Spinner)
                                                                       .ToArray();
+
+        /// <summary>
+        /// All osu! hitobjects which can be merged.
+        /// </summary>
+        private OsuHitObject[] selectedMergeableObjects => SelectedItems.OfType<OsuHitObject>()
+                                                                        .Where(h => h is HitCircle or Slider)
+                                                                        .OrderBy(h => h.StartTime)
+                                                                        .ToArray();
+
+        private void mergeSelection()
+        {
+            var mergeableObjects = selectedMergeableObjects;
+
+            if (!canMerge(mergeableObjects))
+                return;
+
+            ChangeHandler?.BeginChange();
+
+            // Have an initial slider object.
+            var firstHitObject = mergeableObjects[0];
+            var mergedHitObject = firstHitObject as Slider ?? new Slider
+            {
+                StartTime = firstHitObject.StartTime,
+                Position = firstHitObject.Position,
+                NewCombo = firstHitObject.NewCombo,
+                SampleControlPoint = firstHitObject.SampleControlPoint,
+                Samples = firstHitObject.Samples,
+            };
+
+            if (mergedHitObject.Path.ControlPoints.Count == 0)
+            {
+                mergedHitObject.Path.ControlPoints.Add(new PathControlPoint(Vector2.Zero, PathType.Linear));
+            }
+
+            // Merge all the selected hit objects into one slider path.
+            bool lastCircle = firstHitObject is HitCircle;
+
+            foreach (var selectedMergeableObject in mergeableObjects.Skip(1))
+            {
+                if (selectedMergeableObject is IHasPath hasPath)
+                {
+                    var offset = lastCircle ? selectedMergeableObject.Position - mergedHitObject.Position : mergedHitObject.Path.ControlPoints[^1].Position;
+                    float distanceToLastControlPoint = Vector2.Distance(mergedHitObject.Path.ControlPoints[^1].Position, offset);
+
+                    // Calculate the distance required to travel to the expected distance of the merging slider.
+                    mergedHitObject.Path.ExpectedDistance.Value = mergedHitObject.Path.CalculatedDistance + distanceToLastControlPoint + hasPath.Path.Distance;
+
+                    // Remove the last control point if it sits exactly on the start of the next control point.
+                    if (Precision.AlmostEquals(distanceToLastControlPoint, 0))
+                    {
+                        mergedHitObject.Path.ControlPoints.RemoveAt(mergedHitObject.Path.ControlPoints.Count - 1);
+                    }
+
+                    mergedHitObject.Path.ControlPoints.AddRange(hasPath.Path.ControlPoints.Select(o => new PathControlPoint(o.Position + offset, o.Type)));
+                    lastCircle = false;
+                }
+                else
+                {
+                    // Turn the last control point into a linear type if this is the first merging circle in a sequence, so the subsequent control points can be inherited path type.
+                    if (!lastCircle)
+                    {
+                        mergedHitObject.Path.ControlPoints.Last().Type = PathType.Linear;
+                    }
+
+                    mergedHitObject.Path.ControlPoints.Add(new PathControlPoint(selectedMergeableObject.Position - mergedHitObject.Position));
+                    mergedHitObject.Path.ExpectedDistance.Value = null;
+                    lastCircle = true;
+                }
+            }
+
+            // Make sure only the merged hit object is in the beatmap.
+            if (firstHitObject is Slider)
+            {
+                foreach (var selectedMergeableObject in mergeableObjects.Skip(1))
+                {
+                    EditorBeatmap.Remove(selectedMergeableObject);
+                }
+            }
+            else
+            {
+                foreach (var selectedMergeableObject in mergeableObjects)
+                {
+                    EditorBeatmap.Remove(selectedMergeableObject);
+                }
+
+                EditorBeatmap.Add(mergedHitObject);
+            }
+
+            // Make sure the merged hitobject is selected.
+            SelectedItems.Clear();
+            SelectedItems.Add(mergedHitObject);
+
+            ChangeHandler?.EndChange();
+        }
+
+        protected override IEnumerable<MenuItem> GetContextMenuItemsForSelection(IEnumerable<SelectionBlueprint<HitObject>> selection)
+        {
+            foreach (var item in base.GetContextMenuItemsForSelection(selection))
+                yield return item;
+
+            if (canMerge(selectedMergeableObjects))
+                yield return new OsuMenuItem("Merge selection", MenuItemType.Destructive, mergeSelection);
+        }
+
+        private bool canMerge(IReadOnlyList<OsuHitObject> objects) =>
+            objects.Count > 1
+            && (objects.Any(h => h is Slider)
+                || objects.Zip(objects.Skip(1), (h1, h2) => Precision.DefinitelyBigger(Vector2.DistanceSquared(h1.Position, h2.Position), 1)).Any(x => x));
     }
 }

osu.Game.Rulesets.Osu/Edit/Setup/OsuSetupSection.cs

@@ -49,6 +49,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Setup
         private void updateBeatmap()
         {
             Beatmap.BeatmapInfo.StackLeniency = stackLeniency.Current.Value;
+            Beatmap.SaveState();
         }
     }
 }

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

@@ -4,6 +4,7 @@
 using System;
 using System.Linq;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
@@ -11,7 +12,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => @"Alternate";
         public override string Acronym => @"AL";
-        public override string Description => @"Don't use the same key twice in a row!";
+        public override LocalisableString Description => @"Don't use the same key twice in a row!";
         public override IconUsage? Icon => FontAwesome.Solid.Keyboard;
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModSingleTap) }).ToArray();
 

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

@@ -5,6 +5,7 @@ using System;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -16,7 +17,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => "Approach Different";
         public override string Acronym => "AD";
-        public override string Description => "Never trust the approach circles...";
+        public override LocalisableString Description => "Never trust the approach circles...";
         public override double ScoreMultiplier => 1;
         public override IconUsage? Icon { get; } = FontAwesome.Regular.Circle;
 

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

@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.StateChanges;
+using osu.Framework.Localisation;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Objects;
@@ -20,8 +21,8 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Acronym => "AP";
         public override IconUsage? Icon => OsuIcon.ModAutopilot;
         public override ModType Type => ModType.Automation;
-        public override string Description => @"Automatic cursor movement - just follow the rhythm.";
-        public override double ScoreMultiplier => 1;
+        public override LocalisableString Description => @"Automatic cursor movement - just follow the rhythm.";
+        public override double ScoreMultiplier => 0.1;
         public override Type[] IncompatibleMods => new[] { typeof(OsuModSpunOut), typeof(ModRelax), typeof(ModFailCondition), typeof(ModNoFail), typeof(ModAutoplay), typeof(OsuModMagnetised), typeof(OsuModRepel) };
 
         public bool PerformFail() => false;
@@ -30,8 +31,6 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         private OsuInputManager inputManager = null!;
 
-        private IFrameStableClock gameplayClock = null!;
-
         private List<OsuReplayFrame> replayFrames = null!;
 
         private int currentFrame;
@@ -40,7 +39,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         {
             if (currentFrame == replayFrames.Count - 1) return;
 
-            double time = gameplayClock.CurrentTime;
+            double time = playfield.Clock.CurrentTime;
 
             // Very naive implementation of autopilot based on proximity to replay frames.
             // TODO: this needs to be based on user interactions to better match stable (pausing until judgement is registered).
@@ -55,8 +54,6 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
         {
-            gameplayClock = drawableRuleset.FrameStableClock;
-
             // Grab the input manager to disable the user's cursor, and for future use
             inputManager = (OsuInputManager)drawableRuleset.KeyBindingInputManager;
             inputManager.AllowUserCursorMovement = false;

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

@@ -8,6 +8,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
+using osu.Framework.Localisation;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
@@ -22,7 +23,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     public class OsuModBlinds : Mod, IApplicableToDrawableRuleset<OsuHitObject>, IApplicableToHealthProcessor
     {
         public override string Name => "Blinds";
-        public override string Description => "Play with blinds on your screen.";
+        public override LocalisableString Description => "Play with blinds on your screen.";
         public override string Acronym => "BL";
 
         public override IconUsage? Icon => FontAwesome.Solid.Adjust;

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

@@ -3,6 +3,7 @@
 
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
 using osu.Game.Configuration;
 
 namespace osu.Game.Rulesets.Osu.Mods
@@ -15,7 +16,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public override IconUsage? Icon => FontAwesome.Solid.CompressArrowsAlt;
 
-        public override string Description => "Hit them at the right size!";
+        public override LocalisableString Description => "Hit them at the right size!";
 
         [SettingSource("Starting Size", "The initial size multiplier applied to all objects.")]
         public override BindableNumber<float> StartScale { get; } = new BindableFloat

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

@@ -1,12 +1,13 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Localisation;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
     public class OsuModEasy : ModEasyWithExtraLives
     {
-        public override string Description => @"Larger circles, more forgiving HP drain, less accuracy required, and three lives!";
+        public override LocalisableString Description => @"Larger circles, more forgiving HP drain, less accuracy required, and three lives!";
     }
 }

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

@@ -3,6 +3,7 @@
 
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
 using osu.Game.Configuration;
 
 namespace osu.Game.Rulesets.Osu.Mods
@@ -15,7 +16,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public override IconUsage? Icon => FontAwesome.Solid.ArrowsAltV;
 
-        public override string Description => "Hit them at the right size!";
+        public override LocalisableString Description => "Hit them at the right size!";
 
         [SettingSource("Starting Size", "The initial size multiplier applied to all objects.")]
         public override BindableNumber<float> StartScale { get; } = new BindableFloat

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

@@ -6,6 +6,7 @@ using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Bindables;
+using osu.Framework.Localisation;
 using osu.Game.Configuration;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
@@ -22,7 +23,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         [SettingSource("Only fade approach circles", "The main object body will not fade when enabled.")]
         public Bindable<bool> OnlyFadeApproachCircles { get; } = new BindableBool();
 
-        public override string Description => @"Play with no approach circles and fading circles/sliders.";
+        public override LocalisableString Description => @"Play with no approach circles and fading circles/sliders.";
         public override double ScoreMultiplier => UsesDefaultConfiguration ? 1.06 : 1;
 
         public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles), typeof(OsuModSpinIn) };

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

@@ -4,6 +4,8 @@
 using System;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
+using osu.Framework.Timing;
 using osu.Framework.Utils;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Mods;
@@ -22,12 +24,10 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Acronym => "MG";
         public override IconUsage? Icon => FontAwesome.Solid.Magnet;
         public override ModType Type => ModType.Fun;
-        public override string Description => "No need to chase the circles – your cursor is a magnet!";
-        public override double ScoreMultiplier => 1;
+        public override LocalisableString Description => "No need to chase the circles – your cursor is a magnet!";
+        public override double ScoreMultiplier => 0.5;
         public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay), typeof(OsuModRelax), typeof(OsuModRepel) };
 
-        private IFrameStableClock gameplayClock = null!;
-
         [SettingSource("Attraction strength", "How strong the pull is.", 0)]
         public BindableFloat AttractionStrength { get; } = new BindableFloat(0.5f)
         {
@@ -38,8 +38,6 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
         {
-            gameplayClock = drawableRuleset.FrameStableClock;
-
             // Hide judgment displays and follow points as they won't make any sense.
             // Judgements can potentially be turned on in a future where they display at a position relative to their drawable counterpart.
             drawableRuleset.Playfield.DisplayJudgements.Value = false;
@@ -55,27 +53,27 @@ namespace osu.Game.Rulesets.Osu.Mods
                 switch (drawable)
                 {
                     case DrawableHitCircle circle:
-                        easeTo(circle, cursorPos);
+                        easeTo(playfield.Clock, circle, cursorPos);
                         break;
 
                     case DrawableSlider slider:
 
                         if (!slider.HeadCircle.Result.HasResult)
-                            easeTo(slider, cursorPos);
+                            easeTo(playfield.Clock, slider, cursorPos);
                         else
-                            easeTo(slider, cursorPos - slider.Ball.DrawPosition);
+                            easeTo(playfield.Clock, slider, cursorPos - slider.Ball.DrawPosition);
 
                         break;
                 }
             }
         }
 
-        private void easeTo(DrawableHitObject hitObject, Vector2 destination)
+        private void easeTo(IFrameBasedClock clock, DrawableHitObject hitObject, Vector2 destination)
         {
             double dampLength = Interpolation.Lerp(3000, 40, AttractionStrength.Value);
 
-            float x = (float)Interpolation.DampContinuously(hitObject.X, destination.X, dampLength, gameplayClock.ElapsedFrameTime);
-            float y = (float)Interpolation.DampContinuously(hitObject.Y, destination.Y, dampLength, gameplayClock.ElapsedFrameTime);
+            float x = (float)Interpolation.DampContinuously(hitObject.X, destination.X, dampLength, clock.ElapsedFrameTime);
+            float y = (float)Interpolation.DampContinuously(hitObject.Y, destination.Y, dampLength, clock.ElapsedFrameTime);
 
             hitObject.Position = new Vector2(x, y);
         }

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

@@ -3,6 +3,7 @@
 
 using System;
 using osu.Framework.Bindables;
+using osu.Framework.Localisation;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
@@ -13,7 +14,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 {
     public class OsuModMirror : ModMirror, IApplicableToHitObject
     {
-        public override string Description => "Flip objects on the chosen axes.";
+        public override LocalisableString Description => "Flip objects on the chosen axes.";
         public override Type[] IncompatibleMods => new[] { typeof(ModHardRock) };
 
         [SettingSource("Mirrored axes", "Choose which axes objects are mirrored over.")]

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

@@ -4,6 +4,7 @@
 using System;
 using System.Linq;
 using osu.Framework.Bindables;
+using osu.Framework.Localisation;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
@@ -17,7 +18,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 {
     public class OsuModNoScope : ModNoScope, IUpdatableByPlayfield, IApplicableToBeatmap
     {
-        public override string Description => "Where's the cursor?";
+        public override LocalisableString Description => "Where's the cursor?";
 
         private PeriodTracker spinnerPeriods = null!;
 

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

@@ -3,6 +3,7 @@
 
 using System;
 using System.Linq;
+using osu.Framework.Localisation;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
@@ -18,7 +19,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     /// </summary>
     public class OsuModRandom : ModRandom, IApplicableToBeatmap
     {
-        public override string Description => "It never gets boring!";
+        public override LocalisableString Description => "It never gets boring!";
 
         public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(OsuModTarget)).ToArray();
 

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

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using osu.Framework.Localisation;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
@@ -18,7 +19,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 {
     public class OsuModRelax : ModRelax, IUpdatableByPlayfield, IApplicableToDrawableRuleset<OsuHitObject>, IApplicableToPlayer
     {
-        public override string Description => @"You don't need to click. Give your clicking/tapping fingers a break from the heat of things.";
+        public override LocalisableString Description => @"You don't need to click. Give your clicking/tapping fingers a break from the heat of things.";
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModAutopilot), typeof(OsuModMagnetised), typeof(OsuModAlternate), typeof(OsuModSingleTap) }).ToArray();
 
         /// <summary>

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

@@ -2,8 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Diagnostics;
 using osu.Framework.Bindables;
+using osu.Framework.Localisation;
+using osu.Framework.Timing;
 using osu.Framework.Utils;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Mods;
@@ -22,12 +23,10 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Name => "Repel";
         public override string Acronym => "RP";
         public override ModType Type => ModType.Fun;
-        public override string Description => "Hit objects run away!";
+        public override LocalisableString Description => "Hit objects run away!";
         public override double ScoreMultiplier => 1;
         public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay), typeof(OsuModMagnetised) };
 
-        private IFrameStableClock? gameplayClock;
-
         [SettingSource("Repulsion strength", "How strong the repulsion is.", 0)]
         public BindableFloat RepulsionStrength { get; } = new BindableFloat(0.5f)
         {
@@ -38,8 +37,6 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
         {
-            gameplayClock = drawableRuleset.FrameStableClock;
-
             // Hide judgment displays and follow points as they won't make any sense.
             // Judgements can potentially be turned on in a future where they display at a position relative to their drawable counterpart.
             drawableRuleset.Playfield.DisplayJudgements.Value = false;
@@ -68,29 +65,27 @@ namespace osu.Game.Rulesets.Osu.Mods
                 switch (drawable)
                 {
                     case DrawableHitCircle circle:
-                        easeTo(circle, destination, cursorPos);
+                        easeTo(playfield.Clock, circle, destination, cursorPos);
                         break;
 
                     case DrawableSlider slider:
 
                         if (!slider.HeadCircle.Result.HasResult)
-                            easeTo(slider, destination, cursorPos);
+                            easeTo(playfield.Clock, slider, destination, cursorPos);
                         else
-                            easeTo(slider, destination - slider.Ball.DrawPosition, cursorPos);
+                            easeTo(playfield.Clock, slider, destination - slider.Ball.DrawPosition, cursorPos);
 
                         break;
                 }
             }
         }
 
-        private void easeTo(DrawableHitObject hitObject, Vector2 destination, Vector2 cursorPos)
+        private void easeTo(IFrameBasedClock clock, DrawableHitObject hitObject, Vector2 destination, Vector2 cursorPos)
         {
-            Debug.Assert(gameplayClock != null);
-
             double dampLength = Vector2.Distance(hitObject.Position, cursorPos) / (0.04 * RepulsionStrength.Value + 0.04);
 
-            float x = (float)Interpolation.DampContinuously(hitObject.X, destination.X, dampLength, gameplayClock.ElapsedFrameTime);
-            float y = (float)Interpolation.DampContinuously(hitObject.Y, destination.Y, dampLength, gameplayClock.ElapsedFrameTime);
+            float x = (float)Interpolation.DampContinuously(hitObject.X, destination.X, dampLength, clock.ElapsedFrameTime);
+            float y = (float)Interpolation.DampContinuously(hitObject.Y, destination.Y, dampLength, clock.ElapsedFrameTime);
 
             hitObject.Position = new Vector2(x, y);
         }

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

@@ -3,6 +3,7 @@
 
 using System;
 using System.Linq;
+using osu.Framework.Localisation;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
@@ -10,7 +11,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => @"Single Tap";
         public override string Acronym => @"SG";
-        public override string Description => @"You must only use one key!";
+        public override LocalisableString Description => @"You must only use one key!";
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModAlternate) }).ToArray();
 
         protected override bool CheckValidNewAction(OsuAction action) => LastAcceptedAction == null || LastAcceptedAction == action;

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

@@ -4,6 +4,7 @@
 using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
@@ -18,7 +19,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Acronym => "SI";
         public override IconUsage? Icon => FontAwesome.Solid.Undo;
         public override ModType Type => ModType.Fun;
-        public override string Description => "Circles spin in. No approach circles.";
+        public override LocalisableString Description => "Circles spin in. No approach circles.";
         public override double ScoreMultiplier => 1;
 
         // todo: this mod needs to be incompatible with "hidden" due to forcing the circle to remain opaque,

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

@@ -4,6 +4,7 @@
 using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
 using osu.Framework.Utils;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
@@ -18,7 +19,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Acronym => "SO";
         public override IconUsage? Icon => OsuIcon.ModSpunOut;
         public override ModType Type => ModType.Automation;
-        public override string Description => @"Spinners will be automatically completed.";
+        public override LocalisableString Description => @"Spinners will be automatically completed.";
         public override double ScoreMultiplier => 0.9;
         public override Type[] IncompatibleMods => new[] { typeof(ModAutoplay), typeof(OsuModAutopilot), typeof(OsuModTarget) };
 

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

@@ -4,6 +4,7 @@
 using System;
 using System.Linq;
 using System.Threading;
+using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mods;
@@ -23,7 +24,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Name => @"Strict Tracking";
         public override string Acronym => @"ST";
         public override ModType Type => ModType.DifficultyIncrease;
-        public override string Description => @"Once you start a slider, follow precisely or get a miss.";
+        public override LocalisableString Description => @"Once you start a slider, follow precisely or get a miss.";
         public override double ScoreMultiplier => 1.0;
         public override Type[] IncompatibleMods => new[] { typeof(ModClassic), typeof(OsuModTarget) };
 

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

@@ -7,6 +7,7 @@ using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
 using osu.Framework.Utils;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
@@ -39,7 +40,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Acronym => "TP";
         public override ModType Type => ModType.Conversion;
         public override IconUsage? Icon => OsuIcon.ModTarget;
-        public override string Description => @"Practice keeping up with the beat of the song.";
+        public override LocalisableString Description => @"Practice keeping up with the beat of the song.";
         public override double ScoreMultiplier => 1;
 
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[]
@@ -58,6 +59,9 @@ namespace osu.Game.Rulesets.Osu.Mods
             Value = null
         };
 
+        [SettingSource("Metronome ticks", "Whether a metronome beat should play in the background")]
+        public Bindable<bool> Metronome { get; } = new BindableBool(true);
+
         #region Constants
 
         /// <summary>
@@ -336,7 +340,8 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
         {
-            drawableRuleset.Overlays.Add(new MetronomeBeat(drawableRuleset.Beatmap.HitObjects.First().StartTime));
+            if (Metronome.Value)
+                drawableRuleset.Overlays.Add(new MetronomeBeat(drawableRuleset.Beatmap.HitObjects.First().StartTime));
         }
 
         #endregion

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

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Localisation;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Osu.Mods
@@ -9,7 +10,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => "Touch Device";
         public override string Acronym => "TD";
-        public override string Description => "Automatically applied to plays on devices with a touchscreen.";
+        public override LocalisableString Description => "Automatically applied to plays on devices with a touchscreen.";
         public override double ScoreMultiplier => 1;
 
         public override ModType Type => ModType.System;

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

@@ -4,6 +4,7 @@
 using System;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
+using osu.Framework.Localisation;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
@@ -16,7 +17,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Name => "Traceable";
         public override string Acronym => "TC";
         public override ModType Type => ModType.Fun;
-        public override string Description => "Put your faith in the approach circles...";
+        public override LocalisableString Description => "Put your faith in the approach circles...";
         public override double ScoreMultiplier => 1;
 
         public override Type[] IncompatibleMods => new[] { typeof(IHidesApproachCircles) };

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

@@ -4,6 +4,7 @@
 using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
@@ -18,7 +19,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Acronym => "TR";
         public override IconUsage? Icon => FontAwesome.Solid.ArrowsAlt;
         public override ModType Type => ModType.Fun;
-        public override string Description => "Everything rotates. EVERYTHING.";
+        public override LocalisableString Description => "Everything rotates. EVERYTHING.";
         public override double ScoreMultiplier => 1;
         public override Type[] IncompatibleMods => new[] { typeof(OsuModWiggle), typeof(OsuModMagnetised), typeof(OsuModRepel) };
 

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

@@ -5,6 +5,7 @@ using System;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -20,7 +21,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Acronym => "WG";
         public override IconUsage? Icon => FontAwesome.Solid.Certificate;
         public override ModType Type => ModType.Fun;
-        public override string Description => "They just won't stay still...";
+        public override LocalisableString Description => "They just won't stay still...";
         public override double ScoreMultiplier => 1;
         public override Type[] IncompatibleMods => new[] { typeof(OsuModTransform), typeof(OsuModMagnetised), typeof(OsuModRepel) };
 

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

@@ -14,6 +14,7 @@ using osu.Framework.Caching;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Beatmaps.Formats;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
@@ -165,11 +166,15 @@ namespace osu.Game.Rulesets.Osu.Objects
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
 
             TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
+#pragma warning disable 618
+            var legacyDifficultyPoint = DifficultyControlPoint as LegacyBeatmapDecoder.LegacyDifficultyControlPoint;
+#pragma warning restore 618
 
             double scoringDistance = BASE_SCORING_DISTANCE * difficulty.SliderMultiplier * DifficultyControlPoint.SliderVelocity;
+            bool generateTicks = legacyDifficultyPoint?.GenerateTicks ?? true;
 
             Velocity = scoringDistance / timingPoint.BeatLength;
-            TickDistance = scoringDistance / difficulty.SliderTickRate * TickDistanceMultiplier;
+            TickDistance = generateTicks ? (scoringDistance / difficulty.SliderTickRate * TickDistanceMultiplier) : double.PositiveInfinity;
         }
 
         protected override void CreateNestedHitObjects(CancellationToken cancellationToken)

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -3,41 +3,42 @@
 
 #nullable disable
 
-using osu.Game.Beatmaps;
-using osu.Game.Graphics;
-using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Rulesets.Osu.UI;
-using osu.Game.Rulesets.UI;
+using System;
 using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
-using osu.Game.Overlays.Settings;
 using osu.Framework.Input.Bindings;
-using osu.Game.Rulesets.Osu.Edit;
-using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Osu.Replays;
-using osu.Game.Rulesets.Replays.Types;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
+using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Configuration;
 using osu.Game.Rulesets.Osu.Difficulty;
-using osu.Game.Rulesets.Osu.Scoring;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Scoring;
-using osu.Game.Skinning;
-using System;
-using System.Linq;
-using osu.Framework.Extensions.EnumExtensions;
+using osu.Game.Rulesets.Osu.Edit;
 using osu.Game.Rulesets.Osu.Edit.Setup;
+using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Osu.Skinning.Legacy;
 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.UI;
+using osu.Game.Scoring;
 using osu.Game.Screens.Edit.Setup;
 using osu.Game.Screens.Ranking.Statistics;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu
 {
@@ -53,6 +54,8 @@ namespace osu.Game.Rulesets.Osu
 
         public const string SHORT_NAME = "osu";
 
+        public override string RulesetAPIVersionSupported => CURRENT_RULESET_API_VERSION;
+
         public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0) => new[]
         {
             new KeyBinding(InputKey.Z, OsuAction.LeftButton),
@@ -253,7 +256,7 @@ namespace osu.Game.Rulesets.Osu
             };
         }
 
-        public override string GetDisplayNameForHitResult(HitResult result)
+        public override LocalisableString GetDisplayNameForHitResult(HitResult result)
         {
             switch (result)
             {

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

@@ -59,7 +59,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
         private bool rotationTransferred;
 
         [Resolved(canBeNull: true)]
-        private GameplayClock gameplayClock { get; set; }
+        private IGameplayClock gameplayClock { get; set; }
 
         protected override void Update()
         {

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

@@ -11,6 +11,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
 using osu.Game.Rulesets.Osu.UI.Cursor;
 using osu.Game.Screens.Play;
 using osuTK;
@@ -28,7 +29,7 @@ namespace osu.Game.Rulesets.Osu.UI
 
         public override CursorContainer LocalCursor => State.Value == Visibility.Visible ? localCursorContainer : null;
 
-        protected override string Message => "Click the orange cursor to resume";
+        protected override LocalisableString Message => "Click the orange cursor to resume";
 
         [BackgroundDependencyLoader]
         private void load()

osu.Game.Rulesets.Taiko.Tests/Editor/TestSceneTaikoHitObjectComposer.cs

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Taiko.Tests.Editor
         public void Setup() => Schedule(() =>
         {
             BeatDivisor.Value = 8;
-            Clock.Seek(0);
+            EditorClock.Seek(0);
 
             Child = new TestComposer { RelativeSizeAxes = Axes.Both };
         });

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System.Collections.Generic;
 using System.Linq;
 using Humanizer;
@@ -36,7 +34,7 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
             TimeRange = { Value = 5000 },
         };
 
-        private TaikoScoreProcessor scoreProcessor;
+        private TaikoScoreProcessor scoreProcessor = null!;
 
         private IEnumerable<DrawableTaikoMascot> mascots => this.ChildrenOfType<DrawableTaikoMascot>();
 
@@ -65,6 +63,8 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
         [Test]
         public void TestInitialState()
         {
+            AddStep("set beatmap", () => setBeatmap());
+
             AddStep("create mascot", () => SetContents(_ => new DrawableTaikoMascot { RelativeSizeAxes = Axes.Both }));
 
             AddAssert("mascot initially idle", () => allMascotsIn(TaikoMascotAnimationState.Idle));
@@ -89,9 +89,7 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
         [Test]
         public void TestIdleState()
         {
-            AddStep("set beatmap", () => setBeatmap());
-
-            createDrawableRuleset();
+            prepareDrawableRulesetAndBeatmap(false);
 
             assertStateAfterResult(new JudgementResult(new Hit(), new TaikoJudgement()) { Type = HitResult.Great }, TaikoMascotAnimationState.Idle);
             assertStateAfterResult(new JudgementResult(new Hit.StrongNestedHit(), new TaikoStrongJudgement()) { Type = HitResult.IgnoreMiss }, TaikoMascotAnimationState.Idle);
@@ -100,9 +98,7 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
         [Test]
         public void TestKiaiState()
         {
-            AddStep("set beatmap", () => setBeatmap(true));
-
-            createDrawableRuleset();
+            prepareDrawableRulesetAndBeatmap(true);
 
             assertStateAfterResult(new JudgementResult(new Hit(), new TaikoJudgement()) { Type = HitResult.Ok }, TaikoMascotAnimationState.Kiai);
             assertStateAfterResult(new JudgementResult(new Hit(), new TaikoStrongJudgement()) { Type = HitResult.IgnoreMiss }, TaikoMascotAnimationState.Kiai);
@@ -112,9 +108,7 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
         [Test]
         public void TestMissState()
         {
-            AddStep("set beatmap", () => setBeatmap());
-
-            createDrawableRuleset();
+            prepareDrawableRulesetAndBeatmap(false);
 
             assertStateAfterResult(new JudgementResult(new Hit(), new TaikoJudgement()) { Type = HitResult.Great }, TaikoMascotAnimationState.Idle);
             assertStateAfterResult(new JudgementResult(new Hit(), new TaikoJudgement()) { Type = HitResult.Miss }, TaikoMascotAnimationState.Fail);
@@ -126,9 +120,7 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
         [TestCase(false)]
         public void TestClearStateOnComboMilestone(bool kiai)
         {
-            AddStep("set beatmap", () => setBeatmap(kiai));
-
-            createDrawableRuleset();
+            prepareDrawableRulesetAndBeatmap(kiai);
 
             AddRepeatStep("reach 49 combo", () => applyNewResult(new JudgementResult(new Hit(), new TaikoJudgement()) { Type = HitResult.Great }), 49);
 
@@ -139,9 +131,7 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
         [TestCase(false, TaikoMascotAnimationState.Idle)]
         public void TestClearStateOnClearedSwell(bool kiai, TaikoMascotAnimationState expectedStateAfterClear)
         {
-            AddStep("set beatmap", () => setBeatmap(kiai));
-
-            createDrawableRuleset();
+            prepareDrawableRulesetAndBeatmap(kiai);
 
             assertStateAfterResult(new JudgementResult(new Swell(), new TaikoSwellJudgement()) { Type = HitResult.Great }, TaikoMascotAnimationState.Clear);
             AddUntilStep($"state reverts to {expectedStateAfterClear.ToString().ToLowerInvariant()}", () => allMascotsIn(expectedStateAfterClear));
@@ -175,25 +165,27 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
             scoreProcessor.ApplyBeatmap(Beatmap.Value.Beatmap);
         }
 
-        private void createDrawableRuleset()
+        private void prepareDrawableRulesetAndBeatmap(bool kiai)
         {
-            AddUntilStep("wait for beatmap to be loaded", () => Beatmap.Value.Track.IsLoaded);
+            AddStep("set beatmap", () => setBeatmap(kiai));
 
             AddStep("create drawable ruleset", () =>
             {
-                Beatmap.Value.Track.Start();
-
                 SetContents(_ =>
                 {
                     var ruleset = new TaikoRuleset();
                     return new DrawableTaikoRuleset(ruleset, Beatmap.Value.GetPlayableBeatmap(ruleset.RulesetInfo));
                 });
             });
+
+            AddUntilStep("wait for track to be loaded", () => MusicController.TrackLoaded);
+            AddStep("start track", () => MusicController.CurrentTrack.Restart());
+            AddUntilStep("wait for track started", () => MusicController.IsPlaying);
         }
 
         private void assertStateAfterResult(JudgementResult judgementResult, TaikoMascotAnimationState expectedState)
         {
-            TaikoMascotAnimationState[] mascotStates = null;
+            TaikoMascotAnimationState[] mascotStates = null!;
 
             AddStep($"{judgementResult.Type.ToString().ToLowerInvariant()} result for {judgementResult.Judgement.GetType().Name.Humanize(LetterCasing.LowerCase)}",
                 () =>
@@ -204,7 +196,7 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
                     Schedule(() => mascotStates = animatedMascots.Select(mascot => mascot.State.Value).ToArray());
                 });
 
-            AddAssert($"state is {expectedState.ToString().ToLowerInvariant()}", () => mascotStates.All(state => state == expectedState));
+            AddAssert($"state is {expectedState.ToString().ToLowerInvariant()}", () => mascotStates.Distinct(), () => Is.EquivalentTo(new[] { expectedState }));
         }
 
         private void applyNewResult(JudgementResult judgementResult)

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

@@ -16,13 +16,13 @@ namespace osu.Game.Rulesets.Taiko.Tests
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Taiko";
 
-        [TestCase(1.9971301024093662d, 200, "diffcalc-test")]
-        [TestCase(1.9971301024093662d, 200, "diffcalc-test-strong")]
+        [TestCase(3.1098944660126882d, 200, "diffcalc-test")]
+        [TestCase(3.1098944660126882d, 200, "diffcalc-test-strong")]
         public void Test(double expectedStarRating, int expectedMaxCombo, string name)
             => base.Test(expectedStarRating, expectedMaxCombo, name);
 
-        [TestCase(3.1645810961313674d, 200, "diffcalc-test")]
-        [TestCase(3.1645810961313674d, 200, "diffcalc-test-strong")]
+        [TestCase(4.0974106752474251d, 200, "diffcalc-test")]
+        [TestCase(4.0974106752474251d, 200, "diffcalc-test-strong")]
         public void TestClockRateAdjusted(double expectedStarRating, int expectedMaxCombo, string name)
             => Test(expectedStarRating, expectedMaxCombo, name, new TaikoModDoubleTime());
 

osu.Game.Rulesets.Taiko/Difficulty/Evaluators/ColourEvaluator.cs

@@ -0,0 +1,67 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Colour;
+using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Colour.Data;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Evaluators
+{
+    public class ColourEvaluator
+    {
+        /// <summary>
+        /// A sigmoid function. It gives a value between (middle - height/2) and (middle + height/2).
+        /// </summary>
+        /// <param name="val">The input value.</param>
+        /// <param name="center">The center of the sigmoid, where the largest gradient occurs and value is equal to middle.</param>
+        /// <param name="width">The radius of the sigmoid, outside of which values are near the minimum/maximum.</param>
+        /// <param name="middle">The middle of the sigmoid output.</param>
+        /// <param name="height">The height of the sigmoid output. This will be equal to max value - min value.</param>
+        private static double sigmoid(double val, double center, double width, double middle, double height)
+        {
+            double sigmoid = Math.Tanh(Math.E * -(val - center) / width);
+            return sigmoid * (height / 2) + middle;
+        }
+
+        /// <summary>
+        /// Evaluate the difficulty of the first note of a <see cref="MonoStreak"/>.
+        /// </summary>
+        public static double EvaluateDifficultyOf(MonoStreak monoStreak)
+        {
+            return sigmoid(monoStreak.Index, 2, 2, 0.5, 1) * EvaluateDifficultyOf(monoStreak.Parent) * 0.5;
+        }
+
+        /// <summary>
+        /// Evaluate the difficulty of the first note of a <see cref="AlternatingMonoPattern"/>.
+        /// </summary>
+        public static double EvaluateDifficultyOf(AlternatingMonoPattern alternatingMonoPattern)
+        {
+            return sigmoid(alternatingMonoPattern.Index, 2, 2, 0.5, 1) * EvaluateDifficultyOf(alternatingMonoPattern.Parent);
+        }
+
+        /// <summary>
+        /// Evaluate the difficulty of the first note of a <see cref="RepeatingHitPatterns"/>.
+        /// </summary>
+        public static double EvaluateDifficultyOf(RepeatingHitPatterns repeatingHitPattern)
+        {
+            return 2 * (1 - sigmoid(repeatingHitPattern.RepetitionInterval, 2, 2, 0.5, 1));
+        }
+
+        public static double EvaluateDifficultyOf(DifficultyHitObject hitObject)
+        {
+            TaikoDifficultyHitObjectColour colour = ((TaikoDifficultyHitObject)hitObject).Colour;
+            double difficulty = 0.0d;
+
+            if (colour.MonoStreak != null) // Difficulty for MonoStreak
+                difficulty += EvaluateDifficultyOf(colour.MonoStreak);
+            if (colour.AlternatingMonoPattern != null) // Difficulty for AlternatingMonoPattern
+                difficulty += EvaluateDifficultyOf(colour.AlternatingMonoPattern);
+            if (colour.RepeatingHitPattern != null) // Difficulty for RepeatingHitPattern
+                difficulty += EvaluateDifficultyOf(colour.RepeatingHitPattern);
+
+            return difficulty;
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Difficulty/Evaluators/StaminaEvaluator.cs

@@ -0,0 +1,53 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Taiko.Objects;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Evaluators
+{
+    public class StaminaEvaluator
+    {
+        /// <summary>
+        /// Applies a speed bonus dependent on the time since the last hit performed using this key.
+        /// </summary>
+        /// <param name="interval">The interval between the current and previous note hit using the same key.</param>
+        private static double speedBonus(double interval)
+        {
+            // Cap to 600bpm 1/4, 25ms note interval, 50ms key interval
+            // Interval will be capped at a very small value to avoid infinite/negative speed bonuses.
+            // TODO - This is a temporary measure as we need to implement methods of detecting playstyle-abuse of SpeedBonus.
+            interval = Math.Max(interval, 50);
+
+            return 30 / interval;
+        }
+
+        /// <summary>
+        /// Evaluates the minimum mechanical stamina required to play the current object. This is calculated using the
+        /// maximum possible interval between two hits using the same key, by alternating 2 keys for each colour.
+        /// </summary>
+        public static double EvaluateDifficultyOf(DifficultyHitObject current)
+        {
+            if (current.BaseObject is not Hit)
+            {
+                return 0.0;
+            }
+
+            // Find the previous hit object hit by the current key, which is two notes of the same colour prior.
+            TaikoDifficultyHitObject taikoCurrent = (TaikoDifficultyHitObject)current;
+            TaikoDifficultyHitObject? keyPrevious = taikoCurrent.PreviousMono(1);
+
+            if (keyPrevious == null)
+            {
+                // There is no previous hit object hit by the current key
+                return 0.0;
+            }
+
+            double objectStrain = 0.5; // Add a base strain to all objects
+            objectStrain += speedBonus(taikoCurrent.StartTime - keyPrevious.StartTime);
+            return objectStrain;
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/Data/AlternatingMonoPattern.cs

@@ -0,0 +1,53 @@
+// 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;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Colour.Data
+{
+    /// <summary>
+    /// Encodes a list of <see cref="MonoStreak"/>s.
+    /// <see cref="MonoStreak"/>s with the same <see cref="MonoStreak.RunLength"/> are grouped together.
+    /// </summary>
+    public class AlternatingMonoPattern
+    {
+        /// <summary>
+        /// <see cref="MonoStreak"/>s that are grouped together within this <see cref="AlternatingMonoPattern"/>.
+        /// </summary>
+        public readonly List<MonoStreak> MonoStreaks = new List<MonoStreak>();
+
+        /// <summary>
+        /// The parent <see cref="RepeatingHitPatterns"/> that contains this <see cref="AlternatingMonoPattern"/>
+        /// </summary>
+        public RepeatingHitPatterns Parent = null!;
+
+        /// <summary>
+        /// Index of this <see cref="AlternatingMonoPattern"/> within it's parent <see cref="RepeatingHitPatterns"/>
+        /// </summary>
+        public int Index;
+
+        /// <summary>
+        /// The first <see cref="TaikoDifficultyHitObject"/> in this <see cref="AlternatingMonoPattern"/>.
+        /// </summary>
+        public TaikoDifficultyHitObject FirstHitObject => MonoStreaks[0].FirstHitObject;
+
+        /// <summary>
+        /// Determine if this <see cref="AlternatingMonoPattern"/> is a repetition of another <see cref="AlternatingMonoPattern"/>. This
+        /// is a strict comparison and is true if and only if the colour sequence is exactly the same.
+        /// </summary>
+        public bool IsRepetitionOf(AlternatingMonoPattern other)
+        {
+            return HasIdenticalMonoLength(other) &&
+                   other.MonoStreaks.Count == MonoStreaks.Count &&
+                   other.MonoStreaks[0].HitType == MonoStreaks[0].HitType;
+        }
+
+        /// <summary>
+        /// Determine if this <see cref="AlternatingMonoPattern"/> has the same mono length of another <see cref="AlternatingMonoPattern"/>.
+        /// </summary>
+        public bool HasIdenticalMonoLength(AlternatingMonoPattern other)
+        {
+            return other.MonoStreaks[0].RunLength == MonoStreaks[0].RunLength;
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/Data/MonoStreak.cs

@@ -0,0 +1,46 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Taiko.Objects;
+using System.Collections.Generic;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Colour.Data
+{
+    /// <summary>
+    /// Encode colour information for a sequence of <see cref="TaikoDifficultyHitObject"/>s. Consecutive <see cref="TaikoDifficultyHitObject"/>s
+    /// of the same <see cref="Objects.HitType"/> are encoded within the same <see cref="MonoStreak"/>.
+    /// </summary>
+    public class MonoStreak
+    {
+        /// <summary>
+        /// List of <see cref="DifficultyHitObject"/>s that are encoded within this <see cref="MonoStreak"/>.
+        /// </summary>
+        public List<TaikoDifficultyHitObject> HitObjects { get; private set; } = new List<TaikoDifficultyHitObject>();
+
+        /// <summary>
+        /// The parent <see cref="AlternatingMonoPattern"/> that contains this <see cref="MonoStreak"/>
+        /// </summary>
+        public AlternatingMonoPattern Parent = null!;
+
+        /// <summary>
+        /// Index of this <see cref="MonoStreak"/> within it's parent <see cref="AlternatingMonoPattern"/>
+        /// </summary>
+        public int Index;
+
+        /// <summary>
+        /// The first <see cref="TaikoDifficultyHitObject"/> in this <see cref="MonoStreak"/>.
+        /// </summary>
+        public TaikoDifficultyHitObject FirstHitObject => HitObjects[0];
+
+        /// <summary>
+        /// The hit type of all objects encoded within this <see cref="MonoStreak"/>
+        /// </summary>
+        public HitType? HitType => (HitObjects[0].BaseObject as Hit)?.Type;
+
+        /// <summary>
+        /// How long the mono pattern encoded within is
+        /// </summary>
+        public int RunLength => HitObjects.Count;
+    }
+}

osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/Data/RepeatingHitPatterns.cs

@@ -0,0 +1,94 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Colour.Data
+{
+    /// <summary>
+    /// Encodes a list of <see cref="AlternatingMonoPattern"/>s, grouped together by back and forth repetition of the same
+    /// <see cref="AlternatingMonoPattern"/>. Also stores the repetition interval between this and the previous <see cref="RepeatingHitPatterns"/>.
+    /// </summary>
+    public class RepeatingHitPatterns
+    {
+        /// <summary>
+        /// Maximum amount of <see cref="RepeatingHitPatterns"/>s to look back to find a repetition.
+        /// </summary>
+        private const int max_repetition_interval = 16;
+
+        /// <summary>
+        /// The <see cref="AlternatingMonoPattern"/>s that are grouped together within this <see cref="RepeatingHitPatterns"/>.
+        /// </summary>
+        public readonly List<AlternatingMonoPattern> AlternatingMonoPatterns = new List<AlternatingMonoPattern>();
+
+        /// <summary>
+        /// The parent <see cref="TaikoDifficultyHitObject"/> in this <see cref="RepeatingHitPatterns"/>
+        /// </summary>
+        public TaikoDifficultyHitObject FirstHitObject => AlternatingMonoPatterns[0].FirstHitObject;
+
+        /// <summary>
+        /// The previous <see cref="RepeatingHitPatterns"/>. This is used to determine the repetition interval.
+        /// </summary>
+        public readonly RepeatingHitPatterns? Previous;
+
+        /// <summary>
+        /// How many <see cref="RepeatingHitPatterns"/> between the current and previous identical <see cref="RepeatingHitPatterns"/>.
+        /// If no repetition is found this will have a value of <see cref="max_repetition_interval"/> + 1.
+        /// </summary>
+        public int RepetitionInterval { get; private set; } = max_repetition_interval + 1;
+
+        public RepeatingHitPatterns(RepeatingHitPatterns? previous)
+        {
+            Previous = previous;
+        }
+
+        /// <summary>
+        /// Returns true if other is considered a repetition of this pattern. This is true if other's first two payloads
+        /// have identical mono lengths.
+        /// </summary>
+        private bool isRepetitionOf(RepeatingHitPatterns other)
+        {
+            if (AlternatingMonoPatterns.Count != other.AlternatingMonoPatterns.Count) return false;
+
+            for (int i = 0; i < Math.Min(AlternatingMonoPatterns.Count, 2); i++)
+            {
+                if (!AlternatingMonoPatterns[i].HasIdenticalMonoLength(other.AlternatingMonoPatterns[i])) return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Finds the closest previous <see cref="RepeatingHitPatterns"/> that has the identical <see cref="AlternatingMonoPatterns"/>.
+        /// Interval is defined as the amount of <see cref="RepeatingHitPatterns"/> chunks between the current and repeated patterns.
+        /// </summary>
+        public void FindRepetitionInterval()
+        {
+            if (Previous == null)
+            {
+                RepetitionInterval = max_repetition_interval + 1;
+                return;
+            }
+
+            RepeatingHitPatterns? other = Previous;
+            int interval = 1;
+
+            while (interval < max_repetition_interval)
+            {
+                if (isRepetitionOf(other))
+                {
+                    RepetitionInterval = Math.Min(interval, max_repetition_interval);
+                    return;
+                }
+
+                other = other.Previous;
+                if (other == null) break;
+
+                ++interval;
+            }
+
+            RepetitionInterval = max_repetition_interval + 1;
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/TaikoColourDifficultyPreprocessor.cs

@@ -0,0 +1,167 @@
+// 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.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Colour.Data;
+using osu.Game.Rulesets.Taiko.Objects;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Colour
+{
+    /// <summary>
+    /// Utility class to perform various encodings.
+    /// </summary>
+    public static class TaikoColourDifficultyPreprocessor
+    {
+        /// <summary>
+        /// Processes and encodes a list of <see cref="TaikoDifficultyHitObject"/>s into a list of <see cref="TaikoDifficultyHitObjectColour"/>s,
+        /// assigning the appropriate <see cref="TaikoDifficultyHitObjectColour"/>s to each <see cref="TaikoDifficultyHitObject"/>,
+        /// and pre-evaluating colour difficulty of each <see cref="TaikoDifficultyHitObject"/>.
+        /// </summary>
+        public static void ProcessAndAssign(List<DifficultyHitObject> hitObjects)
+        {
+            List<RepeatingHitPatterns> hitPatterns = encode(hitObjects);
+
+            // Assign indexing and encoding data to all relevant objects. Only the first note of each encoding type is
+            // assigned with the relevant encodings.
+            foreach (var repeatingHitPattern in hitPatterns)
+            {
+                repeatingHitPattern.FirstHitObject.Colour.RepeatingHitPattern = repeatingHitPattern;
+
+                // The outermost loop is kept a ForEach loop since it doesn't need index information, and we want to
+                // keep i and j for AlternatingMonoPattern's and MonoStreak's index respectively, to keep it in line with
+                // documentation.
+                for (int i = 0; i < repeatingHitPattern.AlternatingMonoPatterns.Count; ++i)
+                {
+                    AlternatingMonoPattern monoPattern = repeatingHitPattern.AlternatingMonoPatterns[i];
+                    monoPattern.Parent = repeatingHitPattern;
+                    monoPattern.Index = i;
+                    monoPattern.FirstHitObject.Colour.AlternatingMonoPattern = monoPattern;
+
+                    for (int j = 0; j < monoPattern.MonoStreaks.Count; ++j)
+                    {
+                        MonoStreak monoStreak = monoPattern.MonoStreaks[j];
+                        monoStreak.Parent = monoPattern;
+                        monoStreak.Index = j;
+                        monoStreak.FirstHitObject.Colour.MonoStreak = monoStreak;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Encodes a list of <see cref="TaikoDifficultyHitObject"/>s into a list of <see cref="RepeatingHitPatterns"/>s.
+        /// </summary>
+        private static List<RepeatingHitPatterns> encode(List<DifficultyHitObject> data)
+        {
+            List<MonoStreak> monoStreaks = encodeMonoStreak(data);
+            List<AlternatingMonoPattern> alternatingMonoPatterns = encodeAlternatingMonoPattern(monoStreaks);
+            List<RepeatingHitPatterns> repeatingHitPatterns = encodeRepeatingHitPattern(alternatingMonoPatterns);
+
+            return repeatingHitPatterns;
+        }
+
+        /// <summary>
+        /// Encodes a list of <see cref="TaikoDifficultyHitObject"/>s into a list of <see cref="MonoStreak"/>s.
+        /// </summary>
+        private static List<MonoStreak> encodeMonoStreak(List<DifficultyHitObject> data)
+        {
+            List<MonoStreak> monoStreaks = new List<MonoStreak>();
+            MonoStreak? currentMonoStreak = null;
+
+            for (int i = 0; i < data.Count; i++)
+            {
+                TaikoDifficultyHitObject taikoObject = (TaikoDifficultyHitObject)data[i];
+
+                // This ignores all non-note objects, which may or may not be the desired behaviour
+                TaikoDifficultyHitObject? previousObject = taikoObject.PreviousNote(0);
+
+                // If this is the first object in the list or the colour changed, create a new mono streak
+                if (currentMonoStreak == null || previousObject == null || (taikoObject.BaseObject as Hit)?.Type != (previousObject.BaseObject as Hit)?.Type)
+                {
+                    currentMonoStreak = new MonoStreak();
+                    monoStreaks.Add(currentMonoStreak);
+                }
+
+                // Add the current object to the encoded payload.
+                currentMonoStreak.HitObjects.Add(taikoObject);
+            }
+
+            return monoStreaks;
+        }
+
+        /// <summary>
+        /// Encodes a list of <see cref="MonoStreak"/>s into a list of <see cref="AlternatingMonoPattern"/>s.
+        /// </summary>
+        private static List<AlternatingMonoPattern> encodeAlternatingMonoPattern(List<MonoStreak> data)
+        {
+            List<AlternatingMonoPattern> monoPatterns = new List<AlternatingMonoPattern>();
+            AlternatingMonoPattern? currentMonoPattern = null;
+
+            for (int i = 0; i < data.Count; i++)
+            {
+                // Start a new AlternatingMonoPattern if the previous MonoStreak has a different mono length, or if this is the first MonoStreak in the list.
+                if (currentMonoPattern == null || data[i].RunLength != data[i - 1].RunLength)
+                {
+                    currentMonoPattern = new AlternatingMonoPattern();
+                    monoPatterns.Add(currentMonoPattern);
+                }
+
+                // Add the current MonoStreak to the encoded payload.
+                currentMonoPattern.MonoStreaks.Add(data[i]);
+            }
+
+            return monoPatterns;
+        }
+
+        /// <summary>
+        /// Encodes a list of <see cref="AlternatingMonoPattern"/>s into a list of <see cref="RepeatingHitPatterns"/>s.
+        /// </summary>
+        private static List<RepeatingHitPatterns> encodeRepeatingHitPattern(List<AlternatingMonoPattern> data)
+        {
+            List<RepeatingHitPatterns> hitPatterns = new List<RepeatingHitPatterns>();
+            RepeatingHitPatterns? currentHitPattern = null;
+
+            for (int i = 0; i < data.Count; i++)
+            {
+                // Start a new RepeatingHitPattern. AlternatingMonoPatterns that should be grouped together will be handled later within this loop.
+                currentHitPattern = new RepeatingHitPatterns(currentHitPattern);
+
+                // Determine if future AlternatingMonoPatterns should be grouped.
+                bool isCoupled = i < data.Count - 2 && data[i].IsRepetitionOf(data[i + 2]);
+
+                if (!isCoupled)
+                {
+                    // If not, add the current AlternatingMonoPattern to the encoded payload and continue.
+                    currentHitPattern.AlternatingMonoPatterns.Add(data[i]);
+                }
+                else
+                {
+                    // If so, add the current AlternatingMonoPattern to the encoded payload and start repeatedly checking if the
+                    // subsequent AlternatingMonoPatterns should be grouped by increasing i and doing the appropriate isCoupled check.
+                    while (isCoupled)
+                    {
+                        currentHitPattern.AlternatingMonoPatterns.Add(data[i]);
+                        i++;
+                        isCoupled = i < data.Count - 2 && data[i].IsRepetitionOf(data[i + 2]);
+                    }
+
+                    // Skip over viewed data and add the rest to the payload
+                    currentHitPattern.AlternatingMonoPatterns.Add(data[i]);
+                    currentHitPattern.AlternatingMonoPatterns.Add(data[i + 1]);
+                    i++;
+                }
+
+                hitPatterns.Add(currentHitPattern);
+            }
+
+            // Final pass to find repetition intervals
+            for (int i = 0; i < hitPatterns.Count; i++)
+            {
+                hitPatterns[i].FindRepetitionInterval();
+            }
+
+            return hitPatterns;
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/TaikoDifficultyHitObjectColour.cs

@@ -0,0 +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 osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Colour.Data;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Colour
+{
+    /// <summary>
+    /// Stores colour compression information for a <see cref="TaikoDifficultyHitObject"/>.
+    /// </summary>
+    public class TaikoDifficultyHitObjectColour
+    {
+        /// <summary>
+        /// The <see cref="MonoStreak"/> that encodes this note, only present if this is the first note within a <see cref="MonoStreak"/>
+        /// </summary>
+        public MonoStreak? MonoStreak;
+
+        /// <summary>
+        /// The <see cref="AlternatingMonoPattern"/> that encodes this note, only present if this is the first note within a <see cref="AlternatingMonoPattern"/>
+        /// </summary>
+        public AlternatingMonoPattern? AlternatingMonoPattern;
+
+        /// <summary>
+        /// The <see cref="RepeatingHitPattern"/> that encodes this note, only present if this is the first note within a <see cref="RepeatingHitPattern"/>
+        /// </summary>
+        public RepeatingHitPatterns? RepeatingHitPattern;
+    }
+}