Merge branch 'master' into i-ruleset-store

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.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.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/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/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/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/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/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/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/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 IRulesetStore rulesetStore { get; set; }
-
         [Test]
         public void TestShowPanel()
         {

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/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/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/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/IPC/ArchiveImportIPCChannel.cs

@@ -18,6 +18,7 @@ namespace osu.Game.IPC
             : base(host)
         {
             this.importer = importer;
+
             MessageReceived += msg =>
             {
                 Debug.Assert(importer != null);

osu.Game/Localisation/MouseSettingsStrings.cs

@@ -35,9 +35,14 @@ namespace osu.Game.Localisation
         public static LocalisableString ConfineMouseMode => new TranslatableString(getKey(@"confine_mouse_mode"), @"Confine mouse cursor to window");
 
         /// <summary>
-        /// "Disable mouse wheel during gameplay"
+        /// "Disable mouse wheel adjusting volume during gameplay"
         /// </summary>
-        public static LocalisableString DisableMouseWheel => new TranslatableString(getKey(@"disable_mouse_wheel"), @"Disable mouse wheel during gameplay");
+        public static LocalisableString DisableMouseWheelVolumeAdjust => new TranslatableString(getKey(@"disable_mouse_wheel_volume_adjust"), @"Disable mouse wheel adjusting volume during gameplay");
+
+        /// <summary>
+        /// "Volume can still be adjusted using the mouse wheel by holding "Alt""
+        /// </summary>
+        public static LocalisableString DisableMouseWheelVolumeAdjustTooltip => new TranslatableString(getKey(@"disable_mouse_wheel_volume_adjust_tooltip"), @"Volume can still be adjusted using the mouse wheel by holding ""Alt""");
 
         /// <summary>
         /// "Disable mouse buttons during gameplay"

osu.Game/Online/Leaderboards/LeaderboardScore.cs

@@ -65,9 +65,6 @@ namespace osu.Game.Online.Leaderboards
         [Resolved(CanBeNull = true)]
         private SongSelect songSelect { get; set; }
 
-        [Resolved]
-        private ScoreManager scoreManager { get; set; }
-
         [Resolved]
         private Storage storage { get; set; }
 

osu.Game/Online/Multiplayer/MultiplayerClient.cs

@@ -32,12 +32,36 @@ namespace osu.Game.Online.Multiplayer
         /// </summary>
         public event Action? RoomUpdated;
 
+        /// <summary>
+        /// Invoked when a new user joins the room.
+        /// </summary>
         public event Action<MultiplayerRoomUser>? UserJoined;
 
+        /// <summary>
+        /// Invoked when a user leaves the room of their own accord.
+        /// </summary>
         public event Action<MultiplayerRoomUser>? UserLeft;
 
+        /// <summary>
+        /// Invoked when a user was kicked from the room forcefully.
+        /// </summary>
         public event Action<MultiplayerRoomUser>? UserKicked;
 
+        /// <summary>
+        /// Invoked when a new item is added to the playlist.
+        /// </summary>
+        public event Action<MultiplayerPlaylistItem>? ItemAdded;
+
+        /// <summary>
+        /// Invoked when a playlist item is removed from the playlist. The provided <c>long</c> is the playlist's item ID.
+        /// </summary>
+        public event Action<long>? ItemRemoved;
+
+        /// <summary>
+        /// Invoked when a playlist item's details change.
+        /// </summary>
+        public event Action<MultiplayerPlaylistItem>? ItemChanged;
+
         /// <summary>
         /// Invoked when the multiplayer server requests the current beatmap to be loaded into play.
         /// </summary>
@@ -617,6 +641,7 @@ namespace osu.Game.Online.Multiplayer
                 Room.Playlist.Add(item);
                 APIRoom.Playlist.Add(playlistItem);
 
+                ItemAdded?.Invoke(item);
                 RoomUpdated?.Invoke();
             });
         }
@@ -636,6 +661,7 @@ namespace osu.Game.Online.Multiplayer
                 Room.Playlist.Remove(Room.Playlist.Single(existing => existing.ID == playlistItemId));
                 APIRoom.Playlist.RemoveAll(existing => existing.ID == playlistItemId);
 
+                ItemRemoved?.Invoke(playlistItemId);
                 RoomUpdated?.Invoke();
             });
 
@@ -666,6 +692,7 @@ namespace osu.Game.Online.Multiplayer
                 if (CurrentMatchPlayingItem.Value?.ID == playlistItem.ID)
                     CurrentMatchPlayingItem.Value = playlistItem;
 
+                ItemChanged?.Invoke(item);
                 RoomUpdated?.Invoke();
             });
         }
@@ -717,7 +744,9 @@ namespace osu.Game.Online.Multiplayer
                 OwnerID = item.OwnerID,
                 Beatmap = { Value = apiBeatmap },
                 Ruleset = { Value = ruleset },
-                Expired = item.Expired
+                Expired = item.Expired,
+                PlaylistOrder = item.PlaylistOrder,
+                PlayedAt = item.PlayedAt
             };
 
             playlistItem.RequiredMods.AddRange(item.RequiredMods.Select(m => m.ToMod(rulesetInstance)));

osu.Game/Online/Rooms/MultiplayerPlaylistItem.cs

@@ -39,6 +39,18 @@ namespace osu.Game.Online.Rooms
         [Key(7)]
         public bool Expired { get; set; }
 
+        /// <summary>
+        /// The order in which this <see cref="MultiplayerPlaylistItem"/> will be played, starting from 0 and increasing for items which will be played later.
+        /// </summary>
+        [Key(8)]
+        public ushort PlaylistOrder { get; set; }
+
+        /// <summary>
+        /// The date when this <see cref="MultiplayerPlaylistItem"/> was played.
+        /// </summary>
+        [Key(9)]
+        public DateTimeOffset? PlayedAt { get; set; }
+
         public MultiplayerPlaylistItem()
         {
         }
@@ -52,6 +64,8 @@ namespace osu.Game.Online.Rooms
             RequiredMods = item.RequiredMods.Select(m => new APIMod(m)).ToArray();
             AllowedMods = item.AllowedMods.Select(m => new APIMod(m)).ToArray();
             Expired = item.Expired;
+            PlaylistOrder = item.PlaylistOrder ?? 0;
+            PlayedAt = item.PlayedAt;
         }
     }
 }

osu.Game/Online/Rooms/PlaylistItem.cs

@@ -34,6 +34,12 @@ namespace osu.Game.Online.Rooms
         [JsonProperty("expired")]
         public bool Expired { get; set; }
 
+        [JsonProperty("playlist_order")]
+        public ushort? PlaylistOrder { get; set; }
+
+        [JsonProperty("played_at")]
+        public DateTimeOffset? PlayedAt { get; set; }
+
         [JsonIgnore]
         public IBindable<bool> Valid => valid;
 

osu.Game/Overlays/Dashboard/CurrentlyPlayingDisplay.cs

@@ -43,9 +43,6 @@ namespace osu.Game.Overlays.Dashboard
             };
         }
 
-        [Resolved]
-        private IAPIProvider api { get; set; }
-
         [Resolved]
         private UserLookupCache users { get; set; }
 

osu.Game/Overlays/Settings/Sections/Input/MouseSettings.cs

@@ -67,7 +67,8 @@ namespace osu.Game.Overlays.Settings.Sections.Input
                 },
                 new SettingsCheckbox
                 {
-                    LabelText = MouseSettingsStrings.DisableMouseWheel,
+                    LabelText = MouseSettingsStrings.DisableMouseWheelVolumeAdjust,
+                    TooltipText = MouseSettingsStrings.DisableMouseWheelVolumeAdjustTooltip,
                     Current = osuConfig.GetBindable<bool>(OsuSetting.MouseDisableWheel)
                 },
                 new SettingsCheckbox

osu.Game/Overlays/Wiki/Markdown/WikiMarkdownContainer.cs

@@ -5,19 +5,14 @@ using System.Linq;
 using Markdig.Extensions.Yaml;
 using Markdig.Syntax;
 using Markdig.Syntax.Inlines;
-using osu.Framework.Allocation;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Containers.Markdown;
 using osu.Game.Graphics.Containers.Markdown;
-using osu.Game.Online.API;
 
 namespace osu.Game.Overlays.Wiki.Markdown
 {
     public class WikiMarkdownContainer : OsuMarkdownContainer
     {
-        [Resolved]
-        private IAPIProvider api { get; set; }
-
         public string CurrentPath
         {
             set => DocumentUrl = value;

osu.Game/Rulesets/UI/Playfield.cs

@@ -19,7 +19,6 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Skinning;
 using osuTK;
 using System.Diagnostics;
-using osu.Framework.Audio.Sample;
 
 namespace osu.Game.Rulesets.UI
 {
@@ -88,9 +87,6 @@ namespace osu.Game.Rulesets.UI
         [Resolved(CanBeNull = true)]
         private IReadOnlyList<Mod> mods { get; set; }
 
-        [Resolved]
-        private ISampleStore sampleStore { get; set; }
-
         /// <summary>
         /// Creates a new <see cref="Playfield"/>.
         /// </summary>

osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/GroupVisualisation.cs

@@ -1,20 +1,15 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Graphics;
 
 namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
 {
     public class GroupVisualisation : CompositeDrawable
     {
-        [Resolved]
-        private OsuColour colours { get; set; }
-
         public readonly ControlPointGroup Group;
 
         private readonly IBindableList<ControlPoint> controlPoints = new BindableList<ControlPoint>();

osu.Game/Screens/Edit/Compose/Components/Timeline/Timeline.cs

@@ -279,9 +279,6 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                 editorClock.Start();
         }
 
-        [Resolved]
-        private EditorBeatmap beatmap { get; set; }
-
         [Resolved]
         private IBeatSnapProvider beatSnapProvider { get; set; }
 

osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineControlPointGroup.cs

@@ -1,12 +1,10 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Graphics;
 
 namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 {
@@ -16,9 +14,6 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
         private readonly IBindableList<ControlPoint> controlPoints = new BindableList<ControlPoint>();
 
-        [Resolved]
-        private OsuColour colours { get; set; }
-
         public TimelineControlPointGroup(ControlPointGroup group)
         {
             Group = group;

osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs

@@ -184,9 +184,6 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
         private SamplePointPiece sampleOverrideDisplay;
         private DifficultyPointPiece difficultyOverrideDisplay;
 
-        [Resolved]
-        private EditorBeatmap beatmap { get; set; }
-
         private DifficultyControlPoint difficultyControlPoint;
         private SampleControlPoint sampleControlPoint;
 

osu.Game/Screens/Edit/Editor.cs

@@ -109,9 +109,6 @@ namespace osu.Game.Screens.Edit
         [Resolved]
         private IAPIProvider api { get; set; }
 
-        [Resolved]
-        private MusicController music { get; set; }
-
         [Cached]
         public readonly EditorClipboard Clipboard = new EditorClipboard();
 

osu.Game/Screens/Edit/EditorRoundedScreen.cs

@@ -5,7 +5,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Graphics;
 using osu.Game.Overlays;
 
 namespace osu.Game.Screens.Edit
@@ -14,9 +13,6 @@ namespace osu.Game.Screens.Edit
     {
         public const int HORIZONTAL_PADDING = 100;
 
-        [Resolved]
-        private OsuColour colours { get; set; }
-
         private Container roundedContent;
 
         protected override Container<Drawable> Content => roundedContent;

osu.Game/Screens/Edit/EditorTable.cs

@@ -62,9 +62,6 @@ namespace osu.Game.Screens.Edit
 
             private readonly Box hoveredBackground;
 
-            [Resolved]
-            private EditorClock clock { get; set; }
-
             public RowBackground(object item)
             {
                 Item = item;

osu.Game/Screens/Edit/Setup/FileChooserLabelledTextBox.cs

@@ -15,7 +15,6 @@ using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
 using osu.Game.Database;
-using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterfaceV2;
 using osuTK;
@@ -36,9 +35,6 @@ namespace osu.Game.Screens.Edit.Setup
         [Resolved]
         private OsuGameBase game { get; set; }
 
-        [Resolved]
-        private SectionsContainer<SetupSection> sectionsContainer { get; set; }
-
         public FileChooserLabelledTextBox(params string[] handledExtensions)
         {
             this.handledExtensions = handledExtensions;

osu.Game/Screens/Edit/Timing/ControlPointTable.cs

@@ -132,9 +132,6 @@ namespace osu.Game.Screens.Edit.Timing
                 controlPoints.BindTo(group.ControlPoints);
             }
 
-            [Resolved]
-            private OsuColour colours { get; set; }
-
             [BackgroundDependencyLoader]
             private void load()
             {

osu.Game/Screens/Edit/Verify/IssueList.cs

@@ -23,9 +23,6 @@ namespace osu.Game.Screens.Edit.Verify
     {
         private IssueTable table;
 
-        [Resolved]
-        private EditorClock clock { get; set; }
-
         [Resolved]
         private IBindable<WorkingBeatmap> workingBeatmap { get; set; }
 

osu.Game/Screens/Menu/StorageErrorDialog.cs

@@ -15,9 +15,6 @@ namespace osu.Game.Screens.Menu
         [Resolved]
         private DialogOverlay dialogOverlay { get; set; }
 
-        [Resolved]
-        private OsuGameBase osuGame { get; set; }
-
         public StorageErrorDialog(OsuStorage storage, OsuStorageError error)
         {
             HeaderText = "osu! storage error";

osu.Game/Screens/OnlinePlay/Components/RoomManager.cs

@@ -9,7 +9,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Logging;
-using osu.Game.Beatmaps;
 using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
 using osu.Game.Rulesets;
@@ -30,9 +29,6 @@ namespace osu.Game.Screens.OnlinePlay.Components
         [Resolved]
         private IRulesetStore rulesets { get; set; }
 
-        [Resolved]
-        private BeatmapManager beatmaps { get; set; }
-
         [Resolved]
         private IAPIProvider api { get; set; }
 

osu.Game/Screens/OnlinePlay/Components/SelectionPollingComponent.cs

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Threading.Tasks;
-using osu.Framework.Allocation;
 using osu.Game.Online.Rooms;
 
 namespace osu.Game.Screens.OnlinePlay.Components
@@ -12,9 +11,6 @@ namespace osu.Game.Screens.OnlinePlay.Components
     /// </summary>
     public class SelectionPollingComponent : RoomPollingComponent
     {
-        [Resolved]
-        private IRoomManager roomManager { get; set; }
-
         private readonly Room room;
 
         public SelectionPollingComponent(Room room)

osu.Game/Screens/OnlinePlay/DrawableRoomPlaylist.cs

@@ -1,9 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.Collections.Generic;
 using System.Collections.Specialized;
-using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
@@ -22,13 +20,11 @@ namespace osu.Game.Screens.OnlinePlay
         private readonly bool allowSelection;
         private readonly bool showItemOwner;
 
-        public DrawableRoomPlaylist(bool allowEdit, bool allowSelection, bool reverse = false, bool showItemOwner = false)
+        public DrawableRoomPlaylist(bool allowEdit, bool allowSelection, bool showItemOwner = false)
         {
             this.allowEdit = allowEdit;
             this.allowSelection = allowSelection;
             this.showItemOwner = showItemOwner;
-
-            ((ReversibleFillFlowContainer)ListContainer).Reverse = reverse;
         }
 
         protected override void LoadComplete()
@@ -53,7 +49,7 @@ namespace osu.Game.Screens.OnlinePlay
             d.ScrollbarVisible = false;
         });
 
-        protected override FillFlowContainer<RearrangeableListItem<PlaylistItem>> CreateListFillFlowContainer() => new ReversibleFillFlowContainer
+        protected override FillFlowContainer<RearrangeableListItem<PlaylistItem>> CreateListFillFlowContainer() => new FillFlowContainer<RearrangeableListItem<PlaylistItem>>
         {
             Spacing = new Vector2(0, 2)
         };
@@ -76,22 +72,5 @@ namespace osu.Game.Screens.OnlinePlay
 
             Items.Remove(item);
         }
-
-        private class ReversibleFillFlowContainer : FillFlowContainer<RearrangeableListItem<PlaylistItem>>
-        {
-            private bool reverse;
-
-            public bool Reverse
-            {
-                get => reverse;
-                set
-                {
-                    reverse = value;
-                    Invalidate();
-                }
-            }
-
-            public override IEnumerable<Drawable> FlowingChildren => Reverse ? base.FlowingChildren.OrderBy(d => -GetLayoutPosition(d)) : base.FlowingChildren;
-        }
     }
 }

osu.Game/Screens/OnlinePlay/Lounge/Components/DrawableRoom.cs

@@ -30,9 +30,6 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
 
         public readonly Room Room;
 
-        [Resolved]
-        private BeatmapManager beatmaps { get; set; }
-
         protected Container ButtonsContainer { get; private set; }
 
         private readonly Bindable<MatchType> roomType = new Bindable<MatchType>();

osu.Game/Screens/OnlinePlay/Lounge/Components/RoomsContainer.cs

@@ -33,9 +33,6 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
         [Resolved]
         private IRoomManager roomManager { get; set; }
 
-        [Resolved(CanBeNull = true)]
-        private LoungeSubScreen loungeSubScreen { get; set; }
-
         // handle deselection
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
 

osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerMatchSettingsOverlay.cs

@@ -12,7 +12,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Screens;
-using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
@@ -20,7 +19,6 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
-using osu.Game.Rulesets;
 using osu.Game.Screens.OnlinePlay.Match.Components;
 using osuTK;
 
@@ -84,12 +82,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
             [Resolved]
             private MultiplayerClient client { get; set; }
 
-            [Resolved]
-            private Bindable<WorkingBeatmap> beatmap { get; set; }
-
-            [Resolved]
-            private Bindable<RulesetInfo> ruleset { get; set; }
-
             [Resolved]
             private OngoingOperationTracker ongoingOperationTracker { get; set; }
 

osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerReadyButton.cs

@@ -11,7 +11,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Threading;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Backgrounds;
-using osu.Game.Online.API;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Screens.OnlinePlay.Components;
 using osuTK;
@@ -25,9 +24,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
             set => button.Action = value;
         }
 
-        [Resolved]
-        private IAPIProvider api { get; set; }
-
         [Resolved]
         private OsuColour colours { get; set; }
 

osu.Game/Screens/OnlinePlay/Multiplayer/Match/Playlist/MultiplayerHistoryList.cs

@@ -0,0 +1,33 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Online.Rooms;
+using osuTK;
+
+namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist
+{
+    /// <summary>
+    /// A historically-ordered list of <see cref="DrawableRoomPlaylistItem"/>s.
+    /// </summary>
+    public class MultiplayerHistoryList : DrawableRoomPlaylist
+    {
+        public MultiplayerHistoryList()
+            : base(false, false, true)
+        {
+        }
+
+        protected override FillFlowContainer<RearrangeableListItem<PlaylistItem>> CreateListFillFlowContainer() => new HistoryFillFlowContainer
+        {
+            Spacing = new Vector2(0, 2)
+        };
+
+        private class HistoryFillFlowContainer : FillFlowContainer<RearrangeableListItem<PlaylistItem>>
+        {
+            public override IEnumerable<Drawable> FlowingChildren => base.FlowingChildren.OfType<RearrangeableListItem<PlaylistItem>>().OrderByDescending(item => item.Model.PlayedAt);
+        }
+    }
+}

osu.Game/Screens/OnlinePlay/Multiplayer/Match/Playlist/MultiplayerPlaylist.cs

@@ -0,0 +1,131 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Rooms;
+
+namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist
+{
+    /// <summary>
+    /// The multiplayer playlist, containing lists to show the items from a <see cref="MultiplayerRoom"/> in both gameplay-order and historical-order.
+    /// </summary>
+    public class MultiplayerPlaylist : MultiplayerRoomComposite
+    {
+        public readonly Bindable<MultiplayerPlaylistDisplayMode> DisplayMode = new Bindable<MultiplayerPlaylistDisplayMode>();
+
+        private MultiplayerQueueList queueList;
+        private MultiplayerHistoryList historyList;
+        private bool firstPopulation = true;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            const float tab_control_height = 25;
+
+            InternalChildren = new Drawable[]
+            {
+                new OsuTabControl<MultiplayerPlaylistDisplayMode>
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = tab_control_height,
+                    Current = { BindTarget = DisplayMode }
+                },
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Top = tab_control_height + 5 },
+                    Masking = true,
+                    Children = new Drawable[]
+                    {
+                        queueList = new MultiplayerQueueList
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            SelectedItem = { BindTarget = SelectedItem }
+                        },
+                        historyList = new MultiplayerHistoryList
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Alpha = 0,
+                            SelectedItem = { BindTarget = SelectedItem }
+                        }
+                    }
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            DisplayMode.BindValueChanged(onDisplayModeChanged, true);
+        }
+
+        private void onDisplayModeChanged(ValueChangedEvent<MultiplayerPlaylistDisplayMode> mode)
+        {
+            historyList.FadeTo(mode.NewValue == MultiplayerPlaylistDisplayMode.History ? 1 : 0, 100);
+            queueList.FadeTo(mode.NewValue == MultiplayerPlaylistDisplayMode.Queue ? 1 : 0, 100);
+        }
+
+        protected override void OnRoomUpdated()
+        {
+            base.OnRoomUpdated();
+
+            if (Room == null)
+            {
+                historyList.Items.Clear();
+                queueList.Items.Clear();
+                firstPopulation = true;
+                return;
+            }
+
+            if (firstPopulation)
+            {
+                foreach (var item in Room.Playlist)
+                    addItemToLists(item);
+
+                firstPopulation = false;
+            }
+        }
+
+        protected override void PlaylistItemAdded(MultiplayerPlaylistItem item)
+        {
+            base.PlaylistItemAdded(item);
+            addItemToLists(item);
+        }
+
+        protected override void PlaylistItemRemoved(long item)
+        {
+            base.PlaylistItemRemoved(item);
+            removeItemFromLists(item);
+        }
+
+        protected override void PlaylistItemChanged(MultiplayerPlaylistItem item)
+        {
+            base.PlaylistItemChanged(item);
+
+            removeItemFromLists(item.ID);
+            addItemToLists(item);
+        }
+
+        private void addItemToLists(MultiplayerPlaylistItem item)
+        {
+            var apiItem = Playlist.Single(i => i.ID == item.ID);
+
+            if (item.Expired)
+                historyList.Items.Add(apiItem);
+            else
+                queueList.Items.Add(apiItem);
+        }
+
+        private void removeItemFromLists(long item)
+        {
+            queueList.Items.RemoveAll(i => i.ID == item);
+            historyList.Items.RemoveAll(i => i.ID == item);
+        }
+    }
+}

osu.Game/Screens/OnlinePlay/Multiplayer/Match/Playlist/MultiplayerPlaylistDisplayMode.cs

@@ -0,0 +1,14 @@
+// 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.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist
+{
+    /// <summary>
+    /// The type of list displayed in a <see cref="MultiplayerPlaylist"/>.
+    /// </summary>
+    public enum MultiplayerPlaylistDisplayMode
+    {
+        Queue,
+        History,
+    }
+}

osu.Game/Screens/OnlinePlay/Multiplayer/Match/Playlist/MultiplayerQueueList.cs

@@ -0,0 +1,44 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Online.Rooms;
+using osuTK;
+
+namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist
+{
+    /// <summary>
+    /// A gameplay-ordered list of <see cref="DrawableRoomPlaylistItem"/>s.
+    /// </summary>
+    public class MultiplayerQueueList : DrawableRoomPlaylist
+    {
+        public MultiplayerQueueList()
+            : base(false, false, true)
+        {
+        }
+
+        protected override FillFlowContainer<RearrangeableListItem<PlaylistItem>> CreateListFillFlowContainer() => new QueueFillFlowContainer
+        {
+            Spacing = new Vector2(0, 2)
+        };
+
+        private class QueueFillFlowContainer : FillFlowContainer<RearrangeableListItem<PlaylistItem>>
+        {
+            [Resolved(typeof(Room), nameof(Room.Playlist))]
+            private BindableList<PlaylistItem> roomPlaylist { get; set; }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                roomPlaylist.BindCollectionChanged((_, __) => InvalidateLayout());
+            }
+
+            public override IEnumerable<Drawable> FlowingChildren => base.FlowingChildren.OfType<RearrangeableListItem<PlaylistItem>>().OrderBy(item => item.Model.PlaylistOrder);
+        }
+    }
+}

osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs

@@ -26,6 +26,7 @@ using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.OnlinePlay.Match;
 using osu.Game.Screens.OnlinePlay.Match.Components;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Match;
+using osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Participants;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Spectate;
 using osu.Game.Screens.Play;
@@ -56,8 +57,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         [CanBeNull]
         private IDisposable readyClickOperation;
 
-        private DrawableRoomPlaylist playlist;
-
         public MultiplayerMatchSubScreen(Room room)
             : base(room)
         {
@@ -74,9 +73,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
             BeatmapAvailability.BindValueChanged(updateBeatmapAvailability, true);
             UserMods.BindValueChanged(onUserModsChanged);
 
-            playlist.Items.BindTo(Room.Playlist);
-            playlist.SelectedItem.BindTo(SelectedItem);
-
             client.LoadRequested += onLoadRequested;
             client.RoomUpdated += onRoomUpdated;
 
@@ -153,10 +149,10 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
                                 null,
                                 new Drawable[]
                                 {
-                                    playlist = new DrawableRoomPlaylist(false, false, true, true)
+                                    new MultiplayerPlaylist
                                     {
-                                        RelativeSizeAxes = Axes.Both,
+                                        RelativeSizeAxes = Axes.Both
-                                    },
+                                    }
                                 },
                                 new[]
                                 {

osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerRoomComposite.cs

@@ -4,6 +4,7 @@
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Rooms;
 
 namespace osu.Game.Screens.OnlinePlay.Multiplayer
 {
@@ -23,6 +24,9 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
             Client.UserLeft += invokeUserLeft;
             Client.UserKicked += invokeUserKicked;
             Client.UserJoined += invokeUserJoined;
+            Client.ItemAdded += invokeItemAdded;
+            Client.ItemRemoved += invokeItemRemoved;
+            Client.ItemChanged += invokeItemChanged;
 
             OnRoomUpdated();
         }
@@ -31,6 +35,9 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         private void invokeUserJoined(MultiplayerRoomUser user) => Scheduler.AddOnce(UserJoined, user);
         private void invokeUserKicked(MultiplayerRoomUser user) => Scheduler.AddOnce(UserKicked, user);
         private void invokeUserLeft(MultiplayerRoomUser user) => Scheduler.AddOnce(UserLeft, user);
+        private void invokeItemAdded(MultiplayerPlaylistItem item) => Schedule(() => PlaylistItemAdded(item));
+        private void invokeItemRemoved(long item) => Schedule(() => PlaylistItemRemoved(item));
+        private void invokeItemChanged(MultiplayerPlaylistItem item) => Schedule(() => PlaylistItemChanged(item));
 
         /// <summary>
         /// Invoked when a user has joined the room.
@@ -56,6 +63,30 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         {
         }
 
+        /// <summary>
+        /// Invoked when a playlist item is added to the room.
+        /// </summary>
+        /// <param name="item">The added playlist item.</param>
+        protected virtual void PlaylistItemAdded(MultiplayerPlaylistItem item)
+        {
+        }
+
+        /// <summary>
+        /// Invoked when a playlist item is removed from the room.
+        /// </summary>
+        /// <param name="item">The ID of the removed playlist item.</param>
+        protected virtual void PlaylistItemRemoved(long item)
+        {
+        }
+
+        /// <summary>
+        /// Invoked when a playlist item is changed in the room.
+        /// </summary>
+        /// <param name="item">The new playlist item, with an existing item's ID.</param>
+        protected virtual void PlaylistItemChanged(MultiplayerPlaylistItem item)
+        {
+        }
+
         /// <summary>
         /// Invoked when any change occurs to the multiplayer room.
         /// </summary>
@@ -71,6 +102,9 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
                 Client.UserLeft -= invokeUserLeft;
                 Client.UserKicked -= invokeUserKicked;
                 Client.UserJoined -= invokeUserJoined;
+                Client.ItemAdded -= invokeItemAdded;
+                Client.ItemRemoved -= invokeItemRemoved;
+                Client.ItemChanged -= invokeItemChanged;
             }
 
             base.Dispose(isDisposing);

osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs

@@ -36,9 +36,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
         [Resolved]
         private OsuColour colours { get; set; }
 
-        [Resolved]
-        private SpectatorClient spectatorClient { get; set; }
-
         [Resolved]
         private MultiplayerClient multiplayerClient { get; set; }
 

osu.Game/Screens/OnlinePlay/OnlinePlayScreen.cs

@@ -40,18 +40,9 @@ namespace osu.Game.Screens.OnlinePlay
         [Cached]
         private readonly OngoingOperationTracker ongoingOperationTracker = new OngoingOperationTracker();
 
-        [Resolved(CanBeNull = true)]
-        private MusicController music { get; set; }
-
-        [Resolved]
-        private OsuGameBase game { get; set; }
-
         [Resolved]
         protected IAPIProvider API { get; private set; }
 
-        [Resolved(CanBeNull = true)]
-        private OsuLogo logo { get; set; }
-
         protected OnlinePlayScreen()
         {
             Anchor = Anchor.Centre;

osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs

@@ -11,7 +11,6 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Logging;
 using osu.Framework.Screens;
 using osu.Game.Input;
-using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
 using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.OnlinePlay.Match;
@@ -29,9 +28,6 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
 
         public override string ShortTitle => "playlist";
 
-        [Resolved]
-        private IAPIProvider api { get; set; }
-
         private readonly IBindable<bool> isIdle = new BindableBool();
 
         private MatchLeaderboard leaderboard;

osu.Game/Screens/OnlinePlay/Playlists/PlaylistsSongSelect.cs

@@ -2,9 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Linq;
-using osu.Framework.Allocation;
 using osu.Framework.Screens;
-using osu.Game.Beatmaps;
 using osu.Game.Online.Rooms;
 using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.Select;
@@ -13,9 +11,6 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
 {
     public class PlaylistsSongSelect : OnlinePlaySongSelect
     {
-        [Resolved]
-        private BeatmapManager beatmaps { get; set; }
-
         public PlaylistsSongSelect(Room room)
             : base(room)
         {

osu.Game/Screens/Play/HUD/DefaultAccuracyCounter.cs

@@ -9,9 +9,6 @@ namespace osu.Game.Screens.Play.HUD
 {
     public class DefaultAccuracyCounter : GameplayAccuracyCounter, ISkinnableDrawable
     {
-        [Resolved(canBeNull: true)]
-        private HUDOverlay hud { get; set; }
-
         public bool UsesFixedAnchor { get; set; }
 
         [BackgroundDependencyLoader]

osu.Game/Screens/Play/HUD/DefaultComboCounter.cs

@@ -15,9 +15,6 @@ namespace osu.Game.Screens.Play.HUD
 {
     public class DefaultComboCounter : RollingCounter<int>, ISkinnableDrawable
     {
-        [Resolved(canBeNull: true)]
-        private HUDOverlay hud { get; set; }
-
         public bool UsesFixedAnchor { get; set; }
 
         public DefaultComboCounter()

osu.Game/Screens/Play/HUD/DefaultScoreCounter.cs

@@ -16,9 +16,6 @@ namespace osu.Game.Screens.Play.HUD
             Origin = Anchor.TopCentre;
         }
 
-        [Resolved(canBeNull: true)]
-        private HUDOverlay hud { get; set; }
-
         public bool UsesFixedAnchor { get; set; }
 
         [BackgroundDependencyLoader]

osu.Game/Screens/Play/HUD/LegacyComboCounter.cs

@@ -40,9 +40,6 @@ namespace osu.Game.Screens.Play.HUD
 
         private bool isRolling;
 
-        [Resolved]
-        private ISkinSource skin { get; set; }
-
         private readonly Container counterContainer;
 
         /// <summary>

osu.Game/Screens/Play/Player.cs

@@ -768,7 +768,15 @@ namespace osu.Game.Screens.Play
             Scheduler.Add(resultsDisplayDelegate);
         }
 
-        protected override bool OnScroll(ScrollEvent e) => mouseWheelDisabled.Value && !GameplayClockContainer.IsPaused.Value;
+        protected override bool OnScroll(ScrollEvent e)
+        {
+            // During pause, allow global volume adjust regardless of settings.
+            if (GameplayClockContainer.IsPaused.Value)
+                return false;
+
+            // Block global volume adjust if the user has asked for it (special case when holding "Alt").
+            return mouseWheelDisabled.Value && !e.AltPressed;
+        }
 
         #region Fail Logic
 

osu.Game/Screens/Ranking/ScorePanelList.cs

@@ -13,7 +13,6 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Events;
-using osu.Game.Beatmaps;
 using osu.Game.Graphics.Containers;
 using osu.Game.Scoring;
 using osuTK;
@@ -70,9 +69,6 @@ namespace osu.Game.Screens.Ranking
         [Resolved]
         private ScoreManager scoreManager { get; set; }
 
-        [Resolved]
-        private BeatmapDifficultyCache difficultyCache { get; set; }
-
         private readonly CancellationTokenSource loadCancellationSource = new CancellationTokenSource();
         private readonly Flow flow;
         private readonly Scroll scroll;

osu.Game/Screens/Select/Leaderboards/BeatmapLeaderboard.cs

@@ -64,9 +64,6 @@ namespace osu.Game.Screens.Select.Leaderboards
         [Resolved]
         private ScoreManager scoreManager { get; set; }
 
-        [Resolved]
-        private BeatmapDifficultyCache difficultyCache { get; set; }
-
         [Resolved]
         private IBindable<RulesetInfo> ruleset { get; set; }
 

osu.Game/Skinning/Editor/SkinEditorOverlay.cs

@@ -3,13 +3,11 @@
 
 using System.Diagnostics;
 using JetBrains.Annotations;
-using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
-using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Input.Bindings;
 
@@ -28,9 +26,6 @@ namespace osu.Game.Skinning.Editor
 
         public const float VISIBLE_TARGET_SCALE = 0.8f;
 
-        [Resolved]
-        private OsuColour colours { get; set; }
-
         public SkinEditorOverlay(ScalingContainer target)
         {
             this.target = target;

osu.Game/Skinning/LegacyAccuracyCounter.cs

@@ -1,10 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Graphics.Sprites;
-using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.HUD;
 using osuTK;
 
@@ -23,9 +21,6 @@ namespace osu.Game.Skinning
             Margin = new MarginPadding(10);
         }
 
-        [Resolved(canBeNull: true)]
-        private HUDOverlay hud { get; set; }
-
         protected sealed override OsuSpriteText CreateSpriteText() => new LegacySpriteText(LegacyFont.Score)
         {
             Anchor = Anchor.TopRight,

osu.Game/Skinning/PoolableSkinnableSample.cs

@@ -4,7 +4,6 @@
 using System;
 using System.Linq;
 using JetBrains.Annotations;
-using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
@@ -30,9 +29,6 @@ namespace osu.Game.Skinning
         private ISampleInfo sampleInfo;
         private SampleChannel activeChannel;
 
-        [Resolved]
-        private ISampleStore sampleStore { get; set; }
-
         /// <summary>
         /// Creates a new <see cref="PoolableSkinnableSample"/> with no applied <see cref="ISampleInfo"/>.
         /// An <see cref="ISampleInfo"/> can be applied later via <see cref="Apply"/>.

osu.Game/Skinning/SkinnableSound.cs

@@ -7,7 +7,6 @@ using System.Linq;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
-using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
@@ -43,9 +42,6 @@ namespace osu.Game.Skinning
 
         private readonly AudioContainer<PoolableSkinnableSample> samplesContainer;
 
-        [Resolved]
-        private ISampleStore sampleStore { get; set; }
-
         [Resolved(CanBeNull = true)]
         private IPooledSampleProvider samplePool { get; set; }
 

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

@@ -50,6 +50,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private MultiplayerPlaylistItem? currentItem => Room?.Playlist[currentIndex];
         private int currentIndex;
 
+        private long lastPlaylistItemId;
+
         public TestMultiplayerClient(TestMultiplayerRoomManager roomManager)
         {
             this.roomManager = roomManager;
@@ -145,7 +147,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
                             ((IMultiplayerClient)this).ResultsReady();
 
-                            finishCurrentItem().Wait();
+                            FinishCurrentItem().Wait();
                         }
 
                         break;
@@ -169,6 +171,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             serverSidePlaylist.Clear();
             serverSidePlaylist.AddRange(apiRoom.Playlist.Select(item => new MultiplayerPlaylistItem(item)));
+            lastPlaylistItemId = serverSidePlaylist.Max(item => item.ID);
 
             var localUser = new MultiplayerRoomUser(api.LocalUser.Value.Id)
             {
@@ -189,6 +192,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 Host = localUser
             };
 
+            await updatePlaylistOrder(room).ConfigureAwait(false);
             await updateCurrentItem(room, false).ConfigureAwait(false);
 
             RoomSetupAction?.Invoke(room);
@@ -308,12 +312,14 @@ namespace osu.Game.Tests.Visual.Multiplayer
             if (Room.Settings.QueueMode == QueueMode.HostOnly && Room.Host?.UserID != LocalUser?.UserID)
                 throw new InvalidOperationException("Local user is not the room host.");
 
+            item.OwnerID = userId;
+
             switch (Room.Settings.QueueMode)
             {
                 case QueueMode.HostOnly:
                     // In host-only mode, the current item is re-used.
                     item.ID = currentItem.ID;
-                    item.OwnerID = currentItem.OwnerID;
+                    item.PlaylistOrder = currentItem.PlaylistOrder;
 
                     serverSidePlaylist[currentIndex] = item;
                     await ((IMultiplayerClient)this).PlaylistItemChanged(item).ConfigureAwait(false);
@@ -323,12 +329,9 @@ namespace osu.Game.Tests.Visual.Multiplayer
                     break;
 
                 default:
-                    item.ID = serverSidePlaylist.Last().ID + 1;
+                    await addItem(item).ConfigureAwait(false);
-                    item.OwnerID = userId;
-
-                    serverSidePlaylist.Add(item);
-                    await ((IMultiplayerClient)this).PlaylistItemAdded(item).ConfigureAwait(false);
 
+                    // The current item can change as a result of an item being added. For example, if all items earlier in the queue were expired.
                     await updateCurrentItem(Room).ConfigureAwait(false);
                     break;
             }
@@ -385,11 +388,11 @@ namespace osu.Game.Tests.Visual.Multiplayer
             if (newMode == QueueMode.HostOnly && serverSidePlaylist.All(item => item.Expired))
                 await duplicateCurrentItem().ConfigureAwait(false);
 
-            // When changing modes, items could have been added (above) or the queueing order could have changed.
+            await updatePlaylistOrder(Room).ConfigureAwait(false);
             await updateCurrentItem(Room).ConfigureAwait(false);
         }
 
-        private async Task finishCurrentItem()
+        public async Task FinishCurrentItem()
         {
             Debug.Assert(Room != null);
             Debug.Assert(APIRoom != null);
@@ -397,10 +400,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             // Expire the current playlist item.
             currentItem.Expired = true;
+            currentItem.PlayedAt = DateTimeOffset.Now;
+
             await ((IMultiplayerClient)this).PlaylistItemChanged(currentItem).ConfigureAwait(false);
+            await updatePlaylistOrder(Room).ConfigureAwait(false);
 
             // In host-only mode, a duplicate playlist item will be used for the next round.
-            if (Room.Settings.QueueMode == QueueMode.HostOnly)
+            if (Room.Settings.QueueMode == QueueMode.HostOnly && serverSidePlaylist.All(item => item.Expired))
                 await duplicateCurrentItem().ConfigureAwait(false);
 
             await updateCurrentItem(Room).ConfigureAwait(false);
@@ -408,47 +414,102 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         private async Task duplicateCurrentItem()
         {
-            Debug.Assert(Room != null);
-            Debug.Assert(APIRoom != null);
             Debug.Assert(currentItem != null);
 
-            var newItem = new MultiplayerPlaylistItem
+            await addItem(new MultiplayerPlaylistItem
             {
-                ID = serverSidePlaylist.Last().ID + 1,
                 BeatmapID = currentItem.BeatmapID,
                 BeatmapChecksum = currentItem.BeatmapChecksum,
                 RulesetID = currentItem.RulesetID,
                 RequiredMods = currentItem.RequiredMods,
                 AllowedMods = currentItem.AllowedMods
-            };
+            }).ConfigureAwait(false);
+        }
 
-            serverSidePlaylist.Add(newItem);
+        private async Task addItem(MultiplayerPlaylistItem item)
-            await ((IMultiplayerClient)this).PlaylistItemAdded(newItem).ConfigureAwait(false);
+        {
+            Debug.Assert(Room != null);
+
+            // Add the item to the list first in order to compute gameplay order.
+            serverSidePlaylist.Add(item);
+            await updatePlaylistOrder(Room).ConfigureAwait(false);
+
+            item.ID = ++lastPlaylistItemId;
+            await ((IMultiplayerClient)this).PlaylistItemAdded(item).ConfigureAwait(false);
         }
 
         private async Task updateCurrentItem(MultiplayerRoom room, bool notify = true)
         {
-            MultiplayerPlaylistItem newItem;
+            MultiplayerPlaylistItem nextItem = serverSidePlaylist
+                                               .Where(i => !i.Expired)
+                                               .OrderBy(i => i.PlaylistOrder)
+                                               .FirstOrDefault()
+                                               ?? room.Playlist.Last();
+
+            currentIndex = serverSidePlaylist.IndexOf(nextItem);
+
+            long lastItem = room.Settings.PlaylistItemId;
+            room.Settings.PlaylistItemId = nextItem.ID;
+
+            if (notify && nextItem.ID != lastItem)
+                await ((IMultiplayerClient)this).SettingsChanged(room.Settings).ConfigureAwait(false);
+        }
+
+        private async Task updatePlaylistOrder(MultiplayerRoom room)
+        {
+            List<MultiplayerPlaylistItem> orderedActiveItems;
 
             switch (room.Settings.QueueMode)
             {
                 default:
-                    // Pick the single non-expired playlist item.
+                    orderedActiveItems = serverSidePlaylist.Where(item => !item.Expired).OrderBy(item => item.ID == 0 ? int.MaxValue : item.ID).ToList();
-                    newItem = serverSidePlaylist.FirstOrDefault(i => !i.Expired) ?? serverSidePlaylist.Last();
                     break;
 
                 case QueueMode.AllPlayersRoundRobin:
-                    // Group playlist items by (user_id -> count_expired), and select the first available playlist item from a user that has available beatmaps where count_expired is the lowest.
+                    orderedActiveItems = new List<MultiplayerPlaylistItem>();
-                    throw new NotImplementedException();
+
+                    // Todo: This could probably be more efficient, likely at the cost of increased complexity.
+                    // Number of "expired" or "used" items per player.
+                    Dictionary<int, int> perUserCounts = serverSidePlaylist
+                                                         .GroupBy(item => item.OwnerID)
+                                                         .ToDictionary(group => group.Key, group => group.Count(item => item.Expired));
+
+                    // We'll run a simulation over all items which are not expired ("unprocessed"). Expired items will not have their ordering updated.
+                    List<MultiplayerPlaylistItem> unprocessedItems = serverSidePlaylist.Where(item => !item.Expired).ToList();
+
+                    // In every iteration of the simulation, pick the first available item from the user with the lowest number of items in the queue to add to the result set.
+                    // If multiple users have the same number of items in the queue, then the item with the lowest ID is chosen.
+                    while (unprocessedItems.Count > 0)
+                    {
+                        MultiplayerPlaylistItem candidateItem = unprocessedItems
+                                                                .OrderBy(item => perUserCounts[item.OwnerID])
+                                                                .ThenBy(item => item.ID == 0 ? int.MaxValue : item.ID)
+                                                                .First();
+
+                        unprocessedItems.Remove(candidateItem);
+                        orderedActiveItems.Add(candidateItem);
+
+                        perUserCounts[candidateItem.OwnerID]++;
+                    }
+
+                    break;
             }
 
-            currentIndex = serverSidePlaylist.IndexOf(newItem);
+            for (int i = 0; i < orderedActiveItems.Count; i++)
+            {
+                var item = orderedActiveItems[i];
 
-            long lastItem = room.Settings.PlaylistItemId;
+                if (item.PlaylistOrder == i)
-            room.Settings.PlaylistItemId = newItem.ID;
+                    continue;
 
-            if (notify && newItem.ID != lastItem)
+                item.PlaylistOrder = (ushort)i;
-                await ((IMultiplayerClient)this).SettingsChanged(room.Settings).ConfigureAwait(false);
+
+                // Items which have an ID of 0 are not in the database, so avoid propagating database/hub events for them.
+                if (item.ID <= 0)
+                    continue;
+
+                await ((IMultiplayerClient)this).PlaylistItemChanged(item).ConfigureAwait(false);
+            }
         }
     }
 }

osu.Game/Updater/NoActionUpdateManager.cs

@@ -5,7 +5,6 @@ using System.Linq;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Platform;
 using osu.Game.Online.API;
 using osu.Game.Overlays.Notifications;
 
@@ -19,9 +18,6 @@ namespace osu.Game.Updater
     {
         private string version;
 
-        [Resolved]
-        private GameHost host { get; set; }
-
         [BackgroundDependencyLoader]
         private void load(OsuGameBase game)
         {