Merge pull request #15640 from smoogipoo/multi-queueing-modes

Add ability to change multiplayer queue modes
Merge branch 'master' into multi-queueing-modes
2026-05-19 16:20:14 +08:00 · 2021-11-22 13:02:14 +09:00 · 2021-11-22 12:32:47 +09:00 · 2021-11-22 11:54:53 +09:00 · 2021-11-22 11:26:41 +09:00 · 2021-11-22 11:20:19 +09:00
743 changed files with 12801 additions and 5863 deletions
@@ -14,8 +14,8 @@
        "jb"
      ]
    },
-    "smoogipoo.nvika": {
-      "version": "1.0.1",
+    "nvika": {
+      "version": "2.2.0",
      "commands": [
        "nvika"
      ]
@@ -33,4 +33,4 @@
      ]
    }
  }
-}
+}
@@ -5,7 +5,7 @@ updates:
  schedule:
    interval: monthly
    time: "17:00"
-  open-pull-requests-limit: 99
+  open-pull-requests-limit: 0 # disabled until https://github.com/dependabot/dependabot-core/issues/369 is resolved.
  ignore:
  - dependency-name: Microsoft.EntityFrameworkCore.Design
    versions:
@@ -38,7 +38,7 @@ jobs:
        run: dotnet build -c Debug -warnaserror osu.Desktop.slnf

      - name: Test
-        run: dotnet test $pwd/*.Tests/bin/Debug/*/*.Tests.dll --logger "trx;LogFileName=TestResults-${{matrix.os.prettyname}}-${{matrix.threadingMode}}.trx"
+        run: dotnet test $pwd/*.Tests/bin/Debug/*/*.Tests.dll --blame-crash --blame-hang --blame-hang-timeout 5m --logger "trx;LogFileName=TestResults-${{matrix.os.prettyname}}-${{matrix.threadingMode}}.trx"
        shell: pwsh

      # Attempt to upload results even if test fails.
@@ -48,26 +48,33 @@ jobs:
        if: ${{ always() }}
        with:
          name: osu-test-results-${{matrix.os.prettyname}}-${{matrix.threadingMode}}
-          path: ${{github.workspace}}/TestResults/TestResults-${{matrix.os.prettyname}}-${{matrix.threadingMode}}.trx
+          path: ${{github.workspace}}/TestResults/**/*

  build-only-android:
    name: Build only (Android)
-    runs-on: windows-latest
+    runs-on: macos-latest
    timeout-minutes: 60
    steps:
      - name: Checkout
        uses: actions/checkout@v2

+      # Pin Xamarin.Android version to 11.2 for now to avoid build failures caused by a Xamarin-side regression.
+      # See: https://github.com/xamarin/xamarin-android/issues/6284
+      # This can be removed/reverted when the fix makes it to upstream and is deployed on github runners.
+      - name: Set default Xamarin SDK version
+        run: |
+            $VM_ASSETS/select-xamarin-sdk-v2.sh --mono=6.12 --android=11.2
+
      - name: Install .NET 5.0.x
        uses: actions/setup-dotnet@v1
        with:
          dotnet-version: "5.0.x"

-      - name: Setup MSBuild
-        uses: microsoft/setup-msbuild@v1
-
+      # Contrary to seemingly any other msbuild, msbuild running on macOS/Mono
+      # cannot accept .sln(f) files as arguments.
+      # Build just the main game for now.
      - name: Build
-        run: msbuild osu.Android.slnf /restore /p:Configuration=Debug
+        run: msbuild osu.Android/osu.Android.csproj /restore /p:Configuration=Debug

  build-only-ios:
    # While this workflow technically *can* run, it fails as iOS builds are blocked by multiple issues.
@@ -0,0 +1 @@
+osu.iOS
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="UserContentModel">
+    <attachedFolders />
+    <explicitIncludes />
+    <explicitExcludes />
+  </component>
+</project>
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="com.jetbrains.rider.android.RiderAndroidMiscFileCreationComponent">
+    <option name="ENSURE_MISC_FILE_EXISTS" value="true" />
+  </component>
+</project>
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="RiderProjectSettingsUpdater">
+    <option name="vcsConfiguration" value="2" />
+  </component>
+</project>
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>
@@ -16,7 +16,7 @@
    <EmbeddedResource Include="Resources\**\*.*" />
  </ItemGroup>
  <ItemGroup Label="Code Analysis">
-    <PackageReference Include="Microsoft.CodeAnalysis.BannedApiAnalyzers" Version="3.3.2" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.CodeAnalysis.BannedApiAnalyzers" Version="3.3.3" PrivateAssets="All" />
    <AdditionalFiles Include="$(MSBuildThisFileDirectory)CodeAnalysis\BannedSymbols.txt" />
    <PackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="5.0.3" PrivateAssets="All" />
  </ItemGroup>
@@ -10,9 +10,9 @@
    </PropertyGroup>
  <ItemGroup Label="Package References">
    <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
    <PackageReference Include="NUnit" Version="3.13.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
    <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
  </ItemGroup>
  <ItemGroup>
@@ -13,14 +13,14 @@ namespace osu.Game.Rulesets.EmptyFreeform
 {
    public class EmptyFreeformDifficultyCalculator : DifficultyCalculator
    {
-        public EmptyFreeformDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+        public EmptyFreeformDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
            : base(ruleset, beatmap)
        {
        }

        protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
        {
-            return new DifficultyAttributes(mods, skills, 0);
+            return new DifficultyAttributes(mods, 0);
        }

        protected override IEnumerable<DifficultyHitObject> CreateDifficultyHitObjects(IBeatmap beatmap, double clockRate) => Enumerable.Empty<DifficultyHitObject>();
@@ -30,8 +30,8 @@ namespace osu.Game.Rulesets.EmptyFreeform
        public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) =>
            new EmptyFreeformBeatmapConverter(beatmap, this);

-        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) =>
-            new EmptyFreeformDifficultyCalculator(this, beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) =>
+            new EmptyFreeformDifficultyCalculator(RulesetInfo, beatmap);

        public override IEnumerable<Mod> GetModsFor(ModType type)
        {
@@ -3,10 +3,10 @@

 using System.Collections.Generic;
 using osu.Game.Beatmaps;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets.EmptyFreeform.Replays;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
-using osu.Game.Users;

 namespace osu.Game.Rulesets.EmptyFreeform.Mods
 {
@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.EmptyFreeform.Mods
        {
            ScoreInfo = new ScoreInfo
            {
-                User = new User { Username = "sample" },
+                User = new APIUser { Username = "sample" },
            },
            Replay = new EmptyFreeformAutoGenerator(beatmap).Generate(),
        };
@@ -10,9 +10,9 @@
  </PropertyGroup>
  <ItemGroup Label="Package References">
    <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
    <PackageReference Include="NUnit" Version="3.13.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
    <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
  </ItemGroup>
  <ItemGroup>
@@ -3,10 +3,10 @@

 using System.Collections.Generic;
 using osu.Game.Beatmaps;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Pippidon.Replays;
 using osu.Game.Scoring;
-using osu.Game.Users;

 namespace osu.Game.Rulesets.Pippidon.Mods
 {
@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Pippidon.Mods
        {
            ScoreInfo = new ScoreInfo
            {
-                User = new User { Username = "sample" },
+                User = new APIUser { Username = "sample" },
            },
            Replay = new PippidonAutoGenerator(beatmap).Generate(),
        };
@@ -13,14 +13,14 @@ namespace osu.Game.Rulesets.Pippidon
 {
    public class PippidonDifficultyCalculator : DifficultyCalculator
    {
-        public PippidonDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+        public PippidonDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
            : base(ruleset, beatmap)
        {
        }

        protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
        {
-            return new DifficultyAttributes(mods, skills, 0);
+            return new DifficultyAttributes(mods, 0);
        }

        protected override IEnumerable<DifficultyHitObject> CreateDifficultyHitObjects(IBeatmap beatmap, double clockRate) => Enumerable.Empty<DifficultyHitObject>();
@@ -26,8 +26,8 @@ namespace osu.Game.Rulesets.Pippidon
        public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) =>
            new PippidonBeatmapConverter(beatmap, this);

-        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) =>
-            new PippidonDifficultyCalculator(this, beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) =>
+            new PippidonDifficultyCalculator(RulesetInfo, beatmap);

        public override IEnumerable<Mod> GetModsFor(ModType type)
        {
@@ -10,9 +10,9 @@
  </PropertyGroup>
  <ItemGroup Label="Package References">
    <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
    <PackageReference Include="NUnit" Version="3.13.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
    <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
  </ItemGroup>
  <ItemGroup>
@@ -13,14 +13,14 @@ namespace osu.Game.Rulesets.EmptyScrolling
 {
    public class EmptyScrollingDifficultyCalculator : DifficultyCalculator
    {
-        public EmptyScrollingDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+        public EmptyScrollingDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
            : base(ruleset, beatmap)
        {
        }

        protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
        {
-            return new DifficultyAttributes(mods, skills, 0);
+            return new DifficultyAttributes(mods, 0);
        }

        protected override IEnumerable<DifficultyHitObject> CreateDifficultyHitObjects(IBeatmap beatmap, double clockRate) => Enumerable.Empty<DifficultyHitObject>();
@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.EmptyScrolling

        public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new EmptyScrollingBeatmapConverter(beatmap, this);

-        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new EmptyScrollingDifficultyCalculator(this, beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new EmptyScrollingDifficultyCalculator(RulesetInfo, beatmap);

        public override IEnumerable<Mod> GetModsFor(ModType type)
        {
@@ -5,8 +5,8 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.EmptyScrolling.Replays;
 using osu.Game.Scoring;
-using osu.Game.Users;
 using System.Collections.Generic;
+using osu.Game.Online.API.Requests.Responses;

 namespace osu.Game.Rulesets.EmptyScrolling.Mods
 {
@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.EmptyScrolling.Mods
        {
            ScoreInfo = new ScoreInfo
            {
-                User = new User { Username = "sample" },
+                User = new APIUser { Username = "sample" },
            },
            Replay = new EmptyScrollingAutoGenerator(beatmap).Generate(),
        };
@@ -10,9 +10,9 @@
  </PropertyGroup>
  <ItemGroup Label="Package References">
    <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
    <PackageReference Include="NUnit" Version="3.13.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
    <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
  </ItemGroup>
  <ItemGroup>
@@ -3,10 +3,10 @@

 using System.Collections.Generic;
 using osu.Game.Beatmaps;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Pippidon.Replays;
 using osu.Game.Scoring;
-using osu.Game.Users;

 namespace osu.Game.Rulesets.Pippidon.Mods
 {
@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Pippidon.Mods
        {
            ScoreInfo = new ScoreInfo
            {
-                User = new User { Username = "sample" },
+                User = new APIUser { Username = "sample" },
            },
            Replay = new PippidonAutoGenerator(beatmap).Generate(),
        };
@@ -13,14 +13,14 @@ namespace osu.Game.Rulesets.Pippidon
 {
    public class PippidonDifficultyCalculator : DifficultyCalculator
    {
-        public PippidonDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+        public PippidonDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
            : base(ruleset, beatmap)
        {
        }

        protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
        {
-            return new DifficultyAttributes(mods, skills, 0);
+            return new DifficultyAttributes(mods, 0);
        }

        protected override IEnumerable<DifficultyHitObject> CreateDifficultyHitObjects(IBeatmap beatmap, double clockRate) => Enumerable.Empty<DifficultyHitObject>();
@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Pippidon

        public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new PippidonBeatmapConverter(beatmap, this);

-        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new PippidonDifficultyCalculator(this, beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new PippidonDifficultyCalculator(RulesetInfo, beatmap);

        public override IEnumerable<Mod> GetModsFor(ModType type)
        {
@@ -51,11 +51,11 @@
    <Reference Include="Java.Interop" />
  </ItemGroup>
  <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.1026.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.1026.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.1112.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.1119.0" />
  </ItemGroup>
  <ItemGroup Label="Transitive Dependencies">
    <!-- Realm needs to be directly referenced in all Xamarin projects, as it will not pull in its transitive dependencies otherwise. -->
-    <PackageReference Include="Realm" Version="10.6.0" />
+    <PackageReference Include="Realm" Version="10.7.1" />
  </ItemGroup>
 </Project>
@@ -20,6 +20,7 @@ namespace osu.Android
    [Activity(Theme = "@android:style/Theme.NoTitleBar", MainLauncher = true, ScreenOrientation = ScreenOrientation.FullUser, SupportsPictureInPicture = false, ConfigurationChanges = ConfigChanges.Orientation | ConfigChanges.ScreenSize, HardwareAccelerated = false, LaunchMode = LaunchMode.SingleInstance, Exported = true)]
    [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataPathPattern = ".*\\\\.osz", DataHost = "*", DataMimeType = "*/*")]
    [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataPathPattern = ".*\\\\.osk", DataHost = "*", DataMimeType = "*/*")]
+    [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataPathPattern = ".*\\\\.osr", DataHost = "*", DataMimeType = "*/*")]
    [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataMimeType = "application/x-osu-beatmap-archive")]
    [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataMimeType = "application/x-osu-skin-archive")]
    [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataMimeType = "application/x-osu-replay")]
@@ -11,10 +11,10 @@ using osu.Framework.Graphics;
 using osu.Framework.Logging;
 using osu.Game.Configuration;
 using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets;
 using osu.Game.Users;
 using LogLevel = osu.Framework.Logging.LogLevel;
-using User = osu.Game.Users.User;

 namespace osu.Desktop
 {
@@ -27,7 +27,7 @@ namespace osu.Desktop
        [Resolved]
        private IBindable<RulesetInfo> ruleset { get; set; }

-        private IBindable<User> user;
+        private IBindable<APIUser> user;

        private readonly IBindable<UserStatus> status = new Bindable<UserStatus>();
        private readonly IBindable<UserActivity> activity = new Bindable<UserActivity>();
@@ -93,6 +93,11 @@ namespace osu.Desktop

        protected override UpdateManager CreateUpdateManager()
        {
+            string packageManaged = Environment.GetEnvironmentVariable("OSU_EXTERNAL_UPDATE_PROVIDER");
+
+            if (!string.IsNullOrEmpty(packageManaged))
+                return new NoActionUpdateManager();
+
            switch (RuntimeInfo.OS)
            {
                case RuntimeInfo.Platform.Windows:
@@ -183,6 +183,19 @@ namespace osu.Desktop.Updater
                    }
                });
            }
+
+            public override void Close()
+            {
+                // cancelling updates is not currently supported by the underlying updater.
+                // only allow dismissing for now.
+
+                switch (State)
+                {
+                    case ProgressNotificationState.Cancelled:
+                        base.Close();
+                        break;
+                }
+            }
        }

        private class SquirrelLogger : Splat.ILogger, IDisposable
@@ -9,7 +9,7 @@
  <ItemGroup>
    <PackageReference Include="BenchmarkDotNet" Version="0.13.1" />
    <PackageReference Include="nunit" Version="3.13.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
  </ItemGroup>

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

+using osu.Framework.iOS;
 using UIKit;

 namespace osu.Game.Rulesets.Catch.Tests.iOS
@@ -9,7 +10,7 @@ namespace osu.Game.Rulesets.Catch.Tests.iOS
    {
        public static void Main(string[] args)
        {
-            UIApplication.Main(args, "GameUIApplication", "AppDelegate");
+            UIApplication.Main(args, typeof(GameUIApplication), typeof(AppDelegate));
        }
    }
 }
@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Catch.Tests
        public void TestClockRateAdjusted(double expected, string name)
            => Test(expected, name, new CatchModDoubleTime());

-        protected override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new CatchDifficultyCalculator(new CatchRuleset(), beatmap);
+        protected override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new CatchDifficultyCalculator(new CatchRuleset().RulesetInfo, beatmap);

        protected override Ruleset CreateRuleset() => new CatchRuleset();
    }
@@ -0,0 +1,118 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.Edit.Checks;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Tests.Beatmaps;
+
+namespace osu.Game.Rulesets.Catch.Tests.Editor.Checks
+{
+    [TestFixture]
+    public class TestCheckBananaShowerGap
+    {
+        private CheckBananaShowerGap check;
+
+        [SetUp]
+        public void Setup()
+        {
+            check = new CheckBananaShowerGap();
+        }
+
+        [Test]
+        public void TestAllowedSpinnerGaps()
+        {
+            assertOk(mockBeatmap(250, 1000, 1250), DifficultyRating.Easy);
+            assertOk(mockBeatmap(250, 1000, 1250), DifficultyRating.Normal);
+            assertOk(mockBeatmap(125, 1000, 1250), DifficultyRating.Hard);
+            assertOk(mockBeatmap(125, 1000, 1125), DifficultyRating.Insane);
+            assertOk(mockBeatmap(62, 1000, 1125), DifficultyRating.Expert);
+            assertOk(mockBeatmap(62, 1000, 1125), DifficultyRating.ExpertPlus);
+        }
+
+        [Test]
+        public void TestDisallowedSpinnerGapStart()
+        {
+            assertTooShortSpinnerStart(mockBeatmap(249, 1000, 1250), DifficultyRating.Easy);
+            assertTooShortSpinnerStart(mockBeatmap(249, 1000, 1250), DifficultyRating.Normal);
+            assertTooShortSpinnerStart(mockBeatmap(124, 1000, 1250), DifficultyRating.Hard);
+            assertTooShortSpinnerStart(mockBeatmap(124, 1000, 1250), DifficultyRating.Insane);
+            assertTooShortSpinnerStart(mockBeatmap(61, 1000, 1250), DifficultyRating.Expert);
+            assertTooShortSpinnerStart(mockBeatmap(61, 1000, 1250), DifficultyRating.ExpertPlus);
+        }
+
+        [Test]
+        public void TestDisallowedSpinnerGapEnd()
+        {
+            assertTooShortSpinnerEnd(mockBeatmap(250, 1000, 1249), DifficultyRating.Easy);
+            assertTooShortSpinnerEnd(mockBeatmap(250, 1000, 1249), DifficultyRating.Normal);
+            assertTooShortSpinnerEnd(mockBeatmap(125, 1000, 1249), DifficultyRating.Hard);
+            assertTooShortSpinnerEnd(mockBeatmap(125, 1000, 1124), DifficultyRating.Insane);
+            assertTooShortSpinnerEnd(mockBeatmap(62, 1000, 1124), DifficultyRating.Expert);
+            assertTooShortSpinnerEnd(mockBeatmap(62, 1000, 1124), DifficultyRating.ExpertPlus);
+        }
+
+        [Test]
+        public void TestConsecutiveSpinners()
+        {
+            var spinnerConsecutiveBeatmap = new Beatmap<HitObject>
+            {
+                HitObjects = new List<HitObject>
+                {
+                    new BananaShower { StartTime = 0, EndTime = 100, X = 0 },
+                    new BananaShower { StartTime = 101, EndTime = 200, X = 0 },
+                    new BananaShower { StartTime = 201, EndTime = 300, X = 0 }
+                }
+            };
+
+            assertOk(spinnerConsecutiveBeatmap, DifficultyRating.Easy);
+            assertOk(spinnerConsecutiveBeatmap, DifficultyRating.Normal);
+            assertOk(spinnerConsecutiveBeatmap, DifficultyRating.Hard);
+            assertOk(spinnerConsecutiveBeatmap, DifficultyRating.Insane);
+            assertOk(spinnerConsecutiveBeatmap, DifficultyRating.Expert);
+            assertOk(spinnerConsecutiveBeatmap, DifficultyRating.ExpertPlus);
+        }
+
+        private Beatmap<HitObject> mockBeatmap(double bananaShowerStart, double bananaShowerEnd, double nextFruitStart)
+        {
+            return new Beatmap<HitObject>
+            {
+                HitObjects = new List<HitObject>
+                {
+                    new Fruit { StartTime = 0, X = 0 },
+                    new BananaShower { StartTime = bananaShowerStart, EndTime = bananaShowerEnd, X = 0 },
+                    new Fruit { StartTime = nextFruitStart, X = 0 }
+                }
+            };
+        }
+
+        private void assertOk(IBeatmap beatmap, DifficultyRating difficultyRating)
+        {
+            var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap), difficultyRating);
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        private void assertTooShortSpinnerStart(IBeatmap beatmap, DifficultyRating difficultyRating)
+        {
+            var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap), difficultyRating);
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.All(issue => issue.Template is CheckBananaShowerGap.IssueTemplateBananaShowerStartGap));
+        }
+
+        private void assertTooShortSpinnerEnd(IBeatmap beatmap, DifficultyRating difficultyRating)
+        {
+            var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap), difficultyRating);
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.All(issue => issue.Template is CheckBananaShowerGap.IssueTemplateBananaShowerEndGap));
+        }
+    }
+}
@@ -0,0 +1,110 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Timing;
+using osu.Game.Rulesets.Catch.Mods;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Catch.Tests.Mods
+{
+    public class TestSceneCatchModNoScope : ModTestScene
+    {
+        protected override Ruleset CreatePlayerRuleset() => new CatchRuleset();
+
+        [Test]
+        public void TestVisibleDuringBreak()
+        {
+            CreateModTest(new ModTestData
+            {
+                Mod = new CatchModNoScope
+                {
+                    HiddenComboCount = { Value = 0 },
+                },
+                Autoplay = true,
+                PassCondition = () => true,
+                Beatmap = new Beatmap
+                {
+                    HitObjects = new List<HitObject>
+                    {
+                        new Fruit
+                        {
+                            X = CatchPlayfield.CENTER_X,
+                            StartTime = 1000,
+                        },
+                        new Fruit
+                        {
+                            X = CatchPlayfield.CENTER_X,
+                            StartTime = 5000,
+                        }
+                    },
+                    Breaks = new List<BreakPeriod>
+                    {
+                        new BreakPeriod(2000, 4000),
+                    }
+                }
+            });
+
+            AddUntilStep("wait for catcher to hide", () => catcherAlphaAlmostEquals(0));
+            AddUntilStep("wait for start of break", isBreak);
+            AddUntilStep("wait for catcher to show", () => catcherAlphaAlmostEquals(1));
+            AddUntilStep("wait for end of break", () => !isBreak());
+            AddUntilStep("wait for catcher to hide", () => catcherAlphaAlmostEquals(0));
+        }
+
+        [Test]
+        public void TestVisibleAfterComboBreak()
+        {
+            CreateModTest(new ModTestData
+            {
+                Mod = new CatchModNoScope
+                {
+                    HiddenComboCount = { Value = 2 },
+                },
+                Autoplay = true,
+                PassCondition = () => true,
+                Beatmap = new Beatmap
+                {
+                    HitObjects = new List<HitObject>
+                    {
+                        new Fruit
+                        {
+                            X = 0,
+                            StartTime = 1000,
+                        },
+                        new Fruit
+                        {
+                            X = CatchPlayfield.CENTER_X,
+                            StartTime = 3000,
+                        },
+                        new Fruit
+                        {
+                            X = CatchPlayfield.WIDTH,
+                            StartTime = 5000,
+                        },
+                    }
+                }
+            });
+
+            AddAssert("catcher must start visible", () => catcherAlphaAlmostEquals(1));
+            AddUntilStep("wait for combo", () => Player.ScoreProcessor.Combo.Value >= 2);
+            AddAssert("catcher must dim after combo", () => !catcherAlphaAlmostEquals(1));
+            AddStep("break combo", () => Player.ScoreProcessor.Combo.Value = 0);
+            AddUntilStep("wait for catcher to show", () => catcherAlphaAlmostEquals(1));
+        }
+
+        private bool isBreak() => Player.IsBreakTime.Value;
+
+        private bool catcherAlphaAlmostEquals(float alpha)
+        {
+            var playfield = (CatchPlayfield)Player.DrawableRuleset.Playfield;
+            return Precision.AlmostEquals(playfield.CatcherArea.Alpha, alpha);
+        }
+    }
+}
@@ -168,6 +168,28 @@ namespace osu.Game.Rulesets.Catch.Tests
            checkHyperDash(false);
        }

+        [Test]
+        public void TestLastBananaShouldClearPlateOnMiss()
+        {
+            AddStep("catch fruit", () => attemptCatch(new Fruit()));
+            checkPlate(1);
+            AddStep("miss banana", () => attemptCatch(new Banana { X = 100 }));
+            checkPlate(1);
+            AddStep("miss last banana", () => attemptCatch(new Banana { LastInCombo = true, X = 100 }));
+            checkPlate(0);
+        }
+
+        [Test]
+        public void TestLastBananaShouldClearPlateOnCatch()
+        {
+            AddStep("catch fruit", () => attemptCatch(new Fruit()));
+            checkPlate(1);
+            AddStep("catch banana", () => attemptCatch(new Banana()));
+            checkPlate(2);
+            AddStep("catch last banana", () => attemptCatch(new Banana { LastInCombo = true }));
+            checkPlate(0);
+        }
+
        [Test]
        public void TestCatcherRandomStacking()
        {
@@ -30,7 +30,7 @@ namespace osu.Game.Rulesets.Catch.Tests
            var controlPointInfo = new ControlPointInfo();
            controlPointInfo.Add(0, new TimingControlPoint());

-            WorkingBeatmap beatmap = CreateWorkingBeatmap(new Beatmap
+            IWorkingBeatmap beatmap = CreateWorkingBeatmap(new Beatmap
            {
                HitObjects = new List<HitObject> { new Fruit() },
                BeatmapInfo = new BeatmapInfo
@@ -2,9 +2,9 @@
  <Import Project="..\osu.TestProject.props" />
  <ItemGroup Label="Package References">
    <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
    <PackageReference Include="NUnit" Version="3.13.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
    <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
  </ItemGroup>
  <PropertyGroup Label="Project">
@@ -133,6 +133,7 @@ namespace osu.Game.Rulesets.Catch
                        new MultiMod(new ModWindUp(), new ModWindDown()),
                        new CatchModFloatingFruits(),
                        new CatchModMuted(),
+                        new CatchModNoScope(),
                    };

                default:
@@ -177,7 +178,7 @@ namespace osu.Game.Rulesets.Catch
            return base.GetDisplayNameForHitResult(result);
        }

-        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new CatchDifficultyCalculator(this, beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new CatchDifficultyCalculator(RulesetInfo, beatmap);

        public override ISkin CreateLegacySkinProvider(ISkin skin, IBeatmap beatmap) => new CatchLegacySkinTransformer(skin);

@@ -188,5 +189,7 @@ namespace osu.Game.Rulesets.Catch
        public override IConvertibleReplayFrame CreateConvertibleReplayFrame() => new CatchReplayFrame();

        public override HitObjectComposer CreateHitObjectComposer() => new CatchHitObjectComposer(this);
+
+        public override IBeatmapVerifier CreateBeatmapVerifier() => new CatchBeatmapVerifier();
    }
 }
@@ -1,12 +1,35 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

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

 namespace osu.Game.Rulesets.Catch.Difficulty
 {
    public class CatchDifficultyAttributes : DifficultyAttributes
    {
+        [JsonProperty("approach_rate")]
        public double ApproachRate { get; set; }
+
+        public override IEnumerable<(int attributeId, object value)> ToDatabaseAttributes()
+        {
+            foreach (var v in base.ToDatabaseAttributes())
+                yield return v;
+
+            // Todo: osu!catch should not output star rating in the 'aim' attribute.
+            yield return (ATTRIB_ID_AIM, StarRating);
+            yield return (ATTRIB_ID_APPROACH_RATE, ApproachRate);
+            yield return (ATTRIB_ID_MAX_COMBO, MaxCombo);
+        }
+
+        public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values)
+        {
+            base.FromDatabaseAttributes(values);
+
+            StarRating = values[ATTRIB_ID_AIM];
+            ApproachRate = values[ATTRIB_ID_APPROACH_RATE];
+            MaxCombo = (int)values[ATTRIB_ID_MAX_COMBO];
+        }
    }
 }
@@ -23,7 +23,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty

        private float halfCatcherWidth;

-        public CatchDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+        public CatchDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
            : base(ruleset, beatmap)
        {
        }
@@ -31,7 +31,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty
        protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
        {
            if (beatmap.HitObjects.Count == 0)
-                return new CatchDifficultyAttributes { Mods = mods, Skills = skills };
+                return new CatchDifficultyAttributes { Mods = mods };

            // this is the same as osu!, so there's potential to share the implementation... maybe
            double preempt = IBeatmapDifficultyInfo.DifficultyRange(beatmap.Difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
@@ -42,7 +42,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty
                Mods = mods,
                ApproachRate = preempt > 1200.0 ? -(preempt - 1800.0) / 120.0 : -(preempt - 1200.0) / 150.0 + 5.0,
                MaxCombo = beatmap.HitObjects.Count(h => h is Fruit) + beatmap.HitObjects.OfType<JuiceStream>().SelectMany(j => j.NestedHitObjects).Count(h => !(h is TinyDroplet)),
-                Skills = skills
            };
        }

@@ -0,0 +1,24 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Game.Rulesets.Catch.Edit.Checks;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks.Components;
+
+namespace osu.Game.Rulesets.Catch.Edit
+{
+    public class CatchBeatmapVerifier : IBeatmapVerifier
+    {
+        private readonly List<ICheck> checks = new List<ICheck>
+        {
+            new CheckBananaShowerGap()
+        };
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            return checks.SelectMany(check => check.Run(context));
+        }
+    }
+}
@@ -0,0 +1,102 @@
+// 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.Catch.Objects;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks.Components;
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Rulesets.Catch.Edit.Checks
+{
+    /// <summary>
+    /// Check the spinner/banana shower gaps specified in the osu!catch difficulty specific ranking criteria.
+    /// </summary>
+    public class CheckBananaShowerGap : ICheck
+    {
+        private static readonly Dictionary<DifficultyRating, (int startGap, int endGap)> spinner_delta_threshold = new Dictionary<DifficultyRating, (int, int)>
+        {
+            [DifficultyRating.Easy] = (250, 250),
+            [DifficultyRating.Normal] = (250, 250),
+            [DifficultyRating.Hard] = (125, 250),
+            [DifficultyRating.Insane] = (125, 125),
+            [DifficultyRating.Expert] = (62, 125),
+            [DifficultyRating.ExpertPlus] = (62, 125)
+        };
+
+        public CheckMetadata Metadata { get; } = new CheckMetadata(CheckCategory.Compose, "Too short spinner gap");
+
+        public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
+        {
+            new IssueTemplateBananaShowerStartGap(this),
+            new IssueTemplateBananaShowerEndGap(this)
+        };
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            var hitObjects = context.Beatmap.HitObjects;
+            (int expectedStartDelta, int expectedEndDelta) = spinner_delta_threshold[context.InterpretedDifficulty];
+
+            for (int i = 0; i < hitObjects.Count - 1; ++i)
+            {
+                if (!(hitObjects[i] is BananaShower bananaShower))
+                    continue;
+
+                // Skip if the previous hitobject is a banana shower, consecutive spinners are allowed
+                if (i != 0 && hitObjects[i - 1] is CatchHitObject previousHitObject && !(previousHitObject is BananaShower))
+                {
+                    double spinnerStartDelta = bananaShower.StartTime - previousHitObject.GetEndTime();
+
+                    if (spinnerStartDelta < expectedStartDelta)
+                    {
+                        yield return new IssueTemplateBananaShowerStartGap(this)
+                            .Create(spinnerStartDelta, expectedStartDelta, bananaShower, previousHitObject);
+                    }
+                }
+
+                // Skip if the next hitobject is a banana shower, consecutive spinners are allowed
+                if (hitObjects[i + 1] is CatchHitObject nextHitObject && !(nextHitObject is BananaShower))
+                {
+                    double spinnerEndDelta = nextHitObject.StartTime - bananaShower.EndTime;
+
+                    if (spinnerEndDelta < expectedEndDelta)
+                    {
+                        yield return new IssueTemplateBananaShowerEndGap(this)
+                            .Create(spinnerEndDelta, expectedEndDelta, bananaShower, nextHitObject);
+                    }
+                }
+            }
+        }
+
+        public abstract class IssueTemplateBananaShowerGap : IssueTemplate
+        {
+            protected IssueTemplateBananaShowerGap(ICheck check, IssueType issueType, string unformattedMessage)
+                : base(check, issueType, unformattedMessage)
+            {
+            }
+
+            public Issue Create(double deltaTime, int expectedDeltaTime, params HitObject[] hitObjects)
+            {
+                return new Issue(hitObjects, this, Math.Floor(deltaTime), expectedDeltaTime);
+            }
+        }
+
+        public class IssueTemplateBananaShowerStartGap : IssueTemplateBananaShowerGap
+        {
+            public IssueTemplateBananaShowerStartGap(ICheck check)
+                : base(check, IssueType.Problem, "There is only {0} ms between the start of the spinner and the last object, it should not be less than {1} ms.")
+            {
+            }
+        }
+
+        public class IssueTemplateBananaShowerEndGap : IssueTemplateBananaShowerGap
+        {
+            public IssueTemplateBananaShowerEndGap(ICheck check)
+                : base(check, IssueType.Problem, "There is only {0} ms between the end of the spinner and the next object, it should not be less than {1} ms.")
+            {
+            }
+        }
+    }
+}
@@ -3,10 +3,10 @@

 using System.Collections.Generic;
 using osu.Game.Beatmaps;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
-using osu.Game.Users;

 namespace osu.Game.Rulesets.Catch.Mods
 {
@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Catch.Mods
    {
        public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
        {
-            ScoreInfo = new ScoreInfo { User = new User { Username = "osu!salad!" } },
+            ScoreInfo = new ScoreInfo { User = new APIUser { Username = "osu!salad" } },
            Replay = new CatchAutoGenerator(beatmap).Generate(),
        };
    }
@@ -3,11 +3,11 @@

 using System.Collections.Generic;
 using osu.Game.Beatmaps;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
-using osu.Game.Users;

 namespace osu.Game.Rulesets.Catch.Mods
 {
@@ -15,7 +15,7 @@ namespace osu.Game.Rulesets.Catch.Mods
    {
        public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
        {
-            ScoreInfo = new ScoreInfo { User = new User { Username = "osu!salad!" } },
+            ScoreInfo = new ScoreInfo { User = new APIUser { Username = "osu!salad" } },
            Replay = new CatchAutoGenerator(beatmap).Generate(),
        };
    }
@@ -0,0 +1,40 @@
+// 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.Bindables;
+using osu.Game.Rulesets.Mods;
+using osu.Framework.Utils;
+using osu.Game.Configuration;
+using osu.Game.Overlays.Settings;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Catch.Mods
+{
+    public class CatchModNoScope : ModNoScope, IUpdatableByPlayfield
+    {
+        public override string Description => "Where's the catcher?";
+
+        [SettingSource(
+            "Hidden at combo",
+            "The combo count at which the catcher becomes completely hidden",
+            SettingControlType = typeof(SettingsSlider<int, HiddenComboSlider>)
+        )]
+        public override BindableInt HiddenComboCount { get; } = new BindableInt
+        {
+            Default = 10,
+            Value = 10,
+            MinValue = 0,
+            MaxValue = 50,
+        };
+
+        public void Update(Playfield playfield)
+        {
+            var catchPlayfield = (CatchPlayfield)playfield;
+            bool shouldAlwaysShowCatcher = IsBreakTime.Value;
+            float targetAlpha = shouldAlwaysShowCatcher ? 1 : ComboBasedAlpha;
+            catchPlayfield.CatcherArea.Alpha = (float)Interpolation.Lerp(catchPlayfield.CatcherArea.Alpha, targetAlpha, Math.Clamp(catchPlayfield.Time.Elapsed / TRANSITION_DURATION, 0, 1));
+        }
+    }
+}
@@ -145,7 +145,7 @@ namespace osu.Game.Rulesets.Catch.Objects

        public double Distance => Path.Distance;

-        public List<IList<HitSampleInfo>> NodeSamples { get; set; } = new List<IList<HitSampleInfo>>();
+        public IList<IList<HitSampleInfo>> NodeSamples { get; set; } = new List<IList<HitSampleInfo>>();

        public double? LegacyLastTickOffset { get; set; }
    }
@@ -66,7 +66,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
                        return null;

                    case CatchSkinComponents.Catcher:
-                        decimal version = GetConfig<LegacySkinConfiguration.LegacySetting, decimal>(LegacySkinConfiguration.LegacySetting.Version)?.Value ?? 1;
+                        decimal version = GetConfig<SkinConfiguration.LegacySetting, decimal>(SkinConfiguration.LegacySetting.Version)?.Value ?? 1;

                        if (version < 2.3m)
                        {
@@ -210,6 +210,7 @@ namespace osu.Game.Rulesets.Catch.UI
            catchResult.CatcherAnimationState = CurrentState;
            catchResult.CatcherHyperDash = HyperDashing;

+            // Ignore JuiceStreams and BananaShowers
            if (!(drawableObject is DrawablePalpableCatchHitObject palpableObject)) return;

            var hitObject = palpableObject.HitObject;
@@ -244,6 +245,14 @@ namespace osu.Game.Rulesets.Catch.UI
                CurrentState = hitObject.Kiai ? CatcherAnimationState.Kiai : CatcherAnimationState.Idle;
            else if (!(hitObject is Banana))
                CurrentState = CatcherAnimationState.Fail;
+
+            if (palpableObject.HitObject.LastInCombo)
+            {
+                if (result.Judgement is CatchJudgement catchJudgement && catchJudgement.ShouldExplodeFor(result))
+                    Explode();
+                else
+                    Drop();
+            }
        }

        public void OnRevertResult(DrawableCatchHitObject drawableObject, JudgementResult result)
@@ -6,11 +6,9 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
-using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 using osuTK;

@@ -72,18 +70,6 @@ namespace osu.Game.Rulesets.Catch.UI
        public void OnNewResult(DrawableCatchHitObject hitObject, JudgementResult result)
        {
            Catcher.OnNewResult(hitObject, result);
-
-            if (!result.Type.IsScorable())
-                return;
-
-            if (hitObject.HitObject.LastInCombo)
-            {
-                if (result.Judgement is CatchJudgement catchJudgement && catchJudgement.ShouldExplodeFor(result))
-                    Catcher.Explode();
-                else
-                    Catcher.Drop();
-            }
-
            comboDisplay.OnNewResult(hitObject, result);
        }

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

+using osu.Framework.iOS;
 using UIKit;

 namespace osu.Game.Rulesets.Mania.Tests.iOS
@@ -9,7 +10,7 @@ namespace osu.Game.Rulesets.Mania.Tests.iOS
    {
        public static void Main(string[] args)
        {
-            UIApplication.Main(args, "GameUIApplication", "AppDelegate");
+            UIApplication.Main(args, typeof(GameUIApplication), typeof(AppDelegate));
        }
    }
 }
@@ -22,6 +22,9 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
        [Resolved]
        private SkinManager skins { get; set; }

+        [Cached]
+        private EditorClipboard clipboard = new EditorClipboard();
+
        [SetUpSteps]
        public void SetUpSteps()
        {
@@ -38,7 +38,7 @@ namespace osu.Game.Rulesets.Mania.Tests
        private IList<string> getSampleNames(IList<HitSampleInfo> hitSampleInfo)
            => hitSampleInfo.Select(sample => sample.LookupNames.First()).ToList();

-        private IList<IList<string>> getNodeSampleNames(List<IList<HitSampleInfo>> hitSampleInfo)
+        private IList<IList<string>> getNodeSampleNames(IList<IList<HitSampleInfo>> hitSampleInfo)
            => hitSampleInfo?.Select(getSampleNames)
                            .ToList();

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Mania.Tests
        public void TestClockRateAdjusted(double expected, string name)
            => Test(expected, name, new ManiaModDoubleTime());

-        protected override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new ManiaDifficultyCalculator(new ManiaRuleset(), beatmap);
+        protected override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new ManiaDifficultyCalculator(new ManiaRuleset().RulesetInfo, beatmap);

        protected override Ruleset CreateRuleset() => new ManiaRuleset();
    }
@@ -2,9 +2,9 @@
  <Import Project="..\osu.TestProject.props" />
  <ItemGroup Label="Package References">
    <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
    <PackageReference Include="NUnit" Version="3.13.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
    <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
  </ItemGroup>
  <PropertyGroup Label="Project">
@@ -488,7 +488,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
        /// Retrieves the list of node samples that occur at time greater than or equal to <paramref name="time"/>.
        /// </summary>
        /// <param name="time">The time to retrieve node samples at.</param>
-        private List<IList<HitSampleInfo>> nodeSamplesAt(int time)
+        private IList<IList<HitSampleInfo>> nodeSamplesAt(int time)
        {
            if (!(HitObject is IHasPathWithRepeats curveData))
                return null;
@@ -1,13 +1,38 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

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

 namespace osu.Game.Rulesets.Mania.Difficulty
 {
    public class ManiaDifficultyAttributes : DifficultyAttributes
    {
+        [JsonProperty("great_hit_window")]
        public double GreatHitWindow { get; set; }
+
+        [JsonProperty("score_multiplier")]
        public double ScoreMultiplier { get; set; }
+
+        public override IEnumerable<(int attributeId, object value)> ToDatabaseAttributes()
+        {
+            foreach (var v in base.ToDatabaseAttributes())
+                yield return v;
+
+            // Todo: osu!mania doesn't output MaxCombo attribute for some reason.
+            yield return (ATTRIB_ID_STRAIN, StarRating);
+            yield return (ATTRIB_ID_GREAT_HIT_WINDOW, GreatHitWindow);
+            yield return (ATTRIB_ID_SCORE_MULTIPLIER, ScoreMultiplier);
+        }
+
+        public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values)
+        {
+            base.FromDatabaseAttributes(values);
+
+            StarRating = values[ATTRIB_ID_STRAIN];
+            GreatHitWindow = values[ATTRIB_ID_GREAT_HIT_WINDOW];
+            ScoreMultiplier = values[ATTRIB_ID_SCORE_MULTIPLIER];
+        }
    }
 }
@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
+using osu.Game.Extensions;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Skills;
@@ -28,17 +29,17 @@ namespace osu.Game.Rulesets.Mania.Difficulty
        private readonly bool isForCurrentRuleset;
        private readonly double originalOverallDifficulty;

-        public ManiaDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+        public ManiaDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
            : base(ruleset, beatmap)
        {
-            isForCurrentRuleset = beatmap.BeatmapInfo.Ruleset.Equals(ruleset.RulesetInfo);
-            originalOverallDifficulty = beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty;
+            isForCurrentRuleset = beatmap.BeatmapInfo.Ruleset.MatchesOnlineID(ruleset);
+            originalOverallDifficulty = beatmap.BeatmapInfo.Difficulty.OverallDifficulty;
        }

        protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
        {
            if (beatmap.HitObjects.Count == 0)
-                return new ManiaDifficultyAttributes { Mods = mods, Skills = skills };
+                return new ManiaDifficultyAttributes { Mods = mods };

            HitWindows hitWindows = new ManiaHitWindows();
            hitWindows.SetDifficulty(beatmap.Difficulty.OverallDifficulty);
@@ -50,7 +51,6 @@ namespace osu.Game.Rulesets.Mania.Difficulty
                GreatHitWindow = Math.Ceiling(getHitWindow300(mods) / clockRate),
                ScoreMultiplier = getScoreMultiplier(mods),
                MaxCombo = beatmap.HitObjects.Sum(h => h is HoldNote ? 2 : 1),
-                Skills = skills
            };
        }

@@ -272,7 +272,7 @@ namespace osu.Game.Rulesets.Mania

        public override Drawable CreateIcon() => new SpriteIcon { Icon = OsuIcon.RulesetMania };

-        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new ManiaDifficultyCalculator(this, beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new ManiaDifficultyCalculator(RulesetInfo, beatmap);

        public int LegacyID => 3;

@@ -3,11 +3,11 @@

 using System.Collections.Generic;
 using osu.Game.Beatmaps;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Replays;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
-using osu.Game.Users;

 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -15,7 +15,7 @@ namespace osu.Game.Rulesets.Mania.Mods
    {
        public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
        {
-            ScoreInfo = new ScoreInfo { User = new User { Username = "osu!topus!" } },
+            ScoreInfo = new ScoreInfo { User = new APIUser { Username = "osu!topus" } },
            Replay = new ManiaAutoGenerator((ManiaBeatmap)beatmap).Generate(),
        };
    }
@@ -3,12 +3,12 @@

 using System.Collections.Generic;
 using osu.Game.Beatmaps;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Replays;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
-using osu.Game.Users;

 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Mania.Mods
    {
        public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
        {
-            ScoreInfo = new ScoreInfo { User = new User { Username = "osu!topus!" } },
+            ScoreInfo = new ScoreInfo { User = new APIUser { Username = "osu!topus" } },
            Replay = new ManiaAutoGenerator((ManiaBeatmap)beatmap).Generate(),
        };
    }
@@ -67,7 +67,7 @@ namespace osu.Game.Rulesets.Mania.Objects
            }
        }

-        public List<IList<HitSampleInfo>> NodeSamples { get; set; }
+        public IList<IList<HitSampleInfo>> NodeSamples { get; set; }

        /// <summary>
        /// The head note of the hold.
@@ -86,20 +86,18 @@ namespace osu.Game.Rulesets.Mania.Skinning.Default
            [BackgroundDependencyLoader]
            private void load()
            {
-                InternalChild = foregroundBuffer = new BufferedContainer
+                InternalChild = foregroundBuffer = new BufferedContainer(cachedFrameBuffer: true)
                {
                    Blending = BlendingParameters.Additive,
                    RelativeSizeAxes = Axes.Both,
-                    CacheDrawnFrameBuffer = true,
                    Children = new Drawable[]
                    {
                        new Box { RelativeSizeAxes = Axes.Both },
-                        subtractionBuffer = new BufferedContainer
+                        subtractionBuffer = new BufferedContainer(cachedFrameBuffer: true)
                        {
                            RelativeSizeAxes = Axes.Both,
                            // This is needed because we're blending with another object
                            BackgroundColour = Color4.White.Opacity(0),
-                            CacheDrawnFrameBuffer = true,
                            // The 'hole' is achieved by subtracting the result of this container with the parent
                            Blending = new BlendingParameters { AlphaEquation = BlendingEquation.ReverseSubtract },
                            Child = subtractionLayer = new CircularContainer
@@ -98,7 +98,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
                float rightLineWidth = skin.GetManiaSkinConfig<float>(LegacyManiaSkinConfigurationLookups.RightLineWidth, columnIndex)?.Value ?? 1;

                bool hasLeftLine = leftLineWidth > 0;
-                bool hasRightLine = rightLineWidth > 0 && skin.GetConfig<LegacySkinConfiguration.LegacySetting, decimal>(LegacySkinConfiguration.LegacySetting.Version)?.Value >= 2.4m
+                bool hasRightLine = rightLineWidth > 0 && skin.GetConfig<SkinConfiguration.LegacySetting, decimal>(SkinConfiguration.LegacySetting.Version)?.Value >= 2.4m
                                    || isLastColumn;

                Color4 lineColour = skin.GetManiaSkinConfig<Color4>(LegacyManiaSkinConfigurationLookups.ColumnLineColour, columnIndex)?.Value ?? Color4.White;
@@ -63,7 +63,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
        {
            this.beatmap = (ManiaBeatmap)beatmap;

-            isLegacySkin = new Lazy<bool>(() => GetConfig<LegacySkinConfiguration.LegacySetting, decimal>(LegacySkinConfiguration.LegacySetting.Version) != null);
+            isLegacySkin = new Lazy<bool>(() => GetConfig<SkinConfiguration.LegacySetting, decimal>(SkinConfiguration.LegacySetting.Version) != null);
            hasKeyTexture = new Lazy<bool>(() =>
            {
                string keyImage = this.GetManiaSkinConfig<string>(LegacyManiaSkinConfigurationLookups.KeyImage, 0)?.Value ?? "mania-key1";
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using osu.Framework.iOS;
 using UIKit;

 namespace osu.Game.Rulesets.Osu.Tests.iOS
@@ -9,7 +10,7 @@ namespace osu.Game.Rulesets.Osu.Tests.iOS
    {
        public static void Main(string[] args)
        {
-            UIApplication.Main(args, "GameUIApplication", "AppDelegate");
+            UIApplication.Main(args, typeof(GameUIApplication), typeof(AppDelegate));
        }
    }
 }
@@ -0,0 +1,185 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Osu.Tests.Editor
+{
+    public class TestSceneSliderStreamConversion : TestSceneOsuEditor
+    {
+        private BindableBeatDivisor beatDivisor => (BindableBeatDivisor)Editor.Dependencies.Get(typeof(BindableBeatDivisor));
+
+        [Test]
+        public void TestSimpleConversion()
+        {
+            Slider slider = null;
+
+            AddStep("select first slider", () =>
+            {
+                slider = (Slider)EditorBeatmap.HitObjects.First(h => h is Slider);
+                EditorClock.Seek(slider.StartTime);
+                EditorBeatmap.SelectedHitObjects.Add(slider);
+            });
+
+            convertToStream();
+
+            AddAssert("stream created", () => streamCreatedFor(slider,
+                (time: 0, pathPosition: 0),
+                (time: 0.25, pathPosition: 0.25),
+                (time: 0.5, pathPosition: 0.5),
+                (time: 0.75, pathPosition: 0.75),
+                (time: 1, pathPosition: 1)));
+
+            AddStep("undo", () => Editor.Undo());
+            AddAssert("slider restored", () => sliderRestored(slider));
+
+            AddStep("select first slider", () =>
+            {
+                slider = (Slider)EditorBeatmap.HitObjects.First(h => h is Slider);
+                EditorClock.Seek(slider.StartTime);
+                EditorBeatmap.SelectedHitObjects.Add(slider);
+            });
+            AddStep("change beat divisor", () => beatDivisor.Value = 8);
+
+            convertToStream();
+            AddAssert("stream created", () => streamCreatedFor(slider,
+                (time: 0, pathPosition: 0),
+                (time: 0.125, pathPosition: 0.125),
+                (time: 0.25, pathPosition: 0.25),
+                (time: 0.375, pathPosition: 0.375),
+                (time: 0.5, pathPosition: 0.5),
+                (time: 0.625, pathPosition: 0.625),
+                (time: 0.75, pathPosition: 0.75),
+                (time: 0.875, pathPosition: 0.875),
+                (time: 1, pathPosition: 1)));
+        }
+
+        [Test]
+        public void TestConversionWithNonMatchingDivisor()
+        {
+            Slider slider = null;
+
+            AddStep("select second slider", () =>
+            {
+                slider = (Slider)EditorBeatmap.HitObjects.Where(h => h is Slider).ElementAt(1);
+                EditorClock.Seek(slider.StartTime);
+                EditorBeatmap.SelectedHitObjects.Add(slider);
+            });
+            AddStep("change beat divisor", () => beatDivisor.Value = 3);
+
+            convertToStream();
+
+            AddAssert("stream created", () => streamCreatedFor(slider,
+                (time: 0, pathPosition: 0),
+                (time: 2 / 3d, pathPosition: 2 / 3d)));
+        }
+
+        [Test]
+        public void TestConversionWithRepeats()
+        {
+            Slider slider = null;
+
+            AddStep("select first slider with repeats", () =>
+            {
+                slider = (Slider)EditorBeatmap.HitObjects.First(h => h is Slider s && s.RepeatCount > 0);
+                EditorClock.Seek(slider.StartTime);
+                EditorBeatmap.SelectedHitObjects.Add(slider);
+            });
+            AddStep("change beat divisor", () => beatDivisor.Value = 2);
+
+            convertToStream();
+
+            AddAssert("stream created", () => streamCreatedFor(slider,
+                (time: 0, pathPosition: 0),
+                (time: 0.25, pathPosition: 0.5),
+                (time: 0.5, pathPosition: 1),
+                (time: 0.75, pathPosition: 0.5),
+                (time: 1, pathPosition: 0)));
+        }
+
+        [Test]
+        public void TestConversionPreservesSliderProperties()
+        {
+            Slider slider = null;
+
+            AddStep("select second new-combo-starting slider", () =>
+            {
+                slider = (Slider)EditorBeatmap.HitObjects.Where(h => h is Slider s && s.NewCombo).ElementAt(1);
+                EditorClock.Seek(slider.StartTime);
+                EditorBeatmap.SelectedHitObjects.Add(slider);
+            });
+
+            convertToStream();
+
+            AddAssert("stream created", () => streamCreatedFor(slider,
+                (time: 0, pathPosition: 0),
+                (time: 0.25, pathPosition: 0.25),
+                (time: 0.5, pathPosition: 0.5),
+                (time: 0.75, pathPosition: 0.75),
+                (time: 1, pathPosition: 1)));
+
+            AddStep("undo", () => Editor.Undo());
+            AddAssert("slider restored", () => sliderRestored(slider));
+        }
+
+        private void convertToStream()
+        {
+            AddStep("convert to stream", () =>
+            {
+                InputManager.PressKey(Key.LControl);
+                InputManager.PressKey(Key.LShift);
+                InputManager.Key(Key.F);
+                InputManager.ReleaseKey(Key.LShift);
+                InputManager.ReleaseKey(Key.LControl);
+            });
+        }
+
+        private bool streamCreatedFor(Slider slider, params (double time, double pathPosition)[] expectedCircles)
+        {
+            if (EditorBeatmap.HitObjects.Contains(slider))
+                return false;
+
+            foreach ((double expectedTime, double expectedPathPosition) in expectedCircles)
+            {
+                double time = slider.StartTime + slider.Duration * expectedTime;
+                Vector2 position = slider.Position + slider.Path.PositionAt(expectedPathPosition);
+
+                if (!EditorBeatmap.HitObjects.OfType<HitCircle>().Any(h => matches(h, time, position, slider.NewCombo && expectedTime == 0)))
+                    return false;
+            }
+
+            return true;
+
+            bool matches(HitCircle circle, double time, Vector2 position, bool startsNewCombo) =>
+                Precision.AlmostEquals(circle.StartTime, time, 1)
+                && Precision.AlmostEquals(circle.Position, position, 0.01f)
+                && circle.NewCombo == startsNewCombo
+                && circle.Samples.SequenceEqual(slider.HeadCircle.Samples)
+                && circle.SampleControlPoint.IsRedundant(slider.SampleControlPoint);
+        }
+
+        private bool sliderRestored(Slider slider)
+        {
+            var objects = EditorBeatmap.HitObjects.Where(h => h.StartTime >= slider.StartTime && h.GetEndTime() <= slider.EndTime).ToList();
+
+            if (objects.Count > 1)
+                return false;
+
+            var hitObject = objects.Single();
+            if (!(hitObject is Slider restoredSlider))
+                return false;
+
+            return Precision.AlmostEquals(slider.StartTime, restoredSlider.StartTime)
+                   && Precision.AlmostEquals(slider.GetEndTime(), restoredSlider.GetEndTime())
+                   && Precision.AlmostEquals(slider.Position, restoredSlider.Position, 0.01f)
+                   && Precision.AlmostEquals(slider.EndPosition, restoredSlider.EndPosition, 0.01f);
+        }
+    }
+}
@@ -137,7 +137,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
            AddAssert("cursor must start visible", () => cursorAlphaAlmostEquals(1));
            AddUntilStep("wait for combo", () => Player.ScoreProcessor.Combo.Value >= 2);
            AddAssert("cursor must dim after combo", () => !cursorAlphaAlmostEquals(1));
-            AddStep("break combo", () => Player.ScoreProcessor.Combo.Set(0));
+            AddStep("break combo", () => Player.ScoreProcessor.Combo.Value = 0);
            AddUntilStep("wait for cursor to show", () => cursorAlphaAlmostEquals(1));
        }

@@ -15,17 +15,17 @@ namespace osu.Game.Rulesets.Osu.Tests
    {
        protected override string ResourceAssembly => "osu.Game.Rulesets.Osu";

-        [TestCase(6.5867229481955389d, "diffcalc-test")]
-        [TestCase(1.0416315570967911d, "zero-length-sliders")]
+        [TestCase(6.6972307565739273d, "diffcalc-test")]
+        [TestCase(1.4484754139145539d, "zero-length-sliders")]
        public void Test(double expected, string name)
            => base.Test(expected, name);

-        [TestCase(8.2730989071947896d, "diffcalc-test")]
-        [TestCase(1.2726413186221039d, "zero-length-sliders")]
+        [TestCase(8.9382559208689809d, "diffcalc-test")]
+        [TestCase(1.7548875851757628d, "zero-length-sliders")]
        public void TestClockRateAdjusted(double expected, string name)
            => Test(expected, name, new OsuModDoubleTime());

-        protected override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new OsuDifficultyCalculator(new OsuRuleset(), beatmap);
+        protected override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new OsuDifficultyCalculator(new OsuRuleset().RulesetInfo, beatmap);

        protected override Ruleset CreateRuleset() => new OsuRuleset();
    }
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Game.Beatmaps;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Beatmaps;
@@ -14,7 +15,6 @@ using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 using osu.Game.Tests.Visual;
-using osu.Game.Users;
 using osuTK;

 namespace osu.Game.Rulesets.Osu.Tests
@@ -69,7 +69,7 @@ namespace osu.Game.Rulesets.Osu.Tests
        {
            public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
            {
-                ScoreInfo = new ScoreInfo { User = new User { Username = "Autoplay" } },
+                ScoreInfo = new ScoreInfo { User = new APIUser { Username = "Autoplay" } },
                Replay = new MissingAutoGenerator(beatmap, mods).Generate()
            };
        }
@@ -0,0 +1,34 @@
+// 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.Beatmaps;
+using osu.Game.Rulesets.Osu.Objects;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    [TestFixture]
+    public class TestSceneNoSpinnerStacking : TestSceneOsuPlayer
+    {
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset)
+        {
+            var beatmap = new Beatmap
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    BaseDifficulty = new BeatmapDifficulty { OverallDifficulty = 10 },
+                    Ruleset = ruleset
+                }
+            };
+
+            for (int i = 0; i < 512; i++)
+            {
+                if (i % 32 < 20)
+                    beatmap.HitObjects.Add(new Spinner { Position = new Vector2(256, 192), StartTime = i * 200, EndTime = (i * 200) + 100 });
+            }
+
+            return beatmap;
+        }
+    }
+}
@@ -2,10 +2,10 @@
  <Import Project="..\osu.TestProject.props" />
  <ItemGroup Label="Package References">
    <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
    <PackageReference Include="Moq" Version="4.16.1" />
    <PackageReference Include="NUnit" Version="3.13.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
    <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
  </ItemGroup>
  <PropertyGroup Label="Project">
@@ -1,20 +1,77 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using System.Collections.Generic;
+using System.Linq;
+using JetBrains.Annotations;
+using Newtonsoft.Json;
 using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mods;

 namespace osu.Game.Rulesets.Osu.Difficulty
 {
    public class OsuDifficultyAttributes : DifficultyAttributes
    {
+        [JsonProperty("aim_strain")]
        public double AimStrain { get; set; }
+
+        [JsonProperty("speed_strain")]
        public double SpeedStrain { get; set; }
+
+        [JsonProperty("flashlight_rating")]
        public double FlashlightRating { get; set; }
+
+        [JsonProperty("slider_factor")]
+        public double SliderFactor { get; set; }
+
+        [JsonProperty("approach_rate")]
        public double ApproachRate { get; set; }
+
+        [JsonProperty("overall_difficulty")]
        public double OverallDifficulty { get; set; }
+
        public double DrainRate { get; set; }
+
        public int HitCircleCount { get; set; }
+
        public int SliderCount { get; set; }
+
        public int SpinnerCount { get; set; }
+
+        public override IEnumerable<(int attributeId, object value)> ToDatabaseAttributes()
+        {
+            foreach (var v in base.ToDatabaseAttributes())
+                yield return v;
+
+            yield return (ATTRIB_ID_AIM, AimStrain);
+            yield return (ATTRIB_ID_SPEED, SpeedStrain);
+            yield return (ATTRIB_ID_OVERALL_DIFFICULTY, OverallDifficulty);
+            yield return (ATTRIB_ID_APPROACH_RATE, ApproachRate);
+            yield return (ATTRIB_ID_MAX_COMBO, MaxCombo);
+            yield return (ATTRIB_ID_STRAIN, StarRating);
+
+            if (ShouldSerializeFlashlightRating())
+                yield return (ATTRIB_ID_FLASHLIGHT, FlashlightRating);
+
+            yield return (ATTRIB_ID_SLIDER_FACTOR, SliderFactor);
+        }
+
+        public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values)
+        {
+            base.FromDatabaseAttributes(values);
+
+            AimStrain = values[ATTRIB_ID_AIM];
+            SpeedStrain = values[ATTRIB_ID_SPEED];
+            OverallDifficulty = values[ATTRIB_ID_OVERALL_DIFFICULTY];
+            ApproachRate = values[ATTRIB_ID_APPROACH_RATE];
+            MaxCombo = (int)values[ATTRIB_ID_MAX_COMBO];
+            StarRating = values[ATTRIB_ID_STRAIN];
+            FlashlightRating = values.GetValueOrDefault(ATTRIB_ID_FLASHLIGHT);
+            SliderFactor = values[ATTRIB_ID_SLIDER_FACTOR];
+        }
+
+        // Used implicitly by Newtonsoft.Json to not serialize flashlight property in some cases.
+        [UsedImplicitly]
+        public bool ShouldSerializeFlashlightRating() => Mods.Any(m => m is ModFlashlight);
    }
 }
@@ -23,7 +23,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
        private const double difficulty_multiplier = 0.0675;
        private double hitWindowGreat;

-        public OsuDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+        public OsuDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
            : base(ruleset, beatmap)
        {
        }
@@ -31,11 +31,14 @@ namespace osu.Game.Rulesets.Osu.Difficulty
        protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
        {
            if (beatmap.HitObjects.Count == 0)
-                return new OsuDifficultyAttributes { Mods = mods, Skills = skills };
+                return new OsuDifficultyAttributes { Mods = mods };

            double aimRating = Math.Sqrt(skills[0].DifficultyValue()) * difficulty_multiplier;
-            double speedRating = Math.Sqrt(skills[1].DifficultyValue()) * difficulty_multiplier;
-            double flashlightRating = Math.Sqrt(skills[2].DifficultyValue()) * difficulty_multiplier;
+            double aimRatingNoSliders = Math.Sqrt(skills[1].DifficultyValue()) * difficulty_multiplier;
+            double speedRating = Math.Sqrt(skills[2].DifficultyValue()) * difficulty_multiplier;
+            double flashlightRating = Math.Sqrt(skills[3].DifficultyValue()) * difficulty_multiplier;
+
+            double sliderFactor = aimRating > 0 ? aimRatingNoSliders / aimRating : 1;

            if (mods.Any(h => h is OsuModRelax))
                speedRating = 0.0;
@@ -74,6 +77,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                AimStrain = aimRating,
                SpeedStrain = speedRating,
                FlashlightRating = flashlightRating,
+                SliderFactor = sliderFactor,
                ApproachRate = preempt > 1200 ? (1800 - preempt) / 120 : (1200 - preempt) / 150 + 5,
                OverallDifficulty = (80 - hitWindowGreat) / 6,
                DrainRate = drainRate,
@@ -81,7 +85,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                HitCircleCount = hitCirclesCount,
                SliderCount = sliderCount,
                SpinnerCount = spinnerCount,
-                Skills = skills
            };
        }

@@ -108,7 +111,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty

            return new Skill[]
            {
-                new Aim(mods),
+                new Aim(mods, true),
+                new Aim(mods, false),
                new Speed(mods, hitWindowGreat),
                new Flashlight(mods)
            };
@@ -54,7 +54,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty

            if (mods.Any(h => h is OsuModRelax))
            {
-                effectiveMissCount += countOk + countMeh;
+                // As we're adding Oks and Mehs to an approximated number of combo breaks the result can be higher than total hits in specific scenarios (which breaks some calculations) so we need to clamp it.
+                effectiveMissCount = Math.Min(effectiveMissCount + countOk + countMeh, totalHits);
+
                multiplier *= 0.6;
            }

@@ -109,13 +111,11 @@ namespace osu.Game.Rulesets.Osu.Difficulty

            double approachRateFactor = 0.0;
            if (Attributes.ApproachRate > 10.33)
-                approachRateFactor = Attributes.ApproachRate - 10.33;
+                approachRateFactor = 0.3 * (Attributes.ApproachRate - 10.33);
            else if (Attributes.ApproachRate < 8.0)
-                approachRateFactor = 0.025 * (8.0 - Attributes.ApproachRate);
+                approachRateFactor = 0.1 * (8.0 - Attributes.ApproachRate);

-            double approachRateTotalHitsFactor = 1.0 / (1.0 + Math.Exp(-(0.007 * (totalHits - 400))));
-
-            double approachRateBonus = 1.0 + (0.03 + 0.37 * approachRateTotalHitsFactor) * approachRateFactor;
+            aimValue *= 1.0 + approachRateFactor * lengthBonus; // Buff for longer maps with high AR.

            if (mods.Any(m => m is OsuModBlinds))
                aimValue *= 1.3 + (totalHits * (0.0016 / (1 + 2 * effectiveMissCount)) * Math.Pow(accuracy, 16)) * (1 - 0.003 * Attributes.DrainRate * Attributes.DrainRate);
@@ -125,10 +125,17 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                aimValue *= 1.0 + 0.04 * (12.0 - Attributes.ApproachRate);
            }

-            aimValue *= approachRateBonus;
+            // We assume 15% of sliders in a map are difficult since there's no way to tell from the performance calculator.
+            double estimateDifficultSliders = Attributes.SliderCount * 0.15;

-            // Scale the aim value with accuracy _slightly_.
-            aimValue *= 0.5 + accuracy / 2.0;
+            if (Attributes.SliderCount > 0)
+            {
+                double estimateSliderEndsDropped = Math.Clamp(Math.Min(countOk + countMeh + countMiss, Attributes.MaxCombo - scoreMaxCombo), 0, estimateDifficultSliders);
+                double sliderNerfFactor = (1 - Attributes.SliderFactor) * Math.Pow(1 - estimateSliderEndsDropped / estimateDifficultSliders, 3) + Attributes.SliderFactor;
+                aimValue *= sliderNerfFactor;
+            }
+
+            aimValue *= accuracy;
            // It is important to also consider accuracy difficulty when doing that.
            aimValue *= 0.98 + Math.Pow(Attributes.OverallDifficulty, 2) / 2500;

@@ -154,11 +161,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty

            double approachRateFactor = 0.0;
            if (Attributes.ApproachRate > 10.33)
-                approachRateFactor = Attributes.ApproachRate - 10.33;
+                approachRateFactor = 0.3 * (Attributes.ApproachRate - 10.33);

-            double approachRateTotalHitsFactor = 1.0 / (1.0 + Math.Exp(-(0.007 * (totalHits - 400))));
-
-            speedValue *= 1.0 + (0.03 + 0.37 * approachRateTotalHitsFactor) * approachRateFactor;
+            speedValue *= 1.0 + approachRateFactor * lengthBonus; // Buff for longer maps with high AR.

            if (mods.Any(m => m is OsuModBlinds))
            {
@@ -255,7 +260,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty

        private int calculateEffectiveMissCount()
        {
-            // guess the number of misses + slider breaks from combo
+            // Guess the number of misses + slider breaks from combo
            double comboBasedMissCount = 0.0;

            if (Attributes.SliderCount > 0)
@@ -265,7 +270,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                    comboBasedMissCount = fullComboThreshold / Math.Max(1.0, scoreMaxCombo);
            }

-            // we're clamping misscount because since its derived from combo it can be higher than total hits and that breaks some calculations
+            // Clamp misscount since it's derived from combo and can be higher than total hits and that breaks some calculations
            comboBasedMissCount = Math.Min(comboBasedMissCount, totalHits);

            return Math.Max(countMiss, (int)Math.Floor(comboBasedMissCount));
@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.

 using System;
-using System.Linq;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;
@@ -12,20 +11,23 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
 {
    public class OsuDifficultyHitObject : DifficultyHitObject
    {
-        private const int normalized_radius = 52;
+        private const int normalized_radius = 50; // Change radius to 50 to make 100 the diameter. Easier for mental maths.
+        private const int min_delta_time = 25;
+        private const float maximum_slider_radius = normalized_radius * 2.4f;
+        private const float assumed_slider_radius = normalized_radius * 1.8f;

        protected new OsuHitObject BaseObject => (OsuHitObject)base.BaseObject;

-        /// <summary>
-        /// Milliseconds elapsed since the start time of the previous <see cref="OsuDifficultyHitObject"/>, with a minimum of 25ms to account for simultaneous <see cref="OsuDifficultyHitObject"/>s.
-        /// </summary>
-        public double StrainTime { get; private set; }
-
        /// <summary>
        /// Normalized distance from the end position of the previous <see cref="OsuDifficultyHitObject"/> to the start position of this <see cref="OsuDifficultyHitObject"/>.
        /// </summary>
        public double JumpDistance { get; private set; }

+        /// <summary>
+        /// Minimum distance from the end position of the previous <see cref="OsuDifficultyHitObject"/> to the start position of this <see cref="OsuDifficultyHitObject"/>.
+        /// </summary>
+        public double MovementDistance { get; private set; }
+
        /// <summary>
        /// Normalized distance between the start and end position of the previous <see cref="OsuDifficultyHitObject"/>.
        /// </summary>
@@ -37,6 +39,21 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
        /// </summary>
        public double? Angle { get; private set; }

+        /// <summary>
+        /// Milliseconds elapsed since the end time of the previous <see cref="OsuDifficultyHitObject"/>, with a minimum of 25ms.
+        /// </summary>
+        public double MovementTime { get; private set; }
+
+        /// <summary>
+        /// Milliseconds elapsed since the start time of the previous <see cref="OsuDifficultyHitObject"/> to the end time of the same previous <see cref="OsuDifficultyHitObject"/>, with a minimum of 25ms.
+        /// </summary>
+        public double TravelTime { get; private set; }
+
+        /// <summary>
+        /// Milliseconds elapsed since the start time of the previous <see cref="OsuDifficultyHitObject"/>, with a minimum of 25ms.
+        /// </summary>
+        public readonly double StrainTime;
+
        private readonly OsuHitObject lastLastObject;
        private readonly OsuHitObject lastObject;

@@ -46,13 +63,13 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
            this.lastLastObject = (OsuHitObject)lastLastObject;
            this.lastObject = (OsuHitObject)lastObject;

-            setDistances();
+            // Capped to 25ms to prevent difficulty calculation breaking from simultaneous objects.
+            StrainTime = Math.Max(DeltaTime, min_delta_time);

-            // Capped to 25ms to prevent difficulty calculation breaking from simulatenous objects.
-            StrainTime = Math.Max(DeltaTime, 25);
+            setDistances(clockRate);
        }

-        private void setDistances()
+        private void setDistances(double clockRate)
        {
            // We don't need to calculate either angle or distance when one of the last->curr objects is a spinner
            if (BaseObject is Spinner || lastObject is Spinner)
@@ -67,15 +84,31 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
                scalingFactor *= 1 + smallCircleBonus;
            }

+            Vector2 lastCursorPosition = getEndCursorPosition(lastObject);
+            JumpDistance = (BaseObject.StackedPosition * scalingFactor - lastCursorPosition * scalingFactor).Length;
+
            if (lastObject is Slider lastSlider)
            {
                computeSliderCursorPosition(lastSlider);
-                TravelDistance = lastSlider.LazyTravelDistance * scalingFactor;
+                TravelDistance = lastSlider.LazyTravelDistance;
+                TravelTime = Math.Max(lastSlider.LazyTravelTime / clockRate, min_delta_time);
+                MovementTime = Math.Max(StrainTime - TravelTime, min_delta_time);
+
+                // Jump distance from the slider tail to the next object, as opposed to the lazy position of JumpDistance.
+                float tailJumpDistance = Vector2.Subtract(lastSlider.TailCircle.StackedPosition, BaseObject.StackedPosition).Length * scalingFactor;
+
+                // For hitobjects which continue in the direction of the slider, the player will normally follow through the slider,
+                // such that they're not jumping from the lazy position but rather from very close to (or the end of) the slider.
+                // In such cases, a leniency is applied by also considering the jump distance from the tail of the slider, and taking the minimum jump distance.
+                // Additional distance is removed based on position of jump relative to slider follow circle radius.
+                // JumpDistance is the leniency distance beyond the assumed_slider_radius. tailJumpDistance is maximum_slider_radius since the full distance of radial leniency is still possible.
+                MovementDistance = Math.Max(0, Math.Min(JumpDistance - (maximum_slider_radius - assumed_slider_radius), tailJumpDistance - maximum_slider_radius));
+            }
+            else
+            {
+                MovementTime = StrainTime;
+                MovementDistance = JumpDistance;
            }
-
-            Vector2 lastCursorPosition = getEndCursorPosition(lastObject);
-
-            JumpDistance = (BaseObject.StackedPosition * scalingFactor - lastCursorPosition * scalingFactor).Length;

            if (lastLastObject != null && !(lastLastObject is Spinner))
            {
@@ -96,35 +129,60 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
            if (slider.LazyEndPosition != null)
                return;

-            slider.LazyEndPosition = slider.StackedPosition;
+            slider.LazyTravelTime = slider.NestedHitObjects[^1].StartTime - slider.StartTime;

-            float approxFollowCircleRadius = (float)(slider.Radius * 3);
-            var computeVertex = new Action<double>(t =>
+            double endTimeMin = slider.LazyTravelTime / slider.SpanDuration;
+            if (endTimeMin % 2 >= 1)
+                endTimeMin = 1 - endTimeMin % 1;
+            else
+                endTimeMin %= 1;
+
+            slider.LazyEndPosition = slider.StackedPosition + slider.Path.PositionAt(endTimeMin); // temporary lazy end position until a real result can be derived.
+            var currCursorPosition = slider.StackedPosition;
+            double scalingFactor = normalized_radius / slider.Radius; // lazySliderDistance is coded to be sensitive to scaling, this makes the maths easier with the thresholds being used.
+
+            for (int i = 1; i < slider.NestedHitObjects.Count; i++)
            {
-                double progress = (t - slider.StartTime) / slider.SpanDuration;
-                if (progress % 2 >= 1)
-                    progress = 1 - progress % 1;
-                else
-                    progress %= 1;
+                var currMovementObj = (OsuHitObject)slider.NestedHitObjects[i];

-                // ReSharper disable once PossibleInvalidOperationException (bugged in current r# version)
-                var diff = slider.StackedPosition + slider.Path.PositionAt(progress) - slider.LazyEndPosition.Value;
-                float dist = diff.Length;
+                Vector2 currMovement = Vector2.Subtract(currMovementObj.StackedPosition, currCursorPosition);
+                double currMovementLength = scalingFactor * currMovement.Length;

-                if (dist > approxFollowCircleRadius)
+                // Amount of movement required so that the cursor position needs to be updated.
+                double requiredMovement = assumed_slider_radius;
+
+                if (i == slider.NestedHitObjects.Count - 1)
                {
-                    // The cursor would be outside the follow circle, we need to move it
-                    diff.Normalize(); // Obtain direction of diff
-                    dist -= approxFollowCircleRadius;
-                    slider.LazyEndPosition += diff * dist;
-                    slider.LazyTravelDistance += dist;
-                }
-            });
+                    // The end of a slider has special aim rules due to the relaxed time constraint on position.
+                    // There is both a lazy end position as well as the actual end slider position. We assume the player takes the simpler movement.
+                    // For sliders that are circular, the lazy end position may actually be farther away than the sliders true end.
+                    // This code is designed to prevent buffing situations where lazy end is actually a less efficient movement.
+                    Vector2 lazyMovement = Vector2.Subtract((Vector2)slider.LazyEndPosition, currCursorPosition);

-            // Skip the head circle
-            var scoringTimes = slider.NestedHitObjects.Skip(1).Select(t => t.StartTime);
-            foreach (double time in scoringTimes)
-                computeVertex(time);
+                    if (lazyMovement.Length < currMovement.Length)
+                        currMovement = lazyMovement;
+
+                    currMovementLength = scalingFactor * currMovement.Length;
+                }
+                else if (currMovementObj is SliderRepeat)
+                {
+                    // For a slider repeat, assume a tighter movement threshold to better assess repeat sliders.
+                    requiredMovement = normalized_radius;
+                }
+
+                if (currMovementLength > requiredMovement)
+                {
+                    // this finds the positional delta from the required radius and the current position, and updates the currCursorPosition accordingly, as well as rewarding distance.
+                    currCursorPosition = Vector2.Add(currCursorPosition, Vector2.Multiply(currMovement, (float)((currMovementLength - requiredMovement) / currMovementLength)));
+                    currMovementLength *= (currMovementLength - requiredMovement) / currMovementLength;
+                    slider.LazyTravelDistance += (float)currMovementLength;
+                }
+
+                if (i == slider.NestedHitObjects.Count - 1)
+                    slider.LazyEndPosition = currCursorPosition;
+            }
+
+            slider.LazyTravelDistance *= (float)Math.Pow(1 + slider.RepeatCount / 2.5, 1.0 / 2.5); // Bonus for repeat sliders until a better per nested object strain system can be achieved.
        }

        private Vector2 getEndCursorPosition(OsuHitObject hitObject)
@@ -14,53 +14,140 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
    /// </summary>
    public class Aim : OsuStrainSkill
    {
-        private const double angle_bonus_begin = Math.PI / 3;
-        private const double timing_threshold = 107;
-
-        public Aim(Mod[] mods)
+        public Aim(Mod[] mods, bool withSliders)
            : base(mods)
        {
+            this.withSliders = withSliders;
        }

-        private double currentStrain = 1;
+        private readonly bool withSliders;

-        private double skillMultiplier => 26.25;
+        protected override int HistoryLength => 2;
+
+        private const double wide_angle_multiplier = 1.5;
+        private const double acute_angle_multiplier = 2.0;
+        private const double slider_multiplier = 1.5;
+        private const double velocity_change_multiplier = 0.75;
+
+        private double currentStrain;
+
+        private double skillMultiplier => 23.25;
        private double strainDecayBase => 0.15;

        private double strainValueOf(DifficultyHitObject current)
        {
-            if (current.BaseObject is Spinner)
+            if (current.BaseObject is Spinner || Previous.Count <= 1 || Previous[0].BaseObject is Spinner)
                return 0;

-            var osuCurrent = (OsuDifficultyHitObject)current;
+            var osuCurrObj = (OsuDifficultyHitObject)current;
+            var osuLastObj = (OsuDifficultyHitObject)Previous[0];
+            var osuLastLastObj = (OsuDifficultyHitObject)Previous[1];

-            double aimStrain = 0;
+            // Calculate the velocity to the current hitobject, which starts with a base distance / time assuming the last object is a hitcircle.
+            double currVelocity = osuCurrObj.JumpDistance / osuCurrObj.StrainTime;

-            if (Previous.Count > 0)
+            // But if the last object is a slider, then we extend the travel velocity through the slider into the current object.
+            if (osuLastObj.BaseObject is Slider && withSliders)
            {
-                var osuPrevious = (OsuDifficultyHitObject)Previous[0];
+                double movementVelocity = osuCurrObj.MovementDistance / osuCurrObj.MovementTime; // calculate the movement velocity from slider end to current object
+                double travelVelocity = osuCurrObj.TravelDistance / osuCurrObj.TravelTime; // calculate the slider velocity from slider head to slider end.

-                if (osuCurrent.Angle != null && osuCurrent.Angle.Value > angle_bonus_begin)
+                currVelocity = Math.Max(currVelocity, movementVelocity + travelVelocity); // take the larger total combined velocity.
+            }
+
+            // As above, do the same for the previous hitobject.
+            double prevVelocity = osuLastObj.JumpDistance / osuLastObj.StrainTime;
+
+            if (osuLastLastObj.BaseObject is Slider && withSliders)
+            {
+                double movementVelocity = osuLastObj.MovementDistance / osuLastObj.MovementTime;
+                double travelVelocity = osuLastObj.TravelDistance / osuLastObj.TravelTime;
+
+                prevVelocity = Math.Max(prevVelocity, movementVelocity + travelVelocity);
+            }
+
+            double wideAngleBonus = 0;
+            double acuteAngleBonus = 0;
+            double sliderBonus = 0;
+            double velocityChangeBonus = 0;
+
+            double aimStrain = currVelocity; // Start strain with regular velocity.
+
+            if (Math.Max(osuCurrObj.StrainTime, osuLastObj.StrainTime) < 1.25 * Math.Min(osuCurrObj.StrainTime, osuLastObj.StrainTime)) // If rhythms are the same.
+            {
+                if (osuCurrObj.Angle != null && osuLastObj.Angle != null && osuLastLastObj.Angle != null)
                {
-                    const double scale = 90;
+                    double currAngle = osuCurrObj.Angle.Value;
+                    double lastAngle = osuLastObj.Angle.Value;
+                    double lastLastAngle = osuLastLastObj.Angle.Value;

-                    double angleBonus = Math.Sqrt(
-                        Math.Max(osuPrevious.JumpDistance - scale, 0)
-                        * Math.Pow(Math.Sin(osuCurrent.Angle.Value - angle_bonus_begin), 2)
-                        * Math.Max(osuCurrent.JumpDistance - scale, 0));
-                    aimStrain = 1.4 * applyDiminishingExp(Math.Max(0, angleBonus)) / Math.Max(timing_threshold, osuPrevious.StrainTime);
+                    // Rewarding angles, take the smaller velocity as base.
+                    double angleBonus = Math.Min(currVelocity, prevVelocity);
+
+                    wideAngleBonus = calcWideAngleBonus(currAngle);
+                    acuteAngleBonus = calcAcuteAngleBonus(currAngle);
+
+                    if (osuCurrObj.StrainTime > 100) // Only buff deltaTime exceeding 300 bpm 1/2.
+                        acuteAngleBonus = 0;
+                    else
+                    {
+                        acuteAngleBonus *= calcAcuteAngleBonus(lastAngle) // Multiply by previous angle, we don't want to buff unless this is a wiggle type pattern.
+                                           * Math.Min(angleBonus, 125 / osuCurrObj.StrainTime) // The maximum velocity we buff is equal to 125 / strainTime
+                                           * Math.Pow(Math.Sin(Math.PI / 2 * Math.Min(1, (100 - osuCurrObj.StrainTime) / 25)), 2) // scale buff from 150 bpm 1/4 to 200 bpm 1/4
+                                           * Math.Pow(Math.Sin(Math.PI / 2 * (Math.Clamp(osuCurrObj.JumpDistance, 50, 100) - 50) / 50), 2); // Buff distance exceeding 50 (radius) up to 100 (diameter).
+                    }
+
+                    // Penalize wide angles if they're repeated, reducing the penalty as the lastAngle gets more acute.
+                    wideAngleBonus *= angleBonus * (1 - Math.Min(wideAngleBonus, Math.Pow(calcWideAngleBonus(lastAngle), 3)));
+                    // Penalize acute angles if they're repeated, reducing the penalty as the lastLastAngle gets more obtuse.
+                    acuteAngleBonus *= 0.5 + 0.5 * (1 - Math.Min(acuteAngleBonus, Math.Pow(calcAcuteAngleBonus(lastLastAngle), 3)));
                }
            }

-            double jumpDistanceExp = applyDiminishingExp(osuCurrent.JumpDistance);
-            double travelDistanceExp = applyDiminishingExp(osuCurrent.TravelDistance);
+            if (Math.Max(prevVelocity, currVelocity) != 0)
+            {
+                // We want to use the average velocity over the whole object when awarding differences, not the individual jump and slider path velocities.
+                prevVelocity = (osuLastObj.JumpDistance + osuLastObj.TravelDistance) / osuLastObj.StrainTime;
+                currVelocity = (osuCurrObj.JumpDistance + osuCurrObj.TravelDistance) / osuCurrObj.StrainTime;

-            return Math.Max(
-                aimStrain + (jumpDistanceExp + travelDistanceExp + Math.Sqrt(travelDistanceExp * jumpDistanceExp)) / Math.Max(osuCurrent.StrainTime, timing_threshold),
-                (Math.Sqrt(travelDistanceExp * jumpDistanceExp) + jumpDistanceExp + travelDistanceExp) / osuCurrent.StrainTime
-            );
+                // Scale with ratio of difference compared to 0.5 * max dist.
+                double distRatio = Math.Pow(Math.Sin(Math.PI / 2 * Math.Abs(prevVelocity - currVelocity) / Math.Max(prevVelocity, currVelocity)), 2);
+
+                // Reward for % distance up to 125 / strainTime for overlaps where velocity is still changing.
+                double overlapVelocityBuff = Math.Min(125 / Math.Min(osuCurrObj.StrainTime, osuLastObj.StrainTime), Math.Abs(prevVelocity - currVelocity));
+
+                // Reward for % distance slowed down compared to previous, paying attention to not award overlap
+                double nonOverlapVelocityBuff = Math.Abs(prevVelocity - currVelocity)
+                                                // do not award overlap
+                                                * Math.Pow(Math.Sin(Math.PI / 2 * Math.Min(1, Math.Min(osuCurrObj.JumpDistance, osuLastObj.JumpDistance) / 100)), 2);
+
+                // Choose the largest bonus, multiplied by ratio.
+                velocityChangeBonus = Math.Max(overlapVelocityBuff, nonOverlapVelocityBuff) * distRatio;
+
+                // Penalize for rhythm changes.
+                velocityChangeBonus *= Math.Pow(Math.Min(osuCurrObj.StrainTime, osuLastObj.StrainTime) / Math.Max(osuCurrObj.StrainTime, osuLastObj.StrainTime), 2);
+            }
+
+            if (osuCurrObj.TravelTime != 0)
+            {
+                // Reward sliders based on velocity.
+                sliderBonus = osuCurrObj.TravelDistance / osuCurrObj.TravelTime;
+            }
+
+            // Add in acute angle bonus or wide angle bonus + velocity change bonus, whichever is larger.
+            aimStrain += Math.Max(acuteAngleBonus * acute_angle_multiplier, wideAngleBonus * wide_angle_multiplier + velocityChangeBonus * velocity_change_multiplier);
+
+            // Add in additional slider velocity bonus.
+            if (withSliders)
+                aimStrain += sliderBonus * slider_multiplier;
+
+            return aimStrain;
        }

+        private double calcWideAngleBonus(double angle) => Math.Pow(Math.Sin(3.0 / 4 * (Math.Min(5.0 / 6 * Math.PI, Math.Max(Math.PI / 6, angle)) - Math.PI / 6)), 2);
+
+        private double calcAcuteAngleBonus(double angle) => 1 - calcWideAngleBonus(angle);
+
        private double applyDiminishingExp(double val) => Math.Pow(val, 0.99);

        private double strainDecay(double ms) => Math.Pow(strainDecayBase, ms / 1000);
@@ -23,7 +23,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
        private double strainDecayBase => 0.15;
        protected override double DecayWeight => 1.0;
        protected override int HistoryLength => 10; // Look back for 10 notes is added for the sake of flashlight calculations.
-        private double currentStrain = 1;
+
+        private double currentStrain;

        private double strainValueOf(DifficultyHitObject current)
        {
@@ -24,8 +24,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
        private double skillMultiplier => 1375;
        private double strainDecayBase => 0.3;

-        private double currentStrain = 1;
-        private double currentRhythm = 1;
+        private double currentStrain;
+        private double currentRhythm;

        protected override int ReducedSectionCount => 5;
        protected override double DifficultyMultiplier => 1.04;
@@ -11,9 +11,12 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
@@ -47,6 +50,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
        [Resolved(CanBeNull = true)]
        private IEditorChangeHandler changeHandler { get; set; }

+        [Resolved(CanBeNull = true)]
+        private BindableBeatDivisor beatDivisor { get; set; }
+
        public override Quad SelectionQuad => BodyPiece.ScreenSpaceDrawQuad;

        private readonly BindableList<PathControlPoint> controlPoints = new BindableList<PathControlPoint>();
@@ -173,6 +179,20 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
            }
        }

+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            if (!IsSelected)
+                return false;
+
+            if (e.Key == Key.F && e.ControlPressed && e.ShiftPressed)
+            {
+                convertToStream();
+                return true;
+            }
+
+            return false;
+        }
+
        private int addControlPoint(Vector2 position)
        {
            position -= HitObject.Position;
@@ -234,9 +254,56 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
            editorBeatmap?.Update(HitObject);
        }

+        private void convertToStream()
+        {
+            if (editorBeatmap == null || changeHandler == null || beatDivisor == null)
+                return;
+
+            var timingPoint = editorBeatmap.ControlPointInfo.TimingPointAt(HitObject.StartTime);
+            double streamSpacing = timingPoint.BeatLength / beatDivisor.Value;
+
+            changeHandler.BeginChange();
+
+            int i = 0;
+            double time = HitObject.StartTime;
+
+            while (!Precision.DefinitelyBigger(time, HitObject.GetEndTime(), 1))
+            {
+                // positionWithRepeats is a fractional number in the range of [0, HitObject.SpanCount()]
+                // and indicates how many fractional spans of a slider have passed up to time.
+                double positionWithRepeats = (time - HitObject.StartTime) / HitObject.Duration * HitObject.SpanCount();
+                double pathPosition = positionWithRepeats - (int)positionWithRepeats;
+                // every second span is in the reverse direction - need to reverse the path position.
+                if (Precision.AlmostBigger(positionWithRepeats % 2, 1))
+                    pathPosition = 1 - pathPosition;
+
+                Vector2 position = HitObject.Position + HitObject.Path.PositionAt(pathPosition);
+
+                var samplePoint = (SampleControlPoint)HitObject.SampleControlPoint.DeepClone();
+                samplePoint.Time = time;
+
+                editorBeatmap.Add(new HitCircle
+                {
+                    StartTime = time,
+                    Position = position,
+                    NewCombo = i == 0 && HitObject.NewCombo,
+                    SampleControlPoint = samplePoint,
+                    Samples = HitObject.HeadCircle.Samples.Select(s => s.With()).ToList()
+                });
+
+                i += 1;
+                time = HitObject.StartTime + i * streamSpacing;
+            }
+
+            editorBeatmap.Remove(HitObject);
+
+            changeHandler.EndChange();
+        }
+
        public override MenuItem[] ContextMenuItems => new MenuItem[]
        {
            new OsuMenuItem("Add control point", MenuItemType.Standard, () => addControlPoint(rightClickPosition)),
+            new OsuMenuItem("Convert to stream", MenuItemType.Destructive, convertToStream),
        };

        // Always refer to the drawable object's slider body so subsequent movement deltas are calculated with updated positions.
@@ -5,10 +5,10 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Scoring;
-using osu.Game.Users;

 namespace osu.Game.Rulesets.Osu.Mods
 {
@@ -18,7 +18,7 @@ namespace osu.Game.Rulesets.Osu.Mods

        public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
        {
-            ScoreInfo = new ScoreInfo { User = new User { Username = "Autoplay" } },
+            ScoreInfo = new ScoreInfo { User = new APIUser { Username = "Autoplay" } },
            Replay = new OsuAutoGenerator(beatmap, mods).Generate()
        };
    }
@@ -5,11 +5,11 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Scoring;
-using osu.Game.Users;

 namespace osu.Game.Rulesets.Osu.Mods
 {
@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Osu.Mods

        public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
        {
-            ScoreInfo = new ScoreInfo { User = new User { Username = "Autoplay" } },
+            ScoreInfo = new ScoreInfo { User = new APIUser { Username = "Autoplay" } },
            Replay = new OsuAutoGenerator(beatmap, mods).Generate()
        };
    }
@@ -4,52 +4,29 @@
 using System;
 using System.Linq;
 using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Localisation;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
-using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.UI;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Scoring;
-using osu.Game.Screens.Play;
 using osu.Game.Utils;

 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModNoScope : Mod, IUpdatableByPlayfield, IApplicableToScoreProcessor, IApplicableToPlayer, IApplicableToBeatmap
+    public class OsuModNoScope : ModNoScope, IUpdatableByPlayfield, IApplicableToBeatmap
    {
-        /// <summary>
-        /// Slightly higher than the cutoff for <see cref="Drawable.IsPresent"/>.
-        /// </summary>
-        private const float min_alpha = 0.0002f;
-
-        private const float transition_duration = 100;
-
-        public override string Name => "No Scope";
-        public override string Acronym => "NS";
-        public override ModType Type => ModType.Fun;
-        public override IconUsage? Icon => FontAwesome.Solid.EyeSlash;
        public override string Description => "Where's the cursor?";
-        public override double ScoreMultiplier => 1;

-        private BindableNumber<int> currentCombo;
-        private IBindable<bool> isBreakTime;
        private PeriodTracker spinnerPeriods;

-        private float comboBasedAlpha;
-
        [SettingSource(
            "Hidden at combo",
            "The combo count at which the cursor becomes completely hidden",
            SettingControlType = typeof(SettingsSlider<int, HiddenComboSlider>)
        )]
-        public BindableInt HiddenComboCount { get; } = new BindableInt
+        public override BindableInt HiddenComboCount { get; } = new BindableInt
        {
            Default = 10,
            Value = 10,
@@ -57,39 +34,16 @@ namespace osu.Game.Rulesets.Osu.Mods
            MaxValue = 50,
        };

-        public ScoreRank AdjustRank(ScoreRank rank, double accuracy) => rank;
-
-        public void ApplyToPlayer(Player player)
-        {
-            isBreakTime = player.IsBreakTime.GetBoundCopy();
-        }
-
        public void ApplyToBeatmap(IBeatmap beatmap)
        {
-            spinnerPeriods = new PeriodTracker(beatmap.HitObjects.OfType<Spinner>().Select(b => new Period(b.StartTime - transition_duration, b.EndTime)));
+            spinnerPeriods = new PeriodTracker(beatmap.HitObjects.OfType<Spinner>().Select(b => new Period(b.StartTime - TRANSITION_DURATION, b.EndTime)));
        }

-        public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor)
+        public void Update(Playfield playfield)
        {
-            if (HiddenComboCount.Value == 0) return;
-
-            currentCombo = scoreProcessor.Combo.GetBoundCopy();
-            currentCombo.BindValueChanged(combo =>
-            {
-                comboBasedAlpha = Math.Max(min_alpha, 1 - (float)combo.NewValue / HiddenComboCount.Value);
-            }, true);
+            bool shouldAlwaysShowCursor = IsBreakTime.Value || spinnerPeriods.IsInAny(playfield.Clock.CurrentTime);
+            float targetAlpha = shouldAlwaysShowCursor ? 1 : ComboBasedAlpha;
+            playfield.Cursor.Alpha = (float)Interpolation.Lerp(playfield.Cursor.Alpha, targetAlpha, Math.Clamp(playfield.Time.Elapsed / TRANSITION_DURATION, 0, 1));
        }
-
-        public virtual void Update(Playfield playfield)
-        {
-            bool shouldAlwaysShowCursor = isBreakTime.Value || spinnerPeriods.IsInAny(playfield.Clock.CurrentTime);
-            float targetAlpha = shouldAlwaysShowCursor ? 1 : comboBasedAlpha;
-            playfield.Cursor.Alpha = (float)Interpolation.Lerp(playfield.Cursor.Alpha, targetAlpha, Math.Clamp(playfield.Time.Elapsed / transition_duration, 0, 1));
-        }
-    }
-
-    public class HiddenComboSlider : OsuSliderBar<int>
-    {
-        public override LocalisableString TooltipText => Current.Value == 0 ? "always hidden" : base.TooltipText;
    }
 }
@@ -59,7 +59,7 @@ namespace osu.Game.Rulesets.Osu.Objects
            set => StackHeightBindable.Value = value;
        }

-        public Vector2 StackOffset => new Vector2(StackHeight * Scale * -6.4f);
+        public virtual Vector2 StackOffset => new Vector2(StackHeight * Scale * -6.4f);

        public double Radius => OBJECT_RADIUS * Scale;

@@ -79,7 +79,13 @@ namespace osu.Game.Rulesets.Osu.Objects
        /// </summary>
        internal float LazyTravelDistance;

-        public List<IList<HitSampleInfo>> NodeSamples { get; set; } = new List<IList<HitSampleInfo>>();
+        /// <summary>
+        /// The time taken by the cursor upon completion of this <see cref="Slider"/> if it was hit
+        /// with as few movements as possible. This is set and used by difficulty calculation.
+        /// </summary>
+        internal double LazyTravelTime;
+
+        public IList<IList<HitSampleInfo>> NodeSamples { get; set; } = new List<IList<HitSampleInfo>>();

        [JsonIgnore]
        public IList<HitSampleInfo> TailSamples { get; private set; }
@@ -8,6 +8,7 @@ using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
+using osuTK;

 namespace osu.Game.Rulesets.Osu.Objects
 {
@@ -31,6 +32,8 @@ namespace osu.Game.Rulesets.Osu.Objects
        /// </summary>
        public int MaximumBonusSpins { get; protected set; } = 1;

+        public override Vector2 StackOffset => Vector2.Zero;
+
        protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, IBeatmapDifficultyInfo difficulty)
        {
            base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
@@ -208,7 +208,7 @@ namespace osu.Game.Rulesets.Osu

        public override Drawable CreateIcon() => new SpriteIcon { Icon = OsuIcon.RulesetOsu };

-        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new OsuDifficultyCalculator(this, beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new OsuDifficultyCalculator(RulesetInfo, beatmap);

        public override PerformanceCalculator CreatePerformanceCalculator(DifficultyAttributes attributes, ScoreInfo score) => new OsuPerformanceCalculator(this, attributes, score);

@@ -14,7 +14,6 @@ using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Skinning;
 using osuTK;
 using osuTK.Graphics;
-using static osu.Game.Skinning.LegacySkinConfiguration;

 namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 {
@@ -158,7 +157,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy

                        if (hasNumber)
                        {
-                            decimal? legacyVersion = skin.GetConfig<LegacySetting, decimal>(LegacySetting.Version)?.Value;
+                            decimal? legacyVersion = skin.GetConfig<SkinConfiguration.LegacySetting, decimal>(SkinConfiguration.LegacySetting.Version)?.Value;

                            if (legacyVersion >= 2.0m)
                                // legacy skins of version 2.0 and newer only apply very short fade out to the number piece.
@@ -136,10 +136,9 @@ namespace osu.Game.Rulesets.Osu.Statistics
                            }
                        }
                    },
-                    bufferedGrid = new BufferedContainer
+                    bufferedGrid = new BufferedContainer(cachedFrameBuffer: true)
                    {
                        RelativeSizeAxes = Axes.Both,
-                        CacheDrawnFrameBuffer = true,
                        BackgroundColour = Color4Extensions.FromHex("#202624").Opacity(0),
                        Child = pointGrid = new GridContainer
                        {
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using osu.Framework.iOS;
 using UIKit;

 namespace osu.Game.Rulesets.Taiko.Tests.iOS
@@ -9,7 +10,7 @@ namespace osu.Game.Rulesets.Taiko.Tests.iOS
    {
        public static void Main(string[] args)
        {
-            UIApplication.Main(args, "GameUIApplication", "AppDelegate");
+            UIApplication.Main(args, typeof(GameUIApplication), typeof(AppDelegate));
        }
    }
 }
@@ -27,7 +27,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
            var controlPointInfo = new ControlPointInfo();
            controlPointInfo.Add(0, new TimingControlPoint());

-            WorkingBeatmap beatmap = CreateWorkingBeatmap(new Beatmap
+            IWorkingBeatmap beatmap = CreateWorkingBeatmap(new Beatmap
            {
                HitObjects = new List<HitObject> { new Hit { Type = HitType.Centre } },
                BeatmapInfo = new BeatmapInfo
@@ -0,0 +1,91 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Input;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Taiko.Beatmaps;
+using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Setup;
+using osu.Game.Screens.Menu;
+using osu.Game.Screens.Select;
+using osu.Game.Tests.Visual;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Editor
+{
+    public class TestSceneEditorSaving : OsuGameTestScene
+    {
+        private Screens.Edit.Editor editor => Game.ChildrenOfType<Screens.Edit.Editor>().FirstOrDefault();
+
+        private EditorBeatmap editorBeatmap => (EditorBeatmap)editor.Dependencies.Get(typeof(EditorBeatmap));
+
+        /// <summary>
+        /// Tests the general expected flow of creating a new beatmap, saving it, then loading it back from song select.
+        /// Emphasis is placed on <see cref="BeatmapDifficulty.SliderMultiplier"/>, since taiko has special handling for it to keep compatibility with stable.
+        /// </summary>
+        [Test]
+        public void TestNewBeatmapSaveThenLoad()
+        {
+            AddStep("set default beatmap", () => Game.Beatmap.SetDefault());
+            AddStep("set taiko ruleset", () => Ruleset.Value = new TaikoRuleset().RulesetInfo);
+
+            PushAndConfirm(() => new EditorLoader());
+
+            AddUntilStep("wait for editor load", () => editor?.IsLoaded == true);
+
+            AddUntilStep("wait for metadata screen load", () => editor.ChildrenOfType<MetadataSection>().FirstOrDefault()?.IsLoaded == true);
+
+            // We intentionally switch away from the metadata screen, else there is a feedback loop with the textbox handling which causes metadata changes below to get overwritten.
+
+            AddStep("Enter compose mode", () => InputManager.Key(Key.F1));
+            AddUntilStep("Wait for compose mode load", () => editor.ChildrenOfType<HitObjectComposer>().FirstOrDefault()?.IsLoaded == true);
+
+            AddStep("Set slider multiplier", () => editorBeatmap.Difficulty.SliderMultiplier = 2);
+            AddStep("Set artist and title", () =>
+            {
+                editorBeatmap.BeatmapInfo.Metadata.Artist = "artist";
+                editorBeatmap.BeatmapInfo.Metadata.Title = "title";
+            });
+            AddStep("Set difficulty name", () => editorBeatmap.BeatmapInfo.DifficultyName = "difficulty");
+
+            checkMutations();
+
+            AddStep("Save", () => InputManager.Keys(PlatformAction.Save));
+
+            checkMutations();
+
+            AddStep("Exit", () => InputManager.Key(Key.Escape));
+
+            AddUntilStep("Wait for main menu", () => Game.ScreenStack.CurrentScreen is MainMenu);
+
+            PushAndConfirm(() => new PlaySongSelect());
+
+            AddUntilStep("Wait for beatmap selected", () => !Game.Beatmap.IsDefault);
+            AddStep("Open options", () => InputManager.Key(Key.F3));
+            AddStep("Enter editor", () => InputManager.Key(Key.Number5));
+
+            AddUntilStep("Wait for editor load", () => editor != null);
+
+            checkMutations();
+        }
+
+        private void checkMutations()
+        {
+            AddAssert("Beatmap has correct slider multiplier", () =>
+            {
+                // we can only assert value correctness on TaikoMultiplierAppliedDifficulty, because that is the final difficulty converted taiko beatmaps use.
+                // therefore, ensure that we have that difficulty type by calling .CopyFrom(), which is a no-op if the type is already correct.
+                var taikoDifficulty = new TaikoBeatmapConverter.TaikoMultiplierAppliedDifficulty();
+                taikoDifficulty.CopyFrom(editorBeatmap.Difficulty);
+                return Precision.AlmostEquals(taikoDifficulty.SliderMultiplier, 2);
+            });
+            AddAssert("Beatmap has correct metadata", () => editorBeatmap.BeatmapInfo.Metadata.Artist == "artist" && editorBeatmap.BeatmapInfo.Metadata.Title == "title");
+            AddAssert("Beatmap has correct difficulty name", () => editorBeatmap.BeatmapInfo.DifficultyName == "difficulty");
+        }
+    }
+}
@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
        public void TestClockRateAdjusted(double expected, string name)
            => Test(expected, name, new TaikoModDoubleTime());

-        protected override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new TaikoDifficultyCalculator(new TaikoRuleset(), beatmap);
+        protected override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new TaikoDifficultyCalculator(new TaikoRuleset().RulesetInfo, beatmap);

        protected override Ruleset CreateRuleset() => new TaikoRuleset();
    }
@@ -2,9 +2,9 @@
  <Import Project="..\osu.TestProject.props" />
  <ItemGroup Label="Package References">
    <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
    <PackageReference Include="NUnit" Version="3.13.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
    <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
  </ItemGroup>
  <PropertyGroup Label="Project">
@@ -81,7 +81,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                {
                    if (shouldConvertSliderToHits(obj, beatmap, distanceData, out int taikoDuration, out double tickSpacing))
                    {
-                        List<IList<HitSampleInfo>> allSamples = obj is IHasPathWithRepeats curveData ? curveData.NodeSamples : new List<IList<HitSampleInfo>>(new[] { samples });
+                        IList<IList<HitSampleInfo>> allSamples = obj is IHasPathWithRepeats curveData ? curveData.NodeSamples : new List<IList<HitSampleInfo>>(new[] { samples });

                        int i = 0;

@@ -191,7 +191,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps

        protected override Beatmap<TaikoHitObject> CreateBeatmap() => new TaikoBeatmap();

-        private class TaikoMultiplierAppliedDifficulty : BeatmapDifficulty
+        internal class TaikoMultiplierAppliedDifficulty : BeatmapDifficulty
        {
            public TaikoMultiplierAppliedDifficulty(IBeatmapDifficultyInfo difficulty)
            {
@@ -209,7 +209,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
            {
                base.CopyTo(other);
                if (!(other is TaikoMultiplierAppliedDifficulty))
-                    SliderMultiplier /= LegacyBeatmapEncoder.LEGACY_TAIKO_VELOCITY_MULTIPLIER;
+                    other.SliderMultiplier /= LegacyBeatmapEncoder.LEGACY_TAIKO_VELOCITY_MULTIPLIER;
            }

            public override void CopyFrom(IBeatmapDifficultyInfo other)
@@ -1,16 +1,46 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

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

 namespace osu.Game.Rulesets.Taiko.Difficulty
 {
    public class TaikoDifficultyAttributes : DifficultyAttributes
    {
+        [JsonProperty("stamina_strain")]
        public double StaminaStrain { get; set; }
+
+        [JsonProperty("rhythm_strain")]
        public double RhythmStrain { get; set; }
+
+        [JsonProperty("colour_strain")]
        public double ColourStrain { get; set; }
+
+        [JsonProperty("approach_rate")]
        public double ApproachRate { get; set; }
+
+        [JsonProperty("great_hit_window")]
        public double GreatHitWindow { get; set; }
+
+        public override IEnumerable<(int attributeId, object value)> ToDatabaseAttributes()
+        {
+            foreach (var v in base.ToDatabaseAttributes())
+                yield return v;
+
+            yield return (ATTRIB_ID_MAX_COMBO, MaxCombo);
+            yield return (ATTRIB_ID_STRAIN, StarRating);
+            yield return (ATTRIB_ID_GREAT_HIT_WINDOW, GreatHitWindow);
+        }
+
+        public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values)
+        {
+            base.FromDatabaseAttributes(values);
+
+            MaxCombo = (int)values[ATTRIB_ID_MAX_COMBO];
+            StarRating = values[ATTRIB_ID_STRAIN];
+            GreatHitWindow = values[ATTRIB_ID_GREAT_HIT_WINDOW];
+        }
    }
 }
@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
        private const double colour_skill_multiplier = 0.01;
        private const double stamina_skill_multiplier = 0.02;

-        public TaikoDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+        public TaikoDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
            : base(ruleset, beatmap)
        {
        }
@@ -65,7 +65,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
        protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
        {
            if (beatmap.HitObjects.Count == 0)
-                return new TaikoDifficultyAttributes { Mods = mods, Skills = skills };
+                return new TaikoDifficultyAttributes { Mods = mods };

            var colour = (Colour)skills[0];
            var rhythm = (Rhythm)skills[1];
@@ -96,7 +96,6 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
                ColourStrain = colourRating,
                GreatHitWindow = hitWindows.WindowFor(HitResult.Great) / clockRate,
                MaxCombo = beatmap.HitObjects.Count(h => h is Hit),
-                Skills = skills
            };
        }

@@ -3,10 +3,10 @@

 using System.Collections.Generic;
 using osu.Game.Beatmaps;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Taiko.Replays;
 using osu.Game.Scoring;
-using osu.Game.Users;

 namespace osu.Game.Rulesets.Taiko.Mods
 {
@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
    {
        public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
        {
-            ScoreInfo = new ScoreInfo { User = new User { Username = "mekkadosu!" } },
+            ScoreInfo = new ScoreInfo { User = new APIUser { Username = "mekkadosu!" } },
            Replay = new TaikoAutoGenerator(beatmap).Generate(),
        };
    }
@@ -3,11 +3,11 @@

 using System.Collections.Generic;
 using osu.Game.Beatmaps;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Rulesets.Taiko.Replays;
 using osu.Game.Scoring;
-using osu.Game.Users;

 namespace osu.Game.Rulesets.Taiko.Mods
 {
@@ -15,7 +15,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
    {
        public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
        {
-            ScoreInfo = new ScoreInfo { User = new User { Username = "mekkadosu!" } },
+            ScoreInfo = new ScoreInfo { User = new APIUser { Username = "mekkadosu!" } },
            Replay = new TaikoAutoGenerator(beatmap).Generate(),
        };
    }
@@ -69,7 +69,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
            // because the right half is flipped, we need to position using width - position to get the true "topleft" origin position
            float negativeScaleAdjust = content.Width / ratio;

-            if (skin.GetConfig<LegacySkinConfiguration.LegacySetting, decimal>(LegacySkinConfiguration.LegacySetting.Version)?.Value >= 2.1m)
+            if (skin.GetConfig<SkinConfiguration.LegacySetting, decimal>(SkinConfiguration.LegacySetting.Version)?.Value >= 2.1m)
            {
                left.Centre.Position = new Vector2(0, taiko_bar_y) * ratio;
                right.Centre.Position = new Vector2(negativeScaleAdjust - 56, taiko_bar_y) * ratio;
--- a/Show More
+++ b/Show More