Lazer release 2025-09

For tagging purposes.

.github/workflows/ci.yml

@@ -131,7 +131,7 @@ jobs:
 
   build-only-ios:
     name: Build only (iOS)
-    runs-on: macos-latest
+    runs-on: macos-15
     timeout-minutes: 60
     steps:
       - name: Checkout
@@ -143,7 +143,12 @@ jobs:
           dotnet-version: "8.0.x"
 
       - name: Install .NET Workloads
-        run: dotnet workload install ios --from-rollback-file https://raw.githubusercontent.com/ppy/osu-framework/refs/heads/master/workloads.json
+        run: dotnet workload install ios
+
+      # https://github.com/dotnet/macios/issues/19157
+      # https://github.com/actions/runner-images/issues/12758
+      - name: Use Xcode 16.4
+        run: sudo xcode-select -switch /Applications/Xcode_16.4.app
 
       - name: Build
         run: dotnet build -c Debug osu.iOS.slnf

Directory.Build.props

@@ -50,7 +50,7 @@
     <RepositoryUrl>https://github.com/ppy/osu</RepositoryUrl>
     <PackageReleaseNotes>Automated release.</PackageReleaseNotes>
     <Company>ppy Pty Ltd</Company>
-    <Copyright>Copyright (c) 2024 ppy Pty Ltd</Copyright>
+    <Copyright>Copyright (c) 2025 ppy Pty Ltd</Copyright>
     <PackageTags>osu game</PackageTags>
   </PropertyGroup>
 </Project>

LICENCE

@@ -1,4 +1,4 @@
-Copyright (c) 2024 ppy Pty Ltd <contact@ppy.sh>.
+Copyright (c) 2025 ppy Pty Ltd <contact@ppy.sh>.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Templates/osu.Game.Templates.csproj

@@ -8,7 +8,7 @@
     <PackageProjectUrl>https://github.com/ppy/osu/blob/master/Templates</PackageProjectUrl>
     <RepositoryUrl>https://github.com/ppy/osu</RepositoryUrl>
     <PackageReleaseNotes>Automated release.</PackageReleaseNotes>
-    <copyright>Copyright (c) 2024 ppy Pty Ltd</copyright>
+    <copyright>Copyright (c) 2025 ppy Pty Ltd</copyright>
     <Description>Templates to use when creating a ruleset for consumption in osu!.</Description>
     <PackageTags>dotnet-new;templates;osu</PackageTags>
     <TargetFramework>netstandard2.1</TargetFramework>

osu.Android.props

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

osu.Android/OsuGameAndroid.cs

@@ -2,10 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Linq;
 using Android.App;
 using Android.Content.PM;
 using Microsoft.Maui.Devices;
 using osu.Framework.Allocation;
+using osu.Framework.Development;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Platform;
 using osu.Game;
@@ -21,58 +23,30 @@ namespace osu.Android
         [Cached]
         private readonly OsuGameActivity gameActivity;
 
+        private readonly PackageInfo packageInfo;
+
         public override Vector2 ScalingContainerTargetDrawSize => new Vector2(1024, 1024 * DrawHeight / DrawWidth);
 
         public OsuGameAndroid(OsuGameActivity activity)
             : base(null)
         {
             gameActivity = activity;
+            packageInfo = Application.Context.ApplicationContext!.PackageManager!.GetPackageInfo(Application.Context.ApplicationContext.PackageName!, 0).AsNonNull();
         }
 
-        public override Version AssemblyVersion
+        public override string Version
         {
             get
             {
-                var packageInfo = Application.Context.ApplicationContext!.PackageManager!.GetPackageInfo(Application.Context.ApplicationContext.PackageName!, 0).AsNonNull();
+                if (!IsDeployedBuild)
+                    return @"local " + (DebugUtils.IsDebugBuild ? @"debug" : @"release");
 
-                try
-                {
-                    // We store the osu! build number in the "VersionCode" field to better support google play releases.
-                    // If we were to use the main build number, it would require a new submission each time (similar to TestFlight).
-                    // In order to do this, we should split it up and pad the numbers to still ensure sequential increase over time.
-                    //
-                    // We also need to be aware that older SDK versions store this as a 32bit int.
-                    //
-                    // Basic conversion format (as done in Fastfile): 2020.606.0 -> 202006060
-
-                    // https://stackoverflow.com/questions/52977079/android-sdk-28-versioncode-in-packageinfo-has-been-deprecated
-                    string versionName;
-
-                    if (OperatingSystem.IsAndroidVersionAtLeast(28))
-                    {
-                        versionName = packageInfo.LongVersionCode.ToString();
-                        // ensure we only read the trailing portion of long (the part we are interested in).
-                        versionName = versionName.Substring(versionName.Length - 9);
-                    }
-                    else
-                    {
-#pragma warning disable CS0618 // Type or member is obsolete
-                        // this is required else older SDKs will report missing method exception.
-                        versionName = packageInfo.VersionCode.ToString();
-#pragma warning restore CS0618 // Type or member is obsolete
-                    }
-
-                    // undo play store version garbling (as mentioned above).
-                    return new Version(int.Parse(versionName.Substring(0, 4)), int.Parse(versionName.Substring(4, 4)), int.Parse(versionName.Substring(8, 1)));
-                }
-                catch
-                {
-                }
-
-                return new Version(packageInfo.VersionName.AsNonNull());
+                return packageInfo.VersionName.AsNonNull();
             }
         }
 
+        public override Version AssemblyVersion => new Version(packageInfo.VersionName.AsNonNull().Split('-').First());
+
         protected override void LoadComplete()
         {
             base.LoadComplete();

osu.Desktop/OsuGameDesktop.cs

@@ -123,7 +123,7 @@ namespace osu.Desktop
 
         public override bool RestartAppWhenExited()
         {
-            Task.Run(() => Velopack.UpdateExe.Start()).FireAndForget();
+            Task.Run(() => Velopack.UpdateExe.Start(waitPid: (uint)Environment.ProcessId)).FireAndForget();
             return true;
         }
 

osu.Desktop/Program.cs

@@ -36,7 +36,7 @@ namespace osu.Desktop
             // IMPORTANT DON'T IGNORE: For general sanity, velopack's setup needs to run before anything else.
             // This has bitten us in the rear before (bricked updater), and although the underlying issue from
             // last time has been fixed, let's not tempt fate.
-            setupVelopack();
+            setupVelopack(args);
 
             if (OperatingSystem.IsWindows())
             {
@@ -174,8 +174,21 @@ namespace osu.Desktop
             return false;
         }
 
-        private static void setupVelopack()
+        private static void setupVelopack(string[] args)
         {
+            // Arguments being present indicate the user is either starting the game in a special (aka tournament) mode,
+            // or is running with pending imports via file association or otherwise.
+            //
+            // In both these scenarios, we'd hope the game does not attempt to update.
+            //
+            // Special consideration for velopack startup arguments, which must be handled during update.
+            // See https://docs.velopack.io/integrating/hooks#command-line-hooks.
+            if (args.Length > 0 && !args[0].StartsWith("--velo", StringComparison.Ordinal))
+            {
+                Logger.Log("Handling arguments, skipping velopack setup.");
+                return;
+            }
+
             if (OsuGameDesktop.IsPackageManaged)
             {
                 Logger.Log("Updates are being managed by an external provider. Skipping Velopack setup.");
@@ -184,7 +197,7 @@ namespace osu.Desktop
 
             var app = VelopackApp.Build();
 
-            app.WithFirstRun(_ => isFirstRun = true);
+            app.OnFirstRun(_ => isFirstRun = true);
 
             if (OperatingSystem.IsWindows())
                 configureWindows(app);
@@ -195,9 +208,9 @@ namespace osu.Desktop
         [SupportedOSPlatform("windows")]
         private static void configureWindows(VelopackApp app)
         {
-            app.WithFirstRun(_ => WindowsAssociationManager.InstallAssociations());
-            app.WithAfterUpdateFastCallback(_ => WindowsAssociationManager.UpdateAssociations());
-            app.WithBeforeUninstallFastCallback(_ => WindowsAssociationManager.UninstallAssociations());
+            app.OnFirstRun(_ => WindowsAssociationManager.InstallAssociations());
+            app.OnAfterUpdateFastCallback(_ => WindowsAssociationManager.UpdateAssociations());
+            app.OnBeforeUninstallFastCallback(_ => WindowsAssociationManager.UninstallAssociations());
         }
     }
 }

osu.Desktop/Updater/VelopackUpdateManager.cs

@@ -2,21 +2,22 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
-using osu.Framework.Bindables;
 using osu.Framework.Logging;
+using osu.Framework.Threading;
 using osu.Game;
-using osu.Game.Configuration;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Screens.Play;
 using Velopack;
 using Velopack.Sources;
+using UpdateManager = osu.Game.Updater.UpdateManager;
 
 namespace osu.Desktop.Updater
 {
-    public partial class VelopackUpdateManager : Game.Updater.UpdateManager
+    public partial class VelopackUpdateManager : UpdateManager
     {
         [Resolved]
         private INotificationOverlay notificationOverlay { get; set; } = null!;
@@ -27,143 +28,130 @@ namespace osu.Desktop.Updater
         [Resolved]
         private ILocalUserPlayInfo? localUserInfo { get; set; }
 
-        [Resolved]
-        private OsuConfigManager osuConfigManager { get; set; } = null!;
-
         private bool isInGameplay => localUserInfo?.PlayingState.Value != LocalUserPlayingState.NotPlaying;
 
-        private readonly Bindable<ReleaseStream> releaseStream = new Bindable<ReleaseStream>();
-        private UpdateManager? updateManager;
-        private UpdateInfo? pendingUpdate;
+        private ScheduledDelegate? scheduledBackgroundCheck;
 
-        protected override void LoadComplete()
+        private void scheduleNextUpdateCheck()
         {
-            // Used by the base implementation.
-            osuConfigManager.BindWith(OsuSetting.ReleaseStream, releaseStream);
-            releaseStream.BindValueChanged(_ => onReleaseStreamChanged(), true);
-
-            base.LoadComplete();
-        }
-
-        private void onReleaseStreamChanged()
-        {
-            updateManager = new UpdateManager(new GithubSource(@"https://github.com/ppy/osu", null, releaseStream.Value == ReleaseStream.Tachyon), new UpdateOptions
+            scheduledBackgroundCheck?.Cancel();
+            scheduledBackgroundCheck = Scheduler.AddDelayed(() =>
             {
-                AllowVersionDowngrade = true,
-            });
-
-            Schedule(() => Task.Run(CheckForUpdateAsync));
+                log("Running scheduled background update check...");
+                CheckForUpdate();
+            }, 60000 * 30);
         }
 
-        protected override async Task<bool> PerformUpdateCheck() => await checkForUpdateAsync().ConfigureAwait(false);
-
-        private async Task<bool> checkForUpdateAsync()
+        protected override async Task<bool> PerformUpdateCheck(CancellationToken cancellationToken)
         {
-            // whether to check again in 30 minutes. generally only if there's an error or no update was found (yet).
-            bool scheduleRecheck = false;
+            scheduledBackgroundCheck?.Cancel();
+
+            if (isInGameplay)
+            {
+                log("Update check cancelled - user is in gameplay");
+                scheduleNextUpdateCheck();
+                return false;
+            }
 
             try
             {
-                // Avoid any kind of update checking while gameplay is running.
-                if (isInGameplay)
+                IUpdateSource updateSource = new GithubSource(@"https://github.com/ppy/osu", null, ReleaseStream.Value == Game.Configuration.ReleaseStream.Tachyon);
+                Velopack.UpdateManager updateManager = new Velopack.UpdateManager(updateSource, new UpdateOptions
                 {
-                    scheduleRecheck = true;
+                    AllowVersionDowngrade = true
+                });
+
+                UpdateInfo? update = await updateManager.CheckForUpdatesAsync().ConfigureAwait(false);
+
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    log("Update check cancelled");
+                    scheduleNextUpdateCheck();
                     return true;
                 }
 
-                // TODO: we should probably be checking if there's a more recent update, rather than shortcutting here.
-                // Velopack does support this scenario (see https://github.com/ppy/osu/pull/28743#discussion_r1743495975).
-                if (pendingUpdate != null)
+                if (update == null)
                 {
-                    // If there is an update pending restart, show the notification to restart again.
-                    notificationOverlay.Post(new UpdateApplicationCompleteNotification
-                    {
-                        Activated = () =>
-                        {
-                            Task.Run(restartToApplyUpdate);
-                            return true;
-                        }
-                    });
-
-                    return true;
-                }
-
-                if (updateManager == null)
-                {
-                    scheduleRecheck = true;
+                    // No update is available.
+                    log("No update found");
+                    scheduleNextUpdateCheck();
                     return false;
                 }
 
-                pendingUpdate = await updateManager.CheckForUpdatesAsync().ConfigureAwait(false);
-
-                // No update is available. We'll check again later.
-                if (pendingUpdate == null)
-                {
-                    scheduleRecheck = true;
-                    return false;
-                }
-
-                // An update is found, let's notify the user and start downloading it.
-                UpdateProgressNotification notification = new UpdateProgressNotification
-                {
-                    CompletionClickAction = () =>
-                    {
-                        Task.Run(restartToApplyUpdate);
-                        return true;
-                    },
-                };
-
-                runOutsideOfGameplay(() => notificationOverlay.Post(notification));
-                notification.StartDownload();
-
-                try
-                {
-                    await updateManager.DownloadUpdatesAsync(pendingUpdate, p => notification.Progress = p / 100f).ConfigureAwait(false);
-                    runOutsideOfGameplay(() => notification.State = ProgressNotificationState.Completed);
-                }
-                catch (Exception e)
-                {
-                    // In the case of an error, a separate notification will be displayed.
-                    scheduleRecheck = true;
-                    notification.FailDownload();
-                    Logger.Error(e, @"update failed!");
-                }
+                // Download update in the background while notifying awaiters of the update being available.
+                log($"New update available: {update.TargetFullRelease.Version}");
+                downloadUpdate(updateManager, update, cancellationToken);
+                return true;
             }
             catch (Exception e)
             {
-                // we'll ignore this and retry later. can be triggered by no internet connection or thread abortion.
-                scheduleRecheck = true;
-                Logger.Log($@"update check failed ({e.Message})");
+                log($"Update check failed with error ({e.Message})");
+
+                // we shouldn't crash on a web failure. or any failure for the matter.
+                scheduleNextUpdateCheck();
+                return true;
             }
-            finally
+        }
+
+        private void downloadUpdate(Velopack.UpdateManager updateManager, UpdateInfo update, CancellationToken cancellationToken) => Task.Run(async () =>
+        {
+            log($"Beginning download of update {update.TargetFullRelease.Version}...");
+
+            UpdateDownloadProgressNotification progressNotification = new UpdateDownloadProgressNotification(cancellationToken)
             {
-                if (scheduleRecheck)
+                CompletionClickAction = () =>
                 {
-                    Scheduler.AddDelayed(() => Task.Run(async () => await checkForUpdateAsync().ConfigureAwait(false)), 60000 * 30);
+                    restartToApplyUpdate(updateManager, update);
+                    return true;
                 }
+            };
+
+            try
+            {
+                using (var cts = CancellationTokenSource.CreateLinkedTokenSource(progressNotification.CancellationToken, cancellationToken))
+                {
+                    progressNotification.StartDownload();
+                    runOutsideOfGameplay(() => notificationOverlay.Post(progressNotification), cts.Token);
+
+                    await updateManager.DownloadUpdatesAsync(update, p => progressNotification.Progress = p / 100f, cts.Token).ConfigureAwait(false);
+                    runOutsideOfGameplay(() => progressNotification.State = ProgressNotificationState.Completed, cts.Token);
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                progressNotification.FailDownload();
+                log(@"Update cancelled");
+            }
+            catch (Exception e)
+            {
+                // In the case of an error, a separate notification will be displayed.
+                progressNotification.FailDownload();
+                Logger.Error(e, @"Update failed!");
             }
 
             return true;
-        }
+        }, cancellationToken);
 
-        private void runOutsideOfGameplay(Action action)
+        private void runOutsideOfGameplay(Action action, CancellationToken cancellationToken)
         {
+            if (cancellationToken.IsCancellationRequested)
+                return;
+
             if (isInGameplay)
             {
-                Scheduler.AddDelayed(() => runOutsideOfGameplay(action), 1000);
+                Scheduler.AddDelayed(() => runOutsideOfGameplay(action, cancellationToken), 1000);
                 return;
             }
 
             action();
         }
 
-        private async Task restartToApplyUpdate()
+        private void restartToApplyUpdate(Velopack.UpdateManager updateManager, UpdateInfo update) => Task.Run(async () =>
         {
-            if (updateManager == null)
-                return;
-
-            await updateManager.WaitExitThenApplyUpdatesAsync(pendingUpdate?.TargetFullRelease).ConfigureAwait(false);
+            await updateManager.WaitExitThenApplyUpdatesAsync(update.TargetFullRelease).ConfigureAwait(false);
             Schedule(() => game.AttemptExit());
-        }
+        });
+
+        private static void log(string text) => Logger.Log($"VelopackUpdateManager: {text}");
     }
 }

osu.Desktop/osu.Desktop.csproj

@@ -26,7 +26,7 @@
   <ItemGroup Label="Package References">
     <PackageReference Include="System.IO.Packaging" Version="9.0.2" />
     <PackageReference Include="DiscordRichPresence" Version="1.2.1.24" />
-    <PackageReference Include="Velopack" Version="0.0.1053" />
+    <PackageReference Include="Velopack" Version="0.0.1298" />
   </ItemGroup>
   <ItemGroup Label="Resources">
     <EmbeddedResource Include="lazer.ico" />

osu.Desktop/osu.nuspec

@@ -12,7 +12,7 @@
         <requireLicenseAcceptance>false</requireLicenseAcceptance>
         <description>A free-to-win rhythm game. Rhythm is just a *click* away!</description>
         <releaseNotes>testing</releaseNotes>
-        <copyright>Copyright (c) 2024 ppy Pty Ltd</copyright>
+        <copyright>Copyright (c) 2025 ppy Pty Ltd</copyright>
         <language>en-AU</language>
     </metadata>
     <files>

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

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.Mods;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
@@ -21,8 +22,9 @@ namespace osu.Game.Rulesets.Catch.Tests
         {
             var ruleset = new CatchRuleset();
             var difficulty = new BeatmapDifficulty { ApproachRate = originalApproachRate };
+            var beatmapInfo = new BeatmapInfo { Difficulty = difficulty };
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 1);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(beatmapInfo, []);
 
             Assert.That(adjustedDifficulty.ApproachRate, Is.EqualTo(originalApproachRate));
         }
@@ -32,8 +34,9 @@ namespace osu.Game.Rulesets.Catch.Tests
         {
             var ruleset = new CatchRuleset();
             var difficulty = new BeatmapDifficulty();
+            var beatmapInfo = new BeatmapInfo { Difficulty = difficulty };
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 0.75);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(beatmapInfo, [new CatchModHalfTime()]);
 
             Assert.That(adjustedDifficulty.ApproachRate, Is.EqualTo(1.67).Within(0.01));
         }
@@ -43,8 +46,9 @@ namespace osu.Game.Rulesets.Catch.Tests
         {
             var ruleset = new CatchRuleset();
             var difficulty = new BeatmapDifficulty();
+            var beatmapInfo = new BeatmapInfo { Difficulty = difficulty };
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 1.5);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(beatmapInfo, [new CatchModDoubleTime()]);
 
             Assert.That(adjustedDifficulty.ApproachRate, Is.EqualTo(7.67).Within(0.01));
         }

osu.Game.Rulesets.Catch.Tests/Mods/TestSceneCatchModMovingFast.cs

@@ -0,0 +1,21 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Rulesets.Catch.Mods;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Catch.Tests.Mods
+{
+    public partial class TestSceneCatchModMovingFast : ModTestScene
+    {
+        protected override Ruleset CreatePlayerRuleset() => new CatchRuleset();
+
+        [Test]
+        public void TestMovingFast() => CreateModTest(new ModTestData
+        {
+            Mod = new CatchModMovingFast(),
+            PassCondition = () => true
+        });
+    }
+}

osu.Game.Rulesets.Catch.Tests/Resources/old-skin/skin.ini

@@ -1,2 +0,0 @@
-[General]
-// no version specified means v1

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

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
+using osu.Game.Localisation;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Objects;
 
@@ -23,21 +24,21 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
             {
                 new BeatmapStatistic
                 {
-                    Name = @"Fruits",
+                    Name = BeatmapStatisticStrings.Fruits,
                     Content = fruits.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
                     BarDisplayLength = fruits / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Juice Streams",
+                    Name = BeatmapStatisticStrings.JuiceStreams,
                     Content = juiceStreams.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
                     BarDisplayLength = juiceStreams / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Banana Showers",
+                    Name = BeatmapStatisticStrings.BananaShowers,
                     Content = bananaShowers.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Spinners),
                     BarDisplayLength = Math.Min(bananaShowers / 10f, 1),

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
@@ -11,6 +12,7 @@ using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Graphics;
+using osu.Game.Localisation;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Difficulty;
 using osu.Game.Rulesets.Catch.Edit;
@@ -25,6 +27,7 @@ using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Scoring.Legacy;
@@ -33,6 +36,7 @@ using osu.Game.Scoring;
 using osu.Game.Screens.Edit.Setup;
 using osu.Game.Screens.Ranking.Statistics;
 using osu.Game.Skinning;
+using osu.Game.Utils;
 using osuTK;
 
 namespace osu.Game.Rulesets.Catch
@@ -150,6 +154,7 @@ namespace osu.Game.Rulesets.Catch
                         new CatchModFloatingFruits(),
                         new CatchModMuted(),
                         new CatchModNoScope(),
+                        new CatchModMovingFast(),
                     };
 
                 case ModType.System:
@@ -265,9 +270,10 @@ namespace osu.Game.Rulesets.Catch
         }
 
         /// <seealso cref="CatchHitObject.ApplyDefaultsToSelf"/>
-        public override BeatmapDifficulty GetRateAdjustedDisplayDifficulty(IBeatmapDifficultyInfo difficulty, double rate)
+        public override BeatmapDifficulty GetAdjustedDisplayDifficulty(IBeatmapInfo beatmapInfo, IReadOnlyCollection<Mod> mods)
         {
-            BeatmapDifficulty adjustedDifficulty = new BeatmapDifficulty(difficulty);
+            BeatmapDifficulty adjustedDifficulty = base.GetAdjustedDisplayDifficulty(beatmapInfo, mods);
+            double rate = ModUtils.CalculateRateWithMods(mods);
 
             double preempt = IBeatmapDifficultyInfo.DifficultyRange(adjustedDifficulty.ApproachRate, CatchHitObject.PREEMPT_MAX, CatchHitObject.PREEMPT_MID, CatchHitObject.PREEMPT_MIN);
             preempt /= rate;
@@ -276,6 +282,33 @@ namespace osu.Game.Rulesets.Catch
             return adjustedDifficulty;
         }
 
+        public override IEnumerable<RulesetBeatmapAttribute> GetBeatmapAttributesForDisplay(IBeatmapInfo beatmapInfo, IReadOnlyCollection<Mod> mods)
+        {
+            var originalDifficulty = beatmapInfo.Difficulty;
+            var effectiveDifficulty = GetAdjustedDisplayDifficulty(beatmapInfo, mods);
+
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.CircleSize, @"CS", originalDifficulty.CircleSize, effectiveDifficulty.CircleSize, 10)
+            {
+                Description = "Affects the size of fruits.",
+                AdditionalMetrics =
+                [
+                    new RulesetBeatmapAttribute.AdditionalMetric("Hit circle radius", (CatchHitObject.OBJECT_RADIUS * LegacyRulesetExtensions.CalculateScaleFromCircleSize(effectiveDifficulty.CircleSize)).ToLocalisableString("0.#"))
+                ]
+            };
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.ApproachRate, @"AR", originalDifficulty.ApproachRate, effectiveDifficulty.ApproachRate, 10)
+            {
+                Description = "Affects how early fruits fade in on the screen.",
+                AdditionalMetrics =
+                [
+                    new RulesetBeatmapAttribute.AdditionalMetric("Fade-in time", LocalisableString.Interpolate($@"{IBeatmapDifficultyInfo.DifficultyRange(effectiveDifficulty.ApproachRate, CatchHitObject.PREEMPT_RANGE):#,0.##} ms"))
+                ]
+            };
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.HPDrain, @"HP", originalDifficulty.DrainRate, effectiveDifficulty.DrainRate, 10)
+            {
+                Description = "Affects the harshness of health drain and the health penalties for missing."
+            };
+        }
+
         public override bool EditorShowScrollSpeed => false;
     }
 }

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

@@ -18,6 +18,9 @@ namespace osu.Game.Rulesets.Catch.Edit
             new CheckBananaShowerGap(),
             new CheckConcurrentObjects(),
 
+            // Spread
+            new CheckCatchLowestDiffDrainTime(),
+
             // Settings
             new CheckCatchAbnormalDifficultySettings(),
         };

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

@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using System.Text.RegularExpressions;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -219,5 +220,40 @@ namespace osu.Game.Rulesets.Catch.Edit
             distanceSnapGrid.StartTime = sourceHitObject.GetEndTime();
             distanceSnapGrid.StartX = sourceHitObject.EffectiveX;
         }
+
+        #region Clipboard handling
+
+        public override string ConvertSelectionToString()
+            => string.Join(',', EditorBeatmap.SelectedHitObjects.Cast<CatchHitObject>().OrderBy(h => h.StartTime).Select(h => (h.IndexInCurrentCombo + 1).ToString()));
+
+        // 1,2,3,4 ...
+        private static readonly Regex selection_regex = new Regex(@"^\d+(,\d+)*$", RegexOptions.Compiled);
+
+        public override void SelectFromTimestamp(double timestamp, string objectDescription)
+        {
+            if (!selection_regex.IsMatch(objectDescription))
+                return;
+
+            List<CatchHitObject> remainingHitObjects = EditorBeatmap.HitObjects.Cast<CatchHitObject>().Where(h => h.StartTime >= timestamp).ToList();
+            string[] splitDescription = objectDescription.Split(',');
+
+            for (int i = 0; i < splitDescription.Length; i++)
+            {
+                if (!int.TryParse(splitDescription[i], out int combo) || combo < 1)
+                    continue;
+
+                CatchHitObject? current = remainingHitObjects.FirstOrDefault(h => h.IndexInCurrentCombo + 1 == combo);
+
+                if (current == null)
+                    continue;
+
+                EditorBeatmap.SelectedHitObjects.Add(current);
+
+                if (i < splitDescription.Length - 1)
+                    remainingHitObjects = remainingHitObjects.Where(h => h != current && h.StartTime >= current.StartTime).ToList();
+            }
+        }
+
+        #endregion
     }
 }

osu.Game.Rulesets.Catch/Edit/Checks/CheckBananaShowerGap.cs

@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var hitObjects = context.Beatmap.HitObjects;
+            var hitObjects = context.CurrentDifficulty.Playable.HitObjects;
             (int expectedStartDelta, int expectedEndDelta) = spinner_delta_threshold[context.InterpretedDifficulty];
 
             for (int i = 0; i < hitObjects.Count - 1; ++i)

osu.Game.Rulesets.Catch/Edit/Checks/CheckCatchAbnormalDifficultySettings.cs

@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Checks
 
         public override IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var diff = context.Beatmap.Difficulty;
+            var diff = context.CurrentDifficulty.Playable.Difficulty;
             Issue? issue;
 
             if (HasMoreThanOneDecimalPlace("Approach rate", diff.ApproachRate, out issue))

osu.Game.Rulesets.Catch/Edit/Checks/CheckCatchLowestDiffDrainTime.cs

@@ -0,0 +1,21 @@
+// 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 osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit.Checks;
+
+namespace osu.Game.Rulesets.Catch.Edit.Checks
+{
+    public class CheckCatchLowestDiffDrainTime : CheckLowestDiffDrainTime
+    {
+        protected override IEnumerable<(DifficultyRating rating, double thresholdMs, string name)> GetThresholds()
+        {
+            // See lowest difficulty requirements in https://osu.ppy.sh/wiki/en/Ranking_criteria/osu%21catch#general
+            yield return (DifficultyRating.Hard, new TimeSpan(0, 2, 30).TotalMilliseconds, "Platter");
+            yield return (DifficultyRating.Insane, new TimeSpan(0, 3, 15).TotalMilliseconds, "Rain");
+            yield return (DifficultyRating.Expert, new TimeSpan(0, 4, 0).TotalMilliseconds, "Overdose");
+        }
+    }
+}

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

@@ -1,7 +1,9 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Mods;
@@ -10,6 +12,8 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
     public class CatchModAutoplay : ModAutoplay
     {
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(CatchModMovingFast) }).ToArray();
+
         public override ModReplayData CreateReplayData(IBeatmap beatmap, IReadOnlyList<Mod> mods)
             => new ModReplayData(new CatchAutoGenerator(beatmap).Generate(), new ModCreatedUser { Username = "osu!salad" });
     }

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

@@ -1,7 +1,9 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Replays;
@@ -11,6 +13,8 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
     public class CatchModCinema : ModCinema<CatchHitObject>
     {
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(CatchModMovingFast) }).ToArray();
+
         public override ModReplayData CreateReplayData(IBeatmap beatmap, IReadOnlyList<Mod> mods)
             => new ModReplayData(new CatchAutoGenerator(beatmap).Generate(), new ModCreatedUser { Username = "osu!salad" });
     }

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

@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Catch.Mods
         {
             get
             {
-                if (UserAdjustedSettingsCount != 1)
+                if (!IsExactlyOneSettingChanged(CircleSize, ApproachRate, OverallDifficulty, DrainRate))
                     return string.Empty;
 
                 if (!CircleSize.IsDefault) return format("CS", CircleSize);

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Catch.Mods
@@ -9,5 +10,12 @@ namespace osu.Game.Rulesets.Catch.Mods
     public class CatchModEasy : ModEasyWithExtraLives
     {
         public override LocalisableString Description => @"Larger fruits, more forgiving HP drain, less accuracy required, and extra lives!";
+
+        public override void ApplyToDifficulty(BeatmapDifficulty difficulty)
+        {
+            base.ApplyToDifficulty(difficulty);
+
+            difficulty.OverallDifficulty *= ADJUST_RATIO;
+        }
     }
 }

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

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Catch.Mods
 
         public override BindableBool ComboBasedSize { get; } = new BindableBool(true);
 
-        public override float DefaultFlashlightSize => 325;
+        public override float DefaultFlashlightSize => 203.125f;
 
         protected override Flashlight CreateFlashlight() => new CatchFlashlight(this, playfield);
 

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

@@ -3,6 +3,7 @@
 
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
@@ -16,7 +17,7 @@ namespace osu.Game.Rulesets.Catch.Mods
         public override string Acronym => "FF";
         public override LocalisableString Description => "The fruits are... floating?";
         public override double ScoreMultiplier => 1;
-        public override IconUsage? Icon => FontAwesome.Solid.Cloud;
+        public override IconUsage? Icon => OsuIcon.ModFloatingFruits;
 
         public void ApplyToDrawableRuleset(DrawableRuleset<CatchHitObject> drawableRuleset)
         {

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

@@ -22,6 +22,7 @@ namespace osu.Game.Rulesets.Catch.Mods
         {
             base.ApplyToDifficulty(difficulty);
 
+            difficulty.OverallDifficulty = Math.Min(difficulty.OverallDifficulty * ADJUST_RATIO, 10.0f);
             difficulty.CircleSize = Math.Min(difficulty.CircleSize * 1.3f, 10.0f); // CS uses a custom 1.3 ratio.
             difficulty.ApproachRate = Math.Min(difficulty.ApproachRate * ADJUST_RATIO, 10.0f);
         }

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

@@ -0,0 +1,82 @@
+// 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.Sprites;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Mods
+{
+    public partial class CatchModMovingFast : Mod, IApplicableToDrawableRuleset<CatchHitObject>, IApplicableToPlayer
+    {
+        public override string Name => "Moving Fast";
+        public override string Acronym => "MF";
+        public override LocalisableString Description => "Dashing by default, slow down!";
+        public override ModType Type => ModType.Fun;
+        public override double ScoreMultiplier => 1;
+        public override IconUsage? Icon => OsuIcon.ModMovingFast;
+        public override Type[] IncompatibleMods => new[] { typeof(ModAutoplay), typeof(ModRelax) };
+
+        private DrawableCatchRuleset drawableRuleset = null!;
+
+        public void ApplyToDrawableRuleset(DrawableRuleset<CatchHitObject> drawableRuleset)
+        {
+            this.drawableRuleset = (DrawableCatchRuleset)drawableRuleset;
+        }
+
+        public void ApplyToPlayer(Player player)
+        {
+            if (!drawableRuleset.HasReplayLoaded.Value)
+            {
+                var catchPlayfield = (CatchPlayfield)drawableRuleset.Playfield;
+                catchPlayfield.Catcher.Dashing = true;
+                catchPlayfield.CatcherArea.Add(new InvertDashInputHelper(catchPlayfield.CatcherArea));
+            }
+        }
+
+        private partial class InvertDashInputHelper : Drawable, IKeyBindingHandler<CatchAction>
+        {
+            private readonly CatcherArea catcherArea;
+
+            public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
+
+            public InvertDashInputHelper(CatcherArea catcherArea)
+            {
+                this.catcherArea = catcherArea;
+
+                RelativeSizeAxes = Axes.Both;
+            }
+
+            public bool OnPressed(KeyBindingPressEvent<CatchAction> e)
+            {
+                switch (e.Action)
+                {
+                    case CatchAction.MoveLeft or CatchAction.MoveRight:
+                        break;
+
+                    case CatchAction.Dash:
+                        catcherArea.Catcher.Dashing = false;
+                        return true;
+                }
+
+                return false;
+            }
+
+            public void OnReleased(KeyBindingReleaseEvent<CatchAction> e)
+            {
+                if (e.Action == CatchAction.Dash)
+                    catcherArea.Catcher.Dashing = true;
+            }
+        }
+    }
+}

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

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using System.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
@@ -19,6 +21,8 @@ namespace osu.Game.Rulesets.Catch.Mods
     {
         public override LocalisableString Description => @"Use the mouse to control the catcher.";
 
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(CatchModMovingFast) }).ToArray();
+
         private DrawableCatchRuleset drawableRuleset = null!;
 
         public void ApplyToDrawableRuleset(DrawableRuleset<CatchHitObject> drawableRuleset)

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

@@ -150,7 +150,7 @@ namespace osu.Game.Rulesets.Catch.Objects
         {
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
 
-            TimePreempt = (float)IBeatmapDifficultyInfo.DifficultyRange(difficulty.ApproachRate, PREEMPT_MAX, PREEMPT_MID, PREEMPT_MIN);
+            TimePreempt = (float)IBeatmapDifficultyInfo.DifficultyRange(difficulty.ApproachRate, PREEMPT_RANGE);
 
             Scale = LegacyRulesetExtensions.CalculateScaleFromCircleSize(difficulty.CircleSize);
         }
@@ -203,6 +203,8 @@ namespace osu.Game.Rulesets.Catch.Objects
         /// </summary>
         public const double PREEMPT_MAX = 1800;
 
+        public static readonly DifficultyRange PREEMPT_RANGE = new DifficultyRange(PREEMPT_MAX, PREEMPT_MID, PREEMPT_MIN);
+
         /// <summary>
         /// The Y position of the hit object is not used in the normal osu!catch gameplay.
         /// It is preserved to maximize the backward compatibility with the legacy editor, in which the mappers use the Y position to organize the patterns.

osu.Game.Rulesets.Mania.Tests/Editor/Checks/CheckManiaConcurrentObjectsTest.cs

@@ -55,6 +55,16 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor.Checks
             });
         }
 
+        [Test]
+        public void TestHoldNotesAlmostConcurrentOnSameColumn()
+        {
+            assertAlmostConcurrentSame(new List<HitObject>
+            {
+                createHoldNote(startTime: 100, endTime: 400.75d, column: 1),
+                createHoldNote(startTime: 408, endTime: 700.75d, column: 1)
+            });
+        }
+
         private void assertOk(List<HitObject> hitobjects)
         {
             Assert.That(check.Run(getContext(hitobjects)), Is.Empty);
@@ -65,7 +75,17 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor.Checks
             var issues = check.Run(getContext(hitobjects)).ToList();
 
             Assert.That(issues, Has.Count.EqualTo(count));
-            Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrentSame));
+            Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrent));
+            Assert.That(issues.All(issue => issue.ToString().Contains("s are concurrent here")));
+        }
+
+        private void assertAlmostConcurrentSame(List<HitObject> hitobjects)
+        {
+            var issues = check.Run(getContext(hitobjects)).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateAlmostConcurrent));
+            Assert.That(issues.All(issue => issue.ToString().Contains("s are less than 10ms apart")));
         }
 
         private BeatmapVerifierContext getContext(List<HitObject> hitobjects)

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

@@ -22,6 +22,7 @@ namespace osu.Game.Rulesets.Mania.Tests
 
         [TestCase("convert-samples")]
         [TestCase("mania-samples")]
+        [TestCase("mania-slider")] // e.g. second and fourth notes of https://osu.ppy.sh/beatmapsets/73883#mania/216407
         [TestCase("slider-convert-samples")]
         public void Test(string name) => base.Test(name);
 
@@ -32,6 +33,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 StartTime = hitObject.StartTime,
                 EndTime = hitObject.GetEndTime(),
                 Column = ((ManiaHitObject)hitObject).Column,
+                PlaySlidingSamples = hitObject is HoldNote holdNote && holdNote.PlaySlidingSamples,
                 Samples = getSampleNames(hitObject.Samples),
                 NodeSamples = getNodeSampleNames((hitObject as HoldNote)?.NodeSamples)
             };
@@ -57,12 +59,14 @@ namespace osu.Game.Rulesets.Mania.Tests
         public double StartTime;
         public double EndTime;
         public int Column;
+        public bool PlaySlidingSamples;
         public IList<string> Samples;
         public IList<IList<string>> NodeSamples;
 
         public bool Equals(SampleConvertValue other)
             => Precision.AlmostEquals(StartTime, other.StartTime, conversion_lenience)
                && Precision.AlmostEquals(EndTime, other.EndTime, conversion_lenience)
+               && PlaySlidingSamples == other.PlaySlidingSamples
                && samplesEqual(Samples, other.Samples)
                && nodeSamplesEqual(NodeSamples, other.NodeSamples);
 

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

@@ -147,7 +147,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         }
 
         [TestCase]
-        public void TestFilterIntersection()
+        public void TestKeysFilterIntersection()
         {
             var criteria = new ManiaFilterCriteria();
             criteria.TryParseCustomKeywordCriteria("keys", Operator.Greater, "4");
@@ -175,7 +175,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         }
 
         [TestCase]
-        public void TestInvalidFilters()
+        public void TestInvalidKeysFilters()
         {
             var criteria = new ManiaFilterCriteria();
 
@@ -183,5 +183,132 @@ namespace osu.Game.Rulesets.Mania.Tests
             Assert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "4,some text"));
             Assert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.GreaterOrEqual, "4,5,6"));
         }
+
+        [TestCase]
+        public void TestLnsEqual()
+        {
+            var criteria = new ManiaFilterCriteria();
+            var filterCriteria = new FilterCriteria
+            {
+                Ruleset = new ManiaRuleset().RulesetInfo
+            };
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "0");
+            BeatmapInfo beatmapInfo1 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 0,
+                EndTimeObjectCount = 0
+            };
+            Assert.True(criteria.Matches(beatmapInfo1, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "0");
+            BeatmapInfo beatmapInfo2 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 0
+            };
+            Assert.True(criteria.Matches(beatmapInfo2, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "100");
+            BeatmapInfo beatmapInfo3 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 100
+            };
+            Assert.True(criteria.Matches(beatmapInfo3, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "1");
+            BeatmapInfo beatmapInfo4 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 1
+            };
+            Assert.True(criteria.Matches(beatmapInfo4, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "0.1");
+            BeatmapInfo beatmapInfo5 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 1000,
+                EndTimeObjectCount = 1
+            };
+            Assert.True(criteria.Matches(beatmapInfo5, filterCriteria));
+        }
+
+        [TestCase]
+        public void TestLnsGreaterOrEqual()
+        {
+            var criteria = new ManiaFilterCriteria();
+            var filterCriteria = new FilterCriteria
+            {
+                Ruleset = new ManiaRuleset().RulesetInfo
+            };
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "0");
+            BeatmapInfo beatmapInfo1 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 0,
+                EndTimeObjectCount = 0
+            };
+            Assert.True(criteria.Matches(beatmapInfo1, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "0");
+            BeatmapInfo beatmapInfo2 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 0
+            };
+            Assert.True(criteria.Matches(beatmapInfo2, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "100");
+            BeatmapInfo beatmapInfo3 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 100
+            };
+            Assert.True(criteria.Matches(beatmapInfo3, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "1");
+            BeatmapInfo beatmapInfo4 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 1
+            };
+            Assert.True(criteria.Matches(beatmapInfo4, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "0.1");
+            BeatmapInfo beatmapInfo5 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 1000,
+                EndTimeObjectCount = 1
+            };
+            Assert.True(criteria.Matches(beatmapInfo5, filterCriteria));
+        }
+
+        [TestCase]
+        public void TestLnsNotManiaRuleset()
+        {
+            var criteria = new ManiaFilterCriteria();
+            var filterCriteria = new FilterCriteria
+            {
+                Ruleset = new ManiaRuleset().RulesetInfo
+            };
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.LessOrEqual, "100");
+            BeatmapInfo beatmapInfo = new BeatmapInfo
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 50
+            };
+            Assert.False(criteria.Matches(beatmapInfo, filterCriteria));
+        }
+
+        [TestCase]
+        public void TestInvalidLnsFilters()
+        {
+            var criteria = new ManiaFilterCriteria();
+
+            Assert.False(criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "some text"));
+            Assert.False(criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "1some text"));
+        }
     }
 }

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

@@ -5,7 +5,6 @@ using System;
 using NUnit.Framework;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Rulesets.Mania.Mods;
-using osu.Game.Rulesets.Mods;
 using osu.Game.Tests.Beatmaps;
 
 namespace osu.Game.Rulesets.Mania.Tests
@@ -38,7 +37,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { LegacyMods.Key2, new[] { typeof(ManiaModKey2) } },
             new object[] { LegacyMods.Mirror, new[] { typeof(ManiaModMirror) } },
             new object[] { LegacyMods.HardRock | LegacyMods.DoubleTime, new[] { typeof(ManiaModHardRock), typeof(ManiaModDoubleTime) } },
-            new object[] { LegacyMods.ScoreV2, new[] { typeof(ModScoreV2) } },
+            new object[] { LegacyMods.ScoreV2, new[] { typeof(ManiaModScoreV2) } },
         };
 
         [TestCaseSource(nameof(mania_mod_mapping))]

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

@@ -5,6 +5,7 @@
       "StartTime": 1000.0,
       "EndTime": 2750.0,
       "Column": 1,
+      "PlaySlidingSamples": true,
       "NodeSamples": [
         ["Gameplay/normal-hitnormal"],
         ["Gameplay/soft-hitnormal"],
@@ -15,6 +16,7 @@
       "StartTime": 1875.0,
       "EndTime": 2750.0,
       "Column": 0,
+      "PlaySlidingSamples": true,
       "NodeSamples": [
         ["Gameplay/soft-hitnormal"],
         ["Gameplay/drum-hitnormal"]

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

@@ -5,6 +5,7 @@
       "StartTime": 500.0,
       "EndTime": 1500.0,
       "Column": 0,
+      "PlaySlidingSamples": false,
       "NodeSamples": [
         ["Gameplay/normal-hitnormal"],
         []
@@ -17,6 +18,7 @@
       "StartTime": 2000.0,
       "EndTime": 3000.0,
       "Column": 2,
+      "PlaySlidingSamples": false,
       "NodeSamples": [
         ["Gameplay/drum-hitnormal"],
         []

osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/mania-slider-expected-conversion.json

@@ -0,0 +1,18 @@
+{
+  "Mappings": [{
+    "StartTime": 500.0,
+    "Objects": [{
+      "StartTime": 500.0,
+      "EndTime": 2500,
+      "Column": 2,
+      "PlaySlidingSamples": true,
+      "NodeSamples": [
+        ["Gameplay/soft-hitnormal"],
+        ["Gameplay/soft-hitnormal"],
+        ["Gameplay/soft-hitnormal"],
+        ["Gameplay/soft-hitnormal"]
+      ],
+      "Samples": ["Gameplay/soft-hitnormal"]
+    }]
+  }]
+}

osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/mania-slider.osu

@@ -0,0 +1,29 @@
+osu file format v5
+
+[General]
+StackLeniency: 0.7
+Mode: 3
+
+[Difficulty]
+HPDrainRate:2
+CircleSize:5
+OverallDifficulty:2
+SliderMultiplier:1
+SliderTickRate:2
+
+[Events]
+//Background and Video events
+//Break Periods
+//Storyboard Layer 0 (Background)
+//Storyboard Layer 1 (Failing)
+//Storyboard Layer 2 (Passing)
+//Storyboard Layer 3 (Foreground)
+//Storyboard Sound Samples
+//Background Colour Transformations
+3,100,163,162,255
+
+[TimingPoints]
+355,476.190476190476,4,2,1,60,1,0
+
+[HitObjects]
+256,352,500,2,0,L|256:208,3,140

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

@@ -9,7 +9,6 @@ using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Replays;
-using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
@@ -19,7 +18,6 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {
-    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
     public partial class TestSceneLegacyReplayPlayback : LegacyReplayPlaybackTestScene
     {
         protected override Ruleset CreateRuleset() => new ManiaRuleset();
@@ -72,13 +70,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 5f, -137d, HitResult.Miss },
             new object[] { 5f, -138d, HitResult.Miss },
             new object[] { 5f, 111d, HitResult.Ok },
-            new object[] { 5f, 112d, HitResult.Miss },
-            new object[] { 5f, 113d, HitResult.Miss },
-            new object[] { 5f, 114d, HitResult.Miss },
-            new object[] { 5f, 135d, HitResult.Miss },
-            new object[] { 5f, 136d, HitResult.Miss },
-            new object[] { 5f, 137d, HitResult.Miss },
-            new object[] { 5f, 138d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 5f, 112d, HitResult.Miss },
+            // new object[] { 5f, 113d, HitResult.Miss },
+            // new object[] { 5f, 114d, HitResult.Miss },
+            // new object[] { 5f, 135d, HitResult.Miss },
+            // new object[] { 5f, 136d, HitResult.Miss },
+            // new object[] { 5f, 137d, HitResult.Miss },
+            // new object[] { 5f, 138d, HitResult.Miss },
 
             // OD = 9.3 test cases.
             // PERFECT hit window is [ -14ms,  14ms]
@@ -99,13 +98,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 9.3f, 70d, HitResult.Ok },
             new object[] { 9.3f, 71d, HitResult.Ok },
             new object[] { 9.3f, 98d, HitResult.Ok },
-            new object[] { 9.3f, 99d, HitResult.Miss },
-            new object[] { 9.3f, 100d, HitResult.Miss },
-            new object[] { 9.3f, 101d, HitResult.Miss },
-            new object[] { 9.3f, 122d, HitResult.Miss },
-            new object[] { 9.3f, 123d, HitResult.Miss },
-            new object[] { 9.3f, 124d, HitResult.Miss },
-            new object[] { 9.3f, 125d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 9.3f, 99d, HitResult.Miss },
+            // new object[] { 9.3f, 100d, HitResult.Miss },
+            // new object[] { 9.3f, 101d, HitResult.Miss },
+            // new object[] { 9.3f, 122d, HitResult.Miss },
+            // new object[] { 9.3f, 123d, HitResult.Miss },
+            // new object[] { 9.3f, 124d, HitResult.Miss },
+            // new object[] { 9.3f, 125d, HitResult.Miss },
             new object[] { 9.3f, -98d, HitResult.Ok },
             new object[] { 9.3f, -99d, HitResult.Ok },
             new object[] { 9.3f, -100d, HitResult.Meh },
@@ -145,13 +145,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 5f, -137d, HitResult.Miss },
             new object[] { 5f, -138d, HitResult.Miss },
             new object[] { 5f, 111d, HitResult.Ok },
-            new object[] { 5f, 112d, HitResult.Miss },
-            new object[] { 5f, 113d, HitResult.Miss },
-            new object[] { 5f, 114d, HitResult.Miss },
-            new object[] { 5f, 135d, HitResult.Miss },
-            new object[] { 5f, 136d, HitResult.Miss },
-            new object[] { 5f, 137d, HitResult.Miss },
-            new object[] { 5f, 138d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 5f, 112d, HitResult.Miss },
+            // new object[] { 5f, 113d, HitResult.Miss },
+            // new object[] { 5f, 114d, HitResult.Miss },
+            // new object[] { 5f, 135d, HitResult.Miss },
+            // new object[] { 5f, 136d, HitResult.Miss },
+            // new object[] { 5f, 137d, HitResult.Miss },
+            // new object[] { 5f, 138d, HitResult.Miss },
 
             // OD = 9.3 test cases.
             // PERFECT hit window is [ -16ms,  16ms]
@@ -172,13 +173,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 9.3f, 70d, HitResult.Ok },
             new object[] { 9.3f, 71d, HitResult.Ok },
             new object[] { 9.3f, 98d, HitResult.Ok },
-            new object[] { 9.3f, 99d, HitResult.Miss },
-            new object[] { 9.3f, 100d, HitResult.Miss },
-            new object[] { 9.3f, 101d, HitResult.Miss },
-            new object[] { 9.3f, 122d, HitResult.Miss },
-            new object[] { 9.3f, 123d, HitResult.Miss },
-            new object[] { 9.3f, 124d, HitResult.Miss },
-            new object[] { 9.3f, 125d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 9.3f, 99d, HitResult.Miss },
+            // new object[] { 9.3f, 100d, HitResult.Miss },
+            // new object[] { 9.3f, 101d, HitResult.Miss },
+            // new object[] { 9.3f, 122d, HitResult.Miss },
+            // new object[] { 9.3f, 123d, HitResult.Miss },
+            // new object[] { 9.3f, 124d, HitResult.Miss },
+            // new object[] { 9.3f, 125d, HitResult.Miss },
             new object[] { 9.3f, -98d, HitResult.Ok },
             new object[] { 9.3f, -99d, HitResult.Ok },
             new object[] { 9.3f, -100d, HitResult.Meh },
@@ -207,13 +209,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 3.1f, 88d, HitResult.Ok },
             new object[] { 3.1f, 89d, HitResult.Ok },
             new object[] { 3.1f, 116d, HitResult.Ok },
-            new object[] { 3.1f, 117d, HitResult.Miss },
-            new object[] { 3.1f, 118d, HitResult.Miss },
-            new object[] { 3.1f, 119d, HitResult.Miss },
-            new object[] { 3.1f, 140d, HitResult.Miss },
-            new object[] { 3.1f, 141d, HitResult.Miss },
-            new object[] { 3.1f, 142d, HitResult.Miss },
-            new object[] { 3.1f, 143d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 3.1f, 117d, HitResult.Miss },
+            // new object[] { 3.1f, 118d, HitResult.Miss },
+            // new object[] { 3.1f, 119d, HitResult.Miss },
+            // new object[] { 3.1f, 140d, HitResult.Miss },
+            // new object[] { 3.1f, 141d, HitResult.Miss },
+            // new object[] { 3.1f, 142d, HitResult.Miss },
+            // new object[] { 3.1f, 143d, HitResult.Miss },
             new object[] { 3.1f, -116d, HitResult.Ok },
             new object[] { 3.1f, -117d, HitResult.Ok },
             new object[] { 3.1f, -118d, HitResult.Meh },
@@ -253,13 +256,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 5f, -122d, HitResult.Miss },
             new object[] { 5f, -123d, HitResult.Miss },
             new object[] { 5f, 96d, HitResult.Ok },
-            new object[] { 5f, 97d, HitResult.Miss },
-            new object[] { 5f, 98d, HitResult.Miss },
-            new object[] { 5f, 99d, HitResult.Miss },
-            new object[] { 5f, 120d, HitResult.Miss },
-            new object[] { 5f, 121d, HitResult.Miss },
-            new object[] { 5f, 122d, HitResult.Miss },
-            new object[] { 5f, 123d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 5f, 97d, HitResult.Miss },
+            // new object[] { 5f, 98d, HitResult.Miss },
+            // new object[] { 5f, 99d, HitResult.Miss },
+            // new object[] { 5f, 120d, HitResult.Miss },
+            // new object[] { 5f, 121d, HitResult.Miss },
+            // new object[] { 5f, 122d, HitResult.Miss },
+            // new object[] { 5f, 123d, HitResult.Miss },
 
             // OD = 3.1 test cases.
             // PERFECT hit window is [ -16ms,  16ms]
@@ -280,13 +284,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 3.1f, 78d, HitResult.Ok },
             new object[] { 3.1f, 79d, HitResult.Ok },
             new object[] { 3.1f, 96d, HitResult.Ok },
-            new object[] { 3.1f, 97d, HitResult.Miss },
-            new object[] { 3.1f, 98d, HitResult.Miss },
-            new object[] { 3.1f, 99d, HitResult.Miss },
-            new object[] { 3.1f, 120d, HitResult.Miss },
-            new object[] { 3.1f, 121d, HitResult.Miss },
-            new object[] { 3.1f, 122d, HitResult.Miss },
-            new object[] { 3.1f, 123d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 3.1f, 97d, HitResult.Miss },
+            // new object[] { 3.1f, 98d, HitResult.Miss },
+            // new object[] { 3.1f, 99d, HitResult.Miss },
+            // new object[] { 3.1f, 120d, HitResult.Miss },
+            // new object[] { 3.1f, 121d, HitResult.Miss },
+            // new object[] { 3.1f, 122d, HitResult.Miss },
+            // new object[] { 3.1f, 123d, HitResult.Miss },
             new object[] { 3.1f, -96d, HitResult.Ok },
             new object[] { 3.1f, -97d, HitResult.Ok },
             new object[] { 3.1f, -98d, HitResult.Meh },
@@ -327,13 +332,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 5f, -98d, HitResult.Miss },
             new object[] { 5f, -99d, HitResult.Miss },
             new object[] { 5f, 79d, HitResult.Ok },
-            new object[] { 5f, 80d, HitResult.Miss },
-            new object[] { 5f, 81d, HitResult.Miss },
-            new object[] { 5f, 82d, HitResult.Miss },
-            new object[] { 5f, 96d, HitResult.Miss },
-            new object[] { 5f, 97d, HitResult.Miss },
-            new object[] { 5f, 98d, HitResult.Miss },
-            new object[] { 5f, 99d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 5f, 80d, HitResult.Miss },
+            // new object[] { 5f, 81d, HitResult.Miss },
+            // new object[] { 5f, 82d, HitResult.Miss },
+            // new object[] { 5f, 96d, HitResult.Miss },
+            // new object[] { 5f, 97d, HitResult.Miss },
+            // new object[] { 5f, 98d, HitResult.Miss },
+            // new object[] { 5f, 99d, HitResult.Miss },
 
             // OD = 9.3 test cases.
             // This leads to "effective" OD of 13.02.
@@ -356,13 +362,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 9.3f, 50d, HitResult.Ok },
             new object[] { 9.3f, 51d, HitResult.Ok },
             new object[] { 9.3f, 69d, HitResult.Ok },
-            new object[] { 9.3f, 70d, HitResult.Miss },
-            new object[] { 9.3f, 71d, HitResult.Miss },
-            new object[] { 9.3f, 72d, HitResult.Miss },
-            new object[] { 9.3f, 86d, HitResult.Miss },
-            new object[] { 9.3f, 87d, HitResult.Miss },
-            new object[] { 9.3f, 88d, HitResult.Miss },
-            new object[] { 9.3f, 89d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 9.3f, 70d, HitResult.Miss },
+            // new object[] { 9.3f, 71d, HitResult.Miss },
+            // new object[] { 9.3f, 72d, HitResult.Miss },
+            // new object[] { 9.3f, 86d, HitResult.Miss },
+            // new object[] { 9.3f, 87d, HitResult.Miss },
+            // new object[] { 9.3f, 88d, HitResult.Miss },
+            // new object[] { 9.3f, 89d, HitResult.Miss },
             new object[] { 9.3f, -69d, HitResult.Ok },
             new object[] { 9.3f, -70d, HitResult.Ok },
             new object[] { 9.3f, -71d, HitResult.Meh },
@@ -402,13 +409,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 5f, -191d, HitResult.Miss },
             new object[] { 5f, -192d, HitResult.Miss },
             new object[] { 5f, 155d, HitResult.Ok },
-            new object[] { 5f, 156d, HitResult.Miss },
-            new object[] { 5f, 157d, HitResult.Miss },
-            new object[] { 5f, 158d, HitResult.Miss },
-            new object[] { 5f, 189d, HitResult.Miss },
-            new object[] { 5f, 190d, HitResult.Miss },
-            new object[] { 5f, 191d, HitResult.Miss },
-            new object[] { 5f, 192d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 5f, 156d, HitResult.Miss },
+            // new object[] { 5f, 157d, HitResult.Miss },
+            // new object[] { 5f, 158d, HitResult.Miss },
+            // new object[] { 5f, 189d, HitResult.Miss },
+            // new object[] { 5f, 190d, HitResult.Miss },
+            // new object[] { 5f, 191d, HitResult.Miss },
+            // new object[] { 5f, 192d, HitResult.Miss },
         };
 
         private static readonly object[][] score_v1_non_convert_double_time_test_cases =
@@ -440,13 +448,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 5f, -205d, HitResult.Miss },
             new object[] { 5f, -206d, HitResult.Miss },
             new object[] { 5f, 167d, HitResult.Ok },
-            new object[] { 5f, 168d, HitResult.Miss },
-            new object[] { 5f, 169d, HitResult.Miss },
-            new object[] { 5f, 170d, HitResult.Miss },
-            new object[] { 5f, 203d, HitResult.Miss },
-            new object[] { 5f, 204d, HitResult.Miss },
-            new object[] { 5f, 205d, HitResult.Miss },
-            new object[] { 5f, 206d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 5f, 168d, HitResult.Miss },
+            // new object[] { 5f, 169d, HitResult.Miss },
+            // new object[] { 5f, 170d, HitResult.Miss },
+            // new object[] { 5f, 203d, HitResult.Miss },
+            // new object[] { 5f, 204d, HitResult.Miss },
+            // new object[] { 5f, 205d, HitResult.Miss },
+            // new object[] { 5f, 206d, HitResult.Miss },
         };
 
         private static readonly object[][] score_v1_non_convert_half_time_test_cases =
@@ -478,13 +487,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 5f, -103d, HitResult.Miss },
             new object[] { 5f, -104d, HitResult.Miss },
             new object[] { 5f, 83d, HitResult.Ok },
-            new object[] { 5f, 84d, HitResult.Miss },
-            new object[] { 5f, 85d, HitResult.Miss },
-            new object[] { 5f, 86d, HitResult.Miss },
-            new object[] { 5f, 101d, HitResult.Miss },
-            new object[] { 5f, 102d, HitResult.Miss },
-            new object[] { 5f, 103d, HitResult.Miss },
-            new object[] { 5f, 104d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 5f, 84d, HitResult.Miss },
+            // new object[] { 5f, 85d, HitResult.Miss },
+            // new object[] { 5f, 86d, HitResult.Miss },
+            // new object[] { 5f, 101d, HitResult.Miss },
+            // new object[] { 5f, 102d, HitResult.Miss },
+            // new object[] { 5f, 103d, HitResult.Miss },
+            // new object[] { 5f, 104d, HitResult.Miss },
         };
 
         private const double note_time = 300;
@@ -510,7 +520,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 ScoreInfo = new ScoreInfo
                 {
                     Ruleset = CreateRuleset().RulesetInfo,
-                    Mods = [new ModScoreV2()]
+                    Mods = [new ManiaModScoreV2()]
                 }
             };
 

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

@@ -203,7 +203,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         private void toggleTouchControls(bool enabled)
         {
             var maniaConfig = (ManiaRulesetConfigManager)RulesetConfigs.GetConfigFor(CreatePlayerRuleset())!;
-            maniaConfig.SetValue(ManiaRulesetSetting.MobileLayout, enabled ? ManiaMobileLayout.LandscapeWithOverlay : ManiaMobileLayout.Portrait);
+            maniaConfig.SetValue(ManiaRulesetSetting.TouchOverlay, enabled);
         }
 
         private ManiaTouchInputArea? getTouchOverlay() => this.ChildrenOfType<ManiaTouchInputArea>().SingleOrDefault();

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

@@ -12,7 +12,6 @@ using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {
-    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
     public partial class TestSceneReplayStability : ReplayStabilityTestScene
     {
         private static readonly object[][] test_cases =
@@ -22,87 +21,79 @@ namespace osu.Game.Rulesets.Mania.Tests
             // while round brackets `()` represent *open* or *exclusive* bounds.
 
             // OD = 5 test cases.
-            // PERFECT hit window is [ -19.4ms,  19.4ms]
-            // GREAT   hit window is [ -49.0ms,  49.0ms]
-            // GOOD    hit window is [ -82.0ms,  82.0ms]
-            // OK      hit window is [-112.0ms, 112.0ms]
-            // MEH     hit window is [-136.0ms, 136.0ms]
-            // MISS    hit window is [-173.0ms, 173.0ms]
+            // PERFECT hit window is [ -19.5ms,  19.5ms]
+            // GREAT   hit window is [ -49.5ms,  49.5ms]
+            // GOOD    hit window is [ -82.5ms,  82.5ms]
+            // OK      hit window is [-112.5ms, 112.5ms]
+            // MEH     hit window is [-136.5ms, 136.5ms]
+            // MISS    hit window is [-173.5ms, 173.5ms]
             new object[] { 5f, -19d, HitResult.Perfect },
             new object[] { 5f, -19.2d, HitResult.Perfect },
-            new object[] { 5f, -19.38d, HitResult.Perfect },
-            // new object[] { 5f, -19.4d, HitResult.Perfect }, <- in theory this should work, in practice it does not (fails even before encode & rounding due to floating point precision issues)
-            new object[] { 5f, -19.44d, HitResult.Great },
             new object[] { 5f, -19.7d, HitResult.Great },
             new object[] { 5f, -20d, HitResult.Great },
             new object[] { 5f, -48d, HitResult.Great },
             new object[] { 5f, -48.4d, HitResult.Great },
             new object[] { 5f, -48.7d, HitResult.Great },
             new object[] { 5f, -49d, HitResult.Great },
-            new object[] { 5f, -49.2d, HitResult.Good },
+            new object[] { 5f, -49.2d, HitResult.Great },
             new object[] { 5f, -49.7d, HitResult.Good },
             new object[] { 5f, -50d, HitResult.Good },
             new object[] { 5f, -81d, HitResult.Good },
             new object[] { 5f, -81.2d, HitResult.Good },
             new object[] { 5f, -81.7d, HitResult.Good },
             new object[] { 5f, -82d, HitResult.Good },
-            new object[] { 5f, -82.2d, HitResult.Ok },
+            new object[] { 5f, -82.2d, HitResult.Good },
             new object[] { 5f, -82.7d, HitResult.Ok },
             new object[] { 5f, -83d, HitResult.Ok },
             new object[] { 5f, -111d, HitResult.Ok },
             new object[] { 5f, -111.2d, HitResult.Ok },
             new object[] { 5f, -111.7d, HitResult.Ok },
             new object[] { 5f, -112d, HitResult.Ok },
-            new object[] { 5f, -112.2d, HitResult.Meh },
+            new object[] { 5f, -112.2d, HitResult.Ok },
             new object[] { 5f, -112.7d, HitResult.Meh },
             new object[] { 5f, -113d, HitResult.Meh },
             new object[] { 5f, -135d, HitResult.Meh },
             new object[] { 5f, -135.2d, HitResult.Meh },
             new object[] { 5f, -135.8d, HitResult.Meh },
             new object[] { 5f, -136d, HitResult.Meh },
-            new object[] { 5f, -136.2d, HitResult.Miss },
+            new object[] { 5f, -136.2d, HitResult.Meh },
             new object[] { 5f, -136.7d, HitResult.Miss },
             new object[] { 5f, -137d, HitResult.Miss },
 
             // OD = 9.3 test cases.
-            // PERFECT hit window is [ -14.67ms,  14.67ms]
-            // GREAT   hit window is [ -36.10ms,  36.10ms]
-            // GOOD    hit window is [ -69.10ms,  69.10ms]
-            // OK      hit window is [ -99.10ms,  99.10ms]
-            // MEH     hit window is [-123.10ms, 123.10ms]
-            // MISS    hit window is [-160.10ms, 160.10ms]
+            // PERFECT hit window is [ -14.5ms,  14.5ms]
+            // GREAT   hit window is [ -36.5ms,  36.5ms]
+            // GOOD    hit window is [ -69.5ms,  69.5ms]
+            // OK      hit window is [ -99.5ms,  99.5ms]
+            // MEH     hit window is [-123.5ms, 123.5ms]
+            // MISS    hit window is [-160.5ms, 160.5ms]
             new object[] { 9.3f, 14d, HitResult.Perfect },
             new object[] { 9.3f, 14.2d, HitResult.Perfect },
-            new object[] { 9.3f, 14.6d, HitResult.Perfect },
-            // new object[] { 9.3f, 14.67d, HitResult.Perfect }, <- in theory this should work, in practice it does not (fails even before encode & rounding due to floating point precision issues)
             new object[] { 9.3f, 14.7d, HitResult.Great },
             new object[] { 9.3f, 15d, HitResult.Great },
             new object[] { 9.3f, 35d, HitResult.Great },
             new object[] { 9.3f, 35.3d, HitResult.Great },
             new object[] { 9.3f, 35.8d, HitResult.Great },
-            new object[] { 9.3f, 36.05d, HitResult.Great },
-            new object[] { 9.3f, 36.3d, HitResult.Good },
+            new object[] { 9.3f, 36.3d, HitResult.Great },
             new object[] { 9.3f, 36.7d, HitResult.Good },
             new object[] { 9.3f, 37d, HitResult.Good },
             new object[] { 9.3f, 68d, HitResult.Good },
             new object[] { 9.3f, 68.4d, HitResult.Good },
             new object[] { 9.3f, 68.9d, HitResult.Good },
-            new object[] { 9.3f, 69.07d, HitResult.Good },
-            new object[] { 9.3f, 69.25d, HitResult.Ok },
+            new object[] { 9.3f, 69.25d, HitResult.Good },
             new object[] { 9.3f, 69.85d, HitResult.Ok },
             new object[] { 9.3f, 70d, HitResult.Ok },
             new object[] { 9.3f, 98d, HitResult.Ok },
             new object[] { 9.3f, 98.3d, HitResult.Ok },
             new object[] { 9.3f, 98.6d, HitResult.Ok },
             new object[] { 9.3f, 99d, HitResult.Ok },
-            new object[] { 9.3f, 99.3d, HitResult.Meh },
+            new object[] { 9.3f, 99.3d, HitResult.Ok },
             new object[] { 9.3f, 99.7d, HitResult.Meh },
             new object[] { 9.3f, 100d, HitResult.Meh },
             new object[] { 9.3f, 122d, HitResult.Meh },
             new object[] { 9.3f, 122.34d, HitResult.Meh },
             new object[] { 9.3f, 122.57d, HitResult.Meh },
-            new object[] { 9.3f, 123.04d, HitResult.Meh },
-            new object[] { 9.3f, 123.45d, HitResult.Miss },
+            new object[] { 9.3f, 123.45d, HitResult.Meh },
             new object[] { 9.3f, 123.95d, HitResult.Miss },
             new object[] { 9.3f, 124d, HitResult.Miss },
         };
@@ -110,7 +101,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         [TestCaseSource(nameof(test_cases))]
         public void TestHitWindowStability(float overallDifficulty, double hitOffset, HitResult expectedResult)
         {
-            const double note_time = 100;
+            const double note_time = 300;
 
             var beatmap = new ManiaBeatmap(new StageDefinition(1))
             {

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

@@ -47,8 +47,6 @@ namespace osu.Game.Rulesets.Mania.Tests
                         drawableRuleset = (DrawableManiaRuleset)Ruleset.Value.CreateInstance().CreateDrawableRulesetWith(createTestBeatmap())
                     }
                 };
-
-                drawableRuleset.AllowBackwardsSeeks = true;
             });
             AddStep("retrieve config bindable", () =>
             {

osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmap.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
+using osu.Game.Localisation;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.UI;
 
@@ -42,14 +43,14 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             {
                 new BeatmapStatistic
                 {
-                    Name = @"Notes",
+                    Name = BeatmapStatisticStrings.Notes,
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
                     Content = notes.ToString(),
                     BarDisplayLength = notes / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Hold Notes",
+                    Name = BeatmapStatisticStrings.HoldNotes,
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
                     Content = holdNotes.ToString(),
                     BarDisplayLength = holdNotes / (float)sum,

osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs

@@ -99,7 +99,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             }
         }
 
-        public static int GetColumnCount(LegacyBeatmapConversionDifficultyInfo difficulty, IReadOnlyList<Mod>? mods = null)
+        public static int GetColumnCount(LegacyBeatmapConversionDifficultyInfo difficulty, IReadOnlyCollection<Mod>? mods = null)
         {
             var converter = new ManiaBeatmapConverter(null, difficulty, new ManiaRuleset());
 

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

@@ -3,8 +3,10 @@
 
 using System.Collections.Generic;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Legacy;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Utils;
 
@@ -30,12 +32,18 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             if (HitObject is IHasDuration endTimeData)
             {
+                // despite the beatmap originally being made for mania, if the object is parsed as a slider rather than a hold, sliding samples should still be played.
+                // this is seemingly only possible to achieve by modifying the .osu file directly, but online beatmaps that do that exist
+                // (see second and fourth notes of https://osu.ppy.sh/beatmapsets/73883#mania/216407)
+                bool playSlidingSamples = (HitObject is IHasLegacyHitObjectType hasType && hasType.LegacyType == LegacyHitObjectType.Slider) || HitObject is IHasPath;
+
                 pattern.Add(new HoldNote
                 {
                     StartTime = HitObject.StartTime,
                     Duration = endTimeData.Duration,
                     Column = column,
                     Samples = HitObject.Samples,
+                    PlaySlidingSamples = playSlidingSamples,
                     NodeSamples = (HitObject as IHasRepeats)?.NodeSamples ?? HoldNote.CreateDefaultNodeSamples(HitObject)
                 });
             }

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

@@ -521,6 +521,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                     Duration = endTime - startTime,
                     Column = column,
                     Samples = HitObject.Samples,
+                    PlaySlidingSamples = true,
                     NodeSamples = nodeSamplesAt(startTime)
                 };
             }

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

@@ -14,6 +14,7 @@ namespace osu.Game.Rulesets.Mania.Configuration
         public ManiaRulesetConfigManager(SettingsStore? settings, RulesetInfo ruleset, int? variant = null)
             : base(settings, ruleset, variant)
         {
+            Migrate();
         }
 
         protected override void InitialiseDefaults()
@@ -24,6 +25,20 @@ namespace osu.Game.Rulesets.Mania.Configuration
             SetDefault(ManiaRulesetSetting.ScrollDirection, ManiaScrollingDirection.Down);
             SetDefault(ManiaRulesetSetting.TimingBasedNoteColouring, false);
             SetDefault(ManiaRulesetSetting.MobileLayout, ManiaMobileLayout.Portrait);
+            SetDefault(ManiaRulesetSetting.TouchOverlay, false);
+        }
+
+        public void Migrate()
+        {
+            var mobileLayout = GetBindable<ManiaMobileLayout>(ManiaRulesetSetting.MobileLayout);
+
+#pragma warning disable CS0618 // Type or member is obsolete
+            if (mobileLayout.Value == ManiaMobileLayout.LandscapeWithOverlay)
+#pragma warning restore CS0618 // Type or member is obsolete
+            {
+                mobileLayout.Value = ManiaMobileLayout.Landscape;
+                SetValue(ManiaRulesetSetting.TouchOverlay, true);
+            }
         }
 
         public override TrackedSettings CreateTrackedSettings() => new TrackedSettings
@@ -44,5 +59,6 @@ namespace osu.Game.Rulesets.Mania.Configuration
         ScrollDirection,
         TimingBasedNoteColouring,
         MobileLayout,
+        TouchOverlay,
     }
 }

osu.Game.Rulesets.Mania/Edit/Checks/CheckKeyCount.cs

@@ -18,7 +18,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var diff = context.Beatmap.Difficulty;
+            var diff = context.CurrentDifficulty.Playable.Difficulty;
 
             if (diff.CircleSize < 4)
             {

osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaAbnormalDifficultySettings.cs

@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Checks
 
         public override IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var diff = context.Beatmap.Difficulty;
+            var diff = context.CurrentDifficulty.Playable.Difficulty;
             Issue? issue;
 
             if (HasMoreThanOneDecimalPlace("Overall difficulty", diff.OverallDifficulty, out issue))

osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs

@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Checks
     {
         public override IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var hitObjects = context.Beatmap.HitObjects;
+            var hitObjects = context.CurrentDifficulty.Playable.HitObjects;
 
             for (int i = 0; i < hitObjects.Count - 1; ++i)
             {
@@ -28,14 +28,18 @@ namespace osu.Game.Rulesets.Mania.Edit.Checks
                         continue;
 
                     // Two hitobjects cannot be concurrent without also being concurrent with all objects in between.
-                    // So if the next object is not concurrent, then we know no future objects will be either.
-                    if (!AreConcurrent(hitobject, nextHitobject))
+                    // So if the next object is not concurrent or almost concurrent, then we know no future objects will be either.
+                    if (!AreConcurrent(hitobject, nextHitobject) && !AreAlmostConcurrent(hitobject, nextHitobject))
                         break;
 
-                    if (hitobject.GetType() == nextHitobject.GetType())
-                        yield return new IssueTemplateConcurrentSame(this).Create(hitobject, nextHitobject);
-                    else
-                        yield return new IssueTemplateConcurrentDifferent(this).Create(hitobject, nextHitobject);
+                    if (AreConcurrent(hitobject, nextHitobject))
+                    {
+                        yield return new IssueTemplateConcurrent(this).Create(hitobject, nextHitobject);
+                    }
+                    else if (AreAlmostConcurrent(hitobject, nextHitobject))
+                    {
+                        yield return new IssueTemplateAlmostConcurrent(this).Create(hitobject, nextHitobject);
+                    }
                 }
             }
         }

osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaLowestDiffDrainTime.cs

@@ -0,0 +1,21 @@
+// 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 osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit.Checks;
+
+namespace osu.Game.Rulesets.Mania.Edit.Checks
+{
+    public class CheckManiaLowestDiffDrainTime : CheckLowestDiffDrainTime
+    {
+        protected override IEnumerable<(DifficultyRating rating, double thresholdMs, string name)> GetThresholds()
+        {
+            // See lowest difficulty requirements in https://osu.ppy.sh/wiki/en/Ranking_criteria/osu%21mania#rules
+            yield return (DifficultyRating.Hard, new TimeSpan(0, 2, 30).TotalMilliseconds, "Hard");
+            yield return (DifficultyRating.Insane, new TimeSpan(0, 2, 45).TotalMilliseconds, "Insane");
+            yield return (DifficultyRating.Expert, new TimeSpan(0, 3, 30).TotalMilliseconds, "Expert");
+        }
+    }
+}

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

@@ -16,6 +16,9 @@ namespace osu.Game.Rulesets.Mania.Edit
             // Compose
             new CheckManiaConcurrentObjects(),
 
+            // Spread
+            new CheckManiaLowestDiffDrainTime(),
+
             // Settings
             new CheckKeyCount(),
             new CheckManiaAbnormalDifficultySettings(),

osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Bindables;
@@ -19,12 +20,16 @@ namespace osu.Game.Rulesets.Mania
     public class ManiaFilterCriteria : IRulesetFilterCriteria
     {
         private readonly HashSet<int> includedKeyCounts = Enumerable.Range(1, LegacyBeatmapDecoder.MAX_MANIA_KEY_COUNT).ToHashSet();
+        private FilterCriteria.OptionalRange<float> longNotePercentage;
 
         public bool Matches(BeatmapInfo beatmapInfo, FilterCriteria criteria)
         {
             int keyCount = ManiaBeatmapConverter.GetColumnCount(LegacyBeatmapConversionDifficultyInfo.FromBeatmapInfo(beatmapInfo), criteria.Mods);
 
-            return includedKeyCounts.Contains(keyCount);
+            bool keyCountMatch = includedKeyCounts.Contains(keyCount);
+            bool longNotePercentageMatch = !longNotePercentage.HasFilter || (!isConvertedBeatmap(beatmapInfo) && longNotePercentage.IsInRange(calculateLongNotePercentage(beatmapInfo)));
+
+            return keyCountMatch && longNotePercentageMatch;
         }
 
         public bool TryParseCustomKeywordCriteria(string key, Operator op, string strValues)
@@ -84,6 +89,10 @@ namespace osu.Game.Rulesets.Mania
                             return false;
                     }
                 }
+
+                case "ln":
+                case "lns":
+                    return FilterQueryParser.TryUpdateCriteriaRange(ref longNotePercentage, op, strValues);
             }
 
             return false;
@@ -103,5 +112,18 @@ namespace osu.Game.Rulesets.Mania
 
             return false;
         }
+
+        private static bool isConvertedBeatmap(BeatmapInfo beatmapInfo)
+        {
+            return !beatmapInfo.Ruleset.Equals(new ManiaRuleset().RulesetInfo);
+        }
+
+        private static float calculateLongNotePercentage(BeatmapInfo beatmapInfo)
+        {
+            int holdNotes = beatmapInfo.EndTimeObjectCount;
+            int totalNotes = Math.Max(1, beatmapInfo.TotalObjectCount);
+
+            return holdNotes / (float)totalNotes * 100;
+        }
     }
 }

osu.Game.Rulesets.Mania/ManiaMobileLayout.cs

@@ -1,20 +1,25 @@
 // 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.Localisation;
 using osu.Game.Localisation;
+using osu.Game.Rulesets.Mania.Configuration;
 
 namespace osu.Game.Rulesets.Mania
 {
     public enum ManiaMobileLayout
     {
-        [LocalisableDescription(typeof(RulesetSettingsStrings), nameof(RulesetSettingsStrings.PortraitExpandedColumns))]
+        [LocalisableDescription(typeof(RulesetSettingsStrings), nameof(RulesetSettingsStrings.Portrait))]
         Portrait,
 
-        [LocalisableDescription(typeof(RulesetSettingsStrings), nameof(RulesetSettingsStrings.LandscapeExpandedColumns))]
+        [LocalisableDescription(typeof(RulesetSettingsStrings), nameof(RulesetSettingsStrings.Landscape))]
         Landscape,
 
-        [LocalisableDescription(typeof(RulesetSettingsStrings), nameof(RulesetSettingsStrings.LandscapeTouchOverlay))]
+        [LocalisableDescription(typeof(RulesetSettingsStrings), nameof(RulesetSettingsStrings.LandscapeExpandedColumns))]
+        LandscapeExpandedColumns,
+
+        [Obsolete($"Use {nameof(ManiaRulesetSetting.TouchOverlay)} instead.")] // todo: can be removed 20260211
         LandscapeWithOverlay,
     }
 }

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
@@ -12,6 +13,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
+using osu.Game.Localisation;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Difficulty;
@@ -77,6 +79,7 @@ namespace osu.Game.Rulesets.Mania
                     return new ManiaArgonSkinTransformer(skin, beatmap);
 
                 case DefaultLegacySkin:
+                case RetroSkin:
                     return new ManiaClassicSkinTransformer(skin, beatmap);
 
                 case LegacySkin:
@@ -161,7 +164,7 @@ namespace osu.Game.Rulesets.Mania
                 yield return new ManiaModMirror();
 
             if (mods.HasFlag(LegacyMods.ScoreV2))
-                yield return new ModScoreV2();
+                yield return new ManiaModScoreV2();
         }
 
         public override LegacyMods ConvertToLegacyMods(Mod[] mods)
@@ -296,7 +299,7 @@ namespace osu.Game.Rulesets.Mania
                 case ModType.System:
                     return new Mod[]
                     {
-                        new ModScoreV2(),
+                        new ManiaModScoreV2(),
                     };
 
                 default:
@@ -414,6 +417,70 @@ namespace osu.Game.Rulesets.Mania
             }), true)
         };
 
+        /// <seealso cref="ManiaHitWindows"/>
+        public override BeatmapDifficulty GetAdjustedDisplayDifficulty(IBeatmapInfo beatmapInfo, IReadOnlyCollection<Mod> mods)
+        {
+            BeatmapDifficulty adjustedDifficulty = base.GetAdjustedDisplayDifficulty(beatmapInfo, mods);
+
+            // notably, in mania, hit windows are designed to be independent of track playback rate (see `ManiaHitWindows.SpeedMultiplier`).
+            // *however*, to not make matters *too* simple, mania Hard Rock and Easy differ from all other rulesets
+            // in that they apply multipliers *to hit window durations directly* rather than to the Overall Difficulty attribute itself.
+            // because the duration of hit window durations as a function of OD is not a linear function,
+            // this means that multiplying the OD is *not* the same thing as multiplying the hit window duration.
+            // in fact, the second operation is *much* harsher and will produce values much farther outside of normal operating range
+            // (even negative in the case of Easy).
+            // stable handles this wrong on song select and just assumes that it can handle mania EZ / HR the same way as all other rulesets.
+
+            double perfectHitWindow = IBeatmapDifficultyInfo.DifficultyRange(adjustedDifficulty.OverallDifficulty, ManiaHitWindows.PERFECT_WINDOW_RANGE);
+
+            if (mods.Any(m => m is ManiaModHardRock))
+                perfectHitWindow /= ManiaModHardRock.HIT_WINDOW_DIFFICULTY_MULTIPLIER;
+            else if (mods.Any(m => m is ManiaModEasy))
+                perfectHitWindow /= ManiaModEasy.HIT_WINDOW_DIFFICULTY_MULTIPLIER;
+
+            adjustedDifficulty.OverallDifficulty = (float)IBeatmapDifficultyInfo.InverseDifficultyRange(perfectHitWindow, ManiaHitWindows.PERFECT_WINDOW_RANGE);
+            adjustedDifficulty.CircleSize = ManiaBeatmapConverter.GetColumnCount(LegacyBeatmapConversionDifficultyInfo.FromBeatmapInfo(beatmapInfo), mods);
+
+            return adjustedDifficulty;
+        }
+
+        public override IEnumerable<RulesetBeatmapAttribute> GetBeatmapAttributesForDisplay(IBeatmapInfo beatmapInfo, IReadOnlyCollection<Mod> mods)
+        {
+            // a special touch-up of key count is required to the original difficulty, since key conversion mods are not `IApplicableToDifficulty`
+            var originalDifficulty = new BeatmapDifficulty(beatmapInfo.Difficulty)
+            {
+                CircleSize = ManiaBeatmapConverter.GetColumnCount(LegacyBeatmapConversionDifficultyInfo.FromBeatmapInfo(beatmapInfo), [])
+            };
+            var adjustedDifficulty = GetAdjustedDisplayDifficulty(beatmapInfo, mods);
+            var colours = new OsuColour();
+
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.KeyCount, @"KC", originalDifficulty.CircleSize, adjustedDifficulty.CircleSize, 18)
+            {
+                Description = "Affects the number of key columns on the playfield."
+            };
+
+            var hitWindows = new ManiaHitWindows();
+            hitWindows.SetDifficulty(adjustedDifficulty.OverallDifficulty);
+            hitWindows.IsConvert = !beatmapInfo.Ruleset.Equals(RulesetInfo);
+            hitWindows.ClassicModActive = mods.Any(m => m is ManiaModClassic);
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.Accuracy, @"OD", originalDifficulty.OverallDifficulty, adjustedDifficulty.OverallDifficulty, 10)
+            {
+                Description = "Affects timing requirements for notes.",
+                AdditionalMetrics = hitWindows.GetAllAvailableWindows()
+                                              .Reverse()
+                                              .Select(window => new RulesetBeatmapAttribute.AdditionalMetric(
+                                                  $"{window.result.GetDescription().ToUpperInvariant()} hit window",
+                                                  LocalisableString.Interpolate($@"±{hitWindows.WindowFor(window.result):0.##} ms"),
+                                                  colours.ForHitResult(window.result)
+                                              )).ToArray()
+            };
+
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.HPDrain, @"HP", originalDifficulty.DrainRate, adjustedDifficulty.DrainRate, 10)
+            {
+                Description = "Affects the harshness of health drain and the health penalties for missing."
+            };
+        }
+
         public override IRulesetFilterCriteria CreateRulesetFilterCriteria()
         {
             return new ManiaFilterCriteria();

osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using System.Linq;
 using osu.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
@@ -48,12 +50,21 @@ namespace osu.Game.Rulesets.Mania
                 },
             };
 
+            Add(new SettingsCheckbox
+            {
+                LabelText = RulesetSettingsStrings.TouchOverlay,
+                Current = config.GetBindable<bool>(ManiaRulesetSetting.TouchOverlay)
+            });
+
             if (RuntimeInfo.IsMobile)
             {
                 Add(new SettingsEnumDropdown<ManiaMobileLayout>
                 {
                     LabelText = RulesetSettingsStrings.MobileLayout,
                     Current = config.GetBindable<ManiaMobileLayout>(ManiaRulesetSetting.MobileLayout),
+#pragma warning disable CS0618 // Type or member is obsolete
+                    Items = Enum.GetValues<ManiaMobileLayout>().Where(l => l != ManiaMobileLayout.LandscapeWithOverlay),
+#pragma warning restore CS0618 // Type or member is obsolete
                 });
             }
         }

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

@@ -2,12 +2,10 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Bindables;
-using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -17,29 +15,21 @@ namespace osu.Game.Rulesets.Mania.Mods
     /// <remarks>
     /// Historically, in osu!mania, hit windows are expected to adjust relative to the gameplay rate such that the real-world hit window remains the same.
     /// </remarks>
-    public interface IManiaRateAdjustmentMod : IApplicableToDifficulty, IApplicableToHitObject
+    public interface IManiaRateAdjustmentMod : IApplicableToHitObject
     {
         BindableNumber<double> SpeedChange { get; }
 
-        HitWindows HitWindows { get; set; }
-
-        void IApplicableToDifficulty.ApplyToDifficulty(BeatmapDifficulty difficulty)
-        {
-            HitWindows = new ManiaHitWindows(SpeedChange.Value);
-            HitWindows.SetDifficulty(difficulty.OverallDifficulty);
-        }
-
         void IApplicableToHitObject.ApplyToHitObject(HitObject hitObject)
         {
             switch (hitObject)
             {
                 case Note:
-                    hitObject.HitWindows = HitWindows;
+                    ((ManiaHitWindows)hitObject.HitWindows).SpeedMultiplier = SpeedChange.Value;
                     break;
 
                 case HoldNote hold:
-                    hold.Head.HitWindows = HitWindows;
-                    hold.Tail.HitWindows = HitWindows;
+                    ((ManiaHitWindows)hold.Head.HitWindows).SpeedMultiplier = SpeedChange.Value;
+                    ((ManiaHitWindows)hold.Tail.HitWindows).SpeedMultiplier = SpeedChange.Value;
                     break;
             }
         }

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

@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override string Acronym => Name;
         public abstract int KeyCount { get; }
         public override ModType Type => ModType.Conversion;
-        public override double ScoreMultiplier => 1; // TODO: Implement the mania key mod score multiplier
+        public override double ScoreMultiplier => 0.9;
         public override bool Ranked => UsesDefaultConfiguration;
 
         public void ApplyToBeatmapConverter(IBeatmapConverter beatmapConverter)

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

@@ -1,11 +1,41 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModClassic : ModClassic
+    public class ManiaModClassic : ModClassic, IApplicableToBeatmap
     {
+        public void ApplyToBeatmap(IBeatmap beatmap)
+        {
+            bool isConvert = !beatmap.BeatmapInfo.Ruleset.Equals(new ManiaRuleset().RulesetInfo);
+
+            foreach (var ho in beatmap.HitObjects)
+            {
+                switch (ho)
+                {
+                    case Note note:
+                    {
+                        var hitWindows = (ManiaHitWindows)note.HitWindows;
+                        hitWindows.IsConvert = isConvert;
+                        hitWindows.ClassicModActive = true;
+                        break;
+                    }
+
+                    case HoldNote hold:
+                    {
+                        var headWindows = (ManiaHitWindows)hold.Head.HitWindows;
+                        var tailWindows = (ManiaHitWindows)hold.Tail.HitWindows;
+                        headWindows.IsConvert = tailWindows.IsConvert = isConvert;
+                        headWindows.ClassicModActive = tailWindows.ClassicModActive = true;
+                        break;
+                    }
+                }
+            }
+        }
     }
 }

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

@@ -4,6 +4,7 @@
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
@@ -21,7 +22,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override LocalisableString Description => "No more tricky speed changes!";
 
-        public override IconUsage? Icon => FontAwesome.Solid.Equals;
+        public override IconUsage? Icon => OsuIcon.ModConstantSpeed;
 
         public override ModType Type => ModType.Conversion;
 

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

@@ -4,8 +4,10 @@
 using System;
 using System.Linq;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.UI;
 
 namespace osu.Game.Rulesets.Mania.Mods
@@ -14,6 +16,7 @@ namespace osu.Game.Rulesets.Mania.Mods
     {
         public override string Name => "Cover";
         public override string Acronym => "CO";
+        public override IconUsage? Icon => OsuIcon.ModCover;
 
         public override LocalisableString Description => @"Decrease the playfield's viewing area.";
 

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

@@ -1,14 +1,11 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModDaycore : ModDaycore, IManiaRateAdjustmentMod
     {
-        public HitWindows HitWindows { get; set; } = new ManiaHitWindows();
     }
 }

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

@@ -1,16 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModDoubleTime : ModDoubleTime, IManiaRateAdjustmentMod
     {
-        public HitWindows HitWindows { get; set; } = new ManiaHitWindows();
-
         // For now, all rate-increasing mods should be given a 1x multiplier in mania because it doesn't always
         // make the map harder and is more of a personal preference.
         // In the future, we can consider adjusting this by experimenting with not applying the hitwindow leniency.

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

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

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

@@ -2,12 +2,32 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Localisation;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModEasy : ModEasyWithExtraLives
+    public class ManiaModEasy : ModEasyWithExtraLives, IApplicableToHitObject
     {
         public override LocalisableString Description => @"More forgiving HP drain, less accuracy required, and extra lives!";
+
+        public const double HIT_WINDOW_DIFFICULTY_MULTIPLIER = 1 / 1.4;
+
+        void IApplicableToHitObject.ApplyToHitObject(HitObject hitObject)
+        {
+            switch (hitObject)
+            {
+                case Note:
+                    ((ManiaHitWindows)hitObject.HitWindows).DifficultyMultiplier = HIT_WINDOW_DIFFICULTY_MULTIPLIER;
+                    break;
+
+                case HoldNote hold:
+                    ((ManiaHitWindows)hold.Head.HitWindows).DifficultyMultiplier = HIT_WINDOW_DIFFICULTY_MULTIPLIER;
+                    ((ManiaHitWindows)hold.Tail.HitWindows).DifficultyMultiplier = HIT_WINDOW_DIFFICULTY_MULTIPLIER;
+                    break;
+            }
+        }
     }
 }

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

@@ -3,7 +3,9 @@
 
 using System;
 using System.Linq;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.UI;
 
 namespace osu.Game.Rulesets.Mania.Mods
@@ -12,6 +14,7 @@ namespace osu.Game.Rulesets.Mania.Mods
     {
         public override string Name => "Fade In";
         public override string Acronym => "FI";
+        public override IconUsage? Icon => OsuIcon.ModFadeIn;
         public override LocalisableString Description => @"Keys appear out of nowhere!";
         public override double ScoreMultiplier => 1;
         public override bool ValidForFreestyleAsRequiredMod => false;

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

@@ -1,14 +1,11 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModHalfTime : ModHalfTime, IManiaRateAdjustmentMod
     {
-        public HitWindows HitWindows { get; set; } = new ManiaHitWindows();
     }
 }

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

@@ -1,13 +1,33 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModHardRock : ModHardRock
+    public class ManiaModHardRock : ModHardRock, IApplicableToHitObject
     {
         public override double ScoreMultiplier => 1;
         public override bool Ranked => false;
+
+        public const double HIT_WINDOW_DIFFICULTY_MULTIPLIER = 1.4;
+
+        void IApplicableToHitObject.ApplyToHitObject(HitObject hitObject)
+        {
+            switch (hitObject)
+            {
+                case Note:
+                    ((ManiaHitWindows)hitObject.HitWindows).DifficultyMultiplier = HIT_WINDOW_DIFFICULTY_MULTIPLIER;
+                    break;
+
+                case HoldNote hold:
+                    ((ManiaHitWindows)hold.Head.HitWindows).DifficultyMultiplier = HIT_WINDOW_DIFFICULTY_MULTIPLIER;
+                    ((ManiaHitWindows)hold.Tail.HitWindows).DifficultyMultiplier = HIT_WINDOW_DIFFICULTY_MULTIPLIER;
+                    break;
+            }
+        }
     }
 }

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

@@ -9,6 +9,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Framework.Graphics.Sprites;
 using System.Collections.Generic;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Beatmaps;
 
 namespace osu.Game.Rulesets.Mania.Mods
@@ -23,7 +24,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override LocalisableString Description => @"Replaces all hold notes with normal notes.";
 
-        public override IconUsage? Icon => FontAwesome.Solid.DotCircle;
+        public override IconUsage? Icon => OsuIcon.ModHoldOff;
 
         public override ModType Type => ModType.Conversion;
 

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

@@ -8,6 +8,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;
@@ -23,7 +24,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override LocalisableString Description => "Hold the keys. To the beat.";
 
-        public override IconUsage? Icon => FontAwesome.Solid.YinYang;
+        public override IconUsage? Icon => OsuIcon.ModInvert;
 
         public override ModType Type => ModType.Conversion;
 
@@ -63,6 +64,7 @@ namespace osu.Game.Rulesets.Mania.Mods
                         StartTime = locations[i].startTime,
                         Duration = duration,
                         NodeSamples = new List<IList<HitSampleInfo>> { locations[i].samples, Array.Empty<HitSampleInfo>() }
+                        // intentionally don't play sliding samples here, it doesn't work in this mod.
                     });
                 }