Merge pull request #15976 from smoogipoo/add-modes-to-room-panels

Add match type and queue mode to multiplayer room panels

.github/workflows/ci.yml

@@ -77,10 +77,6 @@ jobs:
         run: msbuild osu.Android/osu.Android.csproj /restore /p:Configuration=Debug
 
   build-only-ios:
-    # While this workflow technically *can* run, it fails as iOS builds are blocked by multiple issues.
-    # See https://github.com/ppy/osu-framework/issues/4677 for the details.
-    # The job can be unblocked once those issues are resolved and game deployments can happen again.
-    if: false
     name: Build only (iOS)
     runs-on: macos-latest
     timeout-minutes: 60

CodeAnalysis/BannedSymbols.txt

@@ -10,3 +10,6 @@ T:Microsoft.EntityFrameworkCore.Internal.EnumerableExtensions;Don't use internal
 T:Microsoft.EntityFrameworkCore.Internal.TypeExtensions;Don't use internal extension methods.
 T:NuGet.Packaging.CollectionExtensions;Don't use internal extension methods.
 M:System.Enum.HasFlag(System.Enum);Use osu.Framework.Extensions.EnumExtensions.HasFlagFast<T>() instead.
+M:Realms.IRealmCollection`1.SubscribeForNotifications`1(Realms.NotificationCallbackDelegate{``0});Use osu.Game.Database.RealmObjectExtensions.QueryAsyncWithNotifications(IRealmCollection<T>,NotificationCallbackDelegate<T>) instead.
+M:Realms.CollectionExtensions.SubscribeForNotifications`1(System.Linq.IQueryable{``0},Realms.NotificationCallbackDelegate{``0});Use osu.Game.Database.RealmObjectExtensions.QueryAsyncWithNotifications(IQueryable<T>,NotificationCallbackDelegate<T>) instead.
+M:Realms.CollectionExtensions.SubscribeForNotifications`1(System.Collections.Generic.IList{``0},Realms.NotificationCallbackDelegate{``0});Use osu.Game.Database.RealmObjectExtensions.QueryAsyncWithNotifications(IList<T>,NotificationCallbackDelegate<T>) instead.

osu.Android.props

@@ -51,8 +51,8 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.1112.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.1127.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.1203.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.1207.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. -->

osu.Desktop/LegacyIpc/LegacyIpcDifficultyCalculationRequest.cs

@@ -0,0 +1,18 @@
+// 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.
+
+namespace osu.Desktop.LegacyIpc
+{
+    /// <summary>
+    /// A difficulty calculation request from the legacy client.
+    /// </summary>
+    /// <remarks>
+    /// Synchronise any changes with osu!stable.
+    /// </remarks>
+    public class LegacyIpcDifficultyCalculationRequest
+    {
+        public string BeatmapFile { get; set; }
+        public int RulesetId { get; set; }
+        public int Mods { get; set; }
+    }
+}

osu.Desktop/LegacyIpc/LegacyIpcDifficultyCalculationResponse.cs

@@ -0,0 +1,16 @@
+// 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.
+
+namespace osu.Desktop.LegacyIpc
+{
+    /// <summary>
+    /// A difficulty calculation response returned to the legacy client.
+    /// </summary>
+    /// <remarks>
+    /// Synchronise any changes with osu!stable.
+    /// </remarks>
+    public class LegacyIpcDifficultyCalculationResponse
+    {
+        public double StarRating { get; set; }
+    }
+}

osu.Desktop/LegacyIpc/LegacyIpcMessage.cs

@@ -0,0 +1,53 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Platform;
+using Newtonsoft.Json.Linq;
+
+namespace osu.Desktop.LegacyIpc
+{
+    /// <summary>
+    /// An <see cref="IpcMessage"/> that can be used to communicate to and from legacy clients.
+    /// <para>
+    /// In order to deserialise types at either end, types must be serialised as their <see cref="System.Type.AssemblyQualifiedName"/>,
+    /// however this cannot be done since osu!stable and osu!lazer live in two different assemblies.
+    /// <br />
+    /// To get around this, this class exists which serialises a payload (<see cref="LegacyIpcMessage.Data"/>) as an <see cref="System.Object"/> type,
+    /// which can be deserialised at either end because it is part of the core library (mscorlib / System.Private.CorLib).
+    /// The payload contains the data to be sent over the IPC channel.
+    /// <br />
+    /// At either end, Json.NET deserialises the payload into a <see cref="JObject"/> which is manually converted back into the expected <see cref="LegacyIpcMessage.Data"/> type,
+    /// which then further contains another <see cref="JObject"/> representing the data sent over the IPC channel whose type can likewise be lazily matched through
+    /// <see cref="LegacyIpcMessage.Data.MessageType"/>.
+    /// </para>
+    /// </summary>
+    /// <remarks>
+    /// Synchronise any changes with osu-stable.
+    /// </remarks>
+    public class LegacyIpcMessage : IpcMessage
+    {
+        public LegacyIpcMessage()
+        {
+            // Types/assemblies are not inter-compatible, so always serialise/deserialise into objects.
+            base.Type = typeof(object).FullName;
+        }
+
+        public new string Type => base.Type; // Hide setter.
+
+        public new object Value
+        {
+            get => base.Value;
+            set => base.Value = new Data
+            {
+                MessageType = value.GetType().Name,
+                MessageData = value
+            };
+        }
+
+        public class Data
+        {
+            public string MessageType { get; set; }
+            public object MessageData { get; set; }
+        }
+    }
+}

osu.Desktop/LegacyIpc/LegacyTcpIpcProvider.cs

@@ -0,0 +1,121 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using Newtonsoft.Json.Linq;
+using osu.Framework.Logging;
+using osu.Framework.Platform;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Legacy;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Catch;
+using osu.Game.Rulesets.Mania;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Taiko;
+
+#nullable enable
+
+namespace osu.Desktop.LegacyIpc
+{
+    /// <summary>
+    /// Provides IPC to legacy osu! clients.
+    /// </summary>
+    public class LegacyTcpIpcProvider : TcpIpcProvider
+    {
+        private static readonly Logger logger = Logger.GetLogger("legacy-ipc");
+
+        public LegacyTcpIpcProvider()
+            : base(45357)
+        {
+            MessageReceived += msg =>
+            {
+                try
+                {
+                    logger.Add("Processing legacy IPC message...");
+                    logger.Add($"    {msg.Value}", LogLevel.Debug);
+
+                    // See explanation in LegacyIpcMessage for why this is done this way.
+                    var legacyData = ((JObject)msg.Value).ToObject<LegacyIpcMessage.Data>();
+                    object value = parseObject((JObject)legacyData!.MessageData, legacyData.MessageType);
+
+                    return new LegacyIpcMessage
+                    {
+                        Value = onLegacyIpcMessageReceived(value)
+                    };
+                }
+                catch (Exception ex)
+                {
+                    logger.Add($"Processing IPC message failed: {msg.Value}", exception: ex);
+                    return null;
+                }
+            };
+        }
+
+        private object parseObject(JObject value, string type)
+        {
+            switch (type)
+            {
+                case nameof(LegacyIpcDifficultyCalculationRequest):
+                    return value.ToObject<LegacyIpcDifficultyCalculationRequest>()
+                           ?? throw new InvalidOperationException($"Failed to parse request {value}");
+
+                case nameof(LegacyIpcDifficultyCalculationResponse):
+                    return value.ToObject<LegacyIpcDifficultyCalculationResponse>()
+                           ?? throw new InvalidOperationException($"Failed to parse request {value}");
+
+                default:
+                    throw new ArgumentException($"Unsupported object type {type}");
+            }
+        }
+
+        private object onLegacyIpcMessageReceived(object message)
+        {
+            switch (message)
+            {
+                case LegacyIpcDifficultyCalculationRequest req:
+                    try
+                    {
+                        var ruleset = getLegacyRulesetFromID(req.RulesetId);
+
+                        Mod[] mods = ruleset.ConvertFromLegacyMods((LegacyMods)req.Mods).ToArray();
+                        WorkingBeatmap beatmap = new FlatFileWorkingBeatmap(req.BeatmapFile, _ => ruleset);
+
+                        return new LegacyIpcDifficultyCalculationResponse
+                        {
+                            StarRating = ruleset.CreateDifficultyCalculator(beatmap).Calculate(mods).StarRating
+                        };
+                    }
+                    catch
+                    {
+                        return new LegacyIpcDifficultyCalculationResponse();
+                    }
+
+                default:
+                    throw new ArgumentException($"Unsupported message type {message}");
+            }
+        }
+
+        private static Ruleset getLegacyRulesetFromID(int rulesetId)
+        {
+            switch (rulesetId)
+            {
+                case 0:
+                    return new OsuRuleset();
+
+                case 1:
+                    return new TaikoRuleset();
+
+                case 2:
+                    return new CatchRuleset();
+
+                case 3:
+                    return new ManiaRuleset();
+
+                default:
+                    throw new ArgumentException("Invalid ruleset id");
+            }
+        }
+    }
+}

osu.Desktop/Program.cs

@@ -5,6 +5,7 @@ using System;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
+using osu.Desktop.LegacyIpc;
 using osu.Framework;
 using osu.Framework.Development;
 using osu.Framework.Logging;
@@ -18,8 +19,10 @@ namespace osu.Desktop
     {
         private const string base_game_name = @"osu";
 
+        private static LegacyTcpIpcProvider legacyIpc;
+
         [STAThread]
-        public static int Main(string[] args)
+        public static void Main(string[] args)
         {
             // Back up the cwd before DesktopGameHost changes it
             string cwd = Environment.CurrentDirectory;
@@ -69,14 +72,29 @@ namespace osu.Desktop
                                 throw new TimeoutException(@"IPC took too long to send");
                         }
 
-                        return 0;
+                        return;
                     }
 
                     // we want to allow multiple instances to be started when in debug.
                     if (!DebugUtils.IsDebugBuild)
                     {
                         Logger.Log(@"osu! does not support multiple running instances.", LoggingTarget.Runtime, LogLevel.Error);
-                        return 0;
+                        return;
+                    }
+                }
+
+                if (host.IsPrimaryInstance)
+                {
+                    try
+                    {
+                        Logger.Log("Starting legacy IPC provider...");
+                        legacyIpc = new LegacyTcpIpcProvider();
+                        legacyIpc.Bind();
+                        legacyIpc.StartAsync();
+                    }
+                    catch (Exception ex)
+                    {
+                        Logger.Error(ex, "Failed to start legacy IPC provider");
                     }
                 }
 
@@ -84,8 +102,6 @@ namespace osu.Desktop
                     host.Run(new TournamentGame());
                 else
                     host.Run(new OsuGameDesktop(args));
-
-                return 0;
             }
         }
 

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

@@ -174,7 +174,7 @@ namespace osu.Game.Rulesets.Catch.Tests
 
         private Drawable setupSkinHierarchy(Drawable child, ISkin skin)
         {
-            var legacySkinProvider = new SkinProvidingContainer(skins.GetSkin(DefaultLegacySkin.Info));
+            var legacySkinProvider = new SkinProvidingContainer(skins.GetSkin(DefaultLegacySkin.CreateInfo()));
             var testSkinProvider = new SkinProvidingContainer(skin);
             var legacySkinTransformer = new SkinProvidingContainer(new CatchLegacySkinTransformer(testSkinProvider));
 

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

@@ -8,6 +8,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
+using osu.Game.Database;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Screens.Edit;
@@ -55,13 +56,13 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
         [Test]
         public void TestDefaultSkin()
         {
-            AddStep("set default skin", () => skins.CurrentSkinInfo.Value = SkinInfo.Default);
+            AddStep("set default skin", () => skins.CurrentSkinInfo.Value = DefaultSkin.CreateInfo().ToLive());
         }
 
         [Test]
         public void TestLegacySkin()
         {
-            AddStep("set legacy skin", () => skins.CurrentSkinInfo.Value = DefaultLegacySkin.Info);
+            AddStep("set legacy skin", () => skins.CurrentSkinInfo.Value = DefaultLegacySkin.CreateInfo().ToLive());
         }
     }
 }

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

@@ -9,7 +9,6 @@ using osu.Framework.Bindables;
 using osu.Framework.Caching;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.UI;
@@ -46,12 +45,6 @@ namespace osu.Game.Rulesets.Mania.Edit
         [Resolved]
         private EditorBeatmap beatmap { get; set; }
 
-        [Resolved]
-        private IScrollingInfo scrollingInfo { get; set; }
-
-        [Resolved]
-        private Bindable<WorkingBeatmap> working { get; set; }
-
         [Resolved]
         private OsuColour colours { get; set; }
 

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

@@ -7,16 +7,12 @@ using osu.Framework.Allocation;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Screens.Edit.Compose.Components;
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
     public class ManiaSelectionHandler : EditorSelectionHandler
     {
-        [Resolved]
-        private IScrollingInfo scrollingInfo { get; set; }
-
         [Resolved]
         private HitObjectComposer composer { get; set; }
 

osu.Game.Rulesets.Mania/UI/PoolableHitExplosion.cs

@@ -15,9 +15,6 @@ namespace osu.Game.Rulesets.Mania.UI
 
         public JudgementResult Result { get; private set; }
 
-        [Resolved]
-        private Column column { get; set; }
-
         private SkinnableDrawable skinnableExplosion;
 
         public PoolableHitExplosion()

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

@@ -67,7 +67,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             AddStep("create slider", () =>
             {
-                var tintingSkin = skinManager.GetSkin(DefaultLegacySkin.Info);
+                var tintingSkin = skinManager.GetSkin(DefaultLegacySkin.CreateInfo());
                 tintingSkin.Configuration.ConfigDictionary["AllowSliderBallTint"] = "1";
 
                 Child = new SkinProvidingContainer(tintingSkin)

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

@@ -1,4 +1,4 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
@@ -26,12 +26,12 @@ namespace osu.Game.Rulesets.Osu.Mods
         public BindableFloat Scale { get; } = new BindableFloat(4)
         {
             Precision = 0.1f,
-            MinValue = 2,
+            MinValue = 1.5f,
             MaxValue = 10,
         };
 
         [SettingSource("Style", "Change the animation style of the approach circles.", 1)]
-        public Bindable<AnimationStyle> Style { get; } = new Bindable<AnimationStyle>();
+        public Bindable<AnimationStyle> Style { get; } = new Bindable<AnimationStyle>(AnimationStyle.Gravity);
 
         public void ApplyToDrawableHitObject(DrawableHitObject drawable)
         {
@@ -52,9 +52,18 @@ namespace osu.Game.Rulesets.Osu.Mods
         {
             switch (style)
             {
-                default:
+                case AnimationStyle.Linear:
                     return Easing.None;
 
+                case AnimationStyle.Gravity:
+                    return Easing.InBack;
+
+                case AnimationStyle.InOut1:
+                    return Easing.InOutCubic;
+
+                case AnimationStyle.InOut2:
+                    return Easing.InOutQuint;
+
                 case AnimationStyle.Accelerate1:
                     return Easing.In;
 
@@ -64,9 +73,6 @@ namespace osu.Game.Rulesets.Osu.Mods
                 case AnimationStyle.Accelerate3:
                     return Easing.InQuint;
 
-                case AnimationStyle.Gravity:
-                    return Easing.InBack;
-
                 case AnimationStyle.Decelerate1:
                     return Easing.Out;
 
@@ -76,16 +82,14 @@ namespace osu.Game.Rulesets.Osu.Mods
                 case AnimationStyle.Decelerate3:
                     return Easing.OutQuint;
 
-                case AnimationStyle.InOut1:
-                    return Easing.InOutCubic;
-
-                case AnimationStyle.InOut2:
-                    return Easing.InOutQuint;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(style), style, @"Unsupported animation style");
             }
         }
 
         public enum AnimationStyle
         {
+            Linear,
             Gravity,
             InOut1,
             InOut2,

osu.Game.Rulesets.Taiko/UI/InputDrum.cs

@@ -12,7 +12,6 @@ using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Rulesets.UI;
-using osu.Game.Screens.Play;
 using osu.Game.Skinning;
 using osuTK;
 
@@ -149,9 +148,6 @@ namespace osu.Game.Rulesets.Taiko.UI
                 centreHit.Colour = colours.Pink;
             }
 
-            [Resolved(canBeNull: true)]
-            private GameplayClock gameplayClock { get; set; }
-
             public bool OnPressed(KeyBindingPressEvent<TaikoAction> e)
             {
                 Drawable target = null;

osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs

@@ -2,14 +2,20 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Replays;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Catch;
 using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko;
 using osu.Game.Scoring;
@@ -21,6 +27,14 @@ namespace osu.Game.Tests.Beatmaps.Formats
     [TestFixture]
     public class LegacyScoreDecoderTest
     {
+        private CultureInfo originalCulture;
+
+        [SetUp]
+        public void SetUp()
+        {
+            originalCulture = CultureInfo.CurrentCulture;
+        }
+
         [Test]
         public void TestDecodeManiaReplay()
         {
@@ -44,6 +58,59 @@ namespace osu.Game.Tests.Beatmaps.Formats
             }
         }
 
+        [Test]
+        public void TestCultureInvariance()
+        {
+            var ruleset = new OsuRuleset().RulesetInfo;
+            var scoreInfo = new TestScoreInfo(ruleset);
+            var beatmap = new TestBeatmap(ruleset);
+            var score = new Score
+            {
+                ScoreInfo = scoreInfo,
+                Replay = new Replay
+                {
+                    Frames = new List<ReplayFrame>
+                    {
+                        new OsuReplayFrame(2000, OsuPlayfield.BASE_SIZE / 2, OsuAction.LeftButton)
+                    }
+                }
+            };
+
+            // the "se" culture is used here, as it encodes the negative number sign as U+2212 MINUS SIGN,
+            // rather than the classic ASCII U+002D HYPHEN-MINUS.
+            CultureInfo.CurrentCulture = new CultureInfo("se");
+
+            var encodeStream = new MemoryStream();
+
+            var encoder = new LegacyScoreEncoder(score, beatmap);
+            encoder.Encode(encodeStream);
+
+            var decodeStream = new MemoryStream(encodeStream.GetBuffer());
+
+            var decoder = new TestLegacyScoreDecoder();
+            var decodedAfterEncode = decoder.Parse(decodeStream);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(decodedAfterEncode, Is.Not.Null);
+
+                Assert.That(decodedAfterEncode.ScoreInfo.User.Username, Is.EqualTo(scoreInfo.User.Username));
+                Assert.That(decodedAfterEncode.ScoreInfo.BeatmapInfoID, Is.EqualTo(scoreInfo.BeatmapInfoID));
+                Assert.That(decodedAfterEncode.ScoreInfo.Ruleset, Is.EqualTo(scoreInfo.Ruleset));
+                Assert.That(decodedAfterEncode.ScoreInfo.TotalScore, Is.EqualTo(scoreInfo.TotalScore));
+                Assert.That(decodedAfterEncode.ScoreInfo.MaxCombo, Is.EqualTo(scoreInfo.MaxCombo));
+                Assert.That(decodedAfterEncode.ScoreInfo.Date, Is.EqualTo(scoreInfo.Date));
+
+                Assert.That(decodedAfterEncode.Replay.Frames.Count, Is.EqualTo(1));
+            });
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            CultureInfo.CurrentCulture = originalCulture;
+        }
+
         private class TestLegacyScoreDecoder : LegacyScoreDecoder
         {
             private static readonly Dictionary<int, Ruleset> rulesets = new Ruleset[]

osu.Game.Tests/Beatmaps/TestSceneBeatmapDifficultyCache.cs

@@ -25,9 +25,6 @@ namespace osu.Game.Tests.Beatmaps
 
         private BeatmapSetInfo importedSet;
 
-        [Resolved]
-        private BeatmapManager beatmaps { get; set; }
-
         private TestBeatmapDifficultyCache difficultyCache;
 
         private IBindable<StarDifficulty?> starDifficultyBindable;

osu.Game.Tests/Database/BeatmapImporterTests.cs

@@ -12,6 +12,7 @@ using NUnit.Framework;
 using osu.Framework.Extensions;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Logging;
+using osu.Framework.Platform;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Extensions;
@@ -474,7 +475,7 @@ namespace osu.Game.Tests.Database
         }
 
         [Test]
-        public void TestImportThenDeleteThenImport()
+        public void TestImportThenDeleteThenImportOptimisedPath()
         {
             RunTestWithRealmAsync(async (realmFactory, storage) =>
             {
@@ -485,11 +486,39 @@ namespace osu.Game.Tests.Database
 
                 deleteBeatmapSet(imported, realmFactory.Context);
 
+                Assert.IsTrue(imported.DeletePending);
+
                 var importedSecondTime = await LoadOszIntoStore(importer, realmFactory.Context);
 
                 // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash.
                 Assert.IsTrue(imported.ID == importedSecondTime.ID);
                 Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
+                Assert.IsFalse(imported.DeletePending);
+                Assert.IsFalse(importedSecondTime.DeletePending);
+            });
+        }
+
+        [Test]
+        public void TestImportThenDeleteThenImportNonOptimisedPath()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                using var importer = new NonOptimisedBeatmapImporter(realmFactory, storage);
+                using var store = new RealmRulesetStore(realmFactory, storage);
+
+                var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+
+                deleteBeatmapSet(imported, realmFactory.Context);
+
+                Assert.IsTrue(imported.DeletePending);
+
+                var importedSecondTime = await LoadOszIntoStore(importer, realmFactory.Context);
+
+                // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash.
+                Assert.IsTrue(imported.ID == importedSecondTime.ID);
+                Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
+                Assert.IsFalse(imported.DeletePending);
+                Assert.IsFalse(importedSecondTime.DeletePending);
             });
         }
 
@@ -823,7 +852,11 @@ namespace osu.Game.Tests.Database
         {
             IQueryable<RealmBeatmapSet>? resultSets = null;
 
-            waitForOrAssert(() => (resultSets = realm.All<RealmBeatmapSet>().Where(s => !s.DeletePending && s.OnlineID == 241526)).Any(),
+            waitForOrAssert(() =>
+                {
+                    realm.Refresh();
+                    return (resultSets = realm.All<RealmBeatmapSet>().Where(s => !s.DeletePending && s.OnlineID == 241526)).Any();
+                },
                 @"BeatmapSet did not import to the database in allocated time.", timeout);
 
             // ensure we were stored to beatmap database backing...
@@ -836,16 +869,16 @@ namespace osu.Game.Tests.Database
             // ReSharper disable once PossibleUnintendedReferenceComparison
             IEnumerable<RealmBeatmap> queryBeatmaps() => realm.All<RealmBeatmap>().Where(s => s.BeatmapSet != null && s.BeatmapSet == set);
 
-            waitForOrAssert(() => queryBeatmaps().Count() == 12, @"Beatmaps did not import to the database in allocated time", timeout);
-            waitForOrAssert(() => queryBeatmapSets().Count() == 1, @"BeatmapSet did not import to the database in allocated time", timeout);
+            Assert.AreEqual(12, queryBeatmaps().Count(), @"Beatmap count was not correct");
+            Assert.AreEqual(1, queryBeatmapSets().Count(), @"Beatmapset count was not correct");
 
-            int countBeatmapSetBeatmaps = 0;
-            int countBeatmaps = 0;
+            int countBeatmapSetBeatmaps;
+            int countBeatmaps;
 
-            waitForOrAssert(() =>
-                    (countBeatmapSetBeatmaps = queryBeatmapSets().First().Beatmaps.Count) ==
-                    (countBeatmaps = queryBeatmaps().Count()),
-                $@"Incorrect database beatmap count post-import ({countBeatmaps} but should be {countBeatmapSetBeatmaps}).", timeout);
+            Assert.AreEqual(
+                countBeatmapSetBeatmaps = queryBeatmapSets().First().Beatmaps.Count,
+                countBeatmaps = queryBeatmaps().Count(),
+                $@"Incorrect database beatmap count post-import ({countBeatmaps} but should be {countBeatmapSetBeatmaps}).");
 
             foreach (RealmBeatmap b in set.Beatmaps)
                 Assert.IsTrue(set.Beatmaps.Any(c => c.OnlineID == b.OnlineID));
@@ -867,5 +900,15 @@ namespace osu.Game.Tests.Database
 
             Assert.Fail(failureMessage);
         }
+
+        public class NonOptimisedBeatmapImporter : BeatmapImporter
+        {
+            public NonOptimisedBeatmapImporter(RealmContextFactory realmFactory, Storage storage)
+                : base(realmFactory, storage)
+            {
+            }
+
+            protected override bool HasCustomHashFunction => true;
+        }
     }
 }

osu.Game.Tests/Database/GeneralUsageTests.cs

@@ -5,6 +5,8 @@ using System;
 using System.Threading;
 using System.Threading.Tasks;
 using NUnit.Framework;
+using osu.Game.Database;
+using osu.Game.Models;
 
 #nullable enable
 
@@ -33,6 +35,39 @@ namespace osu.Game.Tests.Database
             });
         }
 
+        /// <summary>
+        /// Test to ensure that a `CreateContext` call nested inside a subscription doesn't cause any deadlocks
+        /// due to context fetching semaphores.
+        /// </summary>
+        [Test]
+        public void TestNestedContextCreationWithSubscription()
+        {
+            RunTestWithRealm((realmFactory, _) =>
+            {
+                bool callbackRan = false;
+
+                using (var context = realmFactory.CreateContext())
+                {
+                    var subscription = context.All<RealmBeatmap>().QueryAsyncWithNotifications((sender, changes, error) =>
+                    {
+                        using (realmFactory.CreateContext())
+                        {
+                            callbackRan = true;
+                        }
+                    });
+
+                    // Force the callback above to run.
+                    using (realmFactory.CreateContext())
+                    {
+                    }
+
+                    subscription?.Dispose();
+                }
+
+                Assert.IsTrue(callbackRan);
+            });
+        }
+
         [Test]
         public void TestBlockOperationsWithContention()
         {

osu.Game.Tests/Database/RealmLiveTests.cs

@@ -29,6 +29,22 @@ namespace osu.Game.Tests.Database
             });
         }
 
+        [Test]
+        public void TestAccessAfterAttach()
+        {
+            RunTestWithRealm((realmFactory, _) =>
+            {
+                var beatmap = new RealmBeatmap(CreateRuleset(), new RealmBeatmapDifficulty(), new RealmBeatmapMetadata());
+
+                var liveBeatmap = beatmap.ToLive();
+
+                using (var context = realmFactory.CreateContext())
+                    context.Write(r => r.Add(beatmap));
+
+                Assert.IsFalse(liveBeatmap.PerformRead(l => l.Hidden));
+            });
+        }
+
         [Test]
         public void TestAccessNonManaged()
         {
@@ -46,49 +62,12 @@ namespace osu.Game.Tests.Database
             Assert.IsFalse(liveBeatmap.PerformRead(l => l.Hidden));
         }
 
-        [Test]
-        public void TestValueAccessWithOpenContext()
-        {
-            RunTestWithRealm((realmFactory, _) =>
-            {
-                RealmLive<RealmBeatmap>? liveBeatmap = null;
-                Task.Factory.StartNew(() =>
-                {
-                    using (var threadContext = realmFactory.CreateContext())
-                    {
-                        var beatmap = threadContext.Write(r => r.Add(new RealmBeatmap(CreateRuleset(), new RealmBeatmapDifficulty(), new RealmBeatmapMetadata())));
-
-                        liveBeatmap = beatmap.ToLive();
-                    }
-                }, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler).Wait();
-
-                Debug.Assert(liveBeatmap != null);
-
-                Task.Factory.StartNew(() =>
-                {
-                    Assert.DoesNotThrow(() =>
-                    {
-                        using (realmFactory.CreateContext())
-                        {
-                            var resolved = liveBeatmap.Value;
-
-                            Assert.IsTrue(resolved.Realm.IsClosed);
-                            Assert.IsTrue(resolved.IsValid);
-
-                            // can access properties without a crash.
-                            Assert.IsFalse(resolved.Hidden);
-                        }
-                    });
-                }, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler).Wait();
-            });
-        }
-
         [Test]
         public void TestScopedReadWithoutContext()
         {
             RunTestWithRealm((realmFactory, _) =>
             {
-                RealmLive<RealmBeatmap>? liveBeatmap = null;
+                ILive<RealmBeatmap>? liveBeatmap = null;
                 Task.Factory.StartNew(() =>
                 {
                     using (var threadContext = realmFactory.CreateContext())
@@ -117,7 +96,7 @@ namespace osu.Game.Tests.Database
         {
             RunTestWithRealm((realmFactory, _) =>
             {
-                RealmLive<RealmBeatmap>? liveBeatmap = null;
+                ILive<RealmBeatmap>? liveBeatmap = null;
                 Task.Factory.StartNew(() =>
                 {
                     using (var threadContext = realmFactory.CreateContext())
@@ -138,12 +117,66 @@ namespace osu.Game.Tests.Database
             });
         }
 
+        [Test]
+        public void TestValueAccessNonManaged()
+        {
+            RunTestWithRealm((realmFactory, _) =>
+            {
+                var beatmap = new RealmBeatmap(CreateRuleset(), new RealmBeatmapDifficulty(), new RealmBeatmapMetadata());
+                var liveBeatmap = beatmap.ToLive();
+
+                Assert.DoesNotThrow(() =>
+                {
+                    var __ = liveBeatmap.Value;
+                });
+            });
+        }
+
+        [Test]
+        public void TestValueAccessWithOpenContextFails()
+        {
+            RunTestWithRealm((realmFactory, _) =>
+            {
+                ILive<RealmBeatmap>? liveBeatmap = null;
+
+                Task.Factory.StartNew(() =>
+                {
+                    using (var threadContext = realmFactory.CreateContext())
+                    {
+                        var beatmap = threadContext.Write(r => r.Add(new RealmBeatmap(CreateRuleset(), new RealmBeatmapDifficulty(), new RealmBeatmapMetadata())));
+
+                        liveBeatmap = beatmap.ToLive();
+                    }
+                }, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler).Wait();
+
+                Debug.Assert(liveBeatmap != null);
+
+                Task.Factory.StartNew(() =>
+                {
+                    // Can't be used, without a valid context.
+                    Assert.Throws<InvalidOperationException>(() =>
+                    {
+                        var __ = liveBeatmap.Value;
+                    });
+
+                    // Can't be used, even from within a valid context.
+                    using (realmFactory.CreateContext())
+                    {
+                        Assert.Throws<InvalidOperationException>(() =>
+                        {
+                            var __ = liveBeatmap.Value;
+                        });
+                    }
+                }, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler).Wait();
+            });
+        }
+
         [Test]
         public void TestValueAccessWithoutOpenContextFails()
         {
             RunTestWithRealm((realmFactory, _) =>
             {
-                RealmLive<RealmBeatmap>? liveBeatmap = null;
+                ILive<RealmBeatmap>? liveBeatmap = null;
                 Task.Factory.StartNew(() =>
                 {
                     using (var threadContext = realmFactory.CreateContext())
@@ -175,8 +208,8 @@ namespace osu.Game.Tests.Database
 
                 using (var updateThreadContext = realmFactory.CreateContext())
                 {
-                    updateThreadContext.All<RealmBeatmap>().SubscribeForNotifications(gotChange);
-                    RealmLive<RealmBeatmap>? liveBeatmap = null;
+                    updateThreadContext.All<RealmBeatmap>().QueryAsyncWithNotifications(gotChange);
+                    ILive<RealmBeatmap>? liveBeatmap = null;
 
                     Task.Factory.StartNew(() =>
                     {
@@ -199,23 +232,22 @@ namespace osu.Game.Tests.Database
                     Assert.AreEqual(0, updateThreadContext.All<RealmBeatmap>().Count());
                     Assert.AreEqual(0, changesTriggered);
 
-                    var resolved = liveBeatmap.Value;
-
-                    // retrieval causes an implicit refresh. even changes that aren't related to the retrieval are fired at this point.
-                    Assert.AreEqual(2, updateThreadContext.All<RealmBeatmap>().Count());
-                    Assert.AreEqual(1, changesTriggered);
-
-                    // even though the realm that this instance was resolved for was closed, it's still valid.
-                    Assert.IsTrue(resolved.Realm.IsClosed);
-                    Assert.IsTrue(resolved.IsValid);
-
-                    // can access properties without a crash.
-                    Assert.IsFalse(resolved.Hidden);
-
-                    updateThreadContext.Write(r =>
+                    liveBeatmap.PerformRead(resolved =>
                     {
-                        // can use with the main context.
-                        r.Remove(resolved);
+                        // retrieval causes an implicit refresh. even changes that aren't related to the retrieval are fired at this point.
+                        // ReSharper disable once AccessToDisposedClosure
+                        Assert.AreEqual(2, updateThreadContext.All<RealmBeatmap>().Count());
+                        Assert.AreEqual(1, changesTriggered);
+
+                        // can access properties without a crash.
+                        Assert.IsFalse(resolved.Hidden);
+
+                        // ReSharper disable once AccessToDisposedClosure
+                        updateThreadContext.Write(r =>
+                        {
+                            // can use with the main context.
+                            r.Remove(resolved);
+                        });
                     });
                 }
 

osu.Game.Tests/Database/RulesetStoreTests.cs

@@ -45,9 +45,9 @@ namespace osu.Game.Tests.Database
             {
                 var rulesets = new RealmRulesetStore(realmFactory, storage);
 
-                Assert.IsTrue((rulesets.AvailableRulesets.First() as RealmRuleset)?.IsManaged == false);
-                Assert.IsTrue((rulesets.GetRuleset(0) as RealmRuleset)?.IsManaged == false);
-                Assert.IsTrue((rulesets.GetRuleset("mania") as RealmRuleset)?.IsManaged == false);
+                Assert.IsFalse(rulesets.AvailableRulesets.First().IsManaged);
+                Assert.IsFalse(rulesets.GetRuleset(0)?.IsManaged);
+                Assert.IsFalse(rulesets.GetRuleset("mania")?.IsManaged);
             });
         }
     }

osu.Game.Tests/Gameplay/TestSceneStoryboardSamples.cs

@@ -167,7 +167,7 @@ namespace osu.Game.Tests.Gameplay
         private class TestSkin : LegacySkin
         {
             public TestSkin(string resourceName, IStorageResourceProvider resources)
-                : base(DefaultLegacySkin.Info, new TestResourceStore(resourceName), resources, "skin.ini")
+                : base(DefaultLegacySkin.CreateInfo(), new TestResourceStore(resourceName), resources, "skin.ini")
             {
             }
         }

osu.Game.Tests/Input/ConfineMouseTrackerTest.cs

@@ -18,9 +18,6 @@ namespace osu.Game.Tests.Input
         [Resolved]
         private FrameworkConfigManager frameworkConfigManager { get; set; }
 
-        [Resolved]
-        private OsuConfigManager osuConfigManager { get; set; }
-
         [TestCase(WindowMode.Windowed)]
         [TestCase(WindowMode.Borderless)]
         public void TestDisableConfining(WindowMode windowMode)

osu.Game.Tests/NonVisual/DifficultyAdjustmentModCombinationsTest.cs

@@ -3,12 +3,14 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Skills;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Utils;
 
 namespace osu.Game.Tests.NonVisual
 {
@@ -20,8 +22,10 @@ namespace osu.Game.Tests.NonVisual
         {
             var combinations = new TestLegacyDifficultyCalculator().CreateDifficultyAdjustmentModCombinations();
 
-            Assert.AreEqual(1, combinations.Length);
-            Assert.IsTrue(combinations[0] is ModNoMod);
+            assertCombinations(new[]
+            {
+                new[] { typeof(ModNoMod) }
+            }, combinations);
         }
 
         [Test]
@@ -29,9 +33,11 @@ namespace osu.Game.Tests.NonVisual
         {
             var combinations = new TestLegacyDifficultyCalculator(new ModA()).CreateDifficultyAdjustmentModCombinations();
 
-            Assert.AreEqual(2, combinations.Length);
-            Assert.IsTrue(combinations[0] is ModNoMod);
-            Assert.IsTrue(combinations[1] is ModA);
+            assertCombinations(new[]
+            {
+                new[] { typeof(ModNoMod) },
+                new[] { typeof(ModA) }
+            }, combinations);
         }
 
         [Test]
@@ -39,14 +45,13 @@ namespace osu.Game.Tests.NonVisual
         {
             var combinations = new TestLegacyDifficultyCalculator(new ModA(), new ModB()).CreateDifficultyAdjustmentModCombinations();
 
-            Assert.AreEqual(4, combinations.Length);
-            Assert.IsTrue(combinations[0] is ModNoMod);
-            Assert.IsTrue(combinations[1] is ModA);
-            Assert.IsTrue(combinations[2] is MultiMod);
-            Assert.IsTrue(combinations[3] is ModB);
-
-            Assert.IsTrue(((MultiMod)combinations[2]).Mods[0] is ModA);
-            Assert.IsTrue(((MultiMod)combinations[2]).Mods[1] is ModB);
+            assertCombinations(new[]
+            {
+                new[] { typeof(ModNoMod) },
+                new[] { typeof(ModA) },
+                new[] { typeof(ModA), typeof(ModB) },
+                new[] { typeof(ModB) }
+            }, combinations);
         }
 
         [Test]
@@ -54,10 +59,12 @@ namespace osu.Game.Tests.NonVisual
         {
             var combinations = new TestLegacyDifficultyCalculator(new ModA(), new ModIncompatibleWithA()).CreateDifficultyAdjustmentModCombinations();
 
-            Assert.AreEqual(3, combinations.Length);
-            Assert.IsTrue(combinations[0] is ModNoMod);
-            Assert.IsTrue(combinations[1] is ModA);
-            Assert.IsTrue(combinations[2] is ModIncompatibleWithA);
+            assertCombinations(new[]
+            {
+                new[] { typeof(ModNoMod) },
+                new[] { typeof(ModA) },
+                new[] { typeof(ModIncompatibleWithA) }
+            }, combinations);
         }
 
         [Test]
@@ -65,22 +72,17 @@ namespace osu.Game.Tests.NonVisual
         {
             var combinations = new TestLegacyDifficultyCalculator(new ModA(), new ModB(), new ModIncompatibleWithA(), new ModIncompatibleWithAAndB()).CreateDifficultyAdjustmentModCombinations();
 
-            Assert.AreEqual(8, combinations.Length);
-            Assert.IsTrue(combinations[0] is ModNoMod);
-            Assert.IsTrue(combinations[1] is ModA);
-            Assert.IsTrue(combinations[2] is MultiMod);
-            Assert.IsTrue(combinations[3] is ModB);
-            Assert.IsTrue(combinations[4] is MultiMod);
-            Assert.IsTrue(combinations[5] is ModIncompatibleWithA);
-            Assert.IsTrue(combinations[6] is MultiMod);
-            Assert.IsTrue(combinations[7] is ModIncompatibleWithAAndB);
-
-            Assert.IsTrue(((MultiMod)combinations[2]).Mods[0] is ModA);
-            Assert.IsTrue(((MultiMod)combinations[2]).Mods[1] is ModB);
-            Assert.IsTrue(((MultiMod)combinations[4]).Mods[0] is ModB);
-            Assert.IsTrue(((MultiMod)combinations[4]).Mods[1] is ModIncompatibleWithA);
-            Assert.IsTrue(((MultiMod)combinations[6]).Mods[0] is ModIncompatibleWithA);
-            Assert.IsTrue(((MultiMod)combinations[6]).Mods[1] is ModIncompatibleWithAAndB);
+            assertCombinations(new[]
+            {
+                new[] { typeof(ModNoMod) },
+                new[] { typeof(ModA) },
+                new[] { typeof(ModA), typeof(ModB) },
+                new[] { typeof(ModB) },
+                new[] { typeof(ModB), typeof(ModIncompatibleWithA) },
+                new[] { typeof(ModIncompatibleWithA) },
+                new[] { typeof(ModIncompatibleWithA), typeof(ModIncompatibleWithAAndB) },
+                new[] { typeof(ModIncompatibleWithAAndB) },
+            }, combinations);
         }
 
         [Test]
@@ -88,10 +90,12 @@ namespace osu.Game.Tests.NonVisual
         {
             var combinations = new TestLegacyDifficultyCalculator(new ModAofA(), new ModIncompatibleWithAofA()).CreateDifficultyAdjustmentModCombinations();
 
-            Assert.AreEqual(3, combinations.Length);
-            Assert.IsTrue(combinations[0] is ModNoMod);
-            Assert.IsTrue(combinations[1] is ModAofA);
-            Assert.IsTrue(combinations[2] is ModIncompatibleWithAofA);
+            assertCombinations(new[]
+            {
+                new[] { typeof(ModNoMod) },
+                new[] { typeof(ModAofA) },
+                new[] { typeof(ModIncompatibleWithAofA) }
+            }, combinations);
         }
 
         [Test]
@@ -99,17 +103,13 @@ namespace osu.Game.Tests.NonVisual
         {
             var combinations = new TestLegacyDifficultyCalculator(new ModA(), new MultiMod(new ModB(), new ModC())).CreateDifficultyAdjustmentModCombinations();
 
-            Assert.AreEqual(4, combinations.Length);
-            Assert.IsTrue(combinations[0] is ModNoMod);
-            Assert.IsTrue(combinations[1] is ModA);
-            Assert.IsTrue(combinations[2] is MultiMod);
-            Assert.IsTrue(combinations[3] is MultiMod);
-
-            Assert.IsTrue(((MultiMod)combinations[2]).Mods[0] is ModA);
-            Assert.IsTrue(((MultiMod)combinations[2]).Mods[1] is ModB);
-            Assert.IsTrue(((MultiMod)combinations[2]).Mods[2] is ModC);
-            Assert.IsTrue(((MultiMod)combinations[3]).Mods[0] is ModB);
-            Assert.IsTrue(((MultiMod)combinations[3]).Mods[1] is ModC);
+            assertCombinations(new[]
+            {
+                new[] { typeof(ModNoMod) },
+                new[] { typeof(ModA) },
+                new[] { typeof(ModA), typeof(ModB), typeof(ModC) },
+                new[] { typeof(ModB), typeof(ModC) }
+            }, combinations);
         }
 
         [Test]
@@ -117,13 +117,12 @@ namespace osu.Game.Tests.NonVisual
         {
             var combinations = new TestLegacyDifficultyCalculator(new ModA(), new MultiMod(new ModB(), new ModIncompatibleWithA())).CreateDifficultyAdjustmentModCombinations();
 
-            Assert.AreEqual(3, combinations.Length);
-            Assert.IsTrue(combinations[0] is ModNoMod);
-            Assert.IsTrue(combinations[1] is ModA);
-            Assert.IsTrue(combinations[2] is MultiMod);
-
-            Assert.IsTrue(((MultiMod)combinations[2]).Mods[0] is ModB);
-            Assert.IsTrue(((MultiMod)combinations[2]).Mods[1] is ModIncompatibleWithA);
+            assertCombinations(new[]
+            {
+                new[] { typeof(ModNoMod) },
+                new[] { typeof(ModA) },
+                new[] { typeof(ModB), typeof(ModIncompatibleWithA) }
+            }, combinations);
         }
 
         [Test]
@@ -131,13 +130,28 @@ namespace osu.Game.Tests.NonVisual
         {
             var combinations = new TestLegacyDifficultyCalculator(new ModA(), new MultiMod(new ModA(), new ModB())).CreateDifficultyAdjustmentModCombinations();
 
-            Assert.AreEqual(3, combinations.Length);
-            Assert.IsTrue(combinations[0] is ModNoMod);
-            Assert.IsTrue(combinations[1] is ModA);
-            Assert.IsTrue(combinations[2] is MultiMod);
+            assertCombinations(new[]
+            {
+                new[] { typeof(ModNoMod) },
+                new[] { typeof(ModA) },
+                new[] { typeof(ModA), typeof(ModB) }
+            }, combinations);
+        }
 
-            Assert.IsTrue(((MultiMod)combinations[2]).Mods[0] is ModA);
-            Assert.IsTrue(((MultiMod)combinations[2]).Mods[1] is ModB);
+        private void assertCombinations(Type[][] expectedCombinations, Mod[] actualCombinations)
+        {
+            Assert.AreEqual(expectedCombinations.Length, actualCombinations.Length);
+
+            Assert.Multiple(() =>
+            {
+                for (int i = 0; i < expectedCombinations.Length; ++i)
+                {
+                    Type[] expectedTypes = expectedCombinations[i];
+                    Type[] actualTypes = ModUtils.FlattenMod(actualCombinations[i]).Select(m => m.GetType()).ToArray();
+
+                    Assert.That(expectedTypes, Is.EquivalentTo(actualTypes));
+                }
+            });
         }
 
         private class ModA : Mod

osu.Game.Tests/NonVisual/Multiplayer/StatefulMultiplayerClientTest.cs

@@ -16,6 +16,27 @@ namespace osu.Game.Tests.NonVisual.Multiplayer
     [HeadlessTest]
     public class StatefulMultiplayerClientTest : MultiplayerTestScene
     {
+        [Test]
+        public void TestUserAddedOnJoin()
+        {
+            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);
+        }
+
+        [Test]
+        public void TestUserRemovedOnLeave()
+        {
+            var user = new APIUser { Id = 44 };
+
+            AddStep("add user", () => Client.AddUser(user));
+            AddAssert("room has 2 users", () => Client.Room?.Users.Count == 2);
+
+            AddRepeatStep("remove user multiple times", () => Client.RemoveUser(user), 3);
+            AddAssert("room has 1 user", () => Client.Room?.Users.Count == 1);
+        }
+
         [Test]
         public void TestPlayingUserTracking()
         {

osu.Game.Tests/OnlinePlay/StatefulMultiplayerClientTest.cs

@@ -1,35 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using NUnit.Framework;
-using osu.Framework.Testing;
-using osu.Game.Online.API.Requests.Responses;
-using osu.Game.Tests.Visual.Multiplayer;
-
-namespace osu.Game.Tests.OnlinePlay
-{
-    [HeadlessTest]
-    public class StatefulMultiplayerClientTest : MultiplayerTestScene
-    {
-        [Test]
-        public void TestUserAddedOnJoin()
-        {
-            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);
-        }
-
-        [Test]
-        public void TestUserRemovedOnLeave()
-        {
-            var user = new APIUser { Id = 44 };
-
-            AddStep("add user", () => Client.AddUser(user));
-            AddAssert("room has 2 users", () => Client.Room?.Users.Count == 2);
-
-            AddRepeatStep("remove user multiple times", () => Client.RemoveUser(user), 3);
-            AddAssert("room has 1 user", () => Client.Room?.Users.Count == 1);
-        }
-    }
-}

osu.Game.Tests/Skins/IO/ImportSkinTest.cs

@@ -9,6 +9,7 @@ using System.Threading.Tasks;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Platform;
+using osu.Game.Database;
 using osu.Game.IO;
 using osu.Game.IO.Archives;
 using osu.Game.Skinning;
@@ -163,32 +164,109 @@ namespace osu.Game.Tests.Skins.IO
             assertCorrectMetadata(import2, "name 1 [my custom skin 2]", "author 1", osu);
         });
 
+        [Test]
+        public Task TestExportThenImportDefaultSkin() => runSkinTest(osu =>
+        {
+            var skinManager = osu.Dependencies.Get<SkinManager>();
+
+            skinManager.EnsureMutableSkin();
+
+            MemoryStream exportStream = new MemoryStream();
+
+            Guid originalSkinId = skinManager.CurrentSkinInfo.Value.ID;
+
+            skinManager.CurrentSkinInfo.Value.PerformRead(s =>
+            {
+                Assert.IsFalse(s.Protected);
+                Assert.AreEqual(typeof(DefaultSkin), s.CreateInstance(skinManager).GetType());
+
+                new LegacySkinExporter(osu.Dependencies.Get<Storage>()).ExportModelTo(s, exportStream);
+
+                Assert.Greater(exportStream.Length, 0);
+            });
+
+            var imported = skinManager.Import(new ImportTask(exportStream, "exported.osk"));
+
+            imported.Result.PerformRead(s =>
+            {
+                Assert.IsFalse(s.Protected);
+                Assert.AreNotEqual(originalSkinId, s.ID);
+                Assert.AreEqual(typeof(DefaultSkin), s.CreateInstance(skinManager).GetType());
+            });
+
+            return Task.CompletedTask;
+        });
+
+        [Test]
+        public Task TestExportThenImportClassicSkin() => runSkinTest(osu =>
+        {
+            var skinManager = osu.Dependencies.Get<SkinManager>();
+
+            skinManager.CurrentSkinInfo.Value = skinManager.DefaultLegacySkin.SkinInfo;
+
+            skinManager.EnsureMutableSkin();
+
+            MemoryStream exportStream = new MemoryStream();
+
+            Guid originalSkinId = skinManager.CurrentSkinInfo.Value.ID;
+
+            skinManager.CurrentSkinInfo.Value.PerformRead(s =>
+            {
+                Assert.IsFalse(s.Protected);
+                Assert.AreEqual(typeof(DefaultLegacySkin), s.CreateInstance(skinManager).GetType());
+
+                new LegacySkinExporter(osu.Dependencies.Get<Storage>()).ExportModelTo(s, exportStream);
+
+                Assert.Greater(exportStream.Length, 0);
+            });
+
+            var imported = skinManager.Import(new ImportTask(exportStream, "exported.osk"));
+
+            imported.Result.PerformRead(s =>
+            {
+                Assert.IsFalse(s.Protected);
+                Assert.AreNotEqual(originalSkinId, s.ID);
+                Assert.AreEqual(typeof(DefaultLegacySkin), s.CreateInstance(skinManager).GetType());
+            });
+
+            return Task.CompletedTask;
+        });
+
         #endregion
 
-        private void assertCorrectMetadata(SkinInfo import1, string name, string creator, OsuGameBase osu)
+        private void assertCorrectMetadata(ILive<SkinInfo> import1, string name, string creator, OsuGameBase osu)
         {
-            Assert.That(import1.Name, Is.EqualTo(name));
-            Assert.That(import1.Creator, Is.EqualTo(creator));
+            import1.PerformRead(i =>
+            {
+                Assert.That(i.Name, Is.EqualTo(name));
+                Assert.That(i.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)));
+                // for extra safety let's reconstruct the skin, reading from the skin.ini.
+                var instance = i.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));
+                Assert.That(instance.Configuration.SkinInfo.Name, Is.EqualTo(name));
+                Assert.That(instance.Configuration.SkinInfo.Creator, Is.EqualTo(creator));
+            });
         }
 
-        private void assertImportedBoth(SkinInfo import1, SkinInfo import2)
+        private void assertImportedBoth(ILive<SkinInfo> import1, ILive<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)));
+            import1.PerformRead(i1 => import2.PerformRead(i2 =>
+            {
+                Assert.That(i2.ID, Is.Not.EqualTo(i1.ID));
+                Assert.That(i2.Hash, Is.Not.EqualTo(i1.Hash));
+                Assert.That(i2.Files.First(), Is.Not.EqualTo(i1.Files.First()));
+            }));
         }
 
-        private void assertImportedOnce(SkinInfo import1, SkinInfo import2)
+        private void assertImportedOnce(ILive<SkinInfo> import1, ILive<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)));
+            import1.PerformRead(i1 => import2.PerformRead(i2 =>
+            {
+                Assert.That(i2.ID, Is.EqualTo(i1.ID));
+                Assert.That(i2.Hash, Is.EqualTo(i1.Hash));
+                Assert.That(i2.Files.First(), Is.EqualTo(i1.Files.First()));
+            }));
         }
 
         private MemoryStream createEmptyOsk()
@@ -255,10 +333,10 @@ namespace osu.Game.Tests.Skins.IO
             }
         }
 
-        private async Task<SkinInfo> loadSkinIntoOsu(OsuGameBase osu, ArchiveReader archive = null)
+        private async Task<ILive<SkinInfo>> loadSkinIntoOsu(OsuGameBase osu, ArchiveReader archive = null)
         {
             var skinManager = osu.Dependencies.Get<SkinManager>();
-            return (await skinManager.Import(archive)).Value;
+            return await skinManager.Import(archive);
         }
     }
 }

osu.Game.Tests/Skins/TestSceneSkinResources.cs

@@ -24,7 +24,7 @@ namespace osu.Game.Tests.Skins
         private void load()
         {
             var imported = skins.Import(new ZipArchiveReader(TestResources.OpenResource("Archives/ogg-skin.osk"))).Result;
-            skin = skins.GetSkin(imported.Value);
+            skin = imported.PerformRead(skinInfo => skins.GetSkin(skinInfo));
         }
 
         [Test]

osu.Game.Tests/Visual/Background/TestSceneBackgroundScreenDefault.cs

@@ -8,6 +8,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Configuration;
+using osu.Game.Database;
 using osu.Game.Graphics.Backgrounds;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
@@ -122,7 +123,7 @@ namespace osu.Game.Tests.Visual.Background
         private void setCustomSkin()
         {
             // feign a skin switch. this doesn't do anything except force CurrentSkin to become a LegacySkin.
-            AddStep("set custom skin", () => skins.CurrentSkinInfo.Value = new SkinInfo { ID = 5 });
+            AddStep("set custom skin", () => skins.CurrentSkinInfo.Value = new SkinInfo().ToLive());
         }
 
         private void setDefaultSkin() => AddStep("set default skin", () => skins.CurrentSkinInfo.SetDefault());

osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapCardDifficultyList.cs

@@ -0,0 +1,71 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Beatmaps.Drawables.Cards;
+using osu.Game.Graphics;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Overlays;
+
+namespace osu.Game.Tests.Visual.Beatmaps
+{
+    public class TestSceneBeatmapCardDifficultyList : OsuTestScene
+    {
+        [Cached]
+        private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            var beatmapSet = new APIBeatmapSet
+            {
+                Beatmaps = new[]
+                {
+                    new APIBeatmap { RulesetID = 1, StarRating = 5.76, DifficultyName = "Oni" },
+                    new APIBeatmap { RulesetID = 1, StarRating = 3.20, DifficultyName = "Muzukashii" },
+                    new APIBeatmap { RulesetID = 1, StarRating = 2.45, DifficultyName = "Futsuu" },
+
+                    new APIBeatmap { RulesetID = 0, StarRating = 2.04, DifficultyName = "Normal" },
+                    new APIBeatmap { RulesetID = 0, StarRating = 3.51, DifficultyName = "Hard" },
+                    new APIBeatmap { RulesetID = 0, StarRating = 5.25, DifficultyName = "Insane" },
+
+                    new APIBeatmap { RulesetID = 2, StarRating = 2.64, DifficultyName = "Salad" },
+                    new APIBeatmap { RulesetID = 2, StarRating = 3.56, DifficultyName = "Platter" },
+                    new APIBeatmap { RulesetID = 2, StarRating = 4.65, DifficultyName = "Rain" },
+
+                    new APIBeatmap { RulesetID = 3, StarRating = 1.93, DifficultyName = "[7K] Normal" },
+                    new APIBeatmap { RulesetID = 3, StarRating = 3.18, DifficultyName = "[7K] Hyper" },
+                    new APIBeatmap { RulesetID = 3, StarRating = 4.82, DifficultyName = "[7K] Another" },
+
+                    new APIBeatmap { RulesetID = 4, StarRating = 9.99, DifficultyName = "Unknown?!" },
+                }
+            };
+
+            Child = new Container
+            {
+                Width = 300,
+                AutoSizeAxes = Axes.Y,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = colourProvider.Background2
+                    },
+                    new Container
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                        Padding = new MarginPadding(10),
+                        Child = new BeatmapCardDifficultyList(beatmapSet)
+                    }
+                }
+            };
+        }
+    }
+}

osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapSkinFallbacks.cs

@@ -12,6 +12,7 @@ using osu.Framework.Testing;
 using osu.Framework.Timing;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Database;
 using osu.Game.Extensions;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
@@ -41,7 +42,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestEmptyLegacyBeatmapSkinFallsBack()
         {
-            CreateSkinTest(SkinInfo.Default, () => new LegacyBeatmapSkin(new BeatmapInfo(), null, null));
+            CreateSkinTest(DefaultSkin.CreateInfo(), () => new LegacyBeatmapSkin(new BeatmapInfo(), null, null));
             AddUntilStep("wait for hud load", () => Player.ChildrenOfType<SkinnableTargetContainer>().All(c => c.ComponentsLoaded));
             AddAssert("hud from default skin", () => AssertComponentsFromExpectedSource(SkinnableTarget.MainHUDComponents, skinManager.CurrentSkin.Value));
         }
@@ -52,7 +53,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             {
                 AddStep("setup skins", () =>
                 {
-                    skinManager.CurrentSkinInfo.Value = gameCurrentSkin;
+                    skinManager.CurrentSkinInfo.Value = gameCurrentSkin.ToLive();
                     currentBeatmapSkin = getBeatmapSkin();
                 });
             });

osu.Game.Tests/Visual/Gameplay/TestSceneReplayRecorder.cs

@@ -43,83 +43,88 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Cached]
         private GameplayState gameplayState = new GameplayState(new Beatmap(), new OsuRuleset(), Array.Empty<Mod>());
 
-        [SetUp]
-        public void SetUp() => Schedule(() =>
+        [SetUpSteps]
+        public void SetUpSteps()
         {
-            replay = new Replay();
+            AddStep("Reset recorder state", cleanUpState);
 
-            Add(new GridContainer
+            AddStep("Setup containers", () =>
             {
-                RelativeSizeAxes = Axes.Both,
-                Content = new[]
+                replay = new Replay();
+
+                Add(new GridContainer
                 {
-                    new Drawable[]
+                    RelativeSizeAxes = Axes.Both,
+                    Content = new[]
                     {
-                        recordingManager = new TestRulesetInputManager(TestSceneModSettings.CreateTestRulesetInfo(), 0, SimultaneousBindingMode.Unique)
+                        new Drawable[]
                         {
-                            Recorder = recorder = new TestReplayRecorder(new Score
+                            recordingManager = new TestRulesetInputManager(TestSceneModSettings.CreateTestRulesetInfo(), 0, SimultaneousBindingMode.Unique)
                             {
-                                Replay = replay,
-                                ScoreInfo = { BeatmapInfo = gameplayState.Beatmap.BeatmapInfo }
-                            })
-                            {
-                                ScreenSpaceToGamefield = pos => recordingManager.ToLocalSpace(pos),
-                            },
-                            Child = new Container
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Children = new Drawable[]
+                                Recorder = recorder = new TestReplayRecorder(new Score
                                 {
-                                    new Box
+                                    Replay = replay,
+                                    ScoreInfo = { BeatmapInfo = gameplayState.Beatmap.BeatmapInfo }
+                                })
+                                {
+                                    ScreenSpaceToGamefield = pos => recordingManager.ToLocalSpace(pos),
+                                },
+                                Child = new Container
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Children = new Drawable[]
                                     {
-                                        Colour = Color4.Brown,
-                                        RelativeSizeAxes = Axes.Both,
-                                    },
-                                    new OsuSpriteText
-                                    {
-                                        Text = "Recording",
-                                        Scale = new Vector2(3),
-                                        Anchor = Anchor.Centre,
-                                        Origin = Anchor.Centre,
-                                    },
-                                    new TestInputConsumer()
-                                }
-                            },
-                        }
-                    },
-                    new Drawable[]
-                    {
-                        playbackManager = new TestRulesetInputManager(TestSceneModSettings.CreateTestRulesetInfo(), 0, SimultaneousBindingMode.Unique)
+                                        new Box
+                                        {
+                                            Colour = Color4.Brown,
+                                            RelativeSizeAxes = Axes.Both,
+                                        },
+                                        new OsuSpriteText
+                                        {
+                                            Text = "Recording",
+                                            Scale = new Vector2(3),
+                                            Anchor = Anchor.Centre,
+                                            Origin = Anchor.Centre,
+                                        },
+                                        new TestInputConsumer()
+                                    }
+                                },
+                            }
+                        },
+                        new Drawable[]
                         {
-                            ReplayInputHandler = new TestFramedReplayInputHandler(replay)
+                            playbackManager = new TestRulesetInputManager(TestSceneModSettings.CreateTestRulesetInfo(), 0, SimultaneousBindingMode.Unique)
                             {
-                                GamefieldToScreenSpace = pos => playbackManager.ToScreenSpace(pos),
-                            },
-                            Child = new Container
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Children = new Drawable[]
+                                ReplayInputHandler = new TestFramedReplayInputHandler(replay)
                                 {
-                                    new Box
+                                    GamefieldToScreenSpace = pos => playbackManager.ToScreenSpace(pos),
+                                },
+                                Child = new Container
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Children = new Drawable[]
                                     {
-                                        Colour = Color4.DarkBlue,
-                                        RelativeSizeAxes = Axes.Both,
-                                    },
-                                    new OsuSpriteText
-                                    {
-                                        Text = "Playback",
-                                        Scale = new Vector2(3),
-                                        Anchor = Anchor.Centre,
-                                        Origin = Anchor.Centre,
-                                    },
-                                    new TestInputConsumer()
-                                }
-                            },
+                                        new Box
+                                        {
+                                            Colour = Color4.DarkBlue,
+                                            RelativeSizeAxes = Axes.Both,
+                                        },
+                                        new OsuSpriteText
+                                        {
+                                            Text = "Playback",
+                                            Scale = new Vector2(3),
+                                            Anchor = Anchor.Centre,
+                                            Origin = Anchor.Centre,
+                                        },
+                                        new TestInputConsumer()
+                                    }
+                                },
+                            }
                         }
                     }
-                }
+                });
             });
-        });
+        }
 
         [Test]
         public void TestBasic()
@@ -184,7 +189,14 @@ namespace osu.Game.Tests.Visual.Gameplay
         [TearDownSteps]
         public void TearDown()
         {
-            AddStep("stop recorder", () => recorder.Expire());
+            AddStep("stop recorder", cleanUpState);
+        }
+
+        private void cleanUpState()
+        {
+            // Ensure previous recorder is disposed else it may affect the global playing state of `SpectatorClient`.
+            recorder?.RemoveAndDisposeImmediately();
+            recorder = null;
         }
 
         public class TestFramedReplayInputHandler : FramedReplayInputHandler<TestReplayFrame>

osu.Game.Tests/Visual/Gameplay/TestSceneReplayRecording.cs

@@ -1,228 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using System.Collections.Generic;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.Bindings;
-using osu.Framework.Input.Events;
-using osu.Framework.Input.StateChanges;
-using osu.Game.Beatmaps;
-using osu.Game.Graphics.Sprites;
-using osu.Game.Replays;
-using osu.Game.Rulesets;
-using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Osu;
-using osu.Game.Rulesets.Replays;
-using osu.Game.Rulesets.UI;
-using osu.Game.Scoring;
-using osu.Game.Screens.Play;
-using osu.Game.Tests.Visual.UserInterface;
-using osuTK;
-using osuTK.Graphics;
-
-namespace osu.Game.Tests.Visual.Gameplay
-{
-    public class TestSceneReplayRecording : OsuTestScene
-    {
-        private readonly TestRulesetInputManager playbackManager;
-
-        private readonly TestRulesetInputManager recordingManager;
-
-        [Cached]
-        private GameplayState gameplayState = new GameplayState(new Beatmap(), new OsuRuleset(), Array.Empty<Mod>());
-
-        public TestSceneReplayRecording()
-        {
-            Replay replay = new Replay();
-
-            Add(new GridContainer
-            {
-                RelativeSizeAxes = Axes.Both,
-                Content = new[]
-                {
-                    new Drawable[]
-                    {
-                        recordingManager = new TestRulesetInputManager(TestSceneModSettings.CreateTestRulesetInfo(), 0, SimultaneousBindingMode.Unique)
-                        {
-                            Recorder = new TestReplayRecorder(new Score
-                            {
-                                Replay = replay,
-                                ScoreInfo = { BeatmapInfo = gameplayState.Beatmap.BeatmapInfo }
-                            })
-                            {
-                                ScreenSpaceToGamefield = pos => recordingManager?.ToLocalSpace(pos) ?? Vector2.Zero,
-                            },
-                            Child = new Container
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Children = new Drawable[]
-                                {
-                                    new Box
-                                    {
-                                        Colour = Color4.Brown,
-                                        RelativeSizeAxes = Axes.Both,
-                                    },
-                                    new OsuSpriteText
-                                    {
-                                        Text = "Recording",
-                                        Scale = new Vector2(3),
-                                        Anchor = Anchor.Centre,
-                                        Origin = Anchor.Centre,
-                                    },
-                                    new TestConsumer()
-                                }
-                            },
-                        }
-                    },
-                    new Drawable[]
-                    {
-                        playbackManager = new TestRulesetInputManager(TestSceneModSettings.CreateTestRulesetInfo(), 0, SimultaneousBindingMode.Unique)
-                        {
-                            ReplayInputHandler = new TestFramedReplayInputHandler(replay)
-                            {
-                                GamefieldToScreenSpace = pos => playbackManager?.ToScreenSpace(pos) ?? Vector2.Zero,
-                            },
-                            Child = new Container
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Children = new Drawable[]
-                                {
-                                    new Box
-                                    {
-                                        Colour = Color4.DarkBlue,
-                                        RelativeSizeAxes = Axes.Both,
-                                    },
-                                    new OsuSpriteText
-                                    {
-                                        Text = "Playback",
-                                        Scale = new Vector2(3),
-                                        Anchor = Anchor.Centre,
-                                        Origin = Anchor.Centre,
-                                    },
-                                    new TestConsumer()
-                                }
-                            },
-                        }
-                    }
-                }
-            });
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-
-            playbackManager.ReplayInputHandler.SetFrameFromTime(Time.Current - 500);
-        }
-    }
-
-    public class TestFramedReplayInputHandler : FramedReplayInputHandler<TestReplayFrame>
-    {
-        public TestFramedReplayInputHandler(Replay replay)
-            : base(replay)
-        {
-        }
-
-        public override void CollectPendingInputs(List<IInput> inputs)
-        {
-            inputs.Add(new MousePositionAbsoluteInput { Position = GamefieldToScreenSpace(CurrentFrame?.Position ?? Vector2.Zero) });
-            inputs.Add(new ReplayState<TestAction> { PressedActions = CurrentFrame?.Actions ?? new List<TestAction>() });
-        }
-    }
-
-    public class TestConsumer : CompositeDrawable, IKeyBindingHandler<TestAction>
-    {
-        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => Parent.ReceivePositionalInputAt(screenSpacePos);
-
-        private readonly Box box;
-
-        public TestConsumer()
-        {
-            Size = new Vector2(30);
-
-            Origin = Anchor.Centre;
-
-            InternalChildren = new Drawable[]
-            {
-                box = new Box
-                {
-                    Colour = Color4.Black,
-                    RelativeSizeAxes = Axes.Both,
-                },
-            };
-        }
-
-        protected override bool OnMouseMove(MouseMoveEvent e)
-        {
-            Position = e.MousePosition;
-            return base.OnMouseMove(e);
-        }
-
-        public bool OnPressed(KeyBindingPressEvent<TestAction> e)
-        {
-            if (e.Repeat)
-                return false;
-
-            box.Colour = Color4.White;
-            return true;
-        }
-
-        public void OnReleased(KeyBindingReleaseEvent<TestAction> e)
-        {
-            box.Colour = Color4.Black;
-        }
-    }
-
-    public class TestRulesetInputManager : RulesetInputManager<TestAction>
-    {
-        public TestRulesetInputManager(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
-            : base(ruleset, variant, unique)
-        {
-        }
-
-        protected override KeyBindingContainer<TestAction> CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
-            => new TestKeyBindingContainer();
-
-        internal class TestKeyBindingContainer : KeyBindingContainer<TestAction>
-        {
-            public override IEnumerable<IKeyBinding> DefaultKeyBindings => new[]
-            {
-                new KeyBinding(InputKey.MouseLeft, TestAction.Down),
-            };
-        }
-    }
-
-    public class TestReplayFrame : ReplayFrame
-    {
-        public Vector2 Position;
-
-        public List<TestAction> Actions = new List<TestAction>();
-
-        public TestReplayFrame(double time, Vector2 position, params TestAction[] actions)
-            : base(time)
-        {
-            Position = position;
-            Actions.AddRange(actions);
-        }
-    }
-
-    public enum TestAction
-    {
-        Down,
-    }
-
-    internal class TestReplayRecorder : ReplayRecorder<TestAction>
-    {
-        public TestReplayRecorder(Score target)
-            : base(target)
-        {
-        }
-
-        protected override ReplayFrame HandleFrame(Vector2 mousePosition, List<TestAction> actions, ReplayFrame previousFrame) =>
-            new TestReplayFrame(Time.Current, mousePosition, actions.ToArray());
-    }
-}

osu.Game.Tests/Visual/Gameplay/TestSceneSkinEditor.cs

@@ -2,12 +2,10 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Testing;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
-using osu.Game.Skinning;
 using osu.Game.Skinning.Editor;
 
 namespace osu.Game.Tests.Visual.Gameplay
@@ -16,9 +14,6 @@ namespace osu.Game.Tests.Visual.Gameplay
     {
         private SkinEditor skinEditor;
 
-        [Resolved]
-        private SkinManager skinManager { get; set; }
-
         protected override bool Autoplay => true;
 
         [SetUpSteps]

osu.Game.Tests/Visual/Gameplay/TestSceneSkinnableHUDOverlay.cs

@@ -10,7 +10,6 @@ using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
-using osu.Game.Configuration;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
@@ -36,9 +35,6 @@ namespace osu.Game.Tests.Visual.Gameplay
         private Drawable hideTarget => hudOverlay.KeyCounter;
         private FillFlowContainer<KeyCounter> keyCounterFlow => hudOverlay.KeyCounter.ChildrenOfType<FillFlowContainer<KeyCounter>>().First();
 
-        [Resolved]
-        private OsuConfigManager config { get; set; }
-
         [Test]
         public void TestComboCounterIncrementing()
         {

osu.Game.Tests/Visual/Gameplay/TestSceneSpectatorPlayback.cs

@@ -51,7 +51,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private TestReplayRecorder recorder;
 
-        private readonly ManualClock manualClock = new ManualClock();
+        private ManualClock manualClock;
 
         private OsuSpriteText latencyDisplay;
 
@@ -66,113 +66,121 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Cached]
         private GameplayState gameplayState = new GameplayState(new Beatmap(), new OsuRuleset(), Array.Empty<Mod>());
 
-        [SetUp]
-        public void SetUp() => Schedule(() =>
+        [SetUpSteps]
+        public void SetUpSteps()
         {
-            replay = new Replay();
+            AddStep("Reset recorder state", cleanUpState);
 
-            users.BindTo(spectatorClient.PlayingUsers);
-            users.BindCollectionChanged((obj, args) =>
+            AddStep("Setup containers", () =>
             {
-                switch (args.Action)
+                replay = new Replay();
+                manualClock = new ManualClock();
+
+                spectatorClient.OnNewFrames += onNewFrames;
+
+                users.BindTo(spectatorClient.PlayingUsers);
+                users.BindCollectionChanged((obj, args) =>
                 {
-                    case NotifyCollectionChangedAction.Add:
-                        Debug.Assert(args.NewItems != null);
-
-                        foreach (int user in args.NewItems)
-                        {
-                            if (user == api.LocalUser.Value.Id)
-                                spectatorClient.WatchUser(user);
-                        }
-
-                        break;
-
-                    case NotifyCollectionChangedAction.Remove:
-                        Debug.Assert(args.OldItems != null);
-
-                        foreach (int user in args.OldItems)
-                        {
-                            if (user == api.LocalUser.Value.Id)
-                                spectatorClient.StopWatchingUser(user);
-                        }
-
-                        break;
-                }
-            }, true);
-
-            spectatorClient.OnNewFrames += onNewFrames;
-
-            Add(new GridContainer
-            {
-                RelativeSizeAxes = Axes.Both,
-                Content = new[]
-                {
-                    new Drawable[]
+                    switch (args.Action)
                     {
-                        recordingManager = new TestRulesetInputManager(TestSceneModSettings.CreateTestRulesetInfo(), 0, SimultaneousBindingMode.Unique)
+                        case NotifyCollectionChangedAction.Add:
+                            Debug.Assert(args.NewItems != null);
+
+                            foreach (int user in args.NewItems)
+                            {
+                                if (user == api.LocalUser.Value.Id)
+                                    spectatorClient.WatchUser(user);
+                            }
+
+                            break;
+
+                        case NotifyCollectionChangedAction.Remove:
+                            Debug.Assert(args.OldItems != null);
+
+                            foreach (int user in args.OldItems)
+                            {
+                                if (user == api.LocalUser.Value.Id)
+                                    spectatorClient.StopWatchingUser(user);
+                            }
+
+                            break;
+                    }
+                }, true);
+
+                Children = new Drawable[]
+                {
+                    new GridContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Content = new[]
                         {
-                            Recorder = recorder = new TestReplayRecorder
+                            new Drawable[]
                             {
-                                ScreenSpaceToGamefield = pos => recordingManager.ToLocalSpace(pos),
-                            },
-                            Child = new Container
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Children = new Drawable[]
+                                recordingManager = new TestRulesetInputManager(TestSceneModSettings.CreateTestRulesetInfo(), 0, SimultaneousBindingMode.Unique)
                                 {
-                                    new Box
+                                    Recorder = recorder = new TestReplayRecorder
+                                    {
+                                        ScreenSpaceToGamefield = pos => recordingManager.ToLocalSpace(pos),
+                                    },
+                                    Child = new Container
                                     {
-                                        Colour = Color4.Brown,
                                         RelativeSizeAxes = Axes.Both,
+                                        Children = new Drawable[]
+                                        {
+                                            new Box
+                                            {
+                                                Colour = Color4.Brown,
+                                                RelativeSizeAxes = Axes.Both,
+                                            },
+                                            new OsuSpriteText
+                                            {
+                                                Text = "Sending",
+                                                Scale = new Vector2(3),
+                                                Anchor = Anchor.Centre,
+                                                Origin = Anchor.Centre,
+                                            },
+                                            new TestInputConsumer()
+                                        }
                                     },
-                                    new OsuSpriteText
-                                    {
-                                        Text = "Sending",
-                                        Scale = new Vector2(3),
-                                        Anchor = Anchor.Centre,
-                                        Origin = Anchor.Centre,
-                                    },
-                                    new TestInputConsumer()
                                 }
                             },
+                            new Drawable[]
+                            {
+                                playbackManager = new TestRulesetInputManager(TestSceneModSettings.CreateTestRulesetInfo(), 0, SimultaneousBindingMode.Unique)
+                                {
+                                    Clock = new FramedClock(manualClock),
+                                    ReplayInputHandler = replayHandler = new TestFramedReplayInputHandler(replay)
+                                    {
+                                        GamefieldToScreenSpace = pos => playbackManager.ToScreenSpace(pos),
+                                    },
+                                    Child = new Container
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                        Children = new Drawable[]
+                                        {
+                                            new Box
+                                            {
+                                                Colour = Color4.DarkBlue,
+                                                RelativeSizeAxes = Axes.Both,
+                                            },
+                                            new OsuSpriteText
+                                            {
+                                                Text = "Receiving",
+                                                Scale = new Vector2(3),
+                                                Anchor = Anchor.Centre,
+                                                Origin = Anchor.Centre,
+                                            },
+                                            new TestInputConsumer()
+                                        }
+                                    },
+                                }
+                            }
                         }
                     },
-                    new Drawable[]
-                    {
-                        playbackManager = new TestRulesetInputManager(TestSceneModSettings.CreateTestRulesetInfo(), 0, SimultaneousBindingMode.Unique)
-                        {
-                            Clock = new FramedClock(manualClock),
-                            ReplayInputHandler = replayHandler = new TestFramedReplayInputHandler(replay)
-                            {
-                                GamefieldToScreenSpace = pos => playbackManager.ToScreenSpace(pos),
-                            },
-                            Child = new Container
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Children = new Drawable[]
-                                {
-                                    new Box
-                                    {
-                                        Colour = Color4.DarkBlue,
-                                        RelativeSizeAxes = Axes.Both,
-                                    },
-                                    new OsuSpriteText
-                                    {
-                                        Text = "Receiving",
-                                        Scale = new Vector2(3),
-                                        Anchor = Anchor.Centre,
-                                        Origin = Anchor.Centre,
-                                    },
-                                    new TestInputConsumer()
-                                }
-                            },
-                        }
-                    }
-                }
+                    latencyDisplay = new OsuSpriteText()
+                };
             });
-
-            Add(latencyDisplay = new OsuSpriteText());
-        });
+        }
 
         private void onNewFrames(int userId, FrameDataBundle frames)
         {
@@ -189,6 +197,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestBasic()
         {
+            AddStep("Wait for user input", () => { });
         }
 
         private double latency = SpectatorClient.TIME_BETWEEN_SENDS;
@@ -232,11 +241,15 @@ namespace osu.Game.Tests.Visual.Gameplay
         [TearDownSteps]
         public void TearDown()
         {
-            AddStep("stop recorder", () =>
-            {
-                recorder.Expire();
-                spectatorClient.OnNewFrames -= onNewFrames;
-            });
+            AddStep("stop recorder", cleanUpState);
+        }
+
+        private void cleanUpState()
+        {
+            // Ensure previous recorder is disposed else it may affect the global playing state of `SpectatorClient`.
+            recorder?.RemoveAndDisposeImmediately();
+            recorder = null;
+            spectatorClient.OnNewFrames -= onNewFrames;
         }
 
         public class TestFramedReplayInputHandler : FramedReplayInputHandler<TestReplayFrame>

osu.Game.Tests/Visual/Menus/TestSceneToolbar.cs

@@ -20,7 +20,7 @@ namespace osu.Game.Tests.Visual.Menus
         private TestToolbar toolbar;
 
         [Resolved]
-        private RulesetStore rulesets { get; set; }
+        private IRulesetStore rulesets { get; set; }
 
         [SetUp]
         public void SetUp() => Schedule(() =>

osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoom.cs

@@ -11,12 +11,14 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
 using osu.Game.Online.Rooms.RoomStatuses;
 using osu.Game.Overlays;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.OnlinePlay.Lounge;
 using osu.Game.Screens.OnlinePlay.Lounge.Components;
+using osu.Game.Screens.OnlinePlay.Match;
 using osu.Game.Tests.Beatmaps;
 using osuTK;
 
@@ -172,6 +174,39 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("password icon hidden", () => Precision.AlmostEquals(0, drawableRoom.ChildrenOfType<DrawableRoom.PasswordProtectedIcon>().Single().Alpha));
         }
 
+        [Test]
+        public void TestMultiplayerRooms()
+        {
+            AddStep("create rooms", () => Child = new FillFlowContainer
+            {
+                AutoSizeAxes = Axes.Y,
+                RelativeSizeAxes = Axes.X,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(5),
+                Children = new[]
+                {
+                    new DrawableMatchRoom(new Room
+                    {
+                        Name = { Value = "A host-only room" },
+                        QueueMode = { Value = QueueMode.HostOnly },
+                        Type = { Value = MatchType.HeadToHead }
+                    }),
+                    new DrawableMatchRoom(new Room
+                    {
+                        Name = { Value = "An all-players, team-versus room" },
+                        QueueMode = { Value = QueueMode.AllPlayers },
+                        Type = { Value = MatchType.TeamVersus }
+                    }),
+                    new DrawableMatchRoom(new Room
+                    {
+                        Name = { Value = "A round-robin room" },
+                        QueueMode = { Value = QueueMode.AllPlayersRoundRobin },
+                        Type = { Value = MatchType.HeadToHead }
+                    }),
+                }
+            });
+        }
+
         private DrawableRoom createLoungeRoom(Room room)
         {
             room.Host.Value ??= new APIUser { Username = "peppy", Id = 2 };

osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoomPlaylist.cs

@@ -17,7 +17,6 @@ using osu.Game.Database;
 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;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
@@ -236,7 +235,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             assertDownloadButtonVisible(false);
 
             void assertDownloadButtonVisible(bool visible) => AddUntilStep($"download button {(visible ? "shown" : "hidden")}",
-                () => playlist.ChildrenOfType<BeatmapPanelDownloadButton>().Single().Alpha == (visible ? 1 : 0));
+                () => playlist.ChildrenOfType<BeatmapDownloadButton>().Single().Alpha == (visible ? 1 : 0));
         }
 
         [Test]
@@ -250,7 +249,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             createPlaylist(byOnlineId, byChecksum);
 
-            AddAssert("download buttons shown", () => playlist.ChildrenOfType<BeatmapPanelDownloadButton>().All(d => d.IsPresent));
+            AddAssert("download buttons shown", () => playlist.ChildrenOfType<BeatmapDownloadButton>().All(d => d.IsPresent));
         }
 
         [Test]

osu.Game.Tests/Visual/Multiplayer/TestSceneMatchBeatmapDetailArea.cs

@@ -2,11 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Game.Beatmaps;
 using osu.Game.Online.Rooms;
-using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.OnlinePlay.Components;
@@ -18,12 +15,6 @@ namespace osu.Game.Tests.Visual.Multiplayer
 {
     public class TestSceneMatchBeatmapDetailArea : OnlinePlayTestScene
     {
-        [Resolved]
-        private BeatmapManager beatmapManager { get; set; }
-
-        [Resolved]
-        private RulesetStore rulesetStore { get; set; }
-
         [SetUp]
         public new void Setup() => Schedule(() =>
         {

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs

@@ -397,6 +397,44 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddUntilStep("user state is idle", () => client.LocalUser?.State == MultiplayerUserState.Idle);
         }
 
+        [Test]
+        public void TestPlayStartsWithCorrectBeatmapWhileAtSongSelect()
+        {
+            createRoom(() => new Room
+            {
+                Name = { Value = "Test Room" },
+                Playlist =
+                {
+                    new PlaylistItem
+                    {
+                        Beatmap = { Value = beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First(b => b.RulesetID == 0)).BeatmapInfo },
+                        Ruleset = { Value = new OsuRuleset().RulesetInfo },
+                    }
+                }
+            });
+
+            AddStep("Enter song select", () =>
+            {
+                var currentSubScreen = ((Screens.OnlinePlay.Multiplayer.Multiplayer)multiplayerScreenStack.CurrentScreen).CurrentSubScreen;
+
+                ((MultiplayerMatchSubScreen)currentSubScreen).SelectBeatmap();
+            });
+
+            AddUntilStep("wait for song select", () => this.ChildrenOfType<MultiplayerMatchSongSelect>().FirstOrDefault()?.BeatmapSetsLoaded == true);
+
+            AddAssert("Beatmap matches current item", () => Beatmap.Value.BeatmapInfo.OnlineID == client.Room?.Playlist.First().BeatmapID);
+
+            AddStep("Select next beatmap", () => InputManager.Key(Key.Down));
+
+            AddUntilStep("Beatmap doesn't match current item", () => Beatmap.Value.BeatmapInfo.OnlineID != client.Room?.Playlist.First().BeatmapID);
+
+            AddStep("start match externally", () => client.StartMatch());
+
+            AddUntilStep("play started", () => multiplayerScreenStack.CurrentScreen is Player);
+
+            AddAssert("Beatmap matches current item", () => Beatmap.Value.BeatmapInfo.OnlineID == client.Room?.Playlist.First().BeatmapID);
+        }
+
         [Test]
         public void TestLocalPlayDoesNotStartWhileSpectatingWithNoBeatmap()
         {

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSongSelect.cs

@@ -144,7 +144,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("set mods", () => SelectedMods.Value = new[] { new TaikoModDoubleTime() });
 
             AddStep("confirm selection", () => songSelect.FinaliseSelection());
-            AddStep("exit song select", () => songSelect.Exit());
+
+            AddUntilStep("song select exited", () => !songSelect.IsCurrentScreen());
 
             AddAssert("beatmap not changed", () => Beatmap.Value.BeatmapInfo.Equals(selectedBeatmap));
             AddAssert("ruleset not changed", () => Ruleset.Value.Equals(new TaikoRuleset().RulesetInfo));

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerPlaylist.cs

@@ -0,0 +1,234 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Graphics;
+using osu.Framework.Platform;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Rooms;
+using osu.Game.Rulesets;
+using osu.Game.Screens.OnlinePlay;
+using osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist;
+using osu.Game.Tests.Beatmaps;
+using osu.Game.Tests.Resources;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public class TestSceneMultiplayerPlaylist : MultiplayerTestScene
+    {
+        private MultiplayerPlaylist list;
+        private BeatmapManager beatmaps;
+        private RulesetStore rulesets;
+        private BeatmapSetInfo importedSet;
+        private BeatmapInfo importedBeatmap;
+
+        [BackgroundDependencyLoader]
+        private void load(GameHost host, AudioManager audio)
+        {
+            Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
+            Dependencies.Cache(beatmaps = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, Resources, host, Beatmap.Default));
+        }
+
+        [SetUp]
+        public new void Setup() => Schedule(() =>
+        {
+            Child = list = new MultiplayerPlaylist
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Both,
+                Size = new Vector2(0.4f, 0.8f)
+            };
+        });
+
+        [SetUpSteps]
+        public new void SetUpSteps()
+        {
+            AddStep("import beatmap", () =>
+            {
+                beatmaps.Import(TestResources.GetQuickTestBeatmapForImport()).Wait();
+                importedSet = beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.All).First();
+                importedBeatmap = importedSet.Beatmaps.First(b => b.RulesetID == 0);
+            });
+
+            AddStep("change to all players mode", () => Client.ChangeSettings(new MultiplayerRoomSettings { QueueMode = QueueMode.AllPlayers }));
+        }
+
+        [Test]
+        public void TestNonExpiredItemsAddedToQueueList()
+        {
+            assertItemInQueueListStep(1, 0);
+
+            addItemStep();
+            assertItemInQueueListStep(2, 1);
+
+            addItemStep();
+            assertItemInQueueListStep(3, 2);
+        }
+
+        [Test]
+        public void TestExpiredItemsAddedToHistoryList()
+        {
+            assertItemInQueueListStep(1, 0);
+
+            addItemStep(true);
+            assertItemInHistoryListStep(2, 0);
+
+            addItemStep(true);
+            assertItemInHistoryListStep(3, 0);
+            assertItemInHistoryListStep(2, 1);
+
+            // Initial item is still in the queue.
+            assertItemInQueueListStep(1, 0);
+        }
+
+        [Test]
+        public void TestExpiredItemsMoveToQueueList()
+        {
+            addItemStep();
+            addItemStep();
+
+            AddStep("finish current item", () => Client.FinishCurrentItem());
+
+            assertItemInHistoryListStep(1, 0);
+            assertItemInQueueListStep(2, 0);
+            assertItemInQueueListStep(3, 1);
+
+            AddStep("finish current item", () => Client.FinishCurrentItem());
+
+            assertItemInHistoryListStep(2, 0);
+            assertItemInHistoryListStep(1, 1);
+            assertItemInQueueListStep(3, 0);
+
+            AddStep("finish current item", () => Client.FinishCurrentItem());
+
+            assertItemInHistoryListStep(3, 0);
+            assertItemInHistoryListStep(2, 1);
+            assertItemInHistoryListStep(1, 2);
+        }
+
+        [Test]
+        public void TestListsClearedWhenRoomLeft()
+        {
+            addItemStep();
+            AddStep("finish current item", () => Client.FinishCurrentItem());
+
+            AddStep("leave room", () => RoomManager.PartRoom());
+            AddUntilStep("wait for room part", () => Client.Room == null);
+
+            AddUntilStep("item 0 not in lists", () => !inHistoryList(0) && !inQueueList(0));
+            AddUntilStep("item 1 not in lists", () => !inHistoryList(0) && !inQueueList(0));
+        }
+
+        [Ignore("Expired items are initially removed from the room.")]
+        [Test]
+        public void TestJoinRoomWithMixedItemsAddedInCorrectLists()
+        {
+            AddStep("leave room", () => RoomManager.PartRoom());
+            AddUntilStep("wait for room part", () => Client.Room == null);
+
+            AddStep("join room with items", () =>
+            {
+                RoomManager.CreateRoom(new Room
+                {
+                    Name = { Value = "test name" },
+                    Playlist =
+                    {
+                        new PlaylistItem
+                        {
+                            Beatmap = { Value = new TestBeatmap(Ruleset.Value).BeatmapInfo },
+                            Ruleset = { Value = Ruleset.Value }
+                        },
+                        new PlaylistItem
+                        {
+                            Beatmap = { Value = new TestBeatmap(Ruleset.Value).BeatmapInfo },
+                            Ruleset = { Value = Ruleset.Value },
+                            Expired = true
+                        }
+                    }
+                });
+            });
+
+            AddUntilStep("wait for room join", () => RoomJoined);
+
+            assertItemInQueueListStep(1, 0);
+            assertItemInHistoryListStep(2, 0);
+        }
+
+        /// <summary>
+        /// Adds a step to create a new playlist item.
+        /// </summary>
+        private void addItemStep(bool expired = false) => AddStep("add item", () => Client.AddPlaylistItem(new MultiplayerPlaylistItem(new PlaylistItem
+        {
+            Beatmap = { Value = importedBeatmap },
+            BeatmapID = importedBeatmap.OnlineID ?? -1,
+            Expired = expired,
+            PlayedAt = DateTimeOffset.Now
+        })));
+
+        /// <summary>
+        /// Asserts the position of a given playlist item in the queue list.
+        /// </summary>
+        /// <param name="playlistItemId">The item id.</param>
+        /// <param name="visualIndex">The index at which the item should appear visually. The item with index 0 is at the top of the list.</param>
+        private void assertItemInQueueListStep(int playlistItemId, int visualIndex)
+        {
+            changeDisplayModeStep(MultiplayerPlaylistDisplayMode.Queue);
+
+            AddUntilStep($"{playlistItemId} in queue at pos = {visualIndex}", () =>
+            {
+                return !inHistoryList(playlistItemId)
+                       && this.ChildrenOfType<MultiplayerQueueList>()
+                              .Single()
+                              .ChildrenOfType<DrawableRoomPlaylistItem>()
+                              .OrderBy(drawable => drawable.Position.Y)
+                              .TakeWhile(drawable => drawable.Item.ID != playlistItemId)
+                              .Count() == visualIndex;
+            });
+        }
+
+        /// <summary>
+        /// Asserts the position of a given playlist item in the history list.
+        /// </summary>
+        /// <param name="playlistItemId">The item id.</param>
+        /// <param name="visualIndex">The index at which the item should appear visually. The item with index 0 is at the top of the list.</param>
+        private void assertItemInHistoryListStep(int playlistItemId, int visualIndex)
+        {
+            changeDisplayModeStep(MultiplayerPlaylistDisplayMode.History);
+
+            AddUntilStep($"{playlistItemId} in history at pos = {visualIndex}", () =>
+            {
+                return !inQueueList(playlistItemId)
+                       && this.ChildrenOfType<MultiplayerHistoryList>()
+                              .Single()
+                              .ChildrenOfType<DrawableRoomPlaylistItem>()
+                              .OrderBy(drawable => drawable.Position.Y)
+                              .TakeWhile(drawable => drawable.Item.ID != playlistItemId)
+                              .Count() == visualIndex;
+            });
+        }
+
+        private void changeDisplayModeStep(MultiplayerPlaylistDisplayMode mode) => AddStep($"change list to {mode}", () => list.DisplayMode.Value = mode);
+
+        private bool inQueueList(int playlistItemId)
+        {
+            return this.ChildrenOfType<MultiplayerQueueList>()
+                       .Single()
+                       .Items.Any(i => i.ID == playlistItemId);
+        }
+
+        private bool inHistoryList(int playlistItemId)
+        {
+            return this.ChildrenOfType<MultiplayerHistoryList>()
+                       .Single()
+                       .Items.Any(i => i.ID == playlistItemId);
+        }
+    }
+}

osu.Game.Tests/Visual/Multiplayer/TestScenePlaylistsSongSelect.cs

@@ -24,9 +24,6 @@ namespace osu.Game.Tests.Visual.Multiplayer
 {
     public class TestScenePlaylistsSongSelect : OnlinePlayTestScene
     {
-        [Resolved]
-        private BeatmapManager beatmapManager { get; set; }
-
         private BeatmapManager manager;
 
         private RulesetStore rulesets;

osu.Game.Tests/Visual/Multiplayer/TestSceneTeamVersus.cs

@@ -11,6 +11,7 @@ using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
 using osu.Game.Online.Rooms;
 using osu.Game.Rulesets;
@@ -118,6 +119,33 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("user still on team 0", () => (client.Room?.Users.FirstOrDefault()?.MatchState as TeamVersusUserState)?.TeamID == 0);
         }
 
+        [Test]
+        public void TestSettingsUpdatedWhenChangingMatchType()
+        {
+            createRoom(() => new Room
+            {
+                Name = { Value = "Test Room" },
+                Type = { Value = MatchType.HeadToHead },
+                Playlist =
+                {
+                    new PlaylistItem
+                    {
+                        Beatmap = { Value = beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First(b => b.RulesetID == 0)).BeatmapInfo },
+                        Ruleset = { Value = new OsuRuleset().RulesetInfo },
+                    }
+                }
+            });
+
+            AddUntilStep("match type head to head", () => client.APIRoom?.Type.Value == MatchType.HeadToHead);
+
+            AddStep("change match type", () => client.ChangeSettings(new MultiplayerRoomSettings
+            {
+                MatchType = MatchType.TeamVersus
+            }));
+
+            AddUntilStep("api room updated to team versus", () => client.APIRoom?.Type.Value == MatchType.TeamVersus);
+        }
+
         [Test]
         public void TestChangeTypeViaMatchSettings()
         {
@@ -152,6 +180,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddUntilStep("wait for room open", () => this.ChildrenOfType<MultiplayerMatchSubScreen>().FirstOrDefault()?.IsLoaded == true);
             AddWaitStep("wait for transition", 2);
 
+            AddUntilStep("create room button enabled", () => this.ChildrenOfType<MultiplayerMatchSettingsOverlay.CreateOrUpdateButton>().Single().Enabled.Value);
             AddStep("create room", () =>
             {
                 InputManager.MoveMouseTo(this.ChildrenOfType<MultiplayerMatchSettingsOverlay.CreateOrUpdateButton>().Single());

osu.Game.Tests/Visual/Navigation/TestSceneEditDefaultSkin.cs

@@ -0,0 +1,39 @@
+// 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.Testing;
+using osu.Game.Overlays.Settings.Sections;
+using osu.Game.Skinning;
+using osu.Game.Skinning.Editor;
+
+namespace osu.Game.Tests.Visual.Navigation
+{
+    public class TestSceneEditDefaultSkin : OsuGameTestScene
+    {
+        private SkinManager skinManager => Game.Dependencies.Get<SkinManager>();
+        private SkinEditorOverlay skinEditor => Game.Dependencies.Get<SkinEditorOverlay>();
+
+        [Test]
+        public void TestEditDefaultSkin()
+        {
+            AddAssert("is default skin", () => skinManager.CurrentSkinInfo.Value.ID == SkinInfo.DEFAULT_SKIN);
+
+            AddStep("open settings", () => { Game.Settings.Show(); });
+
+            // Until step requires as settings has a delayed load.
+            AddUntilStep("export button disabled", () => Game.Settings.ChildrenOfType<SkinSection.ExportSkinButton>().SingleOrDefault()?.Enabled.Value == false);
+
+            // Will create a mutable skin.
+            AddStep("open skin editor", () => skinEditor.Show());
+
+            // Until step required as the skin editor may take time to load (and an extra scheduled frame for the mutable part).
+            AddUntilStep("is modified default skin", () => skinManager.CurrentSkinInfo.Value.ID != SkinInfo.DEFAULT_SKIN);
+            AddAssert("is not protected", () => skinManager.CurrentSkinInfo.Value.PerformRead(s => !s.Protected));
+
+            AddUntilStep("export button enabled", () => Game.Settings.ChildrenOfType<SkinSection.ExportSkinButton>().SingleOrDefault()?.Enabled.Value == true);
+        }
+    }
+}

osu.Game.Tests/Visual/Navigation/TestSceneMouseWheelVolumeAdjust.cs

@@ -0,0 +1,99 @@
+// 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.Configuration;
+using osu.Game.Screens.Play;
+using osu.Game.Tests.Beatmaps.IO;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Navigation
+{
+    public class TestSceneMouseWheelVolumeAdjust : OsuGameTestScene
+    {
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            // Headless tests are always at minimum volume. This covers interactive tests, matching that initial value.
+            AddStep("Set volume to min", () => Game.Audio.Volume.Value = 0);
+            AddAssert("Volume is min", () => Game.Audio.AggregateVolume.Value == 0);
+            AddStep("Move mouse to centre", () => InputManager.MoveMouseTo(Game.ScreenSpaceDrawQuad.Centre));
+        }
+
+        [Test]
+        public void TestAdjustVolumeFromMainMenu()
+        {
+            // First scroll makes volume controls appear, second adjusts volume.
+            AddRepeatStep("Adjust volume using mouse wheel", () => InputManager.ScrollVerticalBy(5), 2);
+            AddUntilStep("Volume is above zero", () => Game.Audio.AggregateVolume.Value > 0);
+        }
+
+        [Test]
+        public void TestAdjustVolumeFromPlayerWheelEnabled()
+        {
+            loadToPlayerNonBreakTime();
+
+            // First scroll makes volume controls appear, second adjusts volume.
+            AddRepeatStep("Adjust volume using mouse wheel", () => InputManager.ScrollVerticalBy(5), 2);
+            AddAssert("Volume is above zero", () => Game.Audio.Volume.Value > 0);
+        }
+
+        [Test]
+        public void TestAdjustVolumeFromPlayerWheelDisabled()
+        {
+            AddStep("disable wheel volume adjust", () => Game.LocalConfig.SetValue(OsuSetting.MouseDisableWheel, true));
+
+            loadToPlayerNonBreakTime();
+
+            // First scroll makes volume controls appear, second adjusts volume.
+            AddRepeatStep("Adjust volume using mouse wheel", () => InputManager.ScrollVerticalBy(5), 2);
+            AddAssert("Volume is still zero", () => Game.Audio.Volume.Value == 0);
+        }
+
+        [Test]
+        public void TestAdjustVolumeFromPlayerWheelDisabledHoldingAlt()
+        {
+            AddStep("disable wheel volume adjust", () => Game.LocalConfig.SetValue(OsuSetting.MouseDisableWheel, true));
+
+            loadToPlayerNonBreakTime();
+
+            // First scroll makes volume controls appear, second adjusts volume.
+            AddRepeatStep("Adjust volume using mouse wheel holding alt", () =>
+            {
+                InputManager.PressKey(Key.AltLeft);
+                InputManager.ScrollVerticalBy(5);
+                InputManager.ReleaseKey(Key.AltLeft);
+            }, 2);
+
+            AddAssert("Volume is above zero", () => Game.Audio.Volume.Value > 0);
+        }
+
+        private void loadToPlayerNonBreakTime()
+        {
+            Player player = null;
+            Screens.Select.SongSelect songSelect = null;
+            PushAndConfirm(() => songSelect = new TestSceneScreenNavigation.TestPlaySongSelect());
+            AddUntilStep("wait for song select", () => songSelect.BeatmapSetsLoaded);
+
+            AddStep("import beatmap", () => ImportBeatmapTest.LoadOszIntoOsu(Game, virtualTrack: true).Wait());
+            AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
+            AddStep("press enter", () => InputManager.Key(Key.Enter));
+
+            AddUntilStep("wait for player", () =>
+            {
+                // dismiss any notifications that may appear (ie. muted notification).
+                clickMouseInCentre();
+                return (player = Game.ScreenStack.CurrentScreen as Player) != null;
+            });
+
+            AddUntilStep("wait for play time active", () => !player.IsBreakTime.Value);
+        }
+
+        private void clickMouseInCentre()
+        {
+            InputManager.MoveMouseTo(Game.ScreenSpaceDrawQuad.Centre);
+            InputManager.Click(MouseButton.Left);
+        }
+    }
+}

osu.Game.Tests/Visual/Navigation/TestSceneOsuGame.cs

@@ -83,9 +83,6 @@ namespace osu.Game.Tests.Visual.Navigation
         [Resolved]
         private OsuGameBase gameBase { get; set; }
 
-        [Resolved]
-        private GameHost host { get; set; }
-
         [Test]
         public void TestNullRulesetHandled()
         {

osu.Game.Tests/Visual/Online/TestSceneBeatmapDownloadButton.cs

@@ -6,15 +6,15 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Drawables;
 using osu.Game.Online;
 using osu.Game.Online.API.Requests.Responses;
-using osu.Game.Overlays.BeatmapListing.Panels;
 using osu.Game.Tests.Resources;
 using osuTK;
 
 namespace osu.Game.Tests.Visual.Online
 {
-    public class TestSceneDirectDownloadButton : OsuTestScene
+    public class TestSceneBeatmapDownloadButton : OsuTestScene
     {
         private TestDownloadButton downloadButton;
 
@@ -137,7 +137,7 @@ namespace osu.Game.Tests.Visual.Online
             return apiBeatmapSet;
         }
 
-        private class TestDownloadButton : BeatmapPanelDownloadButton
+        private class TestDownloadButton : BeatmapDownloadButton
         {
             public new bool DownloadEnabled => base.DownloadEnabled;
 

osu.Game.Tests/Visual/Online/TestSceneBeatmapRulesetSelector.cs

@@ -25,7 +25,7 @@ namespace osu.Game.Tests.Visual.Online
         }
 
         [Resolved]
-        private RulesetStore rulesets { get; set; }
+        private IRulesetStore rulesets { get; set; }
 
         [Test]
         public void TestMultipleRulesetsBeatmapSet()

osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs

@@ -30,7 +30,7 @@ namespace osu.Game.Tests.Visual.Online
         }
 
         [Resolved]
-        private RulesetStore rulesets { get; set; }
+        private IRulesetStore rulesets { get; set; }
 
         [Test]
         public void TestLoading()

osu.Game.Tests/Visual/Online/TestSceneChatOverlay.cs

@@ -13,7 +13,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input;
-using osu.Framework.Platform;
 using osu.Framework.Testing;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
@@ -47,9 +46,6 @@ namespace osu.Game.Tests.Visual.Online
         [CanBeNull]
         private Func<Channel, List<Message>> onGetMessages;
 
-        [Resolved]
-        private GameHost host { get; set; }
-
         public TestSceneChatOverlay()
         {
             channels = Enumerable.Range(1, 10)

osu.Game.Tests/Visual/Online/TestSceneDirectPanel.cs

@@ -1,137 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Collections.Generic;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Audio;
-using osu.Game.Beatmaps;
-using osu.Game.Online.API.Requests.Responses;
-using osu.Game.Overlays.BeatmapListing.Panels;
-using osu.Game.Rulesets;
-using osuTK;
-using APIUser = osu.Game.Online.API.Requests.Responses.APIUser;
-
-namespace osu.Game.Tests.Visual.Online
-{
-    [Cached(typeof(IPreviewTrackOwner))]
-    public class TestSceneDirectPanel : OsuTestScene, IPreviewTrackOwner
-    {
-        [BackgroundDependencyLoader]
-        private void load(RulesetStore rulesets)
-        {
-            var normal = getBeatmapSet();
-            normal.HasVideo = true;
-            normal.HasStoryboard = true;
-
-            var undownloadable = getUndownloadableBeatmapSet();
-            var manyDifficulties = getManyDifficultiesBeatmapSet();
-
-            var explicitMap = getBeatmapSet();
-            explicitMap.HasExplicitContent = true;
-
-            var featuredMap = getBeatmapSet();
-            featuredMap.TrackId = 1;
-
-            var explicitFeaturedMap = getBeatmapSet();
-            explicitFeaturedMap.HasExplicitContent = true;
-            explicitFeaturedMap.TrackId = 2;
-
-            Child = new BasicScrollContainer
-            {
-                RelativeSizeAxes = Axes.Both,
-                Child = new FillFlowContainer
-                {
-                    RelativeSizeAxes = Axes.X,
-                    AutoSizeAxes = Axes.Y,
-                    Direction = FillDirection.Full,
-                    Padding = new MarginPadding(20),
-                    Spacing = new Vector2(5, 20),
-                    Children = new Drawable[]
-                    {
-                        new GridBeatmapPanel(normal),
-                        new GridBeatmapPanel(undownloadable),
-                        new GridBeatmapPanel(manyDifficulties),
-                        new GridBeatmapPanel(explicitMap),
-                        new GridBeatmapPanel(featuredMap),
-                        new GridBeatmapPanel(explicitFeaturedMap),
-                        new ListBeatmapPanel(normal),
-                        new ListBeatmapPanel(undownloadable),
-                        new ListBeatmapPanel(manyDifficulties),
-                        new ListBeatmapPanel(explicitMap),
-                        new ListBeatmapPanel(featuredMap),
-                        new ListBeatmapPanel(explicitFeaturedMap)
-                    },
-                },
-            };
-
-            APIBeatmapSet getBeatmapSet() => CreateAPIBeatmapSet(Ruleset.Value);
-
-            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,
-                    }
-                }
-            };
-
-            APIBeatmapSet getManyDifficultiesBeatmapSet()
-            {
-                var beatmaps = new List<APIBeatmap>();
-
-                for (int i = 0; i < 100; i++)
-                {
-                    beatmaps.Add(new APIBeatmap
-                    {
-                        RulesetID = i % 4,
-                        StarRating = 2 + i % 4 * 2,
-                        OverallDifficulty = 3.5f,
-                    });
-                }
-
-                return new APIBeatmapSet
-                {
-                    OnlineID = 1,
-                    Title = "undownloadable beatmap",
-                    Artist = "test",
-                    Source = "more tests",
-                    Author = new APIUser
-                    {
-                        Username = "BanchoBot",
-                        Id = 3,
-                    },
-                    HasVideo = true,
-                    HasStoryboard = true,
-                    Covers = new BeatmapSetOnlineCovers(),
-                    Beatmaps = beatmaps.ToArray(),
-                };
-            }
-        }
-    }
-}

osu.Game.Tests/Visual/Online/TestSceneUserPanel.cs

@@ -24,7 +24,7 @@ namespace osu.Game.Tests.Visual.Online
         private TestUserListPanel evast;
 
         [Resolved]
-        private RulesetStore rulesetStore { get; set; }
+        private IRulesetStore rulesetStore { get; set; }
 
         [SetUp]
         public void SetUp() => Schedule(() =>

osu.Game.Tests/Visual/Online/TestSceneUserProfileOverlay.cs

@@ -4,8 +4,6 @@
 using System;
 using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Allocation;
-using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Profile;
@@ -20,9 +18,6 @@ namespace osu.Game.Tests.Visual.Online
 
         private readonly TestUserProfileOverlay profile;
 
-        [Resolved]
-        private IAPIProvider api { get; set; }
-
         public static readonly APIUser TEST_USER = new APIUser
         {
             Username = @"Somebody",

osu.Game.Tests/Visual/Ranking/TestSceneContractedPanelMiddleContent.cs

@@ -9,7 +9,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps;
-using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Scoring;
 using osu.Game.Screens.Ranking;
@@ -20,9 +19,6 @@ namespace osu.Game.Tests.Visual.Ranking
 {
     public class TestSceneContractedPanelMiddleContent : OsuTestScene
     {
-        [Resolved]
-        private RulesetStore rulesetStore { get; set; }
-
         [Test]
         public void TestShowPanel()
         {

osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapInfoWedge.cs

@@ -82,7 +82,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
                 beatmaps.Add(testBeatmap);
 
-                AddStep("set ruleset", () => Ruleset.Value = rulesetInfo);
+                setRuleset(rulesetInfo);
 
                 selectBeatmap(testBeatmap);
 
@@ -167,6 +167,22 @@ namespace osu.Game.Tests.Visual.SongSelect
                     label => label.Statistic.Name == "BPM" && label.Statistic.Content == target.ToString(CultureInfo.InvariantCulture)));
         }
 
+        private void setRuleset(RulesetInfo rulesetInfo)
+        {
+            Container containerBefore = null;
+
+            AddStep("set ruleset", () =>
+            {
+                // wedge content is only refreshed if the ruleset changes, so only wait for load in that case.
+                if (!rulesetInfo.Equals(Ruleset.Value))
+                    containerBefore = infoWedge.DisplayedContent;
+
+                Ruleset.Value = rulesetInfo;
+            });
+
+            AddUntilStep("wait for async load", () => infoWedge.DisplayedContent != containerBefore);
+        }
+
         private void selectBeatmap([CanBeNull] IBeatmap b)
         {
             Container containerBefore = null;

osu.Game.Tests/Visual/UserInterface/TestSceneBeatSyncedContainer.cs

@@ -135,6 +135,35 @@ namespace osu.Game.Tests.Visual.UserInterface
             AddAssert("bpm is default", () => lastBpm != null && Precision.AlmostEquals(lastBpm.Value, 60));
         }
 
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestEarlyActivationEffectPoint(bool earlyActivating)
+        {
+            double earlyActivationMilliseconds = earlyActivating ? 100 : 0;
+            ControlPoint actualEffectPoint = null;
+
+            AddStep($"set early activation to {earlyActivationMilliseconds}", () => beatContainer.EarlyActivationMilliseconds = earlyActivationMilliseconds);
+
+            AddStep("seek before kiai effect point", () =>
+            {
+                ControlPoint expectedEffectPoint = Beatmap.Value.Beatmap.ControlPointInfo.EffectPoints.First(ep => ep.KiaiMode);
+                actualEffectPoint = null;
+                beatContainer.AllowMistimedEventFiring = false;
+
+                beatContainer.NewBeat = (i, timingControlPoint, effectControlPoint, channelAmplitudes) =>
+                {
+                    if (Precision.AlmostEquals(gameplayClockContainer.CurrentTime + earlyActivationMilliseconds, expectedEffectPoint.Time, BeatSyncedContainer.MISTIMED_ALLOWANCE))
+                        actualEffectPoint = effectControlPoint;
+                };
+
+                gameplayClockContainer.Seek(expectedEffectPoint.Time - earlyActivationMilliseconds);
+            });
+
+            AddUntilStep("wait for effect point", () => actualEffectPoint != null);
+
+            AddAssert("effect has kiai", () => actualEffectPoint != null && ((EffectControlPoint)actualEffectPoint).KiaiMode);
+        }
+
         private class TestBeatSyncedContainer : BeatSyncedContainer
         {
             private const int flash_layer_height = 150;
@@ -145,6 +174,12 @@ namespace osu.Game.Tests.Visual.UserInterface
                 set => base.AllowMistimedEventFiring = value;
             }
 
+            public new double EarlyActivationMilliseconds
+            {
+                get => base.EarlyActivationMilliseconds;
+                set => base.EarlyActivationMilliseconds = value;
+            }
+
             private readonly InfoString timingPointCount;
             private readonly InfoString currentTimingPoint;
             private readonly InfoString beatCount;

osu.Game.Tests/Visual/UserInterface/TestSceneUpdateableBeatmapBackgroundSprite.cs

@@ -26,9 +26,6 @@ namespace osu.Game.Tests.Visual.UserInterface
         private BeatmapSetInfo testBeatmap;
         private IAPIProvider api;
 
-        [Resolved]
-        private BeatmapManager beatmaps { get; set; }
-
         [BackgroundDependencyLoader]
         private void load(OsuGameBase osu, IAPIProvider api, RulesetStore rulesets)
         {

osu.Game.Tournament.Tests/Components/TestSceneTournamentBeatmapPanel.cs

@@ -6,19 +6,20 @@ using osu.Framework.Graphics;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Online.API.Requests.Responses;
-using osu.Game.Rulesets;
+using osu.Game.Tests.Visual;
 using osu.Game.Tournament.Components;
 
 namespace osu.Game.Tournament.Tests.Components
 {
     public class TestSceneTournamentBeatmapPanel : TournamentTestScene
     {
+        /// <remarks>
+        /// Warning: the below API instance is actually the online API, rather than the dummy API provided by the test.
+        /// It cannot be trivially replaced because setting <see cref="OsuTestScene.UseOnlineAPI"/> to <see langword="true"/> causes <see cref="OsuTestScene.API"/> to no longer be usable.
+        /// </remarks>
         [Resolved]
         private IAPIProvider api { get; set; }
 
-        [Resolved]
-        private RulesetStore rulesets { get; set; }
-
         [BackgroundDependencyLoader]
         private void load()
         {

osu.Game.Tournament.Tests/Components/TestSceneTournamentModDisplay.cs

@@ -19,7 +19,7 @@ namespace osu.Game.Tournament.Tests.Components
         private IAPIProvider api { get; set; }
 
         [Resolved]
-        private RulesetStore rulesets { get; set; }
+        private IRulesetStore rulesets { get; set; }
 
         private FillFlowContainer<TournamentBeatmapPanel> fillFlow;
 

osu.Game.Tournament.Tests/NonVisual/CustomTourneyDirectoryTest.cs

@@ -87,16 +87,16 @@ namespace osu.Game.Tournament.Tests.NonVisual
                 // Recreate the old setup that uses "tournament" as the base path.
                 string oldPath = Path.Combine(osuRoot, "tournament");
 
-                string videosPath = Path.Combine(oldPath, "videos");
-                string modsPath = Path.Combine(oldPath, "mods");
-                string flagsPath = Path.Combine(oldPath, "flags");
+                string videosPath = Path.Combine(oldPath, "Videos");
+                string modsPath = Path.Combine(oldPath, "Mods");
+                string flagsPath = Path.Combine(oldPath, "Flags");
 
                 Directory.CreateDirectory(videosPath);
                 Directory.CreateDirectory(modsPath);
                 Directory.CreateDirectory(flagsPath);
 
                 // Define testing files corresponding to the specific file migrations that are needed
-                string bracketFile = Path.Combine(osuRoot, "bracket.json");
+                string bracketFile = Path.Combine(osuRoot, TournamentGameBase.BRACKET_FILENAME);
 
                 string drawingsConfig = Path.Combine(osuRoot, "drawings.ini");
                 string drawingsFile = Path.Combine(osuRoot, "drawings.txt");
@@ -123,9 +123,9 @@ namespace osu.Game.Tournament.Tests.NonVisual
 
                     string migratedPath = Path.Combine(host.Storage.GetFullPath("."), "tournaments", "default");
 
-                    videosPath = Path.Combine(migratedPath, "videos");
-                    modsPath = Path.Combine(migratedPath, "mods");
-                    flagsPath = Path.Combine(migratedPath, "flags");
+                    videosPath = Path.Combine(migratedPath, "Videos");
+                    modsPath = Path.Combine(migratedPath, "Mods");
+                    flagsPath = Path.Combine(migratedPath, "Flags");
 
                     videoFile = Path.Combine(videosPath, "video.mp4");
                     modFile = Path.Combine(modsPath, "mod.png");
@@ -133,7 +133,7 @@ namespace osu.Game.Tournament.Tests.NonVisual
 
                     Assert.That(storage.GetFullPath("."), Is.EqualTo(migratedPath));
 
-                    Assert.True(storage.Exists("bracket.json"));
+                    Assert.True(storage.Exists(TournamentGameBase.BRACKET_FILENAME));
                     Assert.True(storage.Exists("drawings.txt"));
                     Assert.True(storage.Exists("drawings_results.txt"));
 

osu.Game.Tournament/Components/TournamentModIcon.cs

@@ -21,7 +21,7 @@ namespace osu.Game.Tournament.Components
         private readonly string modAcronym;
 
         [Resolved]
-        private RulesetStore rulesets { get; set; }
+        private IRulesetStore rulesets { get; set; }
 
         public TournamentModIcon(string modAcronym)
         {
@@ -31,7 +31,7 @@ namespace osu.Game.Tournament.Components
         [BackgroundDependencyLoader]
         private void load(TextureStore textures, LadderInfo ladderInfo)
         {
-            var customTexture = textures.Get($"mods/{modAcronym}");
+            var customTexture = textures.Get($"Mods/{modAcronym}");
 
             if (customTexture != null)
             {

osu.Game.Tournament/IO/TournamentStorage.cs

@@ -51,6 +51,23 @@ namespace osu.Game.Tournament.IO
             Logger.Log("Changing tournament storage: " + GetFullPath(string.Empty));
         }
 
+        protected override void ChangeTargetStorage(Storage newStorage)
+        {
+            // due to an unfortunate oversight, on OSes that are sensitive to pathname casing
+            // the custom flags directory needed to be named `Flags` (uppercase),
+            // while custom mods and videos directories needed to be named `mods` and `videos` respectively (lowercase).
+            // to unify handling to uppercase, move any non-compliant directories automatically for the user to migrate.
+            // can be removed 20220528
+            if (newStorage.ExistsDirectory("flags"))
+                AttemptOperation(() => Directory.Move(newStorage.GetFullPath("flags"), newStorage.GetFullPath("Flags")));
+            if (newStorage.ExistsDirectory("mods"))
+                AttemptOperation(() => Directory.Move(newStorage.GetFullPath("mods"), newStorage.GetFullPath("Mods")));
+            if (newStorage.ExistsDirectory("videos"))
+                AttemptOperation(() => Directory.Move(newStorage.GetFullPath("videos"), newStorage.GetFullPath("Videos")));
+
+            base.ChangeTargetStorage(newStorage);
+        }
+
         public IEnumerable<string> ListTournaments() => AllTournaments.GetDirectories(string.Empty);
 
         public override void Migrate(Storage newStorage)
@@ -69,7 +86,7 @@ namespace osu.Game.Tournament.IO
                 DeleteRecursive(source);
             }
 
-            moveFileIfExists("bracket.json", destination);
+            moveFileIfExists(TournamentGameBase.BRACKET_FILENAME, destination);
             moveFileIfExists("drawings.txt", destination);
             moveFileIfExists("drawings_results.txt", destination);
             moveFileIfExists("drawings.ini", destination);

osu.Game.Tournament/IO/TournamentVideoResourceStore.cs

@@ -9,7 +9,7 @@ namespace osu.Game.Tournament.IO
     public class TournamentVideoResourceStore : NamespacedResourceStore<byte[]>
     {
         public TournamentVideoResourceStore(Storage storage)
-            : base(new StorageBackedResourceStore(storage), "videos")
+            : base(new StorageBackedResourceStore(storage), "Videos")
         {
             AddExtension("m4v");
             AddExtension("avi");

osu.Game.Tournament/IPC/FileBasedIPC.cs

@@ -28,7 +28,7 @@ namespace osu.Game.Tournament.IPC
         protected IAPIProvider API { get; private set; }
 
         [Resolved]
-        protected RulesetStore Rulesets { get; private set; }
+        protected IRulesetStore Rulesets { get; private set; }
 
         [Resolved]
         private GameHost host { get; set; }

osu.Game.Tournament/Screens/Editors/SeedingEditorScreen.cs

@@ -25,9 +25,6 @@ namespace osu.Game.Tournament.Screens.Editors
 
         protected override BindableList<SeedingResult> Storage => team.SeedingResults;
 
-        [Resolved(canBeNull: true)]
-        private TournamentSceneManager sceneManager { get; set; }
-
         public SeedingEditorScreen(TournamentTeam team, TournamentScreen parentScreen)
             : base(parentScreen)
         {
@@ -38,9 +35,6 @@ namespace osu.Game.Tournament.Screens.Editors
         {
             public SeedingResult Model { get; }
 
-            [Resolved]
-            private LadderInfo ladderInfo { get; set; }
-
             public SeedingResultRow(TournamentTeam team, SeedingResult round)
             {
                 Model = round;

osu.Game.Tournament/Screens/Setup/StablePathSelectScreen.cs

@@ -21,9 +21,6 @@ namespace osu.Game.Tournament.Screens.Setup
 {
     public class StablePathSelectScreen : TournamentScreen
     {
-        [Resolved]
-        private GameHost host { get; set; }
-
         [Resolved(canBeNull: true)]
         private TournamentSceneManager sceneManager { get; set; }
 

osu.Game.Tournament/Screens/TeamIntro/SeedingScreen.cs

@@ -197,7 +197,7 @@ namespace osu.Game.Tournament.Screens.TeamIntro
                     {
                         row.Add(new Sprite
                         {
-                            Texture = textures.Get($"mods/{mods.ToLower()}"),
+                            Texture = textures.Get($"Mods/{mods.ToLower()}"),
                             Scale = new Vector2(0.5f)
                         });
                     }

osu.Game.Tournament/TournamentGame.cs

@@ -71,7 +71,7 @@ namespace osu.Game.Tournament
                         loadingSpinner.Expire();
 
                         Logger.Error(t.Exception, "Couldn't load bracket with error");
-                        Add(new WarningBox("Your bracket.json file could not be parsed. Please check runtime.log for more details."));
+                        Add(new WarningBox($"Your {BRACKET_FILENAME} file could not be parsed. Please check runtime.log for more details."));
                     });
 
                     return;

osu.Game.Tournament/TournamentGameBase.cs

@@ -11,6 +11,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Input;
 using osu.Framework.IO.Stores;
+using osu.Framework.Logging;
 using osu.Framework.Platform;
 using osu.Game.Graphics;
 using osu.Game.Online.API.Requests;
@@ -26,15 +27,15 @@ namespace osu.Game.Tournament
     [Cached(typeof(TournamentGameBase))]
     public class TournamentGameBase : OsuGameBase
     {
-        private const string bracket_filename = "bracket.json";
+        public const string BRACKET_FILENAME = @"bracket.json";
         private LadderInfo ladder;
         private TournamentStorage storage;
         private DependencyContainer dependencies;
         private FileBasedIPC ipc;
 
-        protected Task BracketLoadTask => taskCompletionSource.Task;
+        protected Task BracketLoadTask => bracketLoadTaskCompletionSource.Task;
 
-        private readonly TaskCompletionSource<bool> taskCompletionSource = new TaskCompletionSource<bool>();
+        private readonly TaskCompletionSource<bool> bracketLoadTaskCompletionSource = new TaskCompletionSource<bool>();
 
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
@@ -71,9 +72,9 @@ namespace osu.Game.Tournament
         {
             try
             {
-                if (storage.Exists(bracket_filename))
+                if (storage.Exists(BRACKET_FILENAME))
                 {
-                    using (Stream stream = storage.GetStream(bracket_filename, FileAccess.Read, FileMode.Open))
+                    using (Stream stream = storage.GetStream(BRACKET_FILENAME, FileAccess.Read, FileMode.Open))
                     using (var sr = new StreamReader(stream))
                         ladder = JsonConvert.DeserializeObject<LadderInfo>(sr.ReadToEnd(), new JsonPointConverter());
                 }
@@ -144,7 +145,7 @@ namespace osu.Game.Tournament
             }
             catch (Exception e)
             {
-                taskCompletionSource.SetException(e);
+                bracketLoadTaskCompletionSource.SetException(e);
                 return;
             }
 
@@ -156,7 +157,7 @@ namespace osu.Game.Tournament
                 dependencies.CacheAs<MatchIPCInfo>(ipc = new FileBasedIPC());
                 Add(ipc);
 
-                taskCompletionSource.SetResult(true);
+                bracketLoadTaskCompletionSource.SetResult(true);
 
                 initialisationText.Expire();
             });
@@ -292,6 +293,12 @@ namespace osu.Game.Tournament
 
         protected virtual void SaveChanges()
         {
+            if (!bracketLoadTaskCompletionSource.Task.IsCompletedSuccessfully)
+            {
+                Logger.Log("Inhibiting bracket save as bracket parsing failed");
+                return;
+            }
+
             foreach (var r in ladder.Rounds)
                 r.Matches = ladder.Matches.Where(p => p.Round.Value == r).Select(p => p.ID).ToList();
 
@@ -309,7 +316,7 @@ namespace osu.Game.Tournament
                     Converters = new JsonConverter[] { new JsonPointConverter() }
                 });
 
-            using (var stream = storage.GetStream(bracket_filename, FileAccess.Write, FileMode.Create))
+            using (var stream = storage.GetStream(BRACKET_FILENAME, FileAccess.Write, FileMode.Create))
             using (var sw = new StreamWriter(stream))
                 sw.Write(serialisedLadder);
         }

osu.Game/Audio/PreviewTrackManager.cs

@@ -18,9 +18,6 @@ namespace osu.Game.Audio
 
         private readonly BindableDouble muteBindable = new BindableDouble();
 
-        [Resolved]
-        private AudioManager audio { get; set; }
-
         private ITrackStore trackStore;
 
         protected TrackManagerPreviewTrack CurrentTrack;

osu.Game/Beatmaps/BeatmapManager.cs

@@ -288,9 +288,9 @@ namespace osu.Game.Beatmaps
 
         #region Implementation of IModelFileManager<in BeatmapSetInfo,in BeatmapSetFileInfo>
 
-        public void ReplaceFile(BeatmapSetInfo model, BeatmapSetFileInfo file, Stream contents, string filename = null)
+        public void ReplaceFile(BeatmapSetInfo model, BeatmapSetFileInfo file, Stream contents)
         {
-            beatmapModelManager.ReplaceFile(model, file, contents, filename);
+            beatmapModelManager.ReplaceFile(model, file, contents);
         }
 
         public void DeleteFile(BeatmapSetInfo model, BeatmapSetFileInfo file)

osu.Game/Beatmaps/DifficultyRecommender.cs

@@ -25,7 +25,7 @@ namespace osu.Game.Beatmaps
         private IAPIProvider api { get; set; }
 
         [Resolved]
-        private RulesetStore rulesets { get; set; }
+        private IRulesetStore rulesets { get; set; }
 
         [Resolved]
         private Bindable<RulesetInfo> ruleset { get; set; }
@@ -35,7 +35,7 @@ namespace osu.Game.Beatmaps
         /// </summary>
         private int? requestedUserId;
 
-        private readonly Dictionary<RulesetInfo, double> recommendedDifficultyMapping = new Dictionary<RulesetInfo, double>();
+        private readonly Dictionary<IRulesetInfo, double> recommendedDifficultyMapping = new Dictionary<IRulesetInfo, double>();
 
         private readonly IBindable<APIState> apiState = new Bindable<APIState>();
 
@@ -101,7 +101,7 @@ namespace osu.Game.Beatmaps
         /// Rulesets ordered descending by their respective recommended difficulties.
         /// The currently selected ruleset will always be first.
         /// </returns>
-        private IEnumerable<RulesetInfo> orderedRulesets
+        private IEnumerable<IRulesetInfo> orderedRulesets
         {
             get
             {

osu.Game/Beatmaps/Drawables/BeatmapDownloadButton.cs

@@ -6,7 +6,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Extensions;
 using osu.Game.Graphics.Containers;
@@ -14,9 +13,9 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Online;
 using osu.Game.Online.API.Requests.Responses;
 
-namespace osu.Game.Overlays.BeatmapListing.Panels
+namespace osu.Game.Beatmaps.Drawables
 {
-    public class BeatmapPanelDownloadButton : CompositeDrawable
+    public class BeatmapDownloadButton : CompositeDrawable
     {
         protected bool DownloadEnabled => button.Enabled.Value;
 
@@ -35,7 +34,7 @@ namespace osu.Game.Overlays.BeatmapListing.Panels
 
         private readonly IBeatmapSetInfo beatmapSet;
 
-        public BeatmapPanelDownloadButton(IBeatmapSetInfo beatmapSet)
+        public BeatmapDownloadButton(IBeatmapSetInfo beatmapSet)
         {
             this.beatmapSet = beatmapSet;
 

osu.Game/Beatmaps/Drawables/Cards/BeatmapCard.cs

@@ -23,7 +23,6 @@ using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osu.Game.Overlays.BeatmapSet;
 using osuTK;
-using osu.Game.Overlays.BeatmapListing.Panels;
 using osu.Game.Resources.Localisation.Web;
 using DownloadButton = osu.Game.Beatmaps.Drawables.Cards.Buttons.DownloadButton;
 

osu.Game/Beatmaps/Drawables/Cards/BeatmapCardDifficultyList.cs

@@ -0,0 +1,103 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Online.Chat;
+using osu.Game.Rulesets;
+using osuTK;
+
+namespace osu.Game.Beatmaps.Drawables.Cards
+{
+    public class BeatmapCardDifficultyList : CompositeDrawable
+    {
+        public BeatmapCardDifficultyList(IBeatmapSetInfo beatmapSetInfo)
+        {
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+
+            FillFlowContainer flow;
+
+            InternalChild = flow = new FillFlowContainer
+            {
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(0, 3)
+            };
+
+            bool firstGroup = true;
+
+            foreach (var group in beatmapSetInfo.Beatmaps.GroupBy(beatmap => beatmap.Ruleset.OnlineID).OrderBy(group => group.Key))
+            {
+                if (!firstGroup)
+                {
+                    flow.Add(Empty().With(s =>
+                    {
+                        s.RelativeSizeAxes = Axes.X;
+                        s.Height = 4;
+                    }));
+                }
+
+                foreach (var difficulty in group.OrderBy(b => b.StarRating))
+                    flow.Add(new BeatmapCardDifficultyRow(difficulty));
+
+                firstGroup = false;
+            }
+        }
+
+        private class BeatmapCardDifficultyRow : CompositeDrawable
+        {
+            private readonly IBeatmapInfo beatmapInfo;
+
+            public BeatmapCardDifficultyRow(IBeatmapInfo beatmapInfo)
+            {
+                this.beatmapInfo = beatmapInfo;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(RulesetStore rulesets)
+            {
+                RelativeSizeAxes = Axes.X;
+                AutoSizeAxes = Axes.Y;
+
+                InternalChild = new FillFlowContainer
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Direction = FillDirection.Horizontal,
+                    Spacing = new Vector2(4, 0),
+                    Children = new[]
+                    {
+                        (rulesets.GetRuleset(beatmapInfo.Ruleset.OnlineID)?.CreateInstance().CreateIcon() ?? new SpriteIcon { Icon = FontAwesome.Regular.QuestionCircle }).With(icon =>
+                        {
+                            icon.Anchor = icon.Origin = Anchor.CentreLeft;
+                            icon.Size = new Vector2(16);
+                        }),
+                        new StarRatingDisplay(new StarDifficulty(beatmapInfo.StarRating, 0), StarRatingDisplaySize.Small)
+                        {
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft
+                        },
+                        new LinkFlowContainer(s =>
+                        {
+                            s.Font = OsuFont.Default.With(size: 14, weight: FontWeight.SemiBold);
+                        }).With(d =>
+                        {
+                            d.AutoSizeAxes = Axes.Both;
+                            d.Anchor = Anchor.CentreLeft;
+                            d.Origin = Anchor.CentreLeft;
+                            d.Padding = new MarginPadding { Bottom = 2 };
+                            d.AddLink(beatmapInfo.DifficultyName, LinkAction.OpenBeatmap, beatmapInfo.OnlineID.ToString());
+                        })
+                    }
+                };
+            }
+        }
+    }
+}

osu.Game/Beatmaps/Drawables/Cards/IconPill.cs

@@ -8,7 +8,7 @@ using osu.Framework.Graphics.Sprites;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Overlays.BeatmapListing.Panels
+namespace osu.Game.Beatmaps.Drawables.Cards
 {
     public class IconPill : CircularContainer
     {

osu.Game/Beatmaps/Drawables/DifficultyIcon.cs

@@ -86,7 +86,7 @@ namespace osu.Game.Beatmaps.Drawables
         }
 
         [Resolved]
-        private RulesetStore rulesets { get; set; }
+        private IRulesetStore rulesets { get; set; }
 
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)

osu.Game/Beatmaps/Drawables/DifficultySpectrumDisplay.cs

@@ -62,7 +62,7 @@ namespace osu.Game.Beatmaps.Drawables
             // matching web: https://github.com/ppy/osu-web/blob/d06d8c5e735eb1f48799b1654b528e9a7afb0a35/resources/assets/lib/beatmapset-panel.tsx#L127
             bool collapsed = beatmapSet.Beatmaps.Count() > 12;
 
-            foreach (var rulesetGrouping in beatmapSet.Beatmaps.GroupBy(beatmap => beatmap.Ruleset.OnlineID))
+            foreach (var rulesetGrouping in beatmapSet.Beatmaps.GroupBy(beatmap => beatmap.Ruleset.OnlineID).OrderBy(group => group.Key))
             {
                 flow.Add(new RulesetDifficultyGroup(rulesetGrouping.Key, rulesetGrouping, collapsed));
             }

osu.Game/Beatmaps/Drawables/DownloadProgressBar.cs

@@ -5,13 +5,12 @@ using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online;
 using osuTK.Graphics;
 
-namespace osu.Game.Overlays.BeatmapListing.Panels
+namespace osu.Game.Beatmaps.Drawables
 {
     public class DownloadProgressBar : CompositeDrawable
     {

osu.Game/Beatmaps/FlatFileWorkingBeatmap.cs

@@ -0,0 +1,52 @@
+// 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.IO;
+using osu.Framework.Audio.Track;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Beatmaps.Formats;
+using osu.Game.IO;
+using osu.Game.Rulesets;
+using osu.Game.Skinning;
+
+namespace osu.Game.Beatmaps
+{
+    /// <summary>
+    /// A <see cref="WorkingBeatmap"/> which can be constructed directly from a .osu file, providing an implementation for
+    /// <see cref="WorkingBeatmap.GetPlayableBeatmap(osu.Game.Rulesets.IRulesetInfo,System.Collections.Generic.IReadOnlyList{osu.Game.Rulesets.Mods.Mod})"/>.
+    /// </summary>
+    public class FlatFileWorkingBeatmap : WorkingBeatmap
+    {
+        private readonly Beatmap beatmap;
+
+        public FlatFileWorkingBeatmap(string file, Func<int, Ruleset> rulesetProvider, int? beatmapId = null)
+            : this(readFromFile(file), rulesetProvider, beatmapId)
+        {
+        }
+
+        private FlatFileWorkingBeatmap(Beatmap beatmap, Func<int, Ruleset> rulesetProvider, int? beatmapId = null)
+            : base(beatmap.BeatmapInfo, null)
+        {
+            this.beatmap = beatmap;
+
+            beatmap.BeatmapInfo.Ruleset = rulesetProvider(beatmap.BeatmapInfo.RulesetID).RulesetInfo;
+
+            if (beatmapId.HasValue)
+                beatmap.BeatmapInfo.OnlineID = beatmapId;
+        }
+
+        private static Beatmap readFromFile(string filename)
+        {
+            using (var stream = File.OpenRead(filename))
+            using (var reader = new LineBufferedReader(stream))
+                return Decoder.GetDecoder<Beatmap>(reader).Decode(reader);
+        }
+
+        protected override IBeatmap GetBeatmap() => beatmap;
+        protected override Texture GetBackground() => throw new NotImplementedException();
+        protected override Track GetBeatmapTrack() => throw new NotImplementedException();
+        protected internal override ISkin GetSkin() => throw new NotImplementedException();
+        public override Stream GetStream(string storagePath) => throw new NotImplementedException();
+    }
+}

osu.Game/Collections/CollectionFilterDropdown.cs

@@ -13,7 +13,6 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
-using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osuTK;
@@ -193,9 +192,6 @@ namespace osu.Game.Collections
             [NotNull]
             protected new CollectionFilterMenuItem Item => ((DropdownMenuItem<CollectionFilterMenuItem>)base.Item).Value;
 
-            [Resolved]
-            private OsuColour colours { get; set; }
-
             [Resolved]
             private IBindable<WorkingBeatmap> beatmap { get; set; }
 

osu.Game/Collections/CollectionManager.cs

@@ -40,9 +40,6 @@ namespace osu.Game.Collections
 
         public readonly BindableList<BeatmapCollection> Collections = new BindableList<BeatmapCollection>();
 
-        [Resolved]
-        private GameHost host { get; set; }
-
         [Resolved]
         private BeatmapManager beatmaps { get; set; }
 

osu.Game/Configuration/OsuConfigManager.cs

@@ -17,6 +17,7 @@ using osu.Game.Overlays;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Filter;
+using osu.Game.Skinning;
 
 namespace osu.Game.Configuration
 {
@@ -27,7 +28,7 @@ namespace osu.Game.Configuration
         {
             // UI/selection defaults
             SetDefault(OsuSetting.Ruleset, string.Empty);
-            SetDefault(OsuSetting.Skin, 0, -1, int.MaxValue);
+            SetDefault(OsuSetting.Skin, SkinInfo.DEFAULT_SKIN.ToString());
 
             SetDefault(OsuSetting.BeatmapDetailTab, PlayBeatmapDetailArea.TabType.Details);
             SetDefault(OsuSetting.BeatmapDetailModsFilter, false);
@@ -210,9 +211,12 @@ namespace osu.Game.Configuration
                         value: scalingMode.GetLocalisableDescription()
                     )
                 ),
-                new TrackedSetting<int>(OsuSetting.Skin, skin =>
+                new TrackedSetting<string>(OsuSetting.Skin, skin =>
                 {
-                    string skinName = LookupSkinName(skin) ?? string.Empty;
+                    string skinName = string.Empty;
+
+                    if (Guid.TryParse(skin, out var id))
+                        skinName = LookupSkinName(id) ?? string.Empty;
 
                     return new SettingDescription(
                         rawValue: skinName,
@@ -233,7 +237,7 @@ namespace osu.Game.Configuration
             };
         }
 
-        public Func<int, string> LookupSkinName { private get; set; }
+        public Func<Guid, string> LookupSkinName { private get; set; }
 
         public Func<GlobalAction, LocalisableString> LookupKeyBindings { get; set; }
     }

osu.Game/Database/ArchiveModelManager.cs

@@ -453,13 +453,12 @@ namespace osu.Game.Database
         /// <param name="model">The item to operate on.</param>
         /// <param name="file">The existing file to be replaced.</param>
         /// <param name="contents">The new file contents.</param>
-        /// <param name="filename">An optional filename for the new file. Will use the previous filename if not specified.</param>
-        public void ReplaceFile(TModel model, TFileModel file, Stream contents, string filename = null)
+        public void ReplaceFile(TModel model, TFileModel file, Stream contents)
         {
             using (ContextFactory.GetForWrite())
             {
                 DeleteFile(model, file);
-                AddFile(model, contents, filename ?? file.Filename);
+                AddFile(model, contents, file.Filename);
             }
         }
 

osu.Game/Database/BeatmapLookupCache.cs

@@ -0,0 +1,149 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+
+namespace osu.Game.Database
+{
+    // This class is based on `UserLookupCache` which is well tested.
+    // If modifications are to be made here, a base abstract implementation should likely be created and shared between the two.
+    public class BeatmapLookupCache : MemoryCachingComponent<int, APIBeatmap>
+    {
+        [Resolved]
+        private IAPIProvider api { get; set; }
+
+        /// <summary>
+        /// Perform an API lookup on the specified beatmap, populating a <see cref="APIBeatmap"/> model.
+        /// </summary>
+        /// <param name="beatmapId">The beatmap to lookup.</param>
+        /// <param name="token">An optional cancellation token.</param>
+        /// <returns>The populated beatmap, or null if the beatmap does not exist or the request could not be satisfied.</returns>
+        [ItemCanBeNull]
+        public Task<APIBeatmap> GetBeatmapAsync(int beatmapId, CancellationToken token = default) => GetAsync(beatmapId, token);
+
+        /// <summary>
+        /// Perform an API lookup on the specified beatmaps, populating a <see cref="APIBeatmap"/> model.
+        /// </summary>
+        /// <param name="beatmapIds">The beatmaps to lookup.</param>
+        /// <param name="token">An optional cancellation token.</param>
+        /// <returns>The populated beatmaps. May include null results for failed retrievals.</returns>
+        public Task<APIBeatmap[]> GetBeatmapsAsync(int[] beatmapIds, CancellationToken token = default)
+        {
+            var beatmapLookupTasks = new List<Task<APIBeatmap>>();
+
+            foreach (int u in beatmapIds)
+            {
+                beatmapLookupTasks.Add(GetBeatmapAsync(u, token).ContinueWith(task =>
+                {
+                    if (!task.IsCompletedSuccessfully)
+                        return null;
+
+                    return task.Result;
+                }, token));
+            }
+
+            return Task.WhenAll(beatmapLookupTasks);
+        }
+
+        protected override async Task<APIBeatmap> ComputeValueAsync(int lookup, CancellationToken token = default)
+            => await queryBeatmap(lookup).ConfigureAwait(false);
+
+        private readonly Queue<(int id, TaskCompletionSource<APIBeatmap>)> pendingBeatmapTasks = new Queue<(int, TaskCompletionSource<APIBeatmap>)>();
+        private Task pendingRequestTask;
+        private readonly object taskAssignmentLock = new object();
+
+        private Task<APIBeatmap> queryBeatmap(int beatmapId)
+        {
+            lock (taskAssignmentLock)
+            {
+                var tcs = new TaskCompletionSource<APIBeatmap>();
+
+                // Add to the queue.
+                pendingBeatmapTasks.Enqueue((beatmapId, tcs));
+
+                // Create a request task if there's not already one.
+                if (pendingRequestTask == null)
+                    createNewTask();
+
+                return tcs.Task;
+            }
+        }
+
+        private void performLookup()
+        {
+            // contains at most 50 unique beatmap IDs from beatmapTasks, which is used to perform the lookup.
+            var beatmapTasks = new Dictionary<int, List<TaskCompletionSource<APIBeatmap>>>();
+
+            // Grab at most 50 unique beatmap IDs from the queue.
+            lock (taskAssignmentLock)
+            {
+                while (pendingBeatmapTasks.Count > 0 && beatmapTasks.Count < 50)
+                {
+                    (int id, TaskCompletionSource<APIBeatmap> task) next = pendingBeatmapTasks.Dequeue();
+
+                    // Perform a secondary check for existence, in case the beatmap was queried in a previous batch.
+                    if (CheckExists(next.id, out var existing))
+                        next.task.SetResult(existing);
+                    else
+                    {
+                        if (beatmapTasks.TryGetValue(next.id, out var tasks))
+                            tasks.Add(next.task);
+                        else
+                            beatmapTasks[next.id] = new List<TaskCompletionSource<APIBeatmap>> { next.task };
+                    }
+                }
+            }
+
+            if (beatmapTasks.Count == 0)
+                return;
+
+            // Query the beatmaps.
+            var request = new GetBeatmapsRequest(beatmapTasks.Keys.ToArray());
+
+            // rather than queueing, we maintain our own single-threaded request stream.
+            // todo: we probably want retry logic here.
+            api.Perform(request);
+
+            // Create a new request task if there's still more beatmaps to query.
+            lock (taskAssignmentLock)
+            {
+                pendingRequestTask = null;
+                if (pendingBeatmapTasks.Count > 0)
+                    createNewTask();
+            }
+
+            List<APIBeatmap> foundBeatmaps = request.Response?.Beatmaps;
+
+            if (foundBeatmaps != null)
+            {
+                foreach (var beatmap in foundBeatmaps)
+                {
+                    if (beatmapTasks.TryGetValue(beatmap.OnlineID, out var tasks))
+                    {
+                        foreach (var task in tasks)
+                            task.SetResult(beatmap);
+
+                        beatmapTasks.Remove(beatmap.OnlineID);
+                    }
+                }
+            }
+
+            // if any tasks remain which were not satisfied, return null.
+            foreach (var tasks in beatmapTasks.Values)
+            {
+                foreach (var task in tasks)
+                    task.SetResult(null);
+            }
+        }
+
+        private void createNewTask() => pendingRequestTask = Task.Run(performLookup);
+    }
+}

osu.Game/Database/EFToRealmMigrator.cs

@@ -0,0 +1,148 @@
+// 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 Microsoft.EntityFrameworkCore;
+using osu.Game.Configuration;
+using osu.Game.Models;
+using osu.Game.Skinning;
+
+#nullable enable
+
+namespace osu.Game.Database
+{
+    internal class EFToRealmMigrator
+    {
+        private readonly DatabaseContextFactory efContextFactory;
+        private readonly RealmContextFactory realmContextFactory;
+        private readonly OsuConfigManager config;
+
+        public EFToRealmMigrator(DatabaseContextFactory efContextFactory, RealmContextFactory realmContextFactory, OsuConfigManager config)
+        {
+            this.efContextFactory = efContextFactory;
+            this.realmContextFactory = realmContextFactory;
+            this.config = config;
+        }
+
+        public void Run()
+        {
+            using (var db = efContextFactory.GetForWrite())
+            {
+                migrateSettings(db);
+                migrateSkins(db);
+            }
+        }
+
+        private void migrateSkins(DatabaseWriteUsage db)
+        {
+            // can be removed 20220530.
+            var existingSkins = db.Context.SkinInfo
+                                  .Include(s => s.Files)
+                                  .ThenInclude(f => f.FileInfo)
+                                  .ToList();
+
+            // previous entries in EF are removed post migration.
+            if (!existingSkins.Any())
+                return;
+
+            var userSkinChoice = config.GetBindable<string>(OsuSetting.Skin);
+            int.TryParse(userSkinChoice.Value, out int userSkinInt);
+
+            switch (userSkinInt)
+            {
+                case EFSkinInfo.DEFAULT_SKIN:
+                    userSkinChoice.Value = SkinInfo.DEFAULT_SKIN.ToString();
+                    break;
+
+                case EFSkinInfo.CLASSIC_SKIN:
+                    userSkinChoice.Value = SkinInfo.CLASSIC_SKIN.ToString();
+                    break;
+            }
+
+            using (var realm = realmContextFactory.CreateContext())
+            using (var transaction = realm.BeginWrite())
+            {
+                // only migrate data if the realm database is empty.
+                // note that this cannot be written as: `realm.All<SkinInfo>().All(s => s.Protected)`, because realm does not support `.All()`.
+                if (!realm.All<SkinInfo>().Any(s => !s.Protected))
+                {
+                    foreach (var skin in existingSkins)
+                    {
+                        var realmSkin = new SkinInfo
+                        {
+                            Name = skin.Name,
+                            Creator = skin.Creator,
+                            Hash = skin.Hash,
+                            Protected = false,
+                            InstantiationInfo = skin.InstantiationInfo,
+                        };
+
+                        foreach (var file in skin.Files)
+                        {
+                            var realmFile = realm.Find<RealmFile>(file.FileInfo.Hash);
+
+                            if (realmFile == null)
+                                realm.Add(realmFile = new RealmFile { Hash = file.FileInfo.Hash });
+
+                            realmSkin.Files.Add(new RealmNamedFileUsage(realmFile, file.Filename));
+                        }
+
+                        realm.Add(realmSkin);
+
+                        if (skin.ID == userSkinInt)
+                            userSkinChoice.Value = realmSkin.ID.ToString();
+                    }
+                }
+
+                db.Context.RemoveRange(existingSkins);
+                // Intentionally don't clean up the files, so they don't get purged by EF.
+
+                transaction.Commit();
+            }
+        }
+
+        private void migrateSettings(DatabaseWriteUsage db)
+        {
+            // migrate ruleset settings. can be removed 20220315.
+            var existingSettings = db.Context.DatabasedSetting;
+
+            // previous entries in EF are removed post migration.
+            if (!existingSettings.Any())
+                return;
+
+            using (var realm = realmContextFactory.CreateContext())
+            using (var transaction = realm.BeginWrite())
+            {
+                // only migrate data if the realm database is empty.
+                if (!realm.All<RealmRulesetSetting>().Any())
+                {
+                    foreach (var dkb in existingSettings)
+                    {
+                        if (dkb.RulesetID == null)
+                            continue;
+
+                        string? shortName = getRulesetShortNameFromLegacyID(dkb.RulesetID.Value);
+
+                        if (string.IsNullOrEmpty(shortName))
+                            continue;
+
+                        realm.Add(new RealmRulesetSetting
+                        {
+                            Key = dkb.Key,
+                            Value = dkb.StringValue,
+                            RulesetName = shortName,
+                            Variant = dkb.Variant ?? 0,
+                        });
+                    }
+                }
+
+                db.Context.RemoveRange(existingSettings);
+
+                transaction.Commit();
+            }
+        }
+
+        private string? getRulesetShortNameFromLegacyID(long rulesetId) =>
+            efContextFactory.Get().RulesetInfo.FirstOrDefault(r => r.ID == rulesetId)?.ShortName;
+    }
+}

osu.Game/Database/ILive.cs

@@ -38,10 +38,10 @@ namespace osu.Game.Database
         bool IsManaged { get; }
 
         /// <summary>
-        /// Resolve the value of this instance on the current thread's context.
+        /// Resolve the value of this instance on the update thread.
         /// </summary>
         /// <remarks>
-        /// After resolving the data should not be passed between threads.
+        /// After resolving, the data should not be passed between threads.
         /// </remarks>
         T Value { get; }
     }

osu.Game/Database/IModelFileManager.cs

@@ -15,8 +15,7 @@ namespace osu.Game.Database
         /// <param name="model">The item to operate on.</param>
         /// <param name="file">The existing file to be replaced.</param>
         /// <param name="contents">The new file contents.</param>
-        /// <param name="filename">An optional filename for the new file. Will use the previous filename if not specified.</param>
-        void ReplaceFile(TModel model, TFileModel file, Stream contents, string filename = null);
+        void ReplaceFile(TModel model, TFileModel file, Stream contents);
 
         /// <summary>
         /// Delete an existing file.
@@ -26,7 +25,7 @@ namespace osu.Game.Database
         void DeleteFile(TModel model, TFileModel file);
 
         /// <summary>
-        /// Add a new file.
+        /// Add a new file. If the file already exists, it is overwritten.
         /// </summary>
         /// <param name="model">The item to operate on.</param>
         /// <param name="contents">The new file contents.</param>

osu.Game/Database/OsuDbContext.cs

@@ -25,7 +25,7 @@ namespace osu.Game.Database
         public DbSet<BeatmapSetInfo> BeatmapSetInfo { get; set; }
         public DbSet<FileInfo> FileInfo { get; set; }
         public DbSet<RulesetInfo> RulesetInfo { get; set; }
-        public DbSet<SkinInfo> SkinInfo { get; set; }
+        public DbSet<EFSkinInfo> SkinInfo { get; set; }
         public DbSet<ScoreInfo> ScoreInfo { get; set; }
 
         // migrated to realm
@@ -133,8 +133,9 @@ namespace osu.Game.Database
             modelBuilder.Entity<BeatmapSetInfo>().HasIndex(b => b.DeletePending);
             modelBuilder.Entity<BeatmapSetInfo>().HasIndex(b => b.Hash).IsUnique();
 
-            modelBuilder.Entity<SkinInfo>().HasIndex(b => b.Hash).IsUnique();
-            modelBuilder.Entity<SkinInfo>().HasIndex(b => b.DeletePending);
+            modelBuilder.Entity<EFSkinInfo>().HasIndex(b => b.Hash).IsUnique();
+            modelBuilder.Entity<EFSkinInfo>().HasIndex(b => b.DeletePending);
+            modelBuilder.Entity<EFSkinInfo>().HasMany(s => s.Files).WithOne(f => f.SkinInfo);
 
             modelBuilder.Entity<DatabasedSetting>().HasIndex(b => new { b.RulesetID, b.Variant });
 

osu.Game/Database/RealmContextFactory.cs

@@ -14,6 +14,7 @@ using osu.Framework.Statistics;
 using osu.Game.Configuration;
 using osu.Game.Input.Bindings;
 using osu.Game.Models;
+using osu.Game.Skinning;
 using osu.Game.Stores;
 using Realms;
 
@@ -52,6 +53,8 @@ namespace osu.Game.Database
         /// </summary>
         private readonly SemaphoreSlim contextCreationLock = new SemaphoreSlim(1);
 
+        private readonly ThreadLocal<bool> currentThreadCanCreateContexts = new ThreadLocal<bool>();
+
         private static readonly GlobalStatistic<int> refreshes = GlobalStatistics.Get<int>(@"Realm", @"Dirty Refreshes");
         private static readonly GlobalStatistic<int> contexts_created = GlobalStatistics.Get<int>(@"Realm", @"Contexts (Created)");
 
@@ -99,10 +102,6 @@ namespace osu.Game.Database
 
             // This method triggers the first `CreateContext` call, which will implicitly run realm migrations and bring the schema up-to-date.
             cleanupPendingDeletions();
-
-            // Data migration is handled separately from schema migrations.
-            // This is required as the user may be initialising realm for the first time ever, which would result in no schema migrations running.
-            migrateDataFromEF();
         }
 
         private void cleanupPendingDeletions()
@@ -120,6 +119,11 @@ namespace osu.Game.Database
                     realm.Remove(s);
                 }
 
+                var pendingDeleteSkins = realm.All<SkinInfo>().Where(s => s.DeletePending);
+
+                foreach (var s in pendingDeleteSkins)
+                    realm.Remove(s);
+
                 transaction.Commit();
             }
 
@@ -151,9 +155,22 @@ namespace osu.Game.Database
             if (isDisposed)
                 throw new ObjectDisposedException(nameof(RealmContextFactory));
 
+            bool tookSemaphoreLock = false;
+
             try
             {
-                contextCreationLock.Wait();
+                if (!currentThreadCanCreateContexts.Value)
+                {
+                    contextCreationLock.Wait();
+                    currentThreadCanCreateContexts.Value = true;
+                    tookSemaphoreLock = true;
+                }
+                else
+                {
+                    // the semaphore is used to handle blocking of all context creation during certain periods.
+                    // once the semaphore has been taken by this code section, it is safe to create further contexts on the same thread.
+                    // this can happen if a realm subscription is active and triggers a callback which has user code that calls `CreateContext`.
+                }
 
                 contexts_created.Value++;
 
@@ -161,7 +178,11 @@ namespace osu.Game.Database
             }
             finally
             {
-                contextCreationLock.Release();
+                if (tookSemaphoreLock)
+                {
+                    contextCreationLock.Release();
+                    currentThreadCanCreateContexts.Value = false;
+                }
             }
         }
 
@@ -174,53 +195,6 @@ namespace osu.Game.Database
             };
         }
 
-        private void migrateDataFromEF()
-        {
-            if (efContextFactory == null)
-                return;
-
-            using (var db = efContextFactory.GetForWrite())
-            {
-                // migrate ruleset settings. can be removed 20220315.
-                var existingSettings = db.Context.DatabasedSetting;
-
-                // previous entries in EF are removed post migration.
-                if (!existingSettings.Any())
-                    return;
-
-                using (var realm = CreateContext())
-                using (var transaction = realm.BeginWrite())
-                {
-                    // only migrate data if the realm database is empty.
-                    if (!realm.All<RealmRulesetSetting>().Any())
-                    {
-                        foreach (var dkb in existingSettings)
-                        {
-                            if (dkb.RulesetID == null)
-                                continue;
-
-                            string? shortName = getRulesetShortNameFromLegacyID(dkb.RulesetID.Value);
-
-                            if (string.IsNullOrEmpty(shortName))
-                                continue;
-
-                            realm.Add(new RealmRulesetSetting
-                            {
-                                Key = dkb.Key,
-                                Value = dkb.StringValue,
-                                RulesetName = shortName,
-                                Variant = dkb.Variant ?? 0,
-                            });
-                        }
-                    }
-
-                    db.Context.RemoveRange(existingSettings);
-
-                    transaction.Commit();
-                }
-            }
-        }
-
         private void onMigration(Migration migration, ulong lastSchemaVersion)
         {
             for (ulong i = lastSchemaVersion + 1; i <= schema_version; i++)
@@ -307,6 +281,9 @@ namespace osu.Game.Database
                 case 10:
                     string rulesetSettingClassName = getMappedOrOriginalName(typeof(RealmRulesetSetting));
 
+                    if (!migration.OldRealm.Schema.TryFindObjectSchema(rulesetSettingClassName, out _))
+                        return;
+
                     var oldSettings = migration.OldRealm.DynamicApi.All(rulesetSettingClassName);
                     var newSettings = migration.NewRealm.All<RealmRulesetSetting>().ToList();
 
@@ -329,6 +306,9 @@ namespace osu.Game.Database
                 case 11:
                     string keyBindingClassName = getMappedOrOriginalName(typeof(RealmKeyBinding));
 
+                    if (!migration.OldRealm.Schema.TryFindObjectSchema(keyBindingClassName, out _))
+                        return;
+
                     var oldKeyBindings = migration.OldRealm.DynamicApi.All(keyBindingClassName);
                     var newKeyBindings = migration.NewRealm.All<RealmKeyBinding>().ToList();
 

osu.Game/Database/RealmLive.cs

@@ -2,7 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Threading;
+using osu.Framework.Development;
 using Realms;
 
 #nullable enable
@@ -17,10 +17,7 @@ namespace osu.Game.Database
     {
         public Guid ID { get; }
 
-        public bool IsManaged { get; }
-
-        private readonly SynchronizationContext? fetchedContext;
-        private readonly int fetchedThreadId;
+        public bool IsManaged => data.IsManaged;
 
         /// <summary>
         /// The original live data used to create this instance.
@@ -35,14 +32,6 @@ namespace osu.Game.Database
         {
             this.data = data;
 
-            if (data.IsManaged)
-            {
-                IsManaged = true;
-
-                fetchedContext = SynchronizationContext.Current;
-                fetchedThreadId = Thread.CurrentThread.ManagedThreadId;
-            }
-
             ID = data.ID;
         }
 
@@ -52,7 +41,7 @@ namespace osu.Game.Database
         /// <param name="perform">The action to perform.</param>
         public void PerformRead(Action<T> perform)
         {
-            if (originalDataValid)
+            if (!IsManaged)
             {
                 perform(data);
                 return;
@@ -71,7 +60,7 @@ namespace osu.Game.Database
             if (typeof(RealmObjectBase).IsAssignableFrom(typeof(TReturn)))
                 throw new InvalidOperationException($"Realm live objects should not exit the scope of {nameof(PerformRead)}.");
 
-            if (originalDataValid)
+            if (!IsManaged)
                 return perform(data);
 
             using (var realm = Realm.GetInstance(data.Realm.Config))
@@ -99,27 +88,22 @@ namespace osu.Game.Database
         {
             get
             {
-                if (originalDataValid)
+                if (!IsManaged)
                     return data;
 
-                T retrieved;
+                if (!ThreadSafety.IsUpdateThread)
+                    throw new InvalidOperationException($"Can't use {nameof(Value)} on managed objects from non-update threads");
 
-                using (var realm = Realm.GetInstance(data.Realm.Config))
-                    retrieved = realm.Find<T>(ID);
+                // When using Value, we rely on garbage collection for the realm instance used to retrieve the instance.
+                // As we are sure that this is on the update thread, there should always be an open and constantly refreshing realm instance to ensure file size growth is a non-issue.
+                var realm = Realm.GetInstance(data.Realm.Config);
 
-                if (!retrieved.IsValid)
-                    throw new InvalidOperationException("Attempted to access value without an open context");
-
-                return retrieved;
+                return realm.Find<T>(ID);
             }
         }
 
-        private bool originalDataValid => !IsManaged || (isCorrectThread && data.IsValid);
-
-        // this matches realm's internal thread validation (see https://github.com/realm/realm-dotnet/blob/903b4d0b304f887e37e2d905384fb572a6496e70/Realm/Realm/Native/SynchronizationContextScheduler.cs#L72)
-        private bool isCorrectThread
-            => (fetchedContext != null && SynchronizationContext.Current == fetchedContext) || fetchedThreadId == Thread.CurrentThread.ManagedThreadId;
-
         public bool Equals(ILive<T>? other) => ID == other?.ID;
+
+        public override string ToString() => PerformRead(i => i.ToString());
     }
 }

osu.Game/Database/RealmObjectExtensions.cs

@@ -1,12 +1,16 @@
 // 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 AutoMapper;
+using osu.Framework.Development;
 using osu.Game.Input.Bindings;
 using Realms;
 
+#nullable enable
+
 namespace osu.Game.Database
 {
     public static class RealmObjectExtensions
@@ -49,16 +53,120 @@ namespace osu.Game.Database
             return mapper.Map<T>(item);
         }
 
-        public static List<RealmLive<T>> ToLive<T>(this IEnumerable<T> realmList)
+        public static List<ILive<T>> ToLive<T>(this IEnumerable<T> realmList)
             where T : RealmObject, IHasGuidPrimaryKey
         {
-            return realmList.Select(l => new RealmLive<T>(l)).ToList();
+            return realmList.Select(l => new RealmLive<T>(l)).Cast<ILive<T>>().ToList();
         }
 
-        public static RealmLive<T> ToLive<T>(this T realmObject)
+        public static ILive<T> ToLive<T>(this T realmObject)
             where T : RealmObject, IHasGuidPrimaryKey
         {
             return new RealmLive<T>(realmObject);
         }
+
+        /// <summary>
+        /// Register a callback to be invoked each time this <see cref="T:Realms.IRealmCollection`1" /> changes.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// This adds osu! specific thread and managed state safety checks on top of <see cref="IRealmCollection{T}.SubscribeForNotifications"/>.
+        /// </para>
+        /// <para>
+        /// The first callback will be invoked with the initial <see cref="T:Realms.IRealmCollection`1" /> after the asynchronous query completes,
+        /// and then called again after each write transaction which changes either any of the objects in the collection, or
+        /// which objects are in the collection. The <c>changes</c> parameter will
+        /// be <c>null</c> the first time the callback is invoked with the initial results. For each call after that,
+        /// it will contain information about which rows in the results were added, removed or modified.
+        /// </para>
+        /// <para>
+        /// If a write transaction did not modify any objects in this <see cref="T:Realms.IRealmCollection`1" />, the callback is not invoked at all.
+        /// If an error occurs the callback will be invoked with <c>null</c> for the <c>sender</c> parameter and a non-<c>null</c> <c>error</c>.
+        /// Currently the only errors that can occur are when opening the <see cref="T:Realms.Realm" /> on the background worker thread.
+        /// </para>
+        /// <para>
+        /// At the time when the block is called, the <see cref="T:Realms.IRealmCollection`1" /> object will be fully evaluated
+        /// and up-to-date, and as long as you do not perform a write transaction on the same thread
+        /// or explicitly call <see cref="M:Realms.Realm.Refresh" />, accessing it will never perform blocking work.
+        /// </para>
+        /// <para>
+        /// Notifications are delivered via the standard event loop, and so can't be delivered while the event loop is blocked by other activity.
+        /// When notifications can't be delivered instantly, multiple notifications may be coalesced into a single notification.
+        /// This can include the notification with the initial collection.
+        /// </para>
+        /// </remarks>
+        /// <param name="collection">The <see cref="IRealmCollection{T}"/> to observe for changes.</param>
+        /// <param name="callback">The callback to be invoked with the updated <see cref="T:Realms.IRealmCollection`1" />.</param>
+        /// <returns>
+        /// A subscription token. It must be kept alive for as long as you want to receive change notifications.
+        /// To stop receiving notifications, call <see cref="M:System.IDisposable.Dispose" />.
+        ///
+        /// May be null in the case the provided collection is not managed.
+        /// </returns>
+        /// <seealso cref="M:Realms.CollectionExtensions.SubscribeForNotifications``1(System.Collections.Generic.IList{``0},Realms.NotificationCallbackDelegate{``0})" />
+        /// <seealso cref="M:Realms.CollectionExtensions.SubscribeForNotifications``1(System.Linq.IQueryable{``0},Realms.NotificationCallbackDelegate{``0})" />
+        public static IDisposable? QueryAsyncWithNotifications<T>(this IRealmCollection<T> collection, NotificationCallbackDelegate<T> callback)
+            where T : RealmObjectBase
+        {
+            // Subscriptions can only work on the main thread.
+            if (!ThreadSafety.IsUpdateThread)
+                throw new InvalidOperationException("Cannot subscribe for realm notifications from a non-update thread.");
+
+            return collection.SubscribeForNotifications(callback);
+        }
+
+        /// <summary>
+        /// A convenience method that casts <see cref="IQueryable{T}"/> to <see cref="IRealmCollection{T}"/> and subscribes for change notifications.
+        /// </summary>
+        /// <remarks>
+        /// This adds osu! specific thread and managed state safety checks on top of <see cref="IRealmCollection{T}.SubscribeForNotifications"/>.
+        /// </remarks>
+        /// <param name="list">The <see cref="IQueryable{T}"/> to observe for changes.</param>
+        /// <typeparam name="T">Type of the elements in the list.</typeparam>
+        /// <seealso cref="IRealmCollection{T}.SubscribeForNotifications"/>
+        /// <param name="callback">The callback to be invoked with the updated <see cref="IRealmCollection{T}"/>.</param>
+        /// <returns>
+        /// A subscription token. It must be kept alive for as long as you want to receive change notifications.
+        /// To stop receiving notifications, call <see cref="IDisposable.Dispose"/>.
+        ///
+        /// May be null in the case the provided collection is not managed.
+        /// </returns>
+        public static IDisposable? QueryAsyncWithNotifications<T>(this IQueryable<T> list, NotificationCallbackDelegate<T> callback)
+            where T : RealmObjectBase
+        {
+            // Subscribing to non-managed instances doesn't work.
+            // In this usage, the instance may be non-managed in tests.
+            if (!(list is IRealmCollection<T> realmCollection))
+                return null;
+
+            return QueryAsyncWithNotifications(realmCollection, callback);
+        }
+
+        /// <summary>
+        /// A convenience method that casts <see cref="IList{T}"/> to <see cref="IRealmCollection{T}"/> and subscribes for change notifications.
+        /// </summary>
+        /// <remarks>
+        /// This adds osu! specific thread and managed state safety checks on top of <see cref="IRealmCollection{T}.SubscribeForNotifications"/>.
+        /// </remarks>
+        /// <param name="list">The <see cref="IList{T}"/> to observe for changes.</param>
+        /// <typeparam name="T">Type of the elements in the list.</typeparam>
+        /// <seealso cref="IRealmCollection{T}.SubscribeForNotifications"/>
+        /// <param name="callback">The callback to be invoked with the updated <see cref="IRealmCollection{T}"/>.</param>
+        /// <returns>
+        /// A subscription token. It must be kept alive for as long as you want to receive change notifications.
+        /// To stop receiving notifications, call <see cref="IDisposable.Dispose"/>.
+        ///
+        /// May be null in the case the provided collection is not managed.
+        /// </returns>
+        public static IDisposable? QueryAsyncWithNotifications<T>(this IList<T> list, NotificationCallbackDelegate<T> callback)
+            where T : RealmObjectBase
+        {
+            // Subscribing to non-managed instances doesn't work.
+            // In this usage, the instance may be non-managed in tests.
+            if (!(list is IRealmCollection<T> realmCollection))
+                return null;
+
+            return QueryAsyncWithNotifications(realmCollection, callback);
+        }
     }
 }

osu.Game/Database/UserLookupCache.cs

@@ -100,6 +100,9 @@ namespace osu.Game.Database
                 }
             }
 
+            if (userTasks.Count == 0)
+                return;
+
             // Query the users.
             var request = new GetUsersRequest(userTasks.Keys.ToArray());
 

osu.Game/Graphics/Containers/BeatSyncedContainer.cs

@@ -111,7 +111,7 @@ namespace osu.Game.Graphics.Containers
             if (clock == null)
                 return;
 
-            double currentTrackTime = clock.CurrentTime;
+            double currentTrackTime = clock.CurrentTime + EarlyActivationMilliseconds;
 
             if (Beatmap.Value.TrackLoaded && Beatmap.Value.BeatmapLoaded)
             {
@@ -132,13 +132,11 @@ namespace osu.Game.Graphics.Containers
             {
                 // this may be the case where the beat syncing clock has been paused.
                 // we still want to show an idle animation, so use this container's time instead.
-                currentTrackTime = Clock.CurrentTime;
+                currentTrackTime = Clock.CurrentTime + EarlyActivationMilliseconds;
                 timingPoint = TimingControlPoint.DEFAULT;
                 effectPoint = EffectControlPoint.DEFAULT;
             }
 
-            currentTrackTime += EarlyActivationMilliseconds;
-
             double beatLength = timingPoint.BeatLength / Divisor;
 
             while (beatLength < MinimumBeatLength)

osu.Game/Graphics/UserInterface/OsuTabDropdown.cs

@@ -66,7 +66,7 @@ namespace osu.Game.Graphics.UserInterface
                 Origin = Anchor.TopRight;
 
                 BackgroundColour = Color4.Black.Opacity(0.7f);
-                MaxHeight = 400;
+                MaxHeight = 200;
             }
 
             protected override DrawableDropdownMenuItem CreateDrawableDropdownMenuItem(MenuItem item) => new DrawableOsuTabDropdownMenuItem(item);

osu.Game/IPC/ArchiveImportIPCChannel.cs

@@ -18,6 +18,7 @@ namespace osu.Game.IPC
             : base(host)
         {
             this.importer = importer;
+
             MessageReceived += msg =>
             {
                 Debug.Assert(importer != null);
@@ -25,6 +26,8 @@ namespace osu.Game.IPC
                 {
                     if (t.Exception != null) throw t.Exception;
                 }, TaskContinuationOptions.OnlyOnFaulted);
+
+                return null;
             };
         }
 

osu.Game/Input/Bindings/DatabasedKeyBindingContainer.cs

@@ -8,7 +8,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Input.Bindings;
 using osu.Game.Database;
 using osu.Game.Rulesets;
-using Realms;
 
 namespace osu.Game.Input.Bindings
 {
@@ -56,7 +55,7 @@ namespace osu.Game.Input.Bindings
                                            .Where(b => b.RulesetName == rulesetName && b.Variant == variant);
 
             realmSubscription = realmKeyBindings
-                .SubscribeForNotifications((sender, changes, error) =>
+                .QueryAsyncWithNotifications((sender, changes, error) =>
                 {
                     // first subscription ignored as we are handling this in LoadComplete.
                     if (changes == null)