Merge pull request #15526 from Susko3/move-HoverClickSounds

Move `HoverClickSounds` to cover only the clickable button in `KeyBindingRow`
Merge pull request #15522 from bdach/taiko-slider-multiplier-saving
2026-05-30 04:39:54 +08:00 · 2021-11-08 23:01:05 +09:00 · 2021-11-08 22:51:43 +09:00 · 2021-11-08 22:34:56 +09:00 · 2021-11-08 14:32:00 +01:00 · 2021-11-08 13:42:56 +01:00
506 changed files with 6513 additions and 4245 deletions
@@ -14,8 +14,8 @@
        "jb"
      ]
    },
-    "smoogipoo.nvika": {
-      "version": "1.0.1",
+    "nvika": {
+      "version": "2.2.0",
      "commands": [
        "nvika"
      ]
@@ -33,4 +33,4 @@
      ]
    }
  }
-}
+}
@@ -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,7 +10,7 @@
    </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 Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
@@ -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,7 +10,7 @@
  </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 Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
@@ -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(),
        };
@@ -10,7 +10,7 @@
  </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 Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
@@ -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,7 +10,7 @@
  </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 Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
@@ -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(),
        };
@@ -52,7 +52,7 @@
  </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.Framework.Android" Version="2021.1108.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. -->
@@ -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>();
@@ -2,7 +2,7 @@
  <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 Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
@@ -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(),
        };
    }
@@ -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)
                        {
@@ -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();

@@ -2,7 +2,7 @@
  <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 Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
@@ -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;
@@ -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";
@@ -15,13 +15,13 @@ 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.6975550434910005d, "diffcalc-test")]
+        [TestCase(1.4670676815251105d, "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.9389769779826267d, "diffcalc-test")]
+        [TestCase(1.7786917985891204d, "zero-length-sliders")]
        public void TestClockRateAdjusted(double expected, string name)
            => Test(expected, name, new OsuModDoubleTime());

@@ -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,7 +2,7 @@
  <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" />
@@ -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,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                aimValue *= 1.0 + 0.04 * (12.0 - Attributes.ApproachRate);
            }

-            aimValue *= approachRateBonus;
-
-            // Scale the aim value with accuracy _slightly_.
-            aimValue *= 0.5 + accuracy / 2.0;
+            aimValue *= accuracy;
            // It is important to also consider accuracy difficulty when doing that.
            aimValue *= 0.98 + Math.Pow(Attributes.OverallDifficulty, 2) / 2500;

@@ -154,11 +151,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 +250,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 +260,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.65f;

        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,136 @@ 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)
            : base(mods)
        {
        }

-        private double currentStrain = 1;
+        protected override int HistoryLength => 2;

-        private double skillMultiplier => 26.25;
+        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)
            {
-                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)
+            {
+                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.
+            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;
@@ -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()
        };
    }
@@ -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);
@@ -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
                        {
@@ -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.Version = "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.Version == "difficulty");
+        }
+    }
+}
@@ -2,7 +2,7 @@
  <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 Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
@@ -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)
@@ -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;
@@ -112,7 +112,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                Assert.AreEqual("Renatus", metadata.TitleUnicode);
                Assert.AreEqual("Soleily", metadata.Artist);
                Assert.AreEqual("Soleily", metadata.ArtistUnicode);
-                Assert.AreEqual("Gamu", metadata.AuthorString);
+                Assert.AreEqual("Gamu", metadata.Author.Username);
                Assert.AreEqual("Insane", beatmapInfo.Version);
                Assert.AreEqual(string.Empty, metadata.Source);
                Assert.AreEqual("MBC7 Unisphere 地球ヤバイEP Chikyu Yabai", metadata.Tags);
@@ -547,7 +547,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                Assert.DoesNotThrow(() => beatmap = decoder.Decode(stream));
                Assert.IsNotNull(beatmap);
                Assert.AreEqual("Beatmap with corrupted header", beatmap.Metadata.Title);
-                Assert.AreEqual("Evil Hacker", beatmap.Metadata.AuthorString);
+                Assert.AreEqual("Evil Hacker", beatmap.Metadata.Author.Username);
            }
        }

@@ -565,7 +565,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                Assert.DoesNotThrow(() => beatmap = decoder.Decode(stream));
                Assert.IsNotNull(beatmap);
                Assert.AreEqual("Beatmap with no header", beatmap.Metadata.Title);
-                Assert.AreEqual("Incredibly Evil Hacker", beatmap.Metadata.AuthorString);
+                Assert.AreEqual("Incredibly Evil Hacker", beatmap.Metadata.Author.Username);
            }
        }

@@ -583,7 +583,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                Assert.DoesNotThrow(() => beatmap = decoder.Decode(stream));
                Assert.IsNotNull(beatmap);
                Assert.AreEqual("Empty lines at start", beatmap.Metadata.Title);
-                Assert.AreEqual("Edge Case Hunter", beatmap.Metadata.AuthorString);
+                Assert.AreEqual("Edge Case Hunter", beatmap.Metadata.Author.Username);
            }
        }

@@ -601,7 +601,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                Assert.DoesNotThrow(() => beatmap = decoder.Decode(stream));
                Assert.IsNotNull(beatmap);
                Assert.AreEqual("The dog ate the file header", beatmap.Metadata.Title);
-                Assert.AreEqual("Why does this keep happening", beatmap.Metadata.AuthorString);
+                Assert.AreEqual("Why does this keep happening", beatmap.Metadata.Author.Username);
            }
        }

@@ -619,7 +619,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                Assert.DoesNotThrow(() => beatmap = decoder.Decode(stream));
                Assert.IsNotNull(beatmap);
                Assert.AreEqual("No empty line delimiting header from contents", beatmap.Metadata.Title);
-                Assert.AreEqual("Edge Case Hunter", beatmap.Metadata.AuthorString);
+                Assert.AreEqual("Edge Case Hunter", beatmap.Metadata.Author.Username);
            }
        }

@@ -673,6 +673,8 @@ namespace osu.Game.Tests.Beatmaps.Formats
                Assert.That(first.ControlPoints[1].Position, Is.EqualTo(new Vector2(161, -244)));
                Assert.That(first.ControlPoints[1].Type, Is.EqualTo(null));

+                // ReSharper disable once HeuristicUnreachableCode
+                // weird one, see https://youtrack.jetbrains.com/issue/RIDER-70159.
                Assert.That(first.ControlPoints[2].Position, Is.EqualTo(new Vector2(376, -3)));
                Assert.That(first.ControlPoints[2].Type, Is.EqualTo(PathType.Bezier));
                Assert.That(first.ControlPoints[3].Position, Is.EqualTo(new Vector2(68, 15)));
@@ -35,7 +35,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
            Assert.AreEqual("Soleily", meta.Artist);
            Assert.AreEqual("Soleily", meta.ArtistUnicode);
            Assert.AreEqual("03. Renatus - Soleily 192kbps.mp3", meta.AudioFile);
-            Assert.AreEqual("Gamu", meta.AuthorString);
+            Assert.AreEqual("Gamu", meta.Author.Username);
            Assert.AreEqual("machinetop_background.jpg", meta.BackgroundFile);
            Assert.AreEqual(164471, meta.PreviewTime);
            Assert.AreEqual(string.Empty, meta.Source);
@@ -17,12 +17,12 @@ using osu.Framework.Logging;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.IO;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Scoring;
 using osu.Game.Tests.Resources;
 using osu.Game.Tests.Scores.IO;
-using osu.Game.Users;
 using SharpCompress.Archives;
 using SharpCompress.Archives.Zip;
 using SharpCompress.Common;
@@ -408,8 +408,8 @@ namespace osu.Game.Tests.Beatmaps.IO
                    var manager = osu.Dependencies.Get<BeatmapManager>();

                    // ReSharper disable once AccessToModifiedClosure
-                    manager.ItemUpdated.BindValueChanged(_ => Interlocked.Increment(ref itemAddRemoveFireCount));
-                    manager.ItemRemoved.BindValueChanged(_ => Interlocked.Increment(ref itemAddRemoveFireCount));
+                    manager.ItemUpdated += _ => Interlocked.Increment(ref itemAddRemoveFireCount);
+                    manager.ItemRemoved += _ => Interlocked.Increment(ref itemAddRemoveFireCount);

                    var imported = await LoadOszIntoOsu(osu);

@@ -846,6 +846,42 @@ namespace osu.Game.Tests.Beatmaps.IO
            }
        }

+        // TODO: needs to be pulled across to realm implementation when this file is nuked.
+        [Test]
+        public void TestSaveRemovesInvalidCharactersFromPath()
+        {
+            // unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host);
+
+                    var manager = osu.Dependencies.Get<BeatmapManager>();
+
+                    var working = manager.CreateNew(new OsuRuleset().RulesetInfo, APIUser.SYSTEM_USER);
+
+                    var beatmap = working.Beatmap;
+
+                    beatmap.BeatmapInfo.Version = "difficulty";
+                    beatmap.BeatmapInfo.Metadata = new BeatmapMetadata
+                    {
+                        Artist = "Artist/With\\Slashes",
+                        Title = "Title",
+                        AuthorString = "mapper",
+                    };
+
+                    manager.Save(beatmap.BeatmapInfo, working.Beatmap);
+
+                    Assert.AreEqual("Artist_With_Slashes - Title (mapper) [difficulty].osu", beatmap.BeatmapInfo.Path);
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
        [Test]
        public void TestCreateNewEmptyBeatmap()
        {
@@ -856,7 +892,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                    var osu = LoadOsuIntoHost(host);
                    var manager = osu.Dependencies.Get<BeatmapManager>();

-                    var working = manager.CreateNew(new OsuRuleset().RulesetInfo, User.SYSTEM_USER);
+                    var working = manager.CreateNew(new OsuRuleset().RulesetInfo, APIUser.SYSTEM_USER);

                    manager.Save(working.BeatmapInfo, working.Beatmap);

@@ -883,7 +919,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                    var osu = LoadOsuIntoHost(host);
                    var manager = osu.Dependencies.Get<BeatmapManager>();

-                    var working = manager.CreateNew(new OsuRuleset().RulesetInfo, User.SYSTEM_USER);
+                    var working = manager.CreateNew(new OsuRuleset().RulesetInfo, APIUser.SYSTEM_USER);

                    ((Beatmap)working.Beatmap).HitObjects.Add(new HitCircle { StartTime = 5000 });

@@ -60,7 +60,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                Assert.AreEqual("Soleily", meta.Artist);
                Assert.AreEqual("Soleily", meta.ArtistUnicode);
                Assert.AreEqual("03. Renatus - Soleily 192kbps.mp3", meta.AudioFile);
-                Assert.AreEqual("Deif", meta.AuthorString);
+                Assert.AreEqual("Deif", meta.Author.Username);
                Assert.AreEqual("machinetop_background.jpg", meta.BackgroundFile);
                Assert.AreEqual(164471, meta.PreviewTime);
                Assert.AreEqual(string.Empty, meta.Source);
@@ -3,7 +3,7 @@

 using NUnit.Framework;
 using osu.Game.Beatmaps;
-using osu.Game.Users;
+using osu.Game.Online.API.Requests.Responses;

 namespace osu.Game.Tests.Beatmaps
 {
@@ -34,7 +34,7 @@ namespace osu.Game.Tests.Beatmaps
                {
                    Artist = "artist",
                    Title = "title",
-                    Author = new User { Username = "creator" }
+                    Author = new APIUser { Username = "creator" }
                }
            };

@@ -50,7 +50,7 @@ namespace osu.Game.Tests.Beatmaps
                {
                    Artist = "artist",
                    Title = "title",
-                    Author = new User { Username = "creator" }
+                    Author = new APIUser { Username = "creator" }
                },
                Version = "difficulty"
            };
@@ -9,9 +9,9 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Chat;
 using osu.Game.Tests.Visual;
-using osu.Game.Users;

 namespace osu.Game.Tests.Chat
 {
@@ -133,7 +133,7 @@ namespace osu.Game.Tests.Chat
            }
        }

-        private Channel createChannel(int id, ChannelType type) => new Channel(new User())
+        private Channel createChannel(int id, ChannelType type) => new Channel(new APIUser())
        {
            Id = id,
            Name = $"Channel {id}",
@@ -482,7 +482,10 @@ namespace osu.Game.Tests.Database
                var metadata = new RealmBeatmapMetadata
                {
                    Artist = "SomeArtist",
-                    Author = "SomeAuthor"
+                    Author =
+                    {
+                        Username = "SomeAuthor"
+                    }
                };

                var ruleset = realmFactory.Context.All<RealmRuleset>().First();
@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Platform;
 using osu.Game.Database;
@@ -33,7 +34,7 @@ namespace osu.Game.Tests.Database
            storage = new NativeStorage(directory.FullName);

            realmContextFactory = new RealmContextFactory(storage, "test");
-            keyBindingStore = new RealmKeyBindingStore(realmContextFactory);
+            keyBindingStore = new RealmKeyBindingStore(realmContextFactory, new ReadableKeyCombinationProvider());
        }

        [Test]
@@ -35,7 +35,7 @@ namespace osu.Game.Tests.Editing.Checks
        public void TestMissing()
        {
            // While this is a problem, it is out of scope for this check and is caught by a different one.
-            beatmap.Metadata.AudioFile = null;
+            beatmap.Metadata.AudioFile = string.Empty;

            var mock = new Mock<IWorkingBeatmap>();
            mock.SetupGet(w => w.Beatmap).Returns(beatmap);
@@ -53,7 +53,7 @@ namespace osu.Game.Tests.Editing.Checks
        public void TestMissing()
        {
            // While this is a problem, it is out of scope for this check and is caught by a different one.
-            beatmap.Metadata.BackgroundFile = null;
+            beatmap.Metadata.BackgroundFile = string.Empty;
            var context = getContext(null, System.Array.Empty<byte>());

            Assert.That(check.Run(context), Is.Empty);
@@ -65,7 +65,7 @@ namespace osu.Game.Tests.Editing.Checks
        [Test]
        public void TestBackgroundNotSet()
        {
-            beatmap.Metadata.BackgroundFile = null;
+            beatmap.Metadata.BackgroundFile = string.Empty;

            var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
            var issues = check.Run(context).ToList();
@@ -7,7 +7,7 @@ using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Tests.Beatmaps;
 using osu.Game.Tests.Resources;
-using static osu.Game.Skinning.LegacySkinConfiguration;
+using static osu.Game.Skinning.SkinConfiguration;

 namespace osu.Game.Tests.Gameplay
 {
@@ -105,6 +105,9 @@ namespace osu.Game.Tests.Mods
            testMod.ResetSettingsToDefaults();

            Assert.That(testMod.DrainRate.Value, Is.Null);
+
+            // ReSharper disable once HeuristicUnreachableCode
+            // see https://youtrack.jetbrains.com/issue/RIDER-70159.
            Assert.That(testMod.OverallDifficulty.Value, Is.Null);

            var applied = applyDifficulty(new BeatmapDifficulty
@@ -39,8 +39,8 @@ namespace osu.Game.Tests.NonVisual
        [Test]
        public void TestCheckNullID()
        {
-            var ourInfo = new BeatmapSetInfo { Status = BeatmapSetOnlineStatus.Loved };
-            var otherInfo = new BeatmapSetInfo { Status = BeatmapSetOnlineStatus.Approved };
+            var ourInfo = new BeatmapSetInfo { Hash = "1" };
+            var otherInfo = new BeatmapSetInfo { Hash = "2" };

            Assert.AreNotEqual(ourInfo, otherInfo);
        }
@@ -189,7 +189,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
        public void TestCriteriaMatchingArtistWithNullUnicodeName(string artistName, bool filtered)
        {
            var exampleBeatmapInfo = getExampleBeatmap();
-            exampleBeatmapInfo.Metadata.ArtistUnicode = null;
+            exampleBeatmapInfo.Metadata.ArtistUnicode = string.Empty;

            var criteria = new FilterCriteria
            {
@@ -79,8 +79,17 @@ namespace osu.Game.Tests.NonVisual
            public List<HitObject> HitObjects;
            public override IEnumerable<HitObject> Objects => HitObjects;

-            public override event Action<JudgementResult> NewResult;
-            public override event Action<JudgementResult> RevertResult;
+            public override event Action<JudgementResult> NewResult
+            {
+                add => throw new InvalidOperationException();
+                remove => throw new InvalidOperationException();
+            }
+
+            public override event Action<JudgementResult> RevertResult
+            {
+                add => throw new InvalidOperationException();
+                remove => throw new InvalidOperationException();
+            }

            public override Playfield Playfield { get; }
            public override Container Overlays { get; }
@@ -95,9 +104,6 @@ namespace osu.Game.Tests.NonVisual
            public TestDrawableRuleset()
                : base(new OsuRuleset())
            {
-                // won't compile without this.
-                NewResult?.Invoke(null);
-                RevertResult?.Invoke(null);
            }

            public override void SetReplayScore(Score replayScore) => throw new NotImplementedException();
@@ -6,10 +6,10 @@ using Humanizer;
 using NUnit.Framework;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Testing;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
 using osu.Game.Tests.Visual.Multiplayer;
-using osu.Game.Users;

 namespace osu.Game.Tests.NonVisual.Multiplayer
 {
@@ -21,7 +21,7 @@ namespace osu.Game.Tests.NonVisual.Multiplayer
        {
            int id = 2000;

-            AddRepeatStep("add some users", () => Client.AddUser(new User { Id = id++ }), 5);
+            AddRepeatStep("add some users", () => Client.AddUser(new APIUser { Id = id++ }), 5);
            checkPlayingUserCount(0);

            AddAssert("playlist item is available", () => Client.CurrentMatchPlayingItem.Value != null);
@@ -64,7 +64,7 @@ namespace osu.Game.Tests.NonVisual.Multiplayer
                    room.State = MultiplayerRoomState.Playing;
                    room.Users.Add(new MultiplayerRoomUser(PLAYER_1_ID)
                    {
-                        User = new User { Id = PLAYER_1_ID },
+                        User = new APIUser { Id = PLAYER_1_ID },
                        State = MultiplayerUserState.Playing
                    });
                };
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using System;
 using System.Collections.Generic;
 using Newtonsoft.Json;
 using NUnit.Framework;
@@ -8,6 +9,7 @@ using osu.Framework.Bindables;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Online.API;
+using osu.Game.Online.Solo;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
@@ -66,9 +68,11 @@ namespace osu.Game.Tests.Online
            var deserialised = JsonConvert.DeserializeObject<APIMod>(JsonConvert.SerializeObject(apiMod));
            var converted = (TestModTimeRamp)deserialised?.ToMod(new TestRuleset());

-            Assert.That(converted?.AdjustPitch.Value, Is.EqualTo(false));
-            Assert.That(converted?.InitialRate.Value, Is.EqualTo(1.25));
-            Assert.That(converted?.FinalRate.Value, Is.EqualTo(0.25));
+            Assert.That(converted, Is.Not.Null);
+
+            Assert.That(converted.AdjustPitch.Value, Is.EqualTo(false));
+            Assert.That(converted.InitialRate.Value, Is.EqualTo(1.25));
+            Assert.That(converted.FinalRate.Value, Is.EqualTo(0.25));
        }

        [Test]
@@ -88,33 +92,27 @@ namespace osu.Game.Tests.Online
        }

        [Test]
-        public void TestDeserialiseScoreInfoWithEmptyMods()
+        public void TestDeserialiseSubmittableScoreWithEmptyMods()
        {
-            var score = new ScoreInfo { Ruleset = new OsuRuleset().RulesetInfo };
+            var score = new SubmittableScore(new ScoreInfo { Ruleset = new OsuRuleset().RulesetInfo });

-            var deserialised = JsonConvert.DeserializeObject<ScoreInfo>(JsonConvert.SerializeObject(score));
-
-            if (deserialised != null)
-                deserialised.Ruleset = new OsuRuleset().RulesetInfo;
+            var deserialised = JsonConvert.DeserializeObject<SubmittableScore>(JsonConvert.SerializeObject(score));

            Assert.That(deserialised?.Mods.Length, Is.Zero);
        }

        [Test]
-        public void TestDeserialiseScoreInfoWithCustomModSetting()
+        public void TestDeserialiseSubmittableScoreWithCustomModSetting()
        {
-            var score = new ScoreInfo
+            var score = new SubmittableScore(new ScoreInfo
            {
                Ruleset = new OsuRuleset().RulesetInfo,
                Mods = new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 2 } } }
-            };
+            });

-            var deserialised = JsonConvert.DeserializeObject<ScoreInfo>(JsonConvert.SerializeObject(score));
+            var deserialised = JsonConvert.DeserializeObject<SubmittableScore>(JsonConvert.SerializeObject(score));

-            if (deserialised != null)
-                deserialised.Ruleset = new OsuRuleset().RulesetInfo;
-
-            Assert.That(((OsuModDoubleTime)deserialised?.Mods[0])?.SpeedChange.Value, Is.EqualTo(2));
+            Assert.That((deserialised?.Mods[0])?.Settings["speed_change"], Is.EqualTo(2));
        }

        private class TestRuleset : Ruleset
@@ -126,11 +124,11 @@ namespace osu.Game.Tests.Online
                new TestModDifficultyAdjust()
            };

-            public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod> mods = null) => throw new System.NotImplementedException();
+            public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod> mods = null) => throw new NotImplementedException();

-            public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => throw new System.NotImplementedException();
+            public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => throw new NotImplementedException();

-            public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => throw new System.NotImplementedException();
+            public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => throw new NotImplementedException();

            public override string Description { get; } = string.Empty;
            public override string ShortName { get; } = string.Empty;
@@ -128,7 +128,7 @@ namespace osu.Game.Tests.Online

        private void addAvailabilityCheckStep(string description, Func<BeatmapAvailability> expected)
        {
-            AddAssert(description, () => availabilityTracker.Availability.Value.Equals(expected.Invoke()));
+            AddUntilStep(description, () => availabilityTracker.Availability.Value.Equals(expected.Invoke()));
        }

        private static BeatmapInfo getTestBeatmapInfo(string archiveFile)
@@ -168,19 +168,19 @@ namespace osu.Game.Tests.Online
                return new TestBeatmapModelManager(this, storage, contextFactory, rulesets, api, host);
            }

-            protected override BeatmapModelDownloader CreateBeatmapModelDownloader(IBeatmapModelManager manager, IAPIProvider api, GameHost host)
+            protected override BeatmapModelDownloader CreateBeatmapModelDownloader(IModelImporter<BeatmapSetInfo> manager, IAPIProvider api, GameHost host)
            {
                return new TestBeatmapModelDownloader(manager, api, host);
            }

            internal class TestBeatmapModelDownloader : BeatmapModelDownloader
            {
-                public TestBeatmapModelDownloader(IBeatmapModelManager modelManager, IAPIProvider apiProvider, GameHost gameHost)
-                    : base(modelManager, apiProvider, gameHost)
+                public TestBeatmapModelDownloader(IModelImporter<BeatmapSetInfo> importer, IAPIProvider apiProvider, GameHost gameHost)
+                    : base(importer, apiProvider, gameHost)
                {
                }

-                protected override ArchiveDownloadRequest<BeatmapSetInfo> CreateDownloadRequest(BeatmapSetInfo set, bool minimiseDownloadSize)
+                protected override ArchiveDownloadRequest<IBeatmapSetInfo> CreateDownloadRequest(IBeatmapSetInfo set, bool minimiseDownloadSize)
                    => new TestDownloadRequest(set);
            }

@@ -202,12 +202,12 @@ namespace osu.Game.Tests.Online
            }
        }

-        private class TestDownloadRequest : ArchiveDownloadRequest<BeatmapSetInfo>
+        private class TestDownloadRequest : ArchiveDownloadRequest<IBeatmapSetInfo>
        {
            public new void SetProgress(float progress) => base.SetProgress(progress);
            public new void TriggerSuccess(string filename) => base.TriggerSuccess(filename);

-            public TestDownloadRequest(BeatmapSetInfo model)
+            public TestDownloadRequest(IBeatmapSetInfo model)
                : base(model)
            {
            }
@@ -3,8 +3,8 @@

 using NUnit.Framework;
 using osu.Framework.Testing;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Tests.Visual.Multiplayer;
-using osu.Game.Users;

 namespace osu.Game.Tests.OnlinePlay
 {
@@ -14,7 +14,7 @@ namespace osu.Game.Tests.OnlinePlay
        [Test]
        public void TestUserAddedOnJoin()
        {
-            var user = new User { Id = 33 };
+            var user = new APIUser { Id = 33 };

            AddRepeatStep("add user multiple times", () => Client.AddUser(user), 3);
            AddAssert("room has 2 users", () => Client.Room?.Users.Count == 2);
@@ -23,7 +23,7 @@ namespace osu.Game.Tests.OnlinePlay
        [Test]
        public void TestUserRemovedOnLeave()
        {
-            var user = new User { Id = 44 };
+            var user = new APIUser { Id = 44 };

            AddStep("add user", () => Client.AddUser(user));
            AddAssert("room has 2 users", () => Client.Room?.Users.Count == 2);
@@ -11,12 +11,12 @@ using osu.Framework.Allocation;
 using osu.Framework.Platform;
 using osu.Game.Beatmaps;
 using osu.Game.IO.Archives;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
-using osu.Game.Users;

 namespace osu.Game.Tests.Scores.IO
 {
@@ -38,7 +38,7 @@ namespace osu.Game.Tests.Scores.IO
                        Accuracy = 0.8,
                        MaxCombo = 500,
                        Combo = 250,
-                        User = new User { Username = "Test user" },
+                        User = new APIUser { Username = "Test user" },
                        Date = DateTimeOffset.Now,
                        OnlineScoreID = 12345,
                    };
@@ -4,10 +4,12 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Platform;
+using osu.Game.IO;
 using osu.Game.IO.Archives;
 using osu.Game.Skinning;
 using SharpCompress.Archives.Zip;
@@ -16,169 +18,213 @@ namespace osu.Game.Tests.Skins.IO
 {
    public class ImportSkinTest : ImportTest
    {
-        [Test]
-        public async Task TestBasicImport()
-        {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportSkinTest)))
-            {
-                try
-                {
-                    var osu = LoadOsuIntoHost(host);
-
-                    var imported = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk("test skin", "skinner"), "skin.osk"));
-
-                    Assert.That(imported.Name, Is.EqualTo("test skin"));
-                    Assert.That(imported.Creator, Is.EqualTo("skinner"));
-                }
-                finally
-                {
-                    host.Exit();
-                }
-            }
-        }
+        #region Testing filename metadata inclusion

        [Test]
-        public async Task TestImportTwiceWithSameMetadata()
+        public Task TestSingleImportDifferentFilename() => runSkinTest(async osu =>
        {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportSkinTest)))
-            {
-                try
-                {
-                    var osu = LoadOsuIntoHost(host);
+            var import1 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni("test skin", "skinner"), "skin.osk"));

-                    var imported = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk("test skin", "skinner"), "skin.osk"));
-                    var imported2 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk("test skin", "skinner"), "skin2.osk"));
-
-                    Assert.That(imported2.ID, Is.Not.EqualTo(imported.ID));
-                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins(true).Count, Is.EqualTo(1));
-
-                    // the first should be overwritten by the second import.
-                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins(true).First().Files.First().FileInfoID, Is.EqualTo(imported2.Files.First().FileInfoID));
-                }
-                finally
-                {
-                    host.Exit();
-                }
-            }
-        }
+            // When the import filename doesn't match, it should be appended (and update the skin.ini).
+            assertCorrectMetadata(import1, "test skin [skin]", "skinner", osu);
+        });

        [Test]
-        public async Task TestImportTwiceWithNoMetadata()
+        public Task TestSingleImportWeirdIniFileCase() => runSkinTest(async osu =>
        {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportSkinTest)))
-            {
-                try
-                {
-                    var osu = LoadOsuIntoHost(host);
+            var import1 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni("test skin", "skinner", iniFilename: "Skin.InI"), "skin.osk"));

-                    // if a user downloads two skins that do have skin.ini files but don't have any creator metadata in the skin.ini, they should both import separately just for safety.
-                    var imported = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk(string.Empty, string.Empty), "download.osk"));
-                    var imported2 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk(string.Empty, string.Empty), "download.osk"));
-
-                    Assert.That(imported2.ID, Is.Not.EqualTo(imported.ID));
-                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins(true).Count, Is.EqualTo(2));
-
-                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins(true).First().Files.First().FileInfoID, Is.EqualTo(imported.Files.First().FileInfoID));
-                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins(true).Last().Files.First().FileInfoID, Is.EqualTo(imported2.Files.First().FileInfoID));
-                }
-                finally
-                {
-                    host.Exit();
-                }
-            }
-        }
+            // When the import filename doesn't match, it should be appended (and update the skin.ini).
+            assertCorrectMetadata(import1, "test skin [skin]", "skinner", osu);
+        });

        [Test]
-        public async Task TestImportTwiceWithDifferentMetadata()
+        public Task TestSingleImportMissingSectionHeader() => runSkinTest(async osu =>
        {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportSkinTest)))
-            {
-                try
-                {
-                    var osu = LoadOsuIntoHost(host);
+            var import1 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni("test skin", "skinner", includeSectionHeader: false), "skin.osk"));

-                    var imported = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk("test skin v2", "skinner"), "skin.osk"));
-                    var imported2 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk("test skin v2.1", "skinner"), "skin2.osk"));
-
-                    Assert.That(imported2.ID, Is.Not.EqualTo(imported.ID));
-                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins(true).Count, Is.EqualTo(2));
-
-                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins(true).First().Files.First().FileInfoID, Is.EqualTo(imported.Files.First().FileInfoID));
-                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins(true).Last().Files.First().FileInfoID, Is.EqualTo(imported2.Files.First().FileInfoID));
-                }
-                finally
-                {
-                    host.Exit();
-                }
-            }
-        }
+            // When the import filename doesn't match, it should be appended (and update the skin.ini).
+            assertCorrectMetadata(import1, "test skin [skin]", "skinner", osu);
+        });

        [Test]
-        public async Task TestImportUpperCasedOskArchive()
+        public Task TestSingleImportMatchingFilename() => runSkinTest(async osu =>
        {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportSkinTest)))
-            {
-                try
-                {
-                    var osu = LoadOsuIntoHost(host);
+            var import1 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni("test skin", "skinner"), "test skin.osk"));

-                    var imported = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk("name 1", "author 1"), "skin1.OsK"));
-
-                    Assert.That(imported.Name, Is.EqualTo("name 1"));
-                    Assert.That(imported.Creator, Is.EqualTo("author 1"));
-
-                    var imported2 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk("name 1", "author 1"), "skin1.oSK"));
-
-                    Assert.That(imported2.Hash, Is.EqualTo(imported.Hash));
-                }
-                finally
-                {
-                    host.Exit();
-                }
-            }
-        }
+            // When the import filename matches it shouldn't be appended.
+            assertCorrectMetadata(import1, "test skin", "skinner", osu);
+        });

        [Test]
-        public async Task TestSameMetadataNameDifferentFolderName()
+        public Task TestSingleImportNoIniFile() => runSkinTest(async osu =>
        {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportSkinTest)))
-            {
-                try
-                {
-                    var osu = LoadOsuIntoHost(host);
+            var import1 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithNonIniFile(), "test skin.osk"));

-                    var imported = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk("name 1", "author 1", false), "my custom skin 1"));
-                    Assert.That(imported.Name, Is.EqualTo("name 1 [my custom skin 1]"));
-                    Assert.That(imported.Creator, Is.EqualTo("author 1"));
+            // When the import filename matches it shouldn't be appended.
+            assertCorrectMetadata(import1, "test skin", "Unknown", osu);
+        });

-                    var imported2 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk("name 1", "author 1", false), "my custom skin 2"));
-                    Assert.That(imported2.Name, Is.EqualTo("name 1 [my custom skin 2]"));
-                    Assert.That(imported2.Creator, Is.EqualTo("author 1"));
+        [Test]
+        public Task TestEmptyImportImportsWithFilename() => runSkinTest(async osu =>
+        {
+            var import1 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createEmptyOsk(), "test skin.osk"));

-                    Assert.That(imported2.Hash, Is.Not.EqualTo(imported.Hash));
-                }
-                finally
-                {
-                    host.Exit();
-                }
-            }
+            // When the import filename matches it shouldn't be appended.
+            assertCorrectMetadata(import1, "test skin", "Unknown", osu);
+        });
+
+        #endregion
+
+        #region Cases where imports should match existing
+
+        [Test]
+        public Task TestImportTwiceWithSameMetadataAndFilename() => runSkinTest(async osu =>
+        {
+            var import1 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni("test skin", "skinner"), "skin.osk"));
+            var import2 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni("test skin", "skinner"), "skin.osk"));
+
+            assertImportedOnce(import1, import2);
+        });
+
+        [Test]
+        public Task TestImportTwiceWithNoMetadataSameDownloadFilename() => runSkinTest(async osu =>
+        {
+            // if a user downloads two skins that do have skin.ini files but don't have any creator metadata in the skin.ini, they should both import separately just for safety.
+            var import1 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni(string.Empty, string.Empty), "download.osk"));
+            var import2 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni(string.Empty, string.Empty), "download.osk"));
+
+            assertImportedOnce(import1, import2);
+        });
+
+        [Test]
+        public Task TestImportUpperCasedOskArchive() => runSkinTest(async osu =>
+        {
+            var import1 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni("name 1", "author 1"), "name 1.OsK"));
+            assertCorrectMetadata(import1, "name 1", "author 1", osu);
+
+            var import2 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni("name 1", "author 1"), "name 1.oSK"));
+
+            assertImportedOnce(import1, import2);
+        });
+
+        [Test]
+        public Task TestSameMetadataNameSameFolderName() => runSkinTest(async osu =>
+        {
+            var import1 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni("name 1", "author 1"), "my custom skin 1"));
+            var import2 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni("name 1", "author 1"), "my custom skin 1"));
+
+            assertImportedOnce(import1, import2);
+            assertCorrectMetadata(import1, "name 1 [my custom skin 1]", "author 1", osu);
+        });
+
+        #endregion
+
+        #region Cases where imports should be uniquely imported
+
+        [Test]
+        public Task TestImportTwiceWithSameMetadataButDifferentFilename() => runSkinTest(async osu =>
+        {
+            var import1 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni("test skin", "skinner"), "skin.osk"));
+            var import2 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni("test skin", "skinner"), "skin2.osk"));
+
+            assertImportedBoth(import1, import2);
+        });
+
+        [Test]
+        public Task TestImportTwiceWithNoMetadataDifferentDownloadFilename() => runSkinTest(async osu =>
+        {
+            // if a user downloads two skins that do have skin.ini files but don't have any creator metadata in the skin.ini, they should both import separately just for safety.
+            var import1 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni(string.Empty, string.Empty), "download.osk"));
+            var import2 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni(string.Empty, string.Empty), "download2.osk"));
+
+            assertImportedBoth(import1, import2);
+        });
+
+        [Test]
+        public Task TestImportTwiceWithSameFilenameDifferentMetadata() => runSkinTest(async osu =>
+        {
+            var import1 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni("test skin v2", "skinner"), "skin.osk"));
+            var import2 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni("test skin v2.1", "skinner"), "skin.osk"));
+
+            assertImportedBoth(import1, import2);
+            assertCorrectMetadata(import1, "test skin v2 [skin]", "skinner", osu);
+            assertCorrectMetadata(import2, "test skin v2.1 [skin]", "skinner", osu);
+        });
+
+        [Test]
+        public Task TestSameMetadataNameDifferentFolderName() => runSkinTest(async osu =>
+        {
+            var import1 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni("name 1", "author 1"), "my custom skin 1"));
+            var import2 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOskWithIni("name 1", "author 1"), "my custom skin 2"));
+
+            assertImportedBoth(import1, import2);
+            assertCorrectMetadata(import1, "name 1 [my custom skin 1]", "author 1", osu);
+            assertCorrectMetadata(import2, "name 1 [my custom skin 2]", "author 1", osu);
+        });
+
+        #endregion
+
+        private void assertCorrectMetadata(SkinInfo import1, string name, string creator, OsuGameBase osu)
+        {
+            Assert.That(import1.Name, Is.EqualTo(name));
+            Assert.That(import1.Creator, Is.EqualTo(creator));
+
+            // for extra safety let's reconstruct the skin, reading from the skin.ini.
+            var instance = import1.CreateInstance((IStorageResourceProvider)osu.Dependencies.Get(typeof(SkinManager)));
+
+            Assert.That(instance.Configuration.SkinInfo.Name, Is.EqualTo(name));
+            Assert.That(instance.Configuration.SkinInfo.Creator, Is.EqualTo(creator));
        }

-        private MemoryStream createOsk(string name, string author, bool makeUnique = true)
+        private void assertImportedBoth(SkinInfo import1, SkinInfo import2)
+        {
+            Assert.That(import2.ID, Is.Not.EqualTo(import1.ID));
+            Assert.That(import2.Hash, Is.Not.EqualTo(import1.Hash));
+            Assert.That(import2.Files.Select(f => f.FileInfoID), Is.Not.EquivalentTo(import1.Files.Select(f => f.FileInfoID)));
+        }
+
+        private void assertImportedOnce(SkinInfo import1, SkinInfo import2)
+        {
+            Assert.That(import2.ID, Is.EqualTo(import1.ID));
+            Assert.That(import2.Hash, Is.EqualTo(import1.Hash));
+            Assert.That(import2.Files.Select(f => f.FileInfoID), Is.EquivalentTo(import1.Files.Select(f => f.FileInfoID)));
+        }
+
+        private MemoryStream createEmptyOsk()
        {
            var zipStream = new MemoryStream();
            using var zip = ZipArchive.Create();
-            zip.AddEntry("skin.ini", generateSkinIni(name, author, makeUnique));
            zip.SaveTo(zipStream);
            return zipStream;
        }

-        private MemoryStream generateSkinIni(string name, string author, bool makeUnique = true)
+        private MemoryStream createOskWithNonIniFile()
+        {
+            var zipStream = new MemoryStream();
+            using var zip = ZipArchive.Create();
+            zip.AddEntry("hitcircle.png", new MemoryStream(new byte[] { 0, 1, 2, 3 }));
+            zip.SaveTo(zipStream);
+            return zipStream;
+        }
+
+        private MemoryStream createOskWithIni(string name, string author, bool makeUnique = false, string iniFilename = @"skin.ini", bool includeSectionHeader = true)
+        {
+            var zipStream = new MemoryStream();
+            using var zip = ZipArchive.Create();
+            zip.AddEntry(iniFilename, generateSkinIni(name, author, makeUnique, includeSectionHeader));
+            zip.SaveTo(zipStream);
+            return zipStream;
+        }
+
+        private MemoryStream generateSkinIni(string name, string author, bool makeUnique = true, bool includeSectionHeader = true)
        {
            var stream = new MemoryStream();
            var writer = new StreamWriter(stream);

-            writer.WriteLine("[General]");
+            if (includeSectionHeader)
+                writer.WriteLine("[General]");
+
            writer.WriteLine($"Name: {name}");
            writer.WriteLine($"Author: {author}");

@@ -193,6 +239,22 @@ namespace osu.Game.Tests.Skins.IO
            return stream;
        }

+        private async Task runSkinTest(Func<OsuGameBase, Task> action, [CallerMemberName] string callingMethodName = @"")
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(callingMethodName))
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host);
+                    await action(osu);
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
        private async Task<SkinInfo> loadSkinIntoOsu(OsuGameBase osu, ArchiveReader archive = null)
        {
            var skinManager = osu.Dependencies.Get<SkinManager>();
@@ -106,7 +106,7 @@ namespace osu.Game.Tests.Skins
            var decoder = new LegacySkinDecoder();
            using (var resStream = TestResources.OpenResource("skin-latest.ini"))
            using (var stream = new LineBufferedReader(resStream))
-                Assert.AreEqual(LegacySkinConfiguration.LATEST_VERSION, decoder.Decode(stream).LegacyVersion);
+                Assert.AreEqual(SkinConfiguration.LATEST_VERSION, decoder.Decode(stream).LegacyVersion);
        }

        [Test]
@@ -151,7 +151,7 @@ namespace osu.Game.Tests.Skins
        {
            AddStep("Set user skin version 2.3", () => userSource.Configuration.LegacyVersion = 2.3m);
            AddStep("Set beatmap skin version null", () => beatmapSource.Configuration.LegacyVersion = null);
-            AddAssert("Check legacy version lookup", () => requester.GetConfig<LegacySkinConfiguration.LegacySetting, decimal>(LegacySkinConfiguration.LegacySetting.Version)?.Value == 2.3m);
+            AddAssert("Check legacy version lookup", () => requester.GetConfig<SkinConfiguration.LegacySetting, decimal>(SkinConfiguration.LegacySetting.Version)?.Value == 2.3m);
        }

        [Test]
@@ -160,7 +160,7 @@ namespace osu.Game.Tests.Skins
            // completely ignoring beatmap versions for simplicity.
            AddStep("Set user skin version 2.3", () => userSource.Configuration.LegacyVersion = 2.3m);
            AddStep("Set beatmap skin version null", () => beatmapSource.Configuration.LegacyVersion = 1.7m);
-            AddAssert("Check legacy version lookup", () => requester.GetConfig<LegacySkinConfiguration.LegacySetting, decimal>(LegacySkinConfiguration.LegacySetting.Version)?.Value == 2.3m);
+            AddAssert("Check legacy version lookup", () => requester.GetConfig<SkinConfiguration.LegacySetting, decimal>(SkinConfiguration.LegacySetting.Version)?.Value == 2.3m);
        }

        [Test]
@@ -169,14 +169,14 @@ namespace osu.Game.Tests.Skins
            AddStep("Set user skin version 2.3", () => userSource.Configuration.LegacyVersion = null);
            AddStep("Set beatmap skin version null", () => beatmapSource.Configuration.LegacyVersion = null);
            AddAssert("Check legacy version lookup",
-                () => requester.GetConfig<LegacySkinConfiguration.LegacySetting, decimal>(LegacySkinConfiguration.LegacySetting.Version)?.Value == LegacySkinConfiguration.LATEST_VERSION);
+                () => requester.GetConfig<SkinConfiguration.LegacySetting, decimal>(SkinConfiguration.LegacySetting.Version)?.Value == SkinConfiguration.LATEST_VERSION);
        }

        [Test]
        public void TestIniWithNoVersionFallsBackTo1()
        {
            AddStep("Parse skin with no version", () => userSource.Configuration = new LegacySkinDecoder().Decode(new LineBufferedReader(new MemoryStream())));
-            AddAssert("Check legacy version lookup", () => requester.GetConfig<LegacySkinConfiguration.LegacySetting, decimal>(LegacySkinConfiguration.LegacySetting.Version)?.Value == 1.0m);
+            AddAssert("Check legacy version lookup", () => requester.GetConfig<SkinConfiguration.LegacySetting, decimal>(SkinConfiguration.LegacySetting.Version)?.Value == 1.0m);
        }

        public enum LookupType
@@ -10,10 +10,10 @@ using osu.Framework.Testing;
 using osu.Game.Configuration;
 using osu.Game.Graphics.Backgrounds;
 using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Screens;
 using osu.Game.Screens.Backgrounds;
 using osu.Game.Skinning;
-using osu.Game.Users;

 namespace osu.Game.Tests.Visual.Background
 {
@@ -113,7 +113,7 @@ namespace osu.Game.Tests.Visual.Background
            AddStep($"set background mode to {source}", () => config.SetValue(OsuSetting.MenuBackgroundSource, source));

        private void setSupporter(bool isSupporter) =>
-            AddStep($"set supporter {isSupporter}", () => ((DummyAPIAccess)API).LocalUser.Value = new User
+            AddStep($"set supporter {isSupporter}", () => ((DummyAPIAccess)API).LocalUser.Value = new APIUser
            {
                IsSupporter = isSupporter,
                Id = API.LocalUser.Value.Id + 1,
@@ -18,6 +18,7 @@ using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Scoring;
@@ -29,7 +30,6 @@ using osu.Game.Screens.Ranking;
 using osu.Game.Screens.Select;
 using osu.Game.Tests.Beatmaps;
 using osu.Game.Tests.Resources;
-using osu.Game.Users;
 using osuTK;
 using osuTK.Graphics;

@@ -231,7 +231,7 @@ namespace osu.Game.Tests.Visual.Background

            AddStep("Transition to Results", () => player.Push(results = new FadeAccessibleResults(new ScoreInfo
            {
-                User = new User { Username = "osu!" },
+                User = new APIUser { Username = "osu!" },
                BeatmapInfo = new TestBeatmap(Ruleset.Value).BeatmapInfo,
                Ruleset = Ruleset.Value,
            })));
@@ -0,0 +1,229 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Drawables.Cards;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Overlays;
+using osuTK;
+using APIUser = osu.Game.Online.API.Requests.Responses.APIUser;
+
+namespace osu.Game.Tests.Visual.Beatmaps
+{
+    public class TestSceneBeatmapCard : OsuTestScene
+    {
+        private DummyAPIAccess dummyAPI => (DummyAPIAccess)API;
+
+        private APIBeatmapSet[] testCases;
+
+        #region Test case generation
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            var normal = CreateAPIBeatmapSet(Ruleset.Value);
+            normal.HasVideo = true;
+            normal.HasStoryboard = true;
+
+            var withStatistics = CreateAPIBeatmapSet(Ruleset.Value);
+            withStatistics.Title = withStatistics.TitleUnicode = "play favourite stats";
+            withStatistics.Status = BeatmapSetOnlineStatus.Approved;
+            withStatistics.FavouriteCount = 284_239;
+            withStatistics.PlayCount = 999_001;
+            withStatistics.Ranked = DateTimeOffset.Now.AddDays(-45);
+            withStatistics.HypeStatus = new BeatmapSetHypeStatus
+            {
+                Current = 34,
+                Required = 5
+            };
+            withStatistics.NominationStatus = new BeatmapSetNominationStatus
+            {
+                Current = 1,
+                Required = 2
+            };
+
+            var undownloadable = getUndownloadableBeatmapSet();
+            undownloadable.LastUpdated = DateTimeOffset.Now.AddYears(-1);
+
+            var someDifficulties = getManyDifficultiesBeatmapSet(11);
+            someDifficulties.Title = someDifficulties.TitleUnicode = "favourited";
+            someDifficulties.Title = someDifficulties.TitleUnicode = "some difficulties";
+            someDifficulties.Status = BeatmapSetOnlineStatus.Qualified;
+            someDifficulties.HasFavourited = true;
+            someDifficulties.FavouriteCount = 1;
+            someDifficulties.NominationStatus = new BeatmapSetNominationStatus
+            {
+                Current = 2,
+                Required = 2
+            };
+
+            var manyDifficulties = getManyDifficultiesBeatmapSet(100);
+            manyDifficulties.Status = BeatmapSetOnlineStatus.Pending;
+
+            var explicitMap = CreateAPIBeatmapSet(Ruleset.Value);
+            explicitMap.Title = someDifficulties.TitleUnicode = "explicit beatmap";
+            explicitMap.HasExplicitContent = true;
+
+            var featuredMap = CreateAPIBeatmapSet(Ruleset.Value);
+            featuredMap.Title = someDifficulties.TitleUnicode = "featured artist beatmap";
+            featuredMap.TrackId = 1;
+
+            var explicitFeaturedMap = CreateAPIBeatmapSet(Ruleset.Value);
+            explicitFeaturedMap.Title = someDifficulties.TitleUnicode = "explicit featured artist";
+            explicitFeaturedMap.HasExplicitContent = true;
+            explicitFeaturedMap.TrackId = 2;
+
+            var longName = CreateAPIBeatmapSet(Ruleset.Value);
+            longName.Title = longName.TitleUnicode = "this track has an incredibly and implausibly long title";
+            longName.Artist = longName.ArtistUnicode = "and this artist! who would have thunk it. it's really such a long name.";
+            longName.HasExplicitContent = true;
+            longName.TrackId = 444;
+
+            testCases = new[]
+            {
+                normal,
+                withStatistics,
+                undownloadable,
+                someDifficulties,
+                manyDifficulties,
+                explicitMap,
+                featuredMap,
+                explicitFeaturedMap,
+                longName
+            };
+        }
+
+        private APIBeatmapSet getUndownloadableBeatmapSet() => new APIBeatmapSet
+        {
+            OnlineID = 123,
+            Title = "undownloadable beatmap",
+            Artist = "test",
+            Source = "more tests",
+            Author = new APIUser
+            {
+                Username = "BanchoBot",
+                Id = 3,
+            },
+            Availability = new BeatmapSetOnlineAvailability
+            {
+                DownloadDisabled = true,
+            },
+            Preview = @"https://b.ppy.sh/preview/12345.mp3",
+            PlayCount = 123,
+            FavouriteCount = 456,
+            BPM = 111,
+            HasVideo = true,
+            HasStoryboard = true,
+            Covers = new BeatmapSetOnlineCovers(),
+            Beatmaps = new[]
+            {
+                new APIBeatmap
+                {
+                    RulesetID = Ruleset.Value.OnlineID,
+                    DifficultyName = "Test",
+                    StarRating = 6.42,
+                }
+            }
+        };
+
+        private static APIBeatmapSet getManyDifficultiesBeatmapSet(int count)
+        {
+            var beatmaps = new List<APIBeatmap>();
+
+            for (int i = 0; i < count; i++)
+            {
+                beatmaps.Add(new APIBeatmap
+                {
+                    RulesetID = i % 4,
+                    StarRating = 2 + i % 4 * 2,
+                });
+            }
+
+            return new APIBeatmapSet
+            {
+                OnlineID = 1,
+                Title = "many difficulties beatmap",
+                Artist = "test",
+                Author = new APIUser
+                {
+                    Username = "BanchoBot",
+                    Id = 3,
+                },
+                HasVideo = true,
+                HasStoryboard = true,
+                Covers = new BeatmapSetOnlineCovers(),
+                Beatmaps = beatmaps.ToArray(),
+            };
+        }
+
+        #endregion
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("register request handling", () => dummyAPI.HandleRequest = request =>
+            {
+                if (!(request is PostBeatmapFavouriteRequest))
+                    return false;
+
+                request.TriggerSuccess();
+                return true;
+            });
+        }
+
+        private Drawable createContent(OverlayColourScheme colourScheme, Func<APIBeatmapSet, Drawable> creationFunc)
+        {
+            var colourProvider = new OverlayColourProvider(colourScheme);
+
+            return new DependencyProvidingContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                CachedDependencies = new (Type, object)[]
+                {
+                    (typeof(OverlayColourProvider), colourProvider)
+                },
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = colourProvider.Background5
+                    },
+                    new BasicScrollContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Child = new FillFlowContainer
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            Direction = FillDirection.Full,
+                            Padding = new MarginPadding(10),
+                            Spacing = new Vector2(10),
+                            ChildrenEnumerable = testCases.Select(creationFunc)
+                        }
+                    }
+                }
+            };
+        }
+
+        private void createTestCase(Func<APIBeatmapSet, Drawable> creationFunc)
+        {
+            foreach (var scheme in Enum.GetValues(typeof(OverlayColourScheme)).Cast<OverlayColourScheme>())
+                AddStep($"set {scheme} scheme", () => Child = createContent(scheme, creationFunc));
+        }
+
+        [Test]
+        public void TestNormal() => createTestCase(beatmapSetInfo => new BeatmapCard(beatmapSetInfo));
+    }
+}
@@ -0,0 +1,86 @@
+// 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.Allocation;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps.Drawables.Cards.Buttons;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Overlays;
+using osu.Game.Resources.Localisation.Web;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Beatmaps
+{
+    public class TestSceneBeatmapCardFavouriteButton : OsuManualInputManagerTestScene
+    {
+        private DummyAPIAccess dummyAPI => (DummyAPIAccess)API;
+
+        [Cached]
+        private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
+
+        [Test]
+        public void TestInitialState([Values] bool favourited)
+        {
+            APIBeatmapSet beatmapSetInfo = null;
+            FavouriteButton button = null;
+
+            AddStep("create beatmap set", () =>
+            {
+                beatmapSetInfo = CreateAPIBeatmapSet(Ruleset.Value);
+                beatmapSetInfo.HasFavourited = favourited;
+            });
+            AddStep("create button", () => Child = button = new FavouriteButton(beatmapSetInfo) { Scale = new Vector2(2) });
+
+            assertCorrectIcon(favourited);
+            AddAssert("correct tooltip text", () => button.TooltipText == (favourited ? BeatmapsetsStrings.ShowDetailsUnfavourite : BeatmapsetsStrings.ShowDetailsFavourite));
+        }
+
+        [Test]
+        public void TestRequestHandling()
+        {
+            APIBeatmapSet beatmapSetInfo = null;
+            FavouriteButton button = null;
+            BeatmapFavouriteAction? lastRequestAction = null;
+
+            AddStep("create beatmap set", () => beatmapSetInfo = CreateAPIBeatmapSet(Ruleset.Value));
+            AddStep("create button", () => Child = button = new FavouriteButton(beatmapSetInfo) { Scale = new Vector2(2) });
+
+            assertCorrectIcon(false);
+
+            AddStep("register request handling", () => dummyAPI.HandleRequest = request =>
+            {
+                if (!(request is PostBeatmapFavouriteRequest favouriteRequest))
+                    return false;
+
+                lastRequestAction = favouriteRequest.Action;
+                request.TriggerSuccess();
+                return true;
+            });
+
+            AddStep("click icon", () =>
+            {
+                InputManager.MoveMouseTo(button);
+                InputManager.Click(MouseButton.Left);
+            });
+            AddUntilStep("favourite request sent", () => lastRequestAction == BeatmapFavouriteAction.Favourite);
+            assertCorrectIcon(true);
+
+            AddStep("click icon", () =>
+            {
+                InputManager.MoveMouseTo(button);
+                InputManager.Click(MouseButton.Left);
+            });
+            AddUntilStep("unfavourite request sent", () => lastRequestAction == BeatmapFavouriteAction.UnFavourite);
+            assertCorrectIcon(false);
+        }
+
+        private void assertCorrectIcon(bool favourited) => AddAssert("icon correct",
+            () => this.ChildrenOfType<SpriteIcon>().Single().Icon.Equals(favourited ? FontAwesome.Solid.Heart : FontAwesome.Regular.Heart));
+    }
+}
@@ -21,7 +21,7 @@ namespace osu.Game.Tests.Visual.Beatmaps
            {
                RulesetID = difficulty.rulesetId,
                StarRating = difficulty.stars
-            }).ToList()
+            }).ToArray()
        };

        [Test]
@@ -5,7 +5,10 @@ using System;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.UserInterface;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu;
@@ -29,6 +32,9 @@ namespace osu.Game.Tests.Visual.Editing
        private ComposeBlueprintContainer blueprintContainer
            => Editor.ChildrenOfType<ComposeBlueprintContainer>().First();

+        private ContextMenuContainer contextMenuContainer
+            => Editor.ChildrenOfType<ContextMenuContainer>().First();
+
        private void moveMouseToObject(Func<HitObject> targetFunc)
        {
            AddStep("move mouse to object", () =>
@@ -42,6 +48,19 @@ namespace osu.Game.Tests.Visual.Editing
            });
        }

+        [Test]
+        public void TestSelectAndShowContextMenu()
+        {
+            var addedObject = new HitCircle { StartTime = 100, Position = new Vector2(100, 100) };
+            AddStep("add hitobject", () => EditorBeatmap.Add(addedObject));
+
+            moveMouseToObject(() => addedObject);
+            AddStep("right click", () => InputManager.Click(MouseButton.Right));
+
+            AddUntilStep("hitobject selected", () => EditorBeatmap.SelectedHitObjects.Single() == addedObject);
+            AddUntilStep("context menu is visible", () => contextMenuContainer.ChildrenOfType<OsuContextMenu>().Single().State == MenuState.Open);
+        }
+
        [Test]
        public void TestNudgeSelection()
        {
@@ -23,10 +23,10 @@ namespace osu.Game.Tests.Visual.Editing
            AddStep("set metadata", () =>
            {
                editorBeatmap.Metadata.Artist = "Example Artist";
-                editorBeatmap.Metadata.ArtistUnicode = null;
+                editorBeatmap.Metadata.ArtistUnicode = string.Empty;

                editorBeatmap.Metadata.Title = "Example Title";
-                editorBeatmap.Metadata.TitleUnicode = null;
+                editorBeatmap.Metadata.TitleUnicode = string.Empty;
            });

            createSection();
@@ -44,10 +44,10 @@ namespace osu.Game.Tests.Visual.Editing
            AddStep("set metadata", () =>
            {
                editorBeatmap.Metadata.ArtistUnicode = "＊なみりん";
-                editorBeatmap.Metadata.Artist = null;
+                editorBeatmap.Metadata.Artist = string.Empty;

                editorBeatmap.Metadata.TitleUnicode = "コイシテイク・プラネット";
-                editorBeatmap.Metadata.Title = null;
+                editorBeatmap.Metadata.Title = string.Empty;
            });

            createSection();
@@ -86,10 +86,10 @@ namespace osu.Game.Tests.Visual.Editing
            AddStep("set metadata", () =>
            {
                editorBeatmap.Metadata.ArtistUnicode = "＊なみりん";
-                editorBeatmap.Metadata.Artist = null;
+                editorBeatmap.Metadata.Artist = string.Empty;

                editorBeatmap.Metadata.TitleUnicode = "コイシテイク・プラネット";
-                editorBeatmap.Metadata.Title = null;
+                editorBeatmap.Metadata.Title = string.Empty;
            });

            createSection();
@@ -7,8 +7,8 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Screens.Play.HUD;
-using osu.Game.Users;
 using osuTK;

 namespace osu.Game.Tests.Visual.Gameplay
@@ -39,7 +39,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                playerScore.Value = 1222333;
            });

-            AddStep("add local player", () => createLeaderboardScore(playerScore, new User { Username = "You", Id = 3 }, true));
+            AddStep("add local player", () => createLeaderboardScore(playerScore, new APIUser { Username = "You", Id = 3 }, true));
            AddStep("toggle expanded", () => leaderboard.Expanded.Value = !leaderboard.Expanded.Value);
            AddSliderStep("set player score", 50, 5000000, 1222333, v => playerScore.Value = v);
        }
@@ -50,8 +50,8 @@ namespace osu.Game.Tests.Visual.Gameplay
            var player2Score = new BindableDouble(1234567);
            var player3Score = new BindableDouble(1111111);

-            AddStep("add player 2", () => createLeaderboardScore(player2Score, new User { Username = "Player 2" }));
-            AddStep("add player 3", () => createLeaderboardScore(player3Score, new User { Username = "Player 3" }));
+            AddStep("add player 2", () => createLeaderboardScore(player2Score, new APIUser { Username = "Player 2" }));
+            AddStep("add player 3", () => createLeaderboardScore(player3Score, new APIUser { Username = "Player 3" }));

            AddUntilStep("is player 2 position #1", () => leaderboard.CheckPositionByUsername("Player 2", 1));
            AddUntilStep("is player position #2", () => leaderboard.CheckPositionByUsername("You", 2));
@@ -72,38 +72,38 @@ namespace osu.Game.Tests.Visual.Gameplay
        public void TestRandomScores()
        {
            int playerNumber = 1;
-            AddRepeatStep("add player with random score", () => createRandomScore(new User { Username = $"Player {playerNumber++}" }), 10);
+            AddRepeatStep("add player with random score", () => createRandomScore(new APIUser { Username = $"Player {playerNumber++}" }), 10);
        }

        [Test]
        public void TestExistingUsers()
        {
-            AddStep("add peppy", () => createRandomScore(new User { Username = "peppy", Id = 2 }));
-            AddStep("add smoogipoo", () => createRandomScore(new User { Username = "smoogipoo", Id = 1040328 }));
-            AddStep("add flyte", () => createRandomScore(new User { Username = "flyte", Id = 3103765 }));
-            AddStep("add frenzibyte", () => createRandomScore(new User { Username = "frenzibyte", Id = 14210502 }));
+            AddStep("add peppy", () => createRandomScore(new APIUser { Username = "peppy", Id = 2 }));
+            AddStep("add smoogipoo", () => createRandomScore(new APIUser { Username = "smoogipoo", Id = 1040328 }));
+            AddStep("add flyte", () => createRandomScore(new APIUser { Username = "flyte", Id = 3103765 }));
+            AddStep("add frenzibyte", () => createRandomScore(new APIUser { Username = "frenzibyte", Id = 14210502 }));
        }

        [Test]
        public void TestMaxHeight()
        {
            int playerNumber = 1;
-            AddRepeatStep("add 3 other players", () => createRandomScore(new User { Username = $"Player {playerNumber++}" }), 3);
+            AddRepeatStep("add 3 other players", () => createRandomScore(new APIUser { Username = $"Player {playerNumber++}" }), 3);
            checkHeight(4);

-            AddRepeatStep("add 4 other players", () => createRandomScore(new User { Username = $"Player {playerNumber++}" }), 4);
+            AddRepeatStep("add 4 other players", () => createRandomScore(new APIUser { Username = $"Player {playerNumber++}" }), 4);
            checkHeight(8);

-            AddRepeatStep("add 4 other players", () => createRandomScore(new User { Username = $"Player {playerNumber++}" }), 4);
+            AddRepeatStep("add 4 other players", () => createRandomScore(new APIUser { Username = $"Player {playerNumber++}" }), 4);
            checkHeight(8);

            void checkHeight(int panelCount)
                => AddAssert($"leaderboard height is {panelCount} panels high", () => leaderboard.DrawHeight == (GameplayLeaderboardScore.PANEL_HEIGHT + leaderboard.Spacing) * panelCount);
        }

-        private void createRandomScore(User user) => createLeaderboardScore(new BindableDouble(RNG.Next(0, 5_000_000)), user);
+        private void createRandomScore(APIUser user) => createLeaderboardScore(new BindableDouble(RNG.Next(0, 5_000_000)), user);

-        private void createLeaderboardScore(BindableDouble score, User user, bool isTracked = false)
+        private void createLeaderboardScore(BindableDouble score, APIUser user, bool isTracked = false)
        {
            var leaderboardScore = leaderboard.Add(user, isTracked);
            leaderboardScore.TotalScore.BindTo(score);
@@ -235,8 +235,17 @@ namespace osu.Game.Tests.Visual.Gameplay

            public override IEnumerable<HitObject> Objects => new[] { new HitCircle { HitWindows = HitWindows } };

-            public override event Action<JudgementResult> NewResult;
-            public override event Action<JudgementResult> RevertResult;
+            public override event Action<JudgementResult> NewResult
+            {
+                add => throw new InvalidOperationException();
+                remove => throw new InvalidOperationException();
+            }
+
+            public override event Action<JudgementResult> RevertResult
+            {
+                add => throw new InvalidOperationException();
+                remove => throw new InvalidOperationException();
+            }

            public override Playfield Playfield { get; }
            public override Container Overlays { get; }
@@ -251,9 +260,6 @@ namespace osu.Game.Tests.Visual.Gameplay
            public TestDrawableRuleset()
                : base(new OsuRuleset())
            {
-                // won't compile without this.
-                NewResult?.Invoke(null);
-                RevertResult?.Invoke(null);
            }

            public override void SetReplayScore(Score replayScore) => throw new NotImplementedException();
@@ -7,14 +7,16 @@ using osu.Framework.Graphics;
 using osu.Game.Online;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Scoring;
-using osu.Game.Users;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Testing;
+using osu.Game.Database;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.Ranking;
 using osuTK.Input;
+using APIUser = osu.Game.Online.API.Requests.Responses.APIUser;

 namespace osu.Game.Tests.Visual.Gameplay
 {
@@ -112,6 +114,36 @@ namespace osu.Game.Tests.Visual.Gameplay
            AddAssert("button is not enabled", () => !downloadButton.ChildrenOfType<DownloadButton>().First().Enabled.Value);
        }

+        [Resolved]
+        private ScoreManager scoreManager { get; set; }
+
+        [Test]
+        public void TestScoreImportThenDelete()
+        {
+            ILive<ScoreInfo> imported = null;
+
+            AddStep("create button without replay", () =>
+            {
+                Child = downloadButton = new TestReplayDownloadButton(getScoreInfo(false))
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                };
+            });
+
+            AddUntilStep("wait for load", () => downloadButton.IsLoaded);
+
+            AddUntilStep("state is not downloaded", () => downloadButton.State.Value == DownloadState.NotDownloaded);
+
+            AddStep("import score", () => imported = scoreManager.Import(getScoreInfo(true)).Result);
+
+            AddUntilStep("state is available", () => downloadButton.State.Value == DownloadState.LocallyAvailable);
+
+            AddStep("delete score", () => scoreManager.Delete(imported.Value));
+
+            AddUntilStep("state is not downloaded", () => downloadButton.State.Value == DownloadState.NotDownloaded);
+        }
+
        [Test]
        public void CreateButtonWithNoScore()
        {
@@ -132,12 +164,13 @@ namespace osu.Game.Tests.Visual.Gameplay

        private ScoreInfo getScoreInfo(bool replayAvailable)
        {
-            return new APILegacyScoreInfo
+            return new APIScoreInfo
            {
-                OnlineScoreID = 2553163309,
-                OnlineRulesetID = 0,
-                Replay = replayAvailable,
-                User = new User
+                OnlineID = 2553163309,
+                RulesetID = 0,
+                Beatmap = CreateAPIBeatmapSet(new OsuRuleset().RulesetInfo).Beatmaps.First(),
+                HasReplay = replayAvailable,
+                User = new APIUser
                {
                    Id = 39828,
                    Username = @"WubWoofWolf",
@@ -54,7 +54,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                                ScoreInfo = { BeatmapInfo = gameplayState.Beatmap.BeatmapInfo }
                            })
                            {
-                                ScreenSpaceToGamefield = pos => recordingManager.ToLocalSpace(pos)
+                                ScreenSpaceToGamefield = pos => recordingManager?.ToLocalSpace(pos) ?? Vector2.Zero,
                            },
                            Child = new Container
                            {
@@ -84,7 +84,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                        {
                            ReplayInputHandler = new TestFramedReplayInputHandler(replay)
                            {
-                                GamefieldToScreenSpace = pos => playbackManager.ToScreenSpace(pos),
+                                GamefieldToScreenSpace = pos => playbackManager?.ToScreenSpace(pos) ?? Vector2.Zero,
                            },
                            Child = new Container
                            {
@@ -9,6 +9,7 @@ using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Spectator;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Replays;
@@ -18,13 +19,12 @@ using osu.Game.Screens.Play;
 using osu.Game.Tests.Beatmaps.IO;
 using osu.Game.Tests.Visual.Multiplayer;
 using osu.Game.Tests.Visual.Spectator;
-using osu.Game.Users;

 namespace osu.Game.Tests.Visual.Gameplay
 {
    public class TestSceneSpectator : ScreenTestScene
    {
-        private readonly User streamingUser = new User { Id = MultiplayerTestScene.PLAYER_1_ID, Username = "Test user" };
+        private readonly APIUser streamingUser = new APIUser { Id = MultiplayerTestScene.PLAYER_1_ID, Username = "Test user" };

        [Cached(typeof(UserLookupCache))]
        private UserLookupCache lookupCache = new TestUserLookupCache();
@@ -4,11 +4,11 @@
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Spectator;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mania;
 using osu.Game.Tests.Visual.Spectator;
-using osu.Game.Users;

 namespace osu.Game.Tests.Visual.Gameplay
 {
@@ -24,7 +24,7 @@ namespace osu.Game.Tests.Visual.Gameplay

        public override void SetUpSteps()
        {
-            AddStep("set dummy user", () => dummyAPIAccess.LocalUser.Value = new User
+            AddStep("set dummy user", () => dummyAPIAccess.LocalUser.Value = new APIUser
            {
                Id = dummy_user_id,
                Username = "DummyUser"
@@ -3,8 +3,8 @@

 using osu.Framework.Allocation;
 using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Screens.Menu;
-using osu.Game.Users;

 namespace osu.Game.Tests.Visual.Menus
 {
@@ -17,7 +17,7 @@ namespace osu.Game.Tests.Visual.Menus

            AddStep("toggle support", () =>
            {
-                ((DummyAPIAccess)API).LocalUser.Value = new User
+                ((DummyAPIAccess)API).LocalUser.Value = new APIUser
                {
                    Username = API.LocalUser.Value.Username,
                    Id = API.LocalUser.Value.Id + 1,
@@ -10,6 +10,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Rooms;
 using osu.Game.Online.Rooms.RoomStatuses;
 using osu.Game.Overlays;
@@ -17,7 +18,6 @@ using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.OnlinePlay.Lounge;
 using osu.Game.Screens.OnlinePlay.Lounge.Components;
 using osu.Game.Tests.Beatmaps;
-using osu.Game.Users;
 using osuTK;

 namespace osu.Game.Tests.Visual.Multiplayer
@@ -67,6 +67,36 @@ namespace osu.Game.Tests.Visual.Multiplayer
                            }
                        }),
                        createLoungeRoom(new Room
+                        {
+                            Name = { Value = "Multiplayer room" },
+                            Status = { Value = new RoomStatusOpen() },
+                            EndDate = { Value = DateTimeOffset.Now.AddDays(1) },
+                            Type = { Value = MatchType.HeadToHead },
+                            Playlist =
+                            {
+                                new PlaylistItem
+                                {
+                                    Beatmap =
+                                    {
+                                        Value = new TestBeatmap(new OsuRuleset().RulesetInfo)
+                                        {
+                                            BeatmapInfo =
+                                            {
+                                                StarDifficulty = 2.5,
+                                                Metadata =
+                                                {
+                                                    Artist = "very very very very very very very very very long artist",
+                                                    ArtistUnicode = "very very very very very very very very very long artist",
+                                                    Title = "very very very very very very very very very very very long title",
+                                                    TitleUnicode = "very very very very very very very very very very very long title",
+                                                }
+                                            }
+                                        }.BeatmapInfo,
+                                    }
+                                }
+                            }
+                        }),
+                        createLoungeRoom(new Room
                        {
                            Name = { Value = "Playlist room with multiple beatmaps" },
                            Status = { Value = new RoomStatusPlaying() },
@@ -144,11 +174,11 @@ namespace osu.Game.Tests.Visual.Multiplayer

        private DrawableRoom createLoungeRoom(Room room)
        {
-            room.Host.Value ??= new User { Username = "peppy", Id = 2 };
+            room.Host.Value ??= new APIUser { Username = "peppy", Id = 2 };

            if (room.RecentParticipants.Count == 0)
            {
-                room.RecentParticipants.AddRange(Enumerable.Range(0, 20).Select(i => new User
+                room.RecentParticipants.AddRange(Enumerable.Range(0, 20).Select(i => new APIUser
                {
                    Id = i,
                    Username = $"User {i}"
@@ -5,10 +5,10 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Testing;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Rooms;
 using osu.Game.Screens.OnlinePlay.Lounge.Components;
 using osu.Game.Tests.Visual.OnlinePlay;
-using osu.Game.Users;
 using osu.Game.Users.Drawables;

 namespace osu.Game.Tests.Visual.Multiplayer
@@ -25,7 +25,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                Name = { Value = "test room" },
                Host =
                {
-                    Value = new User
+                    Value = new APIUser
                    {
                        Id = 2,
                        Username = "peppy",
@@ -137,7 +137,7 @@ namespace osu.Game.Tests.Visual.Multiplayer

        private void addUser(int id)
        {
-            SelectedRoom.Value.RecentParticipants.Add(new User
+            SelectedRoom.Value.RecentParticipants.Add(new APIUser
            {
                Id = id,
                Username = $"User {id}"
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.

 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
@@ -13,6 +14,7 @@ using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Drawables;
 using osu.Game.Graphics.Containers;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays.BeatmapListing.Panels;
 using osu.Game.Rulesets;
@@ -20,7 +22,6 @@ using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.OnlinePlay;
 using osu.Game.Tests.Beatmaps;
-using osu.Game.Users;
 using osuTK;
 using osuTK.Input;

@@ -38,8 +39,6 @@ namespace osu.Game.Tests.Visual.Multiplayer
        {
            Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, Resources, host, Beatmap.Default));
-
-            manager.Import(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo.BeatmapSet).Wait();
        }

        [Test]
@@ -204,7 +203,11 @@ namespace osu.Game.Tests.Visual.Multiplayer
        [Test]
        public void TestDownloadButtonHiddenWhenBeatmapExists()
        {
-            createPlaylist(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo);
+            var beatmap = new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo;
+
+            AddStep("import beatmap", () => manager.Import(beatmap.BeatmapSet).Wait());
+
+            createPlaylist(beatmap);

            assertDownloadButtonVisible(false);

@@ -221,11 +224,11 @@ namespace osu.Game.Tests.Visual.Multiplayer
        [Test]
        public void TestDownloadButtonVisibleInitiallyWhenBeatmapDoesNotExist()
        {
-            var byOnlineId = new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo;
-            byOnlineId.BeatmapSet.OnlineBeatmapSetID = 1337; // Some random ID that does not exist locally.
+            var byOnlineId = CreateAPIBeatmap();
+            byOnlineId.OnlineID = 1337; // Some random ID that does not exist locally.

-            var byChecksum = new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo;
-            byChecksum.MD5Hash = "1337"; // Some random checksum that does not exist locally.
+            var byChecksum = CreateAPIBeatmap();
+            byChecksum.Checksum = "1337"; // Some random checksum that does not exist locally.

            createPlaylist(byOnlineId, byChecksum);

@@ -235,8 +238,11 @@ namespace osu.Game.Tests.Visual.Multiplayer
        [Test]
        public void TestExplicitBeatmapItem()
        {
-            var beatmap = new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo;
-            beatmap.BeatmapSet.OnlineInfo.HasExplicitContent = true;
+            var beatmap = CreateAPIBeatmap();
+
+            Debug.Assert(beatmap.BeatmapSet != null);
+
+            beatmap.BeatmapSet.HasExplicitContent = true;

            createPlaylist(beatmap);
        }
@@ -288,7 +294,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                                    Metadata = new BeatmapMetadata
                                    {
                                        Artist = "Artist",
-                                        Author = new User { Username = "Creator name here" },
+                                        Author = new APIUser { Username = "Creator name here" },
                                        Title = "Long title used to check background colour",
                                    },
                                    BeatmapSet = new BeatmapSetInfo()
@@ -308,7 +314,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
            AddUntilStep("wait for items to load", () => playlist.ItemMap.Values.All(i => i.IsLoaded));
        }

-        private void createPlaylist(params BeatmapInfo[] beatmaps)
+        private void createPlaylist(params IBeatmapInfo[] beatmaps)
        {
            AddStep("create playlist", () =>
            {
@@ -19,7 +19,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 {
    public class TestSceneLoungeRoomsContainer : OnlinePlayTestScene
    {
-        protected new TestRequestHandlingRoomManager RoomManager => (TestRequestHandlingRoomManager)base.RoomManager;
+        protected new TestRoomManager RoomManager => (TestRoomManager)base.RoomManager;

        private RoomsContainer container;

@@ -10,8 +10,8 @@ using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Rooms;
 using osu.Game.Screens.OnlinePlay.Match.Components;
 using osu.Game.Tests.Visual.OnlinePlay;
-using osu.Game.Users;
 using osuTK;
+using APIUser = osu.Game.Online.API.Requests.Responses.APIUser;

 namespace osu.Game.Tests.Visual.Multiplayer
 {
@@ -32,7 +32,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                                new APIUserScoreAggregate
                                {
                                    UserID = 2,
-                                    User = new User { Id = 2, Username = "peppy" },
+                                    User = new APIUser { Id = 2, Username = "peppy" },
                                    TotalScore = 995533,
                                    RoomID = 3,
                                    CompletedBeatmaps = 1,
@@ -42,7 +42,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                                new APIUserScoreAggregate
                                {
                                    UserID = 1040328,
-                                    User = new User { Id = 1040328, Username = "smoogipoo" },
+                                    User = new APIUser { Id = 1040328, Username = "smoogipoo" },
                                    TotalScore = 981100,
                                    RoomID = 3,
                                    CompletedBeatmaps = 1,
@@ -6,11 +6,11 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
 using osu.Framework.Timing;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Spectate;
 using osu.Game.Screens.Play.HUD;
-using osu.Game.Users;

 namespace osu.Game.Tests.Visual.Multiplayer
 {
@@ -35,7 +35,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                foreach ((int userId, var _) in clocks)
                {
                    SpectatorClient.StartPlay(userId, 0);
-                    OnlinePlayDependencies.Client.AddUser(new User { Id = userId });
+                    OnlinePlayDependencies.Client.AddUser(new APIUser { Id = userId });
                }
            });

@@ -11,6 +11,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
 using osu.Game.Rulesets.UI;
@@ -19,7 +20,6 @@ using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.HUD;
 using osu.Game.Screens.Play.PlayerSettings;
 using osu.Game.Tests.Beatmaps.IO;
-using osu.Game.Users;
 using osuTK.Graphics;

 namespace osu.Game.Tests.Visual.Multiplayer
@@ -59,8 +59,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
        {
            AddStep("start players silently", () =>
            {
-                OnlinePlayDependencies.Client.AddUser(new User { Id = PLAYER_1_ID }, true);
-                OnlinePlayDependencies.Client.AddUser(new User { Id = PLAYER_2_ID }, true);
+                OnlinePlayDependencies.Client.AddUser(new APIUser { Id = PLAYER_1_ID }, true);
+                OnlinePlayDependencies.Client.AddUser(new APIUser { Id = PLAYER_2_ID }, true);

                playingUsers.Add(new MultiplayerRoomUser(PLAYER_1_ID));
                playingUsers.Add(new MultiplayerRoomUser(PLAYER_2_ID));
@@ -120,13 +120,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
        {
            AddStep("start players", () =>
            {
-                var player1 = OnlinePlayDependencies.Client.AddUser(new User { Id = PLAYER_1_ID }, true);
+                var player1 = OnlinePlayDependencies.Client.AddUser(new APIUser { Id = PLAYER_1_ID }, true);
                player1.MatchState = new TeamVersusUserState
                {
                    TeamID = 0,
                };

-                var player2 = OnlinePlayDependencies.Client.AddUser(new User { Id = PLAYER_2_ID }, true);
+                var player2 = OnlinePlayDependencies.Client.AddUser(new APIUser { Id = PLAYER_2_ID }, true);
                player2.MatchState = new TeamVersusUserState
                {
                    TeamID = 1,
@@ -367,7 +367,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                {
                    var user = new MultiplayerRoomUser(id)
                    {
-                        User = new User { Id = id },
+                        User = new APIUser { Id = id },
                    };

                    OnlinePlayDependencies.Client.AddUser(user.User, true);
@@ -17,14 +17,13 @@ using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays.Mods;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Screens;
-using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.OnlinePlay.Lounge;
 using osu.Game.Screens.OnlinePlay.Lounge.Components;
 using osu.Game.Screens.OnlinePlay.Match;
@@ -32,8 +31,8 @@ using osu.Game.Screens.OnlinePlay.Multiplayer;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Match;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Ranking;
+using osu.Game.Screens.Spectate;
 using osu.Game.Tests.Resources;
-using osu.Game.Users;
 using osuTK.Input;

 namespace osu.Game.Tests.Visual.Multiplayer
@@ -44,11 +43,10 @@ namespace osu.Game.Tests.Visual.Multiplayer
        private RulesetStore rulesets;
        private BeatmapSetInfo importedSet;

-        private DependenciesScreen dependenciesScreen;
-        private TestMultiplayer multiplayerScreen;
-        private TestMultiplayerClient client;
+        private TestMultiplayerScreenStack multiplayerScreenStack;

-        private TestRequestHandlingMultiplayerRoomManager roomManager => multiplayerScreen.RoomManager;
+        private TestMultiplayerClient client => multiplayerScreenStack.Client;
+        private TestMultiplayerRoomManager roomManager => multiplayerScreenStack.RoomManager;

        [Cached(typeof(UserLookupCache))]
        private UserLookupCache lookupCache = new TestUserLookupCache();
@@ -70,22 +68,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
                importedSet = beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.All).First();
            });

-            AddStep("create multiplayer screen", () => multiplayerScreen = new TestMultiplayer());
-
-            AddStep("load dependencies", () =>
-            {
-                client = new TestMultiplayerClient(roomManager);
-
-                // The screen gets suspended so it stops receiving updates.
-                Child = client;
-
-                LoadScreen(dependenciesScreen = new DependenciesScreen(client));
-            });
-
-            AddUntilStep("wait for dependencies to load", () => dependenciesScreen.IsLoaded);
-
-            AddStep("load multiplayer", () => LoadScreen(multiplayerScreen));
-            AddUntilStep("wait for multiplayer to load", () => multiplayerScreen.IsLoaded);
+            AddStep("load multiplayer", () => LoadScreen(multiplayerScreenStack = new TestMultiplayerScreenStack()));
+            AddUntilStep("wait for multiplayer to load", () => multiplayerScreenStack.IsLoaded);
            AddUntilStep("wait for lounge to load", () => this.ChildrenOfType<MultiplayerLoungeSubScreen>().FirstOrDefault()?.IsLoaded == true);
        }

@@ -145,12 +129,12 @@ namespace osu.Game.Tests.Visual.Multiplayer
        private void addRandomPlayer()
        {
            int randomUser = RNG.Next(200000, 500000);
-            client.AddUser(new User { Id = randomUser, Username = $"user {randomUser}" });
+            client.AddUser(new APIUser { Id = randomUser, Username = $"user {randomUser}" });
        }

        private void removeLastUser()
        {
-            User lastUser = client.Room?.Users.Last().User;
+            APIUser lastUser = client.Room?.Users.Last().User;

            if (lastUser == null || lastUser == client.LocalUser?.User)
                return;
@@ -160,7 +144,7 @@ namespace osu.Game.Tests.Visual.Multiplayer

        private void kickLastUser()
        {
-            User lastUser = client.Room?.Users.Last().User;
+            APIUser lastUser = client.Room?.Users.Last().User;

            if (lastUser == null || lastUser == client.LocalUser?.User)
                return;
@@ -247,6 +231,9 @@ namespace osu.Game.Tests.Visual.Multiplayer
                    }
                }
            });
+
+            AddAssert("Check participant count correct", () => client.APIRoom?.ParticipantCount.Value == 1);
+            AddAssert("Check participant list contains user", () => client.APIRoom?.RecentParticipants.Count(u => u.Id == API.LocalUser.Value.Id) == 1);
        }

        [Test]
@@ -306,6 +293,9 @@ namespace osu.Game.Tests.Visual.Multiplayer

            AddUntilStep("wait for room open", () => this.ChildrenOfType<MultiplayerMatchSubScreen>().FirstOrDefault()?.IsLoaded == true);
            AddUntilStep("wait for join", () => client.Room != null);
+
+            AddAssert("Check participant count correct", () => client.APIRoom?.ParticipantCount.Value == 1);
+            AddAssert("Check participant list contains user", () => client.APIRoom?.RecentParticipants.Count(u => u.Id == API.LocalUser.Value.Id) == 1);
        }

        [Test]
@@ -424,7 +414,7 @@ namespace osu.Game.Tests.Visual.Multiplayer

            AddStep("join other user (ready, host)", () =>
            {
-                client.AddUser(new User { Id = MultiplayerTestScene.PLAYER_1_ID, Username = "Other" });
+                client.AddUser(new APIUser { Id = MultiplayerTestScene.PLAYER_1_ID, Username = "Other" });
                client.TransferHost(MultiplayerTestScene.PLAYER_1_ID);
                client.ChangeUserState(MultiplayerTestScene.PLAYER_1_ID, MultiplayerUserState.Ready);
            });
@@ -441,7 +431,7 @@ namespace osu.Game.Tests.Visual.Multiplayer

            AddStep("start match externally", () => client.StartMatch());

-            AddAssert("play not started", () => multiplayerScreen.IsCurrentScreen());
+            AddAssert("play not started", () => multiplayerScreenStack.IsCurrentScreen());
        }

        [Test]
@@ -464,7 +454,7 @@ namespace osu.Game.Tests.Visual.Multiplayer

            AddStep("join other user (ready, host)", () =>
            {
-                client.AddUser(new User { Id = MultiplayerTestScene.PLAYER_1_ID, Username = "Other" });
+                client.AddUser(new APIUser { Id = MultiplayerTestScene.PLAYER_1_ID, Username = "Other" });
                client.TransferHost(MultiplayerTestScene.PLAYER_1_ID);
                client.ChangeUserState(MultiplayerTestScene.PLAYER_1_ID, MultiplayerUserState.Ready);
            });
@@ -485,7 +475,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                importedSet = beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.All).First();
            });

-            AddUntilStep("play started", () => !multiplayerScreen.IsCurrentScreen());
+            AddUntilStep("play started", () => multiplayerScreenStack.CurrentScreen is SpectatorScreen);
        }

        [Test]
@@ -527,16 +517,16 @@ namespace osu.Game.Tests.Visual.Multiplayer

            AddStep("open mod overlay", () => this.ChildrenOfType<RoomSubScreen.UserModSelectButton>().Single().TriggerClick());

-            AddStep("invoke on back button", () => multiplayerScreen.OnBackButton());
+            AddStep("invoke on back button", () => multiplayerScreenStack.OnBackButton());

            AddAssert("mod overlay is hidden", () => this.ChildrenOfType<UserModSelectOverlay>().Single().State.Value == Visibility.Hidden);

            AddAssert("dialog overlay is hidden", () => DialogOverlay.State.Value == Visibility.Hidden);

-            testLeave("back button", () => multiplayerScreen.OnBackButton());
+            testLeave("back button", () => multiplayerScreenStack.OnBackButton());

            // mimics home button and OS window close
-            testLeave("forced exit", () => multiplayerScreen.Exit());
+            testLeave("forced exit", () => multiplayerScreenStack.Exit());

            void testLeave(string actionName, Action action)
            {
@@ -577,7 +567,7 @@ namespace osu.Game.Tests.Visual.Multiplayer

            AddStep("click start button", () => InputManager.Click(MouseButton.Left));

-            AddUntilStep("wait for player", () => Stack.CurrentScreen is Player);
+            AddUntilStep("wait for player", () => multiplayerScreenStack.CurrentScreen is Player);

            // Gameplay runs in real-time, so we need to incrementally check if gameplay has finished in order to not time out.
            for (double i = 1000; i < TestResources.QUICK_BEATMAP_LENGTH; i += 1000)
@@ -586,15 +576,15 @@ namespace osu.Game.Tests.Visual.Multiplayer
                AddUntilStep($"wait for time > {i}", () => this.ChildrenOfType<GameplayClockContainer>().SingleOrDefault()?.GameplayClock.CurrentTime > time);
            }

-            AddUntilStep("wait for results", () => Stack.CurrentScreen is ResultsScreen);
+            AddUntilStep("wait for results", () => multiplayerScreenStack.CurrentScreen is ResultsScreen);
        }

        private MultiplayerReadyButton readyButton => this.ChildrenOfType<MultiplayerReadyButton>().Single();

        private void createRoom(Func<Room> room)
        {
-            AddUntilStep("wait for lounge", () => multiplayerScreen.ChildrenOfType<LoungeSubScreen>().SingleOrDefault()?.IsLoaded == true);
-            AddStep("open room", () => multiplayerScreen.ChildrenOfType<LoungeSubScreen>().Single().Open(room()));
+            AddUntilStep("wait for lounge", () => multiplayerScreenStack.ChildrenOfType<LoungeSubScreen>().SingleOrDefault()?.IsLoaded == true);
+            AddStep("open room", () => multiplayerScreenStack.ChildrenOfType<LoungeSubScreen>().Single().Open(room()));

            AddUntilStep("wait for room open", () => this.ChildrenOfType<MultiplayerMatchSubScreen>().FirstOrDefault()?.IsLoaded == true);
            AddWaitStep("wait for transition", 2);
@@ -607,26 +597,5 @@ namespace osu.Game.Tests.Visual.Multiplayer

            AddUntilStep("wait for join", () => client.Room != null);
        }
-
-        /// <summary>
-        /// Used for the sole purpose of adding <see cref="TestMultiplayerClient"/> as a resolvable dependency.
-        /// </summary>
-        private class DependenciesScreen : OsuScreen
-        {
-            [Cached(typeof(MultiplayerClient))]
-            public readonly TestMultiplayerClient Client;
-
-            public DependenciesScreen(TestMultiplayerClient client)
-            {
-                Client = client;
-            }
-        }
-
-        private class TestMultiplayer : Screens.OnlinePlay.Multiplayer.Multiplayer
-        {
-            public new TestRequestHandlingMultiplayerRoomManager RoomManager { get; private set; }
-
-            protected override RoomManager CreateRoomManager() => RoomManager = new TestRequestHandlingMultiplayerRoomManager();
-        }
    }
 }
@@ -8,10 +8,10 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
-using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Configuration;
 using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Spectator;
 using osu.Game.Replays.Legacy;
@@ -21,7 +21,6 @@ using osu.Game.Scoring;
 using osu.Game.Screens.Play.HUD;
 using osu.Game.Tests.Visual.OnlinePlay;
 using osu.Game.Tests.Visual.Spectator;
-using osu.Game.Users;

 namespace osu.Game.Tests.Visual.Multiplayer
 {
@@ -40,9 +39,10 @@ namespace osu.Game.Tests.Visual.Multiplayer
            Dependencies.Cache(config = new OsuConfigManager(LocalStorage));
        }

-        [SetUpSteps]
        public override void SetUpSteps()
        {
+            base.SetUpSteps();
+
            AddStep("set local user", () => ((DummyAPIAccess)API).LocalUser.Value = LookupCache.GetUserAsync(1).Result);

            AddStep("create leaderboard", () =>
@@ -58,7 +58,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                foreach (int user in users)
                {
                    SpectatorClient.StartPlay(user, Beatmap.Value.BeatmapInfo.OnlineBeatmapID ?? 0);
-                    multiplayerUsers.Add(OnlinePlayDependencies.Client.AddUser(new User { Id = user }, true));
+                    multiplayerUsers.Add(OnlinePlayDependencies.Client.AddUser(new APIUser { Id = user }, true));
                }

                Children = new Drawable[]
@@ -5,9 +5,9 @@ using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
-using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
 using osu.Game.Online.Rooms;
@@ -16,7 +16,6 @@ using osu.Game.Screens.OnlinePlay.Multiplayer;
 using osu.Game.Screens.Play.HUD;
 using osu.Game.Tests.Visual.OnlinePlay;
 using osu.Game.Tests.Visual.Spectator;
-using osu.Game.Users;

 namespace osu.Game.Tests.Visual.Multiplayer
 {
@@ -44,9 +43,10 @@ namespace osu.Game.Tests.Visual.Multiplayer
            return room;
        }

-        [SetUpSteps]
        public override void SetUpSteps()
        {
+            base.SetUpSteps();
+
            AddStep("set local user", () => ((DummyAPIAccess)API).LocalUser.Value = LookupCache.GetUserAsync(1).Result);

            AddStep("create leaderboard", () =>
@@ -62,7 +62,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                foreach (int user in users)
                {
                    SpectatorClient.StartPlay(user, Beatmap.Value.BeatmapInfo.OnlineBeatmapID ?? 0);
-                    var roomUser = OnlinePlayDependencies.Client.AddUser(new User { Id = user }, true);
+                    var roomUser = OnlinePlayDependencies.Client.AddUser(new APIUser { Id = user }, true);

                    roomUser.MatchState = new TeamVersusUserState
                    {
@@ -18,7 +18,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 {
    public class TestSceneMultiplayerLoungeSubScreen : OnlinePlayTestScene
    {
-        protected new TestRequestHandlingRoomManager RoomManager => (TestRequestHandlingRoomManager)base.RoomManager;
+        protected new TestRoomManager RoomManager => (TestRoomManager)base.RoomManager;

        private LoungeSubScreen loungeScreen;

@@ -4,7 +4,6 @@
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Online.Rooms;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Match;

 namespace osu.Game.Tests.Visual.Multiplayer
@@ -14,8 +13,6 @@ namespace osu.Game.Tests.Visual.Multiplayer
        [SetUp]
        public new void Setup() => Schedule(() =>
        {
-            SelectedRoom.Value = new Room();
-
            Child = new Container
            {
                Anchor = Anchor.Centre,
@@ -9,6 +9,7 @@ using osu.Framework.Platform;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
 using osu.Game.Rulesets;
@@ -18,7 +19,6 @@ using osu.Game.Screens.OnlinePlay.Multiplayer;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Match;
 using osu.Game.Tests.Beatmaps;
 using osu.Game.Tests.Resources;
-using osu.Game.Users;
 using osuTK.Input;

 namespace osu.Game.Tests.Visual.Multiplayer
@@ -119,7 +119,7 @@ namespace osu.Game.Tests.Visual.Multiplayer

            AddStep("join other user (ready)", () =>
            {
-                Client.AddUser(new User { Id = PLAYER_1_ID });
+                Client.AddUser(new APIUser { Id = PLAYER_1_ID });
                Client.ChangeUserState(PLAYER_1_ID, MultiplayerUserState.Ready);
            });

--- a/Show More
+++ b/Show More