Merge branch 'master' of https://github.com/ppy/osu into present-recommended

 Conflicts:

	osu.Game/OsuGameBase.cs

	osu.Game/Screens/Select/DifficultyRecommender.cs

	osu.Game/Screens/Select/SongSelect.cs

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

@@ -0,0 +1,196 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.OpenGL.Textures;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Configuration;
+using osu.Game.Graphics.Backgrounds;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+
+namespace osu.Game.Tests.Visual.Background
+{
+    public class TestSceneSeasonalBackgroundLoader : ScreenTestScene
+    {
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
+        [Resolved]
+        private SessionStatics statics { get; set; }
+
+        [Cached(typeof(LargeTextureStore))]
+        private LookupLoggingTextureStore textureStore = new LookupLoggingTextureStore();
+
+        private DummyAPIAccess dummyAPI => (DummyAPIAccess)API;
+
+        private SeasonalBackgroundLoader backgroundLoader;
+        private Container backgroundContainer;
+
+        // in real usages these would be online URLs, but correct execution of this test
+        // shouldn't be coupled to existence of online assets.
+        private static readonly List<string> seasonal_background_urls = new List<string>
+        {
+            "Backgrounds/bg2",
+            "Backgrounds/bg4",
+            "Backgrounds/bg3"
+        };
+
+        [BackgroundDependencyLoader]
+        private void load(LargeTextureStore wrappedStore)
+        {
+            textureStore.AddStore(wrappedStore);
+
+            Add(backgroundContainer = new Container
+            {
+                RelativeSizeAxes = Axes.Both
+            });
+        }
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            // reset API response in statics to avoid test crosstalk.
+            statics.Set<APISeasonalBackgrounds>(Static.SeasonalBackgrounds, null);
+            textureStore.PerformedLookups.Clear();
+            dummyAPI.SetState(APIState.Online);
+
+            backgroundContainer.Clear();
+        });
+
+        [TestCase(-5)]
+        [TestCase(5)]
+        public void TestAlwaysSeasonal(int daysOffset)
+        {
+            registerBackgroundsResponse(DateTimeOffset.Now.AddDays(daysOffset));
+            setSeasonalBackgroundMode(SeasonalBackgroundMode.Always);
+
+            createLoader();
+
+            for (int i = 0; i < 4; ++i)
+                loadNextBackground();
+
+            AddAssert("all backgrounds cycled", () => new HashSet<string>(textureStore.PerformedLookups).SetEquals(seasonal_background_urls));
+        }
+
+        [TestCase(-5)]
+        [TestCase(5)]
+        public void TestNeverSeasonal(int daysOffset)
+        {
+            registerBackgroundsResponse(DateTimeOffset.Now.AddDays(daysOffset));
+            setSeasonalBackgroundMode(SeasonalBackgroundMode.Never);
+
+            createLoader();
+
+            assertNoBackgrounds();
+        }
+
+        [Test]
+        public void TestSometimesInSeason()
+        {
+            registerBackgroundsResponse(DateTimeOffset.Now.AddDays(5));
+            setSeasonalBackgroundMode(SeasonalBackgroundMode.Sometimes);
+
+            createLoader();
+
+            assertAnyBackground();
+        }
+
+        [Test]
+        public void TestSometimesOutOfSeason()
+        {
+            registerBackgroundsResponse(DateTimeOffset.Now.AddDays(-10));
+            setSeasonalBackgroundMode(SeasonalBackgroundMode.Sometimes);
+
+            createLoader();
+
+            assertNoBackgrounds();
+        }
+
+        [Test]
+        public void TestDelayedConnectivity()
+        {
+            registerBackgroundsResponse(DateTimeOffset.Now.AddDays(30));
+            setSeasonalBackgroundMode(SeasonalBackgroundMode.Always);
+            AddStep("go offline", () => dummyAPI.SetState(APIState.Offline));
+
+            createLoader();
+            assertNoBackgrounds();
+
+            AddStep("go online", () => dummyAPI.SetState(APIState.Online));
+
+            assertAnyBackground();
+        }
+
+        private void registerBackgroundsResponse(DateTimeOffset endDate)
+            => AddStep("setup request handler", () =>
+            {
+                dummyAPI.HandleRequest = request =>
+                {
+                    if (dummyAPI.State.Value != APIState.Online || !(request is GetSeasonalBackgroundsRequest backgroundsRequest))
+                        return;
+
+                    backgroundsRequest.TriggerSuccess(new APISeasonalBackgrounds
+                    {
+                        Backgrounds = seasonal_background_urls.Select(url => new APISeasonalBackground { Url = url }).ToList(),
+                        EndDate = endDate
+                    });
+                };
+            });
+
+        private void setSeasonalBackgroundMode(SeasonalBackgroundMode mode)
+            => AddStep($"set seasonal mode to {mode}", () => config.Set(OsuSetting.SeasonalBackgroundMode, mode));
+
+        private void createLoader()
+            => AddStep("create loader", () =>
+            {
+                if (backgroundLoader != null)
+                    Remove(backgroundLoader);
+
+                Add(backgroundLoader = new SeasonalBackgroundLoader());
+            });
+
+        private void loadNextBackground()
+        {
+            SeasonalBackground background = null;
+
+            AddStep("create next background", () =>
+            {
+                background = backgroundLoader.LoadNextBackground();
+                LoadComponentAsync(background, bg => backgroundContainer.Child = bg);
+            });
+
+            AddUntilStep("background loaded", () => background.IsLoaded);
+        }
+
+        private void assertAnyBackground()
+        {
+            loadNextBackground();
+            AddAssert("background looked up", () => textureStore.PerformedLookups.Any());
+        }
+
+        private void assertNoBackgrounds()
+        {
+            AddAssert("no background available", () => backgroundLoader.LoadNextBackground() == null);
+            AddAssert("no lookups performed", () => !textureStore.PerformedLookups.Any());
+        }
+
+        private class LookupLoggingTextureStore : LargeTextureStore
+        {
+            public List<string> PerformedLookups { get; } = new List<string>();
+
+            public override Texture Get(string name, WrapMode wrapModeS, WrapMode wrapModeT)
+            {
+                PerformedLookups.Add(name);
+                return base.Get(name, wrapModeS, wrapModeT);
+            }
+        }
+    }
+}

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

@@ -27,6 +27,7 @@ using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.PlayerSettings;
 using osu.Game.Screens.Ranking;
 using osu.Game.Screens.Select;
+using osu.Game.Tests.Beatmaps;
 using osu.Game.Tests.Resources;
 using osu.Game.Users;
 using osuTK;
@@ -186,9 +187,16 @@ namespace osu.Game.Tests.Visual.Background
         public void TestTransition()
         {
             performFullSetup();
+
             FadeAccessibleResults results = null;
-            AddStep("Transition to Results", () => player.Push(results =
-                new FadeAccessibleResults(new ScoreInfo { User = new User { Username = "osu!" } })));
+
+            AddStep("Transition to Results", () => player.Push(results = new FadeAccessibleResults(new ScoreInfo
+            {
+                User = new User { Username = "osu!" },
+                Beatmap = new TestBeatmap(Ruleset.Value).BeatmapInfo,
+                Ruleset = Ruleset.Value,
+            })));
+
             AddUntilStep("Wait for results is current", () => results.IsCurrentScreen());
             AddUntilStep("Screen is undimmed, original background retained", () =>
                 songSelect.IsBackgroundUndimmed() && songSelect.IsBackgroundCurrent() && results.IsBlurCorrect());

osu.Game.Tests/Visual/Collections/TestSceneManageCollectionsDialog.cs

@@ -0,0 +1,235 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Platform;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Collections;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Dialog;
+using osu.Game.Rulesets;
+using osu.Game.Tests.Resources;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Collections
+{
+    public class TestSceneManageCollectionsDialog : OsuManualInputManagerTestScene
+    {
+        protected override Container<Drawable> Content { get; } = new Container { RelativeSizeAxes = Axes.Both };
+
+        private DialogOverlay dialogOverlay;
+        private CollectionManager manager;
+
+        private RulesetStore rulesets;
+        private BeatmapManager beatmapManager;
+
+        private ManageCollectionsDialog dialog;
+
+        [BackgroundDependencyLoader]
+        private void load(GameHost host)
+        {
+            Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
+            Dependencies.Cache(beatmapManager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, Audio, host, Beatmap.Default));
+
+            beatmapManager.Import(TestResources.GetTestBeatmapForImport()).Wait();
+
+            base.Content.AddRange(new Drawable[]
+            {
+                manager = new CollectionManager(LocalStorage),
+                Content,
+                dialogOverlay = new DialogOverlay()
+            });
+
+            Dependencies.Cache(manager);
+            Dependencies.Cache(dialogOverlay);
+        }
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            manager.Collections.Clear();
+            Child = dialog = new ManageCollectionsDialog();
+        });
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("show dialog", () => dialog.Show());
+        }
+
+        [Test]
+        public void TestHideDialog()
+        {
+            AddWaitStep("wait for animation", 3);
+            AddStep("hide dialog", () => dialog.Hide());
+        }
+
+        [Test]
+        public void TestLastItemIsPlaceholder()
+        {
+            AddAssert("last item is placeholder", () => !manager.Collections.Contains(dialog.ChildrenOfType<DrawableCollectionListItem>().Last().Model));
+        }
+
+        [Test]
+        public void TestAddCollectionExternal()
+        {
+            AddStep("add collection", () => manager.Collections.Add(new BeatmapCollection { Name = { Value = "First collection" } }));
+            assertCollectionCount(1);
+            assertCollectionName(0, "First collection");
+
+            AddStep("add another collection", () => manager.Collections.Add(new BeatmapCollection { Name = { Value = "Second collection" } }));
+            assertCollectionCount(2);
+            assertCollectionName(1, "Second collection");
+        }
+
+        [Test]
+        public void TestFocusPlaceholderDoesNotCreateCollection()
+        {
+            AddStep("focus placeholder", () =>
+            {
+                InputManager.MoveMouseTo(dialog.ChildrenOfType<DrawableCollectionListItem>().Last());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            assertCollectionCount(0);
+        }
+
+        [Test]
+        public void TestAddCollectionViaPlaceholder()
+        {
+            DrawableCollectionListItem placeholderItem = null;
+
+            AddStep("focus placeholder", () =>
+            {
+                InputManager.MoveMouseTo(placeholderItem = dialog.ChildrenOfType<DrawableCollectionListItem>().Last());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            // Done directly via the collection since InputManager methods cannot add text to textbox...
+            AddStep("change collection name", () => placeholderItem.Model.Name.Value = "a");
+            assertCollectionCount(1);
+            AddAssert("collection now exists", () => manager.Collections.Contains(placeholderItem.Model));
+
+            AddAssert("last item is placeholder", () => !manager.Collections.Contains(dialog.ChildrenOfType<DrawableCollectionListItem>().Last().Model));
+        }
+
+        [Test]
+        public void TestRemoveCollectionExternal()
+        {
+            AddStep("add two collections", () => manager.Collections.AddRange(new[]
+            {
+                new BeatmapCollection { Name = { Value = "1" } },
+                new BeatmapCollection { Name = { Value = "2" } },
+            }));
+
+            AddStep("remove first collection", () => manager.Collections.RemoveAt(0));
+            assertCollectionCount(1);
+            assertCollectionName(0, "2");
+        }
+
+        [Test]
+        public void TestRemoveCollectionViaButton()
+        {
+            AddStep("add two collections", () => manager.Collections.AddRange(new[]
+            {
+                new BeatmapCollection { Name = { Value = "1" } },
+                new BeatmapCollection { Name = { Value = "2" }, Beatmaps = { beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps[0] } },
+            }));
+
+            assertCollectionCount(2);
+
+            AddStep("click first delete button", () =>
+            {
+                InputManager.MoveMouseTo(dialog.ChildrenOfType<DrawableCollectionListItem.DeleteButton>().First(), new Vector2(5, 0));
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("dialog not displayed", () => dialogOverlay.CurrentDialog == null);
+            assertCollectionCount(1);
+            assertCollectionName(0, "2");
+
+            AddStep("click first delete button", () =>
+            {
+                InputManager.MoveMouseTo(dialog.ChildrenOfType<DrawableCollectionListItem.DeleteButton>().First(), new Vector2(5, 0));
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("dialog displayed", () => dialogOverlay.CurrentDialog is DeleteCollectionDialog);
+            AddStep("click confirmation", () =>
+            {
+                InputManager.MoveMouseTo(dialogOverlay.CurrentDialog.ChildrenOfType<PopupDialogButton>().First());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            assertCollectionCount(0);
+        }
+
+        [Test]
+        public void TestCollectionNotRemovedWhenDialogCancelled()
+        {
+            AddStep("add two collections", () => manager.Collections.AddRange(new[]
+            {
+                new BeatmapCollection { Name = { Value = "1" }, Beatmaps = { beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps[0] } },
+            }));
+
+            assertCollectionCount(1);
+
+            AddStep("click first delete button", () =>
+            {
+                InputManager.MoveMouseTo(dialog.ChildrenOfType<DrawableCollectionListItem.DeleteButton>().First(), new Vector2(5, 0));
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("dialog displayed", () => dialogOverlay.CurrentDialog is DeleteCollectionDialog);
+            AddStep("click cancellation", () =>
+            {
+                InputManager.MoveMouseTo(dialogOverlay.CurrentDialog.ChildrenOfType<PopupDialogButton>().Last());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            assertCollectionCount(1);
+        }
+
+        [Test]
+        public void TestCollectionRenamedExternal()
+        {
+            AddStep("add two collections", () => manager.Collections.AddRange(new[]
+            {
+                new BeatmapCollection { Name = { Value = "1" } },
+                new BeatmapCollection { Name = { Value = "2" } },
+            }));
+
+            AddStep("change first collection name", () => manager.Collections[0].Name.Value = "First");
+
+            assertCollectionName(0, "First");
+        }
+
+        [Test]
+        public void TestCollectionRenamedOnTextChange()
+        {
+            AddStep("add two collections", () => manager.Collections.AddRange(new[]
+            {
+                new BeatmapCollection { Name = { Value = "1" } },
+                new BeatmapCollection { Name = { Value = "2" } },
+            }));
+
+            assertCollectionCount(2);
+
+            AddStep("change first collection name", () => dialog.ChildrenOfType<TextBox>().First().Text = "First");
+            AddAssert("collection has new name", () => manager.Collections[0].Name.Value == "First");
+        }
+
+        private void assertCollectionCount(int count)
+            => AddUntilStep($"{count} collections shown", () => dialog.ChildrenOfType<DrawableCollectionListItem>().Count(i => i.IsCreated.Value) == count);
+
+        private void assertCollectionName(int index, string name)
+            => AddUntilStep($"item {index + 1} has correct name", () => dialog.ChildrenOfType<DrawableCollectionListItem>().ElementAt(index).ChildrenOfType<TextBox>().First().Text == name);
+    }
+}

osu.Game.Tests/Visual/Components/TestScenePreviewTrackManager.cs

@@ -167,6 +167,21 @@ namespace osu.Game.Tests.Visual.Components
             AddAssert("game not muted", () => audio.Tracks.AggregateVolume.Value != 0);
         }
 
+        [Test]
+        public void TestOwnerNotRegistered()
+        {
+            PreviewTrack track = null;
+
+            AddStep("get track", () => Add(new TestTrackOwner(track = getTrack(), registerAsOwner: false)));
+            AddUntilStep("wait for loaded", () => track.IsLoaded);
+
+            AddStep("start track", () => track.Start());
+            AddUntilStep("track is running", () => track.IsRunning);
+
+            AddStep("cancel from anyone", () => trackManager.StopAnyPlaying(this));
+            AddAssert("track stopped", () => !track.IsRunning);
+        }
+
         private TestPreviewTrack getTrack() => (TestPreviewTrack)trackManager.Get(null);
 
         private TestPreviewTrack getOwnedTrack()
@@ -181,10 +196,12 @@ namespace osu.Game.Tests.Visual.Components
         private class TestTrackOwner : CompositeDrawable, IPreviewTrackOwner
         {
             private readonly PreviewTrack track;
+            private readonly bool registerAsOwner;
 
-            public TestTrackOwner(PreviewTrack track)
+            public TestTrackOwner(PreviewTrack track, bool registerAsOwner = true)
             {
                 this.track = track;
+                this.registerAsOwner = registerAsOwner;
             }
 
             [BackgroundDependencyLoader]
@@ -196,7 +213,8 @@ namespace osu.Game.Tests.Visual.Components
             protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
             {
                 var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
-                dependencies.CacheAs<IPreviewTrackOwner>(this);
+                if (registerAsOwner)
+                    dependencies.CacheAs<IPreviewTrackOwner>(this);
                 return dependencies;
             }
         }

osu.Game.Tests/Visual/Editing/TestSceneComposeSelectBox.cs

@@ -0,0 +1,72 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Screens.Edit.Compose.Components;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Editing
+{
+    public class TestSceneComposeSelectBox : OsuTestScene
+    {
+        private Container selectionArea;
+
+        public TestSceneComposeSelectBox()
+        {
+            SelectionBox selectionBox = null;
+
+            AddStep("create box", () =>
+                Child = selectionArea = new Container
+                {
+                    Size = new Vector2(400),
+                    Position = -new Vector2(150),
+                    Anchor = Anchor.Centre,
+                    Children = new Drawable[]
+                    {
+                        selectionBox = new SelectionBox
+                        {
+                            CanRotate = true,
+                            CanScaleX = true,
+                            CanScaleY = true,
+
+                            OnRotation = handleRotation,
+                            OnScale = handleScale
+                        }
+                    }
+                });
+
+            AddToggleStep("toggle rotation", state => selectionBox.CanRotate = state);
+            AddToggleStep("toggle x", state => selectionBox.CanScaleX = state);
+            AddToggleStep("toggle y", state => selectionBox.CanScaleY = state);
+        }
+
+        private bool handleScale(Vector2 amount, Anchor reference)
+        {
+            if ((reference & Anchor.y1) == 0)
+            {
+                int directionY = (reference & Anchor.y0) > 0 ? -1 : 1;
+                if (directionY < 0)
+                    selectionArea.Y += amount.Y;
+                selectionArea.Height += directionY * amount.Y;
+            }
+
+            if ((reference & Anchor.x1) == 0)
+            {
+                int directionX = (reference & Anchor.x0) > 0 ? -1 : 1;
+                if (directionX < 0)
+                    selectionArea.X += amount.X;
+                selectionArea.Width += directionX * amount.X;
+            }
+
+            return true;
+        }
+
+        private bool handleRotation(float angle)
+        {
+            // kinda silly and wrong, but just showing that the drag handles work.
+            selectionArea.Rotation += angle;
+            return true;
+        }
+    }
+}

osu.Game.Tests/Visual/Editing/TestSceneEditorBeatmapCreation.cs

@@ -0,0 +1,83 @@
+// 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 System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Screens.Edit.Setup;
+using osu.Game.Tests.Resources;
+using SharpCompress.Archives;
+using SharpCompress.Archives.Zip;
+
+namespace osu.Game.Tests.Visual.Editing
+{
+    public class TestSceneEditorBeatmapCreation : EditorTestScene
+    {
+        protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
+
+        protected override bool EditorComponentsReady => Editor.ChildrenOfType<SetupScreen>().SingleOrDefault()?.IsLoaded == true;
+
+        [Resolved]
+        private BeatmapManager beatmapManager { get; set; }
+
+        public override void SetUpSteps()
+        {
+            AddStep("set dummy", () => Beatmap.Value = new DummyWorkingBeatmap(Audio, null));
+
+            base.SetUpSteps();
+
+            // if we save a beatmap with a hash collision, things fall over.
+            // probably needs a more solid resolution in the future but this will do for now.
+            AddStep("make new beatmap unique", () => EditorBeatmap.Metadata.Title = Guid.NewGuid().ToString());
+        }
+
+        [Test]
+        public void TestCreateNewBeatmap()
+        {
+            AddStep("save beatmap", () => Editor.Save());
+            AddAssert("new beatmap persisted", () => EditorBeatmap.BeatmapInfo.ID > 0);
+            AddAssert("new beatmap in database", () => beatmapManager.QueryBeatmapSet(s => s.ID == EditorBeatmap.BeatmapInfo.BeatmapSet.ID)?.DeletePending == false);
+        }
+
+        [Test]
+        public void TestExitWithoutSave()
+        {
+            AddStep("exit without save", () => Editor.Exit());
+            AddUntilStep("wait for exit", () => !Editor.IsCurrentScreen());
+            AddAssert("new beatmap not persisted", () => beatmapManager.QueryBeatmapSet(s => s.ID == EditorBeatmap.BeatmapInfo.BeatmapSet.ID)?.DeletePending == true);
+        }
+
+        [Test]
+        public void TestAddAudioTrack()
+        {
+            AddAssert("switch track to real track", () =>
+            {
+                var setup = Editor.ChildrenOfType<SetupScreen>().First();
+
+                var temp = TestResources.GetTestBeatmapForImport();
+
+                string extractedFolder = $"{temp}_extracted";
+                Directory.CreateDirectory(extractedFolder);
+
+                using (var zip = ZipArchive.Open(temp))
+                    zip.WriteToDirectory(extractedFolder);
+
+                bool success = setup.ChildrenOfType<ResourcesSection>().First().ChangeAudioTrack(Path.Combine(extractedFolder, "03. Renatus - Soleily 192kbps.mp3"));
+
+                File.Delete(temp);
+                Directory.Delete(extractedFolder, true);
+
+                return success;
+            });
+
+            AddAssert("track length changed", () => Beatmap.Value.Track.Length > 60000);
+        }
+    }
+}

osu.Game.Tests/Visual/Editing/TestSceneEditorChangeStates.cs

@@ -1,30 +1,27 @@
 // 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.Testing;
+using osu.Game.Rulesets;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Screens.Edit;
 
 namespace osu.Game.Tests.Visual.Editing
 {
     public class TestSceneEditorChangeStates : EditorTestScene
     {
-        public TestSceneEditorChangeStates()
-            : base(new OsuRuleset())
+        protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
+
+        [Test]
+        public void TestSelectedObjects()
         {
-        }
-
-        private EditorBeatmap editorBeatmap;
-
-        public override void SetUpSteps()
-        {
-            base.SetUpSteps();
-
-            AddStep("get beatmap", () => editorBeatmap = Editor.ChildrenOfType<EditorBeatmap>().Single());
+            HitCircle obj = null;
+            AddStep("add hitobject", () => EditorBeatmap.Add(obj = new HitCircle { StartTime = 1000 }));
+            AddStep("select hitobject", () => EditorBeatmap.SelectedHitObjects.Add(obj));
+            AddAssert("confirm 1 selected", () => EditorBeatmap.SelectedHitObjects.Count == 1);
+            AddStep("deselect hitobject", () => EditorBeatmap.SelectedHitObjects.Remove(obj));
+            AddAssert("confirm 0 selected", () => EditorBeatmap.SelectedHitObjects.Count == 0);
         }
 
         [Test]
@@ -32,11 +29,12 @@ namespace osu.Game.Tests.Visual.Editing
         {
             int hitObjectCount = 0;
 
-            AddStep("get initial state", () => hitObjectCount = editorBeatmap.HitObjects.Count);
+            AddStep("get initial state", () => hitObjectCount = EditorBeatmap.HitObjects.Count);
 
             addUndoSteps();
 
-            AddAssert("no change occurred", () => hitObjectCount == editorBeatmap.HitObjects.Count);
+            AddAssert("no change occurred", () => hitObjectCount == EditorBeatmap.HitObjects.Count);
+            AddAssert("no unsaved changes", () => !Editor.HasUnsavedChanges);
         }
 
         [Test]
@@ -44,11 +42,12 @@ namespace osu.Game.Tests.Visual.Editing
         {
             int hitObjectCount = 0;
 
-            AddStep("get initial state", () => hitObjectCount = editorBeatmap.HitObjects.Count);
+            AddStep("get initial state", () => hitObjectCount = EditorBeatmap.HitObjects.Count);
 
             addRedoSteps();
 
-            AddAssert("no change occurred", () => hitObjectCount == editorBeatmap.HitObjects.Count);
+            AddAssert("no change occurred", () => hitObjectCount == EditorBeatmap.HitObjects.Count);
+            AddAssert("no unsaved changes", () => !Editor.HasUnsavedChanges);
         }
 
         [Test]
@@ -60,15 +59,17 @@ namespace osu.Game.Tests.Visual.Editing
 
             AddStep("bind removal", () =>
             {
-                editorBeatmap.HitObjectAdded += h => addedObject = h;
-                editorBeatmap.HitObjectRemoved += h => removedObject = h;
+                EditorBeatmap.HitObjectAdded += h => addedObject = h;
+                EditorBeatmap.HitObjectRemoved += h => removedObject = h;
             });
 
-            AddStep("add hitobject", () => editorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
+            AddStep("add hitobject", () => EditorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
             AddAssert("hitobject added", () => addedObject == expectedObject);
+            AddAssert("unsaved changes", () => Editor.HasUnsavedChanges);
 
             addUndoSteps();
             AddAssert("hitobject removed", () => removedObject == expectedObject);
+            AddAssert("no unsaved changes", () => !Editor.HasUnsavedChanges);
         }
 
         [Test]
@@ -80,11 +81,11 @@ namespace osu.Game.Tests.Visual.Editing
 
             AddStep("bind removal", () =>
             {
-                editorBeatmap.HitObjectAdded += h => addedObject = h;
-                editorBeatmap.HitObjectRemoved += h => removedObject = h;
+                EditorBeatmap.HitObjectAdded += h => addedObject = h;
+                EditorBeatmap.HitObjectRemoved += h => removedObject = h;
             });
 
-            AddStep("add hitobject", () => editorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
+            AddStep("add hitobject", () => EditorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
             addUndoSteps();
 
             AddStep("reset variables", () =>
@@ -96,6 +97,17 @@ namespace osu.Game.Tests.Visual.Editing
             addRedoSteps();
             AddAssert("hitobject added", () => addedObject.StartTime == expectedObject.StartTime); // Can't compare via equality (new hitobject instance)
             AddAssert("no hitobject removed", () => removedObject == null);
+            AddAssert("unsaved changes", () => Editor.HasUnsavedChanges);
+        }
+
+        [Test]
+        public void TestAddObjectThenSaveHasNoUnsavedChanges()
+        {
+            AddStep("add hitobject", () => EditorBeatmap.Add(new HitCircle { StartTime = 1000 }));
+
+            AddAssert("unsaved changes", () => Editor.HasUnsavedChanges);
+            AddStep("save changes", () => Editor.Save());
+            AddAssert("no unsaved changes", () => !Editor.HasUnsavedChanges);
         }
 
         [Test]
@@ -107,12 +119,12 @@ namespace osu.Game.Tests.Visual.Editing
 
             AddStep("bind removal", () =>
             {
-                editorBeatmap.HitObjectAdded += h => addedObject = h;
-                editorBeatmap.HitObjectRemoved += h => removedObject = h;
+                EditorBeatmap.HitObjectAdded += h => addedObject = h;
+                EditorBeatmap.HitObjectRemoved += h => removedObject = h;
             });
 
-            AddStep("add hitobject", () => editorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
-            AddStep("remove object", () => editorBeatmap.Remove(expectedObject));
+            AddStep("add hitobject", () => EditorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
+            AddStep("remove object", () => EditorBeatmap.Remove(expectedObject));
             AddStep("reset variables", () =>
             {
                 addedObject = null;
@@ -122,6 +134,7 @@ namespace osu.Game.Tests.Visual.Editing
             addUndoSteps();
             AddAssert("hitobject added", () => addedObject.StartTime == expectedObject.StartTime); // Can't compare via equality (new hitobject instance)
             AddAssert("no hitobject removed", () => removedObject == null);
+            AddAssert("unsaved changes", () => Editor.HasUnsavedChanges); // 2 steps performed, 1 undone
         }
 
         [Test]
@@ -133,12 +146,12 @@ namespace osu.Game.Tests.Visual.Editing
 
             AddStep("bind removal", () =>
             {
-                editorBeatmap.HitObjectAdded += h => addedObject = h;
-                editorBeatmap.HitObjectRemoved += h => removedObject = h;
+                EditorBeatmap.HitObjectAdded += h => addedObject = h;
+                EditorBeatmap.HitObjectRemoved += h => removedObject = h;
             });
 
-            AddStep("add hitobject", () => editorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
-            AddStep("remove object", () => editorBeatmap.Remove(expectedObject));
+            AddStep("add hitobject", () => EditorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
+            AddStep("remove object", () => EditorBeatmap.Remove(expectedObject));
             addUndoSteps();
 
             AddStep("reset variables", () =>
@@ -150,19 +163,11 @@ namespace osu.Game.Tests.Visual.Editing
             addRedoSteps();
             AddAssert("hitobject removed", () => removedObject.StartTime == expectedObject.StartTime); // Can't compare via equality (new hitobject instance after undo)
             AddAssert("no hitobject added", () => addedObject == null);
+            AddAssert("no changes", () => !Editor.HasUnsavedChanges); // end result is empty beatmap, matching original state
         }
 
-        private void addUndoSteps() => AddStep("undo", () => ((TestEditor)Editor).Undo());
+        private void addUndoSteps() => AddStep("undo", () => Editor.Undo());
 
-        private void addRedoSteps() => AddStep("redo", () => ((TestEditor)Editor).Redo());
-
-        protected override Editor CreateEditor() => new TestEditor();
-
-        private class TestEditor : Editor
-        {
-            public new void Undo() => base.Undo();
-
-            public new void Redo() => base.Redo();
-        }
+        private void addRedoSteps() => AddStep("redo", () => Editor.Redo());
     }
 }

osu.Game.Tests/Visual/Editing/TestSceneEditorClipboard.cs

@@ -0,0 +1,154 @@
+// 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.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Tests.Beatmaps;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Editing
+{
+    public class TestSceneEditorClipboard : EditorTestScene
+    {
+        protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new TestBeatmap(ruleset, false);
+
+        [Test]
+        public void TestCutRemovesObjects()
+        {
+            var addedObject = new HitCircle { StartTime = 1000 };
+
+            AddStep("add hitobject", () => EditorBeatmap.Add(addedObject));
+
+            AddStep("select added object", () => EditorBeatmap.SelectedHitObjects.Add(addedObject));
+
+            AddStep("cut hitobject", () => Editor.Cut());
+
+            AddAssert("no hitobjects in beatmap", () => EditorBeatmap.HitObjects.Count == 0);
+        }
+
+        [TestCase(1000)]
+        [TestCase(2000)]
+        public void TestCutPaste(double newTime)
+        {
+            var addedObject = new HitCircle { StartTime = 1000 };
+
+            AddStep("add hitobject", () => EditorBeatmap.Add(addedObject));
+
+            AddStep("select added object", () => EditorBeatmap.SelectedHitObjects.Add(addedObject));
+
+            AddStep("cut hitobject", () => Editor.Cut());
+
+            AddStep("move forward in time", () => EditorClock.Seek(newTime));
+
+            AddStep("paste hitobject", () => Editor.Paste());
+
+            AddAssert("is one object", () => EditorBeatmap.HitObjects.Count == 1);
+
+            AddAssert("new object selected", () => EditorBeatmap.SelectedHitObjects.Single().StartTime == newTime);
+        }
+
+        [Test]
+        public void TestCutPasteSlider()
+        {
+            var addedObject = new Slider
+            {
+                StartTime = 1000,
+                Path = new SliderPath
+                {
+                    ControlPoints =
+                    {
+                        new PathControlPoint(),
+                        new PathControlPoint(new Vector2(100, 0), PathType.Bezier)
+                    }
+                }
+            };
+
+            AddStep("add hitobject", () => EditorBeatmap.Add(addedObject));
+
+            AddStep("select added object", () => EditorBeatmap.SelectedHitObjects.Add(addedObject));
+
+            AddStep("cut hitobject", () => Editor.Cut());
+
+            AddStep("paste hitobject", () => Editor.Paste());
+
+            AddAssert("is one object", () => EditorBeatmap.HitObjects.Count == 1);
+
+            AddAssert("path matches", () =>
+            {
+                var path = ((Slider)EditorBeatmap.HitObjects.Single()).Path;
+                return path.ControlPoints.Count == 2 && path.ControlPoints.SequenceEqual(addedObject.Path.ControlPoints);
+            });
+        }
+
+        [Test]
+        public void TestCutPasteSpinner()
+        {
+            var addedObject = new Spinner
+            {
+                StartTime = 1000,
+                Duration = 5000
+            };
+
+            AddStep("add hitobject", () => EditorBeatmap.Add(addedObject));
+
+            AddStep("select added object", () => EditorBeatmap.SelectedHitObjects.Add(addedObject));
+
+            AddStep("cut hitobject", () => Editor.Cut());
+
+            AddStep("paste hitobject", () => Editor.Paste());
+
+            AddAssert("is one object", () => EditorBeatmap.HitObjects.Count == 1);
+
+            AddAssert("duration matches", () => ((Spinner)EditorBeatmap.HitObjects.Single()).Duration == 5000);
+        }
+
+        [Test]
+        public void TestCopyPaste()
+        {
+            var addedObject = new HitCircle { StartTime = 1000 };
+
+            AddStep("add hitobject", () => EditorBeatmap.Add(addedObject));
+
+            AddStep("select added object", () => EditorBeatmap.SelectedHitObjects.Add(addedObject));
+
+            AddStep("copy hitobject", () => Editor.Copy());
+
+            AddStep("move forward in time", () => EditorClock.Seek(2000));
+
+            AddStep("paste hitobject", () => Editor.Paste());
+
+            AddAssert("are two objects", () => EditorBeatmap.HitObjects.Count == 2);
+
+            AddAssert("new object selected", () => EditorBeatmap.SelectedHitObjects.Single().StartTime == 2000);
+        }
+
+        [Test]
+        public void TestCutNothing()
+        {
+            AddStep("cut hitobject", () => Editor.Cut());
+            AddAssert("are no objects", () => EditorBeatmap.HitObjects.Count == 0);
+        }
+
+        [Test]
+        public void TestCopyNothing()
+        {
+            AddStep("copy hitobject", () => Editor.Copy());
+            AddAssert("are no objects", () => EditorBeatmap.HitObjects.Count == 0);
+        }
+
+        [Test]
+        public void TestPasteNothing()
+        {
+            AddStep("paste hitobject", () => Editor.Paste());
+            AddAssert("are no objects", () => EditorBeatmap.HitObjects.Count == 0);
+        }
+    }
+}

osu.Game.Tests/Visual/Editing/TestSceneEditorComposeRadioButtons.cs

@@ -3,6 +3,7 @@
 
 using NUnit.Framework;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Screens.Edit.Components.RadioButtons;
 
 namespace osu.Game.Tests.Visual.Editing
@@ -22,7 +23,7 @@ namespace osu.Game.Tests.Visual.Editing
                 {
                     new RadioButton("Item 1", () => { }),
                     new RadioButton("Item 2", () => { }),
-                    new RadioButton("Item 3", () => { }),
+                    new RadioButton("Item 3", () => { }, () => new SpriteIcon { Icon = FontAwesome.Regular.Angry }),
                     new RadioButton("Item 4", () => { }),
                     new RadioButton("Item 5", () => { })
                 }

osu.Game.Tests/Visual/Editing/TestSceneEditorQuickDelete.cs

@@ -0,0 +1,88 @@
+// 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.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
+using osu.Game.Tests.Beatmaps;
+using osu.Game.Screens.Edit.Compose.Components;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Editing
+{
+    public class TestSceneEditorQuickDelete : EditorTestScene
+    {
+        protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new TestBeatmap(ruleset, false);
+
+        private BlueprintContainer blueprintContainer
+            => Editor.ChildrenOfType<BlueprintContainer>().First();
+
+        [Test]
+        public void TestQuickDeleteRemovesObject()
+        {
+            var addedObject = new HitCircle { StartTime = 1000 };
+
+            AddStep("add hitobject", () => EditorBeatmap.Add(addedObject));
+
+            AddStep("select added object", () => EditorBeatmap.SelectedHitObjects.Add(addedObject));
+
+            AddStep("move mouse to object", () =>
+            {
+                var pos = blueprintContainer.ChildrenOfType<HitCirclePiece>().First().ScreenSpaceDrawQuad.Centre;
+                InputManager.MoveMouseTo(pos);
+            });
+            AddStep("hold shift", () => InputManager.PressKey(Key.ShiftLeft));
+            AddStep("right click", () => InputManager.Click(MouseButton.Right));
+            AddStep("release shift", () => InputManager.ReleaseKey(Key.ShiftLeft));
+
+            AddAssert("no hitobjects in beatmap", () => EditorBeatmap.HitObjects.Count == 0);
+        }
+
+        [Test]
+        public void TestQuickDeleteRemovesSliderControlPoint()
+        {
+            Slider slider = new Slider { StartTime = 1000 };
+
+            PathControlPoint[] points =
+            {
+                new PathControlPoint(),
+                new PathControlPoint(new Vector2(50, 0)),
+                new PathControlPoint(new Vector2(100, 0))
+            };
+
+            AddStep("add slider", () =>
+            {
+                slider.Path = new SliderPath(points);
+                EditorBeatmap.Add(slider);
+            });
+
+            AddStep("select added slider", () => EditorBeatmap.SelectedHitObjects.Add(slider));
+
+            AddStep("move mouse to controlpoint", () =>
+            {
+                var pos = blueprintContainer.ChildrenOfType<PathControlPointPiece>().ElementAt(1).ScreenSpaceDrawQuad.Centre;
+                InputManager.MoveMouseTo(pos);
+            });
+            AddStep("hold shift", () => InputManager.PressKey(Key.ShiftLeft));
+
+            AddStep("right click", () => InputManager.Click(MouseButton.Right));
+            AddAssert("slider has 2 points", () => slider.Path.ControlPoints.Count == 2);
+
+            // second click should nuke the object completely.
+            AddStep("right click", () => InputManager.Click(MouseButton.Right));
+            AddAssert("no hitobjects in beatmap", () => EditorBeatmap.HitObjects.Count == 0);
+
+            AddStep("release shift", () => InputManager.ReleaseKey(Key.ShiftLeft));
+        }
+    }
+}

osu.Game.Tests/Visual/Editing/TestSceneEditorSamplePlayback.cs

@@ -0,0 +1,50 @@
+// 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.Graphics.Audio;
+using osu.Framework.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+
+namespace osu.Game.Tests.Visual.Editing
+{
+    public class TestSceneEditorSamplePlayback : EditorTestScene
+    {
+        protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
+
+        [Test]
+        public void TestSlidingSampleStopsOnSeek()
+        {
+            DrawableSlider slider = null;
+            DrawableSample[] loopingSamples = null;
+            DrawableSample[] onceOffSamples = null;
+
+            AddStep("get first slider", () =>
+            {
+                slider = Editor.ChildrenOfType<DrawableSlider>().OrderBy(s => s.HitObject.StartTime).First();
+                onceOffSamples = slider.ChildrenOfType<DrawableSample>().Where(s => !s.Looping).ToArray();
+                loopingSamples = slider.ChildrenOfType<DrawableSample>().Where(s => s.Looping).ToArray();
+            });
+
+            AddStep("start playback", () => EditorClock.Start());
+
+            AddUntilStep("wait for slider sliding then seek", () =>
+            {
+                if (!slider.Tracking.Value)
+                    return false;
+
+                if (!loopingSamples.Any(s => s.Playing))
+                    return false;
+
+                EditorClock.Seek(20000);
+                return true;
+            });
+
+            AddAssert("non-looping samples are playing", () => onceOffSamples.Length == 4 && loopingSamples.All(s => s.Played || s.Playing));
+            AddAssert("looping samples are not playing", () => loopingSamples.Length == 1 && loopingSamples.All(s => s.Played && !s.Playing));
+        }
+    }
+}

osu.Game.Tests/Visual/Editing/TestSceneEditorSeekSnapping.cs

@@ -175,13 +175,13 @@ namespace osu.Game.Tests.Visual.Editing
             AddAssert("Time = 50", () => Clock.CurrentTime == 50);
             AddStep("Seek(49.999)", () => Clock.Seek(49.999));
             AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
-            AddAssert("Time = 50", () => Clock.CurrentTime == 50);
+            AddAssert("Time = 100", () => Clock.CurrentTime == 100);
             AddStep("Seek(99)", () => Clock.Seek(99));
             AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
             AddAssert("Time = 100", () => Clock.CurrentTime == 100);
             AddStep("Seek(99.999)", () => Clock.Seek(99.999));
             AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
-            AddAssert("Time = 100", () => Clock.CurrentTime == 100);
+            AddAssert("Time = 100", () => Clock.CurrentTime == 150);
             AddStep("Seek(174)", () => Clock.Seek(174));
             AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
             AddAssert("Time = 175", () => Clock.CurrentTime == 175);

osu.Game.Tests/Visual/Editing/TestSceneSetupScreen.cs

@@ -0,0 +1,32 @@
+// 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.Allocation;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Setup;
+
+namespace osu.Game.Tests.Visual.Editing
+{
+    [TestFixture]
+    public class TestSceneSetupScreen : EditorClockTestScene
+    {
+        [Cached(typeof(EditorBeatmap))]
+        [Cached(typeof(IBeatSnapProvider))]
+        private readonly EditorBeatmap editorBeatmap;
+
+        public TestSceneSetupScreen()
+        {
+            editorBeatmap = new EditorBeatmap(new OsuBeatmap());
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Beatmap.Value = CreateWorkingBeatmap(editorBeatmap.PlayableBeatmap);
+            Child = new SetupScreen();
+        }
+    }
+}

osu.Game.Tests/Visual/Editing/TestSceneTimelineBlueprintContainer.cs

@@ -10,7 +10,7 @@ namespace osu.Game.Tests.Visual.Editing
     [TestFixture]
     public class TestSceneTimelineBlueprintContainer : TimelineTestScene
     {
-        public override Drawable CreateTestComponent() => new TimelineBlueprintContainer();
+        public override Drawable CreateTestComponent() => new TimelineBlueprintContainer(Composer);
 
         protected override void LoadComplete()
         {

osu.Game.Tests/Visual/Editing/TestSceneTimelineTickDisplay.cs

@@ -5,7 +5,6 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Screens.Edit.Compose.Components;
-using osu.Game.Screens.Edit.Compose.Components.Timeline;
 using osuTK;
 
 namespace osu.Game.Tests.Visual.Editing
@@ -13,7 +12,7 @@ namespace osu.Game.Tests.Visual.Editing
     [TestFixture]
     public class TestSceneTimelineTickDisplay : TimelineTestScene
     {
-        public override Drawable CreateTestComponent() => new TimelineTickDisplay();
+        public override Drawable CreateTestComponent() => Empty(); // tick display is implicitly inside the timeline.
 
         [BackgroundDependencyLoader]
         private void load()

osu.Game.Tests/Visual/Editing/TestSceneTimingScreen.cs

@@ -3,7 +3,8 @@
 
 using NUnit.Framework;
 using osu.Framework.Allocation;
-using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Timing;
 
@@ -13,18 +14,29 @@ namespace osu.Game.Tests.Visual.Editing
     public class TestSceneTimingScreen : EditorClockTestScene
     {
         [Cached(typeof(EditorBeatmap))]
+        [Cached(typeof(IBeatSnapProvider))]
         private readonly EditorBeatmap editorBeatmap;
 
+        protected override bool ScrollUsingMouseWheel => false;
+
         public TestSceneTimingScreen()
         {
-            editorBeatmap = new EditorBeatmap(new OsuBeatmap());
+            editorBeatmap = new EditorBeatmap(CreateBeatmap(new OsuRuleset().RulesetInfo));
         }
 
         [BackgroundDependencyLoader]
         private void load()
         {
             Beatmap.Value = CreateWorkingBeatmap(editorBeatmap.PlayableBeatmap);
+            Beatmap.Disabled = true;
+
             Child = new TimingScreen();
         }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            Beatmap.Disabled = false;
+            base.Dispose(isDisposing);
+        }
     }
 }

osu.Game.Tests/Visual/Editing/TestSceneWaveform.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Threading;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
@@ -76,7 +77,7 @@ namespace osu.Game.Tests.Visual.Editing
                 };
             });
 
-            AddUntilStep("wait for load", () => graph.ResampledWaveform != null);
+            AddUntilStep("wait for load", () => graph.Loaded.IsSet);
         }
 
         [Test]
@@ -98,12 +99,18 @@ namespace osu.Game.Tests.Visual.Editing
                 };
             });
 
-            AddUntilStep("wait for load", () => graph.ResampledWaveform != null);
+            AddUntilStep("wait for load", () => graph.Loaded.IsSet);
         }
 
         public class TestWaveformGraph : WaveformGraph
         {
-            public new Waveform ResampledWaveform => base.ResampledWaveform;
+            public readonly ManualResetEventSlim Loaded = new ManualResetEventSlim();
+
+            protected override void OnWaveformRegenerated(Waveform waveform)
+            {
+                base.OnWaveformRegenerated(waveform);
+                Loaded.Set();
+            }
         }
     }
 }

osu.Game.Tests/Visual/Editing/TestSceneZoomableScrollContainer.cs

@@ -7,13 +7,14 @@ using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Utils;
 using osu.Framework.Testing;
+using osu.Framework.Utils;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Cursor;
 using osu.Game.Screens.Edit.Compose.Components.Timeline;
 using osuTK;
 using osuTK.Graphics;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Editing
 {
@@ -88,6 +89,7 @@ namespace osu.Game.Tests.Visual.Editing
 
             // Scroll in at 0.25
             AddStep("Move mouse to 0.25x", () => InputManager.MoveMouseTo(new Vector2(scrollQuad.TopLeft.X + 0.25f * scrollQuad.Size.X, scrollQuad.Centre.Y)));
+            AddStep("Press alt down", () => InputManager.PressKey(Key.AltLeft));
             AddStep("Scroll by 3", () => InputManager.ScrollBy(new Vector2(0, 3)));
             AddAssert("Box not at 0", () => !Precision.AlmostEquals(boxQuad.TopLeft, scrollQuad.TopLeft));
             AddAssert("Box 1/4 at 1/4", () => Precision.AlmostEquals(boxQuad.TopLeft.X + 0.25f * boxQuad.Size.X, scrollQuad.TopLeft.X + 0.25f * scrollQuad.Size.X));
@@ -96,6 +98,25 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("Scroll by -3", () => InputManager.ScrollBy(new Vector2(0, -3)));
             AddAssert("Box at 0", () => Precision.AlmostEquals(boxQuad.TopLeft, scrollQuad.TopLeft));
             AddAssert("Box 1/4 at 1/4", () => Precision.AlmostEquals(boxQuad.TopLeft.X + 0.25f * boxQuad.Size.X, scrollQuad.TopLeft.X + 0.25f * scrollQuad.Size.X));
+            AddStep("Release alt", () => InputManager.ReleaseKey(Key.AltLeft));
+        }
+
+        [Test]
+        public void TestMouseZoomInThenScroll()
+        {
+            reset();
+
+            // Scroll in at 0.25
+            AddStep("Move mouse to 0.25x", () => InputManager.MoveMouseTo(new Vector2(scrollQuad.TopLeft.X + 0.25f * scrollQuad.Size.X, scrollQuad.Centre.Y)));
+            AddStep("Press alt down", () => InputManager.PressKey(Key.AltLeft));
+            AddStep("Zoom by 3", () => InputManager.ScrollBy(new Vector2(0, 3)));
+            AddStep("Release alt", () => InputManager.ReleaseKey(Key.AltLeft));
+
+            AddStep("Scroll far left", () => InputManager.ScrollBy(new Vector2(0, 30)));
+            AddUntilStep("Scroll is at start", () => Precision.AlmostEquals(scrollQuad.TopLeft.X, boxQuad.TopLeft.X, 1));
+
+            AddStep("Scroll far right", () => InputManager.ScrollBy(new Vector2(0, -300)));
+            AddUntilStep("Scroll is at end", () => Precision.AlmostEquals(scrollQuad.TopRight.X, boxQuad.TopRight.X, 1));
         }
 
         [Test]
@@ -103,6 +124,8 @@ namespace osu.Game.Tests.Visual.Editing
         {
             reset();
 
+            AddStep("Press alt down", () => InputManager.PressKey(Key.AltLeft));
+
             // Scroll in at 0.25
             AddStep("Move mouse to 0.25x", () => InputManager.MoveMouseTo(new Vector2(scrollQuad.TopLeft.X + 0.25f * scrollQuad.Size.X, scrollQuad.Centre.Y)));
             AddStep("Scroll by 1", () => InputManager.ScrollBy(new Vector2(0, 1)));
@@ -124,6 +147,8 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("Move mouse to 0.25x", () => InputManager.MoveMouseTo(new Vector2(scrollQuad.TopLeft.X + 0.25f * scrollQuad.Size.X, scrollQuad.Centre.Y)));
             AddStep("Scroll by -1", () => InputManager.ScrollBy(new Vector2(0, -1)));
             AddAssert("Box at 0", () => Precision.AlmostEquals(boxQuad.TopLeft, scrollQuad.TopLeft));
+
+            AddStep("Release alt", () => InputManager.ReleaseKey(Key.AltLeft));
         }
 
         private void reset()

osu.Game.Tests/Visual/Editing/TimelineTestScene.cs

@@ -21,21 +21,25 @@ namespace osu.Game.Tests.Visual.Editing
     {
         protected TimelineArea TimelineArea { get; private set; }
 
+        protected HitObjectComposer Composer { get; private set; }
+
         [BackgroundDependencyLoader]
         private void load(AudioManager audio)
         {
             Beatmap.Value = new WaveformTestBeatmap(audio);
 
             var playable = Beatmap.Value.GetPlayableBeatmap(Beatmap.Value.BeatmapInfo.Ruleset);
-
             var editorBeatmap = new EditorBeatmap(playable);
 
             Dependencies.Cache(editorBeatmap);
             Dependencies.CacheAs<IBeatSnapProvider>(editorBeatmap);
 
+            Composer = playable.BeatmapInfo.Ruleset.CreateInstance().CreateHitObjectComposer().With(d => d.Alpha = 0);
+
             AddRange(new Drawable[]
             {
                 editorBeatmap,
+                Composer,
                 new FillFlowContainer
                 {
                     AutoSizeAxes = Axes.Both,

osu.Game.Tests/Visual/Gameplay/OsuPlayerTestScene.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.
+
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    /// <summary>
+    /// A <see cref="PlayerTestScene"/> with an arbitrary ruleset value to test with.
+    /// </summary>
+    public abstract class OsuPlayerTestScene : PlayerTestScene
+    {
+        protected override Ruleset CreatePlayerRuleset() => new OsuRuleset();
+    }
+}

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

@@ -11,6 +11,7 @@ using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.Break;
 using osu.Game.Screens.Ranking;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
@@ -35,6 +36,18 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("rewind", () => Player.GameplayClockContainer.Seek(-80000));
             AddUntilStep("key counter reset", () => Player.HUDOverlay.KeyCounter.Children.All(kc => kc.CountPresses == 0));
 
+            double? time = null;
+
+            AddStep("store time", () => time = Player.GameplayClockContainer.GameplayClock.CurrentTime);
+
+            // test seek via keyboard
+            AddStep("seek with right arrow key", () => InputManager.Key(Key.Right));
+            AddAssert("time seeked forward", () => Player.GameplayClockContainer.GameplayClock.CurrentTime > time + 2000);
+
+            AddStep("store time", () => time = Player.GameplayClockContainer.GameplayClock.CurrentTime);
+            AddStep("seek with left arrow key", () => InputManager.Key(Key.Left));
+            AddAssert("time seeked backward", () => Player.GameplayClockContainer.GameplayClock.CurrentTime < time);
+
             seekToBreak(0);
             seekToBreak(1);
 

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

@@ -0,0 +1,47 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Screens.Play.HUD;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneComboCounter : SkinnableTestScene
+    {
+        private IEnumerable<SkinnableComboCounter> comboCounters => CreatedDrawables.OfType<SkinnableComboCounter>();
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("Create combo counters", () => SetContents(() =>
+            {
+                var comboCounter = new SkinnableComboCounter();
+                comboCounter.Current.Value = 1;
+                return comboCounter;
+            }));
+        }
+
+        [Test]
+        public void TestComboCounterIncrementing()
+        {
+            AddRepeatStep("increase combo", () =>
+            {
+                foreach (var counter in comboCounters)
+                    counter.Current.Value++;
+            }, 10);
+
+            AddStep("reset combo", () =>
+            {
+                foreach (var counter in comboCounters)
+                    counter.Current.Value = 0;
+            });
+        }
+    }
+}

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

@@ -4,23 +4,19 @@
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
-using osu.Framework.Audio.Track;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets;
-using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Storyboards;
 using osuTK;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
-    public class TestSceneCompletionCancellation : PlayerTestScene
+    public class TestSceneCompletionCancellation : OsuPlayerTestScene
     {
-        private Track track;
-
         [Resolved]
         private AudioManager audio { get; set; }
 
@@ -29,18 +25,13 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         protected override bool AllowFail => false;
 
-        public TestSceneCompletionCancellation()
-            : base(new OsuRuleset())
-        {
-        }
-
         [SetUpSteps]
         public override void SetUpSteps()
         {
             base.SetUpSteps();
 
             // Ensure track has actually running before attempting to seek
-            AddUntilStep("wait for track to start running", () => track.IsRunning);
+            AddUntilStep("wait for track to start running", () => Beatmap.Value.Track.IsRunning);
         }
 
         [Test]
@@ -79,13 +70,13 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private void complete()
         {
-            AddStep("seek to completion", () => track.Seek(5000));
+            AddStep("seek to completion", () => Beatmap.Value.Track.Seek(5000));
             AddUntilStep("completion set by processor", () => Player.ScoreProcessor.HasCompleted.Value);
         }
 
         private void cancel()
         {
-            AddStep("rewind to cancel", () => track.Seek(4000));
+            AddStep("rewind to cancel", () => Beatmap.Value.Track.Seek(4000));
             AddUntilStep("completion cleared by processor", () => !Player.ScoreProcessor.HasCompleted.Value);
         }
 
@@ -97,11 +88,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         }
 
         protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null)
-        {
-            var working = new ClockBackedTestWorkingBeatmap(beatmap, storyboard, new FramedClock(new ManualClock { Rate = 1 }), audio);
-            track = working.Track;
-            return working;
-        }
+            => new ClockBackedTestWorkingBeatmap(beatmap, storyboard, new FramedClock(new ManualClock { Rate = 1 }), audio);
 
         protected override IBeatmap CreateBeatmap(RulesetInfo ruleset)
         {

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

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using NUnit.Framework;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -276,7 +277,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             public override bool CanConvert() => true;
 
-            protected override IEnumerable<TestHitObject> ConvertHitObject(HitObject original, IBeatmap beatmap)
+            protected override IEnumerable<TestHitObject> ConvertHitObject(HitObject original, IBeatmap beatmap, CancellationToken cancellationToken)
             {
                 yield return new TestHitObject
                 {

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

@@ -0,0 +1,65 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Skinning;
+using osu.Game.Storyboards;
+using osu.Game.Storyboards.Drawables;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneDrawableStoryboardSprite : SkinnableTestScene
+    {
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
+
+        [Cached]
+        private Storyboard storyboard { get; set; } = new Storyboard();
+
+        [Test]
+        public void TestSkinSpriteDisallowedByDefault()
+        {
+            const string lookup_name = "hitcircleoverlay";
+
+            AddStep("allow skin lookup", () => storyboard.UseSkinSprites = false);
+
+            AddStep("create sprites", () => SetContents(
+                () => createSprite(lookup_name, Anchor.TopLeft, Vector2.Zero)));
+
+            assertSpritesFromSkin(false);
+        }
+
+        [Test]
+        public void TestAllowLookupFromSkin()
+        {
+            const string lookup_name = "hitcircleoverlay";
+
+            AddStep("allow skin lookup", () => storyboard.UseSkinSprites = true);
+
+            AddStep("create sprites", () => SetContents(
+                () => createSprite(lookup_name, Anchor.Centre, Vector2.Zero)));
+
+            assertSpritesFromSkin(true);
+        }
+
+        private DrawableStoryboardSprite createSprite(string lookupName, Anchor origin, Vector2 initialPosition)
+            => new DrawableStoryboardSprite(
+                new StoryboardSprite(lookupName, origin, initialPosition)
+            ).With(s =>
+            {
+                s.LifetimeStart = double.MinValue;
+                s.LifetimeEnd = double.MaxValue;
+            });
+
+        private void assertSpritesFromSkin(bool fromSkin) =>
+            AddAssert($"sprites are {(fromSkin ? "from skin" : "from storyboard")}",
+                () => this.ChildrenOfType<DrawableStoryboardSprite>()
+                          .All(sprite => sprite.ChildrenOfType<SkinnableSprite>().Any() == fromSkin));
+    }
+}

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

@@ -6,6 +6,7 @@ using System.Linq;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
 using osu.Game.Screens.Play;
 
 namespace osu.Game.Tests.Visual.Gameplay
@@ -21,8 +22,14 @@ namespace osu.Game.Tests.Visual.Gameplay
         protected override void AddCheckSteps()
         {
             AddUntilStep("wait for fail", () => Player.HasFailed);
-            AddUntilStep("wait for multiple judged objects", () => ((FailPlayer)Player).DrawableRuleset.Playfield.AllHitObjects.Count(h => h.AllJudged) > 1);
-            AddAssert("total judgements == 1", () => ((FailPlayer)Player).HealthProcessor.JudgedHits >= 1);
+            AddUntilStep("wait for multiple judgements", () => ((FailPlayer)Player).ScoreProcessor.JudgedHits > 1);
+            AddAssert("total number of results == 1", () =>
+            {
+                var score = new ScoreInfo();
+                ((FailPlayer)Player).ScoreProcessor.PopulateScore(score);
+
+                return score.Statistics.Values.Sum() == 1;
+            });
         }
 
         private class FailPlayer : TestPlayer

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

@@ -3,6 +3,7 @@
 
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Testing;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Scoring;
@@ -14,6 +15,8 @@ namespace osu.Game.Tests.Visual.Gameplay
     {
         private FailingLayer layer;
 
+        private readonly Bindable<bool> showHealth = new Bindable<bool>();
+
         [Resolved]
         private OsuConfigManager config { get; set; }
 
@@ -24,8 +27,10 @@ namespace osu.Game.Tests.Visual.Gameplay
             {
                 Child = layer = new FailingLayer();
                 layer.BindHealthProcessor(new DrainingHealthProcessor(1));
+                layer.ShowHealth.BindTo(showHealth);
             });
 
+            AddStep("show health", () => showHealth.Value = true);
             AddStep("enable layer", () => config.Set(OsuSetting.FadePlayfieldWhenHealthLow, true));
             AddUntilStep("layer is visible", () => layer.IsPresent);
         }
@@ -69,5 +74,27 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddWaitStep("wait for potential fade", 10);
             AddAssert("layer is still visible", () => layer.IsPresent);
         }
+
+        [Test]
+        public void TestLayerVisibilityWithDifferentOptions()
+        {
+            AddStep("set health to 0.10", () => layer.Current.Value = 0.1);
+
+            AddStep("don't show health", () => showHealth.Value = false);
+            AddStep("disable FadePlayfieldWhenHealthLow", () => config.Set(OsuSetting.FadePlayfieldWhenHealthLow, false));
+            AddUntilStep("layer fade is invisible", () => !layer.IsPresent);
+
+            AddStep("don't show health", () => showHealth.Value = false);
+            AddStep("enable FadePlayfieldWhenHealthLow", () => config.Set(OsuSetting.FadePlayfieldWhenHealthLow, true));
+            AddUntilStep("layer fade is invisible", () => !layer.IsPresent);
+
+            AddStep("show health", () => showHealth.Value = true);
+            AddStep("disable FadePlayfieldWhenHealthLow", () => config.Set(OsuSetting.FadePlayfieldWhenHealthLow, false));
+            AddUntilStep("layer fade is invisible", () => !layer.IsPresent);
+
+            AddStep("show health", () => showHealth.Value = true);
+            AddStep("enable FadePlayfieldWhenHealthLow", () => config.Set(OsuSetting.FadePlayfieldWhenHealthLow, true));
+            AddUntilStep("layer fade is visible", () => layer.IsPresent);
+        }
     }
 }

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

@@ -86,7 +86,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             showOverlay();
 
-            AddStep("Up arrow", () => press(Key.Up));
+            AddStep("Up arrow", () => InputManager.Key(Key.Up));
             AddAssert("Last button selected", () => pauseOverlay.Buttons.Last().Selected.Value);
         }
 
@@ -98,7 +98,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             showOverlay();
 
-            AddStep("Down arrow", () => press(Key.Down));
+            AddStep("Down arrow", () => InputManager.Key(Key.Down));
             AddAssert("First button selected", () => getButton(0).Selected.Value);
         }
 
@@ -110,11 +110,11 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddStep("Show overlay", () => failOverlay.Show());
 
-            AddStep("Up arrow", () => press(Key.Up));
+            AddStep("Up arrow", () => InputManager.Key(Key.Up));
             AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected.Value);
-            AddStep("Up arrow", () => press(Key.Up));
+            AddStep("Up arrow", () => InputManager.Key(Key.Up));
             AddAssert("First button selected", () => failOverlay.Buttons.First().Selected.Value);
-            AddStep("Up arrow", () => press(Key.Up));
+            AddStep("Up arrow", () => InputManager.Key(Key.Up));
             AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected.Value);
         }
 
@@ -126,11 +126,11 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddStep("Show overlay", () => failOverlay.Show());
 
-            AddStep("Down arrow", () => press(Key.Down));
+            AddStep("Down arrow", () => InputManager.Key(Key.Down));
             AddAssert("First button selected", () => failOverlay.Buttons.First().Selected.Value);
-            AddStep("Down arrow", () => press(Key.Down));
+            AddStep("Down arrow", () => InputManager.Key(Key.Down));
             AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected.Value);
-            AddStep("Down arrow", () => press(Key.Down));
+            AddStep("Down arrow", () => InputManager.Key(Key.Down));
             AddAssert("First button selected", () => failOverlay.Buttons.First().Selected.Value);
         }
 
@@ -177,7 +177,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             showOverlay();
 
-            AddStep("Down arrow", () => press(Key.Down));
+            AddStep("Down arrow", () => InputManager.Key(Key.Down));
             AddStep("Hover second button", () => InputManager.MoveMouseTo(getButton(1)));
             AddAssert("First button not selected", () => !getButton(0).Selected.Value);
             AddAssert("Second button selected", () => getButton(1).Selected.Value);
@@ -195,7 +195,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             });
 
             AddStep("Hover second button", () => InputManager.MoveMouseTo(getButton(1)));
-            AddStep("Up arrow", () => press(Key.Up));
+            AddStep("Up arrow", () => InputManager.Key(Key.Up));
             AddAssert("Second button not selected", () => !getButton(1).Selected.Value);
             AddAssert("First button selected", () => getButton(0).Selected.Value);
         }
@@ -210,7 +210,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddStep("Hover second button", () => InputManager.MoveMouseTo(getButton(1)));
             AddStep("Unhover second button", () => InputManager.MoveMouseTo(Vector2.Zero));
-            AddStep("Down arrow", () => press(Key.Down));
+            AddStep("Down arrow", () => InputManager.Key(Key.Down));
             AddAssert("First button selected", () => getButton(0).Selected.Value); // Initial state condition
         }
 
@@ -246,8 +246,8 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddStep("Select second button", () =>
             {
-                press(Key.Down);
-                press(Key.Down);
+                InputManager.Key(Key.Down);
+                InputManager.Key(Key.Down);
             });
 
             bool triggered = false;
@@ -256,7 +256,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             {
                 lastAction = pauseOverlay.OnRetry;
                 pauseOverlay.OnRetry = () => triggered = true;
-                press(Key.Enter);
+                InputManager.Key(Key.Enter);
             });
 
             AddAssert("Action was triggered", () =>
@@ -272,16 +272,24 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("Overlay is closed", () => pauseOverlay.State.Value == Visibility.Hidden);
         }
 
+        [Test]
+        public void TestSelectionResetOnVisibilityChange()
+        {
+            showOverlay();
+            AddStep("Select last button", () => InputManager.Key(Key.Up));
+
+            hideOverlay();
+            showOverlay();
+
+            AddAssert("No button selected",
+                () => pauseOverlay.Buttons.All(button => !button.Selected.Value));
+        }
+
         private void showOverlay() => AddStep("Show overlay", () => pauseOverlay.Show());
+        private void hideOverlay() => AddStep("Hide overlay", () => pauseOverlay.Hide());
 
         private DialogButton getButton(int index) => pauseOverlay.Buttons.Skip(index).First();
 
-        private void press(Key key)
-        {
-            InputManager.PressKey(key);
-            InputManager.ReleaseKey(key);
-        }
-
         private void press(GlobalAction action)
         {
             globalActionContainer.TriggerPressed(action);

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

@@ -5,41 +5,28 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
-using osu.Framework.Audio.Track;
 using osu.Framework.Utils;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets;
-using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Storyboards;
 using osuTK;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
-    public class TestSceneGameplayRewinding : PlayerTestScene
+    public class TestSceneGameplayRewinding : OsuPlayerTestScene
     {
         [Resolved]
         private AudioManager audioManager { get; set; }
 
-        public TestSceneGameplayRewinding()
-            : base(new OsuRuleset())
-        {
-        }
-
-        private Track track;
-
-        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null)
-        {
-            var working = new ClockBackedTestWorkingBeatmap(beatmap, storyboard, new FramedClock(new ManualClock { Rate = 1 }), audioManager);
-            track = working.Track;
-            return working;
-        }
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null) =>
+            new ClockBackedTestWorkingBeatmap(beatmap, storyboard, new FramedClock(new ManualClock { Rate = 1 }), audioManager);
 
         [Test]
         public void TestNoJudgementsOnRewind()
         {
-            AddUntilStep("wait for track to start running", () => track.IsRunning);
+            AddUntilStep("wait for track to start running", () => Beatmap.Value.Track.IsRunning);
             addSeekStep(3000);
             AddAssert("all judged", () => Player.DrawableRuleset.Playfield.AllHitObjects.All(h => h.Judged));
             AddUntilStep("key counter counted keys", () => Player.HUDOverlay.KeyCounter.Children.All(kc => kc.CountPresses >= 7));
@@ -52,7 +39,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private void addSeekStep(double time)
         {
-            AddStep($"seek to {time}", () => track.Seek(time));
+            AddStep($"seek to {time}", () => Beatmap.Value.Track.Seek(time));
 
             // Allow a few frames of lenience
             AddUntilStep("wait for seek to finish", () => Precision.AlmostEquals(time, Player.DrawableRuleset.FrameStableClock.CurrentTime, 100));

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

@@ -0,0 +1,69 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics.Audio;
+using osu.Framework.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Screens.Play;
+using osu.Game.Skinning;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneGameplaySamplePlayback : PlayerTestScene
+    {
+        [Test]
+        public void TestAllSamplesStopDuringSeek()
+        {
+            DrawableSlider slider = null;
+            DrawableSample[] samples = null;
+            ISamplePlaybackDisabler sampleDisabler = null;
+
+            AddUntilStep("get variables", () =>
+            {
+                sampleDisabler = Player;
+                slider = Player.ChildrenOfType<DrawableSlider>().OrderBy(s => s.HitObject.StartTime).FirstOrDefault();
+                samples = slider?.ChildrenOfType<DrawableSample>().ToArray();
+
+                return slider != null;
+            });
+
+            AddUntilStep("wait for slider sliding then seek", () =>
+            {
+                if (!slider.Tracking.Value)
+                    return false;
+
+                if (!samples.Any(s => s.Playing))
+                    return false;
+
+                Player.ChildrenOfType<GameplayClockContainer>().First().Seek(40000);
+                return true;
+            });
+
+            AddAssert("sample playback disabled", () => sampleDisabler.SamplePlaybackDisabled.Value);
+
+            // because we are in frame stable context, it's quite likely that not all samples are "played" at this point.
+            // the important thing is that at least one started, and that sample has since stopped.
+            AddAssert("all looping samples stopped immediately", () => allStopped(allLoopingSounds));
+            AddUntilStep("all samples stopped eventually", () => allStopped(allSounds));
+
+            AddAssert("sample playback still disabled", () => sampleDisabler.SamplePlaybackDisabled.Value);
+
+            AddUntilStep("seek finished, sample playback enabled", () => !sampleDisabler.SamplePlaybackDisabled.Value);
+            AddUntilStep("any sample is playing", () => Player.ChildrenOfType<PausableSkinnableSound>().Any(s => s.IsPlaying));
+        }
+
+        private IEnumerable<PausableSkinnableSound> allSounds => Player.ChildrenOfType<PausableSkinnableSound>();
+        private IEnumerable<PausableSkinnableSound> allLoopingSounds => allSounds.Where(sound => sound.Looping);
+
+        private bool allStopped(IEnumerable<PausableSkinnableSound> sounds) => sounds.All(sound => !sound.IsPlaying);
+
+        protected override bool Autoplay => true;
+
+        protected override Ruleset CreatePlayerRuleset() => new OsuRuleset();
+    }
+}

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

@@ -26,6 +26,16 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Resolved]
         private OsuConfigManager config { get; set; }
 
+        [Test]
+        public void TestComboCounterIncrementing()
+        {
+            createNew();
+
+            AddRepeatStep("increase combo", () => { hudOverlay.ComboCounter.Current.Value++; }, 10);
+
+            AddStep("reset combo", () => { hudOverlay.ComboCounter.Current.Value = 0; });
+        }
+
         [Test]
         public void TestShownByDefault()
         {
@@ -45,7 +55,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             createNew(h => h.OnLoadComplete += _ => initialAlpha = hideTarget.Alpha);
             AddUntilStep("wait for load", () => hudOverlay.IsAlive);
-            AddAssert("initial alpha was less than 1", () => initialAlpha != null && initialAlpha < 1);
+            AddAssert("initial alpha was less than 1", () => initialAlpha < 1);
         }
 
         [Test]
@@ -62,20 +72,42 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("key counter flow not affected", () => keyCounterFlow.IsPresent);
         }
 
+        [Test]
+        public void TestMomentaryShowHUD()
+        {
+            createNew();
+
+            HUDVisibilityMode originalConfigValue = HUDVisibilityMode.HideDuringGameplay;
+
+            AddStep("get original config value", () => originalConfigValue = config.Get<HUDVisibilityMode>(OsuSetting.HUDVisibilityMode));
+
+            AddStep("set hud to never show", () => config.Set(OsuSetting.HUDVisibilityMode, HUDVisibilityMode.Never));
+
+            AddUntilStep("wait for fade", () => !hideTarget.IsPresent);
+
+            AddStep("trigger momentary show", () => InputManager.PressKey(Key.ControlLeft));
+            AddUntilStep("wait for visible", () => hideTarget.IsPresent);
+
+            AddStep("stop trigering", () => InputManager.ReleaseKey(Key.ControlLeft));
+            AddUntilStep("wait for fade", () => !hideTarget.IsPresent);
+
+            AddStep("set original config value", () => config.Set(OsuSetting.HUDVisibilityMode, originalConfigValue));
+        }
+
         [Test]
         public void TestExternalHideDoesntAffectConfig()
         {
-            bool originalConfigValue = false;
+            HUDVisibilityMode originalConfigValue = HUDVisibilityMode.HideDuringGameplay;
 
             createNew();
 
-            AddStep("get original config value", () => originalConfigValue = config.Get<bool>(OsuSetting.ShowInterface));
+            AddStep("get original config value", () => originalConfigValue = config.Get<HUDVisibilityMode>(OsuSetting.HUDVisibilityMode));
 
             AddStep("set showhud false", () => hudOverlay.ShowHud.Value = false);
-            AddAssert("config unchanged", () => originalConfigValue == config.Get<bool>(OsuSetting.ShowInterface));
+            AddAssert("config unchanged", () => originalConfigValue == config.Get<HUDVisibilityMode>(OsuSetting.HUDVisibilityMode));
 
             AddStep("set showhud true", () => hudOverlay.ShowHud.Value = true);
-            AddAssert("config unchanged", () => originalConfigValue == config.Get<bool>(OsuSetting.ShowInterface));
+            AddAssert("config unchanged", () => originalConfigValue == config.Get<HUDVisibilityMode>(OsuSetting.HUDVisibilityMode));
         }
 
         [Test]
@@ -107,12 +139,16 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddStep("create overlay", () =>
             {
-                Child = hudOverlay = new HUDOverlay(null, null, null, Array.Empty<Mod>());
+                hudOverlay = new HUDOverlay(null, null, null, Array.Empty<Mod>());
 
                 // Add any key just to display the key counter visually.
                 hudOverlay.KeyCounter.Add(new KeyCounterKeyboard(Key.Space));
 
+                hudOverlay.ComboCounter.Current.Value = 1;
+
                 action?.Invoke(hudOverlay);
+
+                Child = hudOverlay;
             });
         }
     }

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

@@ -22,8 +22,10 @@ namespace osu.Game.Tests.Visual.Gameplay
     {
         private BarHitErrorMeter barMeter;
         private BarHitErrorMeter barMeter2;
+        private BarHitErrorMeter barMeter3;
         private ColourHitErrorMeter colourMeter;
         private ColourHitErrorMeter colourMeter2;
+        private ColourHitErrorMeter colourMeter3;
         private HitWindows hitWindows;
 
         public TestSceneHitErrorMeter()
@@ -98,7 +100,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                 Children = new[]
                 {
                     new OsuSpriteText { Text = $@"Great: {hitWindows?.WindowFor(HitResult.Great)}" },
-                    new OsuSpriteText { Text = $@"Good: {hitWindows?.WindowFor(HitResult.Good)}" },
+                    new OsuSpriteText { Text = $@"Good: {hitWindows?.WindowFor(HitResult.Ok)}" },
                     new OsuSpriteText { Text = $@"Meh: {hitWindows?.WindowFor(HitResult.Meh)}" },
                 }
             });
@@ -115,6 +117,13 @@ namespace osu.Game.Tests.Visual.Gameplay
                 Origin = Anchor.CentreLeft,
             });
 
+            Add(barMeter3 = new BarHitErrorMeter(hitWindows, true)
+            {
+                Anchor = Anchor.BottomCentre,
+                Origin = Anchor.CentreLeft,
+                Rotation = 270,
+            });
+
             Add(colourMeter = new ColourHitErrorMeter(hitWindows)
             {
                 Anchor = Anchor.CentreRight,
@@ -128,6 +137,14 @@ namespace osu.Game.Tests.Visual.Gameplay
                 Origin = Anchor.CentreLeft,
                 Margin = new MarginPadding { Left = 50 }
             });
+
+            Add(colourMeter3 = new ColourHitErrorMeter(hitWindows)
+            {
+                Anchor = Anchor.BottomCentre,
+                Origin = Anchor.CentreLeft,
+                Rotation = 270,
+                Margin = new MarginPadding { Left = 50 }
+            });
         }
 
         private void newJudgement(double offset = 0)
@@ -140,8 +157,10 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             barMeter.OnNewJudgement(judgement);
             barMeter2.OnNewJudgement(judgement);
+            barMeter3.OnNewJudgement(judgement);
             colourMeter.OnNewJudgement(judgement);
             colourMeter2.OnNewJudgement(judgement);
+            colourMeter3.OnNewJudgement(judgement);
         }
     }
 }

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

@@ -32,11 +32,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestDefaultsWhenNotDatabased()
         {
-            AddStep("fire key", () =>
-            {
-                InputManager.PressKey(Key.A);
-                InputManager.ReleaseKey(Key.A);
-            });
+            AddStep("fire key", () => InputManager.Key(Key.A));
 
             AddAssert("received key", () => receiver.ReceivedAction);
         }

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

@@ -40,11 +40,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             void addPressKeyStep()
             {
-                AddStep($"Press {testKey} key", () =>
-                {
-                    InputManager.PressKey(testKey);
-                    InputManager.ReleaseKey(testKey);
-                });
+                AddStep($"Press {testKey} key", () => InputManager.Key(testKey));
             }
 
             addPressKeyStep();

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

@@ -0,0 +1,72 @@
+// 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.Bindables;
+using osu.Game.Overlays;
+using osu.Game.Rulesets;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneOverlayActivation : OsuPlayerTestScene
+    {
+        protected new OverlayTestPlayer Player => base.Player as OverlayTestPlayer;
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddUntilStep("gameplay has started",
+                () => Player.GameplayClockContainer.GameplayClock.CurrentTime > Player.DrawableRuleset.GameplayStartTime);
+        }
+
+        [Test]
+        public void TestGameplayOverlayActivation()
+        {
+            AddAssert("local user playing", () => Player.LocalUserPlaying.Value);
+            AddAssert("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
+        }
+
+        [Test]
+        public void TestGameplayOverlayActivationPaused()
+        {
+            AddAssert("local user playing", () => Player.LocalUserPlaying.Value);
+            AddAssert("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
+            AddStep("pause gameplay", () => Player.Pause());
+            AddAssert("local user not playing", () => !Player.LocalUserPlaying.Value);
+            AddUntilStep("activation mode is user triggered", () => Player.OverlayActivationMode == OverlayActivation.UserTriggered);
+        }
+
+        [Test]
+        public void TestGameplayOverlayActivationReplayLoaded()
+        {
+            AddAssert("local user playing", () => Player.LocalUserPlaying.Value);
+            AddAssert("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
+            AddStep("load a replay", () => Player.DrawableRuleset.HasReplayLoaded.Value = true);
+            AddAssert("local user not playing", () => !Player.LocalUserPlaying.Value);
+            AddAssert("activation mode is user triggered", () => Player.OverlayActivationMode == OverlayActivation.UserTriggered);
+        }
+
+        [Test]
+        public void TestGameplayOverlayActivationBreaks()
+        {
+            AddAssert("local user playing", () => Player.LocalUserPlaying.Value);
+            AddAssert("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
+            AddStep("seek to break", () => Player.GameplayClockContainer.Seek(Beatmap.Value.Beatmap.Breaks.First().StartTime));
+            AddUntilStep("activation mode is user triggered", () => Player.OverlayActivationMode == OverlayActivation.UserTriggered);
+            AddAssert("local user not playing", () => !Player.LocalUserPlaying.Value);
+            AddStep("seek to break end", () => Player.GameplayClockContainer.Seek(Beatmap.Value.Beatmap.Breaks.First().EndTime));
+            AddUntilStep("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
+            AddAssert("local user playing", () => Player.LocalUserPlaying.Value);
+        }
+
+        protected override TestPlayer CreatePlayer(Ruleset ruleset) => new OverlayTestPlayer();
+
+        protected class OverlayTestPlayer : TestPlayer
+        {
+            public new OverlayActivation OverlayActivationMode => base.OverlayActivationMode.Value;
+            public new Bindable<bool> LocalUserPlaying => base.LocalUserPlaying;
+        }
+    }
+}

osu.Game.Tests/Visual/Gameplay/TestSceneParticleExplosion.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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Graphics;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    [TestFixture]
+    public class TestSceneParticleExplosion : OsuTestScene
+    {
+        private ParticleExplosion explosion;
+
+        [BackgroundDependencyLoader]
+        private void load(TextureStore textures)
+        {
+            AddStep("create initial", () =>
+            {
+                Child = explosion = new ParticleExplosion(textures.Get("Cursor/cursortrail"), 150, 1200)
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(400)
+                };
+            });
+
+            AddWaitStep("wait for playback", 5);
+
+            AddRepeatStep(@"restart animation", () =>
+            {
+                explosion.Restart();
+            }, 10);
+        }
+    }
+}

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

@@ -10,14 +10,14 @@ using osu.Framework.Testing;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Cursor;
 using osu.Game.Rulesets;
-using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.Play;
+using osu.Game.Skinning;
 using osuTK;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
-    public class TestScenePause : PlayerTestScene
+    public class TestScenePause : OsuPlayerTestScene
     {
         protected new PausePlayer Player => (PausePlayer)base.Player;
 
@@ -26,7 +26,6 @@ namespace osu.Game.Tests.Visual.Gameplay
         protected override Container<Drawable> Content => content;
 
         public TestScenePause()
-            : base(new OsuRuleset())
         {
             base.Content.Add(content = new MenuCursorContainer { RelativeSizeAxes = Axes.Both });
         }
@@ -60,11 +59,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             confirmClockRunning(false);
             confirmPauseOverlayShown(false);
 
-            AddStep("click to resume", () =>
-            {
-                InputManager.PressButton(MouseButton.Left);
-                InputManager.ReleaseButton(MouseButton.Left);
-            });
+            AddStep("click to resume", () => InputManager.Click(MouseButton.Left));
 
             confirmClockRunning(true);
         }
@@ -159,7 +154,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         public void TestQuickRetryFromFailedGameplay()
         {
             AddUntilStep("wait for fail", () => Player.HasFailed);
-            AddStep("quick retry", () => Player.GameplayClockContainer.OfType<HotkeyRetryOverlay>().First().Action?.Invoke());
+            AddStep("quick retry", () => Player.GameplayClockContainer.ChildrenOfType<HotkeyRetryOverlay>().First().Action?.Invoke());
 
             confirmExited();
         }
@@ -168,7 +163,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         public void TestQuickExitFromFailedGameplay()
         {
             AddUntilStep("wait for fail", () => Player.HasFailed);
-            AddStep("quick exit", () => Player.GameplayClockContainer.OfType<HotkeyExitOverlay>().First().Action?.Invoke());
+            AddStep("quick exit", () => Player.GameplayClockContainer.ChildrenOfType<HotkeyExitOverlay>().First().Action?.Invoke());
 
             confirmExited();
         }
@@ -176,9 +171,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestExitFromGameplay()
         {
-            AddStep("exit", () => Player.Exit());
-            confirmPaused();
-
+            // an externally triggered exit should immediately exit, skipping all pause logic.
             AddStep("exit", () => Player.Exit());
             confirmExited();
         }
@@ -186,7 +179,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestQuickExitFromGameplay()
         {
-            AddStep("quick exit", () => Player.GameplayClockContainer.OfType<HotkeyExitOverlay>().First().Action?.Invoke());
+            AddStep("quick exit", () => Player.GameplayClockContainer.ChildrenOfType<HotkeyExitOverlay>().First().Action?.Invoke());
 
             confirmExited();
         }
@@ -225,6 +218,31 @@ namespace osu.Game.Tests.Visual.Gameplay
             confirmExited();
         }
 
+        [Test]
+        public void TestPauseSoundLoop()
+        {
+            AddStep("seek before gameplay", () => Player.GameplayClockContainer.Seek(-5000));
+
+            SkinnableSound getLoop() => Player.ChildrenOfType<PauseOverlay>().FirstOrDefault()?.ChildrenOfType<SkinnableSound>().FirstOrDefault();
+
+            pauseAndConfirm();
+            AddAssert("loop is playing", () => getLoop().IsPlaying);
+
+            resumeAndConfirm();
+            AddUntilStep("loop is stopped", () => !getLoop().IsPlaying);
+
+            AddUntilStep("pause again", () =>
+            {
+                Player.Pause();
+                return !Player.GameplayClockContainer.GameplayClock.IsRunning;
+            });
+
+            AddAssert("loop is playing", () => getLoop().IsPlaying);
+
+            resumeAndConfirm();
+            AddUntilStep("loop is stopped", () => !getLoop().IsPlaying);
+        }
+
         private void pauseAndConfirm()
         {
             pause();

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

@@ -8,12 +8,11 @@ using osu.Framework.Platform;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets;
-using osu.Game.Rulesets.Osu;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
     [HeadlessTest] // we alter unsafe properties on the game host to test inactive window state.
-    public class TestScenePauseWhenInactive : PlayerTestScene
+    public class TestScenePauseWhenInactive : OsuPlayerTestScene
     {
         protected override IBeatmap CreateBeatmap(RulesetInfo ruleset)
         {
@@ -27,11 +26,6 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Resolved]
         private GameHost host { get; set; }
 
-        public TestScenePauseWhenInactive()
-            : base(new OsuRuleset())
-        {
-        }
-
         [Test]
         public void TestDoesntPauseDuringIntro()
         {

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

@@ -13,6 +13,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Utils;
 using osu.Framework.Screens;
+using osu.Framework.Testing;
 using osu.Game.Configuration;
 using osu.Game.Graphics.Containers;
 using osu.Game.Overlays;
@@ -22,49 +23,86 @@ using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
-using osu.Game.Screens;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.PlayerSettings;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
-    public class TestScenePlayerLoader : OsuManualInputManagerTestScene
+    public class TestScenePlayerLoader : ScreenTestScene
     {
         private TestPlayerLoader loader;
-        private TestPlayerLoaderContainer container;
         private TestPlayer player;
 
+        private bool epilepsyWarning;
+
         [Resolved]
         private AudioManager audioManager { get; set; }
 
         [Resolved]
         private SessionStatics sessionStatics { get; set; }
 
+        [Cached]
+        private readonly NotificationOverlay notificationOverlay;
+
+        [Cached]
+        private readonly VolumeOverlay volumeOverlay;
+
+        private readonly ChangelogOverlay changelogOverlay;
+
+        public TestScenePlayerLoader()
+        {
+            AddRange(new Drawable[]
+            {
+                notificationOverlay = new NotificationOverlay
+                {
+                    Anchor = Anchor.TopRight,
+                    Origin = Anchor.TopRight,
+                },
+                volumeOverlay = new VolumeOverlay
+                {
+                    Anchor = Anchor.TopLeft,
+                    Origin = Anchor.TopLeft,
+                },
+                changelogOverlay = new ChangelogOverlay()
+            });
+        }
+
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            player = null;
+            audioManager.Volume.SetDefault();
+        });
+
         /// <summary>
         /// Sets the input manager child to a new test player loader container instance.
         /// </summary>
         /// <param name="interactive">If the test player should behave like the production one.</param>
         /// <param name="beforeLoadAction">An action to run before player load but after bindable leases are returned.</param>
-        /// <param name="afterLoadAction">An action to run after container load.</param>
-        public void ResetPlayer(bool interactive, Action beforeLoadAction = null, Action afterLoadAction = null)
+        private void resetPlayer(bool interactive, Action beforeLoadAction = null)
         {
-            audioManager.Volume.SetDefault();
-
-            InputManager.Clear();
-
             beforeLoadAction?.Invoke();
+
             Beatmap.Value = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
+            Beatmap.Value.BeatmapInfo.EpilepsyWarning = epilepsyWarning;
 
             foreach (var mod in SelectedMods.Value.OfType<IApplicableToTrack>())
                 mod.ApplyToTrack(Beatmap.Value.Track);
 
-            InputManager.Child = container = new TestPlayerLoaderContainer(
-                loader = new TestPlayerLoader(() =>
-                {
-                    afterLoadAction?.Invoke();
-                    return player = new TestPlayer(interactive, interactive);
-                }));
+            LoadScreen(loader = new TestPlayerLoader(() => player = new TestPlayer(interactive, interactive)));
+        }
+
+        [Test]
+        public void TestEarlyExitBeforePlayerConstruction()
+        {
+            AddStep("load dummy beatmap", () => resetPlayer(false, () => SelectedMods.Value = new[] { new OsuModNightcore() }));
+            AddUntilStep("wait for current", () => loader.IsCurrentScreen());
+            AddStep("exit loader", () => loader.Exit());
+            AddUntilStep("wait for not current", () => !loader.IsCurrentScreen());
+            AddAssert("player did not load", () => player == null);
+            AddUntilStep("player disposed", () => loader.DisposalTask == null);
+            AddAssert("mod rate still applied", () => Beatmap.Value.Track.Rate != 1);
         }
 
         /// <summary>
@@ -73,11 +111,12 @@ namespace osu.Game.Tests.Visual.Gameplay
         /// speed adjustments were undone too late, causing cross-screen pollution.
         /// </summary>
         [Test]
-        public void TestEarlyExit()
+        public void TestEarlyExitAfterPlayerConstruction()
         {
-            AddStep("load dummy beatmap", () => ResetPlayer(false, () => SelectedMods.Value = new[] { new OsuModNightcore() }));
+            AddStep("load dummy beatmap", () => resetPlayer(false, () => SelectedMods.Value = new[] { new OsuModNightcore() }));
             AddUntilStep("wait for current", () => loader.IsCurrentScreen());
             AddAssert("mod rate applied", () => Beatmap.Value.Track.Rate != 1);
+            AddUntilStep("wait for non-null player", () => player != null);
             AddStep("exit loader", () => loader.Exit());
             AddUntilStep("wait for not current", () => !loader.IsCurrentScreen());
             AddAssert("player did not load", () => !player.IsLoaded);
@@ -88,13 +127,13 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestBlockLoadViaMouseMovement()
         {
-            AddStep("load dummy beatmap", () => ResetPlayer(false));
+            AddStep("load dummy beatmap", () => resetPlayer(false));
             AddUntilStep("wait for current", () => loader.IsCurrentScreen());
 
             AddUntilStep("wait for load ready", () =>
             {
                 moveMouse();
-                return player.LoadState == LoadState.Ready;
+                return player?.LoadState == LoadState.Ready;
             });
             AddRepeatStep("move mouse", moveMouse, 20);
 
@@ -113,20 +152,18 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestBlockLoadViaFocus()
         {
-            OsuFocusedOverlayContainer overlay = null;
-
-            AddStep("load dummy beatmap", () => ResetPlayer(false));
+            AddStep("load dummy beatmap", () => resetPlayer(false));
             AddUntilStep("wait for current", () => loader.IsCurrentScreen());
 
-            AddStep("show focused overlay", () => { container.Add(overlay = new ChangelogOverlay { State = { Value = Visibility.Visible } }); });
-            AddUntilStep("overlay visible", () => overlay.IsPresent);
+            AddStep("show focused overlay", () => changelogOverlay.Show());
+            AddUntilStep("overlay visible", () => changelogOverlay.IsPresent);
 
-            AddUntilStep("wait for load ready", () => player.LoadState == LoadState.Ready);
+            AddUntilStep("wait for load ready", () => player?.LoadState == LoadState.Ready);
             AddRepeatStep("twiddle thumbs", () => { }, 20);
 
             AddAssert("loader still active", () => loader.IsCurrentScreen());
 
-            AddStep("hide overlay", () => overlay.Hide());
+            AddStep("hide overlay", () => changelogOverlay.Hide());
             AddUntilStep("loads after idle", () => !loader.IsCurrentScreen());
         }
 
@@ -135,15 +172,9 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             SlowLoadPlayer slowPlayer = null;
 
-            AddStep("load dummy beatmap", () => ResetPlayer(false));
-            AddUntilStep("wait for current", () => loader.IsCurrentScreen());
-            AddStep("mouse in centre", () => InputManager.MoveMouseTo(loader.ScreenSpaceDrawQuad.Centre));
-            AddUntilStep("wait for player to be current", () => player.IsCurrentScreen());
             AddStep("load slow dummy beatmap", () =>
             {
-                InputManager.Child = container = new TestPlayerLoaderContainer(
-                    loader = new TestPlayerLoader(() => slowPlayer = new SlowLoadPlayer(false, false)));
-
+                LoadScreen(loader = new TestPlayerLoader(() => slowPlayer = new SlowLoadPlayer(false, false)));
                 Scheduler.AddDelayed(() => slowPlayer.AllowLoad.Set(), 5000);
             });
 
@@ -157,7 +188,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             TestMod playerMod1 = null;
             TestMod playerMod2 = null;
 
-            AddStep("load player", () => { ResetPlayer(true, () => SelectedMods.Value = new[] { gameMod = new TestMod() }); });
+            AddStep("load player", () => { resetPlayer(true, () => SelectedMods.Value = new[] { gameMod = new TestMod() }); });
 
             AddUntilStep("wait for loader to become current", () => loader.IsCurrentScreen());
             AddStep("mouse in centre", () => InputManager.MoveMouseTo(loader.ScreenSpaceDrawQuad.Centre));
@@ -185,7 +216,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             var testMod = new TestMod();
 
-            AddStep("load player", () => ResetPlayer(true));
+            AddStep("load player", () => resetPlayer(true));
 
             AddUntilStep("wait for loader to become current", () => loader.IsCurrentScreen());
             AddStep("set test mod in loader", () => loader.Mods.Value = new[] { testMod });
@@ -195,19 +226,19 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestMutedNotificationMasterVolume()
         {
-            addVolumeSteps("master volume", () => audioManager.Volume.Value = 0, null, () => audioManager.Volume.IsDefault);
+            addVolumeSteps("master volume", () => audioManager.Volume.Value = 0, () => audioManager.Volume.IsDefault);
         }
 
         [Test]
         public void TestMutedNotificationTrackVolume()
         {
-            addVolumeSteps("music volume", () => audioManager.VolumeTrack.Value = 0, null, () => audioManager.VolumeTrack.IsDefault);
+            addVolumeSteps("music volume", () => audioManager.VolumeTrack.Value = 0, () => audioManager.VolumeTrack.IsDefault);
         }
 
         [Test]
         public void TestMutedNotificationMuteButton()
         {
-            addVolumeSteps("mute button", null, () => container.VolumeOverlay.IsMuted.Value = true, () => !container.VolumeOverlay.IsMuted.Value);
+            addVolumeSteps("mute button", () => volumeOverlay.IsMuted.Value = true, () => !volumeOverlay.IsMuted.Value);
         }
 
         /// <remarks>
@@ -215,19 +246,18 @@ namespace osu.Game.Tests.Visual.Gameplay
         /// </remarks>
         /// <param name="volumeName">What part of the volume system is checked</param>
         /// <param name="beforeLoad">The action to be invoked to set the volume before loading</param>
-        /// <param name="afterLoad">The action to be invoked to set the volume after loading</param>
         /// <param name="assert">The function to be invoked and checked</param>
-        private void addVolumeSteps(string volumeName, Action beforeLoad, Action afterLoad, Func<bool> assert)
+        private void addVolumeSteps(string volumeName, Action beforeLoad, Func<bool> assert)
         {
             AddStep("reset notification lock", () => sessionStatics.GetBindable<bool>(Static.MutedAudioNotificationShownOnce).Value = false);
 
-            AddStep("load player", () => ResetPlayer(false, beforeLoad, afterLoad));
-            AddUntilStep("wait for player", () => player.LoadState == LoadState.Ready);
+            AddStep("load player", () => resetPlayer(false, beforeLoad));
+            AddUntilStep("wait for player", () => player?.LoadState == LoadState.Ready);
 
-            AddAssert("check for notification", () => container.NotificationOverlay.UnreadCount.Value == 1);
+            AddAssert("check for notification", () => notificationOverlay.UnreadCount.Value == 1);
             AddStep("click notification", () =>
             {
-                var scrollContainer = (OsuScrollContainer)container.NotificationOverlay.Children.Last();
+                var scrollContainer = (OsuScrollContainer)notificationOverlay.Children.Last();
                 var flowContainer = scrollContainer.Children.OfType<FillFlowContainer<NotificationSection>>().First();
                 var notification = flowContainer.First();
 
@@ -240,42 +270,38 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddUntilStep("wait for player load", () => player.IsLoaded);
         }
 
-        private class TestPlayerLoaderContainer : Container
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestEpilepsyWarning(bool warning)
         {
-            [Cached]
-            public readonly NotificationOverlay NotificationOverlay;
+            AddStep("change epilepsy warning", () => epilepsyWarning = warning);
+            AddStep("load dummy beatmap", () => resetPlayer(false));
 
-            [Cached]
-            public readonly VolumeOverlay VolumeOverlay;
+            AddUntilStep("wait for current", () => loader.IsCurrentScreen());
 
-            public TestPlayerLoaderContainer(IScreen screen)
+            AddAssert($"epilepsy warning {(warning ? "present" : "absent")}", () => this.ChildrenOfType<EpilepsyWarning>().Any() == warning);
+
+            if (warning)
             {
-                RelativeSizeAxes = Axes.Both;
-
-                OsuScreenStack stack;
-
-                InternalChildren = new Drawable[]
-                {
-                    stack = new OsuScreenStack
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                    },
-                    NotificationOverlay = new NotificationOverlay
-                    {
-                        Anchor = Anchor.TopRight,
-                        Origin = Anchor.TopRight,
-                    },
-                    VolumeOverlay = new VolumeOverlay
-                    {
-                        Anchor = Anchor.TopLeft,
-                        Origin = Anchor.TopLeft,
-                    }
-                };
-
-                stack.Push(screen);
+                AddUntilStep("sound volume decreased", () => Beatmap.Value.Track.AggregateVolume.Value == 0.25);
+                AddUntilStep("sound volume restored", () => Beatmap.Value.Track.AggregateVolume.Value == 1);
             }
         }
 
+        [Test]
+        public void TestEpilepsyWarningEarlyExit()
+        {
+            AddStep("set epilepsy warning", () => epilepsyWarning = true);
+            AddStep("load dummy beatmap", () => resetPlayer(false));
+
+            AddUntilStep("wait for current", () => loader.IsCurrentScreen());
+
+            AddUntilStep("wait for epilepsy warning", () => loader.ChildrenOfType<EpilepsyWarning>().Single().Alpha > 0);
+            AddStep("exit early", () => loader.Exit());
+
+            AddUntilStep("sound volume restored", () => Beatmap.Value.Track.AggregateVolume.Value == 1);
+        }
+
         private class TestPlayerLoader : PlayerLoader
         {
             public new VisualSettings VisualSettings => base.VisualSettings;

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

@@ -0,0 +1,292 @@
+// 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 System.Threading;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input;
+using osu.Framework.Testing;
+using osu.Framework.Timing;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Legacy;
+using osu.Game.Rulesets.UI;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestScenePoolingRuleset : OsuTestScene
+    {
+        private const double time_between_objects = 1000;
+
+        private TestDrawablePoolingRuleset drawableRuleset;
+
+        [Test]
+        public void TestReusedWithHitObjectsSpacedFarApart()
+        {
+            ManualClock clock = null;
+
+            createTest(new Beatmap
+            {
+                HitObjects =
+                {
+                    new HitObject(),
+                    new HitObject { StartTime = time_between_objects }
+                }
+            }, 1, () => new FramedClock(clock = new ManualClock()));
+
+            DrawableTestHitObject firstObject = null;
+            AddUntilStep("first object shown", () => this.ChildrenOfType<DrawableTestHitObject>().SingleOrDefault()?.HitObject == drawableRuleset.Beatmap.HitObjects[0]);
+            AddStep("get DHO", () => firstObject = this.ChildrenOfType<DrawableTestHitObject>().Single());
+
+            AddStep("fast forward to second object", () => clock.CurrentTime = drawableRuleset.Beatmap.HitObjects[1].StartTime);
+
+            AddUntilStep("second object shown", () => this.ChildrenOfType<DrawableTestHitObject>().SingleOrDefault()?.HitObject == drawableRuleset.Beatmap.HitObjects[1]);
+            AddAssert("DHO reused", () => this.ChildrenOfType<DrawableTestHitObject>().Single() == firstObject);
+        }
+
+        [Test]
+        public void TestCustomTransformsClearedBetweenReuses()
+        {
+            ManualClock clock = null;
+
+            createTest(new Beatmap
+            {
+                HitObjects =
+                {
+                    new HitObject(),
+                    new HitObject { StartTime = 2000 }
+                }
+            }, 1, () => new FramedClock(clock = new ManualClock()));
+
+            DrawableTestHitObject firstObject = null;
+            Vector2 position = default;
+
+            AddUntilStep("first object shown", () => this.ChildrenOfType<DrawableTestHitObject>().SingleOrDefault()?.HitObject == drawableRuleset.Beatmap.HitObjects[0]);
+            AddStep("get DHO", () => firstObject = this.ChildrenOfType<DrawableTestHitObject>().Single());
+            AddStep("store position", () => position = firstObject.Position);
+            AddStep("add custom transform", () => firstObject.ApplyCustomUpdateState += onStateUpdate);
+
+            AddStep("fast forward past first object", () => clock.CurrentTime = 1500);
+            AddStep("unapply custom transform", () => firstObject.ApplyCustomUpdateState -= onStateUpdate);
+
+            AddStep("fast forward to second object", () => clock.CurrentTime = drawableRuleset.Beatmap.HitObjects[1].StartTime);
+            AddUntilStep("second object shown", () => this.ChildrenOfType<DrawableTestHitObject>().SingleOrDefault()?.HitObject == drawableRuleset.Beatmap.HitObjects[1]);
+            AddAssert("DHO reused", () => this.ChildrenOfType<DrawableTestHitObject>().Single() == firstObject);
+            AddAssert("object in new position", () => firstObject.Position != position);
+
+            void onStateUpdate(DrawableHitObject hitObject, ArmedState state)
+            {
+                using (hitObject.BeginAbsoluteSequence(hitObject.StateUpdateTime))
+                    hitObject.MoveToOffset(new Vector2(-100, 0));
+            }
+        }
+
+        [Test]
+        public void TestNotReusedWithHitObjectsSpacedClose()
+        {
+            ManualClock clock = null;
+
+            createTest(new Beatmap
+            {
+                HitObjects =
+                {
+                    new HitObject(),
+                    new HitObject { StartTime = 250 }
+                }
+            }, 2, () => new FramedClock(clock = new ManualClock()));
+
+            AddStep("fast forward to second object", () => clock.CurrentTime = drawableRuleset.Beatmap.HitObjects[1].StartTime);
+
+            AddUntilStep("two DHOs shown", () => this.ChildrenOfType<DrawableTestHitObject>().Count() == 2);
+            AddAssert("DHOs have different hitobjects",
+                () => this.ChildrenOfType<DrawableTestHitObject>().ElementAt(0).HitObject != this.ChildrenOfType<DrawableTestHitObject>().ElementAt(1).HitObject);
+        }
+
+        [Test]
+        public void TestManyHitObjects()
+        {
+            var beatmap = new Beatmap();
+
+            for (int i = 0; i < 500; i++)
+                beatmap.HitObjects.Add(new HitObject { StartTime = i * 10 });
+
+            createTest(beatmap, 100);
+
+            AddUntilStep("any DHOs shown", () => this.ChildrenOfType<DrawableTestHitObject>().Any());
+            AddUntilStep("no DHOs shown", () => !this.ChildrenOfType<DrawableTestHitObject>().Any());
+        }
+
+        private void createTest(IBeatmap beatmap, int poolSize, Func<IFrameBasedClock> createClock = null) => AddStep("create test", () =>
+        {
+            var ruleset = new TestPoolingRuleset();
+
+            drawableRuleset = (TestDrawablePoolingRuleset)ruleset.CreateDrawableRulesetWith(CreateWorkingBeatmap(beatmap).GetPlayableBeatmap(ruleset.RulesetInfo));
+            drawableRuleset.FrameStablePlayback = true;
+            drawableRuleset.PoolSize = poolSize;
+
+            Child = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Clock = createClock?.Invoke() ?? new FramedOffsetClock(Clock, false) { Offset = -Clock.CurrentTime },
+                Child = drawableRuleset
+            };
+        });
+
+        #region Ruleset
+
+        private class TestPoolingRuleset : Ruleset
+        {
+            public override IEnumerable<Mod> GetModsFor(ModType type) => throw new NotImplementedException();
+
+            public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod> mods = null) => new TestDrawablePoolingRuleset(this, beatmap, mods);
+
+            public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new TestBeatmapConverter(beatmap, this);
+
+            public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => throw new NotImplementedException();
+
+            public override string Description { get; } = string.Empty;
+
+            public override string ShortName { get; } = string.Empty;
+        }
+
+        private class TestDrawablePoolingRuleset : DrawableRuleset<TestHitObject>
+        {
+            public int PoolSize;
+
+            public TestDrawablePoolingRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods = null)
+                : base(ruleset, beatmap, mods)
+            {
+            }
+
+            public override DrawableHitObject<TestHitObject> CreateDrawableRepresentation(TestHitObject h) => null;
+
+            protected override PassThroughInputManager CreateInputManager() => new PassThroughInputManager();
+
+            protected override Playfield CreatePlayfield() => new TestPlayfield(PoolSize);
+        }
+
+        private class TestPlayfield : Playfield
+        {
+            private readonly int poolSize;
+
+            public TestPlayfield(int poolSize)
+            {
+                this.poolSize = poolSize;
+                AddInternal(HitObjectContainer);
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                RegisterPool<TestHitObject, DrawableTestHitObject>(poolSize);
+            }
+
+            protected override HitObjectLifetimeEntry CreateLifetimeEntry(HitObject hitObject) => new TestHitObjectLifetimeEntry(hitObject);
+
+            protected override GameplayCursorContainer CreateCursor() => null;
+        }
+
+        private class TestHitObjectLifetimeEntry : HitObjectLifetimeEntry
+        {
+            public TestHitObjectLifetimeEntry(HitObject hitObject)
+                : base(hitObject)
+            {
+            }
+
+            protected override double InitialLifetimeOffset => 0;
+        }
+
+        private class TestBeatmapConverter : BeatmapConverter<TestHitObject>
+        {
+            public TestBeatmapConverter(IBeatmap beatmap, Ruleset ruleset)
+                : base(beatmap, ruleset)
+            {
+            }
+
+            public override bool CanConvert() => true;
+
+            protected override IEnumerable<TestHitObject> ConvertHitObject(HitObject original, IBeatmap beatmap, CancellationToken cancellationToken)
+            {
+                yield return new TestHitObject
+                {
+                    StartTime = original.StartTime,
+                    Duration = 250
+                };
+            }
+        }
+
+        #endregion
+
+        #region HitObject
+
+        private class TestHitObject : ConvertHitObject
+        {
+            public double EndTime => StartTime + Duration;
+
+            public double Duration { get; set; }
+        }
+
+        private class DrawableTestHitObject : DrawableHitObject<TestHitObject>
+        {
+            public DrawableTestHitObject()
+                : base(null)
+            {
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+
+                Size = new Vector2(50, 50);
+
+                Colour = new Color4(RNG.NextSingle(), RNG.NextSingle(), RNG.NextSingle(), 1f);
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                AddInternal(new Circle
+                {
+                    RelativeSizeAxes = Axes.Both,
+                });
+            }
+
+            protected override void OnApply(HitObject hitObject)
+            {
+                base.OnApply(hitObject);
+                Position = new Vector2(RNG.Next(-200, 200), RNG.Next(-200, 200));
+            }
+
+            protected override void CheckForResult(bool userTriggered, double timeOffset)
+            {
+                if (timeOffset > HitObject.Duration)
+                    ApplyResult(r => r.Type = r.Judgement.MaxResult);
+            }
+
+            protected override void UpdateHitStateTransforms(ArmedState state)
+            {
+                base.UpdateHitStateTransforms(state);
+
+                switch (state)
+                {
+                    case ArmedState.Hit:
+                    case ArmedState.Miss:
+                        this.FadeOut(250);
+                        break;
+                }
+            }
+        }
+
+        #endregion
+    }
+}

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

@@ -19,7 +19,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             var beatmap = Beatmap.Value.GetPlayableBeatmap(ruleset.RulesetInfo, Array.Empty<Mod>());
 
-            return new ScoreAccessibleReplayPlayer(ruleset.GetAutoplayMod().CreateReplayScore(beatmap));
+            return new ScoreAccessibleReplayPlayer(ruleset.GetAutoplayMod()?.CreateReplayScore(beatmap));
         }
 
         protected override void AddCheckSteps()

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

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -12,11 +13,13 @@ using osu.Framework.Input.Events;
 using osu.Framework.Input.StateChanges;
 using osu.Framework.Testing;
 using osu.Framework.Threading;
+using osu.Game.Beatmaps;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Replays;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play;
 using osu.Game.Tests.Visual.UserInterface;
 using osuTK;
 using osuTK.Graphics;
@@ -33,6 +36,9 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private TestReplayRecorder recorder;
 
+        [Cached]
+        private GameplayBeatmap gameplayBeatmap = new GameplayBeatmap(new Beatmap());
+
         [SetUp]
         public void SetUp() => Schedule(() =>
         {
@@ -152,8 +158,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("much move with press", () => moveFunction = Scheduler.AddDelayed(() =>
             {
                 InputManager.MoveMouseTo(InputManager.CurrentState.Mouse.Position + new Vector2(-1, 0));
-                InputManager.PressButton(MouseButton.Left);
-                InputManager.ReleaseButton(MouseButton.Left);
+                InputManager.Click(MouseButton.Left);
             }, 10, true));
             AddWaitStep("move", 10);
             AddStep("stop move", () => moveFunction.Cancel());
@@ -166,6 +171,12 @@ namespace osu.Game.Tests.Visual.Gameplay
             playbackManager?.ReplayInputHandler.SetFrameFromTime(Time.Current - 100);
         }
 
+        [TearDownSteps]
+        public void TearDown()
+        {
+            AddStep("stop recorder", () => recorder.Expire());
+        }
+
         public class TestFramedReplayInputHandler : FramedReplayInputHandler<TestReplayFrame>
         {
             public TestFramedReplayInputHandler(Replay replay)
@@ -173,19 +184,10 @@ namespace osu.Game.Tests.Visual.Gameplay
             {
             }
 
-            public override List<IInput> GetPendingInputs()
+            public override void CollectPendingInputs(List<IInput> inputs)
             {
-                return new List<IInput>
-                {
-                    new MousePositionAbsoluteInput
-                    {
-                        Position = GamefieldToScreenSpace(CurrentFrame?.Position ?? Vector2.Zero)
-                    },
-                    new ReplayState<TestAction>
-                    {
-                        PressedActions = CurrentFrame?.Actions ?? new List<TestAction>()
-                    }
-                };
+                inputs.Add(new MousePositionAbsoluteInput { Position = GamefieldToScreenSpace(CurrentFrame?.Position ?? Vector2.Zero) });
+                inputs.Add(new ReplayState<TestAction> { PressedActions = CurrentFrame?.Actions ?? new List<TestAction>() });
             }
         }
 

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

@@ -2,17 +2,20 @@
 // 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.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.Replays;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play;
 using osu.Game.Tests.Visual.UserInterface;
 using osuTK;
 using osuTK.Graphics;
@@ -25,6 +28,9 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private readonly TestRulesetInputManager recordingManager;
 
+        [Cached]
+        private GameplayBeatmap gameplayBeatmap = new GameplayBeatmap(new Beatmap());
+
         public TestSceneReplayRecording()
         {
             Replay replay = new Replay();
@@ -113,19 +119,10 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
         }
 
-        public override List<IInput> GetPendingInputs()
+        public override void CollectPendingInputs(List<IInput> inputs)
         {
-            return new List<IInput>
-            {
-                new MousePositionAbsoluteInput
-                {
-                    Position = GamefieldToScreenSpace(CurrentFrame?.Position ?? Vector2.Zero)
-                },
-                new ReplayState<TestAction>
-                {
-                    PressedActions = CurrentFrame?.Actions ?? new List<TestAction>()
-                }
-            };
+            inputs.Add(new MousePositionAbsoluteInput { Position = GamefieldToScreenSpace(CurrentFrame?.Position ?? Vector2.Zero) });
+            inputs.Add(new ReplayState<TestAction> { PressedActions = CurrentFrame?.Actions ?? new List<TestAction>() });
         }
     }
 

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

@@ -48,7 +48,10 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private class ExampleContainer : PlayerSettingsGroup
         {
-            protected override string Title => @"example";
+            public ExampleContainer()
+                : base("example")
+            {
+            }
         }
     }
 }

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

@@ -1,70 +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.Graphics;
-using osu.Game.Graphics.UserInterface;
-using osu.Game.Screens.Play.HUD;
-using osuTK;
-
-namespace osu.Game.Tests.Visual.Gameplay
-{
-    [TestFixture]
-    public class TestSceneScoreCounter : OsuTestScene
-    {
-        public TestSceneScoreCounter()
-        {
-            int numerator = 0, denominator = 0;
-
-            ScoreCounter score = new ScoreCounter(7)
-            {
-                Origin = Anchor.TopRight,
-                Anchor = Anchor.TopRight,
-                TextSize = 40,
-                Margin = new MarginPadding(20),
-            };
-            Add(score);
-
-            ComboCounter comboCounter = new StandardComboCounter
-            {
-                Origin = Anchor.BottomLeft,
-                Anchor = Anchor.BottomLeft,
-                Margin = new MarginPadding(10),
-                TextSize = 40,
-            };
-            Add(comboCounter);
-
-            PercentageCounter accuracyCounter = new PercentageCounter
-            {
-                Origin = Anchor.TopRight,
-                Anchor = Anchor.TopRight,
-                Position = new Vector2(-20, 60),
-            };
-            Add(accuracyCounter);
-
-            AddStep(@"Reset all", delegate
-            {
-                score.Current.Value = 0;
-                comboCounter.Current.Value = 0;
-                numerator = denominator = 0;
-                accuracyCounter.SetFraction(0, 0);
-            });
-
-            AddStep(@"Hit! :D", delegate
-            {
-                score.Current.Value += 300 + (ulong)(300.0 * (comboCounter.Current.Value > 0 ? comboCounter.Current.Value - 1 : 0) / 25.0);
-                comboCounter.Increment();
-                numerator++;
-                denominator++;
-                accuracyCounter.SetFraction(numerator, denominator);
-            });
-
-            AddStep(@"miss...", delegate
-            {
-                comboCounter.Current.Value = 0;
-                denominator++;
-                accuracyCounter.SetFraction(numerator, denominator);
-            });
-        }
-    }
-}

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

@@ -0,0 +1,49 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Screens.Play.HUD;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneSkinnableAccuracyCounter : SkinnableTestScene
+    {
+        private IEnumerable<SkinnableAccuracyCounter> accuracyCounters => CreatedDrawables.OfType<SkinnableAccuracyCounter>();
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("Create combo counters", () => SetContents(() =>
+            {
+                var accuracyCounter = new SkinnableAccuracyCounter();
+
+                accuracyCounter.Current.Value = 1;
+
+                return accuracyCounter;
+            }));
+        }
+
+        [Test]
+        public void TestChangingAccuracy()
+        {
+            AddStep(@"Reset all", delegate
+            {
+                foreach (var s in accuracyCounters)
+                    s.Current.Value = 1;
+            });
+
+            AddStep(@"Hit! :D", delegate
+            {
+                foreach (var s in accuracyCounters)
+                    s.Current.Value -= 0.023f;
+            });
+        }
+    }
+}

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

@@ -10,6 +10,7 @@ using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Audio;
@@ -295,7 +296,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                     }
                     : null;
 
-            public Texture GetTexture(string componentName) => throw new NotImplementedException();
+            public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => throw new NotImplementedException();
 
             public SampleChannel GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
 
@@ -306,7 +307,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             public Drawable GetDrawableComponent(ISkinComponent componentName) => new SecondarySourceBox();
 
-            public Texture GetTexture(string componentName) => throw new NotImplementedException();
+            public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => throw new NotImplementedException();
 
             public SampleChannel GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
 
@@ -318,7 +319,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             public Drawable GetDrawableComponent(ISkinComponent componentName) => new BaseSourceBox();
 
-            public Texture GetTexture(string componentName) => throw new NotImplementedException();
+            public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => throw new NotImplementedException();
 
             public SampleChannel GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
 

osu.Game.Tests/Visual/Gameplay/TestSceneSkinnableHUDOverlay.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 System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+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;
+using osu.Game.Screens.Play;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneSkinnableHUDOverlay : SkinnableTestScene
+    {
+        private HUDOverlay hudOverlay;
+
+        private IEnumerable<HUDOverlay> hudOverlays => CreatedDrawables.OfType<HUDOverlay>();
+
+        // best way to check without exposing.
+        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()
+        {
+            createNew();
+
+            AddRepeatStep("increase combo", () =>
+            {
+                foreach (var hud in hudOverlays)
+                    hud.ComboCounter.Current.Value++;
+            }, 10);
+
+            AddStep("reset combo", () =>
+            {
+                foreach (var hud in hudOverlays)
+                    hud.ComboCounter.Current.Value = 0;
+            });
+        }
+
+        [Test]
+        public void TestFadesInOnLoadComplete()
+        {
+            float? initialAlpha = null;
+
+            createNew(h => h.OnLoadComplete += _ => initialAlpha = hideTarget.Alpha);
+            AddUntilStep("wait for load", () => hudOverlay.IsAlive);
+            AddAssert("initial alpha was less than 1", () => initialAlpha < 1);
+        }
+
+        [Test]
+        public void TestHideExternally()
+        {
+            createNew();
+
+            AddStep("set showhud false", () => hudOverlays.ForEach(h => h.ShowHud.Value = false));
+
+            AddUntilStep("hidetarget is hidden", () => !hideTarget.IsPresent);
+            AddAssert("pause button is still visible", () => hudOverlay.HoldToQuit.IsPresent);
+
+            // Key counter flow container should not be affected by this, only the key counter display will be hidden as checked above.
+            AddAssert("key counter flow not affected", () => keyCounterFlow.IsPresent);
+        }
+
+        private void createNew(Action<HUDOverlay> action = null)
+        {
+            AddStep("create overlay", () =>
+            {
+                SetContents(() =>
+                {
+                    hudOverlay = new HUDOverlay(null, null, null, Array.Empty<Mod>());
+
+                    // Add any key just to display the key counter visually.
+                    hudOverlay.KeyCounter.Add(new KeyCounterKeyboard(Key.Space));
+
+                    hudOverlay.ComboCounter.Current.Value = 1;
+
+                    action?.Invoke(hudOverlay);
+
+                    return hudOverlay;
+                });
+            });
+        }
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
+    }
+}

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

@@ -0,0 +1,61 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Screens.Play;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneSkinnableHealthDisplay : SkinnableTestScene
+    {
+        private IEnumerable<SkinnableHealthDisplay> healthDisplays => CreatedDrawables.OfType<SkinnableHealthDisplay>();
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("Create health displays", () =>
+            {
+                SetContents(() => new SkinnableHealthDisplay());
+            });
+            AddStep(@"Reset all", delegate
+            {
+                foreach (var s in healthDisplays)
+                    s.Current.Value = 1;
+            });
+        }
+
+        [Test]
+        public void TestHealthDisplayIncrementing()
+        {
+            AddRepeatStep(@"decrease hp", delegate
+            {
+                foreach (var healthDisplay in healthDisplays)
+                    healthDisplay.Current.Value -= 0.08f;
+            }, 10);
+
+            AddRepeatStep(@"increase hp without flash", delegate
+            {
+                foreach (var healthDisplay in healthDisplays)
+                    healthDisplay.Current.Value += 0.1f;
+            }, 3);
+
+            AddRepeatStep(@"increase hp with flash", delegate
+            {
+                foreach (var healthDisplay in healthDisplays)
+                {
+                    healthDisplay.Current.Value += 0.1f;
+                    healthDisplay.Flash(new JudgementResult(null, new OsuJudgement()));
+                }
+            }, 3);
+        }
+    }
+}

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

@@ -0,0 +1,54 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Screens.Play.HUD;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneSkinnableScoreCounter : SkinnableTestScene
+    {
+        private IEnumerable<SkinnableScoreCounter> scoreCounters => CreatedDrawables.OfType<SkinnableScoreCounter>();
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("Create combo counters", () => SetContents(() =>
+            {
+                var comboCounter = new SkinnableScoreCounter();
+                comboCounter.Current.Value = 1;
+                return comboCounter;
+            }));
+        }
+
+        [Test]
+        public void TestScoreCounterIncrementing()
+        {
+            AddStep(@"Reset all", delegate
+            {
+                foreach (var s in scoreCounters)
+                    s.Current.Value = 0;
+            });
+
+            AddStep(@"Hit! :D", delegate
+            {
+                foreach (var s in scoreCounters)
+                    s.Current.Value += 300;
+            });
+        }
+
+        [Test]
+        public void TestVeryLargeScore()
+        {
+            AddStep("set large score", () => scoreCounters.ForEach(counter => counter.Current.Value = 1_000_000_000));
+        }
+    }
+}

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

@@ -0,0 +1,167 @@
+// 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.Sample;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Audio;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.OpenGL.Textures;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Testing;
+using osu.Game.Audio;
+using osu.Game.Screens.Play;
+using osu.Game.Skinning;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneSkinnableSound : OsuTestScene
+    {
+        private TestSkinSourceContainer skinSource;
+        private PausableSkinnableSound skinnableSound;
+
+        [SetUp]
+        public void SetUpSteps()
+        {
+            AddStep("setup hierarchy", () =>
+            {
+                Children = new Drawable[]
+                {
+                    skinSource = new TestSkinSourceContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Child = skinnableSound = new PausableSkinnableSound(new SampleInfo("Gameplay/normal-sliderslide"))
+                    },
+                };
+            });
+        }
+
+        [Test]
+        public void TestStoppedSoundDoesntResumeAfterPause()
+        {
+            DrawableSample sample = null;
+            AddStep("start sample with looping", () =>
+            {
+                sample = skinnableSound.ChildrenOfType<DrawableSample>().First();
+
+                skinnableSound.Looping = true;
+                skinnableSound.Play();
+            });
+
+            AddUntilStep("wait for sample to start playing", () => sample.Playing);
+
+            AddStep("stop sample", () => skinnableSound.Stop());
+
+            AddUntilStep("wait for sample to stop playing", () => !sample.Playing);
+
+            AddStep("disable sample playback", () => skinSource.SamplePlaybackDisabled.Value = true);
+
+            AddStep("enable sample playback", () => skinSource.SamplePlaybackDisabled.Value = false);
+
+            AddWaitStep("wait a bit", 5);
+            AddAssert("sample not playing", () => !sample.Playing);
+        }
+
+        [Test]
+        public void TestLoopingSoundResumesAfterPause()
+        {
+            DrawableSample sample = null;
+            AddStep("start sample with looping", () =>
+            {
+                skinnableSound.Looping = true;
+                skinnableSound.Play();
+                sample = skinnableSound.ChildrenOfType<DrawableSample>().First();
+            });
+
+            AddUntilStep("wait for sample to start playing", () => sample.Playing);
+
+            AddStep("disable sample playback", () => skinSource.SamplePlaybackDisabled.Value = true);
+            AddUntilStep("wait for sample to stop playing", () => !sample.Playing);
+
+            AddStep("enable sample playback", () => skinSource.SamplePlaybackDisabled.Value = false);
+            AddUntilStep("wait for sample to start playing", () => sample.Playing);
+        }
+
+        [Test]
+        public void TestNonLoopingStopsWithPause()
+        {
+            DrawableSample sample = null;
+            AddStep("start sample", () =>
+            {
+                skinnableSound.Play();
+                sample = skinnableSound.ChildrenOfType<DrawableSample>().First();
+            });
+
+            AddAssert("sample playing", () => sample.Playing);
+
+            AddStep("disable sample playback", () => skinSource.SamplePlaybackDisabled.Value = true);
+
+            AddUntilStep("sample not playing", () => !sample.Playing);
+
+            AddStep("enable sample playback", () => skinSource.SamplePlaybackDisabled.Value = false);
+
+            AddAssert("sample not playing", () => !sample.Playing);
+            AddAssert("sample not playing", () => !sample.Playing);
+            AddAssert("sample not playing", () => !sample.Playing);
+        }
+
+        [Test]
+        public void TestSkinChangeDoesntPlayOnPause()
+        {
+            DrawableSample sample = null;
+            AddStep("start sample", () =>
+            {
+                skinnableSound.Play();
+                sample = skinnableSound.ChildrenOfType<DrawableSample>().Single();
+            });
+
+            AddAssert("sample playing", () => sample.Playing);
+
+            AddStep("disable sample playback", () => skinSource.SamplePlaybackDisabled.Value = true);
+            AddUntilStep("wait for sample to stop playing", () => !sample.Playing);
+
+            AddStep("trigger skin change", () => skinSource.TriggerSourceChanged());
+
+            AddAssert("retrieve and ensure current sample is different", () =>
+            {
+                DrawableSample oldSample = sample;
+                sample = skinnableSound.ChildrenOfType<DrawableSample>().Single();
+                return sample != oldSample;
+            });
+
+            AddAssert("new sample stopped", () => !sample.Playing);
+            AddStep("enable sample playback", () => skinSource.SamplePlaybackDisabled.Value = false);
+
+            AddWaitStep("wait a bit", 5);
+            AddAssert("new sample not played", () => !sample.Playing);
+        }
+
+        [Cached(typeof(ISkinSource))]
+        [Cached(typeof(ISamplePlaybackDisabler))]
+        private class TestSkinSourceContainer : Container, ISkinSource, ISamplePlaybackDisabler
+        {
+            [Resolved]
+            private ISkinSource source { get; set; }
+
+            public event Action SourceChanged;
+
+            public Bindable<bool> SamplePlaybackDisabled { get; } = new Bindable<bool>();
+
+            IBindable<bool> ISamplePlaybackDisabler.SamplePlaybackDisabled => SamplePlaybackDisabled;
+
+            public Drawable GetDrawableComponent(ISkinComponent component) => source?.GetDrawableComponent(component);
+            public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => source?.GetTexture(componentName, wrapModeS, wrapModeT);
+            public SampleChannel GetSample(ISampleInfo sampleInfo) => source?.GetSample(sampleInfo);
+            public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => source?.GetConfig<TLookup, TValue>(lookup);
+
+            public void TriggerSourceChanged()
+            {
+                SourceChanged?.Invoke();
+            }
+        }
+    }
+}

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

@@ -1,11 +1,9 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.Play;
 using osuTK;
@@ -32,7 +30,10 @@ namespace osu.Game.Tests.Visual.Gameplay
             requestCount = 0;
             increment = skip_time;
 
-            Child = gameplayClockContainer = new GameplayClockContainer(CreateWorkingBeatmap(CreateBeatmap(new OsuRuleset().RulesetInfo)), Array.Empty<Mod>(), 0)
+            var working = CreateWorkingBeatmap(CreateBeatmap(new OsuRuleset().RulesetInfo));
+            working.LoadTrack();
+
+            Child = gameplayClockContainer = new GameplayClockContainer(working, 0)
             {
                 RelativeSizeAxes = Axes.Both,
                 Children = new Drawable[]

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

@@ -0,0 +1,304 @@
+// 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.Tasks;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Online.Spectator;
+using osu.Game.Replays.Legacy;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play;
+using osu.Game.Tests.Beatmaps.IO;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneSpectator : ScreenTestScene
+    {
+        [Cached(typeof(SpectatorStreamingClient))]
+        private TestSpectatorStreamingClient testSpectatorStreamingClient = new TestSpectatorStreamingClient();
+
+        // used just to show beatmap card for the time being.
+        protected override bool UseOnlineAPI => true;
+
+        private Spectator spectatorScreen;
+
+        [Resolved]
+        private OsuGameBase game { get; set; }
+
+        private int nextFrame;
+
+        private BeatmapSetInfo importedBeatmap;
+
+        private int importedBeatmapId;
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("reset sent frames", () => nextFrame = 0);
+
+            AddStep("import beatmap", () =>
+            {
+                importedBeatmap = ImportBeatmapTest.LoadOszIntoOsu(game, virtualTrack: true).Result;
+                importedBeatmapId = importedBeatmap.Beatmaps.First(b => b.RulesetID == 0).OnlineBeatmapID ?? -1;
+            });
+
+            AddStep("add streaming client", () =>
+            {
+                Remove(testSpectatorStreamingClient);
+                Add(testSpectatorStreamingClient);
+            });
+
+            finish();
+        }
+
+        [Test]
+        public void TestFrameStarvationAndResume()
+        {
+            loadSpectatingScreen();
+
+            AddAssert("screen hasn't changed", () => Stack.CurrentScreen is Spectator);
+
+            start();
+            sendFrames();
+
+            waitForPlayer();
+            AddAssert("ensure frames arrived", () => replayHandler.HasFrames);
+
+            AddUntilStep("wait for frame starvation", () => replayHandler.NextFrame == null);
+            checkPaused(true);
+
+            double? pausedTime = null;
+
+            AddStep("store time", () => pausedTime = currentFrameStableTime);
+
+            sendFrames();
+
+            AddUntilStep("wait for frame starvation", () => replayHandler.NextFrame == null);
+            checkPaused(true);
+
+            AddAssert("time advanced", () => currentFrameStableTime > pausedTime);
+        }
+
+        [Test]
+        public void TestPlayStartsWithNoFrames()
+        {
+            loadSpectatingScreen();
+
+            start();
+            waitForPlayer();
+            checkPaused(true);
+
+            sendFrames(1000); // send enough frames to ensure play won't be paused
+
+            checkPaused(false);
+        }
+
+        [Test]
+        public void TestSpectatingDuringGameplay()
+        {
+            start();
+
+            loadSpectatingScreen();
+
+            AddStep("advance frame count", () => nextFrame = 300);
+            sendFrames();
+
+            waitForPlayer();
+
+            AddUntilStep("playing from correct point in time", () => player.ChildrenOfType<DrawableRuleset>().First().FrameStableClock.CurrentTime > 30000);
+        }
+
+        [Test]
+        public void TestHostRetriesWhileWatching()
+        {
+            loadSpectatingScreen();
+
+            start();
+            sendFrames();
+
+            waitForPlayer();
+
+            Player lastPlayer = null;
+            AddStep("store first player", () => lastPlayer = player);
+
+            start();
+            sendFrames();
+
+            waitForPlayer();
+            AddAssert("player is different", () => lastPlayer != player);
+        }
+
+        [Test]
+        public void TestHostFails()
+        {
+            loadSpectatingScreen();
+
+            start();
+
+            waitForPlayer();
+            checkPaused(true);
+
+            finish();
+
+            checkPaused(false);
+            // TODO: should replay until running out of frames then fail
+        }
+
+        [Test]
+        public void TestStopWatchingDuringPlay()
+        {
+            loadSpectatingScreen();
+
+            start();
+            sendFrames();
+            waitForPlayer();
+
+            AddStep("stop spectating", () => (Stack.CurrentScreen as Player)?.Exit());
+            AddUntilStep("spectating stopped", () => spectatorScreen.GetChildScreen() == null);
+        }
+
+        [Test]
+        public void TestStopWatchingThenHostRetries()
+        {
+            loadSpectatingScreen();
+
+            start();
+            sendFrames();
+            waitForPlayer();
+
+            AddStep("stop spectating", () => (Stack.CurrentScreen as Player)?.Exit());
+            AddUntilStep("spectating stopped", () => spectatorScreen.GetChildScreen() == null);
+
+            // host starts playing a new session
+            start();
+            waitForPlayer();
+        }
+
+        [Test]
+        public void TestWatchingBeatmapThatDoesntExistLocally()
+        {
+            loadSpectatingScreen();
+
+            start(-1234);
+            sendFrames();
+
+            AddAssert("screen didn't change", () => Stack.CurrentScreen is Spectator);
+        }
+
+        private OsuFramedReplayInputHandler replayHandler =>
+            (OsuFramedReplayInputHandler)Stack.ChildrenOfType<OsuInputManager>().First().ReplayInputHandler;
+
+        private Player player => Stack.CurrentScreen as Player;
+
+        private double currentFrameStableTime
+            => player.ChildrenOfType<FrameStabilityContainer>().First().FrameStableClock.CurrentTime;
+
+        private void waitForPlayer() => AddUntilStep("wait for player", () => Stack.CurrentScreen is Player);
+
+        private void start(int? beatmapId = null) => AddStep("start play", () => testSpectatorStreamingClient.StartPlay(beatmapId ?? importedBeatmapId));
+
+        private void finish(int? beatmapId = null) => AddStep("end play", () => testSpectatorStreamingClient.EndPlay(beatmapId ?? importedBeatmapId));
+
+        private void checkPaused(bool state) =>
+            AddUntilStep($"game is {(state ? "paused" : "playing")}", () => player.ChildrenOfType<DrawableRuleset>().First().IsPaused.Value == state);
+
+        private void sendFrames(int count = 10)
+        {
+            AddStep("send frames", () =>
+            {
+                testSpectatorStreamingClient.SendFrames(nextFrame, count);
+                nextFrame += count;
+            });
+        }
+
+        private void loadSpectatingScreen()
+        {
+            AddStep("load screen", () => LoadScreen(spectatorScreen = new Spectator(testSpectatorStreamingClient.StreamingUser)));
+            AddUntilStep("wait for screen load", () => spectatorScreen.LoadState == LoadState.Loaded);
+        }
+
+        public class TestSpectatorStreamingClient : SpectatorStreamingClient
+        {
+            public readonly User StreamingUser = new User { Id = 1234, Username = "Test user" };
+
+            public new BindableList<int> PlayingUsers => (BindableList<int>)base.PlayingUsers;
+
+            private int beatmapId;
+
+            protected override Task Connect()
+            {
+                return Task.CompletedTask;
+            }
+
+            public void StartPlay(int beatmapId)
+            {
+                this.beatmapId = beatmapId;
+                sendState(beatmapId);
+            }
+
+            public void EndPlay(int beatmapId)
+            {
+                ((ISpectatorClient)this).UserFinishedPlaying(StreamingUser.Id, new SpectatorState
+                {
+                    BeatmapID = beatmapId,
+                    RulesetID = 0,
+                });
+
+                sentState = false;
+            }
+
+            private bool sentState;
+
+            public void SendFrames(int index, int count)
+            {
+                var frames = new List<LegacyReplayFrame>();
+
+                for (int i = index; i < index + count; i++)
+                {
+                    var buttonState = i == index + count - 1 ? ReplayButtonState.None : ReplayButtonState.Left1;
+
+                    frames.Add(new LegacyReplayFrame(i * 100, RNG.Next(0, 512), RNG.Next(0, 512), buttonState));
+                }
+
+                var bundle = new FrameDataBundle(frames);
+                ((ISpectatorClient)this).UserSentFrames(StreamingUser.Id, bundle);
+
+                if (!sentState)
+                    sendState(beatmapId);
+            }
+
+            public override void WatchUser(int userId)
+            {
+                if (sentState)
+                {
+                    // usually the server would do this.
+                    sendState(beatmapId);
+                }
+
+                base.WatchUser(userId);
+            }
+
+            private void sendState(int beatmapId)
+            {
+                sentState = true;
+                ((ISpectatorClient)this).UserBeganPlaying(StreamingUser.Id, new SpectatorState
+                {
+                    BeatmapID = beatmapId,
+                    RulesetID = 0,
+                });
+            }
+        }
+    }
+}

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

@@ -0,0 +1,361 @@
+// 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.Collections.Specialized;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+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.Framework.Logging;
+using osu.Framework.Testing;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Online.API;
+using osu.Game.Online.Spectator;
+using osu.Game.Replays;
+using osu.Game.Replays.Legacy;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.Replays.Types;
+using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play;
+using osu.Game.Tests.Visual.UserInterface;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneSpectatorPlayback : OsuManualInputManagerTestScene
+    {
+        protected override bool UseOnlineAPI => true;
+
+        private TestRulesetInputManager playbackManager;
+        private TestRulesetInputManager recordingManager;
+
+        private Replay replay;
+
+        private readonly IBindableList<int> users = new BindableList<int>();
+
+        private TestReplayRecorder recorder;
+
+        private readonly ManualClock manualClock = new ManualClock();
+
+        private OsuSpriteText latencyDisplay;
+
+        private TestFramedReplayInputHandler replayHandler;
+
+        [Resolved]
+        private IAPIProvider api { get; set; }
+
+        [Resolved]
+        private SpectatorStreamingClient streamingClient { get; set; }
+
+        [Cached]
+        private GameplayBeatmap gameplayBeatmap = new GameplayBeatmap(new Beatmap());
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            replay = new Replay();
+
+            users.BindTo(streamingClient.PlayingUsers);
+            users.BindCollectionChanged((obj, args) =>
+            {
+                switch (args.Action)
+                {
+                    case NotifyCollectionChangedAction.Add:
+                        foreach (int user in args.NewItems)
+                        {
+                            if (user == api.LocalUser.Value.Id)
+                                streamingClient.WatchUser(user);
+                        }
+
+                        break;
+
+                    case NotifyCollectionChangedAction.Remove:
+                        foreach (int user in args.OldItems)
+                        {
+                            if (user == api.LocalUser.Value.Id)
+                                streamingClient.StopWatchingUser(user);
+                        }
+
+                        break;
+                }
+            }, true);
+
+            streamingClient.OnNewFrames += onNewFrames;
+
+            Add(new GridContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Content = new[]
+                {
+                    new Drawable[]
+                    {
+                        recordingManager = new TestRulesetInputManager(new TestSceneModSettings.TestRulesetInfo(), 0, SimultaneousBindingMode.Unique)
+                        {
+                            Recorder = recorder = new TestReplayRecorder
+                            {
+                                ScreenSpaceToGamefield = pos => recordingManager.ToLocalSpace(pos),
+                            },
+                            Child = new Container
+                            {
+                                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 Drawable[]
+                    {
+                        playbackManager = new TestRulesetInputManager(new TestSceneModSettings.TestRulesetInfo(), 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()
+                                }
+                            },
+                        }
+                    }
+                }
+            });
+
+            Add(latencyDisplay = new OsuSpriteText());
+        });
+
+        private void onNewFrames(int userId, FrameDataBundle frames)
+        {
+            Logger.Log($"Received {frames.Frames.Count()} new frames ({string.Join(',', frames.Frames.Select(f => ((int)f.Time).ToString()))})");
+
+            foreach (var legacyFrame in frames.Frames)
+            {
+                var frame = new TestReplayFrame();
+                frame.FromLegacy(legacyFrame, null, null);
+                replay.Frames.Add(frame);
+            }
+        }
+
+        [Test]
+        public void TestBasic()
+        {
+        }
+
+        private double latency = SpectatorStreamingClient.TIME_BETWEEN_SENDS;
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (latencyDisplay == null) return;
+
+            // propagate initial time value
+            if (manualClock.CurrentTime == 0)
+            {
+                manualClock.CurrentTime = Time.Current;
+                return;
+            }
+
+            if (replayHandler.NextFrame != null)
+            {
+                var lastFrame = replay.Frames.LastOrDefault();
+
+                // this isn't perfect as we basically can't be aware of the rate-of-send here (the streamer is not sending data when not being moved).
+                // in gameplay playback, the case where NextFrame is null would pause gameplay and handle this correctly; it's strictly a test limitation / best effort implementation.
+                if (lastFrame != null)
+                    latency = Math.Max(latency, Time.Current - lastFrame.Time);
+
+                latencyDisplay.Text = $"latency: {latency:N1}";
+
+                double proposedTime = Time.Current - latency + Time.Elapsed;
+
+                // this will either advance by one or zero frames.
+                double? time = replayHandler.SetFrameFromTime(proposedTime);
+
+                if (time == null)
+                    return;
+
+                manualClock.CurrentTime = time.Value;
+            }
+        }
+
+        [TearDownSteps]
+        public void TearDown()
+        {
+            AddStep("stop recorder", () =>
+            {
+                recorder.Expire();
+                streamingClient.OnNewFrames -= onNewFrames;
+            });
+        }
+
+        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 TestInputConsumer : CompositeDrawable, IKeyBindingHandler<TestAction>
+        {
+            public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => Parent.ReceivePositionalInputAt(screenSpacePos);
+
+            private readonly Box box;
+
+            public TestInputConsumer()
+            {
+                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(TestAction action)
+            {
+                box.Colour = Color4.White;
+                return true;
+            }
+
+            public void OnReleased(TestAction action)
+            {
+                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<KeyBinding> DefaultKeyBindings => new[]
+                {
+                    new KeyBinding(InputKey.MouseLeft, TestAction.Down),
+                };
+            }
+        }
+
+        public class TestReplayFrame : ReplayFrame, IConvertibleReplayFrame
+        {
+            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 TestReplayFrame()
+            {
+            }
+
+            public void FromLegacy(LegacyReplayFrame currentFrame, IBeatmap beatmap, ReplayFrame lastFrame = null)
+            {
+                Position = currentFrame.Position;
+                Time = currentFrame.Time;
+                if (currentFrame.MouseLeft)
+                    Actions.Add(TestAction.Down);
+            }
+
+            public LegacyReplayFrame ToLegacy(IBeatmap beatmap)
+            {
+                ReplayButtonState state = ReplayButtonState.None;
+
+                if (Actions.Contains(TestAction.Down))
+                    state |= ReplayButtonState.Left1;
+
+                return new LegacyReplayFrame(Time, Position.X, Position.Y, state);
+            }
+        }
+
+        public enum TestAction
+        {
+            Down,
+        }
+
+        internal class TestReplayRecorder : ReplayRecorder<TestAction>
+        {
+            public TestReplayRecorder()
+                : base(new Replay())
+            {
+            }
+
+            protected override ReplayFrame HandleFrame(Vector2 mousePosition, List<TestAction> actions, ReplayFrame previousFrame)
+            {
+                return new TestReplayFrame(Time.Current, mousePosition, actions.ToArray());
+            }
+        }
+    }
+}

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

@@ -22,19 +22,32 @@ namespace osu.Game.Tests.Visual.Gameplay
     [TestFixture]
     public class TestSceneStoryboard : OsuTestScene
     {
-        private readonly Container<DrawableStoryboard> storyboardContainer;
+        private Container<DrawableStoryboard> storyboardContainer;
         private DrawableStoryboard storyboard;
 
-        [Cached]
-        private MusicController musicController = new MusicController();
+        [Test]
+        public void TestStoryboard()
+        {
+            AddStep("Restart", restart);
+            AddToggleStep("Passing", passing =>
+            {
+                if (storyboard != null) storyboard.Passing = passing;
+            });
+        }
 
-        public TestSceneStoryboard()
+        [Test]
+        public void TestStoryboardMissingVideo()
+        {
+            AddStep("Load storyboard with missing video", loadStoryboardNoVideo);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
         {
             Clock = new FramedClock();
 
             AddRange(new Drawable[]
             {
-                musicController,
                 new Container
                 {
                     RelativeSizeAxes = Axes.Both,
@@ -58,32 +71,11 @@ namespace osu.Game.Tests.Visual.Gameplay
                     State = { Value = Visibility.Visible },
                 }
             });
+
+            Beatmap.BindValueChanged(beatmapChanged, true);
         }
 
-        [Test]
-        public void TestStoryboard()
-        {
-            AddStep("Restart", restart);
-            AddToggleStep("Passing", passing =>
-            {
-                if (storyboard != null) storyboard.Passing = passing;
-            });
-        }
-
-        [Test]
-        public void TestStoryboardMissingVideo()
-        {
-            AddStep("Load storyboard with missing video", loadStoryboardNoVideo);
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            Beatmap.ValueChanged += beatmapChanged;
-        }
-
-        private void beatmapChanged(ValueChangedEvent<WorkingBeatmap> e)
-            => loadStoryboard(e.NewValue);
+        private void beatmapChanged(ValueChangedEvent<WorkingBeatmap> e) => loadStoryboard(e.NewValue);
 
         private void restart()
         {

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

@@ -19,10 +19,10 @@ namespace osu.Game.Tests.Visual.Menus
         [Cached]
         private OsuLogo logo;
 
+        protected OsuScreenStack IntroStack;
+
         protected IntroTestScene()
         {
-            OsuScreenStack introStack = null;
-
             Children = new Drawable[]
             {
                 new Box
@@ -45,17 +45,17 @@ namespace osu.Game.Tests.Visual.Menus
                 logo.FinishTransforms();
                 logo.IsTracking = false;
 
-                introStack?.Expire();
+                IntroStack?.Expire();
 
-                Add(introStack = new OsuScreenStack
+                Add(IntroStack = new OsuScreenStack
                 {
                     RelativeSizeAxes = Axes.Both,
                 });
 
-                introStack.Push(CreateScreen());
+                IntroStack.Push(CreateScreen());
             });
 
-            AddUntilStep("wait for menu", () => introStack.CurrentScreen is MainMenu);
+            AddUntilStep("wait for menu", () => IntroStack.CurrentScreen is MainMenu);
         }
 
         protected abstract IScreen CreateScreen();

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

@@ -0,0 +1,23 @@
+// 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.Screens;
+using osu.Framework.Utils;
+using osu.Game.Screens.Menu;
+
+namespace osu.Game.Tests.Visual.Menus
+{
+    [TestFixture]
+    public class TestSceneIntroWelcome : IntroTestScene
+    {
+        protected override IScreen CreateScreen() => new IntroWelcome();
+
+        public TestSceneIntroWelcome()
+        {
+            AddUntilStep("wait for load", () => MusicController.TrackLoaded);
+            AddAssert("correct track", () => Precision.AlmostEquals(MusicController.CurrentTrack.Length, 48000, 1));
+            AddAssert("check if menu music loops", () => MusicController.CurrentTrack.Looping);
+        }
+    }
+}

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

@@ -0,0 +1,83 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Input.Bindings;
+using osu.Game.Overlays;
+using osu.Game.Tests.Resources;
+using osu.Game.Tests.Visual.Navigation;
+
+namespace osu.Game.Tests.Visual.Menus
+{
+    public class TestSceneMusicActionHandling : OsuGameTestScene
+    {
+        private GlobalActionContainer globalActionContainer => Game.ChildrenOfType<GlobalActionContainer>().First();
+
+        [Test]
+        public void TestMusicPlayAction()
+        {
+            AddStep("ensure playing something", () => Game.MusicController.EnsurePlayingSomething());
+            AddStep("toggle playback", () => globalActionContainer.TriggerPressed(GlobalAction.MusicPlay));
+            AddAssert("music paused", () => !Game.MusicController.IsPlaying && Game.MusicController.UserPauseRequested);
+            AddStep("toggle playback", () => globalActionContainer.TriggerPressed(GlobalAction.MusicPlay));
+            AddAssert("music resumed", () => Game.MusicController.IsPlaying && !Game.MusicController.UserPauseRequested);
+        }
+
+        [Test]
+        public void TestMusicNavigationActions()
+        {
+            int importId = 0;
+            Queue<(WorkingBeatmap working, TrackChangeDirection changeDirection)> trackChangeQueue = null;
+
+            // ensure we have at least two beatmaps available to identify the direction the music controller navigated to.
+            AddRepeatStep("import beatmap", () => Game.BeatmapManager.Import(new BeatmapSetInfo
+            {
+                Beatmaps = new List<BeatmapInfo>
+                {
+                    new BeatmapInfo
+                    {
+                        BaseDifficulty = new BeatmapDifficulty(),
+                    }
+                },
+                Metadata = new BeatmapMetadata
+                {
+                    Artist = $"a test map {importId++}",
+                    Title = "title",
+                }
+            }).Wait(), 5);
+
+            AddStep("import beatmap with track", () =>
+            {
+                var setWithTrack = Game.BeatmapManager.Import(TestResources.GetTestBeatmapForImport()).Result;
+                Beatmap.Value = Game.BeatmapManager.GetWorkingBeatmap(setWithTrack.Beatmaps.First());
+            });
+
+            AddStep("bind to track change", () =>
+            {
+                trackChangeQueue = new Queue<(WorkingBeatmap, TrackChangeDirection)>();
+                Game.MusicController.TrackChanged += (working, changeDirection) => trackChangeQueue.Enqueue((working, changeDirection));
+            });
+
+            AddStep("seek track to 6 second", () => Game.MusicController.SeekTo(6000));
+            AddUntilStep("wait for current time to update", () => Game.MusicController.CurrentTrack.CurrentTime > 5000);
+
+            AddStep("press previous", () => globalActionContainer.TriggerPressed(GlobalAction.MusicPrev));
+            AddAssert("no track change", () => trackChangeQueue.Count == 0);
+            AddUntilStep("track restarted", () => Game.MusicController.CurrentTrack.CurrentTime < 5000);
+
+            AddStep("press previous", () => globalActionContainer.TriggerPressed(GlobalAction.MusicPrev));
+            AddAssert("track changed to previous", () =>
+                trackChangeQueue.Count == 1 &&
+                trackChangeQueue.Dequeue().changeDirection == TrackChangeDirection.Prev);
+
+            AddStep("press next", () => globalActionContainer.TriggerPressed(GlobalAction.MusicNext));
+            AddAssert("track changed to next", () =>
+                trackChangeQueue.Count == 1 &&
+                trackChangeQueue.Dequeue().changeDirection == TrackChangeDirection.Next);
+        }
+    }
+}

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

@@ -1,7 +1,6 @@
 // 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.Game.Overlays;
@@ -11,14 +10,10 @@ namespace osu.Game.Tests.Visual.Menus
 {
     public class TestSceneSongTicker : OsuTestScene
     {
-        [Cached]
-        private MusicController musicController = new MusicController();
-
         public TestSceneSongTicker()
         {
             AddRange(new Drawable[]
             {
-                musicController,
                 new SongTicker
                 {
                     Anchor = Anchor.Centre,

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

@@ -4,8 +4,10 @@
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
+using osu.Game.Overlays;
 using osu.Game.Overlays.Toolbar;
 using osu.Game.Rulesets;
 using osuTK.Input;
@@ -15,7 +17,7 @@ namespace osu.Game.Tests.Visual.Menus
     [TestFixture]
     public class TestSceneToolbar : OsuManualInputManagerTestScene
     {
-        private Toolbar toolbar;
+        private TestToolbar toolbar;
 
         [Resolved]
         private RulesetStore rulesets { get; set; }
@@ -23,7 +25,7 @@ namespace osu.Game.Tests.Visual.Menus
         [SetUp]
         public void SetUp() => Schedule(() =>
         {
-            Child = toolbar = new Toolbar { State = { Value = Visibility.Visible } };
+            Child = toolbar = new TestToolbar { State = { Value = Visibility.Visible } };
         });
 
         [Test]
@@ -63,14 +65,31 @@ namespace osu.Game.Tests.Visual.Menus
                 AddStep($"switch to ruleset {i} via shortcut", () =>
                 {
                     InputManager.PressKey(Key.ControlLeft);
-                    InputManager.PressKey(numberKey);
-
+                    InputManager.Key(numberKey);
                     InputManager.ReleaseKey(Key.ControlLeft);
-                    InputManager.ReleaseKey(numberKey);
                 });
 
                 AddUntilStep("ruleset switched", () => rulesetSelector.Current.Value.Equals(expected));
             }
         }
+
+        [TestCase(OverlayActivation.All)]
+        [TestCase(OverlayActivation.Disabled)]
+        public void TestRespectsOverlayActivation(OverlayActivation mode)
+        {
+            AddStep($"set activation mode to {mode}", () => toolbar.OverlayActivationMode.Value = mode);
+            AddStep("hide toolbar", () => toolbar.Hide());
+            AddStep("try to show toolbar", () => toolbar.Show());
+
+            if (mode == OverlayActivation.Disabled)
+                AddAssert("toolbar still hidden", () => toolbar.State.Value == Visibility.Hidden);
+            else
+                AddAssert("toolbar is visible", () => toolbar.State.Value == Visibility.Visible);
+        }
+
+        public class TestToolbar : Toolbar
+        {
+            public new Bindable<OverlayActivation> OverlayActivationMode => base.OverlayActivationMode as Bindable<OverlayActivation>;
+        }
     }
 }

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

@@ -0,0 +1,61 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Game.Beatmaps;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Rulesets;
+using osu.Game.Screens.Multi;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public abstract class RoomManagerTestScene : MultiplayerTestScene
+    {
+        [Cached(Type = typeof(IRoomManager))]
+        protected TestRoomManager RoomManager { get; } = new TestRoomManager();
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("clear rooms", () => RoomManager.Rooms.Clear());
+        }
+
+        protected void AddRooms(int count, RulesetInfo ruleset = null)
+        {
+            AddStep("add rooms", () =>
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    var room = new Room
+                    {
+                        RoomID = { Value = i },
+                        Name = { Value = $"Room {i}" },
+                        Host = { Value = new User { Username = "Host" } },
+                        EndDate = { Value = DateTimeOffset.Now + TimeSpan.FromSeconds(10) },
+                        Category = { Value = i % 2 == 0 ? RoomCategory.Spotlight : RoomCategory.Normal }
+                    };
+
+                    if (ruleset != null)
+                    {
+                        room.Playlist.Add(new PlaylistItem
+                        {
+                            Ruleset = { Value = ruleset },
+                            Beatmap =
+                            {
+                                Value = new BeatmapInfo
+                                {
+                                    Metadata = new BeatmapMetadata()
+                                }
+                            }
+                        });
+                    }
+
+                    RoomManager.Rooms.Add(room);
+                }
+            });
+        }
+    }
+}

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

@@ -0,0 +1,35 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Bindables;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Screens.Multi;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public class TestRoomManager : IRoomManager
+    {
+        public event Action RoomsUpdated
+        {
+            add { }
+            remove { }
+        }
+
+        public readonly BindableList<Room> Rooms = new BindableList<Room>();
+
+        public Bindable<bool> InitialRoomsReceived { get; } = new Bindable<bool>(true);
+
+        IBindableList<Room> IRoomManager.Rooms => Rooms;
+
+        public void CreateRoom(Room room, Action<Room> onSuccess = null, Action<string> onError = null) => Rooms.Add(room);
+
+        public void JoinRoom(Room room, Action<Room> onSuccess = null, Action<string> onError = null)
+        {
+        }
+
+        public void PartRoom()
+        {
+        }
+    }
+}

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

@@ -4,12 +4,18 @@
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Platform;
 using osu.Framework.Testing;
+using osu.Game.Beatmaps;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.Multiplayer;
+using osu.Game.Overlays;
+using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.Multi;
@@ -23,6 +29,18 @@ namespace osu.Game.Tests.Visual.Multiplayer
     {
         private TestPlaylist playlist;
 
+        private BeatmapManager manager;
+        private RulesetStore rulesets;
+
+        [BackgroundDependencyLoader]
+        private void load(GameHost host, AudioManager audio)
+        {
+            Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
+            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, host, Beatmap.Default));
+
+            manager.Import(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo.BeatmapSet).Wait();
+        }
+
         [Test]
         public void TestNonEditableNonSelectable()
         {
@@ -182,6 +200,28 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("click delete button", () => InputManager.Click(MouseButton.Left));
         }
 
+        [Test]
+        public void TestDownloadButtonHiddenInitiallyWhenBeatmapExists()
+        {
+            createPlaylist(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo);
+
+            AddAssert("download button hidden", () => !playlist.ChildrenOfType<BeatmapDownloadTrackingComposite>().Single().IsPresent);
+        }
+
+        [Test]
+        public void TestDownloadButtonVisibleInitiallyWhenBeatmapDoesNotExist()
+        {
+            var byOnlineId = new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo;
+            byOnlineId.BeatmapSet.OnlineBeatmapSetID = 1337; // Some random ID that does not exist locally.
+
+            var byChecksum = new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo;
+            byChecksum.MD5Hash = "1337"; // Some random checksum that does not exist locally.
+
+            createPlaylist(byOnlineId, byChecksum);
+
+            AddAssert("download buttons shown", () => playlist.ChildrenOfType<BeatmapDownloadTrackingComposite>().All(d => d.IsPresent));
+        }
+
         private void moveToItem(int index, Vector2? offset = null)
             => AddStep($"move mouse to item {index}", () => InputManager.MoveMouseTo(playlist.ChildrenOfType<OsuRearrangeableListItem<PlaylistItem>>().ElementAt(index), offset));
 
@@ -235,6 +275,39 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddUntilStep("wait for items to load", () => playlist.ItemMap.Values.All(i => i.IsLoaded));
         }
 
+        private void createPlaylist(params BeatmapInfo[] beatmaps)
+        {
+            AddStep("create playlist", () =>
+            {
+                Child = playlist = new TestPlaylist(false, false)
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(500, 300)
+                };
+
+                int index = 0;
+
+                foreach (var b in beatmaps)
+                {
+                    playlist.Items.Add(new PlaylistItem
+                    {
+                        ID = index++,
+                        Beatmap = { Value = b },
+                        Ruleset = { Value = new OsuRuleset().RulesetInfo },
+                        RequiredMods =
+                        {
+                            new OsuModHardRock(),
+                            new OsuModDoubleTime(),
+                            new OsuModAutoplay()
+                        }
+                    });
+                }
+            });
+
+            AddUntilStep("wait for items to load", () => playlist.ItemMap.Values.All(i => i.IsLoaded));
+        }
+
         private class TestPlaylist : DrawableRoomPlaylist
         {
             public new IReadOnlyDictionary<PlaylistItem, RearrangeableListItem<PlaylistItem>> ItemMap => base.ItemMap;

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

@@ -0,0 +1,20 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics;
+using osu.Game.Screens.Multi.Lounge.Components;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public class TestSceneLoungeFilterControl : OsuTestScene
+    {
+        public TestSceneLoungeFilterControl()
+        {
+            Child = new FilterControl
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre
+            };
+        }
+    }
+}

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

@@ -16,7 +16,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [SetUp]
         public void Setup() => Schedule(() =>
         {
-            Room.CopyFrom(new Room());
+            Room = new Room();
 
             Child = new RoomInfo
             {

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

@@ -1,30 +1,22 @@
 // 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.Bindables;
 using osu.Framework.Graphics;
-using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Online.Multiplayer;
-using osu.Game.Rulesets;
 using osu.Game.Rulesets.Catch;
 using osu.Game.Rulesets.Osu;
-using osu.Game.Screens.Multi;
 using osu.Game.Screens.Multi.Lounge.Components;
-using osu.Game.Users;
 using osuTK.Graphics;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
-    public class TestSceneLoungeRoomsContainer : MultiplayerTestScene
+    public class TestSceneLoungeRoomsContainer : RoomManagerTestScene
     {
-        [Cached(Type = typeof(IRoomManager))]
-        private TestRoomManager roomManager = new TestRoomManager();
-
         private RoomsContainer container;
 
         [BackgroundDependencyLoader]
@@ -39,34 +31,53 @@ namespace osu.Game.Tests.Visual.Multiplayer
             };
         }
 
-        public override void SetUpSteps()
-        {
-            base.SetUpSteps();
-
-            AddStep("clear rooms", () => roomManager.Rooms.Clear());
-        }
-
         [Test]
         public void TestBasicListChanges()
         {
-            addRooms(3);
+            AddRooms(3);
 
             AddAssert("has 3 rooms", () => container.Rooms.Count == 3);
-            AddStep("remove first room", () => roomManager.Rooms.Remove(roomManager.Rooms.FirstOrDefault()));
+            AddStep("remove first room", () => RoomManager.Rooms.Remove(RoomManager.Rooms.FirstOrDefault()));
             AddAssert("has 2 rooms", () => container.Rooms.Count == 2);
             AddAssert("first room removed", () => container.Rooms.All(r => r.Room.RoomID.Value != 0));
 
             AddStep("select first room", () => container.Rooms.First().Action?.Invoke());
-            AddAssert("first room selected", () => Room == roomManager.Rooms.First());
+            AddAssert("first room selected", () => checkRoomSelected(RoomManager.Rooms.First()));
 
             AddStep("join first room", () => container.Rooms.First().Action?.Invoke());
-            AddAssert("first room joined", () => roomManager.Rooms.First().Status.Value is JoinedRoomStatus);
+            AddAssert("first room joined", () => RoomManager.Rooms.First().Status.Value is JoinedRoomStatus);
+        }
+
+        [Test]
+        public void TestKeyboardNavigation()
+        {
+            AddRooms(3);
+
+            AddAssert("no selection", () => checkRoomSelected(null));
+
+            press(Key.Down);
+            AddAssert("first room selected", () => checkRoomSelected(RoomManager.Rooms.First()));
+
+            press(Key.Up);
+            AddAssert("first room selected", () => checkRoomSelected(RoomManager.Rooms.First()));
+
+            press(Key.Down);
+            press(Key.Down);
+            AddAssert("last room selected", () => checkRoomSelected(RoomManager.Rooms.Last()));
+
+            press(Key.Enter);
+            AddAssert("last room joined", () => RoomManager.Rooms.Last().Status.Value is JoinedRoomStatus);
+        }
+
+        private void press(Key down)
+        {
+            AddStep($"press {down}", () => InputManager.Key(down));
         }
 
         [Test]
         public void TestStringFiltering()
         {
-            addRooms(4);
+            AddRooms(4);
 
             AddUntilStep("4 rooms visible", () => container.Rooms.Count(r => r.IsPresent) == 4);
 
@@ -82,8 +93,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestRulesetFiltering()
         {
-            addRooms(2, new OsuRuleset().RulesetInfo);
-            addRooms(3, new CatchRuleset().RulesetInfo);
+            AddRooms(2, new OsuRuleset().RulesetInfo);
+            AddRooms(3, new CatchRuleset().RulesetInfo);
 
             AddUntilStep("5 rooms visible", () => container.Rooms.Count(r => r.IsPresent) == 5);
 
@@ -96,64 +107,10 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddUntilStep("3 rooms visible", () => container.Rooms.Count(r => r.IsPresent) == 3);
         }
 
-        private void addRooms(int count, RulesetInfo ruleset = null)
-        {
-            AddStep("add rooms", () =>
-            {
-                for (int i = 0; i < count; i++)
-                {
-                    var room = new Room
-                    {
-                        RoomID = { Value = i },
-                        Name = { Value = $"Room {i}" },
-                        Host = { Value = new User { Username = "Host" } },
-                        EndDate = { Value = DateTimeOffset.Now + TimeSpan.FromSeconds(10) }
-                    };
-
-                    if (ruleset != null)
-                    {
-                        room.Playlist.Add(new PlaylistItem
-                        {
-                            Ruleset = { Value = ruleset },
-                            Beatmap =
-                            {
-                                Value = new BeatmapInfo
-                                {
-                                    Metadata = new BeatmapMetadata()
-                                }
-                            }
-                        });
-                    }
-
-                    roomManager.Rooms.Add(room);
-                }
-            });
-        }
+        private bool checkRoomSelected(Room room) => Room == room;
 
         private void joinRequested(Room room) => room.Status.Value = new JoinedRoomStatus();
 
-        private class TestRoomManager : IRoomManager
-        {
-            public event Action RoomsUpdated
-            {
-                add { }
-                remove { }
-            }
-
-            public readonly BindableList<Room> Rooms = new BindableList<Room>();
-            IBindableList<Room> IRoomManager.Rooms => Rooms;
-
-            public void CreateRoom(Room room, Action<Room> onSuccess = null, Action<string> onError = null) => Rooms.Add(room);
-
-            public void JoinRoom(Room room, Action<Room> onSuccess = null, Action<string> onError = null)
-            {
-            }
-
-            public void PartRoom()
-            {
-            }
-        }
-
         private class JoinedRoomStatus : RoomStatus
         {
             public override string Message => "Joined";

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

@@ -0,0 +1,58 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Game.Graphics.Containers;
+using osu.Game.Screens.Multi.Lounge;
+using osu.Game.Screens.Multi.Lounge.Components;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public class TestSceneLoungeSubScreen : RoomManagerTestScene
+    {
+        private LoungeSubScreen loungeScreen;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+        }
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("push screen", () => LoadScreen(loungeScreen = new LoungeSubScreen
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Width = 0.5f,
+            }));
+
+            AddUntilStep("wait for present", () => loungeScreen.IsCurrentScreen());
+        }
+
+        private RoomsContainer roomsContainer => loungeScreen.ChildrenOfType<RoomsContainer>().First();
+
+        [Test]
+        public void TestScrollSelectedIntoView()
+        {
+            AddRooms(30);
+
+            AddUntilStep("first room is not masked", () => checkRoomVisible(roomsContainer.Rooms.First()));
+
+            AddStep("select last room", () => roomsContainer.Rooms.Last().Action?.Invoke());
+
+            AddUntilStep("first room is masked", () => !checkRoomVisible(roomsContainer.Rooms.First()));
+            AddUntilStep("last room is not masked", () => checkRoomVisible(roomsContainer.Rooms.Last()));
+        }
+
+        private bool checkRoomVisible(DrawableRoom room) =>
+            loungeScreen.ChildrenOfType<OsuScrollContainer>().First().ScreenSpaceDrawQuad
+                        .Contains(room.ScreenSpaceDrawQuad.Centre);
+    }
+}

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

@@ -26,7 +26,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [SetUp]
         public void Setup() => Schedule(() =>
         {
-            Room.Playlist.Clear();
+            Room = new Room();
 
             Child = new MatchBeatmapDetailArea
             {

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

@@ -14,6 +14,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
     {
         public TestSceneMatchHeader()
         {
+            Room = new Room();
             Room.Playlist.Add(new PlaylistItem
             {
                 Beatmap =

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

@@ -6,6 +6,7 @@ using Newtonsoft.Json;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Online.API;
+using osu.Game.Online.Multiplayer;
 using osu.Game.Screens.Multi.Match.Components;
 using osu.Game.Users;
 using osuTK;
@@ -18,7 +19,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         public TestSceneMatchLeaderboard()
         {
-            Room.RoomID.Value = 3;
+            Room = new Room { RoomID = { Value = 3 } };
 
             Add(new MatchLeaderboard
             {

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

@@ -1,32 +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 osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Screens.Multi.Match.Components;
-using osuTK;
-
-namespace osu.Game.Tests.Visual.Multiplayer
-{
-    public class TestSceneMatchLeaderboardChatDisplay : MultiplayerTestScene
-    {
-        protected override bool UseOnlineAPI => true;
-
-        public TestSceneMatchLeaderboardChatDisplay()
-        {
-            Room.RoomID.Value = 7;
-
-            Add(new Container
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                Size = new Vector2(500),
-                Child = new LeaderboardChatDisplay
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                }
-            });
-        }
-    }
-}

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

@@ -133,7 +133,9 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 remove { }
             }
 
-            public IBindableList<Room> Rooms { get; } = null;
+            public Bindable<bool> InitialRoomsReceived { get; } = new Bindable<bool>(true);
+
+            public IBindableList<Room> Rooms => null;
 
             public void CreateRoom(Room room, Action<Room> onSuccess = null, Action<string> onError = null)
             {

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

@@ -14,8 +14,11 @@ using osu.Framework.Platform;
 using osu.Framework.Screens;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Online.Multiplayer;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.Multi.Components;
 using osu.Game.Screens.Select;
 
@@ -51,7 +54,6 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 {
                     Ruleset = new OsuRuleset().RulesetInfo,
                     OnlineBeatmapID = beatmapId,
-                    Path = "normal.osu",
                     Version = $"{beatmapId} (length {TimeSpan.FromMilliseconds(length):m\\:ss}, bpm {bpm:0.#})",
                     Length = length,
                     BPM = bpm,
@@ -95,7 +97,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [SetUp]
         public void Setup() => Schedule(() =>
         {
-            Room.Playlist.Clear();
+            Room = new Room();
         });
 
         [Test]
@@ -144,6 +146,43 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("new item has id 2", () => Room.Playlist.Last().ID == 2);
         }
 
+        /// <summary>
+        /// Tests that the same <see cref="Mod"/> instances are not shared between two playlist items.
+        /// </summary>
+        [Test]
+        public void TestNewItemHasNewModInstances()
+        {
+            AddStep("set dt mod", () => SelectedMods.Value = new[] { new OsuModDoubleTime() });
+            AddStep("create item", () => songSelect.BeatmapDetails.CreateNewItem());
+            AddStep("change mod rate", () => ((OsuModDoubleTime)SelectedMods.Value[0]).SpeedChange.Value = 2);
+            AddStep("create item", () => songSelect.BeatmapDetails.CreateNewItem());
+
+            AddAssert("item 1 has rate 1.5", () => Precision.AlmostEquals(1.5, ((OsuModDoubleTime)Room.Playlist.First().RequiredMods[0]).SpeedChange.Value));
+            AddAssert("item 2 has rate 2", () => Precision.AlmostEquals(2, ((OsuModDoubleTime)Room.Playlist.Last().RequiredMods[0]).SpeedChange.Value));
+        }
+
+        /// <summary>
+        /// Tests that the global mod instances are not retained by the rooms, as global mod instances are retained and re-used by the mod select overlay.
+        /// </summary>
+        [Test]
+        public void TestGlobalModInstancesNotRetained()
+        {
+            OsuModDoubleTime mod = null;
+
+            AddStep("set dt mod and store", () =>
+            {
+                SelectedMods.Value = new[] { new OsuModDoubleTime() };
+
+                // Mod select overlay replaces our mod.
+                mod = (OsuModDoubleTime)SelectedMods.Value[0];
+            });
+
+            AddStep("create item", () => songSelect.BeatmapDetails.CreateNewItem());
+
+            AddStep("change stored mod rate", () => mod.SpeedChange.Value = 2);
+            AddAssert("item has rate 1.5", () => Precision.AlmostEquals(1.5, ((OsuModDoubleTime)Room.Playlist.First().RequiredMods[0]).SpeedChange.Value));
+        }
+
         private class TestMatchSongSelect : MatchSongSelect
         {
             public new MatchBeatmapDetailArea BeatmapDetails => (MatchBeatmapDetailArea)base.BeatmapDetails;

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

@@ -5,7 +5,9 @@ using System;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Audio;
 using osu.Framework.Bindables;
+using osu.Framework.Platform;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
@@ -29,18 +31,24 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Cached(typeof(IRoomManager))]
         private readonly TestRoomManager roomManager = new TestRoomManager();
 
-        [Resolved]
-        private BeatmapManager beatmaps { get; set; }
-
-        [Resolved]
-        private RulesetStore rulesets { get; set; }
+        private BeatmapManager manager;
+        private RulesetStore rulesets;
 
         private TestMatchSubScreen match;
 
+        [BackgroundDependencyLoader]
+        private void load(GameHost host, AudioManager audio)
+        {
+            Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
+            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, host, Beatmap.Default));
+
+            manager.Import(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo.BeatmapSet).Wait();
+        }
+
         [SetUp]
         public void Setup() => Schedule(() =>
         {
-            Room.CopyFrom(new Room());
+            Room = new Room();
         });
 
         [SetUpSteps]
@@ -50,6 +58,23 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddUntilStep("wait for load", () => match.IsCurrentScreen());
         }
 
+        [Test]
+        public void TestLoadSimpleMatch()
+        {
+            AddStep("set room properties", () =>
+            {
+                Room.RoomID.Value = 1;
+                Room.Name.Value = "my awesome room";
+                Room.Host.Value = new User { Id = 2, Username = "peppy" };
+                Room.RecentParticipants.Add(Room.Host.Value);
+                Room.Playlist.Add(new PlaylistItem
+                {
+                    Beatmap = { Value = new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo },
+                    Ruleset = { Value = new OsuRuleset().RulesetInfo }
+                });
+            });
+        }
+
         [Test]
         public void TestPlaylistItemSelectedOnCreate()
         {
@@ -75,10 +100,49 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("first playlist item selected", () => match.SelectedItem.Value == Room.Playlist[0]);
         }
 
+        [Test]
+        public void TestBeatmapUpdatedOnReImport()
+        {
+            BeatmapSetInfo importedSet = null;
+
+            AddStep("import altered beatmap", () =>
+            {
+                var beatmap = new TestBeatmap(new OsuRuleset().RulesetInfo);
+                beatmap.BeatmapInfo.BaseDifficulty.CircleSize = 1;
+
+                importedSet = manager.Import(beatmap.BeatmapInfo.BeatmapSet).Result;
+            });
+
+            AddStep("load room", () =>
+            {
+                Room.Name.Value = "my awesome room";
+                Room.Host.Value = new User { Id = 2, Username = "peppy" };
+                Room.Playlist.Add(new PlaylistItem
+                {
+                    Beatmap = { Value = importedSet.Beatmaps[0] },
+                    Ruleset = { Value = new OsuRuleset().RulesetInfo }
+                });
+            });
+
+            AddStep("create room", () =>
+            {
+                InputManager.MoveMouseTo(match.ChildrenOfType<MatchSettingsOverlay.CreateRoomButton>().Single());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("match has altered beatmap", () => match.Beatmap.Value.Beatmap.BeatmapInfo.BaseDifficulty.CircleSize == 1);
+
+            AddStep("re-import original beatmap", () => manager.Import(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo.BeatmapSet).Wait());
+
+            AddAssert("match has original beatmap", () => match.Beatmap.Value.Beatmap.BeatmapInfo.BaseDifficulty.CircleSize != 1);
+        }
+
         private class TestMatchSubScreen : MatchSubScreen
         {
             public new Bindable<PlaylistItem> SelectedItem => base.SelectedItem;
 
+            public new Bindable<WorkingBeatmap> Beatmap => base.Beatmap;
+
             public TestMatchSubScreen(Room room)
                 : base(room)
             {
@@ -93,6 +157,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 remove => throw new NotImplementedException();
             }
 
+            public Bindable<bool> InitialRoomsReceived { get; } = new Bindable<bool>(true);
+
             public IBindableList<Room> Rooms { get; } = new BindableList<Room>();
 
             public void CreateRoom(Room room, Action<Room> onSuccess = null, Action<string> onError = null)

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

@@ -2,6 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Game.Overlays;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
@@ -10,11 +12,15 @@ namespace osu.Game.Tests.Visual.Multiplayer
     {
         protected override bool UseOnlineAPI => true;
 
+        [Cached]
+        private MusicController musicController { get; set; } = new MusicController();
+
         public TestSceneMultiScreen()
         {
             Screens.Multi.Multiplayer multi = new Screens.Multi.Multiplayer();
 
-            AddStep(@"show", () => LoadScreen(multi));
+            AddStep("show", () => LoadScreen(multi));
+            AddUntilStep("wait for loaded", () => multi.IsLoaded);
         }
     }
 }

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

@@ -3,6 +3,7 @@
 
 using NUnit.Framework;
 using osu.Framework.Graphics;
+using osu.Game.Online.Multiplayer;
 using osu.Game.Screens.Multi.Components;
 using osuTK;
 
@@ -12,22 +13,22 @@ namespace osu.Game.Tests.Visual.Multiplayer
     {
         protected override bool UseOnlineAPI => true;
 
-        public TestSceneOverlinedParticipants()
+        [SetUp]
+        public void Setup() => Schedule(() =>
         {
-            Room.RoomID.Value = 7;
-        }
+            Room = new Room { RoomID = { Value = 7 } };
+        });
 
         [Test]
         public void TestHorizontalLayout()
         {
             AddStep("create component", () =>
             {
-                Child = new OverlinedParticipants(Direction.Horizontal)
+                Child = new ParticipantsDisplay(Direction.Horizontal)
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     Width = 500,
-                    AutoSizeAxes = Axes.Y,
                 };
             });
         }
@@ -37,7 +38,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             AddStep("create component", () =>
             {
-                Child = new OverlinedParticipants(Direction.Vertical)
+                Child = new ParticipantsDisplay(Direction.Vertical)
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,

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

@@ -4,7 +4,7 @@
 using osu.Framework.Graphics;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Rulesets.Osu;
-using osu.Game.Screens.Multi.Components;
+using osu.Game.Screens.Multi;
 using osu.Game.Tests.Beatmaps;
 using osuTK;
 
@@ -16,6 +16,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         public TestSceneOverlinedPlaylist()
         {
+            Room = new Room { RoomID = { Value = 7 } };
+
             for (int i = 0; i < 10; i++)
             {
                 Room.Playlist.Add(new PlaylistItem
@@ -26,7 +28,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 });
             }
 
-            Add(new OverlinedPlaylist(false)
+            Add(new DrawableRoomPlaylist(false, false)
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,

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

@@ -1,7 +1,9 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using NUnit.Framework;
 using osu.Framework.Graphics;
+using osu.Game.Online.Multiplayer;
 using osu.Game.Screens.Multi.Components;
 
 namespace osu.Game.Tests.Visual.Multiplayer
@@ -10,10 +12,14 @@ namespace osu.Game.Tests.Visual.Multiplayer
     {
         protected override bool UseOnlineAPI => true;
 
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            Room = new Room { RoomID = { Value = 7 } };
+        });
+
         public TestSceneParticipantsList()
         {
-            Room.RoomID.Value = 7;
-
             Add(new ParticipantsList { RelativeSizeAxes = Axes.Both });
         }
     }

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

@@ -0,0 +1,376 @@
+// 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 System.Net;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+using Newtonsoft.Json.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Screens.Multi.Ranking;
+using osu.Game.Screens.Ranking;
+using osu.Game.Tests.Beatmaps;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public class TestSceneTimeshiftResultsScreen : ScreenTestScene
+    {
+        private const int scores_per_result = 10;
+
+        private TestResultsScreen resultsScreen;
+        private int currentScoreId;
+        private bool requestComplete;
+
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            currentScoreId = 0;
+            requestComplete = false;
+            bindHandler();
+        });
+
+        [Test]
+        public void TestShowWithUserScore()
+        {
+            ScoreInfo userScore = null;
+
+            AddStep("bind user score info handler", () =>
+            {
+                userScore = new TestScoreInfo(new OsuRuleset().RulesetInfo) { OnlineScoreID = currentScoreId++ };
+                bindHandler(userScore: userScore);
+            });
+
+            createResults(() => userScore);
+            waitForDisplay();
+
+            AddAssert("user score selected", () => this.ChildrenOfType<ScorePanel>().Single(p => p.Score.OnlineScoreID == userScore.OnlineScoreID).State == PanelState.Expanded);
+        }
+
+        [Test]
+        public void TestShowNullUserScore()
+        {
+            createResults();
+            waitForDisplay();
+
+            AddAssert("top score selected", () => this.ChildrenOfType<ScorePanel>().OrderByDescending(p => p.Score.TotalScore).First().State == PanelState.Expanded);
+        }
+
+        [Test]
+        public void TestShowUserScoreWithDelay()
+        {
+            ScoreInfo userScore = null;
+
+            AddStep("bind user score info handler", () =>
+            {
+                userScore = new TestScoreInfo(new OsuRuleset().RulesetInfo) { OnlineScoreID = currentScoreId++ };
+                bindHandler(3000, userScore);
+            });
+
+            createResults(() => userScore);
+            waitForDisplay();
+
+            AddAssert("more than 1 panel displayed", () => this.ChildrenOfType<ScorePanel>().Count() > 1);
+            AddAssert("user score selected", () => this.ChildrenOfType<ScorePanel>().Single(p => p.Score.OnlineScoreID == userScore.OnlineScoreID).State == PanelState.Expanded);
+        }
+
+        [Test]
+        public void TestShowNullUserScoreWithDelay()
+        {
+            AddStep("bind delayed handler", () => bindHandler(3000));
+
+            createResults();
+            waitForDisplay();
+
+            AddAssert("top score selected", () => this.ChildrenOfType<ScorePanel>().OrderByDescending(p => p.Score.TotalScore).First().State == PanelState.Expanded);
+        }
+
+        [Test]
+        public void TestFetchWhenScrolledToTheRight()
+        {
+            createResults();
+            waitForDisplay();
+
+            AddStep("bind delayed handler", () => bindHandler(3000));
+
+            for (int i = 0; i < 2; i++)
+            {
+                int beforePanelCount = 0;
+
+                AddStep("get panel count", () => beforePanelCount = this.ChildrenOfType<ScorePanel>().Count());
+                AddStep("scroll to right", () => resultsScreen.ScorePanelList.ChildrenOfType<OsuScrollContainer>().Single().ScrollToEnd(false));
+
+                AddAssert("right loading spinner shown", () => resultsScreen.RightSpinner.State.Value == Visibility.Visible);
+                waitForDisplay();
+
+                AddAssert($"count increased by {scores_per_result}", () => this.ChildrenOfType<ScorePanel>().Count() == beforePanelCount + scores_per_result);
+                AddAssert("right loading spinner hidden", () => resultsScreen.RightSpinner.State.Value == Visibility.Hidden);
+            }
+        }
+
+        [Test]
+        public void TestFetchWhenScrolledToTheLeft()
+        {
+            ScoreInfo userScore = null;
+
+            AddStep("bind user score info handler", () =>
+            {
+                userScore = new TestScoreInfo(new OsuRuleset().RulesetInfo) { OnlineScoreID = currentScoreId++ };
+                bindHandler(userScore: userScore);
+            });
+
+            createResults(() => userScore);
+            waitForDisplay();
+
+            AddStep("bind delayed handler", () => bindHandler(3000));
+
+            for (int i = 0; i < 2; i++)
+            {
+                int beforePanelCount = 0;
+
+                AddStep("get panel count", () => beforePanelCount = this.ChildrenOfType<ScorePanel>().Count());
+                AddStep("scroll to left", () => resultsScreen.ScorePanelList.ChildrenOfType<OsuScrollContainer>().Single().ScrollToStart(false));
+
+                AddAssert("left loading spinner shown", () => resultsScreen.LeftSpinner.State.Value == Visibility.Visible);
+                waitForDisplay();
+
+                AddAssert($"count increased by {scores_per_result}", () => this.ChildrenOfType<ScorePanel>().Count() == beforePanelCount + scores_per_result);
+                AddAssert("left loading spinner hidden", () => resultsScreen.LeftSpinner.State.Value == Visibility.Hidden);
+            }
+        }
+
+        private void createResults(Func<ScoreInfo> getScore = null)
+        {
+            AddStep("load results", () =>
+            {
+                LoadScreen(resultsScreen = new TestResultsScreen(getScore?.Invoke(), 1, new PlaylistItem
+                {
+                    Beatmap = { Value = new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo },
+                    Ruleset = { Value = new OsuRuleset().RulesetInfo }
+                }));
+            });
+        }
+
+        private void waitForDisplay()
+        {
+            AddUntilStep("wait for request to complete", () => requestComplete);
+            AddWaitStep("wait for display", 5);
+        }
+
+        private void bindHandler(double delay = 0, ScoreInfo userScore = null, bool failRequests = false) => ((DummyAPIAccess)API).HandleRequest = request =>
+        {
+            requestComplete = false;
+
+            if (failRequests)
+            {
+                triggerFail(request, delay);
+                return;
+            }
+
+            switch (request)
+            {
+                case ShowPlaylistUserScoreRequest s:
+                    if (userScore == null)
+                        triggerFail(s, delay);
+                    else
+                        triggerSuccess(s, createUserResponse(userScore), delay);
+                    break;
+
+                case IndexPlaylistScoresRequest i:
+                    triggerSuccess(i, createIndexResponse(i), delay);
+                    break;
+            }
+        };
+
+        private void triggerSuccess<T>(APIRequest<T> req, T result, double delay)
+            where T : class
+        {
+            if (delay == 0)
+                success();
+            else
+            {
+                Task.Run(async () =>
+                {
+                    await Task.Delay(TimeSpan.FromMilliseconds(delay));
+                    Schedule(success);
+                });
+            }
+
+            void success()
+            {
+                requestComplete = true;
+                req.TriggerSuccess(result);
+            }
+        }
+
+        private void triggerFail(APIRequest req, double delay)
+        {
+            if (delay == 0)
+                fail();
+            else
+            {
+                Task.Run(async () =>
+                {
+                    await Task.Delay(TimeSpan.FromMilliseconds(delay));
+                    Schedule(fail);
+                });
+            }
+
+            void fail()
+            {
+                requestComplete = true;
+                req.TriggerFailure(new WebException("Failed."));
+            }
+        }
+
+        private MultiplayerScore createUserResponse([NotNull] ScoreInfo userScore)
+        {
+            var multiplayerUserScore = new MultiplayerScore
+            {
+                ID = (int)(userScore.OnlineScoreID ?? currentScoreId++),
+                Accuracy = userScore.Accuracy,
+                EndedAt = userScore.Date,
+                Passed = userScore.Passed,
+                Rank = userScore.Rank,
+                Position = 200,
+                MaxCombo = userScore.MaxCombo,
+                TotalScore = userScore.TotalScore,
+                User = userScore.User,
+                Statistics = userScore.Statistics,
+                ScoresAround = new MultiplayerScoresAround
+                {
+                    Higher = new MultiplayerScores(),
+                    Lower = new MultiplayerScores()
+                }
+            };
+
+            for (int i = 1; i <= scores_per_result; i++)
+            {
+                multiplayerUserScore.ScoresAround.Lower.Scores.Add(new MultiplayerScore
+                {
+                    ID = currentScoreId++,
+                    Accuracy = userScore.Accuracy,
+                    EndedAt = userScore.Date,
+                    Passed = true,
+                    Rank = userScore.Rank,
+                    MaxCombo = userScore.MaxCombo,
+                    TotalScore = userScore.TotalScore - i,
+                    User = new User
+                    {
+                        Id = 2,
+                        Username = $"peppy{i}",
+                        CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                    },
+                    Statistics = userScore.Statistics
+                });
+
+                multiplayerUserScore.ScoresAround.Higher.Scores.Add(new MultiplayerScore
+                {
+                    ID = currentScoreId++,
+                    Accuracy = userScore.Accuracy,
+                    EndedAt = userScore.Date,
+                    Passed = true,
+                    Rank = userScore.Rank,
+                    MaxCombo = userScore.MaxCombo,
+                    TotalScore = userScore.TotalScore + i,
+                    User = new User
+                    {
+                        Id = 2,
+                        Username = $"peppy{i}",
+                        CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                    },
+                    Statistics = userScore.Statistics
+                });
+            }
+
+            addCursor(multiplayerUserScore.ScoresAround.Lower);
+            addCursor(multiplayerUserScore.ScoresAround.Higher);
+
+            return multiplayerUserScore;
+        }
+
+        private IndexedMultiplayerScores createIndexResponse(IndexPlaylistScoresRequest req)
+        {
+            var result = new IndexedMultiplayerScores();
+
+            long startTotalScore = req.Cursor?.Properties["total_score"].ToObject<long>() ?? 1000000;
+            string sort = req.IndexParams?.Properties["sort"].ToObject<string>() ?? "score_desc";
+
+            for (int i = 1; i <= scores_per_result; i++)
+            {
+                result.Scores.Add(new MultiplayerScore
+                {
+                    ID = currentScoreId++,
+                    Accuracy = 1,
+                    EndedAt = DateTimeOffset.Now,
+                    Passed = true,
+                    Rank = ScoreRank.X,
+                    MaxCombo = 1000,
+                    TotalScore = startTotalScore + (sort == "score_asc" ? i : -i),
+                    User = new User
+                    {
+                        Id = 2,
+                        Username = $"peppy{i}",
+                        CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                    },
+                    Statistics = new Dictionary<HitResult, int>
+                    {
+                        { HitResult.Miss, 1 },
+                        { HitResult.Meh, 50 },
+                        { HitResult.Good, 100 },
+                        { HitResult.Great, 300 }
+                    }
+                });
+            }
+
+            addCursor(result);
+
+            return result;
+        }
+
+        private void addCursor(MultiplayerScores scores)
+        {
+            scores.Cursor = new Cursor
+            {
+                Properties = new Dictionary<string, JToken>
+                {
+                    { "total_score", JToken.FromObject(scores.Scores[^1].TotalScore) },
+                    { "score_id", JToken.FromObject(scores.Scores[^1].ID) },
+                }
+            };
+
+            scores.Params = new IndexScoresParams
+            {
+                Properties = new Dictionary<string, JToken>
+                {
+                    { "sort", JToken.FromObject(scores.Scores[^1].TotalScore > scores.Scores[^2].TotalScore ? "score_asc" : "score_desc") }
+                }
+            };
+        }
+
+        private class TestResultsScreen : TimeshiftResultsScreen
+        {
+            public new LoadingSpinner LeftSpinner => base.LeftSpinner;
+            public new LoadingSpinner CentreSpinner => base.CentreSpinner;
+            public new LoadingSpinner RightSpinner => base.RightSpinner;
+            public new ScorePanelList ScorePanelList => base.ScorePanelList;
+
+            public TestResultsScreen(ScoreInfo score, int roomId, PlaylistItem playlistItem, bool allowRetry = true)
+                : base(score, roomId, playlistItem, allowRetry)
+            {
+            }
+        }
+    }
+}

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

@@ -17,6 +17,7 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
 using osu.Game.Overlays;
 using osu.Game.Rulesets;
+using osu.Game.Scoring;
 using osu.Game.Screens;
 using osu.Game.Screens.Menu;
 using osuTK.Graphics;
@@ -33,6 +34,8 @@ namespace osu.Game.Tests.Visual.Navigation
 
         protected TestOsuGame Game;
 
+        protected override bool UseFreshStoragePerRun => true;
+
         [BackgroundDependencyLoader]
         private void load(GameHost host)
         {
@@ -100,6 +103,8 @@ namespace osu.Game.Tests.Visual.Navigation
 
             public new BeatmapManager BeatmapManager => base.BeatmapManager;
 
+            public new ScoreManager ScoreManager => base.ScoreManager;
+
             public new SettingsPanel Settings => base.Settings;
 
             public new MusicController MusicController => base.MusicController;

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

@@ -1,24 +1,37 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Game.Overlays;
+using osu.Game.Screens;
 using osu.Game.Screens.Menu;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Select;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Navigation
 {
     public class TestScenePerformFromScreen : OsuGameTestScene
     {
+        private bool actionPerformed;
+
+        public override void SetUpSteps()
+        {
+            AddStep("reset status", () => actionPerformed = false);
+
+            base.SetUpSteps();
+        }
+
         [Test]
         public void TestPerformAtMenu()
         {
-            AddAssert("could perform immediately", () =>
-            {
-                bool actionPerformed = false;
-                Game.PerformFromScreen(_ => actionPerformed = true);
-                return actionPerformed;
-            });
+            AddStep("perform immediately", () => Game.PerformFromScreen(_ => actionPerformed = true));
+            AddAssert("did perform", () => actionPerformed);
         }
 
         [Test]
@@ -26,12 +39,9 @@ namespace osu.Game.Tests.Visual.Navigation
         {
             PushAndConfirm(() => new PlaySongSelect());
 
-            AddAssert("could perform immediately", () =>
-            {
-                bool actionPerformed = false;
-                Game.PerformFromScreen(_ => actionPerformed = true, new[] { typeof(PlaySongSelect) });
-                return actionPerformed;
-            });
+            AddStep("perform immediately", () => Game.PerformFromScreen(_ => actionPerformed = true, new[] { typeof(PlaySongSelect) }));
+            AddAssert("did perform", () => actionPerformed);
+            AddAssert("screen didn't change", () => Game.ScreenStack.CurrentScreen is PlaySongSelect);
         }
 
         [Test]
@@ -39,7 +49,6 @@ namespace osu.Game.Tests.Visual.Navigation
         {
             PushAndConfirm(() => new PlaySongSelect());
 
-            bool actionPerformed = false;
             AddStep("try to perform", () => Game.PerformFromScreen(_ => actionPerformed = true));
             AddUntilStep("returned to menu", () => Game.ScreenStack.CurrentScreen is MainMenu);
             AddAssert("did perform", () => actionPerformed);
@@ -51,7 +60,6 @@ namespace osu.Game.Tests.Visual.Navigation
             PushAndConfirm(() => new PlaySongSelect());
             PushAndConfirm(() => new PlayerLoader(() => new Player()));
 
-            bool actionPerformed = false;
             AddStep("try to perform", () => Game.PerformFromScreen(_ => actionPerformed = true, new[] { typeof(PlaySongSelect) }));
             AddUntilStep("returned to song select", () => Game.ScreenStack.CurrentScreen is PlaySongSelect);
             AddAssert("did perform", () => actionPerformed);
@@ -63,10 +71,121 @@ namespace osu.Game.Tests.Visual.Navigation
             PushAndConfirm(() => new PlaySongSelect());
             PushAndConfirm(() => new PlayerLoader(() => new Player()));
 
-            bool actionPerformed = false;
             AddStep("try to perform", () => Game.PerformFromScreen(_ => actionPerformed = true));
             AddUntilStep("returned to song select", () => Game.ScreenStack.CurrentScreen is MainMenu);
             AddAssert("did perform", () => actionPerformed);
         }
+
+        [Test]
+        public void TestOverlaysAlwaysClosed()
+        {
+            ChatOverlay chat = null;
+            AddUntilStep("is at menu", () => Game.ScreenStack.CurrentScreen is MainMenu);
+            AddUntilStep("wait for chat load", () => (chat = Game.ChildrenOfType<ChatOverlay>().SingleOrDefault()) != null);
+
+            AddStep("show chat", () => InputManager.Key(Key.F8));
+
+            AddStep("try to perform", () => Game.PerformFromScreen(_ => actionPerformed = true));
+
+            AddUntilStep("still at menu", () => Game.ScreenStack.CurrentScreen is MainMenu);
+            AddAssert("did perform", () => actionPerformed);
+            AddAssert("chat closed", () => chat.State.Value == Visibility.Hidden);
+        }
+
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestPerformBlockedByDialog(bool confirmed)
+        {
+            DialogBlockingScreen blocker = null;
+
+            PushAndConfirm(() => blocker = new DialogBlockingScreen());
+            AddStep("try to perform", () => Game.PerformFromScreen(_ => actionPerformed = true));
+
+            AddWaitStep("wait a bit", 10);
+
+            AddAssert("screen didn't change", () => Game.ScreenStack.CurrentScreen is DialogBlockingScreen);
+            AddAssert("did not perform", () => !actionPerformed);
+            AddAssert("only one exit attempt", () => blocker.ExitAttempts == 1);
+
+            AddUntilStep("wait for dialog display", () => Game.Dependencies.Get<DialogOverlay>().IsLoaded);
+
+            if (confirmed)
+            {
+                AddStep("accept dialog", () => InputManager.Key(Key.Number1));
+                AddUntilStep("wait for dialog dismissed", () => Game.Dependencies.Get<DialogOverlay>().CurrentDialog == null);
+                AddUntilStep("did perform", () => actionPerformed);
+            }
+            else
+            {
+                AddStep("cancel dialog", () => InputManager.Key(Key.Number2));
+                AddAssert("screen didn't change", () => Game.ScreenStack.CurrentScreen is DialogBlockingScreen);
+                AddAssert("did not perform", () => !actionPerformed);
+            }
+        }
+
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestPerformBlockedByDialogNested(bool confirmSecond)
+        {
+            DialogBlockingScreen blocker = null;
+            DialogBlockingScreen blocker2 = null;
+
+            PushAndConfirm(() => blocker = new DialogBlockingScreen());
+            PushAndConfirm(() => blocker2 = new DialogBlockingScreen());
+
+            AddStep("try to perform", () => Game.PerformFromScreen(_ => actionPerformed = true));
+
+            AddUntilStep("wait for dialog", () => blocker2.ExitAttempts == 1);
+
+            AddWaitStep("wait a bit", 10);
+
+            AddUntilStep("wait for dialog display", () => Game.Dependencies.Get<DialogOverlay>().IsLoaded);
+
+            AddAssert("screen didn't change", () => Game.ScreenStack.CurrentScreen == blocker2);
+            AddAssert("did not perform", () => !actionPerformed);
+            AddAssert("only one exit attempt", () => blocker2.ExitAttempts == 1);
+
+            AddStep("accept dialog", () => InputManager.Key(Key.Number1));
+            AddUntilStep("screen changed", () => Game.ScreenStack.CurrentScreen == blocker);
+
+            AddUntilStep("wait for second dialog", () => blocker.ExitAttempts == 1);
+            AddAssert("did not perform", () => !actionPerformed);
+            AddAssert("only one exit attempt", () => blocker.ExitAttempts == 1);
+
+            if (confirmSecond)
+            {
+                AddStep("accept dialog", () => InputManager.Key(Key.Number1));
+                AddUntilStep("did perform", () => actionPerformed);
+            }
+            else
+            {
+                AddStep("cancel dialog", () => InputManager.Key(Key.Number2));
+                AddAssert("screen didn't change", () => Game.ScreenStack.CurrentScreen == blocker);
+                AddAssert("did not perform", () => !actionPerformed);
+            }
+        }
+
+        public class DialogBlockingScreen : OsuScreen
+        {
+            [Resolved]
+            private DialogOverlay dialogOverlay { get; set; }
+
+            private int dialogDisplayCount;
+
+            public int ExitAttempts { get; private set; }
+
+            public override bool OnExiting(IScreen next)
+            {
+                ExitAttempts++;
+
+                if (dialogDisplayCount++ < 1)
+                {
+                    dialogOverlay.Push(new ConfirmExitDialog(this.Exit, () => { }));
+                    return true;
+                }
+
+                return base.OnExiting(next);
+            }
+        }
     }
 }

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

@@ -80,6 +80,13 @@ namespace osu.Game.Tests.Visual.Navigation
 
         private void returnToMenu()
         {
+            // if we don't pause, there's a chance the track may change at the main menu out of our control (due to reaching the end of the track).
+            AddStep("pause audio", () =>
+            {
+                if (Game.MusicController.IsPlaying)
+                    Game.MusicController.TogglePause();
+            });
+
             AddStep("return to menu", () => Game.ScreenStack.CurrentScreen.Exit());
             AddUntilStep("wait for menu", () => Game.ScreenStack.CurrentScreen is MainMenu);
         }

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

@@ -0,0 +1,171 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mania;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Scoring;
+using osu.Game.Screens;
+using osu.Game.Screens.Menu;
+using osu.Game.Screens.Play;
+using osu.Game.Screens.Ranking;
+
+namespace osu.Game.Tests.Visual.Navigation
+{
+    public class TestScenePresentScore : OsuGameTestScene
+    {
+        private BeatmapSetInfo beatmap;
+
+        [SetUpSteps]
+        public new void SetUpSteps()
+        {
+            AddStep("import beatmap", () =>
+            {
+                var difficulty = new BeatmapDifficulty();
+                var metadata = new BeatmapMetadata
+                {
+                    Artist = "SomeArtist",
+                    AuthorString = "SomeAuthor",
+                    Title = "import"
+                };
+
+                beatmap = Game.BeatmapManager.Import(new BeatmapSetInfo
+                {
+                    Hash = Guid.NewGuid().ToString(),
+                    OnlineBeatmapSetID = 1,
+                    Metadata = metadata,
+                    Beatmaps = new List<BeatmapInfo>
+                    {
+                        new BeatmapInfo
+                        {
+                            OnlineBeatmapID = 1 * 1024,
+                            Metadata = metadata,
+                            BaseDifficulty = difficulty,
+                            Ruleset = new OsuRuleset().RulesetInfo
+                        },
+                        new BeatmapInfo
+                        {
+                            OnlineBeatmapID = 1 * 2048,
+                            Metadata = metadata,
+                            BaseDifficulty = difficulty,
+                            Ruleset = new OsuRuleset().RulesetInfo
+                        },
+                    }
+                }).Result;
+            });
+        }
+
+        [Test]
+        public void TestFromMainMenu([Values] ScorePresentType type)
+        {
+            var firstImport = importScore(1);
+            var secondimport = importScore(3);
+
+            presentAndConfirm(firstImport, type);
+            returnToMenu();
+            presentAndConfirm(secondimport, type);
+            returnToMenu();
+            returnToMenu();
+        }
+
+        [Test]
+        public void TestFromMainMenuDifferentRuleset([Values] ScorePresentType type)
+        {
+            var firstImport = importScore(1);
+            var secondimport = importScore(3, new ManiaRuleset().RulesetInfo);
+
+            presentAndConfirm(firstImport, type);
+            returnToMenu();
+            presentAndConfirm(secondimport, type);
+            returnToMenu();
+            returnToMenu();
+        }
+
+        [Test]
+        public void TestFromSongSelect([Values] ScorePresentType type)
+        {
+            var firstImport = importScore(1);
+            presentAndConfirm(firstImport, type);
+
+            var secondimport = importScore(3);
+            presentAndConfirm(secondimport, type);
+        }
+
+        [Test]
+        public void TestFromSongSelectDifferentRuleset([Values] ScorePresentType type)
+        {
+            var firstImport = importScore(1);
+            presentAndConfirm(firstImport, type);
+
+            var secondimport = importScore(3, new ManiaRuleset().RulesetInfo);
+            presentAndConfirm(secondimport, type);
+        }
+
+        private void returnToMenu()
+        {
+            // if we don't pause, there's a chance the track may change at the main menu out of our control (due to reaching the end of the track).
+            AddStep("pause audio", () =>
+            {
+                if (Game.MusicController.IsPlaying)
+                    Game.MusicController.TogglePause();
+            });
+
+            AddStep("return to menu", () => Game.ScreenStack.CurrentScreen.Exit());
+            AddUntilStep("wait for menu", () => Game.ScreenStack.CurrentScreen is MainMenu);
+        }
+
+        private Func<ScoreInfo> importScore(int i, RulesetInfo ruleset = null)
+        {
+            ScoreInfo imported = null;
+            AddStep($"import score {i}", () =>
+            {
+                imported = Game.ScoreManager.Import(new ScoreInfo
+                {
+                    Hash = Guid.NewGuid().ToString(),
+                    OnlineScoreID = i,
+                    Beatmap = beatmap.Beatmaps.First(),
+                    Ruleset = ruleset ?? new OsuRuleset().RulesetInfo
+                }).Result;
+            });
+
+            AddAssert($"import {i} succeeded", () => imported != null);
+
+            return () => imported;
+        }
+
+        /// <summary>
+        /// Some tests test waiting for a particular screen twice in a row, but expect a new instance each time.
+        /// There's a case where they may succeed incorrectly if we don't compare against the previous instance.
+        /// </summary>
+        private IScreen lastWaitedScreen;
+
+        private void presentAndConfirm(Func<ScoreInfo> getImport, ScorePresentType type)
+        {
+            AddStep("present score", () => Game.PresentScore(getImport(), type));
+
+            switch (type)
+            {
+                case ScorePresentType.Results:
+                    AddUntilStep("wait for results", () => lastWaitedScreen != Game.ScreenStack.CurrentScreen && Game.ScreenStack.CurrentScreen is ResultsScreen);
+                    AddStep("store last waited screen", () => lastWaitedScreen = Game.ScreenStack.CurrentScreen);
+                    AddUntilStep("correct score displayed", () => ((ResultsScreen)Game.ScreenStack.CurrentScreen).Score.ID == getImport().ID);
+                    AddAssert("correct ruleset selected", () => Game.Ruleset.Value.ID == getImport().Ruleset.ID);
+                    break;
+
+                case ScorePresentType.Gameplay:
+                    AddUntilStep("wait for player loader", () => lastWaitedScreen != Game.ScreenStack.CurrentScreen && Game.ScreenStack.CurrentScreen is ReplayPlayerLoader);
+                    AddStep("store last waited screen", () => lastWaitedScreen = Game.ScreenStack.CurrentScreen);
+                    AddUntilStep("correct score displayed", () => ((ReplayPlayerLoader)Game.ScreenStack.CurrentScreen).Score.ID == getImport().ID);
+                    AddAssert("correct ruleset selected", () => Game.Ruleset.Value.ID == getImport().Ruleset.ID);
+                    break;
+            }
+        }
+    }
+}

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

@@ -4,13 +4,16 @@
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
-using osu.Framework.Audio.Track;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
+using osu.Game.Overlays.Toolbar;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Select;
+using osu.Game.Screens.Select.Options;
 using osu.Game.Tests.Beatmaps.IO;
 using osuTK;
 using osuTK.Input;
@@ -45,7 +48,6 @@ namespace osu.Game.Tests.Visual.Navigation
             Player player = null;
 
             WorkingBeatmap beatmap() => Game.Beatmap.Value;
-            Track track() => beatmap().Track;
 
             PushAndConfirm(() => new TestSongSelect());
 
@@ -54,20 +56,34 @@ namespace osu.Game.Tests.Visual.Navigation
             AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
 
             if (withUserPause)
-                AddStep("pause", () => Game.Dependencies.Get<MusicController>().Stop());
+                AddStep("pause", () => Game.Dependencies.Get<MusicController>().Stop(true));
 
-            AddStep("press enter", () => pressAndRelease(Key.Enter));
+            AddStep("press enter", () => InputManager.Key(Key.Enter));
 
             AddUntilStep("wait for player", () => (player = Game.ScreenStack.CurrentScreen as Player) != null);
             AddUntilStep("wait for fail", () => player.HasFailed);
 
-            AddUntilStep("wait for track stop", () => !track().IsRunning);
-            AddAssert("Ensure time before preview point", () => track().CurrentTime < beatmap().Metadata.PreviewTime);
+            AddUntilStep("wait for track stop", () => !Game.MusicController.IsPlaying);
+            AddAssert("Ensure time before preview point", () => Game.MusicController.CurrentTrack.CurrentTime < beatmap().Metadata.PreviewTime);
 
             pushEscape();
 
-            AddUntilStep("wait for track playing", () => track().IsRunning);
-            AddAssert("Ensure time wasn't reset to preview point", () => track().CurrentTime < beatmap().Metadata.PreviewTime);
+            AddUntilStep("wait for track playing", () => Game.MusicController.IsPlaying);
+            AddAssert("Ensure time wasn't reset to preview point", () => Game.MusicController.CurrentTrack.CurrentTime < beatmap().Metadata.PreviewTime);
+        }
+
+        [Test]
+        public void TestMenuMakesMusic()
+        {
+            TestSongSelect songSelect = null;
+
+            PushAndConfirm(() => songSelect = new TestSongSelect());
+
+            AddUntilStep("wait for no track", () => Game.MusicController.CurrentTrack.IsDummyDevice);
+
+            AddStep("return to menu", () => songSelect.Exit());
+
+            AddUntilStep("wait for track", () => !Game.MusicController.CurrentTrack.IsDummyDevice && Game.MusicController.IsPlaying);
         }
 
         [Test]
@@ -106,11 +122,11 @@ namespace osu.Game.Tests.Visual.Navigation
         public void TestOpenOptionsAndExitWithEscape()
         {
             AddUntilStep("Wait for options to load", () => Game.Settings.IsLoaded);
-            AddStep("Enter menu", () => pressAndRelease(Key.Enter));
+            AddStep("Enter menu", () => InputManager.Key(Key.Enter));
             AddStep("Move mouse to options overlay", () => InputManager.MoveMouseTo(optionsButtonPosition));
             AddStep("Click options overlay", () => InputManager.Click(MouseButton.Left));
             AddAssert("Options overlay was opened", () => Game.Settings.State.Value == Visibility.Visible);
-            AddStep("Hide options overlay using escape", () => pressAndRelease(Key.Escape));
+            AddStep("Hide options overlay using escape", () => InputManager.Key(Key.Escape));
             AddAssert("Options overlay was closed", () => Game.Settings.State.Value == Visibility.Hidden);
         }
 
@@ -122,16 +138,58 @@ namespace osu.Game.Tests.Visual.Navigation
             AddUntilStep("Wait for music controller", () => Game.MusicController.IsLoaded);
             AddStep("Seek close to end", () =>
             {
-                Game.MusicController.SeekTo(Game.Beatmap.Value.Track.Length - 1000);
-                Game.Beatmap.Value.Track.Completed += () => trackCompleted = true;
+                Game.MusicController.SeekTo(Game.MusicController.CurrentTrack.Length - 1000);
+                Game.MusicController.CurrentTrack.Completed += () => trackCompleted = true;
             });
 
             AddUntilStep("Track was completed", () => trackCompleted);
-            AddUntilStep("Track was restarted", () => Game.Beatmap.Value.Track.IsRunning);
+            AddUntilStep("Track was restarted", () => Game.MusicController.IsPlaying);
+        }
+
+        [Test]
+        public void TestModSelectInput()
+        {
+            TestSongSelect songSelect = null;
+
+            PushAndConfirm(() => songSelect = new TestSongSelect());
+
+            AddStep("Show mods overlay", () => songSelect.ModSelectOverlay.Show());
+
+            AddStep("Change ruleset to osu!taiko", () =>
+            {
+                InputManager.PressKey(Key.ControlLeft);
+                InputManager.Key(Key.Number2);
+                InputManager.ReleaseKey(Key.ControlLeft);
+            });
+
+            AddAssert("Ruleset changed to osu!taiko", () => Game.Toolbar.ChildrenOfType<ToolbarRulesetSelector>().Single().Current.Value.ID == 1);
+
+            AddAssert("Mods overlay still visible", () => songSelect.ModSelectOverlay.State.Value == Visibility.Visible);
+        }
+
+        [Test]
+        public void TestBeatmapOptionsInput()
+        {
+            TestSongSelect songSelect = null;
+
+            PushAndConfirm(() => songSelect = new TestSongSelect());
+
+            AddStep("Show options overlay", () => songSelect.BeatmapOptionsOverlay.Show());
+
+            AddStep("Change ruleset to osu!taiko", () =>
+            {
+                InputManager.PressKey(Key.ControlLeft);
+                InputManager.Key(Key.Number2);
+                InputManager.ReleaseKey(Key.ControlLeft);
+            });
+
+            AddAssert("Ruleset changed to osu!taiko", () => Game.Toolbar.ChildrenOfType<ToolbarRulesetSelector>().Single().Current.Value.ID == 1);
+
+            AddAssert("Options overlay still visible", () => songSelect.BeatmapOptionsOverlay.State.Value == Visibility.Visible);
         }
 
         private void pushEscape() =>
-            AddStep("Press escape", () => pressAndRelease(Key.Escape));
+            AddStep("Press escape", () => InputManager.Key(Key.Escape));
 
         private void exitViaEscapeAndConfirm()
         {
@@ -146,15 +204,11 @@ namespace osu.Game.Tests.Visual.Navigation
             ConfirmAtMainMenu();
         }
 
-        private void pressAndRelease(Key key)
-        {
-            InputManager.PressKey(key);
-            InputManager.ReleaseKey(key);
-        }
-
         private class TestSongSelect : PlaySongSelect
         {
             public ModSelectOverlay ModSelectOverlay => ModSelect;
+
+            public BeatmapOptionsOverlay BeatmapOptionsOverlay => BeatmapOptions;
         }
     }
 }

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

@@ -7,8 +7,10 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
 using osu.Game.Overlays.BeatmapSet;
 using osu.Game.Screens.Select.Details;
@@ -72,6 +74,32 @@ namespace osu.Game.Tests.Visual.Online
             };
         }
 
+        [Test]
+        public void TestOnlyFailMetrics()
+        {
+            AddStep("set beatmap", () => successRate.Beatmap = new BeatmapInfo
+            {
+                Metrics = new BeatmapMetrics
+                {
+                    Fails = Enumerable.Range(1, 100).ToArray(),
+                }
+            });
+            AddAssert("graph max values correct",
+                () => successRate.ChildrenOfType<BarGraph>().All(graph => graph.MaxValue == 100));
+        }
+
+        [Test]
+        public void TestEmptyMetrics()
+        {
+            AddStep("set beatmap", () => successRate.Beatmap = new BeatmapInfo
+            {
+                Metrics = new BeatmapMetrics()
+            });
+
+            AddAssert("graph max values correct",
+                () => successRate.ChildrenOfType<BarGraph>().All(graph => graph.MaxValue == 0));
+        }
+
         private class GraphExposingSuccessRate : SuccessRate
         {
             public new FailRetryGraph Graph => base.Graph;

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

@@ -103,11 +103,7 @@ namespace osu.Game.Tests.Visual.Online
         public void TestChannelShortcutKeys()
         {
             AddStep("Join channels", () => channels.ForEach(channel => channelManager.JoinChannel(channel)));
-            AddStep("Close channel selector", () =>
-            {
-                InputManager.PressKey(Key.Escape);
-                InputManager.ReleaseKey(Key.Escape);
-            });
+            AddStep("Close channel selector", () => InputManager.Key(Key.Escape));
             AddUntilStep("Wait for close", () => chatOverlay.SelectionOverlayState == Visibility.Hidden);
 
             for (int zeroBasedIndex = 0; zeroBasedIndex < 10; ++zeroBasedIndex)
@@ -216,9 +212,8 @@ namespace osu.Game.Tests.Visual.Online
         {
             var channelKey = Key.Number0 + number;
             InputManager.PressKey(Key.AltLeft);
-            InputManager.PressKey(channelKey);
+            InputManager.Key(channelKey);
             InputManager.ReleaseKey(Key.AltLeft);
-            InputManager.ReleaseKey(channelKey);
         }
 
         private void clickDrawable(Drawable d)
@@ -246,7 +241,12 @@ namespace osu.Game.Tests.Visual.Online
             {
                 ((BindableList<Channel>)ChannelManager.AvailableChannels).AddRange(channels);
 
-                Child = ChatOverlay = new TestChatOverlay { RelativeSizeAxes = Axes.Both, };
+                InternalChildren = new Drawable[]
+                {
+                    ChannelManager,
+                    ChatOverlay = new TestChatOverlay { RelativeSizeAxes = Axes.Both, },
+                };
+
                 ChatOverlay.Show();
             }
         }

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

@@ -1,52 +1,128 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
-using osu.Game.Online.API.Requests;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics;
-using osu.Game.Overlays.Comments;
 using osu.Game.Overlays;
 using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Game.Users;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Overlays.Comments;
 
 namespace osu.Game.Tests.Visual.Online
 {
     [TestFixture]
     public class TestSceneCommentsContainer : OsuTestScene
     {
-        protected override bool UseOnlineAPI => true;
-
         [Cached]
         private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Purple);
 
-        public TestSceneCommentsContainer()
-        {
-            BasicScrollContainer scroll;
-            TestCommentsContainer comments;
+        private DummyAPIAccess dummyAPI => (DummyAPIAccess)API;
 
-            Add(scroll = new BasicScrollContainer
+        private CommentsContainer commentsContainer;
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+            Child = new BasicScrollContainer
             {
                 RelativeSizeAxes = Axes.Both,
-                Child = comments = new TestCommentsContainer()
+                Child = commentsContainer = new CommentsContainer()
             });
 
-            AddStep("Big Black comments", () => comments.ShowComments(CommentableType.Beatmapset, 41823));
-            AddStep("Airman comments", () => comments.ShowComments(CommentableType.Beatmapset, 24313));
-            AddStep("Lazer build comments", () => comments.ShowComments(CommentableType.Build, 4772));
-            AddStep("News comments", () => comments.ShowComments(CommentableType.NewsPost, 715));
-            AddStep("Trigger user change", comments.User.TriggerChange);
-            AddStep("Idle state", () =>
-            {
-                scroll.Clear();
-                scroll.Add(comments = new TestCommentsContainer());
-            });
-        }
-
-        private class TestCommentsContainer : CommentsContainer
+        [Test]
+        public void TestIdleState()
         {
-            public new Bindable<User> User => base.User;
+            AddUntilStep("loading spinner shown",
+                () => commentsContainer.ChildrenOfType<CommentsShowMoreButton>().Single().IsLoading);
         }
+
+        [Test]
+        public void TestSingleCommentsPage()
+        {
+            setUpCommentsResponse(exampleComments);
+            AddStep("show comments", () => commentsContainer.ShowComments(CommentableType.Beatmapset, 123));
+            AddUntilStep("show more button hidden",
+                () => commentsContainer.ChildrenOfType<CommentsShowMoreButton>().Single().Alpha == 0);
+        }
+
+        [Test]
+        public void TestMultipleCommentPages()
+        {
+            var comments = exampleComments;
+            comments.HasMore = true;
+            comments.TopLevelCount = 10;
+
+            setUpCommentsResponse(comments);
+            AddStep("show comments", () => commentsContainer.ShowComments(CommentableType.Beatmapset, 123));
+            AddUntilStep("show more button visible",
+                () => commentsContainer.ChildrenOfType<CommentsShowMoreButton>().Single().Alpha == 1);
+        }
+
+        [Test]
+        public void TestMultipleLoads()
+        {
+            var comments = exampleComments;
+            int topLevelCommentCount = exampleComments.Comments.Count;
+
+            AddStep("hide container", () => commentsContainer.Hide());
+            setUpCommentsResponse(comments);
+            AddRepeatStep("show comments multiple times",
+                () => commentsContainer.ShowComments(CommentableType.Beatmapset, 456), 2);
+            AddStep("show container", () => commentsContainer.Show());
+            AddUntilStep("comment count is correct",
+                () => commentsContainer.ChildrenOfType<DrawableComment>().Count() == topLevelCommentCount);
+        }
+
+        private void setUpCommentsResponse(CommentBundle commentBundle)
+            => AddStep("set up response", () =>
+            {
+                dummyAPI.HandleRequest = request =>
+                {
+                    if (!(request is GetCommentsRequest getCommentsRequest))
+                        return;
+
+                    getCommentsRequest.TriggerSuccess(commentBundle);
+                };
+            });
+
+        private CommentBundle exampleComments => new CommentBundle
+        {
+            Comments = new List<Comment>
+            {
+                new Comment
+                {
+                    Id = 1,
+                    Message = "This is a comment",
+                    LegacyName = "FirstUser",
+                    CreatedAt = DateTimeOffset.Now,
+                    VotesCount = 19,
+                    RepliesCount = 1
+                },
+                new Comment
+                {
+                    Id = 5,
+                    ParentId = 1,
+                    Message = "This is a child comment",
+                    LegacyName = "SecondUser",
+                    CreatedAt = DateTimeOffset.Now,
+                    VotesCount = 4,
+                },
+                new Comment
+                {
+                    Id = 10,
+                    Message = "This is another comment",
+                    LegacyName = "ThirdUser",
+                    CreatedAt = DateTimeOffset.Now,
+                    VotesCount = 0
+                },
+            },
+            IncludedComments = new List<Comment>(),
+        };
     }
 }

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

@@ -0,0 +1,76 @@
+// 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 System.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Database;
+using osu.Game.Online.Spectator;
+using osu.Game.Overlays.Dashboard;
+using osu.Game.Tests.Visual.Gameplay;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestSceneCurrentlyPlayingDisplay : OsuTestScene
+    {
+        [Cached(typeof(SpectatorStreamingClient))]
+        private TestSceneSpectator.TestSpectatorStreamingClient testSpectatorStreamingClient = new TestSceneSpectator.TestSpectatorStreamingClient();
+
+        private CurrentlyPlayingDisplay currentlyPlaying;
+
+        [Cached(typeof(UserLookupCache))]
+        private UserLookupCache lookupCache = new TestUserLookupCache();
+
+        private Container nestedContainer;
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("add streaming client", () =>
+            {
+                nestedContainer?.Remove(testSpectatorStreamingClient);
+                Remove(lookupCache);
+
+                Children = new Drawable[]
+                {
+                    lookupCache,
+                    nestedContainer = new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Children = new Drawable[]
+                        {
+                            testSpectatorStreamingClient,
+                            currentlyPlaying = new CurrentlyPlayingDisplay
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                            }
+                        }
+                    },
+                };
+            });
+
+            AddStep("Reset players", () => testSpectatorStreamingClient.PlayingUsers.Clear());
+        }
+
+        [Test]
+        public void TestBasicDisplay()
+        {
+            AddStep("Add playing user", () => testSpectatorStreamingClient.PlayingUsers.Add(2));
+            AddUntilStep("Panel loaded", () => currentlyPlaying.ChildrenOfType<UserGridPanel>()?.FirstOrDefault()?.User.Id == 2);
+            AddStep("Remove playing user", () => testSpectatorStreamingClient.PlayingUsers.Remove(2));
+            AddUntilStep("Panel no longer present", () => !currentlyPlaying.ChildrenOfType<UserGridPanel>().Any());
+        }
+
+        internal class TestUserLookupCache : UserLookupCache
+        {
+            protected override Task<User> ComputeValueAsync(int lookup, CancellationToken token = default)
+                => Task.FromResult(new User { Username = "peppy", Id = 2 });
+        }
+    }
+}

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

@@ -3,14 +3,13 @@
 
 using System;
 using System.Collections.Generic;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Overlays.Dashboard.Friends;
-using osu.Framework.Graphics;
-using osu.Game.Users;
-using osu.Game.Overlays;
-using osu.Framework.Allocation;
 using NUnit.Framework;
-using osu.Game.Online.API;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Dashboard.Friends;
+using osu.Game.Users;
 
 namespace osu.Game.Tests.Visual.Online
 {
@@ -36,7 +35,7 @@ namespace osu.Game.Tests.Visual.Online
         [Test]
         public void TestOffline()
         {
-            AddStep("Populate", () => display.Users = getUsers());
+            AddStep("Populate with offline test users", () => display.Users = getUsers());
         }
 
         [Test]
@@ -80,14 +79,7 @@ namespace osu.Game.Tests.Visual.Online
 
         private class TestFriendDisplay : FriendDisplay
         {
-            public void Fetch()
-            {
-                base.APIStateChanged(API, APIState.Online);
-            }
-
-            public override void APIStateChanged(IAPIProvider api, APIState state)
-            {
-            }
+            public void Fetch() => PerformFetch();
         }
     }
 }

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

@@ -12,7 +12,7 @@ namespace osu.Game.Tests.Visual.Online
     [TestFixture]
     public class TestSceneFullscreenOverlay : OsuTestScene
     {
-        private FullscreenOverlay overlay;
+        private FullscreenOverlay<OverlayHeader> overlay;
 
         protected override void LoadComplete()
         {
@@ -38,10 +38,10 @@ namespace osu.Game.Tests.Visual.Online
             AddAssert("fire count 3", () => fireCount == 3);
         }
 
-        private class TestFullscreenOverlay : FullscreenOverlay
+        private class TestFullscreenOverlay : FullscreenOverlay<OverlayHeader>
         {
             public TestFullscreenOverlay()
-                : base(OverlayColourScheme.Pink)
+                : base(OverlayColourScheme.Pink, null)
             {
                 Children = new Drawable[]
                 {

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

@@ -0,0 +1,61 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Framework.Allocation;
+using osu.Game.Overlays;
+using System;
+using osu.Game.Overlays.Dashboard.Home.News;
+using osuTK;
+using System.Collections.Generic;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestSceneHomeNewsPanel : OsuTestScene
+    {
+        [Cached]
+        private readonly OverlayColourProvider overlayColour = new OverlayColourProvider(OverlayColourScheme.Purple);
+
+        public TestSceneHomeNewsPanel()
+        {
+            Add(new FillFlowContainer
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                AutoSizeAxes = Axes.Y,
+                Width = 500,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(0, 5),
+                Children = new Drawable[]
+                {
+                    new FeaturedNewsItemPanel(new APINewsPost
+                    {
+                        Title = "This post has an image which starts with \"/\" and has many authors!",
+                        Preview = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
+                        FirstImage = "/help/wiki/shared/news/banners/monthly-beatmapping-contest.png",
+                        PublishedAt = DateTimeOffset.Now,
+                        Slug = "2020-07-16-summer-theme-park-2020-voting-open"
+                    }),
+                    new NewsItemGroupPanel(new List<APINewsPost>
+                    {
+                        new APINewsPost
+                        {
+                            Title = "Title 1",
+                            Slug = "2020-07-16-summer-theme-park-2020-voting-open",
+                            PublishedAt = DateTimeOffset.Now,
+                        },
+                        new APINewsPost
+                        {
+                            Title = "Title of this post is Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
+                            Slug = "2020-07-16-summer-theme-park-2020-voting-open",
+                            PublishedAt = DateTimeOffset.Now,
+                        }
+                    }),
+                    new ShowMoreNewsPanel()
+                }
+            });
+        }
+    }
+}

osu.Game.Tests/Visual/Online/TestSceneNewsCard.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.Graphics.Containers;
+using osu.Framework.Graphics;
+using osu.Game.Overlays.News;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Framework.Allocation;
+using osu.Game.Overlays;
+using osuTK;
+using System;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestSceneNewsCard : OsuTestScene
+    {
+        [Cached]
+        private readonly OverlayColourProvider overlayColour = new OverlayColourProvider(OverlayColourScheme.Purple);
+
+        public TestSceneNewsCard()
+        {
+            Add(new FillFlowContainer<NewsCard>
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Direction = FillDirection.Vertical,
+                Width = 500,
+                AutoSizeAxes = Axes.Y,
+                Spacing = new Vector2(0, 20),
+                Children = new[]
+                {
+                    new NewsCard(new APINewsPost
+                    {
+                        Title = "This post has an image which starts with \"/\" and has many authors! (clickable)",
+                        Preview = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
+                        Author = "someone, someone1, someone2, someone3, someone4",
+                        FirstImage = "/help/wiki/shared/news/banners/monthly-beatmapping-contest.png",
+                        PublishedAt = DateTimeOffset.Now,
+                        Slug = "2020-07-16-summer-theme-park-2020-voting-open"
+                    }),
+                    new NewsCard(new APINewsPost
+                    {
+                        Title = "This post has a full-url image! (HTML entity: &amp;) (non-clickable)",
+                        Preview = "boom (HTML entity: &amp;)",
+                        Author = "user (HTML entity: &amp;)",
+                        FirstImage = "https://assets.ppy.sh/artists/88/header.jpg",
+                        PublishedAt = DateTimeOffset.Now
+                    })
+                }
+            });
+        }
+    }
+}

osu.Game.Tests/Visual/Online/TestSceneNewsHeader.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 NUnit.Framework;
+using osu.Game.Overlays.News;
+using osu.Framework.Graphics;
+using osu.Game.Overlays;
+using osu.Framework.Allocation;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestSceneNewsHeader : OsuTestScene
+    {
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Purple);
+
+        private TestHeader header;
+
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            Child = header = new TestHeader
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre
+            };
+        });
+
+        [Test]
+        public void TestControl()
+        {
+            AddAssert("Front page selected", () => header.Current.Value == "frontpage");
+            AddAssert("1 tab total", () => header.TabCount == 1);
+
+            AddStep("Set article 1", () => header.SetArticle("1"));
+            AddAssert("Article 1 selected", () => header.Current.Value == "1");
+            AddAssert("2 tabs total", () => header.TabCount == 2);
+
+            AddStep("Set article 2", () => header.SetArticle("2"));
+            AddAssert("Article 2 selected", () => header.Current.Value == "2");
+            AddAssert("2 tabs total", () => header.TabCount == 2);
+
+            AddStep("Set front page", () => header.SetFrontPage());
+            AddAssert("Front page selected", () => header.Current.Value == "frontpage");
+            AddAssert("1 tab total", () => header.TabCount == 1);
+        }
+
+        private class TestHeader : NewsHeader
+        {
+            public int TabCount => TabControl.Items.Count;
+        }
+    }
+}

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

@@ -2,65 +2,64 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using osu.Framework.Graphics;
+using NUnit.Framework;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
-using osu.Game.Overlays.News;
 
 namespace osu.Game.Tests.Visual.Online
 {
     public class TestSceneNewsOverlay : OsuTestScene
     {
-        private TestNewsOverlay news;
+        private DummyAPIAccess dummyAPI => (DummyAPIAccess)API;
 
-        protected override void LoadComplete()
+        private NewsOverlay news;
+
+        [SetUp]
+        public void SetUp() => Schedule(() => Child = news = new NewsOverlay());
+
+        [Test]
+        public void TestRequest()
         {
-            base.LoadComplete();
-            Add(news = new TestNewsOverlay());
-            AddStep(@"Show", news.Show);
-            AddStep(@"Hide", news.Hide);
-
-            AddStep(@"Show front page", () => news.ShowFrontPage());
-            AddStep(@"Custom article", () => news.Current.Value = "Test Article 101");
-
-            AddStep(@"Article covers", () => news.LoadAndShowContent(new NewsCoverTest()));
+            setUpNewsResponse(responseExample);
+            AddStep("Show", () => news.Show());
+            AddStep("Show article", () => news.ShowArticle("article"));
         }
 
-        private class TestNewsOverlay : NewsOverlay
-        {
-            public new void LoadAndShowContent(NewsContent content) => base.LoadAndShowContent(content);
-        }
-
-        private class NewsCoverTest : NewsContent
-        {
-            public NewsCoverTest()
+        private void setUpNewsResponse(GetNewsResponse r)
+            => AddStep("set up response", () =>
             {
-                Spacing = new osuTK.Vector2(0, 10);
-
-                var article = new NewsArticleCover.ArticleInfo
+                dummyAPI.HandleRequest = request =>
                 {
-                    Author = "Ephemeral",
-                    CoverUrl = "https://assets.ppy.sh/artists/58/header.jpg",
-                    Time = new DateTime(2019, 12, 4),
-                    Title = "New Featured Artist: Kurokotei"
-                };
+                    if (!(request is GetNewsRequest getNewsRequest))
+                        return;
 
-                Children = new Drawable[]
-                {
-                    new NewsArticleCover(article)
-                    {
-                        Height = 200
-                    },
-                    new NewsArticleCover(article)
-                    {
-                        Height = 120
-                    },
-                    new NewsArticleCover(article)
-                    {
-                        RelativeSizeAxes = Axes.None,
-                        Size = new osuTK.Vector2(400, 200),
-                    }
+                    getNewsRequest.TriggerSuccess(r);
                 };
+            });
+
+        private GetNewsResponse responseExample => new GetNewsResponse
+        {
+            NewsPosts = new[]
+            {
+                new APINewsPost
+                {
+                    Title = "This post has an image which starts with \"/\" and has many authors!",
+                    Preview = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
+                    Author = "someone, someone1, someone2, someone3, someone4",
+                    FirstImage = "/help/wiki/shared/news/banners/monthly-beatmapping-contest.png",
+                    PublishedAt = DateTimeOffset.Now
+                },
+                new APINewsPost
+                {
+                    Title = "This post has a full-url image! (HTML entity: &)",
+                    Preview = "boom (HTML entity: &)",
+                    Author = "user (HTML entity: &)",
+                    FirstImage = "https://assets.ppy.sh/artists/88/header.jpg",
+                    PublishedAt = DateTimeOffset.Now
+                }
             }
-        }
+        };
     }
 }

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

@@ -26,7 +26,7 @@ namespace osu.Game.Tests.Visual.Online
         [Test]
         public void TestGenericActivity()
         {
-            AddStep("Set activity", () => API.Activity.Value = new UserActivity.InLobby());
+            AddStep("Set activity", () => API.Activity.Value = new UserActivity.InLobby(null));
 
             AddStep("Run command", () => Add(new NowPlayingCommand()));
 
@@ -57,9 +57,9 @@ namespace osu.Game.Tests.Visual.Online
         [TestCase(false)]
         public void TestLinkPresence(bool hasOnlineId)
         {
-            AddStep("Set activity", () => API.Activity.Value = new UserActivity.InLobby());
+            AddStep("Set activity", () => API.Activity.Value = new UserActivity.InLobby(null));
 
-            AddStep("Set beatmap", () => Beatmap.Value = new DummyWorkingBeatmap(null, null)
+            AddStep("Set beatmap", () => Beatmap.Value = new DummyWorkingBeatmap(Audio, null)
             {
                 BeatmapInfo = { OnlineBeatmapID = hasOnlineId ? 1234 : (int?)null }
             });

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

@@ -32,7 +32,7 @@ namespace osu.Game.Tests.Visual.Online
         [Test]
         public void TestOnlineStateVisibility()
         {
-            AddStep("set status to online", () => ((DummyAPIAccess)API).State = APIState.Online);
+            AddStep("set status to online", () => ((DummyAPIAccess)API).SetState(APIState.Online));
 
             AddUntilStep("children are visible", () => onlineView.ViewTarget.IsPresent);
             AddUntilStep("loading animation is not visible", () => !onlineView.LoadingSpinner.IsPresent);
@@ -41,7 +41,7 @@ namespace osu.Game.Tests.Visual.Online
         [Test]
         public void TestOfflineStateVisibility()
         {
-            AddStep("set status to offline", () => ((DummyAPIAccess)API).State = APIState.Offline);
+            AddStep("set status to offline", () => ((DummyAPIAccess)API).SetState(APIState.Offline));
 
             AddUntilStep("children are not visible", () => !onlineView.ViewTarget.IsPresent);
             AddUntilStep("loading animation is not visible", () => !onlineView.LoadingSpinner.IsPresent);
@@ -50,7 +50,7 @@ namespace osu.Game.Tests.Visual.Online
         [Test]
         public void TestConnectingStateVisibility()
         {
-            AddStep("set status to connecting", () => ((DummyAPIAccess)API).State = APIState.Connecting);
+            AddStep("set status to connecting", () => ((DummyAPIAccess)API).SetState(APIState.Connecting));
 
             AddUntilStep("children are not visible", () => !onlineView.ViewTarget.IsPresent);
             AddUntilStep("loading animation is visible", () => onlineView.LoadingSpinner.IsPresent);
@@ -59,7 +59,7 @@ namespace osu.Game.Tests.Visual.Online
         [Test]
         public void TestFailingStateVisibility()
         {
-            AddStep("set status to failing", () => ((DummyAPIAccess)API).State = APIState.Failing);
+            AddStep("set status to failing", () => ((DummyAPIAccess)API).SetState(APIState.Failing));
 
             AddUntilStep("children are not visible", () => !onlineView.ViewTarget.IsPresent);
             AddUntilStep("loading animation is visible", () => onlineView.LoadingSpinner.IsPresent);

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

@@ -1,40 +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.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Game.Overlays;
-using osu.Game.Overlays.Profile.Sections;
-
-namespace osu.Game.Tests.Visual.Online
-{
-    public class TestSceneProfileCounterPill : OsuTestScene
-    {
-        [Cached]
-        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Red);
-
-        private readonly CounterPill pill;
-        private readonly BindableInt value = new BindableInt();
-
-        public TestSceneProfileCounterPill()
-        {
-            Child = pill = new CounterPill
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                Current = { BindTarget = value }
-            };
-        }
-
-        [Test]
-        public void TestVisibility()
-        {
-            AddStep("Set value to 0", () => value.Value = 0);
-            AddAssert("Check hidden", () => !pill.IsPresent);
-            AddStep("Set value to 10", () => value.Value = 10);
-            AddAssert("Check visible", () => pill.IsPresent);
-        }
-    }
-}

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

@@ -30,12 +30,6 @@ namespace osu.Game.Tests.Visual.Online
             Add(selector = new SpotlightSelector());
         }
 
-        [Test]
-        public void TestVisibility()
-        {
-            AddStep("Toggle Visibility", selector.ToggleVisibility);
-        }
-
         [Test]
         public void TestLocalSpotlights()
         {

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

@@ -15,6 +15,7 @@ using osu.Game.Rulesets.Catch;
 using osu.Framework.Allocation;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
+using osu.Game.Overlays.Rankings;
 
 namespace osu.Game.Tests.Visual.Online
 {
@@ -105,7 +106,7 @@ namespace osu.Game.Tests.Visual.Online
         {
             onLoadStarted();
 
-            request = new GetSpotlightRankingsRequest(ruleset, spotlight);
+            request = new GetSpotlightRankingsRequest(ruleset, spotlight, RankingsSortCriteria.All);
             ((GetSpotlightRankingsRequest)request).Success += rankings => Schedule(() =>
             {
                 var table = new ScoresTable(1, rankings.Users);

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

@@ -4,19 +4,22 @@
 using osu.Framework.Graphics;
 using osu.Game.Graphics.UserInterface;
 using osu.Framework.Allocation;
-using osu.Game.Graphics;
+using osu.Game.Overlays;
 
 namespace osu.Game.Tests.Visual.Online
 {
     public class TestSceneShowMoreButton : OsuTestScene
     {
+        [Cached]
+        private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Green);
+
         public TestSceneShowMoreButton()
         {
-            TestButton button = null;
+            ShowMoreButton button = null;
 
             int fireCount = 0;
 
-            Add(button = new TestButton
+            Add(button = new ShowMoreButton
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
@@ -46,16 +49,5 @@ namespace osu.Game.Tests.Visual.Online
             AddAssert("action fired twice", () => fireCount == 2);
             AddAssert("is in loading state", () => button.IsLoading);
         }
-
-        private class TestButton : ShowMoreButton
-        {
-            [BackgroundDependencyLoader]
-            private void load(OsuColour colors)
-            {
-                IdleColour = colors.YellowDark;
-                HoverColour = colors.Yellow;
-                ChevronIconColour = colors.Red;
-            }
-        }
     }
 }