Merge pull request #32267 from nekodex/skinnable-star-fountain-sfx

Allow kiai/star-fountain activation SFX to be skinnable
Use SkinnableSound to ensure samples track active skin
2026-05-21 07:09:53 +08:00 · 2025-03-10 00:59:04 +09:00 · 2025-03-09 23:54:44 +09:00 · 2025-03-09 22:49:53 +09:00 · 2025-03-09 22:11:01 +09:00 · 2025-03-09 19:35:07 +09:00
678 changed files with 20703 additions and 6232 deletions
@@ -9,7 +9,7 @@
      ]
    },
    "nvika": {
-      "version": "3.0.0",
+      "version": "4.0.0",
      "commands": [
        "nvika"
      ]
@@ -114,10 +114,7 @@ jobs:
          dotnet-version: "8.0.x"

      - name: Install .NET workloads
-        # since windows image 20241113.3.0, not specifying a version here
-        # installs the .NET 7 version of android workload for very unknown reasons.
-        # revisit once we upgrade to .NET 9, it's probably fixed there.
-        run: dotnet workload install android --version (dotnet --version)
+        run: dotnet workload install android

      - name: Compile
        run: dotnet build -c Debug osu.Android.slnf
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="deploymentTargetSelector">
+    <selectionStates>
+      <SelectionState runConfigName="osu.Android">
+        <option name="selectionMode" value="DROPDOWN" />
+      </SelectionState>
+    </selectionStates>
+  </component>
+</project>
@@ -18,3 +18,6 @@ M:Humanizer.InflectorExtensions.Pascalize(System.String);Humanizer's .Pascalize(
 M:Humanizer.InflectorExtensions.Camelize(System.String);Humanizer's .Camelize() extension method changes behaviour depending on CultureInfo.CurrentCulture. Use StringDehumanizeExtensions.ToCamelCase() instead.
 M:Humanizer.InflectorExtensions.Underscore(System.String);Humanizer's .Underscore() extension method changes behaviour depending on CultureInfo.CurrentCulture. Use StringDehumanizeExtensions.ToSnakeCase() instead.
 M:Humanizer.InflectorExtensions.Kebaberize(System.String);Humanizer's .Kebaberize() extension method changes behaviour depending on CultureInfo.CurrentCulture. Use StringDehumanizeExtensions.ToKebabCase() instead.
+M:osuTK.MathHelper.Clamp(System.Int32,System.Int32,System.Int32)~System.Int32;Use Math.Clamp() instead.
+M:osuTK.MathHelper.Clamp(System.Single,System.Single,System.Single)~System.Single;This osuTK helper has unsafe semantics when one of the bounds provided is NaN. Use Math.Clamp() instead.
+M:osuTK.MathHelper.Clamp(System.Double,System.Double,System.Double)~System.Double;This osuTK helper has unsafe semantics when one of the bounds provided is NaN. Use Math.Clamp() instead.
@@ -51,8 +51,11 @@ dotnet_diagnostic.IDE1006.severity = warning
 # Too many noisy warnings for parsing/formatting numbers
 dotnet_diagnostic.CA1305.severity = none

+# messagepack complains about "osu" not being title cased due to reserved words
+dotnet_diagnostic.CS8981.severity = none
+
 # CA1507: Use nameof to express symbol names
-# Flaggs serialization name attributes
+# Flags serialization name attributes
 dotnet_diagnostic.CA1507.severity = suggestion

 # CA1806: Do not ignore method results
@@ -37,7 +37,7 @@ You can also generally download a version for your current device from the [osu!

 If your platform is unsupported or not listed above, there is still a chance you can run the release or manually build it by following the instructions below.

-**For iOS/iPadOS users**: The iOS testflight link fills up very fast (Apple has a hard limit of 10,000 users). We reset it occasionally. Please do not ask about this. Check back regularly for link resets or follow [peppy](https://twitter.com/ppy) on twitter for announcements. Our goal is to get the game on mobile app stores in early 2024.
+**For iOS/iPadOS users**: The iOS testflight link fills up very fast (Apple has a hard limit of 10,000 users). We reset it occasionally. Please do not ask about this. Check back regularly for link resets or follow [peppy](https://twitter.com/ppy) on twitter for announcements. Our goal is to get the game on mobile app stores very soon so we don't have to live with this limitation.

 ## Developing a custom ruleset

@@ -9,9 +9,9 @@
      <GenerateProgramFile>false</GenerateProgramFile>
    </PropertyGroup>
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
    <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\osu.Game.Rulesets.EmptyFreeform\osu.Game.Rulesets.EmptyFreeform.csproj" />
@@ -14,7 +14,16 @@ namespace osu.Game.Rulesets.EmptyFreeform.Objects

        public Vector2 Position { get; set; }

-        public float X => Position.X;
-        public float Y => Position.Y;
+        public float X
+        {
+            get => Position.X;
+            set => Position = new Vector2(value, Y);
+        }
+
+        public float Y
+        {
+            get => Position.Y;
+            set => Position = new Vector2(X, value);
+        }
    }
 }
@@ -9,9 +9,9 @@
    <GenerateProgramFile>false</GenerateProgramFile>
  </PropertyGroup>
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
    <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj" />
@@ -14,7 +14,16 @@ namespace osu.Game.Rulesets.Pippidon.Objects

        public Vector2 Position { get; set; }

-        public float X => Position.X;
-        public float Y => Position.Y;
+        public float X
+        {
+            get => Position.X;
+            set => Position = new Vector2(value, Y);
+        }
+
+        public float Y
+        {
+            get => Position.Y;
+            set => Position = new Vector2(X, value);
+        }
    }
 }
@@ -9,9 +9,9 @@
    <GenerateProgramFile>false</GenerateProgramFile>
  </PropertyGroup>
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
    <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\osu.Game.Rulesets.EmptyScrolling\osu.Game.Rulesets.EmptyScrolling.csproj" />
@@ -9,9 +9,9 @@
    <GenerateProgramFile>false</GenerateProgramFile>
  </PropertyGroup>
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
    <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj" />
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
@@ -9,7 +10,6 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Pippidon.Objects;
 using osu.Game.Rulesets.Pippidon.UI;
-using osuTK;

 namespace osu.Game.Rulesets.Pippidon.Beatmaps
 {
@@ -40,7 +40,7 @@ namespace osu.Game.Rulesets.Pippidon.Beatmaps
            };
        }

-        private int getLane(HitObject hitObject) => (int)MathHelper.Clamp(
+        private int getLane(HitObject hitObject) => (int)Math.Clamp(
            (getUsablePosition(hitObject) - minPosition) / (maxPosition - minPosition) * PippidonPlayfield.LANE_COUNT, 0, PippidonPlayfield.LANE_COUNT - 1);

        private float getUsablePosition(HitObject h) => (h as IHasYPosition)?.Y ?? ((IHasXPosition)h).X;
@@ -10,7 +10,7 @@
    <EmbedAssembliesIntoApk>true</EmbedAssembliesIntoApk>
  </PropertyGroup>
  <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2024.1224.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2025.225.0" />
  </ItemGroup>
  <PropertyGroup>
    <!-- Fody does not handle Android build well, and warns when unchanged.
@@ -1,34 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using Android.Content.PM;
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Game.Screens.Play;
-
-namespace osu.Android
-{
-    public partial class GameplayScreenRotationLocker : Component
-    {
-        private IBindable<LocalUserPlayingState> localUserPlaying = null!;
-
-        [Resolved]
-        private OsuGameActivity gameActivity { get; set; } = null!;
-
-        [BackgroundDependencyLoader]
-        private void load(ILocalUserPlayInfo localUserPlayInfo)
-        {
-            localUserPlaying = localUserPlayInfo.PlayingState.GetBoundCopy();
-            localUserPlaying.BindValueChanged(updateLock, true);
-        }
-
-        private void updateLock(ValueChangedEvent<LocalUserPlayingState> userPlaying)
-        {
-            gameActivity.RunOnUiThread(() =>
-            {
-                gameActivity.RequestedOrientation = userPlaying.NewValue == LocalUserPlayingState.Playing ? ScreenOrientation.Locked : gameActivity.DefaultOrientation;
-            });
-        }
-    }
-}
@@ -13,7 +13,6 @@ using Android.Graphics;
 using Android.OS;
 using Android.Views;
 using osu.Framework.Android;
-using osu.Framework.Extensions.ObjectExtensions;
 using osu.Game.Database;
 using Debug = System.Diagnostics.Debug;
 using Uri = Android.Net.Uri;
@@ -50,9 +49,25 @@ namespace osu.Android
        /// <remarks>Adjusted on startup to match expected UX for the current device type (phone/tablet).</remarks>
        public ScreenOrientation DefaultOrientation = ScreenOrientation.Unspecified;

-        private OsuGameAndroid game = null!;
+        public new bool IsTablet { get; private set; }

-        protected override Framework.Game CreateGame() => game = new OsuGameAndroid(this);
+        private readonly OsuGameAndroid game;
+
+        private bool gameCreated;
+
+        protected override Framework.Game CreateGame()
+        {
+            if (gameCreated)
+                throw new InvalidOperationException("Framework tried to create a game twice.");
+
+            gameCreated = true;
+            return game;
+        }
+
+        public OsuGameActivity()
+        {
+            game = new OsuGameAndroid(this);
+        }

        protected override void OnCreate(Bundle? savedInstanceState)
        {
@@ -76,9 +91,9 @@ namespace osu.Android
            WindowManager.DefaultDisplay.GetSize(displaySize);
 #pragma warning restore CA1422
            float smallestWidthDp = Math.Min(displaySize.X, displaySize.Y) / Resources.DisplayMetrics.Density;
-            bool isTablet = smallestWidthDp >= 600f;
+            IsTablet = smallestWidthDp >= 600f;

-            RequestedOrientation = DefaultOrientation = isTablet ? ScreenOrientation.FullUser : ScreenOrientation.SensorLandscape;
+            RequestedOrientation = DefaultOrientation = IsTablet ? ScreenOrientation.FullUser : ScreenOrientation.SensorLandscape;

            // Currently (SDK 6.0.200), BundleAssemblies is not runnable for net6-android.
            // The assembly files are not available as files either after native AOT.
@@ -95,25 +110,38 @@ namespace osu.Android

        private void handleIntent(Intent? intent)
        {
-            switch (intent?.Action)
+            if (intent == null)
+                return;
+
+            switch (intent.Action)
            {
                case Intent.ActionDefault:
                    if (intent.Scheme == ContentResolver.SchemeContent)
-                        handleImportFromUris(intent.Data.AsNonNull());
+                    {
+                        if (intent.Data != null)
+                            handleImportFromUris(intent.Data);
+                    }
                    else if (osu_url_schemes.Contains(intent.Scheme))
-                        game.HandleLink(intent.DataString);
+                    {
+                        if (intent.DataString != null)
+                            game.HandleLink(intent.DataString);
+                    }
+
                    break;

                case Intent.ActionSend:
                case Intent.ActionSendMultiple:
                {
+                    if (intent.ClipData == null)
+                        break;
+
                    var uris = new List<Uri>();

-                    for (int i = 0; i < intent.ClipData?.ItemCount; i++)
+                    for (int i = 0; i < intent.ClipData.ItemCount; i++)
                    {
-                        var content = intent.ClipData?.GetItemAt(i);
-                        if (content != null)
-                            uris.Add(content.Uri.AsNonNull());
+                        var item = intent.ClipData.GetItemAt(i);
+                        if (item?.Uri != null)
+                            uris.Add(item.Uri);
                    }

                    handleImportFromUris(uris.ToArray());
@@ -3,13 +3,16 @@

 using System;
 using Android.App;
+using Android.Content.PM;
 using Microsoft.Maui.Devices;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Platform;
 using osu.Game;
+using osu.Game.Screens;
 using osu.Game.Updater;
 using osu.Game.Utils;
+using osuTK;

 namespace osu.Android
 {
@@ -18,6 +21,8 @@ namespace osu.Android
        [Cached]
        private readonly OsuGameActivity gameActivity;

+        public override Vector2 ScalingContainerTargetDrawSize => new Vector2(1024, 1024 * DrawHeight / DrawWidth);
+
        public OsuGameAndroid(OsuGameActivity activity)
            : base(null)
        {
@@ -71,7 +76,35 @@ namespace osu.Android
        protected override void LoadComplete()
        {
            base.LoadComplete();
-            LoadComponentAsync(new GameplayScreenRotationLocker(), Add);
+            UserPlayingState.BindValueChanged(_ => updateOrientation());
+        }
+
+        protected override void ScreenChanged(IOsuScreen? current, IOsuScreen? newScreen)
+        {
+            base.ScreenChanged(current, newScreen);
+
+            if (newScreen != null)
+                updateOrientation();
+        }
+
+        private void updateOrientation()
+        {
+            var orientation = MobileUtils.GetOrientation(this, (IOsuScreen)ScreenStack.CurrentScreen, gameActivity.IsTablet);
+
+            switch (orientation)
+            {
+                case MobileUtils.Orientation.Locked:
+                    gameActivity.RequestedOrientation = ScreenOrientation.Locked;
+                    break;
+
+                case MobileUtils.Orientation.Portrait:
+                    gameActivity.RequestedOrientation = ScreenOrientation.Portrait;
+                    break;
+
+                case MobileUtils.Orientation.Default:
+                    gameActivity.RequestedOrientation = gameActivity.DefaultOrientation;
+                    break;
+            }
        }

        public override void SetHost(GameHost host)
@@ -51,12 +51,9 @@ namespace osu.Desktop
        [Resolved]
        private LocalUserStatisticsProvider statisticsProvider { get; set; } = null!;

-        [Resolved]
-        private OsuConfigManager config { get; set; } = null!;
-
-        private readonly IBindable<UserStatus?> status = new Bindable<UserStatus?>();
-        private readonly IBindable<UserActivity> activity = new Bindable<UserActivity>();
-        private readonly Bindable<DiscordRichPresenceMode> privacyMode = new Bindable<DiscordRichPresenceMode>();
+        private IBindable<DiscordRichPresenceMode> privacyMode = null!;
+        private IBindable<UserStatus> userStatus = null!;
+        private IBindable<UserActivity?> userActivity = null!;

        private readonly RichPresence presence = new RichPresence
        {
@@ -71,8 +68,12 @@ namespace osu.Desktop
        private IBindable<APIUser>? user;

        [BackgroundDependencyLoader]
-        private void load()
+        private void load(OsuConfigManager config, SessionStatics session)
        {
+            privacyMode = config.GetBindable<DiscordRichPresenceMode>(OsuSetting.DiscordRichPresence);
+            userStatus = config.GetBindable<UserStatus>(OsuSetting.UserOnlineStatus);
+            userActivity = session.GetBindable<UserActivity?>(Static.UserOnlineActivity);
+
            client = new DiscordRpcClient(client_id)
            {
                // SkipIdenticalPresence allows us to fire SetPresence at any point and leave it to the underlying implementation
@@ -81,7 +82,7 @@ namespace osu.Desktop
            };

            client.OnReady += onReady;
-            client.OnError += (_, e) => Logger.Log($"An error occurred with Discord RPC Client: {e.Message} ({e.Code})", LoggingTarget.Network, LogLevel.Error);
+            client.OnError += (_, e) => Logger.Log($"An error occurred with Discord RPC Client: {e.Message} ({e.Code})", LoggingTarget.Network);

            try
            {
@@ -105,21 +106,11 @@ namespace osu.Desktop
        {
            base.LoadComplete();

-            config.BindWith(OsuSetting.DiscordRichPresence, privacyMode);
-
            user = api.LocalUser.GetBoundCopy();
-            user.BindValueChanged(u =>
-            {
-                status.UnbindBindings();
-                status.BindTo(u.NewValue.Status);
-
-                activity.UnbindBindings();
-                activity.BindTo(u.NewValue.Activity);
-            }, true);

            ruleset.BindValueChanged(_ => schedulePresenceUpdate());
-            status.BindValueChanged(_ => schedulePresenceUpdate());
-            activity.BindValueChanged(_ => schedulePresenceUpdate());
+            userStatus.BindValueChanged(_ => schedulePresenceUpdate());
+            userActivity.BindValueChanged(_ => schedulePresenceUpdate());
            privacyMode.BindValueChanged(_ => schedulePresenceUpdate());

            multiplayerClient.RoomUpdated += onRoomUpdated;
@@ -151,13 +142,13 @@ namespace osu.Desktop
                if (!client.IsInitialized)
                    return;

-                if (status.Value == UserStatus.Offline || privacyMode.Value == DiscordRichPresenceMode.Off)
+                if (!api.IsLoggedIn || userStatus.Value == UserStatus.Offline || privacyMode.Value == DiscordRichPresenceMode.Off)
                {
                    client.ClearPresence();
                    return;
                }

-                bool hideIdentifiableInformation = privacyMode.Value == DiscordRichPresenceMode.Limited || status.Value == UserStatus.DoNotDisturb;
+                bool hideIdentifiableInformation = privacyMode.Value == DiscordRichPresenceMode.Limited || userStatus.Value == UserStatus.DoNotDisturb;

                updatePresence(hideIdentifiableInformation);
                client.SetPresence(presence);
@@ -170,19 +161,19 @@ namespace osu.Desktop
                return;

            // user activity
-            if (activity.Value != null)
+            if (userActivity.Value != null)
            {
-                presence.State = clampLength(activity.Value.GetStatus(hideIdentifiableInformation));
-                presence.Details = clampLength(activity.Value.GetDetails(hideIdentifiableInformation) ?? string.Empty);
+                presence.State = clampLength(userActivity.Value.GetStatus(hideIdentifiableInformation));
+                presence.Details = clampLength(userActivity.Value.GetDetails(hideIdentifiableInformation) ?? string.Empty);

-                if (activity.Value.GetBeatmapID(hideIdentifiableInformation) is int beatmapId && beatmapId > 0)
+                if (userActivity.Value.GetBeatmapID(hideIdentifiableInformation) is int beatmapId && beatmapId > 0)
                {
                    presence.Buttons = new[]
                    {
                        new Button
                        {
                            Label = "View beatmap",
-                            Url = $@"{api.WebsiteRootUrl}/beatmaps/{beatmapId}?mode={ruleset.Value.ShortName}"
+                            Url = $@"{api.Endpoints.WebsiteUrl}/beatmaps/{beatmapId}?mode={ruleset.Value.ShortName}"
                        }
                    };
                }
@@ -67,7 +67,12 @@ namespace osu.Desktop
            {
                try
                {
-                    stableInstallPath = getStableInstallPathFromRegistry();
+                    stableInstallPath = getStableInstallPathFromRegistry("osustable.File.osz");
+
+                    if (!string.IsNullOrEmpty(stableInstallPath) && checkExists(stableInstallPath))
+                        return stableInstallPath;
+
+                    stableInstallPath = getStableInstallPathFromRegistry("osu!");

                    if (!string.IsNullOrEmpty(stableInstallPath) && checkExists(stableInstallPath))
                        return stableInstallPath;
@@ -89,9 +94,9 @@ namespace osu.Desktop
        }

        [SupportedOSPlatform("windows")]
-        private string? getStableInstallPathFromRegistry()
+        private string? getStableInstallPathFromRegistry(string progId)
        {
-            using (RegistryKey? key = Registry.ClassesRoot.OpenSubKey("osu!"))
+            using (RegistryKey? key = Registry.ClassesRoot.OpenSubKey(progId))
                return key?.OpenSubKey(WindowsAssociationManager.SHELL_OPEN_COMMAND)?.GetValue(string.Empty)?.ToString()?.Split('"')[1].Replace("osu!.exe", "");
        }

@@ -30,8 +30,6 @@ namespace osu.Desktop.Security

        private partial class ElevatedPrivilegesNotification : SimpleNotification
        {
-            public override bool IsImportant => true;
-
            public ElevatedPrivilegesNotification()
            {
                Text = $"Running osu! as {(RuntimeInfo.IsUnix ? "root" : "administrator")} does not improve performance, may break integrations and poses a security risk. Please run the game as a normal user.";
@@ -17,6 +17,7 @@ namespace osu.Desktop.Windows
    public static class WindowsAssociationManager
    {
        private const string software_classes = @"Software\Classes";
+        private const string software_registered_applications = @"Software\RegisteredApplications";

        /// <summary>
        /// Sub key for setting the icon.
@@ -36,7 +37,11 @@ namespace osu.Desktop.Windows
        /// Program ID prefix used for file associations. Should be relatively short since the full program ID has a 39 character limit,
        /// see https://learn.microsoft.com/en-us/windows/win32/com/-progid--key.
        /// </summary>
-        private const string program_id_prefix = "osu.File";
+        private const string program_id_file_prefix = "osu.File";
+
+        private const string program_id_protocol_prefix = "osu.Uri";
+
+        private static readonly ApplicationCapability application_capability = new ApplicationCapability(@"osu", @"Software\ppy\osu\Capabilities", "osu!(lazer)");

        private static readonly FileAssociation[] file_associations =
        {
@@ -56,14 +61,13 @@ namespace osu.Desktop.Windows
        /// Installs file and URI associations.
        /// </summary>
        /// <remarks>
-        /// Call <see cref="UpdateDescriptions"/> in a timely fashion to keep descriptions up-to-date and localised.
+        /// Call <see cref="LocaliseDescriptions"/> in a timely fashion to keep descriptions up-to-date and localised.
        /// </remarks>
        public static void InstallAssociations()
        {
            try
            {
                updateAssociations();
-                updateDescriptions(null); // write default descriptions in case `UpdateDescriptions()` is not called.
                NotifyShellUpdate();
            }
            catch (Exception e)
@@ -76,17 +80,13 @@ namespace osu.Desktop.Windows
        /// Updates associations with latest definitions.
        /// </summary>
        /// <remarks>
-        /// Call <see cref="UpdateDescriptions"/> in a timely fashion to keep descriptions up-to-date and localised.
+        /// Call <see cref="LocaliseDescriptions"/> in a timely fashion to keep descriptions up-to-date and localised.
        /// </remarks>
        public static void UpdateAssociations()
        {
            try
            {
                updateAssociations();
-
-                // TODO: Remove once UpdateDescriptions() is called as specified in the xmldoc.
-                updateDescriptions(null); // always write default descriptions, in case of updating from an older version in which file associations were not implemented/installed
-
                NotifyShellUpdate();
            }
            catch (Exception e)
@@ -95,11 +95,19 @@ namespace osu.Desktop.Windows
            }
        }

-        public static void UpdateDescriptions(LocalisationManager localisationManager)
+        // TODO: call this sometime.
+        public static void LocaliseDescriptions(LocalisationManager localisationManager)
        {
            try
            {
-                updateDescriptions(localisationManager);
+                application_capability.LocaliseDescription(localisationManager);
+
+                foreach (var association in file_associations)
+                    association.LocaliseDescription(localisationManager);
+
+                foreach (var association in uri_associations)
+                    association.LocaliseDescription(localisationManager);
+
                NotifyShellUpdate();
            }
            catch (Exception e)
@@ -112,6 +120,8 @@ namespace osu.Desktop.Windows
        {
            try
            {
+                application_capability.Uninstall();
+
                foreach (var association in file_associations)
                    association.Uninstall();

@@ -133,22 +143,16 @@ namespace osu.Desktop.Windows
        /// </summary>
        private static void updateAssociations()
        {
+            application_capability.Install();
+
            foreach (var association in file_associations)
                association.Install();

            foreach (var association in uri_associations)
                association.Install();
-        }

-        private static void updateDescriptions(LocalisationManager? localisation)
-        {
-            foreach (var association in file_associations)
-                association.UpdateDescription(getLocalisedString(association.Description));
-
-            foreach (var association in uri_associations)
-                association.UpdateDescription(getLocalisedString(association.Description));
-
-            string getLocalisedString(LocalisableString s) => localisation?.GetLocalisedString(s) ?? s.ToString();
+            application_capability.RegisterFileAssociations(file_associations);
+            application_capability.RegisterUriAssociations(uri_associations);
        }

        #region Native interop
@@ -174,9 +178,87 @@ namespace osu.Desktop.Windows

        #endregion

-        private record FileAssociation(string Extension, LocalisableString Description, string IconPath)
+        private class ApplicationCapability
        {
-            private string programId => $@"{program_id_prefix}{Extension}";
+            private string uniqueName { get; }
+            private string capabilityPath { get; }
+            private LocalisableString description { get; }
+
+            public ApplicationCapability(string uniqueName, string capabilityPath, LocalisableString description)
+            {
+                this.uniqueName = uniqueName;
+                this.capabilityPath = capabilityPath;
+                this.description = description;
+            }
+
+            /// <summary>
+            /// Registers an application capability according to <see href="https://learn.microsoft.com/en-us/windows/win32/shell/default-programs#registering-an-application-for-use-with-default-programs">
+            /// Registering an Application for Use with Default Programs</see>.
+            /// </summary>
+            public void Install()
+            {
+                using (var capability = Registry.CurrentUser.CreateSubKey(capabilityPath))
+                {
+                    capability.SetValue(@"ApplicationDescription", description.ToString());
+                }
+
+                using (var registeredApplications = Registry.CurrentUser.OpenSubKey(software_registered_applications, true))
+                    registeredApplications?.SetValue(uniqueName, capabilityPath);
+            }
+
+            public void RegisterFileAssociations(FileAssociation[] associations)
+            {
+                using var capability = Registry.CurrentUser.OpenSubKey(capabilityPath, true);
+                if (capability == null) return;
+
+                using var fileAssociations = capability.CreateSubKey(@"FileAssociations");
+
+                foreach (var association in associations)
+                    fileAssociations.SetValue(association.Extension, association.ProgramId);
+            }
+
+            public void RegisterUriAssociations(UriAssociation[] associations)
+            {
+                using var capability = Registry.CurrentUser.OpenSubKey(capabilityPath, true);
+                if (capability == null) return;
+
+                using var urlAssociations = capability.CreateSubKey(@"UrlAssociations");
+
+                foreach (var association in associations)
+                    urlAssociations.SetValue(association.Protocol, association.ProgramId);
+            }
+
+            public void LocaliseDescription(LocalisationManager localisationManager)
+            {
+                using (var capability = Registry.CurrentUser.OpenSubKey(capabilityPath, true))
+                {
+                    capability?.SetValue(@"ApplicationDescription", localisationManager.GetLocalisedString(description));
+                }
+            }
+
+            public void Uninstall()
+            {
+                using (var registeredApplications = Registry.CurrentUser.OpenSubKey(software_registered_applications, true))
+                    registeredApplications?.DeleteValue(uniqueName, throwOnMissingValue: false);
+
+                Registry.CurrentUser.DeleteSubKeyTree(capabilityPath, throwOnMissingSubKey: false);
+            }
+        }
+
+        private class FileAssociation
+        {
+            public string ProgramId => $@"{program_id_file_prefix}{Extension}";
+
+            public string Extension { get; }
+            private LocalisableString description { get; }
+            private string iconPath { get; }
+
+            public FileAssociation(string extension, LocalisableString description, string iconPath)
+            {
+                Extension = extension;
+                this.description = description;
+                this.iconPath = iconPath;
+            }

            /// <summary>
            /// Installs a file extension association in accordance with https://learn.microsoft.com/en-us/windows/win32/com/-progid--key
@@ -187,10 +269,12 @@ namespace osu.Desktop.Windows
                if (classes == null) return;

                // register a program id for the given extension
-                using (var programKey = classes.CreateSubKey(programId))
+                using (var programKey = classes.CreateSubKey(ProgramId))
                {
+                    programKey.SetValue(null, description.ToString());
+
                    using (var defaultIconKey = programKey.CreateSubKey(default_icon))
-                        defaultIconKey.SetValue(null, IconPath);
+                        defaultIconKey.SetValue(null, iconPath);

                    using (var openCommandKey = programKey.CreateSubKey(SHELL_OPEN_COMMAND))
                        openCommandKey.SetValue(null, $@"""{exe_path}"" ""%1""");
@@ -198,23 +282,25 @@ namespace osu.Desktop.Windows

                using (var extensionKey = classes.CreateSubKey(Extension))
                {
-                    // set ourselves as the default program
-                    extensionKey.SetValue(null, programId);
+                    // Clear out our existing default ProgramID. Default programs in Windows are handled internally by Explorer,
+                    // so having it here is just confusing and may override user preferences.
+                    if (extensionKey.GetValue(null) is string s && s == ProgramId)
+                        extensionKey.SetValue(null, string.Empty);

                    // add to the open with dialog
                    // https://learn.microsoft.com/en-us/windows/win32/shell/how-to-include-an-application-on-the-open-with-dialog-box
                    using (var openWithKey = extensionKey.CreateSubKey(@"OpenWithProgIds"))
-                        openWithKey.SetValue(programId, string.Empty);
+                        openWithKey.SetValue(ProgramId, string.Empty);
                }
            }

-            public void UpdateDescription(string description)
+            public void LocaliseDescription(LocalisationManager localisationManager)
            {
                using var classes = Registry.CurrentUser.OpenSubKey(software_classes, true);
                if (classes == null) return;

-                using (var programKey = classes.OpenSubKey(programId, true))
-                    programKey?.SetValue(null, description);
+                using (var programKey = classes.OpenSubKey(ProgramId, true))
+                    programKey?.SetValue(null, localisationManager.GetLocalisedString(description));
            }

            /// <summary>
@@ -227,26 +313,34 @@ namespace osu.Desktop.Windows

                using (var extensionKey = classes.OpenSubKey(Extension, true))
                {
-                    // clear our default association so that Explorer doesn't show the raw programId to users
-                    // the null/(Default) entry is used for both ProdID association and as a fallback friendly name, for legacy reasons
-                    if (extensionKey?.GetValue(null) is string s && s == programId)
-                        extensionKey.SetValue(null, string.Empty);
-
                    using (var openWithKey = extensionKey?.CreateSubKey(@"OpenWithProgIds"))
-                        openWithKey?.DeleteValue(programId, throwOnMissingValue: false);
+                        openWithKey?.DeleteValue(ProgramId, throwOnMissingValue: false);
                }

-                classes.DeleteSubKeyTree(programId, throwOnMissingSubKey: false);
+                classes.DeleteSubKeyTree(ProgramId, throwOnMissingSubKey: false);
            }
        }

-        private record UriAssociation(string Protocol, LocalisableString Description, string IconPath)
+        private class UriAssociation
        {
            /// <summary>
            /// "The <c>URL Protocol</c> string value indicates that this key declares a custom pluggable protocol handler."
            /// See https://learn.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa767914(v=vs.85).
            /// </summary>
-            public const string URL_PROTOCOL = @"URL Protocol";
+            private const string url_protocol = @"URL Protocol";
+
+            public string Protocol { get; }
+            private LocalisableString description { get; }
+            private string iconPath { get; }
+
+            public UriAssociation(string protocol, LocalisableString description, string iconPath)
+            {
+                Protocol = protocol;
+                this.description = description;
+                this.iconPath = iconPath;
+            }
+
+            public string ProgramId => $@"{program_id_protocol_prefix}.{Protocol}";

            /// <summary>
            /// Registers an URI protocol handler in accordance with https://learn.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa767914(v=vs.85).
@@ -258,29 +352,38 @@ namespace osu.Desktop.Windows

                using (var protocolKey = classes.CreateSubKey(Protocol))
                {
-                    protocolKey.SetValue(URL_PROTOCOL, string.Empty);
+                    protocolKey.SetValue(null, $@"URL:{description}");
+                    protocolKey.SetValue(url_protocol, string.Empty);

-                    using (var defaultIconKey = protocolKey.CreateSubKey(default_icon))
-                        defaultIconKey.SetValue(null, IconPath);
+                    // clear out old data
+                    protocolKey.DeleteSubKeyTree(default_icon, throwOnMissingSubKey: false);
+                    protocolKey.DeleteSubKeyTree(@"Shell", throwOnMissingSubKey: false);
+                }

-                    using (var openCommandKey = protocolKey.CreateSubKey(SHELL_OPEN_COMMAND))
+                // register a program id for the given protocol
+                using (var programKey = classes.CreateSubKey(ProgramId))
+                {
+                    using (var defaultIconKey = programKey.CreateSubKey(default_icon))
+                        defaultIconKey.SetValue(null, iconPath);
+
+                    using (var openCommandKey = programKey.CreateSubKey(SHELL_OPEN_COMMAND))
                        openCommandKey.SetValue(null, $@"""{exe_path}"" ""%1""");
                }
            }

-            public void UpdateDescription(string description)
+            public void LocaliseDescription(LocalisationManager localisationManager)
            {
                using var classes = Registry.CurrentUser.OpenSubKey(software_classes, true);
                if (classes == null) return;

                using (var protocolKey = classes.OpenSubKey(Protocol, true))
-                    protocolKey?.SetValue(null, $@"URL:{description}");
+                    protocolKey?.SetValue(null, $@"URL:{localisationManager.GetLocalisedString(description)}");
            }

            public void Uninstall()
            {
                using var classes = Registry.CurrentUser.OpenSubKey(software_classes, true);
-                classes?.DeleteSubKeyTree(Protocol, throwOnMissingSubKey: false);
+                classes?.DeleteSubKeyTree(ProgramId, throwOnMissingSubKey: false);
            }
        }
    }
@@ -24,9 +24,9 @@
    <ProjectReference Include="..\osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj" />
  </ItemGroup>
  <ItemGroup Label="Package References">
-    <PackageReference Include="System.IO.Packaging" Version="8.0.1" />
+    <PackageReference Include="System.IO.Packaging" Version="9.0.2" />
    <PackageReference Include="DiscordRichPresence" Version="1.2.1.24" />
-    <PackageReference Include="Velopack" Version="0.0.915" />
+    <PackageReference Include="Velopack" Version="0.0.1053" />
  </ItemGroup>
  <ItemGroup Label="Resources">
    <EmbeddedResource Include="lazer.ico" />
@@ -9,7 +9,7 @@
  <ItemGroup>
    <PackageReference Include="BenchmarkDotNet" Version="0.14.0" />
    <PackageReference Include="nunit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
  </ItemGroup>

  <ItemGroup>
@@ -12,7 +12,6 @@ using osu.Framework.Testing;
 using osu.Framework.Timing;
 using osu.Game.Rulesets.Catch.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
-using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
@@ -71,11 +70,11 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
            contentContainer.Playfield.HitObjectContainer.Add(hitObject);
        }

-        protected override SnapResult SnapForBlueprint(HitObjectPlacementBlueprint blueprint)
+        protected override void UpdatePlacementTimeAndPosition()
        {
-            var result = base.SnapForBlueprint(blueprint);
-            result.Time = Math.Round(HitObjectContainer.TimeAtScreenSpacePosition(result.ScreenSpacePosition) / TIME_SNAP) * TIME_SNAP;
-            return result;
+            var position = InputManager.CurrentState.Mouse.Position;
+            double time = Math.Round(HitObjectContainer.TimeAtScreenSpacePosition(position) / TIME_SNAP) * TIME_SNAP;
+            CurrentBlueprint.UpdateTimeAndPosition(position, time);
        }
    }
 }
@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

-#nullable disable
-
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
@@ -21,7 +19,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
 {
    public partial class TestSceneJuiceStreamSelectionBlueprint : CatchSelectionBlueprintTestScene
    {
-        private JuiceStream hitObject;
+        private JuiceStream hitObject = null!;

        private readonly ManualClock manualClock = new ManualClock();

@@ -193,6 +191,17 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
            addVertexCheckStep(1, 0, times[0], positions[0]);
        }

+        [Test]
+        public void TestDeletingSecondVertexDeletesEntireJuiceStream()
+        {
+            double[] times = { 100, 400 };
+            float[] positions = { 100, 150 };
+            addBlueprintStep(times, positions);
+
+            addDeleteVertexSteps(times[1], positions[1]);
+            AddAssert("juice stream deleted", () => EditorBeatmap.HitObjects, () => Is.Empty);
+        }
+
        [Test]
        public void TestVertexResampling()
        {
@@ -1,9 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
  <Import Project="..\osu.TestProject.props" />
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
    <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
  </ItemGroup>
  <PropertyGroup Label="Project">
    <OutputType>WinExe</OutputType>
@@ -14,6 +14,7 @@ using osu.Game.Graphics;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Difficulty;
 using osu.Game.Rulesets.Catch.Edit;
+using osu.Game.Rulesets.Catch.Edit.Setup;
 using osu.Game.Rulesets.Catch.Mods;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Replays;
@@ -228,7 +229,7 @@ namespace osu.Game.Rulesets.Catch
        public override IEnumerable<Drawable> CreateEditorSetupSections() =>
        [
            new MetadataSection(),
-            new DifficultySection(),
+            new CatchDifficultySection(),
            new FillFlowContainer
            {
                AutoSizeAxes = Axes.Y,
@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.

 using System.Collections.Generic;
-using Newtonsoft.Json;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;

@@ -10,15 +9,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 {
    public class CatchDifficultyAttributes : DifficultyAttributes
    {
-        /// <summary>
-        /// The perceived approach rate inclusive of rate-adjusting mods (DT/HT/etc).
-        /// </summary>
-        /// <remarks>
-        /// Rate-adjusting mods don't directly affect the approach rate difficulty value, but have a perceived effect as a result of adjusting audio timing.
-        /// </remarks>
-        [JsonProperty("approach_rate")]
-        public double ApproachRate { get; set; }
-
        public override IEnumerable<(int attributeId, object value)> ToDatabaseAttributes()
        {
            foreach (var v in base.ToDatabaseAttributes())
@@ -26,7 +16,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty

            // Todo: osu!catch should not output star rating in the 'aim' attribute.
            yield return (ATTRIB_ID_AIM, StarRating);
-            yield return (ATTRIB_ID_APPROACH_RATE, ApproachRate);
        }

        public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values, IBeatmapOnlineInfo onlineInfo)
@@ -34,7 +23,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty
            base.FromDatabaseAttributes(values, onlineInfo);

            StarRating = values[ATTRIB_ID_AIM];
-            ApproachRate = values[ATTRIB_ID_APPROACH_RATE];
        }
    }
 }
@@ -3,6 +3,7 @@

 using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Difficulty.Preprocessing;
@@ -23,7 +24,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty

        private float halfCatcherWidth;

-        public override int Version => 20220701;
+        public override int Version => 20250306;

        public CatchDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
            : base(ruleset, beatmap)
@@ -35,14 +36,10 @@ namespace osu.Game.Rulesets.Catch.Difficulty
            if (beatmap.HitObjects.Count == 0)
                return new CatchDifficultyAttributes { Mods = mods };

-            // this is the same as osu!, so there's potential to share the implementation... maybe
-            double preempt = IBeatmapDifficultyInfo.DifficultyRange(beatmap.Difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
-
            CatchDifficultyAttributes attributes = new CatchDifficultyAttributes
            {
-                StarRating = Math.Sqrt(skills[0].DifficultyValue()) * difficulty_multiplier,
+                StarRating = Math.Sqrt(skills.OfType<Movement>().Single().DifficultyValue()) * difficulty_multiplier,
                Mods = mods,
-                ApproachRate = preempt > 1200.0 ? -(preempt - 1800.0) / 120.0 : -(preempt - 1200.0) / 150.0 + 5.0,
                MaxCombo = beatmap.GetMaxCombo(),
            };

@@ -3,6 +3,9 @@

 using System;
 using System.Linq;
+using osu.Framework.Audio.Track;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
@@ -50,7 +53,19 @@ namespace osu.Game.Rulesets.Catch.Difficulty
            if (catchAttributes.MaxCombo > 0)
                value *= Math.Min(Math.Pow(score.MaxCombo, 0.8) / Math.Pow(catchAttributes.MaxCombo, 0.8), 1.0);

-            double approachRate = catchAttributes.ApproachRate;
+            var difficulty = score.BeatmapInfo!.Difficulty.Clone();
+
+            score.Mods.OfType<IApplicableToDifficulty>().ForEach(m => m.ApplyToDifficulty(difficulty));
+
+            var track = new TrackVirtual(10000);
+            score.Mods.OfType<IApplicableToTrack>().ForEach(m => m.ApplyToTrack(track));
+            double clockRate = track.Rate;
+
+            // this is the same as osu!, so there's potential to share the implementation... maybe
+            double preempt = IBeatmapDifficultyInfo.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
+
+            double approachRate = preempt > 1200.0 ? -(preempt - 1800.0) / 120.0 : -(preempt - 1200.0) / 150.0 + 5.0;
+
            double approachRateFactor = 1.0;
            if (approachRate > 9.0)
                approachRateFactor += 0.1 * (approachRate - 9.0); // 10% for each AR above 9
@@ -26,7 +26,9 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills

        private float? lastPlayerPosition;
        private float lastDistanceMoved;
+        private float lastExactDistanceMoved;
        private double lastStrainTime;
+        private bool isInBuzzSection;

        /// <summary>
        /// The speed multiplier applied to the player's catcher.
@@ -59,6 +61,9 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills

            float distanceMoved = playerPosition - lastPlayerPosition.Value;

+            // For the exact position we consider that the catcher is in the correct position for both objects
+            float exactDistanceMoved = catchCurrent.NormalizedPosition - lastPlayerPosition.Value;
+
            double weightedStrainTime = catchCurrent.StrainTime + 13 + (3 / catcherSpeedMultiplier);

            double distanceAddition = (Math.Pow(Math.Abs(distanceMoved), 1.3) / 510);
@@ -92,12 +97,30 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
                    playerPosition = catchCurrent.NormalizedPosition;
                }

-                distanceAddition *= 1.0 + edgeDashBonus * ((20 - catchCurrent.LastObject.DistanceToHyperDash) / 20) * Math.Pow((Math.Min(catchCurrent.StrainTime * catcherSpeedMultiplier, 265) / 265), 1.5); // Edge Dashes are easier at lower ms values
+                distanceAddition *= 1.0 + edgeDashBonus * ((20 - catchCurrent.LastObject.DistanceToHyperDash) / 20)
+                                                        * Math.Pow((Math.Min(catchCurrent.StrainTime * catcherSpeedMultiplier, 265) / 265), 1.5); // Edge Dashes are easier at lower ms values
+            }
+
+            // There is an edge case where horizontal back and forth sliders create "buzz" patterns which are repeated "movements" with a distance lower than
+            // the platter's width but high enough to be considered a movement due to the absolute_player_positioning_error and normalized_hitobject_radius offsets
+            // We are detecting this exact scenario. The first back and forth is counted but all subsequent ones are nullified.
+            // To achieve that, we need to store the exact distances (distance ignoring absolute_player_positioning_error and normalized_hitobject_radius)
+            if (Math.Abs(exactDistanceMoved) <= HalfCatcherWidth * 2 && exactDistanceMoved == -lastExactDistanceMoved && catchCurrent.StrainTime == lastStrainTime)
+            {
+                if (isInBuzzSection)
+                    distanceAddition = 0;
+                else
+                    isInBuzzSection = true;
+            }
+            else
+            {
+                isInBuzzSection = false;
            }

            lastPlayerPosition = playerPosition;
            lastDistanceMoved = distanceMoved;
            lastStrainTime = catchCurrent.StrainTime;
+            lastExactDistanceMoved = exactDistanceMoved;

            return distanceAddition / weightedStrainTime;
        }
@@ -7,6 +7,7 @@ using osu.Framework.Utils;
 using osu.Game.Rulesets.Catch.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Edit;
+using osuTK;
 using osuTK.Input;

 namespace osu.Game.Rulesets.Catch.Edit.Blueprints
@@ -59,11 +60,13 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
            return base.OnMouseDown(e);
        }

-        public override void UpdateTimeAndPosition(SnapResult result)
+        public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, double fallbackTime)
        {
-            base.UpdateTimeAndPosition(result);
+            var result = Composer?.FindSnappedPositionAndTime(screenSpacePosition) ?? new SnapResult(screenSpacePosition, fallbackTime);

-            if (!(result.Time is double time)) return;
+            base.UpdateTimeAndPosition(result.ScreenSpacePosition, result.Time ?? fallbackTime);
+
+            if (!(result.Time is double time)) return result;

            switch (PlacementActive)
            {
@@ -78,6 +81,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints

            HitObject.StartTime = Math.Min(placementStartTime, placementEndTime);
            HitObject.EndTime = Math.Max(placementStartTime, placementEndTime);
+            return result;
        }
    }
 }
@@ -9,7 +9,7 @@ using osu.Game.Rulesets.UI.Scrolling;

 namespace osu.Game.Rulesets.Catch.Edit.Blueprints
 {
-    public partial class CatchPlacementBlueprint<THitObject> : HitObjectPlacementBlueprint
+    public abstract partial class CatchPlacementBlueprint<THitObject> : HitObjectPlacementBlueprint
        where THitObject : CatchHitObject, new()
    {
        protected new THitObject HitObject => (THitObject)base.HitObject;
@@ -19,7 +19,10 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
        [Resolved]
        private Playfield playfield { get; set; } = null!;

-        public CatchPlacementBlueprint()
+        [Resolved]
+        protected CatchHitObjectComposer? Composer { get; private set; }
+
+        protected CatchPlacementBlueprint()
            : base(new THitObject())
        {
        }
@@ -92,7 +92,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints.Components
            }));
        }

-        public void UpdateHitObjectFromPath(JuiceStream hitObject)
+        public virtual void UpdateHitObjectFromPath(JuiceStream hitObject)
        {
            // The SV setting may need to be changed for the current path.
            var svBindable = hitObject.SliderVelocityMultiplierBindable;
@@ -138,5 +138,13 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints.Components

            EditorBeatmap?.EndChange();
        }
+
+        public override void UpdateHitObjectFromPath(JuiceStream hitObject)
+        {
+            base.UpdateHitObjectFromPath(hitObject);
+
+            if (hitObject.Path.ControlPoints.Count <= 1 || !hitObject.Path.HasValidLength)
+                EditorBeatmap?.Remove(hitObject);
+        }
    }
 }
@@ -5,6 +5,7 @@ using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Catch.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Edit;
+using osuTK;
 using osuTK.Input;

 namespace osu.Game.Rulesets.Catch.Edit.Blueprints
@@ -41,11 +42,20 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
            return true;
        }

-        public override void UpdateTimeAndPosition(SnapResult result)
+        public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, double fallbackTime)
        {
-            base.UpdateTimeAndPosition(result);
+            var gridSnapResult = Composer?.FindSnappedPositionAndTime(screenSpacePosition) ?? new SnapResult(screenSpacePosition, fallbackTime);
+            gridSnapResult.ScreenSpacePosition.X = screenSpacePosition.X;
+            var distanceSnapResult = Composer?.TryDistanceSnap(gridSnapResult.ScreenSpacePosition);
+
+            var result = distanceSnapResult != null && Vector2.Distance(gridSnapResult.ScreenSpacePosition, distanceSnapResult.ScreenSpacePosition) < CatchHitObjectComposer.DISTANCE_SNAP_RADIUS
+                ? distanceSnapResult
+                : gridSnapResult;
+
+            base.UpdateTimeAndPosition(result.ScreenSpacePosition, result.Time ?? fallbackTime);

            HitObject.X = ToLocalSpace(result.ScreenSpacePosition).X;
+            return result;
        }
    }
 }
@@ -83,15 +83,22 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
            return base.OnMouseDown(e);
        }

-        public override void UpdateTimeAndPosition(SnapResult result)
+        public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, double fallbackTime)
        {
+            var gridSnapResult = Composer?.FindSnappedPositionAndTime(screenSpacePosition) ?? new SnapResult(screenSpacePosition, fallbackTime);
+            gridSnapResult.ScreenSpacePosition.X = screenSpacePosition.X;
+            var distanceSnapResult = Composer?.TryDistanceSnap(gridSnapResult.ScreenSpacePosition);
+
+            var result = distanceSnapResult != null && Vector2.Distance(gridSnapResult.ScreenSpacePosition, distanceSnapResult.ScreenSpacePosition) < CatchHitObjectComposer.DISTANCE_SNAP_RADIUS
+                ? distanceSnapResult
+                : gridSnapResult;
+
            switch (PlacementActive)
            {
                case PlacementState.Waiting:
-                    if (!(result.Time is double snappedTime)) return;
-
                    HitObject.OriginalX = ToLocalSpace(result.ScreenSpacePosition).X;
-                    HitObject.StartTime = snappedTime;
+                    if (result.Time is double snappedTime)
+                        HitObject.StartTime = snappedTime;
                    break;

                case PlacementState.Active:
@@ -100,28 +107,21 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
                    break;

                default:
-                    return;
+                    return result;
            }

            // Make sure the up-to-date position is used for outlines.
            Vector2 startPosition = CatchHitObjectUtils.GetStartPosition(HitObjectContainer, HitObject);
            editablePath.Position = nestedOutlineContainer.Position = scrollingPath.Position = startPosition;

-            updateHitObjectFromPath();
-        }
+            if (lastEditablePathId != editablePath.PathId)
+                editablePath.UpdateHitObjectFromPath(HitObject);
+            lastEditablePathId = editablePath.PathId;

-        private void updateHitObjectFromPath()
-        {
-            if (lastEditablePathId == editablePath.PathId)
-                return;
-
-            editablePath.UpdateHitObjectFromPath(HitObject);
            ApplyDefaultsToHitObject();
-
            scrollingPath.UpdatePathFrom(HitObjectContainer, HitObject);
            nestedOutlineContainer.UpdateNestedObjectsFrom(HitObjectContainer, HitObject);
-
-            lastEditablePathId = editablePath.PathId;
+            return result;
        }

        private double positionToTime(float relativeYPosition)
@@ -1,16 +1,22 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Catch.Edit.Blueprints;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Screens.Edit.Compose.Components;
+using osuTK;

 namespace osu.Game.Rulesets.Catch.Edit
 {
    public partial class CatchBlueprintContainer : ComposeBlueprintContainer
    {
+        public new CatchHitObjectComposer Composer => (CatchHitObjectComposer)base.Composer;
+
        public CatchBlueprintContainer(CatchHitObjectComposer composer)
            : base(composer)
        {
@@ -36,5 +42,28 @@ namespace osu.Game.Rulesets.Catch.Edit
        }

        protected sealed override DragBox CreateDragBox() => new ScrollingDragBox(Composer.Playfield);
+
+        protected override bool TryMoveBlueprints(DragEvent e, IList<(SelectionBlueprint<HitObject> blueprint, Vector2[] originalSnapPositions)> blueprints)
+        {
+            Vector2 distanceTravelled = e.ScreenSpaceMousePosition - e.ScreenSpaceMouseDownPosition;
+
+            // The final movement position, relative to movementBlueprintOriginalPosition.
+            Vector2 movePosition = blueprints.First().originalSnapPositions.First() + distanceTravelled;
+
+            // Retrieve a snapped position.
+            var gridSnapResult = Composer.FindSnappedPositionAndTime(movePosition);
+            gridSnapResult.ScreenSpacePosition.X = movePosition.X;
+            var distanceSnapResult = Composer.TryDistanceSnap(gridSnapResult.ScreenSpacePosition);
+
+            var result = distanceSnapResult != null && Vector2.Distance(gridSnapResult.ScreenSpacePosition, distanceSnapResult.ScreenSpacePosition) < CatchHitObjectComposer.DISTANCE_SNAP_RADIUS
+                ? distanceSnapResult
+                : gridSnapResult;
+
+            var referenceBlueprint = blueprints.First().blueprint;
+            bool moved = SelectionHandler.HandleMovement(new MoveSelectionEvent<HitObject>(referenceBlueprint, result.ScreenSpacePosition - referenceBlueprint.ScreenSpaceSelectionPoint));
+            if (moved)
+                ApplySnapResultTime(result, referenceBlueprint.Item.StartTime);
+            return moved;
+        }
    }
 }
@@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Catch.Edit
            //
            // The implementation below is probably correct but should be checked if/when exposed via controls.

-            float expectedDistance = DurationToDistance(before, after.StartTime - before.GetEndTime());
+            float expectedDistance = DurationToDistance(after.StartTime - before.GetEndTime(), before.StartTime);

            float previousEndX = (before as JuiceStream)?.EndX ?? ((CatchHitObject)before).EffectiveX;
            float actualDistance = Math.Abs(previousEndX - ((CatchHitObject)after).EffectiveX);
@@ -18,15 +18,15 @@ using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.UI;
-using osu.Game.Screens.Edit.Components.TernaryButtons;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;

 namespace osu.Game.Rulesets.Catch.Edit
 {
+    [Cached]
    public partial class CatchHitObjectComposer : ScrollingHitObjectComposer<CatchHitObject>, IKeyBindingHandler<GlobalAction>
    {
-        private const float distance_snap_radius = 50;
+        public const float DISTANCE_SNAP_RADIUS = 50;

        private CatchDistanceSnapGrid distanceSnapGrid = null!;

@@ -72,7 +72,7 @@ namespace osu.Game.Rulesets.Catch.Edit

        protected override Drawable CreateHitObjectInspector() => new CatchHitObjectInspector(DistanceSnapProvider);

-        protected override IEnumerable<TernaryButton> CreateTernaryButtons()
+        protected override IEnumerable<Drawable> CreateTernaryButtons()
            => base.CreateTernaryButtons()
                   .Concat(DistanceSnapProvider.CreateTernaryButtons());

@@ -136,22 +136,12 @@ namespace osu.Game.Rulesets.Catch.Edit
            DistanceSnapProvider.HandleToggleViaKey(key);
        }

-        public override SnapResult FindSnappedPositionAndTime(Vector2 screenSpacePosition, SnapType snapType = SnapType.All)
+        public SnapResult? TryDistanceSnap(Vector2 screenSpacePosition)
        {
-            var result = base.FindSnappedPositionAndTime(screenSpacePosition, snapType);
+            if (distanceSnapGrid.IsPresent && distanceSnapGrid.GetSnappedPosition(screenSpacePosition) is SnapResult snapResult)
+                return snapResult;

-            result.ScreenSpacePosition.X = screenSpacePosition.X;
-
-            if (snapType.HasFlag(SnapType.RelativeGrids))
-            {
-                if (distanceSnapGrid.IsPresent && distanceSnapGrid.GetSnappedPosition(result.ScreenSpacePosition) is SnapResult snapResult &&
-                    Vector2.Distance(snapResult.ScreenSpacePosition, result.ScreenSpacePosition) < distance_snap_radius)
-                {
-                    result = snapResult;
-                }
-            }
-
-            return result;
+            return null;
        }

        private PalpableCatchHitObject? getLastSnappableHitObject(double time)
@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Objects;
@@ -12,6 +13,7 @@ using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
+using osuTK.Input;
 using Direction = osu.Framework.Graphics.Direction;

 namespace osu.Game.Rulesets.Catch.Edit
@@ -38,6 +40,13 @@ namespace osu.Game.Rulesets.Catch.Edit
                return true;
            }

+            moveSelection(deltaX);
+
+            return true;
+        }
+
+        private void moveSelection(float deltaX)
+        {
            EditorBeatmap.PerformOnSelection(h =>
            {
                if (!(h is CatchHitObject catchObject)) return;
@@ -48,7 +57,60 @@ namespace osu.Game.Rulesets.Catch.Edit
                foreach (var nested in catchObject.NestedHitObjects.OfType<CatchHitObject>())
                    nested.OriginalX += deltaX;
            });
+        }

+        private bool nudgeMovementActive;
+
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            // Until the keys below are global actions, this will prevent conflicts with "seek between sample points"
+            // which has a default of ctrl+shift+arrows.
+            if (e.ShiftPressed)
+                return false;
+
+            if (e.ControlPressed)
+            {
+                switch (e.Key)
+                {
+                    case Key.Left:
+                        return nudgeSelection(-1);
+
+                    case Key.Right:
+                        return nudgeSelection(1);
+                }
+            }
+
+            return false;
+        }
+
+        protected override void OnKeyUp(KeyUpEvent e)
+        {
+            base.OnKeyUp(e);
+
+            if (nudgeMovementActive && !e.ControlPressed)
+            {
+                EditorBeatmap.EndChange();
+                nudgeMovementActive = false;
+            }
+        }
+
+        /// <summary>
+        /// Move the current selection spatially by the specified delta, in gamefield coordinates (ie. the same coordinates as the blueprints).
+        /// </summary>
+        private bool nudgeSelection(float deltaX)
+        {
+            if (!nudgeMovementActive)
+            {
+                nudgeMovementActive = true;
+                EditorBeatmap.BeginChange();
+            }
+
+            var firstBlueprint = SelectedBlueprints.FirstOrDefault();
+
+            if (firstBlueprint == null)
+                return false;
+
+            moveSelection(deltaX);
            return true;
        }

@@ -0,0 +1,125 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Localisation;
+using osu.Game.Resources.Localisation.Web;
+using osu.Game.Screens.Edit.Setup;
+
+namespace osu.Game.Rulesets.Catch.Edit.Setup
+{
+    public partial class CatchDifficultySection : SetupSection
+    {
+        private FormSliderBar<float> circleSizeSlider { get; set; } = null!;
+        private FormSliderBar<float> healthDrainSlider { get; set; } = null!;
+        private FormSliderBar<float> approachRateSlider { get; set; } = null!;
+        private FormSliderBar<double> baseVelocitySlider { get; set; } = null!;
+        private FormSliderBar<double> tickRateSlider { get; set; } = null!;
+
+        public override LocalisableString Title => EditorSetupStrings.DifficultyHeader;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Children = new Drawable[]
+            {
+                circleSizeSlider = new FormSliderBar<float>
+                {
+                    Caption = BeatmapsetsStrings.ShowStatsCs,
+                    HintText = EditorSetupStrings.CircleSizeDescription,
+                    Current = new BindableFloat(Beatmap.Difficulty.CircleSize)
+                    {
+                        Default = BeatmapDifficulty.DEFAULT_DIFFICULTY,
+                        MinValue = 0,
+                        MaxValue = 10,
+                        Precision = 0.1f,
+                    },
+                    TransferValueOnCommit = true,
+                    TabbableContentContainer = this,
+                },
+                healthDrainSlider = new FormSliderBar<float>
+                {
+                    Caption = BeatmapsetsStrings.ShowStatsDrain,
+                    HintText = EditorSetupStrings.DrainRateDescription,
+                    Current = new BindableFloat(Beatmap.Difficulty.DrainRate)
+                    {
+                        Default = BeatmapDifficulty.DEFAULT_DIFFICULTY,
+                        MinValue = 0,
+                        MaxValue = 10,
+                        Precision = 0.1f,
+                    },
+                    TransferValueOnCommit = true,
+                    TabbableContentContainer = this,
+                },
+                approachRateSlider = new FormSliderBar<float>
+                {
+                    Caption = BeatmapsetsStrings.ShowStatsAr,
+                    HintText = EditorSetupStrings.ApproachRateDescription,
+                    Current = new BindableFloat(Beatmap.Difficulty.ApproachRate)
+                    {
+                        Default = BeatmapDifficulty.DEFAULT_DIFFICULTY,
+                        MinValue = 0,
+                        MaxValue = 10,
+                        Precision = 0.1f,
+                    },
+                    TransferValueOnCommit = true,
+                    TabbableContentContainer = this,
+                },
+                baseVelocitySlider = new FormSliderBar<double>
+                {
+                    Caption = EditorSetupStrings.BaseVelocity,
+                    HintText = EditorSetupStrings.BaseVelocityDescription,
+                    Current = new BindableDouble(Beatmap.Difficulty.SliderMultiplier)
+                    {
+                        Default = 1.4,
+                        MinValue = 0.4,
+                        MaxValue = 3.6,
+                        Precision = 0.01f,
+                    },
+                    TransferValueOnCommit = true,
+                    TabbableContentContainer = this,
+                },
+                tickRateSlider = new FormSliderBar<double>
+                {
+                    Caption = EditorSetupStrings.TickRate,
+                    HintText = EditorSetupStrings.TickRateDescription,
+                    Current = new BindableDouble(Beatmap.Difficulty.SliderTickRate)
+                    {
+                        Default = 1,
+                        MinValue = 1,
+                        MaxValue = 4,
+                        Precision = 1,
+                    },
+                    TransferValueOnCommit = true,
+                    TabbableContentContainer = this,
+                },
+            };
+
+            foreach (var item in Children.OfType<FormSliderBar<float>>())
+                item.Current.ValueChanged += _ => updateValues();
+
+            foreach (var item in Children.OfType<FormSliderBar<double>>())
+                item.Current.ValueChanged += _ => updateValues();
+        }
+
+        private void updateValues()
+        {
+            // for now, update these on commit rather than making BeatmapMetadata bindables.
+            // after switching database engines we can reconsider if switching to bindables is a good direction.
+            Beatmap.Difficulty.CircleSize = circleSizeSlider.Current.Value;
+            Beatmap.Difficulty.DrainRate = healthDrainSlider.Current.Value;
+            Beatmap.Difficulty.ApproachRate = approachRateSlider.Current.Value;
+            Beatmap.Difficulty.SliderMultiplier = baseVelocitySlider.Current.Value;
+            Beatmap.Difficulty.SliderTickRate = tickRateSlider.Current.Value;
+
+            Beatmap.UpdateAllHitObjects();
+            Beatmap.SaveState();
+        }
+    }
+}
@@ -159,27 +159,26 @@ namespace osu.Game.Rulesets.Catch.Objects
        {
            // Note that this implementation is shared with the osu! ruleset's implementation.
            // If a change is made here, OsuHitObject.cs should also be updated.
-            ComboIndex = lastObj?.ComboIndex ?? 0;
-            ComboIndexWithOffsets = lastObj?.ComboIndexWithOffsets ?? 0;
-            IndexInCurrentCombo = (lastObj?.IndexInCurrentCombo + 1) ?? 0;
+            int index = lastObj?.ComboIndex ?? 0;
+            int indexWithOffsets = lastObj?.ComboIndexWithOffsets ?? 0;
+            int inCurrentCombo = (lastObj?.IndexInCurrentCombo + 1) ?? 0;

-            if (this is BananaShower)
+            // - For the purpose of combo colours, spinners never start a new combo even if they are flagged as doing so.
+            // - At decode time, the first hitobject in the beatmap and the first hitobject after a banana shower are both enforced to be a new combo,
+            //   but this isn't directly enforced by the editor so the extra checks against the last hitobject are duplicated here.
+            if (this is not BananaShower && (NewCombo || lastObj == null || lastObj is BananaShower))
            {
-                // For the purpose of combo colours, spinners never start a new combo even if they are flagged as doing so.
-                return;
-            }
-
-            // At decode time, the first hitobject in the beatmap and the first hitobject after a banana shower are both enforced to be a new combo,
-            // but this isn't directly enforced by the editor so the extra checks against the last hitobject are duplicated here.
-            if (NewCombo || lastObj == null || lastObj is BananaShower)
-            {
-                IndexInCurrentCombo = 0;
-                ComboIndex++;
-                ComboIndexWithOffsets += ComboOffset + 1;
+                inCurrentCombo = 0;
+                index++;
+                indexWithOffsets += ComboOffset + 1;

                if (lastObj != null)
                    lastObj.LastInCombo = true;
            }
+
+            ComboIndex = index;
+            ComboIndexWithOffsets = indexWithOffsets;
+            IndexInCurrentCombo = inCurrentCombo;
        }

        protected override HitWindows CreateHitWindows() => HitWindows.Empty;
@@ -210,11 +209,27 @@ namespace osu.Game.Rulesets.Catch.Objects
        /// </summary>
        public float LegacyConvertedY { get; set; } = DEFAULT_LEGACY_CONVERT_Y;

-        float IHasXPosition.X => OriginalX;
+        float IHasXPosition.X
+        {
+            get => OriginalX;
+            set => OriginalX = value;
+        }

-        float IHasYPosition.Y => LegacyConvertedY;
+        float IHasYPosition.Y
+        {
+            get => LegacyConvertedY;
+            set => LegacyConvertedY = value;
+        }

-        Vector2 IHasPosition.Position => new Vector2(OriginalX, LegacyConvertedY);
+        Vector2 IHasPosition.Position
+        {
+            get => new Vector2(OriginalX, LegacyConvertedY);
+            set
+            {
+                ((IHasXPosition)this).X = value.X;
+                ((IHasYPosition)this).Y = value.Y;
+            }
+        }

        #endregion
    }
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using System;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
@@ -110,7 +111,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Argon

            double duration = ObjectState.HitObject.StartTime - ObjectState.DisplayStartTime;

-            fadeContent.Alpha = MathHelper.Clamp(
+            fadeContent.Alpha = Math.Clamp(
                Interpolation.ValueAt(
                    Time.Current, 1f, 0f,
                    ObjectState.DisplayStartTime + duration * lens_flare_start,
@@ -4,6 +4,7 @@
 using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Game.Screens.Play.HUD;
 using osu.Game.Skinning;
 using osuTK;
 using osuTK.Graphics;
@@ -47,6 +48,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
                            return new DefaultSkinComponentsContainer(container =>
                            {
                                var keyCounter = container.OfType<LegacyKeyCounterDisplay>().FirstOrDefault();
+                                var spectatorList = container.OfType<SpectatorList>().FirstOrDefault();

                                if (keyCounter != null)
                                {
@@ -55,11 +57,19 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
                                    keyCounter.Origin = Anchor.TopRight;
                                    keyCounter.Position = new Vector2(0, -40) * 1.6f;
                                }
+
+                                if (spectatorList != null)
+                                {
+                                    spectatorList.Anchor = Anchor.BottomLeft;
+                                    spectatorList.Origin = Anchor.BottomLeft;
+                                    spectatorList.Position = new Vector2(10, -10);
+                                }
                            })
                            {
                                Children = new Drawable[]
                                {
                                    new LegacyKeyCounterDisplay(),
+                                    new SpectatorList(),
                                }
                            };
                    }
@@ -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.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.UI;
@@ -15,6 +16,8 @@ namespace osu.Game.Rulesets.Catch.UI
        protected override Container<Drawable> Content => content;
        private readonly Container content;

+        private readonly Container scaleContainer;
+
        public CatchPlayfieldAdjustmentContainer()
        {
            const float base_game_width = 1024f;
@@ -26,30 +29,49 @@ namespace osu.Game.Rulesets.Catch.UI
            Anchor = Anchor.Centre;
            Origin = Anchor.Centre;

-            InternalChild = new Container
+            InternalChild = scaleContainer = new Container
            {
-                // This container limits vertical visibility of the playfield to ensure fairness between wide and tall resolutions (i.e. tall resolutions should not see more fruits).
-                // Note that the container still extends across the screen horizontally, so that hit explosions at the sides of the playfield do not get cut off.
-                Name = "Visible area",
                Anchor = Anchor.Centre,
                Origin = Anchor.Centre,
-                RelativeSizeAxes = Axes.X,
-                Height = base_game_height + extra_bottom_space,
-                Y = extra_bottom_space / 2,
-                Masking = true,
+                RelativeSizeAxes = Axes.Both,
                Child = new Container
                {
-                    Name = "Playable area",
-                    Anchor = Anchor.TopCentre,
-                    Origin = Anchor.TopCentre,
-                    // playfields in stable are positioned vertically at three fourths the difference between the playfield height and the window height in stable.
-                    Y = base_game_height * ((1 - playfield_size_adjust) / 4 * 3),
-                    Size = new Vector2(base_game_width, base_game_height) * playfield_size_adjust,
-                    Child = content = new ScalingContainer { RelativeSizeAxes = Axes.Both }
-                },
+                    // This container limits vertical visibility of the playfield to ensure fairness between wide and tall resolutions (i.e. tall resolutions should not see more fruits).
+                    // Note that the container still extends across the screen horizontally, so that hit explosions at the sides of the playfield do not get cut off.
+                    Name = "Visible area",
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.X,
+                    Height = base_game_height + extra_bottom_space,
+                    Y = extra_bottom_space / 2,
+                    Masking = true,
+                    Child = new Container
+                    {
+                        Name = "Playable area",
+                        Anchor = Anchor.TopCentre,
+                        Origin = Anchor.TopCentre,
+                        // playfields in stable are positioned vertically at three fourths the difference between the playfield height and the window height in stable.
+                        Y = base_game_height * ((1 - playfield_size_adjust) / 4 * 3),
+                        Size = new Vector2(base_game_width, base_game_height) * playfield_size_adjust,
+                        Child = content = new ScalingContainer { RelativeSizeAxes = Axes.Both }
+                    },
+                }
            };
        }

+        [BackgroundDependencyLoader]
+        private void load(OsuGame? osuGame)
+        {
+            if (osuGame != null)
+            {
+                // on mobile platforms where the base aspect ratio is wider, the catch playfield
+                // needs to be scaled down to remain playable.
+                const float base_aspect_ratio = 1024f / 768f;
+                float aspectRatio = osuGame.ScalingContainerTargetDrawSize.X / osuGame.ScalingContainerTargetDrawSize.Y;
+                scaleContainer.Scale = new Vector2(base_aspect_ratio / aspectRatio);
+            }
+        }
+
        /// <summary>
        /// A <see cref="Container"/> which scales its content relative to a target width.
        /// </summary>
@@ -9,7 +9,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Timing;
-using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.UI;
@@ -47,12 +46,11 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
            });
        }

-        protected override SnapResult SnapForBlueprint(HitObjectPlacementBlueprint blueprint)
+        protected override void UpdatePlacementTimeAndPosition()
        {
            double time = column.TimeAtScreenSpacePosition(InputManager.CurrentState.Mouse.Position);
            var pos = column.ScreenSpacePositionAtTime(time);
-
-            return new SnapResult(pos, time, column);
+            CurrentBlueprint.UpdateTimeAndPosition(pos, time);
        }

        protected override Container CreateHitObjectContainer() => new ScrollingTestContainer(ScrollingDirection.Down) { RelativeSizeAxes = Axes.Both };
@@ -20,7 +20,6 @@ using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Compose.Components;
 using osu.Game.Tests.Visual;
-using osuTK;

 namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
@@ -100,10 +99,5 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
        {
            set => InternalChild = value;
        }
-
-        public override SnapResult FindSnappedPositionAndTime(Vector2 screenSpacePosition, SnapType snapType = SnapType.All)
-        {
-            throw new NotImplementedException();
-        }
    }
 }
@@ -29,7 +29,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
            {
                keyCount.Current.Value = 8;
            });
-            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().SingleOrDefault()?.CurrentDialog, Is.InstanceOf<ReloadEditorDialog>);
+            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().SingleOrDefault()?.CurrentDialog, Is.InstanceOf<SaveAndReloadEditorDialog>);
            AddStep("refuse", () => InputManager.Key(Key.Number2));
            AddAssert("key count is 5", () => keyCount.Current.Value, () => Is.EqualTo(5));

@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
            {
                keyCount.Current.Value = 8;
            });
-            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().Single().CurrentDialog, Is.InstanceOf<ReloadEditorDialog>);
+            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().Single().CurrentDialog, Is.InstanceOf<SaveAndReloadEditorDialog>);
            AddStep("acquiesce", () => InputManager.Key(Key.Number1));
            AddUntilStep("beatmap became 8K", () => Game.Beatmap.Value.BeatmapInfo.Difficulty.CircleSize, () => Is.EqualTo(8));
        }
@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
        {
            CreateModTest(new ModTestData
            {
-                Mod = new ManiaModHidden(),
+                Mod = new ManiaModFadeIn(),
                PassCondition = () => checkCoverage(ManiaModHidden.MIN_COVERAGE)
            });
        }
@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
        {
            CreateModTest(new ModTestData
            {
-                Mod = new ManiaModHidden(),
+                Mod = new ManiaModFadeIn(),
                PassCondition = () => checkCoverage(ManiaModHidden.MIN_COVERAGE)
            });

@@ -48,7 +48,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
        {
            CreateModTest(new ModTestData
            {
-                Mod = new ManiaModHidden(),
+                Mod = new ManiaModFadeIn(),
                PassCondition = () => checkCoverage(ManiaModHidden.MAX_COVERAGE)
            });

@@ -60,7 +60,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
        {
            CreateModTest(new ModTestData
            {
-                Mod = new ManiaModHidden(),
+                Mod = new ManiaModFadeIn(),
                PassCondition = () => checkCoverage(ManiaModHidden.MAX_COVERAGE)
            });

@@ -73,7 +73,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
        {
            CreateModTest(new ModTestData
            {
-                Mod = new ManiaModHidden(),
+                Mod = new ManiaModFadeIn(),
                CreateBeatmap = () => new Beatmap
                {
                    HitObjects = Enumerable.Range(1, 100).Select(i => (HitObject)new Note { StartTime = 1000 + 200 * i }).ToList(),
@@ -28,18 +28,20 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
                    {
                        RelativeSizeAxes = Axes.Both,
                        Width = 0.5f,
-                        Child = new ColumnHitObjectArea(new HitObjectContainer())
+                        Child = new ColumnHitObjectArea
                        {
-                            RelativeSizeAxes = Axes.Both
+                            RelativeSizeAxes = Axes.Both,
+                            Child = new HitObjectContainer(),
                        }
                    },
                    new ColumnTestContainer(1, ManiaAction.Key2)
                    {
                        RelativeSizeAxes = Axes.Both,
                        Width = 0.5f,
-                        Child = new ColumnHitObjectArea(new HitObjectContainer())
+                        Child = new ColumnHitObjectArea
                        {
-                            RelativeSizeAxes = Axes.Both
+                            RelativeSizeAxes = Axes.Both,
+                            Child = new HitObjectContainer(),
                        }
                    }
                }
@@ -0,0 +1,68 @@
+// 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.Input;
+using osu.Framework.Testing;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public partial class TestSceneManiaTouchInput : PlayerTestScene
+    {
+        protected override Ruleset CreatePlayerRuleset() => new ManiaRuleset();
+
+        [Test]
+        public void TestTouchInput()
+        {
+            for (int i = 0; i < 4; i++)
+            {
+                int index = i;
+
+                AddStep($"touch column {index}", () => InputManager.BeginTouch(new Touch(TouchSource.Touch1, getColumn(index).ScreenSpaceDrawQuad.Centre)));
+
+                AddAssert("action sent",
+                    () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                    () => Does.Contain(getColumn(index).Action.Value));
+
+                AddStep($"release column {index}", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, getColumn(index).ScreenSpaceDrawQuad.Centre)));
+
+                AddAssert("action released",
+                    () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                    () => Does.Not.Contain(getColumn(index).Action.Value));
+            }
+        }
+
+        [Test]
+        public void TestOneColumnMultipleTouches()
+        {
+            AddStep("touch column 0", () => InputManager.BeginTouch(new Touch(TouchSource.Touch1, getColumn(0).ScreenSpaceDrawQuad.Centre)));
+
+            AddAssert("action sent",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Contain(getColumn(0).Action.Value));
+
+            AddStep("touch another finger", () => InputManager.BeginTouch(new Touch(TouchSource.Touch2, getColumn(0).ScreenSpaceDrawQuad.Centre)));
+
+            AddAssert("action still pressed",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Contain(getColumn(0).Action.Value));
+
+            AddStep("release first finger", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, getColumn(0).ScreenSpaceDrawQuad.Centre)));
+
+            AddAssert("action still pressed",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Contain(getColumn(0).Action.Value));
+
+            AddStep("release second finger", () => InputManager.EndTouch(new Touch(TouchSource.Touch2, getColumn(0).ScreenSpaceDrawQuad.Centre)));
+
+            AddAssert("action released",
+                () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
+                () => Does.Not.Contain(getColumn(0).Action.Value));
+        }
+
+        private Column getColumn(int index) => this.ChildrenOfType<Column>().ElementAt(index);
+    }
+}
@@ -1,49 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Linq;
-using NUnit.Framework;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Input;
-using osu.Framework.Testing;
-using osu.Game.Rulesets.Mania.UI;
-using osu.Game.Tests.Visual;
-
-namespace osu.Game.Rulesets.Mania.Tests
-{
-    public partial class TestSceneManiaTouchInputArea : PlayerTestScene
-    {
-        protected override Ruleset CreatePlayerRuleset() => new ManiaRuleset();
-
-        [Test]
-        public void TestTouchAreaNotInitiallyVisible()
-        {
-            AddAssert("touch area not visible", () => getTouchOverlay()?.State.Value == Visibility.Hidden);
-        }
-
-        [Test]
-        public void TestPressReceptors()
-        {
-            AddAssert("touch area not visible", () => getTouchOverlay()?.State.Value == Visibility.Hidden);
-
-            for (int i = 0; i < 4; i++)
-            {
-                int index = i;
-
-                AddStep($"touch receptor {index}", () => InputManager.BeginTouch(new Touch(TouchSource.Touch1, getReceptor(index).ScreenSpaceDrawQuad.Centre)));
-
-                AddAssert("action sent",
-                    () => this.ChildrenOfType<ManiaInputManager>().SelectMany(m => m.KeyBindingContainer.PressedActions),
-                    () => Does.Contain(getReceptor(index).Action.Value));
-
-                AddStep($"release receptor {index}", () => InputManager.EndTouch(new Touch(TouchSource.Touch1, getReceptor(index).ScreenSpaceDrawQuad.Centre)));
-
-                AddAssert("touch area visible", () => getTouchOverlay()?.State.Value == Visibility.Visible);
-            }
-        }
-
-        private ManiaTouchInputArea? getTouchOverlay() => this.ChildrenOfType<ManiaTouchInputArea>().SingleOrDefault();
-
-        private ManiaTouchInputArea.ColumnInputReceptor getReceptor(int index) => this.ChildrenOfType<ManiaTouchInputArea.ColumnInputReceptor>().ElementAt(index);
-    }
-}
@@ -1,9 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
  <Import Project="..\osu.TestProject.props" />
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
    <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
  </ItemGroup>
  <PropertyGroup Label="Project">
    <OutputType>WinExe</OutputType>
@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.

 using System.Collections.Generic;
-using Newtonsoft.Json;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;

@@ -10,22 +9,12 @@ namespace osu.Game.Rulesets.Mania.Difficulty
 {
    public class ManiaDifficultyAttributes : DifficultyAttributes
    {
-        /// <summary>
-        /// The hit window for a GREAT hit inclusive of rate-adjusting mods (DT/HT/etc).
-        /// </summary>
-        /// <remarks>
-        /// Rate-adjusting mods do not affect the hit window at all in osu-stable.
-        /// </remarks>
-        [JsonProperty("great_hit_window")]
-        public double GreatHitWindow { get; set; }
-
        public override IEnumerable<(int attributeId, object value)> ToDatabaseAttributes()
        {
            foreach (var v in base.ToDatabaseAttributes())
                yield return v;

            yield return (ATTRIB_ID_DIFFICULTY, StarRating);
-            yield return (ATTRIB_ID_GREAT_HIT_WINDOW, GreatHitWindow);
        }

        public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values, IBeatmapOnlineInfo onlineInfo)
@@ -33,7 +22,6 @@ namespace osu.Game.Rulesets.Mania.Difficulty
            base.FromDatabaseAttributes(values, onlineInfo);

            StarRating = values[ATTRIB_ID_DIFFICULTY];
-            GreatHitWindow = values[ATTRIB_ID_GREAT_HIT_WINDOW];
        }
    }
 }
@@ -27,7 +27,6 @@ namespace osu.Game.Rulesets.Mania.Difficulty
        private const double difficulty_multiplier = 0.018;

        private readonly bool isForCurrentRuleset;
-        private readonly double originalOverallDifficulty;

        public override int Version => 20241007;

@@ -35,7 +34,6 @@ namespace osu.Game.Rulesets.Mania.Difficulty
            : base(ruleset, beatmap)
        {
            isForCurrentRuleset = beatmap.BeatmapInfo.Ruleset.MatchesOnlineID(ruleset);
-            originalOverallDifficulty = beatmap.BeatmapInfo.Difficulty.OverallDifficulty;
        }

        protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
@@ -48,11 +46,8 @@ namespace osu.Game.Rulesets.Mania.Difficulty

            ManiaDifficultyAttributes attributes = new ManiaDifficultyAttributes
            {
-                StarRating = skills[0].DifficultyValue() * difficulty_multiplier,
+                StarRating = skills.OfType<Strain>().Single().DifficultyValue() * difficulty_multiplier,
                Mods = mods,
-                // In osu-stable mania, rate-adjustment mods don't affect the hit window.
-                // This is done the way it is to introduce fractional differences in order to match osu-stable for the time being.
-                GreatHitWindow = Math.Ceiling((int)(getHitWindow300(mods) * clockRate) / clockRate),
                MaxCombo = beatmap.HitObjects.Sum(maxComboForObject),
            };

@@ -124,29 +119,5 @@ namespace osu.Game.Rulesets.Mania.Difficulty
                }).ToArray();
            }
        }
-
-        private double getHitWindow300(Mod[] mods)
-        {
-            if (isForCurrentRuleset)
-            {
-                double od = Math.Min(10.0, Math.Max(0, 10.0 - originalOverallDifficulty));
-                return applyModAdjustments(34 + 3 * od, mods);
-            }
-
-            if (Math.Round(originalOverallDifficulty) > 4)
-                return applyModAdjustments(34, mods);
-
-            return applyModAdjustments(47, mods);
-
-            static double applyModAdjustments(double value, Mod[] mods)
-            {
-                if (mods.Any(m => m is ManiaModHardRock))
-                    value /= 1.4;
-                else if (mods.Any(m => m is ManiaModEasy))
-                    value *= 1.4;
-
-                return value;
-            }
-        }
    }
 }
@@ -98,9 +98,9 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints

        private double originalStartTime;

-        public override void UpdateTimeAndPosition(SnapResult result)
+        public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, double fallbackTime)
        {
-            base.UpdateTimeAndPosition(result);
+            var result = base.UpdateTimeAndPosition(screenSpacePosition, fallbackTime);

            if (PlacementActive == PlacementState.Active)
            {
@@ -121,6 +121,8 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
                if (result.Time is double startTime)
                    originalStartTime = HitObject.StartTime = startTime;
            }
+
+            return result;
        }
    }
 }
@@ -5,7 +5,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Primitives;
-using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
@@ -24,7 +23,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
        private EditorBeatmap? editorBeatmap { get; set; }

        [Resolved]
-        private IPositionSnapProvider? positionSnapProvider { get; set; }
+        private ManiaHitObjectComposer? positionSnapProvider { get; set; }

        private EditBodyPiece body = null!;
        private EditHoldNoteEndPiece head = null!;
@@ -1,8 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

-#nullable disable
-
+using System;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Edit;
@@ -20,13 +20,18 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
    {
        protected new T HitObject => (T)base.HitObject;

-        private Column column;
+        [Resolved]
+        private ManiaHitObjectComposer? composer { get; set; }

-        public Column Column
+        private Column? column;
+
+        public Column? Column
        {
            get => column;
            set
            {
+                ArgumentNullException.ThrowIfNull(value);
+
                if (value == column)
                    return;

@@ -53,9 +58,11 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
            return true;
        }

-        public override void UpdateTimeAndPosition(SnapResult result)
+        public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, double fallbackTime)
        {
-            base.UpdateTimeAndPosition(result);
+            var result = composer?.FindSnappedPositionAndTime(screenSpacePosition) ?? new SnapResult(screenSpacePosition, fallbackTime);
+
+            base.UpdateTimeAndPosition(result.ScreenSpacePosition, result.Time ?? fallbackTime);

            if (result.Playfield is Column col)
            {
@@ -76,6 +83,8 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
                if (PlacementActive == PlacementState.Waiting)
                    Column = col;
            }
+
+            return result;
        }

        private float getNoteHeight(Column resultPlayfield) =>
@@ -8,6 +8,7 @@ using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Objects;
+using osuTK;
 using osuTK.Input;

 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
@@ -35,15 +36,17 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
            };
        }

-        public override void UpdateTimeAndPosition(SnapResult result)
+        public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, double referenceTime)
        {
-            base.UpdateTimeAndPosition(result);
+            var result = base.UpdateTimeAndPosition(screenSpacePosition, referenceTime);

            if (result.Playfield != null)
            {
                piece.Width = result.Playfield.DrawWidth;
                piece.Position = ToLocalSpace(result.ScreenSpacePosition);
            }
+
+            return result;
        }

        protected override bool OnMouseDown(MouseDownEvent e)
@@ -1,17 +1,23 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Edit.Blueprints;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Screens.Edit.Compose.Components;
+using osuTK;

 namespace osu.Game.Rulesets.Mania.Edit
 {
    public partial class ManiaBlueprintContainer : ComposeBlueprintContainer
    {
-        public ManiaBlueprintContainer(HitObjectComposer composer)
+        public new ManiaHitObjectComposer Composer => (ManiaHitObjectComposer)base.Composer;
+
+        public ManiaBlueprintContainer(ManiaHitObjectComposer composer)
            : base(composer)
        {
        }
@@ -33,5 +39,22 @@ namespace osu.Game.Rulesets.Mania.Edit
        protected override SelectionHandler<HitObject> CreateSelectionHandler() => new ManiaSelectionHandler();

        protected sealed override DragBox CreateDragBox() => new ScrollingDragBox(Composer.Playfield);
+
+        protected override bool TryMoveBlueprints(DragEvent e, IList<(SelectionBlueprint<HitObject> blueprint, Vector2[] originalSnapPositions)> blueprints)
+        {
+            Vector2 distanceTravelled = e.ScreenSpaceMousePosition - e.ScreenSpaceMouseDownPosition;
+
+            // The final movement position, relative to movementBlueprintOriginalPosition.
+            Vector2 movePosition = blueprints.First().originalSnapPositions.First() + distanceTravelled;
+
+            // Retrieve a snapped position.
+            var result = Composer.FindSnappedPositionAndTime(movePosition);
+
+            var referenceBlueprint = blueprints.First().blueprint;
+            bool moved = SelectionHandler.HandleMovement(new MoveSelectionEvent<HitObject>(referenceBlueprint, result.ScreenSpacePosition - referenceBlueprint.ScreenSpaceSelectionPoint));
+            if (moved)
+                ApplySnapResultTime(result, referenceBlueprint.Item.StartTime);
+            return moved;
+        }
    }
 }
@@ -19,6 +19,7 @@ using osuTK;

 namespace osu.Game.Rulesets.Mania.Edit
 {
+    [Cached]
    public partial class ManiaHitObjectComposer : ScrollingHitObjectComposer<ManiaHitObject>
    {
        private DrawableManiaEditorRuleset drawableRuleset = null!;
@@ -64,11 +65,11 @@ namespace osu.Game.Rulesets.Mania.Edit
                return;

            List<ManiaHitObject> remainingHitObjects = EditorBeatmap.HitObjects.Cast<ManiaHitObject>().Where(h => h.StartTime >= timestamp).ToList();
-            string[] objectDescriptions = objectDescription.Split(',').ToArray();
+            string[] objectDescriptions = objectDescription.Split(',');

            for (int i = 0; i < objectDescriptions.Length; i++)
            {
-                string[] split = objectDescriptions[i].Split('|').ToArray();
+                string[] split = objectDescriptions[i].Split('|');
                if (split.Length != 2)
                    continue;

@@ -134,7 +134,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Setup

            updatingKeyCount = true;

-            editor.Reload().ContinueWith(t =>
+            editor.SaveAndReload().ContinueWith(t =>
            {
                if (!t.GetResultSafely())
                {
@@ -8,7 +8,7 @@ using osu.Game.Rulesets.UI;

 namespace osu.Game.Rulesets.Mania
 {
-    [Cached] // Used for touch input, see ColumnTouchInputArea.
+    [Cached] // Used for touch input, see Column.OnTouchDown/OnTouchUp.
    public partial class ManiaInputManager : RulesetInputManager<ManiaAction>
    {
        public ManiaInputManager(RulesetInfo ruleset, int variant)
@@ -34,7 +34,7 @@ namespace osu.Game.Rulesets.Mania.Mods

            foreach (Column column in maniaPlayfield.Stages.SelectMany(stage => stage.Columns))
            {
-                HitObjectContainer hoc = column.HitObjectArea.HitObjectContainer;
+                HitObjectContainer hoc = column.HitObjectContainer;
                Container hocParent = (Container)hoc.Parent!;

                hocParent.Remove(hoc, false);
@@ -26,9 +26,10 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
            : base(barLine)
        {
            RelativeSizeAxes = Axes.X;
+            Height = 1;
        }

-        [BackgroundDependencyLoader]
+        [BackgroundDependencyLoader(true)]
        private void load()
        {
            AddInternal(new SkinnableDrawable(new ManiaSkinComponentLookup(ManiaSkinComponents.BarLine), _ => new DefaultBarLine())
@@ -36,8 +37,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                Anchor = Anchor.Centre,
                Origin = Anchor.Centre,
            });
-
-            Major.BindValueChanged(major => Height = major.NewValue ? 1.7f : 1.2f, true);
        }

        protected override void OnApply()
@@ -25,7 +25,11 @@ namespace osu.Game.Rulesets.Mania.Objects

        #region LegacyBeatmapEncoder

-        float IHasXPosition.X => Column;
+        float IHasXPosition.X
+        {
+            get => Column;
+            set => Column = (int)value;
+        }

        #endregion
    }
@@ -3,6 +3,7 @@

 using System;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -12,6 +13,7 @@ using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI.Scrolling;
 using osuTK;
 using osuTK.Graphics;

@@ -19,25 +21,29 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
 {
    public partial class ArgonJudgementPiece : TextJudgementPiece, IAnimatableJudgement
    {
-        private const float judgement_y_position = 160;
+        private const float judgement_y_position = -180f;

        private RingExplosion? ringExplosion;

        [Resolved]
        private OsuColour colours { get; set; } = null!;

+        private IBindable<ScrollingDirection> direction = null!;
+
        public ArgonJudgementPiece(HitResult result)
            : base(result)
        {
            AutoSizeAxes = Axes.Both;

            Origin = Anchor.Centre;
-            Y = judgement_y_position;
        }

        [BackgroundDependencyLoader]
-        private void load()
+        private void load(IScrollingInfo scrollingInfo)
        {
+            direction = scrollingInfo.Direction.GetBoundCopy();
+            direction.BindValueChanged(_ => onDirectionChanged(), true);
+
            if (Result.IsHit())
            {
                AddInternal(ringExplosion = new RingExplosion(Result)
@@ -47,6 +53,8 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
            }
        }

+        private void onDirectionChanged() => Y = direction.Value == ScrollingDirection.Up ? -judgement_y_position : judgement_y_position;
+
        protected override SpriteText CreateJudgementText() =>
            new OsuSpriteText
            {
@@ -78,7 +86,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
                    this.ScaleTo(1.6f);
                    this.ScaleTo(1, 100, Easing.In);

-                    this.MoveToY(judgement_y_position);
+                    this.MoveToY(direction.Value == ScrollingDirection.Up ? -judgement_y_position : judgement_y_position);
                    this.MoveToOffset(new Vector2(0, 100), 800, Easing.InQuint);

                    this.RotateTo(0);
@@ -9,7 +9,9 @@ using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play.HUD;
 using osu.Game.Skinning;
+using osuTK;
 using osuTK.Graphics;

 namespace osu.Game.Rulesets.Mania.Skinning.Argon
@@ -39,6 +41,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
                            return new DefaultSkinComponentsContainer(container =>
                            {
                                var combo = container.ChildrenOfType<ArgonManiaComboCounter>().FirstOrDefault();
+                                var spectatorList = container.OfType<SpectatorList>().FirstOrDefault();

                                if (combo != null)
                                {
@@ -47,9 +50,17 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
                                    combo.Origin = Anchor.Centre;
                                    combo.Y = 200;
                                }
+
+                                if (spectatorList != null)
+                                    spectatorList.Position = new Vector2(36, -66);
                            })
                            {
                                new ArgonManiaComboCounter(),
+                                new SpectatorList
+                                {
+                                    Anchor = Anchor.BottomLeft,
+                                    Origin = Anchor.BottomLeft,
+                                }
                            };
                    }

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Default
        [BackgroundDependencyLoader]
        private void load(DrawableHitObject drawableHitObject)
        {
-            RelativeSizeAxes = Axes.Both;
+            RelativeSizeAxes = Axes.X;

            // Avoid flickering due to no anti-aliasing of boxes by default.
            var edgeSmoothness = new Vector2(0.3f);
@@ -75,6 +75,8 @@ namespace osu.Game.Rulesets.Mania.Skinning.Default

        private void updateMajor(ValueChangedEvent<bool> major)
        {
+            Height = major.NewValue ? 1.7f : 1.2f;
+
            mainLine.Alpha = major.NewValue ? 0.5f : 0.2f;
            leftAnchor.Alpha = rightAnchor.Alpha = major.NewValue ? mainLine.Alpha * 0.3f : 0;
        }
@@ -0,0 +1,38 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Skinning;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.Skinning.Legacy
+{
+    public partial class LegacyBarLine : CompositeDrawable
+    {
+        [BackgroundDependencyLoader]
+        private void load(ISkinSource skin)
+        {
+            float skinHeight = skin.GetManiaSkinConfig<float>(LegacyManiaSkinConfigurationLookups.BarLineHeight)?.Value ?? 1;
+
+            RelativeSizeAxes = Axes.X;
+            Height = 1.2f * skinHeight;
+            Colour = skin.GetManiaSkinConfig<Color4>(LegacyManiaSkinConfigurationLookups.BarLineColour)?.Value ?? Color4.White;
+
+            // Avoid flickering due to no anti-aliasing of boxes by default.
+            var edgeSmoothness = new Vector2(0.3f);
+
+            AddInternal(new Box
+            {
+                Name = "Bar line",
+                EdgeSmoothness = edgeSmoothness,
+                Anchor = Anchor.BottomCentre,
+                Origin = Anchor.BottomCentre,
+                RelativeSizeAxes = Axes.Both,
+            });
+        }
+    }
+}
@@ -2,13 +2,14 @@
 // See the LICENCE file in the repository root for full licence text.

 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Utils;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;

 namespace osu.Game.Rulesets.Mania.Skinning.Legacy
@@ -23,21 +24,22 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
            this.result = result;
            this.animation = animation;

-            Anchor = Anchor.Centre;
+            Anchor = Anchor.BottomCentre;
            Origin = Anchor.Centre;

            AutoSizeAxes = Axes.Both;
        }

+        private IBindable<ScrollingDirection> direction = null!;
+
+        [Resolved]
+        private ISkinSource skin { get; set; } = null!;
+
        [BackgroundDependencyLoader]
-        private void load(ISkinSource skin)
+        private void load(IScrollingInfo scrollingInfo)
        {
-            float? scorePosition = skin.GetManiaSkinConfig<float>(LegacyManiaSkinConfigurationLookups.ScorePosition)?.Value;
-
-            if (scorePosition != null)
-                scorePosition -= Stage.HIT_TARGET_POSITION + 150;
-
-            Y = scorePosition ?? 0;
+            direction = scrollingInfo.Direction.GetBoundCopy();
+            direction.BindValueChanged(_ => onDirectionChanged(), true);

            InternalChild = animation.With(d =>
            {
@@ -46,6 +48,17 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
            });
        }

+        private void onDirectionChanged()
+        {
+            float hitPosition = skin.GetManiaSkinConfig<float>(LegacyManiaSkinConfigurationLookups.HitPosition)?.Value ?? 0;
+            float scorePosition = skin.GetManiaSkinConfig<float>(LegacyManiaSkinConfigurationLookups.ScorePosition)?.Value ?? 0;
+
+            float absoluteHitPosition = 480f * LegacyManiaSkinConfiguration.POSITION_SCALE_FACTOR - hitPosition;
+            float finalPosition = scorePosition - absoluteHitPosition;
+
+            Y = direction.Value == ScrollingDirection.Up ? -finalPosition : finalPosition;
+        }
+
        public void PlayAnimation()
        {
            (animation as IFramedAnimation)?.GotoFrame(0);
@@ -15,7 +15,9 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play.HUD;
 using osu.Game.Skinning;
+using osuTK;

 namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 {
@@ -95,6 +97,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
                            return new DefaultSkinComponentsContainer(container =>
                            {
                                var combo = container.ChildrenOfType<LegacyManiaComboCounter>().FirstOrDefault();
+                                var spectatorList = container.OfType<SpectatorList>().FirstOrDefault();

                                if (combo != null)
                                {
@@ -102,9 +105,17 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
                                    combo.Origin = Anchor.Centre;
                                    combo.Y = this.GetManiaSkinConfig<float>(LegacyManiaSkinConfigurationLookups.ComboPosition)?.Value ?? 0;
                                }
+
+                                if (spectatorList != null)
+                                {
+                                    spectatorList.Anchor = Anchor.BottomLeft;
+                                    spectatorList.Origin = Anchor.BottomLeft;
+                                    spectatorList.Position = new Vector2(10, -10);
+                                }
                            })
                            {
                                new LegacyManiaComboCounter(),
+                                new SpectatorList(),
                            };
                    }

@@ -152,7 +163,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
                            return new LegacyStageForeground();

                        case ManiaSkinComponents.BarLine:
-                            return null; // Not yet implemented.
+                            return new LegacyBarLine();

                        default:
                            throw new UnsupportedSkinComponentException(lookup);
@@ -1,10 +1,9 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

-#nullable disable
-
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Pooling;
@@ -45,11 +44,11 @@ namespace osu.Game.Rulesets.Mania.UI

        internal readonly Container TopLevelContainer = new Container { RelativeSizeAxes = Axes.Both };

-        private DrawablePool<PoolableHitExplosion> hitExplosionPool;
+        private DrawablePool<PoolableHitExplosion> hitExplosionPool = null!;
        private readonly OrderedHitPolicy hitPolicy;
        public Container UnderlayElements => HitObjectArea.UnderlayElements;

-        private GameplaySampleTriggerSource sampleTriggerSource;
+        private GameplaySampleTriggerSource sampleTriggerSource = null!;

        /// <summary>
        /// Whether this is a special (ie. scratch) column.
@@ -67,11 +66,15 @@ namespace osu.Game.Rulesets.Mania.UI
            Width = COLUMN_WIDTH;

            hitPolicy = new OrderedHitPolicy(HitObjectContainer);
-            HitObjectArea = new ColumnHitObjectArea(HitObjectContainer) { RelativeSizeAxes = Axes.Both };
+            HitObjectArea = new ColumnHitObjectArea
+            {
+                RelativeSizeAxes = Axes.Both,
+                Child = HitObjectContainer,
+            };
        }

        [Resolved]
-        private ISkinSource skin { get; set; }
+        private ISkinSource skin { get; set; } = null!;

        [BackgroundDependencyLoader]
        private void load(GameHost host)
@@ -132,7 +135,7 @@ namespace osu.Game.Rulesets.Mania.UI

            base.Dispose(isDisposing);

-            if (skin != null)
+            if (skin.IsNotNull())
                skin.SourceChanged -= onSourceChanged;
        }

@@ -180,5 +183,29 @@ namespace osu.Game.Rulesets.Mania.UI
        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos)
            // This probably shouldn't exist as is, but the columns in the stage are separated by a 1px border
            => DrawRectangle.Inflate(new Vector2(Stage.COLUMN_SPACING / 2, 0)).Contains(ToLocalSpace(screenSpacePos));
+
+        #region Touch Input
+
+        [Resolved]
+        private ManiaInputManager? maniaInputManager { get; set; }
+
+        private int touchActivationCount;
+
+        protected override bool OnTouchDown(TouchDownEvent e)
+        {
+            maniaInputManager?.KeyBindingContainer.TriggerPressed(Action.Value);
+            touchActivationCount++;
+            return true;
+        }
+
+        protected override void OnTouchUp(TouchUpEvent e)
+        {
+            touchActivationCount--;
+
+            if (touchActivationCount == 0)
+                maniaInputManager?.KeyBindingContainer.TriggerReleased(Action.Value);
+        }
+
+        #endregion
    }
 }
@@ -3,13 +3,12 @@

 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;

 namespace osu.Game.Rulesets.Mania.UI.Components
 {
-    public partial class ColumnHitObjectArea : HitObjectArea
+    public partial class ColumnHitObjectArea : HitPositionPaddedContainer
    {
        public readonly Container Explosions;

@@ -17,25 +16,29 @@ namespace osu.Game.Rulesets.Mania.UI.Components

        private readonly Drawable hitTarget;

-        public ColumnHitObjectArea(HitObjectContainer hitObjectContainer)
-            : base(hitObjectContainer)
+        protected override Container<Drawable> Content => content;
+
+        private readonly Container content;
+
+        public ColumnHitObjectArea()
        {
            AddRangeInternal(new[]
            {
                UnderlayElements = new Container
                {
                    RelativeSizeAxes = Axes.Both,
-                    Depth = 2,
                },
                hitTarget = new SkinnableDrawable(new ManiaSkinComponentLookup(ManiaSkinComponents.HitTarget), _ => new DefaultHitTarget())
                {
                    RelativeSizeAxes = Axes.X,
-                    Depth = 1
+                },
+                content = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
                },
                Explosions = new Container
                {
                    RelativeSizeAxes = Axes.Both,
-                    Depth = -1,
                }
            });
        }
@@ -1,52 +1,38 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Mania.Skinning;
-using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;

 namespace osu.Game.Rulesets.Mania.UI.Components
 {
-    public partial class HitObjectArea : SkinReloadableDrawable
+    public partial class HitPositionPaddedContainer : Container
    {
        protected readonly IBindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
-        public readonly HitObjectContainer HitObjectContainer;

-        public HitObjectArea(HitObjectContainer hitObjectContainer)
-        {
-            InternalChild = new Container
-            {
-                RelativeSizeAxes = Axes.Both,
-                Child = HitObjectContainer = hitObjectContainer
-            };
-        }
+        [Resolved]
+        private ISkinSource skin { get; set; } = null!;

        [BackgroundDependencyLoader]
        private void load(IScrollingInfo scrollingInfo)
        {
            Direction.BindTo(scrollingInfo.Direction);
-            Direction.BindValueChanged(onDirectionChanged, true);
+            Direction.BindValueChanged(_ => UpdateHitPosition(), true);
+
+            skin.SourceChanged += onSkinChanged;
        }

-        protected override void SkinChanged(ISkinSource skin)
-        {
-            base.SkinChanged(skin);
-            UpdateHitPosition();
-        }
-
-        private void onDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
-        {
-            UpdateHitPosition();
-        }
+        private void onSkinChanged() => UpdateHitPosition();

        protected virtual void UpdateHitPosition()
        {
-            float hitPosition = CurrentSkin.GetConfig<ManiaSkinConfigurationLookup, float>(
+            float hitPosition = skin.GetConfig<ManiaSkinConfigurationLookup, float>(
                                    new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.HitPosition))?.Value
                                ?? Stage.HIT_TARGET_POSITION;

@@ -54,5 +40,13 @@ namespace osu.Game.Rulesets.Mania.UI.Components
                ? new MarginPadding { Top = hitPosition }
                : new MarginPadding { Bottom = hitPosition };
        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (skin.IsNotNull())
+                skin.SourceChanged -= onSkinChanged;
+        }
    }
 }
@@ -0,0 +1,75 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI.Scrolling;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.UI
+{
+    public partial class DefaultManiaJudgementPiece : DefaultJudgementPiece
+    {
+        private const float judgement_y_position = -180f;
+
+        private IBindable<ScrollingDirection> direction = null!;
+
+        public DefaultManiaJudgementPiece(HitResult result)
+            : base(result)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(IScrollingInfo scrollingInfo)
+        {
+            direction = scrollingInfo.Direction.GetBoundCopy();
+            direction.BindValueChanged(_ => onDirectionChanged(), true);
+        }
+
+        private void onDirectionChanged() => Y = direction.Value == ScrollingDirection.Up ? -judgement_y_position : judgement_y_position;
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            JudgementText.Font = JudgementText.Font.With(size: 25);
+        }
+
+        public override void PlayAnimation()
+        {
+            switch (Result)
+            {
+                case HitResult.None:
+                    this.FadeOutFromOne(800);
+                    break;
+
+                case HitResult.Miss:
+                    this.ScaleTo(1.6f);
+                    this.ScaleTo(1, 100, Easing.In);
+
+                    this.MoveToY(direction.Value == ScrollingDirection.Up ? -judgement_y_position : judgement_y_position);
+                    this.MoveToOffset(new Vector2(0, 100), 800, Easing.InQuint);
+
+                    this.RotateTo(0);
+                    this.RotateTo(40, 800, Easing.InQuint);
+
+                    this.FadeOutFromOne(800);
+                    break;
+
+                default:
+                    this.ScaleTo(0.8f);
+                    this.ScaleTo(1, 250, Easing.OutElastic);
+
+                    this.Delay(50)
+                        .ScaleTo(0.75f, 250)
+                        .FadeOut(200);
+
+                    // osu!mania uses a custom fade length, so the base call is intentionally omitted.
+                    break;
+            }
+        }
+    }
+}
@@ -3,51 +3,32 @@

 #nullable disable

+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI.Scrolling;

 namespace osu.Game.Rulesets.Mania.UI
 {
    public partial class DrawableManiaJudgement : DrawableJudgement
    {
-        protected override Drawable CreateDefaultJudgement(HitResult result) => new DefaultManiaJudgementPiece(result);
+        private IBindable<ScrollingDirection> direction;

-        private partial class DefaultManiaJudgementPiece : DefaultJudgementPiece
+        [BackgroundDependencyLoader]
+        private void load(IScrollingInfo scrollingInfo)
        {
-            public DefaultManiaJudgementPiece(HitResult result)
-                : base(result)
-            {
-            }
-
-            protected override void LoadComplete()
-            {
-                base.LoadComplete();
-
-                JudgementText.Font = JudgementText.Font.With(size: 25);
-            }
-
-            public override void PlayAnimation()
-            {
-                switch (Result)
-                {
-                    case HitResult.None:
-                    case HitResult.Miss:
-                        base.PlayAnimation();
-                        break;
-
-                    default:
-                        this.ScaleTo(0.8f);
-                        this.ScaleTo(1, 250, Easing.OutElastic);
-
-                        this.Delay(50)
-                            .ScaleTo(0.75f, 250)
-                            .FadeOut(200);
-
-                        // osu!mania uses a custom fade length, so the base call is intentionally omitted.
-                        break;
-                }
-            }
+            direction = scrollingInfo.Direction.GetBoundCopy();
+            direction.BindValueChanged(_ => onDirectionChanged(), true);
        }
+
+        private void onDirectionChanged()
+        {
+            Anchor = direction.Value == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre;
+            Origin = Anchor.Centre;
+        }
+
+        protected override Drawable CreateDefaultJudgement(HitResult result) => new DefaultManiaJudgementPiece(result);
    }
 }
@@ -32,7 +32,6 @@ using osu.Game.Skinning;

 namespace osu.Game.Rulesets.Mania.UI
 {
-    [Cached]
    public partial class DrawableManiaRuleset : DrawableScrollingRuleset<ManiaHitObject>
    {
        /// <summary>
@@ -51,6 +50,8 @@ namespace osu.Game.Rulesets.Mania.UI

        public IEnumerable<BarLine> BarLines;

+        public override bool RequiresPortraitOrientation => Beatmap.Stages.Count == 1;
+
        protected override bool RelativeScaleBeatLengths => true;

        protected new ManiaRulesetConfigManager Config => (ManiaRulesetConfigManager)base.Config;
@@ -110,8 +111,6 @@ namespace osu.Game.Rulesets.Mania.UI
            configScrollSpeed.BindValueChanged(speed => TargetTimeRange = ComputeScrollTime(speed.NewValue));

            TimeRange.Value = TargetTimeRange = currentTimeRange = ComputeScrollTime(configScrollSpeed.Value);
-
-            KeyBindingInputManager.Add(new ManiaTouchInputArea());
        }

        protected override void AdjustScrollSpeed(int amount) => configScrollSpeed.Value += amount;
@@ -162,7 +161,7 @@ namespace osu.Game.Rulesets.Mania.UI
        /// <returns>The scroll time.</returns>
        public static double ComputeScrollTime(double scrollSpeed) => MAX_TIME_RANGE / scrollSpeed;

-        public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new ManiaPlayfieldAdjustmentContainer();
+        public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new ManiaPlayfieldAdjustmentContainer(this);

        protected override Playfield CreatePlayfield() => new ManiaPlayfield(Beatmap.Stages);

@@ -1,17 +1,63 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using System;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.UI;
+using osuTK;

 namespace osu.Game.Rulesets.Mania.UI
 {
    public partial class ManiaPlayfieldAdjustmentContainer : PlayfieldAdjustmentContainer
    {
-        public ManiaPlayfieldAdjustmentContainer()
+        protected override Container<Drawable> Content { get; }
+
+        private readonly DrawSizePreservingFillContainer scalingContainer;
+
+        private readonly DrawableManiaRuleset drawableManiaRuleset;
+
+        public ManiaPlayfieldAdjustmentContainer(DrawableManiaRuleset drawableManiaRuleset)
        {
-            Anchor = Anchor.Centre;
-            Origin = Anchor.Centre;
+            this.drawableManiaRuleset = drawableManiaRuleset;
+            InternalChild = scalingContainer = new DrawSizePreservingFillContainer
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Both,
+                Child = Content = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                }
+            };
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            float aspectRatio = DrawWidth / DrawHeight;
+            bool isPortrait = aspectRatio < 1f;
+
+            if (isPortrait && drawableManiaRuleset.Beatmap.Stages.Count == 1)
+            {
+                // Scale playfield up by 25% to become playable on mobile devices,
+                // and leave a 10% horizontal gap if the playfield is scaled down due to being too wide.
+                const float base_scale = 1.25f;
+                const float base_width = 768f / base_scale;
+                const float side_gap = 0.9f;
+
+                scalingContainer.Strategy = DrawSizePreservationStrategy.Maximum;
+                float stageWidth = drawableManiaRuleset.Playfield.Stages[0].DrawWidth;
+                scalingContainer.TargetDrawSize = new Vector2(1024, base_width * Math.Max(stageWidth / aspectRatio / (base_width * side_gap), 1f));
+            }
+            else
+            {
+                scalingContainer.Strategy = DrawSizePreservationStrategy.Minimum;
+                scalingContainer.Scale = new Vector2(1f);
+                scalingContainer.Size = new Vector2(1f);
+                scalingContainer.TargetDrawSize = new Vector2(1024, 768);
+            }
        }
    }
 }
@@ -1,199 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Collections.Generic;
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.Events;
-using osu.Game.Configuration;
-using osuTK;
-
-namespace osu.Game.Rulesets.Mania.UI
-{
-    /// <summary>
-    /// An overlay that captures and displays osu!mania mouse and touch input.
-    /// </summary>
-    public partial class ManiaTouchInputArea : VisibilityContainer
-    {
-        // visibility state affects our child. we always want to handle input.
-        public override bool PropagatePositionalInputSubTree => true;
-        public override bool PropagateNonPositionalInputSubTree => true;
-
-        [SettingSource("Spacing", "The spacing between receptors.")]
-        public BindableFloat Spacing { get; } = new BindableFloat(10)
-        {
-            Precision = 1,
-            MinValue = 0,
-            MaxValue = 100,
-        };
-
-        [SettingSource("Opacity", "The receptor opacity.")]
-        public BindableFloat Opacity { get; } = new BindableFloat(1)
-        {
-            Precision = 0.1f,
-            MinValue = 0,
-            MaxValue = 1
-        };
-
-        [Resolved]
-        private DrawableManiaRuleset drawableRuleset { get; set; } = null!;
-
-        private GridContainer gridContainer = null!;
-
-        public ManiaTouchInputArea()
-        {
-            Anchor = Anchor.BottomCentre;
-            Origin = Anchor.BottomCentre;
-
-            RelativeSizeAxes = Axes.Both;
-            Height = 0.5f;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            List<Drawable> receptorGridContent = new List<Drawable>();
-            List<Dimension> receptorGridDimensions = new List<Dimension>();
-
-            bool first = true;
-
-            foreach (var stage in drawableRuleset.Playfield.Stages)
-            {
-                foreach (var column in stage.Columns)
-                {
-                    if (!first)
-                    {
-                        receptorGridContent.Add(new Gutter { Spacing = { BindTarget = Spacing } });
-                        receptorGridDimensions.Add(new Dimension(GridSizeMode.AutoSize));
-                    }
-
-                    receptorGridContent.Add(new ColumnInputReceptor { Action = { BindTarget = column.Action } });
-                    receptorGridDimensions.Add(new Dimension());
-
-                    first = false;
-                }
-            }
-
-            InternalChild = gridContainer = new GridContainer
-            {
-                RelativeSizeAxes = Axes.Both,
-                AlwaysPresent = true,
-                Content = new[] { receptorGridContent.ToArray() },
-                ColumnDimensions = receptorGridDimensions.ToArray()
-            };
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-            Opacity.BindValueChanged(o => Alpha = o.NewValue, true);
-        }
-
-        protected override bool OnKeyDown(KeyDownEvent e)
-        {
-            // Hide whenever the keyboard is used.
-            Hide();
-            return false;
-        }
-
-        protected override bool OnTouchDown(TouchDownEvent e)
-        {
-            Show();
-            return true;
-        }
-
-        protected override void PopIn()
-        {
-            gridContainer.FadeIn(500, Easing.OutQuint);
-        }
-
-        protected override void PopOut()
-        {
-            gridContainer.FadeOut(300);
-        }
-
-        public partial class ColumnInputReceptor : CompositeDrawable
-        {
-            public readonly IBindable<ManiaAction> Action = new Bindable<ManiaAction>();
-
-            private readonly Box highlightOverlay;
-
-            [Resolved]
-            private ManiaInputManager? inputManager { get; set; }
-
-            private bool isPressed;
-
-            public ColumnInputReceptor()
-            {
-                RelativeSizeAxes = Axes.Both;
-
-                InternalChildren = new Drawable[]
-                {
-                    new Container
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Masking = true,
-                        CornerRadius = 10,
-                        Children = new Drawable[]
-                        {
-                            new Box
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Alpha = 0.15f,
-                            },
-                            highlightOverlay = new Box
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Alpha = 0,
-                                Blending = BlendingParameters.Additive,
-                            }
-                        }
-                    }
-                };
-            }
-
-            protected override bool OnTouchDown(TouchDownEvent e)
-            {
-                updateButton(true);
-                return false; // handled by parent container to show overlay.
-            }
-
-            protected override void OnTouchUp(TouchUpEvent e)
-            {
-                updateButton(false);
-            }
-
-            private void updateButton(bool press)
-            {
-                if (press == isPressed)
-                    return;
-
-                isPressed = press;
-
-                if (press)
-                {
-                    inputManager?.KeyBindingContainer.TriggerPressed(Action.Value);
-                    highlightOverlay.FadeTo(0.1f, 80, Easing.OutQuint);
-                }
-                else
-                {
-                    inputManager?.KeyBindingContainer.TriggerReleased(Action.Value);
-                    highlightOverlay.FadeTo(0, 400, Easing.OutQuint);
-                }
-            }
-        }
-
-        private partial class Gutter : Drawable
-        {
-            public readonly IBindable<float> Spacing = new Bindable<float>();
-
-            public Gutter()
-            {
-                Spacing.BindValueChanged(s => Size = new Vector2(s.NewValue));
-            }
-        }
-    }
-}
@@ -103,12 +103,13 @@ namespace osu.Game.Rulesets.Mania.UI
                            Width = 1366, // Bar lines should only be masked on the vertical axis
                            BypassAutoSizeAxes = Axes.Both,
                            Masking = true,
-                            Child = barLineContainer = new HitObjectArea(HitObjectContainer)
+                            Child = barLineContainer = new HitPositionPaddedContainer
                            {
                                Name = "Bar lines",
                                Anchor = Anchor.TopCentre,
                                Origin = Anchor.TopCentre,
                                RelativeSizeAxes = Axes.Y,
+                                Child = HitObjectContainer,
                            }
                        },
                        columnFlow = new ColumnFlow<Column>(definition)
@@ -119,12 +120,13 @@ namespace osu.Game.Rulesets.Mania.UI
                        {
                            RelativeSizeAxes = Axes.Both
                        },
-                        judgements = new JudgementContainer<DrawableManiaJudgement>
+                        new HitPositionPaddedContainer
                        {
-                            Anchor = Anchor.TopCentre,
-                            Origin = Anchor.Centre,
                            RelativeSizeAxes = Axes.Both,
-                            Y = HIT_TARGET_POSITION + 150
+                            Child = judgements = new JudgementContainer<DrawableManiaJudgement>
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                            },
                        },
                        topLevelContainer = new Container { RelativeSizeAxes = Axes.Both }
                    }
@@ -214,13 +216,7 @@ namespace osu.Game.Rulesets.Mania.UI
                return;

            judgements.Clear(false);
-            judgements.Add(judgementPooler.Get(result.Type, j =>
-            {
-                j.Apply(result, judgedObject);
-
-                j.Anchor = Anchor.Centre;
-                j.Origin = Anchor.Centre;
-            })!);
+            judgements.Add(judgementPooler.Get(result.Type, j => j.Apply(result, judgedObject))!);
        }

        protected override void Update()
@@ -10,7 +10,9 @@ using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Screens.Edit.Compose.Components;
@@ -261,6 +263,163 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
            AddAssert("selection preserved", () => EditorBeatmap.SelectedHitObjects.Count, () => Is.EqualTo(1));
        }

+        [Test]
+        public void TestQuickDeleteOnUnselectedControlPointOnlyRemovesThatControlPoint()
+        {
+            var slider = new Slider
+            {
+                StartTime = 0,
+                Position = new Vector2(100, 100),
+                Path = new SliderPath
+                {
+                    ControlPoints =
+                    {
+                        new PathControlPoint { Type = PathType.LINEAR },
+                        new PathControlPoint(new Vector2(100, 0)),
+                        new PathControlPoint(new Vector2(100)),
+                        new PathControlPoint(new Vector2(0, 100))
+                    }
+                }
+            };
+            AddStep("add slider", () => EditorBeatmap.Add(slider));
+            AddStep("select slider", () => EditorBeatmap.SelectedHitObjects.Add(slider));
+
+            AddStep("select second node", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<PathControlPointPiece<Slider>>().ElementAt(1));
+                InputManager.Click(MouseButton.Left);
+            });
+            AddStep("also select third node", () =>
+            {
+                InputManager.PressKey(Key.ControlLeft);
+                InputManager.MoveMouseTo(this.ChildrenOfType<PathControlPointPiece<Slider>>().ElementAt(2));
+                InputManager.Click(MouseButton.Left);
+                InputManager.ReleaseKey(Key.ControlLeft);
+            });
+            AddStep("quick-delete fourth node", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<PathControlPointPiece<Slider>>().ElementAt(3));
+                InputManager.Click(MouseButton.Middle);
+            });
+            AddUntilStep("slider not deleted", () => EditorBeatmap.HitObjects.OfType<Slider>().Count(), () => Is.EqualTo(1));
+            AddUntilStep("slider path has 3 nodes", () => EditorBeatmap.HitObjects.OfType<Slider>().Single().Path.ControlPoints.Count, () => Is.EqualTo(3));
+        }
+
+        [Test]
+        public void TestQuickDeleteOnSelectedControlPointRemovesEntireSelection()
+        {
+            var slider = new Slider
+            {
+                StartTime = 0,
+                Position = new Vector2(100, 100),
+                Path = new SliderPath
+                {
+                    ControlPoints =
+                    {
+                        new PathControlPoint { Type = PathType.LINEAR },
+                        new PathControlPoint(new Vector2(100, 0)),
+                        new PathControlPoint(new Vector2(100)),
+                        new PathControlPoint(new Vector2(0, 100))
+                    }
+                }
+            };
+            AddStep("add slider", () => EditorBeatmap.Add(slider));
+            AddStep("select slider", () => EditorBeatmap.SelectedHitObjects.Add(slider));
+
+            AddStep("select second node", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<PathControlPointPiece<Slider>>().ElementAt(1));
+                InputManager.Click(MouseButton.Left);
+            });
+            AddStep("also select third node", () =>
+            {
+                InputManager.PressKey(Key.ControlLeft);
+                InputManager.MoveMouseTo(this.ChildrenOfType<PathControlPointPiece<Slider>>().ElementAt(2));
+                InputManager.Click(MouseButton.Left);
+                InputManager.ReleaseKey(Key.ControlLeft);
+            });
+            AddStep("quick-delete second node", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<PathControlPointPiece<Slider>>().ElementAt(1));
+                InputManager.Click(MouseButton.Middle);
+            });
+            AddUntilStep("slider not deleted", () => EditorBeatmap.HitObjects.OfType<Slider>().Count(), () => Is.EqualTo(1));
+            AddUntilStep("slider path has 2 nodes", () => EditorBeatmap.HitObjects.OfType<Slider>().Single().Path.ControlPoints.Count, () => Is.EqualTo(2));
+        }
+
+        [Test]
+        public void TestSliderDragMarkerDoesNotBlockControlPointContextMenu()
+        {
+            var slider = new Slider
+            {
+                StartTime = 0,
+                Position = new Vector2(100, 100),
+                Path = new SliderPath
+                {
+                    ControlPoints =
+                    {
+                        new PathControlPoint { Type = PathType.LINEAR },
+                        new PathControlPoint(new Vector2(50, 100)),
+                        new PathControlPoint(new Vector2(145, 100)),
+                    },
+                    ExpectedDistance = { Value = 162.62 }
+                },
+            };
+            AddStep("add slider", () => EditorBeatmap.Add(slider));
+            AddStep("select slider", () => EditorBeatmap.SelectedHitObjects.Add(slider));
+
+            AddStep("select last node", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<PathControlPointPiece<Slider>>().Last());
+                InputManager.Click(MouseButton.Left);
+            });
+            AddStep("right click node", () => InputManager.Click(MouseButton.Right));
+            AddUntilStep("context menu open", () => this.ChildrenOfType<ContextMenuContainer>().Single().ChildrenOfType<Menu>().All(m => m.State == MenuState.Open));
+        }
+
+        [Test]
+        public void TestSliderDragMarkerBlocksSelectionOfObjectsUnderneath()
+        {
+            var firstSlider = new Slider
+            {
+                StartTime = 0,
+                Position = new Vector2(10, 50),
+                Path = new SliderPath
+                {
+                    ControlPoints =
+                    {
+                        new PathControlPoint(),
+                        new PathControlPoint(new Vector2(100))
+                    }
+                }
+            };
+            var secondSlider = new Slider
+            {
+                StartTime = 500,
+                Position = new Vector2(200, 0),
+                Path = new SliderPath
+                {
+                    ControlPoints =
+                    {
+                        new PathControlPoint(),
+                        new PathControlPoint(new Vector2(-100, 100))
+                    }
+                }
+            };
+
+            AddStep("add objects", () => EditorBeatmap.AddRange(new HitObject[] { firstSlider, secondSlider }));
+            AddStep("select second slider", () => EditorBeatmap.SelectedHitObjects.Add(secondSlider));
+
+            AddStep("move to marker", () =>
+            {
+                var marker = this.ChildrenOfType<SliderEndDragMarker>().First();
+                var position = (marker.ScreenSpaceDrawQuad.TopRight + marker.ScreenSpaceDrawQuad.BottomRight) / 2;
+                InputManager.MoveMouseTo(position);
+            });
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+            AddAssert("second slider still selected", () => EditorBeatmap.SelectedHitObjects.Single(), () => Is.EqualTo(secondSlider));
+        }
+
        private ComposeBlueprintContainer blueprintContainer
            => Editor.ChildrenOfType<ComposeBlueprintContainer>().First();

@@ -0,0 +1,100 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Osu.Scoring;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests.Mods
+{
+    public partial class TestSceneOsuModRelax : OsuModTestScene
+    {
+        private readonly HitCircle hitObject;
+        private readonly HitWindows hitWindows = new OsuHitWindows();
+
+        public TestSceneOsuModRelax()
+        {
+            hitWindows.SetDifficulty(9);
+
+            hitObject = new HitCircle
+            {
+                StartTime = 1000,
+                Position = new Vector2(100, 100),
+                HitWindows = hitWindows
+            };
+        }
+
+        protected override TestPlayer CreateModPlayer(Ruleset ruleset) => new ModRelaxTestPlayer(CurrentTestData, AllowFail);
+
+        [Test]
+        public void TestRelax() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModRelax(),
+            Autoplay = false,
+            CreateBeatmap = () => new Beatmap
+            {
+                HitObjects = new List<HitObject> { hitObject }
+            },
+            ReplayFrames = new List<ReplayFrame>
+            {
+                new OsuReplayFrame(0, new Vector2()),
+                new OsuReplayFrame(hitObject.StartTime, hitObject.Position),
+            },
+            PassCondition = () => Player.ScoreProcessor.Combo.Value == 1
+        });
+
+        [Test]
+        public void TestRelaxLeniency() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModRelax(),
+            Autoplay = false,
+            CreateBeatmap = () => new Beatmap
+            {
+                HitObjects = new List<HitObject> { hitObject }
+            },
+            ReplayFrames = new List<ReplayFrame>
+            {
+                new OsuReplayFrame(0, new Vector2(hitObject.X - 22, hitObject.Y - 22)), // must be an edge hit for the cursor to not stay on the object for too long
+                new OsuReplayFrame(hitObject.StartTime - OsuModRelax.RELAX_LENIENCY, new Vector2(hitObject.X - 22, hitObject.Y - 22)),
+                new OsuReplayFrame(hitObject.StartTime, new Vector2(0)),
+            },
+            PassCondition = () => Player.ScoreProcessor.Combo.Value == 1
+        });
+
+        protected partial class ModRelaxTestPlayer : ModTestPlayer
+        {
+            private readonly ModTestData currentTestData;
+
+            public ModRelaxTestPlayer(ModTestData data, bool allowFail)
+                : base(data, allowFail)
+            {
+                currentTestData = data;
+            }
+
+            protected override void PrepareReplay()
+            {
+                // We need to set IsLegacyScore to true otherwise the mod assumes that presses are already embedded into the replay
+                DrawableRuleset?.SetReplayScore(new Score
+                {
+                    Replay = new Replay { Frames = currentTestData.ReplayFrames! },
+                    ScoreInfo = new ScoreInfo { User = new APIUser { Username = @"Test" }, IsLegacyScore = true, Mods = new Mod[] { new OsuModRelax() } },
+                });
+
+                DrawableRuleset?.SetRecordTarget(Score);
+            }
+        }
+    }
+}
@@ -24,11 +24,15 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
        {
        }

-        [Test]
-        public void TestMissTail() => CreateModTest(new ModTestData
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestMissTail(bool tailMiss) => CreateModTest(new ModTestData
        {
-            Mod = new OsuModSuddenDeath(),
-            PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(false),
+            Mod = new OsuModSuddenDeath
+            {
+                FailOnSliderTail = { Value = tailMiss }
+            },
+            PassCondition = () => ((ModFailConditionTestPlayer)Player).CheckFailed(tailMiss),
            Autoplay = false,
            CreateBeatmap = () => new Beatmap
            {
@@ -15,22 +15,22 @@ namespace osu.Game.Rulesets.Osu.Tests
    {
        protected override string ResourceAssembly => "osu.Game.Rulesets.Osu.Tests";

-        [TestCase(6.7171144000821119d, 239, "diffcalc-test")]
-        [TestCase(1.4485749025771304d, 54, "zero-length-sliders")]
-        [TestCase(0.42630400627180914d, 4, "very-fast-slider")]
+        [TestCase(6.7331304290522747d, 239, "diffcalc-test")]
+        [TestCase(1.4602604078137214d, 54, "zero-length-sliders")]
+        [TestCase(0.43052813047866129d, 4, "very-fast-slider")]
        [TestCase(0.14143808967817237d, 2, "nan-slider")]
        public void Test(double expectedStarRating, int expectedMaxCombo, string name)
            => base.Test(expectedStarRating, expectedMaxCombo, name);

-        [TestCase(8.9825709931204205d, 239, "diffcalc-test")]
-        [TestCase(1.7550169162648608d, 54, "zero-length-sliders")]
-        [TestCase(0.55231632896800109d, 4, "very-fast-slider")]
+        [TestCase(9.6779746353001634d, 239, "diffcalc-test")]
+        [TestCase(1.7691451263718989d, 54, "zero-length-sliders")]
+        [TestCase(0.55785578988249407d, 4, "very-fast-slider")]
        public void TestClockRateAdjusted(double expectedStarRating, int expectedMaxCombo, string name)
            => Test(expectedStarRating, expectedMaxCombo, name, new OsuModDoubleTime());

-        [TestCase(6.7171144000821119d, 239, "diffcalc-test")]
-        [TestCase(1.4485749025771304d, 54, "zero-length-sliders")]
-        [TestCase(0.42630400627180914d, 4, "very-fast-slider")]
+        [TestCase(6.7331304290522747d, 239, "diffcalc-test")]
+        [TestCase(1.4602604078137214d, 54, "zero-length-sliders")]
+        [TestCase(0.43052813047866129d, 4, "very-fast-slider")]
        public void TestClassicMod(double expectedStarRating, int expectedMaxCombo, string name)
            => Test(expectedStarRating, expectedMaxCombo, name, new OsuModClassic());

@@ -6,6 +6,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using JetBrains.Annotations;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio.Sample;
@@ -17,6 +18,7 @@ using osu.Framework.Graphics.Textures;
 using osu.Framework.Testing;
 using osu.Framework.Testing.Input;
 using osu.Game.Audio;
+using osu.Game.Rulesets.Osu.Skinning;
 using osu.Game.Rulesets.Osu.Skinning.Legacy;
 using osu.Game.Rulesets.Osu.UI.Cursor;
 using osu.Game.Skinning;
@@ -103,6 +105,23 @@ namespace osu.Game.Rulesets.Osu.Tests
            AddStep("contract", () => this.ChildrenOfType<CursorTrail>().Single().NewPartScale = Vector2.One);
        }

+        [Test]
+        public void TestRotation()
+        {
+            createTest(() =>
+            {
+                var skinContainer = new LegacySkinContainer(renderer, provideMiddle: true, enableRotation: true);
+                var legacyCursorTrail = new LegacyRotatingCursorTrail(skinContainer)
+                {
+                    NewPartScale = new Vector2(10)
+                };
+
+                skinContainer.Child = legacyCursorTrail;
+
+                return skinContainer;
+            });
+        }
+
        private void createTest(Func<Drawable> createContent) => AddStep("create trail", () =>
        {
            Clear();
@@ -121,12 +140,14 @@ namespace osu.Game.Rulesets.Osu.Tests
            private readonly IRenderer renderer;
            private readonly bool provideMiddle;
            private readonly bool provideCursor;
+            private readonly bool enableRotation;

-            public LegacySkinContainer(IRenderer renderer, bool provideMiddle, bool provideCursor = true)
+            public LegacySkinContainer(IRenderer renderer, bool provideMiddle, bool provideCursor = true, bool enableRotation = false)
            {
                this.renderer = renderer;
                this.provideMiddle = provideMiddle;
                this.provideCursor = provideCursor;
+                this.enableRotation = enableRotation;

                RelativeSizeAxes = Axes.Both;
            }
@@ -152,7 +173,19 @@ namespace osu.Game.Rulesets.Osu.Tests

            public ISample GetSample(ISampleInfo sampleInfo) => null;

-            public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => null;
+            public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup)
+            {
+                switch (lookup)
+                {
+                    case OsuSkinConfiguration osuLookup:
+                        if (osuLookup == OsuSkinConfiguration.CursorTrailRotate)
+                            return SkinUtils.As<TValue>(new BindableBool(enableRotation));
+
+                        break;
+                }
+
+                return null;
+            }

            public ISkin FindProvider(Func<ISkin, bool> lookupFunction) => lookupFunction(this) ? this : null;

@@ -185,5 +218,19 @@ namespace osu.Game.Rulesets.Osu.Tests
                MoveMouseTo(ToScreenSpace(DrawSize / 2 + DrawSize / 3 * rPos));
            }
        }
+
+        private partial class LegacyRotatingCursorTrail : LegacyCursorTrail
+        {
+            public LegacyRotatingCursorTrail([NotNull] ISkin skin)
+                : base(skin)
+            {
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+                PartRotation += (float)(Time.Elapsed * 0.1);
+            }
+        }
    }
 }
@@ -1,10 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
  <Import Project="..\osu.TestProject.props" />
  <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
    <PackageReference Include="Moq" Version="4.18.4" />
    <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
  </ItemGroup>
  <PropertyGroup Label="Project">
    <OutputType>WinExe</OutputType>
@@ -12,9 +12,10 @@ 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 = 1.95;
+        private const double acute_angle_multiplier = 2.6;
        private const double slider_multiplier = 1.35;
        private const double velocity_change_multiplier = 0.75;
+        private const double wiggle_multiplier = 1.02;

        /// <summary>
        /// Evaluates the difficulty of aiming the current object, based on:
@@ -64,16 +65,16 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
            double acuteAngleBonus = 0;
            double sliderBonus = 0;
            double velocityChangeBonus = 0;
+            double wiggleBonus = 0;

            double aimStrain = currVelocity; // Start strain with regular velocity.

            if (Math.Max(osuCurrObj.StrainTime, osuLastObj.StrainTime) < 1.25 * Math.Min(osuCurrObj.StrainTime, osuLastObj.StrainTime)) // If rhythms are the same.
            {
-                if (osuCurrObj.Angle != null && osuLastObj.Angle != null && osuLastLastObj.Angle != null)
+                if (osuCurrObj.Angle != null && osuLastObj.Angle != null)
                {
                    double currAngle = osuCurrObj.Angle.Value;
                    double lastAngle = osuLastObj.Angle.Value;
-                    double lastLastAngle = osuLastLastObj.Angle.Value;

                    // Rewarding angles, take the smaller velocity as base.
                    double angleBonus = Math.Min(currVelocity, prevVelocity);
@@ -81,20 +82,27 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
                    wideAngleBonus = calcWideAngleBonus(currAngle);
                    acuteAngleBonus = calcAcuteAngleBonus(currAngle);

-                    if (DifficultyCalculationUtils.MillisecondsToBPM(osuCurrObj.StrainTime, 2) < 300) // Only buff deltaTime exceeding 300 bpm 1/2.
-                        acuteAngleBonus = 0;
-                    else
-                    {
-                        acuteAngleBonus *= calcAcuteAngleBonus(lastAngle) // Multiply by previous angle, we don't want to buff unless this is a wiggle type pattern.
-                                           * Math.Min(angleBonus, diameter * 1.25 / osuCurrObj.StrainTime) // The maximum velocity we buff is equal to 125 / strainTime
-                                           * Math.Pow(Math.Sin(Math.PI / 2 * Math.Min(1, (100 - osuCurrObj.StrainTime) / 25)), 2) // scale buff from 150 bpm 1/4 to 200 bpm 1/4
-                                           * Math.Pow(Math.Sin(Math.PI / 2 * (Math.Clamp(osuCurrObj.LazyJumpDistance, radius, diameter) - radius) / radius), 2); // Buff distance exceeding radius up to diameter.
-                    }
+                    // Penalize angle repetition.
+                    wideAngleBonus *= 1 - Math.Min(wideAngleBonus, Math.Pow(calcWideAngleBonus(lastAngle), 3));
+                    acuteAngleBonus *= 0.08 + 0.92 * (1 - Math.Min(acuteAngleBonus, Math.Pow(calcAcuteAngleBonus(lastAngle), 3)));

-                    // Penalize wide angles if they're repeated, reducing the penalty as the lastAngle gets more acute.
-                    wideAngleBonus *= angleBonus * (1 - Math.Min(wideAngleBonus, Math.Pow(calcWideAngleBonus(lastAngle), 3)));
-                    // Penalize acute angles if they're repeated, reducing the penalty as the lastLastAngle gets more obtuse.
-                    acuteAngleBonus *= 0.5 + 0.5 * (1 - Math.Min(acuteAngleBonus, Math.Pow(calcAcuteAngleBonus(lastLastAngle), 3)));
+                    // Apply full wide angle bonus for distance more than one diameter
+                    wideAngleBonus *= angleBonus * DifficultyCalculationUtils.Smootherstep(osuCurrObj.LazyJumpDistance, 0, diameter);
+
+                    // Apply acute angle bonus for BPM above 300 1/2 and distance more than one diameter
+                    acuteAngleBonus *= angleBonus *
+                                       DifficultyCalculationUtils.Smootherstep(DifficultyCalculationUtils.MillisecondsToBPM(osuCurrObj.StrainTime, 2), 300, 400) *
+                                       DifficultyCalculationUtils.Smootherstep(osuCurrObj.LazyJumpDistance, diameter, diameter * 2);
+
+                    // Apply wiggle bonus for jumps that are [radius, 3*diameter] in distance, with < 110 angle
+                    // https://www.desmos.com/calculator/dp0v0nvowc
+                    wiggleBonus = angleBonus
+                                  * DifficultyCalculationUtils.Smootherstep(osuCurrObj.LazyJumpDistance, radius, diameter)
+                                  * Math.Pow(DifficultyCalculationUtils.ReverseLerp(osuCurrObj.LazyJumpDistance, diameter * 3, diameter), 1.8)
+                                  * DifficultyCalculationUtils.Smootherstep(currAngle, double.DegreesToRadians(110), double.DegreesToRadians(60))
+                                  * DifficultyCalculationUtils.Smootherstep(osuLastObj.LazyJumpDistance, radius, diameter)
+                                  * Math.Pow(DifficultyCalculationUtils.ReverseLerp(osuLastObj.LazyJumpDistance, diameter * 3, diameter), 1.8)
+                                  * DifficultyCalculationUtils.Smootherstep(lastAngle, double.DegreesToRadians(110), double.DegreesToRadians(60));
                }
            }

@@ -122,6 +130,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
                sliderBonus = osuLastObj.TravelDistance / osuLastObj.TravelTime;
            }

+            aimStrain += wiggleBonus * wiggle_multiplier;
+
            // Add in acute angle bonus or wide angle bonus + velocity change bonus, whichever is larger.
            aimStrain += Math.Max(acuteAngleBonus * acute_angle_multiplier, wideAngleBonus * wide_angle_multiplier + velocityChangeBonus * velocity_change_multiplier);

@@ -132,8 +142,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
            return aimStrain;
        }

-        private static double calcWideAngleBonus(double angle) => Math.Pow(Math.Sin(3.0 / 4 * (Math.Min(5.0 / 6 * Math.PI, Math.Max(Math.PI / 6, angle)) - Math.PI / 6)), 2);
+        private static double calcWideAngleBonus(double angle) => DifficultyCalculationUtils.Smoothstep(angle, double.DegreesToRadians(40), double.DegreesToRadians(140));

-        private static double calcAcuteAngleBonus(double angle) => 1 - calcWideAngleBonus(angle);
+        private static double calcAcuteAngleBonus(double angle) => DifficultyCalculationUtils.Smoothstep(angle, double.DegreesToRadians(140), double.DegreesToRadians(40));
    }
 }
@@ -52,12 +52,12 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
                var currentObj = (OsuDifficultyHitObject)current.Previous(i);
                var currentHitObject = (OsuHitObject)(currentObj.BaseObject);

+                cumulativeStrainTime += lastObj.StrainTime;
+
                if (!(currentObj.BaseObject is Spinner))
                {
                    double jumpDistance = (osuHitObject.StackedPosition - currentHitObject.StackedEndPosition).Length;

-                    cumulativeStrainTime += lastObj.StrainTime;
-
                    // We want to nerf objects that can be easily seen within the Flashlight circle radius.
                    if (i == 0)
                        smallDistNerf = Math.Min(1.0, jumpDistance / 75.0);
@@ -2,9 +2,13 @@
 // See the LICENCE file in the repository root for full licence text.

 using System;
+using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Utils;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;

 namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
@@ -14,7 +18,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
        private const double single_spacing_threshold = OsuDifficultyHitObject.NORMALISED_DIAMETER * 1.25; // 1.25 circles distance between centers
        private const double min_speed_bonus = 200; // 200 BPM 1/4th
        private const double speed_balancing_factor = 40;
-        private const double distance_multiplier = 0.94;
+        private const double distance_multiplier = 0.9;

        /// <summary>
        /// Evaluates the difficulty of tapping the current object, based on:
@@ -24,7 +28,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
        /// <item><description>and how easily they can be cheesed.</description></item>
        /// </list>
        /// </summary>
-        public static double EvaluateDifficultyOf(DifficultyHitObject current)
+        public static double EvaluateDifficultyOf(DifficultyHitObject current, IReadOnlyList<Mod> mods)
        {
            if (current.BaseObject is Spinner)
                return 0;
@@ -56,6 +60,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
            // Max distance bonus is 1 * `distance_multiplier` at single_spacing_threshold
            double distanceBonus = Math.Pow(distance / single_spacing_threshold, 3.95) * distance_multiplier;

+            if (mods.OfType<OsuModAutopilot>().Any())
+                distanceBonus = 0;
+
            // Base difficulty with all bonuses
            double difficulty = (1 + speedBonus + distanceBonus) * 1000 / strainTime;

@@ -8,6 +8,7 @@ using Newtonsoft.Json;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Objects;

 namespace osu.Game.Rulesets.Osu.Difficulty
 {
@@ -19,6 +20,12 @@ namespace osu.Game.Rulesets.Osu.Difficulty
        [JsonProperty("aim_difficulty")]
        public double AimDifficulty { get; set; }

+        /// <summary>
+        /// The number of <see cref="Slider"/>s weighted by difficulty.
+        /// </summary>
+        [JsonProperty("aim_difficult_slider_count")]
+        public double AimDifficultSliderCount { get; set; }
+
        /// <summary>
        /// The difficulty corresponding to the speed skill.
        /// </summary>
@@ -52,24 +59,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty
        [JsonProperty("speed_difficult_strain_count")]
        public double SpeedDifficultStrainCount { get; set; }

-        /// <summary>
-        /// The perceived approach rate inclusive of rate-adjusting mods (DT/HT/etc).
-        /// </summary>
-        /// <remarks>
-        /// Rate-adjusting mods don't directly affect the approach rate difficulty value, but have a perceived effect as a result of adjusting audio timing.
-        /// </remarks>
-        [JsonProperty("approach_rate")]
-        public double ApproachRate { get; set; }
-
-        /// <summary>
-        /// The perceived overall difficulty inclusive of rate-adjusting mods (DT/HT/etc).
-        /// </summary>
-        /// <remarks>
-        /// Rate-adjusting mods don't directly affect the overall difficulty value, but have a perceived effect as a result of adjusting audio timing.
-        /// </remarks>
-        [JsonProperty("overall_difficulty")]
-        public double OverallDifficulty { get; set; }
-
        /// <summary>
        /// The beatmap's drain rate. This doesn't scale with rate-adjusting mods.
        /// </summary>
@@ -97,8 +86,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty

            yield return (ATTRIB_ID_AIM, AimDifficulty);
            yield return (ATTRIB_ID_SPEED, SpeedDifficulty);
-            yield return (ATTRIB_ID_OVERALL_DIFFICULTY, OverallDifficulty);
-            yield return (ATTRIB_ID_APPROACH_RATE, ApproachRate);
            yield return (ATTRIB_ID_DIFFICULTY, StarRating);

            if (ShouldSerializeFlashlightDifficulty())
@@ -109,6 +96,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
            yield return (ATTRIB_ID_AIM_DIFFICULT_STRAIN_COUNT, AimDifficultStrainCount);
            yield return (ATTRIB_ID_SPEED_DIFFICULT_STRAIN_COUNT, SpeedDifficultStrainCount);
            yield return (ATTRIB_ID_SPEED_NOTE_COUNT, SpeedNoteCount);
+            yield return (ATTRIB_ID_AIM_DIFFICULT_SLIDER_COUNT, AimDifficultSliderCount);
        }

        public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values, IBeatmapOnlineInfo onlineInfo)
@@ -117,14 +105,13 @@ namespace osu.Game.Rulesets.Osu.Difficulty

            AimDifficulty = values[ATTRIB_ID_AIM];
            SpeedDifficulty = values[ATTRIB_ID_SPEED];
-            OverallDifficulty = values[ATTRIB_ID_OVERALL_DIFFICULTY];
-            ApproachRate = values[ATTRIB_ID_APPROACH_RATE];
            StarRating = values[ATTRIB_ID_DIFFICULTY];
            FlashlightDifficulty = values.GetValueOrDefault(ATTRIB_ID_FLASHLIGHT);
            SliderFactor = values[ATTRIB_ID_SLIDER_FACTOR];
            AimDifficultStrainCount = values[ATTRIB_ID_AIM_DIFFICULT_STRAIN_COUNT];
            SpeedDifficultStrainCount = values[ATTRIB_ID_SPEED_DIFFICULT_STRAIN_COUNT];
            SpeedNoteCount = values[ATTRIB_ID_SPEED_NOTE_COUNT];
+            AimDifficultSliderCount = values[ATTRIB_ID_AIM_DIFFICULT_SLIDER_COUNT];
            DrainRate = onlineInfo.DrainRate;
            HitCircleCount = onlineInfo.CircleCount;
            SliderCount = onlineInfo.SliderCount;
@@ -15,8 +15,6 @@ using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Osu.Difficulty.Skills;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.Scoring;
-using osu.Game.Rulesets.Scoring;

 namespace osu.Game.Rulesets.Osu.Difficulty
 {
@@ -24,7 +22,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
    {
        private const double difficulty_multiplier = 0.0675;

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

        public OsuDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
            : base(ruleset, beatmap)
@@ -36,20 +34,22 @@ namespace osu.Game.Rulesets.Osu.Difficulty
            if (beatmap.HitObjects.Count == 0)
                return new OsuDifficultyAttributes { Mods = mods };

-            double aimRating = Math.Sqrt(skills[0].DifficultyValue()) * difficulty_multiplier;
-            double aimRatingNoSliders = Math.Sqrt(skills[1].DifficultyValue()) * difficulty_multiplier;
-            double speedRating = Math.Sqrt(skills[2].DifficultyValue()) * difficulty_multiplier;
-            double speedNotes = ((Speed)skills[2]).RelevantNoteCount();
-
-            double flashlightRating = 0.0;
-
-            if (mods.Any(h => h is OsuModFlashlight))
-                flashlightRating = Math.Sqrt(skills[3].DifficultyValue()) * difficulty_multiplier;
+            var aim = skills.OfType<Aim>().Single(a => a.IncludeSliders);
+            double aimRating = Math.Sqrt(aim.DifficultyValue()) * difficulty_multiplier;
+            double aimDifficultyStrainCount = aim.CountTopWeightedStrains();
+            double difficultSliders = aim.GetDifficultSliders();

+            var aimWithoutSliders = skills.OfType<Aim>().Single(a => !a.IncludeSliders);
+            double aimRatingNoSliders = Math.Sqrt(aimWithoutSliders.DifficultyValue()) * difficulty_multiplier;
            double sliderFactor = aimRating > 0 ? aimRatingNoSliders / aimRating : 1;

-            double aimDifficultyStrainCount = ((OsuStrainSkill)skills[0]).CountTopWeightedStrains();
-            double speedDifficultyStrainCount = ((OsuStrainSkill)skills[2]).CountTopWeightedStrains();
+            var speed = skills.OfType<Speed>().Single();
+            double speedRating = Math.Sqrt(speed.DifficultyValue()) * difficulty_multiplier;
+            double speedNotes = speed.RelevantNoteCount();
+            double speedDifficultyStrainCount = speed.CountTopWeightedStrains();
+
+            var flashlight = skills.OfType<Flashlight>().SingleOrDefault();
+            double flashlightRating = flashlight == null ? 0.0 : Math.Sqrt(flashlight.DifficultyValue()) * difficulty_multiplier;

            if (mods.Any(m => m is OsuModTouchDevice))
            {
@@ -63,6 +63,12 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                speedRating = 0.0;
                flashlightRating *= 0.7;
            }
+            else if (mods.Any(h => h is OsuModAutopilot))
+            {
+                speedRating *= 0.5;
+                aimRating = 0.0;
+                flashlightRating *= 0.4;
+            }

            double baseAimPerformance = OsuStrainSkill.DifficultyToPerformance(aimRating);
            double baseSpeedPerformance = OsuStrainSkill.DifficultyToPerformance(speedRating);
@@ -82,31 +88,24 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                ? 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;

            int hitCirclesCount = beatmap.HitObjects.Count(h => h is HitCircle);
            int sliderCount = beatmap.HitObjects.Count(h => h is Slider);
            int spinnerCount = beatmap.HitObjects.Count(h => h is Spinner);

-            HitWindows hitWindows = new OsuHitWindows();
-            hitWindows.SetDifficulty(beatmap.Difficulty.OverallDifficulty);
-
-            double hitWindowGreat = hitWindows.WindowFor(HitResult.Great) / clockRate;
-
            OsuDifficultyAttributes attributes = new OsuDifficultyAttributes
            {
                StarRating = starRating,
                Mods = mods,
                AimDifficulty = aimRating,
+                AimDifficultSliderCount = difficultSliders,
                SpeedDifficulty = speedRating,
                SpeedNoteCount = speedNotes,
                FlashlightDifficulty = flashlightRating,
                SliderFactor = sliderFactor,
                AimDifficultStrainCount = aimDifficultyStrainCount,
                SpeedDifficultStrainCount = speedDifficultyStrainCount,
-                ApproachRate = preempt > 1200 ? (1800 - preempt) / 120 : (1200 - preempt) / 150 + 5,
-                OverallDifficulty = (80 - hitWindowGreat) / 6,
                DrainRate = drainRate,
                MaxCombo = beatmap.GetMaxCombo(),
                HitCircleCount = hitCirclesCount,
@@ -24,6 +24,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty
        [JsonProperty("effective_miss_count")]
        public double EffectiveMissCount { get; set; }

+        [JsonProperty("speed_deviation")]
+        public double? SpeedDeviation { get; set; }
+
        public override IEnumerable<PerformanceDisplayAttribute> GetAttributesForDisplay()
        {
            foreach (var attribute in base.GetAttributesForDisplay())
@@ -4,9 +4,15 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Audio.Track;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Difficulty.Utils;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Difficulty.Skills;
 using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;

@@ -40,6 +46,15 @@ namespace osu.Game.Rulesets.Osu.Difficulty
        /// </summary>
        private double effectiveMissCount;

+        private double clockRate;
+        private double greatHitWindow;
+        private double okHitWindow;
+        private double mehHitWindow;
+        private double overallDifficulty;
+        private double approachRate;
+
+        private double? speedDeviation;
+
        public OsuPerformanceCalculator()
            : base(new OsuRuleset())
        {
@@ -61,6 +76,26 @@ namespace osu.Game.Rulesets.Osu.Difficulty
            countSliderTickMiss = score.Statistics.GetValueOrDefault(HitResult.LargeTickMiss);
            effectiveMissCount = countMiss;

+            var difficulty = score.BeatmapInfo!.Difficulty.Clone();
+
+            score.Mods.OfType<IApplicableToDifficulty>().ForEach(m => m.ApplyToDifficulty(difficulty));
+
+            var track = new TrackVirtual(10000);
+            score.Mods.OfType<IApplicableToTrack>().ForEach(m => m.ApplyToTrack(track));
+            clockRate = track.Rate;
+
+            HitWindows hitWindows = new OsuHitWindows();
+            hitWindows.SetDifficulty(difficulty.OverallDifficulty);
+
+            greatHitWindow = hitWindows.WindowFor(HitResult.Great) / clockRate;
+            okHitWindow = hitWindows.WindowFor(HitResult.Ok) / clockRate;
+            mehHitWindow = hitWindows.WindowFor(HitResult.Meh) / clockRate;
+
+            double preempt = IBeatmapDifficultyInfo.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
+
+            overallDifficulty = (80 - greatHitWindow) / 6;
+            approachRate = preempt > 1200 ? (1800 - preempt) / 120 : (1200 - preempt) / 150 + 5;
+
            if (osuAttributes.SliderCount > 0)
            {
                if (usingClassicSliderAccuracy)
@@ -103,17 +138,20 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                // 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);
+                double okMultiplier = Math.Max(0.0, overallDifficulty > 0.0 ? 1 - Math.Pow(overallDifficulty / 13.33, 1.8) : 1.0);
+                double mehMultiplier = Math.Max(0.0, overallDifficulty > 0.0 ? 1 - Math.Pow(overallDifficulty / 13.33, 5) : 1.0);

                // 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);
            }

+            speedDeviation = calculateSpeedDeviation(osuAttributes);
+
            double aimValue = computeAimValue(score, osuAttributes);
            double speedValue = computeSpeedValue(score, osuAttributes);
            double accuracyValue = computeAccuracyValue(score, osuAttributes);
            double flashlightValue = computeFlashlightValue(score, osuAttributes);
+
            double totalValue =
                Math.Pow(
                    Math.Pow(aimValue, 1.1) +
@@ -129,13 +167,40 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                Accuracy = accuracyValue,
                Flashlight = flashlightValue,
                EffectiveMissCount = effectiveMissCount,
+                SpeedDeviation = speedDeviation,
                Total = totalValue
            };
        }

        private double computeAimValue(ScoreInfo score, OsuDifficultyAttributes attributes)
        {
-            double aimValue = OsuStrainSkill.DifficultyToPerformance(attributes.AimDifficulty);
+            if (score.Mods.Any(h => h is OsuModAutopilot))
+                return 0.0;
+
+            double aimDifficulty = attributes.AimDifficulty;
+
+            if (attributes.SliderCount > 0 && attributes.AimDifficultSliderCount > 0)
+            {
+                double estimateImproperlyFollowedDifficultSliders;
+
+                if (usingClassicSliderAccuracy)
+                {
+                    // When the score is considered classic (regardless if it was made on old client or not) we consider all missing combo to be dropped difficult sliders
+                    int maximumPossibleDroppedSliders = totalImperfectHits;
+                    estimateImproperlyFollowedDifficultSliders = Math.Clamp(Math.Min(maximumPossibleDroppedSliders, attributes.MaxCombo - scoreMaxCombo), 0, attributes.AimDifficultSliderCount);
+                }
+                else
+                {
+                    // We add tick misses here since they too mean that the player didn't follow the slider properly
+                    // We however aren't adding misses here because missing slider heads has a harsh penalty by itself and doesn't mean that the rest of the slider wasn't followed properly
+                    estimateImproperlyFollowedDifficultSliders = Math.Clamp(countSliderEndsDropped + countSliderTickMiss, 0, attributes.AimDifficultSliderCount);
+                }
+
+                double sliderNerfFactor = (1 - attributes.SliderFactor) * Math.Pow(1 - estimateImproperlyFollowedDifficultSliders / attributes.AimDifficultSliderCount, 3) + attributes.SliderFactor;
+                aimDifficulty *= sliderNerfFactor;
+            }
+
+            double aimValue = OsuStrainSkill.DifficultyToPerformance(aimDifficulty);

            double lengthBonus = 0.95 + 0.4 * Math.Min(1.0, totalHits / 2000.0) +
                                 (totalHits > 2000 ? Math.Log10(totalHits / 2000.0) * 0.5 : 0.0);
@@ -145,10 +210,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                aimValue *= calculateMissPenalty(effectiveMissCount, attributes.AimDifficultStrainCount);

            double approachRateFactor = 0.0;
-            if (attributes.ApproachRate > 10.33)
-                approachRateFactor = 0.3 * (attributes.ApproachRate - 10.33);
-            else if (attributes.ApproachRate < 8.0)
-                approachRateFactor = 0.05 * (8.0 - attributes.ApproachRate);
+            if (approachRate > 10.33)
+                approachRateFactor = 0.3 * (approachRate - 10.33);
+            else if (approachRate < 8.0)
+                approachRateFactor = 0.05 * (8.0 - approachRate);

            if (score.Mods.Any(h => h is OsuModRelax))
                approachRateFactor = 0.0;
@@ -160,43 +225,19 @@ namespace osu.Game.Rulesets.Osu.Difficulty
            else if (score.Mods.Any(m => m is OsuModHidden || m is OsuModTraceable))
            {
                // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
-                aimValue *= 1.0 + 0.04 * (12.0 - attributes.ApproachRate);
-            }
-
-            // We assume 15% of sliders in a map are difficult since there's no way to tell from the performance calculator.
-            double estimateDifficultSliders = attributes.SliderCount * 0.15;
-
-            if (attributes.SliderCount > 0)
-            {
-                double estimateImproperlyFollowedDifficultSliders;
-
-                if (usingClassicSliderAccuracy)
-                {
-                    // When the score is considered classic (regardless if it was made on old client or not) we consider all missing combo to be dropped difficult sliders
-                    int maximumPossibleDroppedSliders = totalImperfectHits;
-                    estimateImproperlyFollowedDifficultSliders = Math.Clamp(Math.Min(maximumPossibleDroppedSliders, attributes.MaxCombo - scoreMaxCombo), 0, estimateDifficultSliders);
-                }
-                else
-                {
-                    // We add tick misses here since they too mean that the player didn't follow the slider properly
-                    // We however aren't adding misses here because missing slider heads has a harsh penalty by itself and doesn't mean that the rest of the slider wasn't followed properly
-                    estimateImproperlyFollowedDifficultSliders = Math.Clamp(countSliderEndsDropped + countSliderTickMiss, 0, estimateDifficultSliders);
-                }
-
-                double sliderNerfFactor = (1 - attributes.SliderFactor) * Math.Pow(1 - estimateImproperlyFollowedDifficultSliders / estimateDifficultSliders, 3) + attributes.SliderFactor;
-                aimValue *= sliderNerfFactor;
+                aimValue *= 1.0 + 0.04 * (12.0 - approachRate);
            }

            aimValue *= accuracy;
            // It is important to consider accuracy difficulty when scaling with accuracy.
-            aimValue *= 0.98 + Math.Pow(attributes.OverallDifficulty, 2) / 2500;
+            aimValue *= 0.98 + Math.Pow(Math.Max(0, overallDifficulty), 2) / 2500;

            return aimValue;
        }

        private double computeSpeedValue(ScoreInfo score, OsuDifficultyAttributes attributes)
        {
-            if (score.Mods.Any(h => h is OsuModRelax))
+            if (score.Mods.Any(h => h is OsuModRelax) || speedDeviation == null)
                return 0.0;

            double speedValue = OsuStrainSkill.DifficultyToPerformance(attributes.SpeedDifficulty);
@@ -209,8 +250,11 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                speedValue *= calculateMissPenalty(effectiveMissCount, attributes.SpeedDifficultStrainCount);

            double approachRateFactor = 0.0;
-            if (attributes.ApproachRate > 10.33)
-                approachRateFactor = 0.3 * (attributes.ApproachRate - 10.33);
+            if (approachRate > 10.33)
+                approachRateFactor = 0.3 * (approachRate - 10.33);
+
+            if (score.Mods.Any(h => h is OsuModAutopilot))
+                approachRateFactor = 0.0;

            speedValue *= 1.0 + approachRateFactor * lengthBonus; // Buff for longer maps with high AR.

@@ -222,21 +266,21 @@ namespace osu.Game.Rulesets.Osu.Difficulty
            else if (score.Mods.Any(m => m is OsuModHidden || m is OsuModTraceable))
            {
                // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
-                speedValue *= 1.0 + 0.04 * (12.0 - attributes.ApproachRate);
+                speedValue *= 1.0 + 0.04 * (12.0 - approachRate);
            }

+            double speedHighDeviationMultiplier = calculateSpeedHighDeviationNerf(attributes);
+            speedValue *= speedHighDeviationMultiplier;
+
            // Calculate accuracy assuming the worst case scenario
-            double relevantTotalDiff = totalHits - attributes.SpeedNoteCount;
+            double relevantTotalDiff = Math.Max(0, totalHits - attributes.SpeedNoteCount);
            double relevantCountGreat = Math.Max(0, countGreat - relevantTotalDiff);
            double relevantCountOk = Math.Max(0, countOk - Math.Max(0, relevantTotalDiff - countGreat));
            double relevantCountMeh = Math.Max(0, countMeh - Math.Max(0, relevantTotalDiff - countGreat - countOk));
            double relevantAccuracy = attributes.SpeedNoteCount == 0 ? 0 : (relevantCountGreat * 6.0 + relevantCountOk * 2.0 + relevantCountMeh) / (attributes.SpeedNoteCount * 6.0);

            // Scale the speed value with accuracy and OD.
-            speedValue *= (0.95 + Math.Pow(attributes.OverallDifficulty, 2) / 750) * Math.Pow((accuracy + relevantAccuracy) / 2.0, (14.5 - attributes.OverallDifficulty) / 2);
-
-            // Scale the speed value with # of 50s to punish doubletapping.
-            speedValue *= Math.Pow(0.99, countMeh < totalHits / 500.0 ? 0 : countMeh - totalHits / 500.0);
+            speedValue *= (0.95 + Math.Pow(Math.Max(0, overallDifficulty), 2) / 750) * Math.Pow((accuracy + relevantAccuracy) / 2.0, (14.5 - overallDifficulty) / 2);

            return speedValue;
        }
@@ -253,7 +297,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                amountHitObjectsWithAccuracy += attributes.SliderCount;

            if (amountHitObjectsWithAccuracy > 0)
-                betterAccuracyPercentage = ((countGreat - (totalHits - amountHitObjectsWithAccuracy)) * 6 + countOk * 2 + countMeh) / (double)(amountHitObjectsWithAccuracy * 6);
+                betterAccuracyPercentage = ((countGreat - Math.Max(totalHits - amountHitObjectsWithAccuracy, 0)) * 6 + countOk * 2 + countMeh) / (double)(amountHitObjectsWithAccuracy * 6);
            else
                betterAccuracyPercentage = 0;

@@ -263,7 +307,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty

            // Lots of arbitrary values from testing.
            // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution.
-            double accuracyValue = Math.Pow(1.52163, attributes.OverallDifficulty) * Math.Pow(betterAccuracyPercentage, 24) * 2.83;
+            double accuracyValue = Math.Pow(1.52163, overallDifficulty) * Math.Pow(betterAccuracyPercentage, 24) * 2.83;

            // Bonus for many hitcircles - it's harder to keep good accuracy up for longer.
            accuracyValue *= Math.Min(1.15, Math.Pow(amountHitObjectsWithAccuracy / 1000.0, 0.3));
@@ -300,17 +344,117 @@ namespace osu.Game.Rulesets.Osu.Difficulty
            // Scale the flashlight value with accuracy _slightly_.
            flashlightValue *= 0.5 + accuracy / 2.0;
            // It is important to also consider accuracy difficulty when doing that.
-            flashlightValue *= 0.98 + Math.Pow(attributes.OverallDifficulty, 2) / 2500;
+            flashlightValue *= 0.98 + Math.Pow(Math.Max(0, overallDifficulty), 2) / 2500;

            return flashlightValue;
        }

+        /// <summary>
+        /// Estimates player's deviation on speed notes using <see cref="calculateDeviation"/>, assuming worst-case.
+        /// Treats all speed notes as hit circles.
+        /// </summary>
+        private double? calculateSpeedDeviation(OsuDifficultyAttributes attributes)
+        {
+            if (totalSuccessfulHits == 0)
+                return null;
+
+            // Calculate accuracy assuming the worst case scenario
+            double speedNoteCount = attributes.SpeedNoteCount;
+            speedNoteCount += (totalHits - attributes.SpeedNoteCount) * 0.1;
+
+            // Assume worst case: all mistakes were on speed notes
+            double relevantCountMiss = Math.Min(countMiss, speedNoteCount);
+            double relevantCountMeh = Math.Min(countMeh, speedNoteCount - relevantCountMiss);
+            double relevantCountOk = Math.Min(countOk, speedNoteCount - relevantCountMiss - relevantCountMeh);
+            double relevantCountGreat = Math.Max(0, speedNoteCount - relevantCountMiss - relevantCountMeh - relevantCountOk);
+
+            return calculateDeviation(attributes, relevantCountGreat, relevantCountOk, relevantCountMeh, relevantCountMiss);
+        }
+
+        /// <summary>
+        /// Estimates the player's tap deviation based on the OD, given number of greats, oks, mehs and misses,
+        /// assuming the player's mean hit error is 0. The estimation is consistent in that two SS scores on the same map with the same settings
+        /// will always return the same deviation. Misses are ignored because they are usually due to misaiming.
+        /// Greats and oks are assumed to follow a normal distribution, whereas mehs are assumed to follow a uniform distribution.
+        /// </summary>
+        private double? calculateDeviation(OsuDifficultyAttributes attributes, double relevantCountGreat, double relevantCountOk, double relevantCountMeh, double relevantCountMiss)
+        {
+            if (relevantCountGreat + relevantCountOk + relevantCountMeh <= 0)
+                return null;
+
+            double objectCount = relevantCountGreat + relevantCountOk + relevantCountMeh + relevantCountMiss;
+
+            // The probability that a player hits a circle is unknown, but we can estimate it to be
+            // the number of greats on circles divided by the number of circles, and then add one
+            // to the number of circles as a bias correction.
+            double n = Math.Max(1, objectCount - relevantCountMiss - relevantCountMeh);
+            const double z = 2.32634787404; // 99% critical value for the normal distribution (one-tailed).
+
+            // Proportion of greats hit on circles, ignoring misses and 50s.
+            double p = relevantCountGreat / n;
+
+            // We can be 99% confident that p is at least this value.
+            double pLowerBound = (n * p + z * z / 2) / (n + z * z) - z / (n + z * z) * Math.Sqrt(n * p * (1 - p) + z * z / 4);
+
+            // Compute the deviation assuming greats and oks are normally distributed, and mehs are uniformly distributed.
+            // Begin with greats and oks first. Ignoring mehs, we can be 99% confident that the deviation is not higher than:
+            double deviation = greatHitWindow / (Math.Sqrt(2) * DifficultyCalculationUtils.ErfInv(pLowerBound));
+
+            double randomValue = Math.Sqrt(2 / Math.PI) * okHitWindow * Math.Exp(-0.5 * Math.Pow(okHitWindow / deviation, 2))
+                                 / (deviation * DifficultyCalculationUtils.Erf(okHitWindow / (Math.Sqrt(2) * deviation)));
+
+            deviation *= Math.Sqrt(1 - randomValue);
+
+            // Value deviation approach as greatCount approaches 0
+            double limitValue = okHitWindow / Math.Sqrt(3);
+
+            // If precision is not enough to compute true deviation - use limit value
+            if (pLowerBound == 0 || randomValue >= 1 || deviation > limitValue)
+                deviation = limitValue;
+
+            // Then compute the variance for mehs.
+            double mehVariance = (mehHitWindow * mehHitWindow + okHitWindow * mehHitWindow + okHitWindow * okHitWindow) / 3;
+
+            // Find the total deviation.
+            deviation = Math.Sqrt(((relevantCountGreat + relevantCountOk) * Math.Pow(deviation, 2) + relevantCountMeh * mehVariance) / (relevantCountGreat + relevantCountOk + relevantCountMeh));
+
+            return deviation;
+        }
+
+        // Calculates multiplier for speed to account for improper tapping based on the deviation and speed difficulty
+        // https://www.desmos.com/calculator/dmogdhzofn
+        private double calculateSpeedHighDeviationNerf(OsuDifficultyAttributes attributes)
+        {
+            if (speedDeviation == null)
+                return 0;
+
+            double speedValue = OsuStrainSkill.DifficultyToPerformance(attributes.SpeedDifficulty);
+
+            // Decides a point where the PP value achieved compared to the speed deviation is assumed to be tapped improperly. Any PP above this point is considered "excess" speed difficulty.
+            // This is used to cause PP above the cutoff to scale logarithmically towards the original speed value thus nerfing the value.
+            double excessSpeedDifficultyCutoff = 100 + 220 * Math.Pow(22 / speedDeviation.Value, 6.5);
+
+            if (speedValue <= excessSpeedDifficultyCutoff)
+                return 1.0;
+
+            const double scale = 50;
+            double adjustedSpeedValue = scale * (Math.Log((speedValue - excessSpeedDifficultyCutoff) / scale + 1) + excessSpeedDifficultyCutoff / scale);
+
+            // 220 UR and less are considered tapped correctly to ensure that normal scores will be punished as little as possible
+            double lerp = 1 - DifficultyCalculationUtils.ReverseLerp(speedDeviation.Value, 22.0, 27.0);
+            adjustedSpeedValue = double.Lerp(adjustedSpeedValue, speedValue, lerp);
+
+            return adjustedSpeedValue / speedValue;
+        }
+
        // Miss penalty assumes that a player will miss on the hardest parts of a map,
        // so we use the amount of relatively difficult sections to adjust miss penalty
        // to make it more punishing on maps with lower amount of hard sections.
        private double calculateMissPenalty(double missCount, double difficultStrainCount) => 0.96 / ((missCount / (4 * Math.Pow(Math.Log(difficultStrainCount), 0.94))) + 1);
        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;
        private int totalImperfectHits => countOk + countMeh + countMiss;
    }
 }
@@ -2,9 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.

 using System;
+using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Difficulty.Evaluators;
+using osu.Game.Rulesets.Osu.Objects;

 namespace osu.Game.Rulesets.Osu.Difficulty.Skills
 {
@@ -13,19 +16,21 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
    /// </summary>
    public class Aim : OsuStrainSkill
    {
-        public Aim(Mod[] mods, bool withSliders)
+        public readonly bool IncludeSliders;
+
+        public Aim(Mod[] mods, bool includeSliders)
            : base(mods)
        {
-            this.withSliders = withSliders;
+            IncludeSliders = includeSliders;
        }

-        private readonly bool withSliders;
-
        private double currentStrain;

-        private double skillMultiplier => 25.18;
+        private double skillMultiplier => 25.6;
        private double strainDecayBase => 0.15;

+        private readonly List<double> sliderStrains = new List<double>();
+
        private double strainDecay(double ms) => Math.Pow(strainDecayBase, ms / 1000);

        protected override double CalculateInitialStrain(double time, DifficultyHitObject current) => currentStrain * strainDecay(time - current.Previous(0).StartTime);
@@ -33,9 +38,26 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
        protected override double StrainValueAt(DifficultyHitObject current)
        {
            currentStrain *= strainDecay(current.DeltaTime);
-            currentStrain += AimEvaluator.EvaluateDifficultyOf(current, withSliders) * skillMultiplier;
+            currentStrain += AimEvaluator.EvaluateDifficultyOf(current, IncludeSliders) * skillMultiplier;
+
+            if (current.BaseObject is Slider)
+            {
+                sliderStrains.Add(currentStrain);
+            }

            return currentStrain;
        }
+
+        public double GetDifficultSliders()
+        {
+            if (sliderStrains.Count == 0)
+                return 0;
+
+            double maxSliderStrain = sliderStrains.Max();
+            if (maxSliderStrain == 0)
+                return 0;
+
+            return sliderStrains.Sum(strain => 1.0 / (1.0 + Math.Exp(-(strain / maxSliderStrain * 12.0 - 6.0))));
+        }
    }
 }
@@ -15,7 +15,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
    /// </summary>
    public class Speed : OsuStrainSkill
    {
-        private double skillMultiplier => 1.430;
+        private double skillMultiplier => 1.46;
        private double strainDecayBase => 0.3;

        private double currentStrain;
@@ -35,7 +35,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
        protected override double StrainValueAt(DifficultyHitObject current)
        {
            currentStrain *= strainDecay(((OsuDifficultyHitObject)current).StrainTime);
-            currentStrain += SpeedEvaluator.EvaluateDifficultyOf(current) * skillMultiplier;
+            currentStrain += SpeedEvaluator.EvaluateDifficultyOf(current, Mods) * skillMultiplier;

            currentRhythm = RhythmEvaluator.EvaluateDifficultyOf(current);

@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints
    public partial class GridPlacementBlueprint : PlacementBlueprint
    {
        [Resolved]
-        private HitObjectComposer? hitObjectComposer { get; set; }
+        private OsuHitObjectComposer? hitObjectComposer { get; set; }

        private OsuGridToolboxGroup gridToolboxGroup = null!;
        private Vector2 originalOrigin;
@@ -95,12 +95,12 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints
            base.OnDragEnd(e);
        }

-        public override SnapType SnapType => ~SnapType.GlobalGrids;
-
-        public override void UpdateTimeAndPosition(SnapResult result)
+        public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, double fallbackTime)
        {
            if (State.Value == Visibility.Hidden)
-                return;
+                return new SnapResult(screenSpacePosition, fallbackTime);
+
+            var result = hitObjectComposer?.TrySnapToNearbyObjects(screenSpacePosition) ?? new SnapResult(screenSpacePosition, fallbackTime);

            var pos = ToLocalSpace(result.ScreenSpacePosition);

@@ -120,6 +120,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints
                    gridToolboxGroup.SetGridFromPoints(gridToolboxGroup.StartPosition.Value, pos);
                }
            }
+
+            return result;
        }

        protected override void PopOut()
@@ -3,6 +3,7 @@

 #nullable disable

+using System;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -76,7 +77,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components
            if (hasReachedObject && showHitMarkers.Value)
            {
                float alpha = Interpolation.ValueAt(editorTime, 0, 1f, hitObjectTime, hitObjectTime + FADE_OUT_EXTENSION, Easing.In);
-                float ringScale = MathHelper.Clamp(Interpolation.ValueAt(editorTime, 0, 1f, hitObjectTime, hitObjectTime + FADE_OUT_EXTENSION / 2, Easing.OutQuint), 0, 1);
+                float ringScale = Math.Clamp(Interpolation.ValueAt(editorTime, 0, 1f, hitObjectTime, hitObjectTime + FADE_OUT_EXTENSION / 2, Easing.OutQuint), 0, 1);

                ring.Scale = new Vector2(1 + 0.1f * ringScale);
                content.Alpha = 0.9f * (1 - alpha);
@@ -1,10 +1,15 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Input.Events;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit;
+using osuTK;
 using osuTK.Input;

 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles
@@ -15,12 +20,26 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles

        private readonly HitCirclePiece circlePiece;

+        [Resolved]
+        private OsuHitObjectComposer? composer { get; set; }
+
+        [Resolved]
+        private EditorClock? editorClock { get; set; }
+
+        private Bindable<bool> limitedDistanceSnap { get; set; } = null!;
+
        public HitCirclePlacementBlueprint()
            : base(new HitCircle())
        {
            InternalChild = circlePiece = new HitCirclePiece();
        }

+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config)
+        {
+            limitedDistanceSnap = config.GetBindable<bool>(OsuSetting.EditorLimitedDistanceSnap);
+        }
+
        protected override void LoadComplete()
        {
            base.LoadComplete();
@@ -45,10 +64,17 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles
            return base.OnMouseDown(e);
        }

-        public override void UpdateTimeAndPosition(SnapResult result)
+        public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, double fallbackTime)
        {
-            base.UpdateTimeAndPosition(result);
+            var result = composer?.TrySnapToNearbyObjects(screenSpacePosition, fallbackTime);
+            result ??= composer?.TrySnapToDistanceGrid(screenSpacePosition, limitedDistanceSnap.Value && editorClock != null ? editorClock.CurrentTime : null);
+            if (composer?.TrySnapToPositionGrid(result?.ScreenSpacePosition ?? screenSpacePosition, result?.Time ?? fallbackTime) is SnapResult gridSnapResult)
+                result = gridSnapResult;
+            result ??= new SnapResult(screenSpacePosition, fallbackTime);
+
+            base.UpdateTimeAndPosition(result.ScreenSpacePosition, result.Time ?? fallbackTime);
            HitObject.Position = ToLocalSpace(result.ScreenSpacePosition);
+            return result;
        }
    }
 }
--- a/Show More
+++ b/Show More