Merge pull request #4578 from peppy/update-framework

Update framework

.github/ISSUE_TEMPLATE.md

@@ -1,11 +0,0 @@
-osu!lazer is currently still under heavy development!
-
-Please ensure that you are making an issue for one of the following:
-
-- A bug with currently implemented features (not features that don't exist)
-- A feature you are considering adding, so we can collaborate on feedback and design.
-- Discussions about technical design decisions
-
-If your issue qualifies, replace this text with a detailed description of your issue with as much relevant information as you can provide.
-
-Screenshots and log files are highly welcomed.

.github/ISSUE_TEMPLATE/bug-issues.md

@@ -1,14 +1,11 @@
 ---
 name: Bug Report
-about: For issues regarding encountered game bugs
+about: Issues regarding encountered bugs.
 ---
-
-<!-- After you fill in all information, delete all comments in the issue -->
-
-**Describe your problem:** <!-- Provide any information you believe could be useful -->
+**Describe the bug:** 
 
 **Screenshots or videos showing encountered issue:** 
 
-**osu!lazer version:** <!-- Provide the version of your osu!lazer, you can find it at the bottom of the screen  -->
+**osu!lazer version:** 
 
-**Logs:** <!-- Attach your osu!lazer logs, you can find them under %appdata%\osu\logs in Windows, or under ~/.local/share/osu/ in Linux and macOS -->
+**Logs:** 

.github/ISSUE_TEMPLATE/crash-issues.md

@@ -1,16 +1,13 @@
 ---
 name: Crash Report
-about: For issues regarding game crashes or permanent freezes
+about: Issues regarding crashes or permanent freezes.
 ---
-
-<!-- After you fill in all information, delete all comments in the issue -->
-
-**Describe your problem:** <!-- Provide any information you believe could be useful -->
+**Describe the crash:** 
 
 **Screenshots or videos showing encountered issue:** 
 
-**osu!lazer version:** <!-- Provide the version of your osu!lazer, you can find it at the bottom of the screen  -->
+**osu!lazer version:** 
 
-**Logs:** <!-- Attach your osu!lazer logs, you can find them under %appdata%\osu\logs in Windows, or under ~/.local/share/osu/ in Linux and macOS -->
+**Logs:** 
 
-**Computer Specifications:** <!-- Attach your computer specifications, you can find them by using System Information in Windows, System Monitor in Linux, or About This Mac in macOS -->
+**Computer Specifications:** 

.github/ISSUE_TEMPLATE/feature-request-issues.md

@@ -1,10 +1,7 @@
 ---
 name: Feature Request
-about: Let us know what you would like to see in the game!
+about: Features you would like to see in the game!
 ---
+**Describe the new feature:** 
 
-<!-- After you fill in all information, delete all comments in the issue -->
-
-**Describe the feature:** <!-- Describe the feature you would like to see in the game -->
-
-**Proposal designs of the feature:** <!-- Attach screenshots of how the feature should look like according to you -->
+**Proposal designs of the feature:** 

.github/ISSUE_TEMPLATE/missing-for-live-issues.md

@@ -1,10 +1,7 @@
 ---
 name: Missing for Live
-about: Let us know the features you need which are available in osu-stable but not lazer
+about: Features which are available in osu!stable but not yet in osu!lazer.
 ---
+**Describe the missing feature:** 
 
-<!-- After you fill in all information, delete all comments in the issue -->
-
-**Describe the feature:** <!-- Describe the missing game feature -->
-
-**Designs:** <!-- Attach screenshots of how the feature is supposed to look like. For illustrative purpose only; final designs are usually re-imagined from scratch. -->
+**Proposal designs of the feature:** 

osu.Desktop/OsuGameDesktop.cs

@@ -14,6 +14,7 @@ using osuTK.Input;
 using Microsoft.Win32;
 using osu.Desktop.Updater;
 using osu.Framework;
+using osu.Framework.Logging;
 using osu.Framework.Platform.Windows;
 using osu.Framework.Screens;
 using osu.Game.Screens.Menu;
@@ -35,12 +36,15 @@ namespace osu.Desktop
         {
             try
             {
-                return new StableStorage();
+                if (Host is DesktopGameHost desktopHost)
+                    return new StableStorage(desktopHost);
             }
-            catch
+            catch (Exception e)
             {
-                return null;
+                Logger.Error(e, "Error while searching for stable install");
             }
+
+            return null;
         }
 
         protected override void LoadComplete()
@@ -139,8 +143,8 @@ namespace osu.Desktop
                 return null;
             }
 
-            public StableStorage()
-                : base(string.Empty, null)
+            public StableStorage(DesktopGameHost host)
+                : base(string.Empty, host)
             {
             }
         }

osu.Desktop/Overlays/VersionManager.cs

@@ -110,7 +110,7 @@ namespace osu.Desktop.Overlays
             public UpdateCompleteNotification(string version, Action<string> openUrl = null)
             {
                 Text = $"You are now running osu!lazer {version}.\nClick to see what's new!";
-                Icon = FontAwesome.fa_check_square;
+                Icon = FontAwesome.Solid.CheckSquare;
                 Activated = delegate
                 {
                     openUrl?.Invoke($"https://osu.ppy.sh/home/changelog/lazer/{version}");

osu.Desktop/Updater/SimpleUpdateManager.cs

@@ -7,10 +7,10 @@ using Newtonsoft.Json;
 using osu.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.IO.Network;
 using osu.Framework.Platform;
 using osu.Game;
-using osu.Game.Graphics;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 
@@ -54,7 +54,7 @@ namespace osu.Desktop.Updater
                     {
                         Text = $"A newer release of osu! has been found ({version} → {latest.TagName}).\n\n"
                                + "Click here to download the new version, which can be installed over the top of your existing installation",
-                        Icon = FontAwesome.fa_upload,
+                        Icon = FontAwesome.Solid.Upload,
                         Activated = () =>
                         {
                             host.OpenUrlExternally(getBestUrl(latest));

osu.Desktop/Updater/SquirrelUpdateManager.cs

@@ -9,6 +9,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Logging;
 using osu.Game;
 using osu.Game.Graphics;
@@ -158,7 +159,7 @@ namespace osu.Desktop.Updater
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
-                        Icon = FontAwesome.fa_upload,
+                        Icon = FontAwesome.Solid.Upload,
                         Colour = Color4.White,
                         Size = new Vector2(20),
                     }

osu.Desktop/osu.Desktop.csproj

@@ -27,8 +27,8 @@
   <ItemGroup Label="Package References">
     <PackageReference Include="System.IO.Packaging" Version="4.5.0" />
     <PackageReference Include="ppy.squirrel.windows" Version="1.9.0.3" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.1" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.2.1" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.3" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.2.3" />
   </ItemGroup>
   <ItemGroup Label="Resources">
     <EmbeddedResource Include="lazer.ico" />

osu.Game.Rulesets.Catch.Tests/osu.Game.Rulesets.Catch.Tests.csproj

@@ -2,9 +2,9 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.0.1" />
     <PackageReference Include="NUnit" Version="3.11.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.12.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.13.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmap.cs

@@ -3,8 +3,8 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Beatmaps;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Catch.Objects;
 
 namespace osu.Game.Rulesets.Catch.Beatmaps
@@ -23,19 +23,19 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                 {
                     Name = @"Fruit Count",
                     Content = fruits.ToString(),
-                    Icon = FontAwesome.fa_circle_o
+                    Icon = FontAwesome.Regular.Circle
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Juice Stream Count",
                     Content = juiceStreams.ToString(),
-                    Icon = FontAwesome.fa_circle
+                    Icon = FontAwesome.Regular.Circle
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Banana Shower Count",
                     Content = bananaShowers.ToString(),
-                    Icon = FontAwesome.fa_circle
+                    Icon = FontAwesome.Regular.Circle
                 }
             };
         }

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -9,6 +9,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
 using System.Collections.Generic;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Replays;
@@ -17,6 +18,7 @@ using osu.Game.Beatmaps.Legacy;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Difficulty;
 using osu.Game.Rulesets.Difficulty;
+using osu.Game.Scoring;
 
 namespace osu.Game.Rulesets.Catch
 {
@@ -114,10 +116,12 @@ namespace osu.Game.Rulesets.Catch
 
         public override string ShortName => "fruits";
 
-        public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_fruits_o };
+        public override Drawable CreateIcon() => new SpriteIcon { Icon = OsuIcon.RulesetCatch };
 
         public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new CatchDifficultyCalculator(this, beatmap);
 
+        public override PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, ScoreInfo score) => new CatchPerformanceCalculator(this, beatmap, score);
+
         public override int? LegacyID => 2;
 
         public override IConvertibleReplayFrame CreateConvertibleReplayFrame() => new CatchReplayFrame();

osu.Game.Rulesets.Catch/Difficulty/CatchPerformanceCalculator.cs

@@ -0,0 +1,104 @@
+// 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 osu.Game.Beatmaps;
+using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Scoring.Legacy;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Difficulty
+{
+    public class CatchPerformanceCalculator : PerformanceCalculator
+    {
+        protected new CatchDifficultyAttributes Attributes => (CatchDifficultyAttributes)base.Attributes;
+
+        private Mod[] mods;
+
+        private int fruitsHit;
+        private int ticksHit;
+        private int tinyTicksHit;
+        private int tinyTicksMissed;
+        private int misses;
+
+        public CatchPerformanceCalculator(Ruleset ruleset, WorkingBeatmap beatmap, ScoreInfo score)
+            : base(ruleset, beatmap, score)
+        {
+        }
+
+        public override double Calculate(Dictionary<string, double> categoryDifficulty = null)
+        {
+            mods = Score.Mods;
+
+            var legacyScore = Score as LegacyScoreInfo;
+
+            fruitsHit = legacyScore?.Count300 ?? Score.Statistics[HitResult.Perfect];
+            ticksHit = legacyScore?.Count100 ?? 0;
+            tinyTicksHit = legacyScore?.Count50 ?? 0;
+            tinyTicksMissed = legacyScore?.CountKatu ?? 0;
+            misses = Score.Statistics[HitResult.Miss];
+
+            // Don't count scores made with supposedly unranked mods
+            if (mods.Any(m => !m.Ranked))
+                return 0;
+
+            // We are heavily relying on aim in catch the beat
+            double value = Math.Pow(5.0f * Math.Max(1.0f, Attributes.StarRating / 0.0049f) - 4.0f, 2.0f) / 100000.0f;
+
+            // Longer maps are worth more. "Longer" means how many hits there are which can contribute to combo
+            int numTotalHits = totalComboHits();
+
+            // Longer maps are worth more
+            float lengthBonus =
+                0.95f + 0.4f * Math.Min(1.0f, numTotalHits / 3000.0f) +
+                (numTotalHits > 3000 ? (float)Math.Log10(numTotalHits / 3000.0f) * 0.5f : 0.0f);
+
+            // Longer maps are worth more
+            value *= lengthBonus;
+
+            // Penalize misses exponentially. This mainly fixes tag4 maps and the likes until a per-hitobject solution is available
+            value *= Math.Pow(0.97f, misses);
+
+            // Combo scaling
+            float beatmapMaxCombo = Attributes.MaxCombo;
+            if (beatmapMaxCombo > 0)
+                value *= Math.Min(Math.Pow(Attributes.MaxCombo, 0.8f) / Math.Pow(beatmapMaxCombo, 0.8f), 1.0f);
+
+            float approachRate = (float)Attributes.ApproachRate;
+            float approachRateFactor = 1.0f;
+            if (approachRate > 9.0f)
+                approachRateFactor += 0.1f * (approachRate - 9.0f); // 10% for each AR above 9
+            else if (approachRate < 8.0f)
+                approachRateFactor += 0.025f * (8.0f - approachRate); // 2.5% for each AR below 8
+
+            value *= approachRateFactor;
+
+            if (mods.Any(m => m is ModHidden))
+                // Hiddens gives nothing on max approach rate, and more the lower it is
+                value *= 1.05f + 0.075f * (10.0f - Math.Min(10.0f, approachRate)); // 7.5% for each AR below 10
+
+            if (mods.Any(m => m is ModFlashlight))
+                // Apply length bonus again if flashlight is on simply because it becomes a lot harder on longer maps.
+                value *= 1.35f * lengthBonus;
+
+            // Scale the aim value with accuracy _slightly_
+            value *= Math.Pow(accuracy(), 5.5f);
+
+            // Custom multipliers for NoFail. SpunOut is not applicable.
+            if (mods.Any(m => m is ModNoFail))
+                value *= 0.90f;
+
+            return value;
+        }
+
+        private float accuracy() => totalHits() == 0 ? 0 : MathHelper.Clamp((float)totalSuccessfulHits() / totalHits(), 0f, 1f);
+        private int totalHits() => tinyTicksHit + ticksHit + fruitsHit + misses + tinyTicksMissed;
+        private int totalSuccessfulHits() => tinyTicksHit + ticksHit + fruitsHit;
+        private int totalComboHits() => misses + ticksHit + fruitsHit;
+    }
+}

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableBananaShower.cs

@@ -13,17 +13,17 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
     {
         private readonly Container bananaContainer;
 
-        public DrawableBananaShower(BananaShower s, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> getVisualRepresentation = null)
+        public DrawableBananaShower(BananaShower s, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> createDrawableRepresentation = null)
             : base(s)
         {
             RelativeSizeAxes = Axes.X;
             Origin = Anchor.BottomLeft;
             X = 0;
 
-            InternalChild = bananaContainer = new Container { RelativeSizeAxes = Axes.Both };
+            AddInternal(bananaContainer = new Container { RelativeSizeAxes = Axes.Both });
 
             foreach (var b in s.NestedHitObjects.Cast<Banana>())
-                AddNested(getVisualRepresentation?.Invoke(b));
+                AddNested(createDrawableRepresentation?.Invoke(b));
         }
 
         protected override void AddNested(DrawableHitObject h)

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableDroplet.cs

@@ -26,10 +26,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
         [BackgroundDependencyLoader]
         private void load()
         {
-            InternalChild = pulp = new Pulp
-            {
-                Size = Size
-            };
+            AddInternal(pulp = new Pulp { Size = Size });
         }
 
         public override Color4 AccentColour

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableFruit.cs

@@ -42,7 +42,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
             // todo: this should come from the skin.
             AccentColour = colourForRepresentation(HitObject.VisualRepresentation);
 
-            InternalChildren = new[]
+            AddRangeInternal(new[]
             {
                 createPulp(HitObject.VisualRepresentation),
                 border = new Circle
@@ -70,7 +70,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                         }
                     }
                 },
-            };
+            });
 
             if (HitObject.HyperDash)
             {

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableJuiceStream.cs

@@ -13,17 +13,17 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
     {
         private readonly Container dropletContainer;
 
-        public DrawableJuiceStream(JuiceStream s, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> getVisualRepresentation = null)
+        public DrawableJuiceStream(JuiceStream s, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> createDrawableRepresentation = null)
             : base(s)
         {
             RelativeSizeAxes = Axes.Both;
             Origin = Anchor.BottomLeft;
             X = 0;
 
-            InternalChild = dropletContainer = new Container { RelativeSizeAxes = Axes.Both, };
+            AddInternal(dropletContainer = new Container { RelativeSizeAxes = Axes.Both, });
 
             foreach (var o in s.NestedHitObjects.Cast<CatchHitObject>())
-                AddNested(getVisualRepresentation?.Invoke(o));
+                AddNested(createDrawableRepresentation?.Invoke(o));
         }
 
         protected override void AddNested(DrawableHitObject h)

osu.Game.Rulesets.Catch/Replays/CatchFramedReplayInputHandler.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Diagnostics;
 using osu.Framework.Input.StateChanges;
 using osu.Framework.MathUtils;
 using osu.Game.Replays;
@@ -22,10 +23,14 @@ namespace osu.Game.Rulesets.Catch.Replays
         {
             get
             {
-                if (!HasFrames)
+                var frame = CurrentFrame;
+
+                if (frame == null)
                     return null;
 
-                return Interpolation.ValueAt(CurrentTime, CurrentFrame.Position, NextFrame.Position, CurrentFrame.Time, NextFrame.Time);
+                Debug.Assert(CurrentTime != null);
+
+                return NextFrame != null ? Interpolation.ValueAt(CurrentTime.Value, frame.Position, NextFrame.Position, frame.Time, NextFrame.Time) : frame.Position;
             }
         }
 

osu.Game.Rulesets.Catch/UI/CatchPlayfield.cs

@@ -10,7 +10,6 @@ using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
-using osuTK;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
@@ -20,33 +19,24 @@ namespace osu.Game.Rulesets.Catch.UI
 
         internal readonly CatcherArea CatcherArea;
 
-        public CatchPlayfield(BeatmapDifficulty difficulty, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> getVisualRepresentation)
+        public CatchPlayfield(BeatmapDifficulty difficulty, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> createDrawableRepresentation)
         {
             Container explodingFruitContainer;
 
-            Anchor = Anchor.TopCentre;
-            Origin = Anchor.TopCentre;
-
-            Size = new Vector2(0.86f); // matches stable's vertical offset for catcher plate
-
-            InternalChild = new PlayfieldAdjustmentContainer
+            InternalChildren = new Drawable[]
             {
-                RelativeSizeAxes = Axes.Both,
-                Children = new Drawable[]
+                explodingFruitContainer = new Container
                 {
-                    explodingFruitContainer = new Container
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                    },
-                    CatcherArea = new CatcherArea(difficulty)
-                    {
-                        GetVisualRepresentation = getVisualRepresentation,
-                        ExplodingFruitTarget = explodingFruitContainer,
-                        Anchor = Anchor.BottomLeft,
-                        Origin = Anchor.TopLeft,
-                    },
-                    HitObjectContainer
-                }
+                    RelativeSizeAxes = Axes.Both,
+                },
+                CatcherArea = new CatcherArea(difficulty)
+                {
+                    CreateDrawableRepresentation = createDrawableRepresentation,
+                    ExplodingFruitTarget = explodingFruitContainer,
+                    Anchor = Anchor.BottomLeft,
+                    Origin = Anchor.TopLeft,
+                },
+                HitObjectContainer
             };
         }
 

osu.Game.Rulesets.Catch/UI/CatchPlayfieldAdjustmentContainer.cs

@@ -3,17 +3,23 @@
 
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.UI;
 using osuTK;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
-    public class PlayfieldAdjustmentContainer : Container
+    public class CatchPlayfieldAdjustmentContainer : PlayfieldAdjustmentContainer
     {
         protected override Container<Drawable> Content => content;
         private readonly Container content;
 
-        public PlayfieldAdjustmentContainer()
+        public CatchPlayfieldAdjustmentContainer()
         {
+            Anchor = Anchor.TopCentre;
+            Origin = Anchor.TopCentre;
+
+            Size = new Vector2(0.86f); // matches stable's vertical offset for catcher plate
+
             InternalChild = new Container
             {
                 Anchor = Anchor.Centre,

osu.Game.Rulesets.Catch/UI/CatcherArea.cs

@@ -29,7 +29,7 @@ namespace osu.Game.Rulesets.Catch.UI
 
         protected internal readonly Catcher MovableCatcher;
 
-        public Func<CatchHitObject, DrawableHitObject<CatchHitObject>> GetVisualRepresentation;
+        public Func<CatchHitObject, DrawableHitObject<CatchHitObject>> CreateDrawableRepresentation;
 
         public Container ExplodingFruitTarget
         {
@@ -65,7 +65,7 @@ namespace osu.Game.Rulesets.Catch.UI
 
             if (result.IsHit && fruit.CanBePlated)
             {
-                var caughtFruit = (DrawableCatchHitObject)GetVisualRepresentation?.Invoke(fruit.HitObject);
+                var caughtFruit = (DrawableCatchHitObject)CreateDrawableRepresentation?.Invoke(fruit.HitObject);
 
                 if (caughtFruit == null) return;
 

osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.cs

@@ -34,11 +34,13 @@ namespace osu.Game.Rulesets.Catch.UI
 
         protected override ReplayInputHandler CreateReplayInputHandler(Replay replay) => new CatchFramedReplayInputHandler(replay);
 
-        protected override Playfield CreatePlayfield() => new CatchPlayfield(Beatmap.BeatmapInfo.BaseDifficulty, GetVisualRepresentation);
+        protected override Playfield CreatePlayfield() => new CatchPlayfield(Beatmap.BeatmapInfo.BaseDifficulty, CreateDrawableRepresentation);
+
+        public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new CatchPlayfieldAdjustmentContainer();
 
         protected override PassThroughInputManager CreateInputManager() => new CatchInputManager(Ruleset.RulesetInfo);
 
-        public override DrawableHitObject<CatchHitObject> GetVisualRepresentation(CatchHitObject h)
+        public override DrawableHitObject<CatchHitObject> CreateDrawableRepresentation(CatchHitObject h)
         {
             switch (h)
             {
@@ -47,9 +49,9 @@ namespace osu.Game.Rulesets.Catch.UI
                 case Fruit fruit:
                     return new DrawableFruit(fruit);
                 case JuiceStream stream:
-                    return new DrawableJuiceStream(stream, GetVisualRepresentation);
+                    return new DrawableJuiceStream(stream, CreateDrawableRepresentation);
                 case BananaShower shower:
-                    return new DrawableBananaShower(shower, GetVisualRepresentation);
+                    return new DrawableBananaShower(shower, CreateDrawableRepresentation);
                 case TinyDroplet tiny:
                     return new DrawableTinyDroplet(tiny);
                 case Droplet droplet:

osu.Game.Rulesets.Mania.Tests/osu.Game.Rulesets.Mania.Tests.csproj

@@ -2,9 +2,9 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.0.1" />
     <PackageReference Include="NUnit" Version="3.11.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.12.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.13.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmap.cs

@@ -3,8 +3,8 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Beatmaps;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.UI;
 
@@ -42,13 +42,13 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
                 {
                     Name = @"Note Count",
                     Content = notes.ToString(),
-                    Icon = FontAwesome.fa_circle_o
+                    Icon = FontAwesome.Regular.Circle
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Hold Note Count",
                     Content = holdnotes.ToString(),
-                    Icon = FontAwesome.fa_circle
+                    Icon = FontAwesome.Regular.Circle
                 },
             };
         }

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -10,6 +10,7 @@ using osu.Game.Rulesets.UI;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Objects;
@@ -160,7 +161,7 @@ namespace osu.Game.Rulesets.Mania
 
         public override string ShortName => "mania";
 
-        public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_mania_o };
+        public override Drawable CreateIcon() => new SpriteIcon { Icon = OsuIcon.RulesetMania };
 
         public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new ManiaDifficultyCalculator(this, beatmap);
 

osu.Game.Rulesets.Mania/Mods/ManiaModFadeIn.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;
@@ -12,7 +13,7 @@ namespace osu.Game.Rulesets.Mania.Mods
     {
         public override string Name => "Fade In";
         public override string Acronym => "FI";
-        public override FontAwesome Icon => FontAwesome.fa_osu_mod_hidden;
+        public override IconUsage Icon => OsuIcon.ModHidden;
         public override ModType Type => ModType.DifficultyIncrease;
         public override string Description => @"Keys appear out of nowhere!";
         public override double ScoreMultiplier => 1;

osu.Game.Rulesets.Mania/Mods/ManiaModRandom.cs

@@ -3,6 +3,7 @@
 
 using System.Linq;
 using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
@@ -17,7 +18,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override string Name => "Random";
         public override string Acronym => "RD";
         public override ModType Type => ModType.Conversion;
-        public override FontAwesome Icon => FontAwesome.fa_osu_dice;
+        public override IconUsage Icon => OsuIcon.Dice;
         public override string Description => @"Shuffle around the keys!";
         public override double ScoreMultiplier => 1;
 

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNote.cs

@@ -43,7 +43,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
             RelativeSizeAxes = Axes.X;
 
-            InternalChildren = new Drawable[]
+            AddRangeInternal(new Drawable[]
             {
                 bodyPiece = new BodyPiece
                 {
@@ -67,7 +67,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                     Anchor = Anchor.TopCentre,
                     Origin = Anchor.TopCentre
                 }
-            };
+            });
 
             foreach (var tick in tickContainer)
                 AddNested(tick);

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNoteTick.cs

@@ -33,7 +33,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             RelativeSizeAxes = Axes.X;
             Size = new Vector2(1);
 
-            InternalChildren = new[]
+            AddRangeInternal(new[]
             {
                 glowContainer = new CircularContainer
                 {
@@ -51,7 +51,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                         }
                     }
                 }
-            };
+            });
         }
 
         public override Color4 AccentColour

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableNote.cs

@@ -29,7 +29,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             CornerRadius = 5;
             Masking = true;
 
-            InternalChild = headPiece = new NotePiece();
+            AddInternal(headPiece = new NotePiece());
         }
 
         protected override void OnDirectionChanged(ValueChangedEvent<ScrollingDirection> e)

osu.Game.Rulesets.Mania/Replays/ManiaFramedReplayInputHandler.cs

@@ -18,6 +18,6 @@ namespace osu.Game.Rulesets.Mania.Replays
 
         protected override bool IsImportant(ManiaReplayFrame frame) => frame.Actions.Any();
 
-        public override List<IInput> GetPendingInputs() => new List<IInput> { new ReplayState<ManiaAction> { PressedActions = CurrentFrame.Actions } };
+        public override List<IInput> GetPendingInputs() => new List<IInput> { new ReplayState<ManiaAction> { PressedActions = CurrentFrame?.Actions ?? new List<ManiaAction>() } };
     }
 }

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

@@ -6,7 +6,6 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
-using osu.Framework.Graphics;
 using osu.Framework.Input;
 using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
@@ -89,11 +88,9 @@ namespace osu.Game.Rulesets.Mania.UI
         /// <returns>The column which intersects with <paramref name="screenSpacePosition"/>.</returns>
         public Column GetColumnByPosition(Vector2 screenSpacePosition) => Playfield.GetColumnByPosition(screenSpacePosition);
 
-        protected override Playfield CreatePlayfield() => new ManiaPlayfield(Beatmap.Stages)
-        {
-            Anchor = Anchor.Centre,
-            Origin = Anchor.Centre,
-        };
+        public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new ManiaPlayfieldAdjustmentContainer();
+
+        protected override Playfield CreatePlayfield() => new ManiaPlayfield(Beatmap.Stages);
 
         public override ScoreProcessor CreateScoreProcessor() => new ManiaScoreProcessor(this);
 
@@ -101,7 +98,7 @@ namespace osu.Game.Rulesets.Mania.UI
 
         protected override PassThroughInputManager CreateInputManager() => new ManiaInputManager(Ruleset.RulesetInfo, Variant);
 
-        public override DrawableHitObject<ManiaHitObject> GetVisualRepresentation(ManiaHitObject h)
+        public override DrawableHitObject<ManiaHitObject> CreateDrawableRepresentation(ManiaHitObject h)
         {
             switch (h)
             {

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

@@ -28,8 +28,6 @@ namespace osu.Game.Rulesets.Mania.UI
             if (stageDefinitions.Count <= 0)
                 throw new ArgumentException("Can't have zero or fewer stages.");
 
-            Size = new Vector2(1, 0.8f);
-
             GridContainer playfieldGrid;
             AddInternal(playfieldGrid = new GridContainer
             {

osu.Game.Rulesets.Mania/UI/ManiaPlayfieldAdjustmentContainer.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.Rulesets.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.UI
+{
+    public class ManiaPlayfieldAdjustmentContainer : PlayfieldAdjustmentContainer
+    {
+        public ManiaPlayfieldAdjustmentContainer()
+        {
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            Size = new Vector2(1, 0.8f);
+        }
+    }
+}

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

@@ -9,6 +9,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Cursor;
 using osu.Game.Graphics.Cursor;
 using osu.Game.Rulesets.Osu.UI.Cursor;
+using osu.Game.Rulesets.UI;
 using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Osu.Tests
@@ -27,7 +28,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         [BackgroundDependencyLoader]
         private void load()
         {
-            Add(cursorContainer = new GameplayCursorContainer { RelativeSizeAxes = Axes.Both });
+            Add(cursorContainer = new OsuCursorContainer { RelativeSizeAxes = Axes.Both });
         }
     }
 }

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

@@ -0,0 +1,70 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Screens.Play;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestCaseResumeOverlay : ManualInputManagerTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(OsuResumeOverlay),
+        };
+
+        public TestCaseResumeOverlay()
+        {
+            ManualOsuInputManager osuInputManager;
+            CursorContainer cursor;
+            ResumeOverlay resume;
+
+            bool resumeFired = false;
+
+            Child = osuInputManager = new ManualOsuInputManager(new OsuRuleset().RulesetInfo)
+            {
+                Children = new Drawable[]
+                {
+                    cursor = new CursorContainer(),
+                    resume = new OsuResumeOverlay
+                    {
+                        GameplayCursor = cursor
+                    },
+                }
+            };
+
+            resume.ResumeAction = () => resumeFired = true;
+
+            AddStep("move mouse to center", () => InputManager.MoveMouseTo(ScreenSpaceDrawQuad.Centre));
+            AddStep("show", () => resume.Show());
+
+            AddStep("move mouse away", () => InputManager.MoveMouseTo(ScreenSpaceDrawQuad.TopLeft));
+            AddStep("click", () => osuInputManager.GameClick());
+            AddAssert("not dismissed", () => !resumeFired && resume.State == Visibility.Visible);
+
+            AddStep("move mouse back", () => InputManager.MoveMouseTo(ScreenSpaceDrawQuad.Centre));
+            AddStep("click", () => osuInputManager.GameClick());
+            AddAssert("dismissed", () => resumeFired && resume.State == Visibility.Hidden);
+        }
+
+        private class ManualOsuInputManager : OsuInputManager
+        {
+            public ManualOsuInputManager(RulesetInfo ruleset)
+                : base(ruleset)
+            {
+            }
+
+            public void GameClick()
+            {
+                KeyBindingContainer.TriggerPressed(OsuAction.LeftButton);
+                KeyBindingContainer.TriggerReleased(OsuAction.LeftButton);
+            }
+        }
+    }
+}

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

@@ -297,11 +297,6 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         private void performTest(List<ReplayFrame> frames)
         {
-            // Empty frame to be added as a workaround for first frame behavior.
-            // If an input exists on the first frame, the input would apply to the entire intro lead-in
-            // Likely requires some discussion regarding how first frame inputs should be handled.
-            frames.Insert(0, new OsuReplayFrame());
-
             AddStep("load player", () =>
             {
                 Beatmap.Value = new TestWorkingBeatmap(new Beatmap<OsuHitObject>
@@ -330,12 +325,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                     },
                 }, Clock);
 
-                var p = new ScoreAccessibleReplayPlayer(new Score { Replay = new Replay { Frames = frames } })
-                {
-                    AllowPause = false,
-                    AllowLeadIn = false,
-                    AllowResults = false
-                };
+                var p = new ScoreAccessibleReplayPlayer(new Score { Replay = new Replay { Frames = frames } });
 
                 p.OnLoadComplete += _ =>
                 {
@@ -364,7 +354,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
 
             public ScoreAccessibleReplayPlayer(Score score)
-                : base(score)
+                : base(score, false, false)
             {
             }
         }

osu.Game.Rulesets.Osu.Tests/osu.Game.Rulesets.Osu.Tests.csproj

@@ -2,9 +2,9 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.0.1" />
     <PackageReference Include="NUnit" Version="3.11.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.12.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.13.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmap.cs

@@ -3,8 +3,8 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Beatmaps;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Beatmaps
@@ -23,19 +23,19 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                 {
                     Name = @"Circle Count",
                     Content = circles.ToString(),
-                    Icon = FontAwesome.fa_circle_o
+                    Icon = FontAwesome.Regular.Circle
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Slider Count",
                     Content = sliders.ToString(),
-                    Icon = FontAwesome.fa_circle
+                    Icon = FontAwesome.Regular.Circle
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Spinner Count",
                     Content = spinners.ToString(),
-                    Icon = FontAwesome.fa_circle
+                    Icon = FontAwesome.Regular.Circle
                 }
             };
         }

osu.Game.Rulesets.Osu/Edit/DrawableOsuEditRuleset.cs

@@ -15,14 +15,13 @@ namespace osu.Game.Rulesets.Osu.Edit
         {
         }
 
-        protected override Playfield CreatePlayfield() => new OsuPlayfieldNoCursor { Size = Vector2.One　};
+        protected override Playfield CreatePlayfield() => new OsuPlayfieldNoCursor();
+
+        public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new OsuPlayfieldAdjustmentContainer { Size = Vector2.One };
 
         private class OsuPlayfieldNoCursor : OsuPlayfield
         {
-            public OsuPlayfieldNoCursor()
-            {
-                Cursor?.Expire();
-            }
+            protected override GameplayCursorContainer CreateCursor() => null;
         }
     }
 }

osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs

@@ -2,8 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
@@ -13,7 +11,6 @@ using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.UI;
 using osu.Game.Screens.Edit.Compose.Components;
 
@@ -38,8 +35,6 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         public override SelectionHandler CreateSelectionHandler() => new OsuSelectionHandler();
 
-        protected override Container CreateLayerContainer() => new PlayfieldAdjustmentContainer { RelativeSizeAxes = Axes.Both };
-
         public override SelectionBlueprint CreateBlueprintFor(DrawableHitObject hitObject)
         {
             switch (hitObject)

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 
@@ -11,7 +12,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => "Autopilot";
         public override string Acronym => "AP";
-        public override FontAwesome Icon => FontAwesome.fa_osu_mod_autopilot;
+        public override IconUsage Icon => OsuIcon.ModAutopilot;
         public override ModType Type => ModType.Automation;
         public override string Description => @"Automatic cursor movement - just follow the rhythm.";
         public override double ScoreMultiplier => 1;

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

@@ -8,7 +8,6 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Beatmaps;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
@@ -24,7 +23,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Description => "Play with blinds on your screen.";
         public override string Acronym => "BL";
 
-        public override FontAwesome Icon => FontAwesome.fa_adjust;
+        public override IconUsage Icon => FontAwesome.Solid.Adjust;
         public override ModType Type => ModType.DifficultyIncrease;
 
         public override bool Ranked => false;

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

@@ -3,7 +3,7 @@
 
 using System.Collections.Generic;
 using osu.Framework.Graphics;
-using osu.Game.Graphics;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
@@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public override string Acronym => "GR";
 
-        public override FontAwesome Icon => FontAwesome.fa_arrows_v;
+        public override IconUsage Icon => FontAwesome.Solid.ArrowsAltV;
 
         public override ModType Type => ModType.Fun;
 

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 
@@ -11,7 +12,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => "Spun Out";
         public override string Acronym => "SO";
-        public override FontAwesome Icon => FontAwesome.fa_osu_mod_spunout;
+        public override IconUsage Icon => OsuIcon.ModSpunout;
         public override ModType Type => ModType.DifficultyReduction;
         public override string Description => @"Spinners will be automatically completed.";
         public override double ScoreMultiplier => 0.9;

osu.Game.Rulesets.Osu/Mods/OsuModTarget.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 osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 
@@ -11,7 +12,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Name => "Target";
         public override string Acronym => "TP";
         public override ModType Type => ModType.Conversion;
-        public override FontAwesome Icon => FontAwesome.fa_osu_mod_target;
+        public override IconUsage Icon => OsuIcon.ModTarget;
         public override string Description => @"Practice keeping up with the beat of the song.";
         public override double ScoreMultiplier => 1;
     }

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

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 using osu.Framework.Graphics;
-using osu.Game.Graphics;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => "Transform";
         public override string Acronym => "TR";
-        public override FontAwesome Icon => FontAwesome.fa_arrows;
+        public override IconUsage Icon => FontAwesome.Solid.ArrowsAlt;
         public override ModType Type => ModType.Fun;
         public override string Description => "Everything rotates. EVERYTHING.";
         public override double ScoreMultiplier => 1;

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

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 using osu.Framework.Graphics;
-using osu.Game.Graphics;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
@@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => "Wiggle";
         public override string Acronym => "WG";
-        public override FontAwesome Icon => FontAwesome.fa_certificate;
+        public override IconUsage Icon => FontAwesome.Solid.Certificate;
         public override ModType Type => ModType.Fun;
         public override string Description => "They just won't stay still...";
         public override double ScoreMultiplier => 1;

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableRepeatPoint.cs

@@ -4,10 +4,10 @@
 using System;
 using System.Collections.Generic;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Objects.Drawables;
 using osuTK;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;
 
@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 new SkinnableDrawable("Play/osu/reversearrow", _ => new SpriteIcon
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Icon = FontAwesome.fa_chevron_right
+                    Icon = FontAwesome.Solid.ChevronRight
                 }, restrictSize: false)
             };
         }

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs

@@ -12,6 +12,7 @@ using osu.Game.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Screens.Ranking;
 using osu.Game.Rulesets.Scoring;
 
@@ -76,7 +77,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,
                             Size = new Vector2(48),
-                            Icon = FontAwesome.fa_asterisk,
+                            Icon = FontAwesome.Solid.Asterisk,
                             Shadow = false,
                         },
                     }

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SliderBall.cs

@@ -6,6 +6,7 @@ using System.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Objects.Types;
 using osuTK.Graphics;
@@ -14,7 +15,7 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
-    public class SliderBall : CircularContainer, ISliderProgress
+    public class SliderBall : CircularContainer, ISliderProgress, IRequireHighFrequencyMousePosition
     {
         private const float width = 128;
 
@@ -107,18 +108,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 
         private Vector2? lastScreenSpaceMousePosition;
 
-        protected override bool OnMouseDown(MouseDownEvent e)
-        {
-            lastScreenSpaceMousePosition = e.ScreenSpaceMousePosition;
-            return base.OnMouseDown(e);
-        }
-
-        protected override bool OnMouseUp(MouseUpEvent e)
-        {
-            lastScreenSpaceMousePosition = e.ScreenSpaceMousePosition;
-            return base.OnMouseUp(e);
-        }
-
         protected override bool OnMouseMove(MouseMoveEvent e)
         {
             lastScreenSpaceMousePosition = e.ScreenSpaceMousePosition;

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -9,6 +9,7 @@ using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.UI;
 using System.Collections.Generic;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Overlays.Settings;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Osu.Edit;
@@ -137,7 +138,7 @@ namespace osu.Game.Rulesets.Osu
             }
         }
 
-        public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_osu_o };
+        public override Drawable CreateIcon() => new SpriteIcon { Icon = OsuIcon.RulesetOsu };
 
         public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new OsuDifficultyCalculator(this, beatmap);
 

osu.Game.Rulesets.Osu/Replays/OsuAutoGenerator.cs

@@ -292,7 +292,6 @@ namespace osu.Game.Rulesets.Osu.Replays
             {
                 // We add intermediate frames for spinning / following a slider here.
                 case Spinner spinner:
-                {
                     Vector2 difference = startPosition - SPINNER_CENTRE;
 
                     float radius = difference.Length;
@@ -315,9 +314,7 @@ namespace osu.Game.Rulesets.Osu.Replays
 
                     endFrame.Position = endPosition;
                     break;
-                }
                 case Slider slider:
-                {
                     for (double j = FrameDelay; j < slider.Duration; j += FrameDelay)
                     {
                         Vector2 pos = slider.StackedPositionAt(j / slider.Duration);
@@ -326,7 +323,6 @@ namespace osu.Game.Rulesets.Osu.Replays
 
                     AddFrameToReplay(new OsuReplayFrame(slider.EndTime, new Vector2(slider.StackedEndPosition.X, slider.StackedEndPosition.Y), action));
                     break;
-                }
             }
 
             // We only want to let go of our button if we are at the end of the current replay. Otherwise something is still going on after us so we need to keep the button pressed!

osu.Game.Rulesets.Osu/Replays/OsuFramedReplayInputHandler.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Input.StateChanges;
 using osu.Framework.MathUtils;
@@ -24,10 +25,14 @@ namespace osu.Game.Rulesets.Osu.Replays
         {
             get
             {
-                if (!HasFrames)
+                var frame = CurrentFrame;
+
+                if (frame == null)
                     return null;
 
-                return Interpolation.ValueAt(CurrentTime, CurrentFrame.Position, NextFrame.Position, CurrentFrame.Time, NextFrame.Time);
+                Debug.Assert(CurrentTime != null);
+
+                return NextFrame != null ? Interpolation.ValueAt(CurrentTime.Value, frame.Position, NextFrame.Position, frame.Time, NextFrame.Time) : frame.Position;
             }
         }
 
@@ -41,7 +46,7 @@ namespace osu.Game.Rulesets.Osu.Replays
                 },
                 new ReplayState<OsuAction>
                 {
-                    PressedActions = CurrentFrame.Actions
+                    PressedActions = CurrentFrame?.Actions ?? new List<OsuAction>()
                 }
             };
         }

osu.Game.Rulesets.Osu/UI/Cursor/GameplayCursorContainer.cs

@@ -1,223 +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.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Extensions.Color4Extensions;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Cursor;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.Bindings;
-using osu.Game.Beatmaps;
-using osu.Game.Configuration;
-using osu.Game.Skinning;
-using osuTK;
-using osuTK.Graphics;
-
-namespace osu.Game.Rulesets.Osu.UI.Cursor
-{
-    public class GameplayCursorContainer : CursorContainer, IKeyBindingHandler<OsuAction>
-    {
-        protected override Drawable CreateCursor() => new OsuCursor();
-
-        protected override Container<Drawable> Content => fadeContainer;
-
-        private readonly Container<Drawable> fadeContainer;
-
-        public GameplayCursorContainer()
-        {
-            InternalChild = fadeContainer = new Container
-            {
-                RelativeSizeAxes = Axes.Both,
-                Children = new Drawable[]
-                {
-                    new CursorTrail { Depth = 1 }
-                }
-            };
-        }
-
-        private int downCount;
-
-        private void updateExpandedState()
-        {
-            if (downCount > 0)
-                (ActiveCursor as OsuCursor)?.Expand();
-            else
-                (ActiveCursor as OsuCursor)?.Contract();
-        }
-
-        public bool OnPressed(OsuAction action)
-        {
-            switch (action)
-            {
-                case OsuAction.LeftButton:
-                case OsuAction.RightButton:
-                    downCount++;
-                    updateExpandedState();
-                    break;
-            }
-
-            return false;
-        }
-
-        public bool OnReleased(OsuAction action)
-        {
-            switch (action)
-            {
-                case OsuAction.LeftButton:
-                case OsuAction.RightButton:
-                    if (--downCount == 0)
-                        updateExpandedState();
-                    break;
-            }
-
-            return false;
-        }
-
-        public override bool HandlePositionalInput => true; // OverlayContainer will set this false when we go hidden, but we always want to receive input.
-
-        protected override void PopIn()
-        {
-            fadeContainer.FadeTo(1, 300, Easing.OutQuint);
-            ActiveCursor.ScaleTo(1, 400, Easing.OutQuint);
-        }
-
-        protected override void PopOut()
-        {
-            fadeContainer.FadeTo(0.05f, 450, Easing.OutQuint);
-            ActiveCursor.ScaleTo(0.8f, 450, Easing.OutQuint);
-        }
-
-        public class OsuCursor : SkinReloadableDrawable
-        {
-            private bool cursorExpand;
-
-            private Bindable<double> cursorScale;
-            private Bindable<bool> autoCursorScale;
-            private readonly IBindable<WorkingBeatmap> beatmap = new Bindable<WorkingBeatmap>();
-
-            private Container expandTarget;
-            private Drawable scaleTarget;
-
-            public OsuCursor()
-            {
-                Origin = Anchor.Centre;
-                Size = new Vector2(28);
-            }
-
-            protected override void SkinChanged(ISkinSource skin, bool allowFallback)
-            {
-                cursorExpand = skin.GetValue<SkinConfiguration, bool>(s => s.CursorExpand ?? true);
-            }
-
-            [BackgroundDependencyLoader]
-            private void load(OsuConfigManager config, IBindable<WorkingBeatmap> beatmap)
-            {
-                InternalChild = expandTarget = new Container
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Origin = Anchor.Centre,
-                    Anchor = Anchor.Centre,
-                    Child = scaleTarget = new SkinnableDrawable("cursor", _ => new CircularContainer
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Masking = true,
-                        BorderThickness = Size.X / 6,
-                        BorderColour = Color4.White,
-                        EdgeEffect = new EdgeEffectParameters
-                        {
-                            Type = EdgeEffectType.Shadow,
-                            Colour = Color4.Pink.Opacity(0.5f),
-                            Radius = 5,
-                        },
-                        Children = new Drawable[]
-                        {
-                            new Box
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Alpha = 0,
-                                AlwaysPresent = true,
-                            },
-                            new CircularContainer
-                            {
-                                Origin = Anchor.Centre,
-                                Anchor = Anchor.Centre,
-                                RelativeSizeAxes = Axes.Both,
-                                Masking = true,
-                                BorderThickness = Size.X / 3,
-                                BorderColour = Color4.White.Opacity(0.5f),
-                                Children = new Drawable[]
-                                {
-                                    new Box
-                                    {
-                                        RelativeSizeAxes = Axes.Both,
-                                        Alpha = 0,
-                                        AlwaysPresent = true,
-                                    },
-                                },
-                            },
-                            new CircularContainer
-                            {
-                                Origin = Anchor.Centre,
-                                Anchor = Anchor.Centre,
-                                RelativeSizeAxes = Axes.Both,
-                                Scale = new Vector2(0.1f),
-                                Masking = true,
-                                Children = new Drawable[]
-                                {
-                                    new Box
-                                    {
-                                        RelativeSizeAxes = Axes.Both,
-                                        Colour = Color4.White,
-                                    },
-                                },
-                            },
-                        }
-                    }, restrictSize: false)
-                    {
-                        Origin = Anchor.Centre,
-                        Anchor = Anchor.Centre,
-                        RelativeSizeAxes = Axes.Both,
-                    }
-                };
-
-                this.beatmap.BindTo(beatmap);
-                this.beatmap.ValueChanged += _ => calculateScale();
-
-                cursorScale = config.GetBindable<double>(OsuSetting.GameplayCursorSize);
-                cursorScale.ValueChanged += _ => calculateScale();
-
-                autoCursorScale = config.GetBindable<bool>(OsuSetting.AutoCursorSize);
-                autoCursorScale.ValueChanged += _ => calculateScale();
-
-                calculateScale();
-            }
-
-            private void calculateScale()
-            {
-                float scale = (float)cursorScale.Value;
-
-                if (autoCursorScale.Value && beatmap.Value != null)
-                {
-                    // if we have a beatmap available, let's get its circle size to figure out an automatic cursor scale modifier.
-                    scale *= (float)(1 - 0.7 * (1 + beatmap.Value.BeatmapInfo.BaseDifficulty.CircleSize - BeatmapDifficulty.DEFAULT_DIFFICULTY) / BeatmapDifficulty.DEFAULT_DIFFICULTY);
-                }
-
-                scaleTarget.Scale = new Vector2(scale);
-            }
-
-            private const float pressed_scale = 1.2f;
-            private const float released_scale = 1f;
-
-            public void Expand()
-            {
-                if (!cursorExpand) return;
-
-                expandTarget.ScaleTo(released_scale).ScaleTo(pressed_scale, 100, Easing.OutQuad);
-            }
-
-            public void Contract() => expandTarget.ScaleTo(released_scale, 100, Easing.OutQuad);
-        }
-    }
-}

osu.Game.Rulesets.Osu/UI/Cursor/OsuCursor.cs

@@ -0,0 +1,148 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Skinning;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.UI.Cursor
+{
+    public class OsuCursor : SkinReloadableDrawable
+    {
+        private bool cursorExpand;
+
+        private Bindable<double> cursorScale;
+        private Bindable<bool> autoCursorScale;
+        private readonly IBindable<WorkingBeatmap> beatmap = new Bindable<WorkingBeatmap>();
+
+        private Container expandTarget;
+        private Drawable scaleTarget;
+
+        public OsuCursor()
+        {
+            Origin = Anchor.Centre;
+            Size = new Vector2(28);
+        }
+
+        protected override void SkinChanged(ISkinSource skin, bool allowFallback)
+        {
+            cursorExpand = skin.GetValue<SkinConfiguration, bool>(s => s.CursorExpand ?? true);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config, IBindable<WorkingBeatmap> beatmap)
+        {
+            InternalChild = expandTarget = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Origin = Anchor.Centre,
+                Anchor = Anchor.Centre,
+                Child = scaleTarget = new SkinnableDrawable("cursor", _ => new CircularContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    BorderThickness = Size.X / 6,
+                    BorderColour = Color4.White,
+                    EdgeEffect = new EdgeEffectParameters
+                    {
+                        Type = EdgeEffectType.Shadow,
+                        Colour = Color4.Pink.Opacity(0.5f),
+                        Radius = 5,
+                    },
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Alpha = 0,
+                            AlwaysPresent = true,
+                        },
+                        new CircularContainer
+                        {
+                            Origin = Anchor.Centre,
+                            Anchor = Anchor.Centre,
+                            RelativeSizeAxes = Axes.Both,
+                            Masking = true,
+                            BorderThickness = Size.X / 3,
+                            BorderColour = Color4.White.Opacity(0.5f),
+                            Children = new Drawable[]
+                            {
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Alpha = 0,
+                                    AlwaysPresent = true,
+                                },
+                            },
+                        },
+                        new CircularContainer
+                        {
+                            Origin = Anchor.Centre,
+                            Anchor = Anchor.Centre,
+                            RelativeSizeAxes = Axes.Both,
+                            Scale = new Vector2(0.1f),
+                            Masking = true,
+                            Children = new Drawable[]
+                            {
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = Color4.White,
+                                },
+                            },
+                        },
+                    }
+                }, restrictSize: false)
+                {
+                    Origin = Anchor.Centre,
+                    Anchor = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                }
+            };
+
+            this.beatmap.BindTo(beatmap);
+            this.beatmap.ValueChanged += _ => calculateScale();
+
+            cursorScale = config.GetBindable<double>(OsuSetting.GameplayCursorSize);
+            cursorScale.ValueChanged += _ => calculateScale();
+
+            autoCursorScale = config.GetBindable<bool>(OsuSetting.AutoCursorSize);
+            autoCursorScale.ValueChanged += _ => calculateScale();
+
+            calculateScale();
+        }
+
+        private void calculateScale()
+        {
+            float scale = (float)cursorScale.Value;
+
+            if (autoCursorScale.Value && beatmap.Value != null)
+            {
+                // if we have a beatmap available, let's get its circle size to figure out an automatic cursor scale modifier.
+                scale *= (float)(1 - 0.7 * (1 + beatmap.Value.BeatmapInfo.BaseDifficulty.CircleSize - BeatmapDifficulty.DEFAULT_DIFFICULTY) / BeatmapDifficulty.DEFAULT_DIFFICULTY);
+            }
+
+            scaleTarget.Scale = new Vector2(scale);
+        }
+
+        private const float pressed_scale = 1.2f;
+        private const float released_scale = 1f;
+
+        public void Expand()
+        {
+            if (!cursorExpand) return;
+
+            expandTarget.ScaleTo(released_scale).ScaleTo(pressed_scale, 100, Easing.OutQuad);
+        }
+
+        public void Contract() => expandTarget.ScaleTo(released_scale, 100, Easing.OutQuad);
+    }
+}

osu.Game.Rulesets.Osu/UI/Cursor/OsuCursorContainer.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 osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Input.Bindings;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Osu.UI.Cursor
+{
+    public class OsuCursorContainer : GameplayCursorContainer, IKeyBindingHandler<OsuAction>
+    {
+        protected override Drawable CreateCursor() => new OsuCursor();
+
+        protected override Container<Drawable> Content => fadeContainer;
+
+        private readonly Container<Drawable> fadeContainer;
+
+        public OsuCursorContainer()
+        {
+            InternalChild = fadeContainer = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
+                {
+                    new CursorTrail { Depth = 1 }
+                }
+            };
+        }
+
+        private int downCount;
+
+        private void updateExpandedState()
+        {
+            if (downCount > 0)
+                (ActiveCursor as OsuCursor)?.Expand();
+            else
+                (ActiveCursor as OsuCursor)?.Contract();
+        }
+
+        public bool OnPressed(OsuAction action)
+        {
+            switch (action)
+            {
+                case OsuAction.LeftButton:
+                case OsuAction.RightButton:
+                    downCount++;
+                    updateExpandedState();
+                    break;
+            }
+
+            return false;
+        }
+
+        public bool OnReleased(OsuAction action)
+        {
+            switch (action)
+            {
+                case OsuAction.LeftButton:
+                case OsuAction.RightButton:
+                    if (--downCount == 0)
+                        updateExpandedState();
+                    break;
+            }
+
+            return false;
+        }
+
+        public override bool HandlePositionalInput => true; // OverlayContainer will set this false when we go hidden, but we always want to receive input.
+
+        protected override void PopIn()
+        {
+            fadeContainer.FadeTo(1, 300, Easing.OutQuint);
+            ActiveCursor.ScaleTo(1, 400, Easing.OutQuint);
+        }
+
+        protected override void PopOut()
+        {
+            fadeContainer.FadeTo(0.05f, 450, Easing.OutQuint);
+            ActiveCursor.ScaleTo(0.8f, 450, Easing.OutQuint);
+        }
+    }
+}

osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs

@@ -14,6 +14,7 @@ using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play;
 
 namespace osu.Game.Rulesets.Osu.UI
 {
@@ -32,7 +33,11 @@ namespace osu.Game.Rulesets.Osu.UI
 
         protected override PassThroughInputManager CreateInputManager() => new OsuInputManager(Ruleset.RulesetInfo);
 
-        public override DrawableHitObject<OsuHitObject> GetVisualRepresentation(OsuHitObject h)
+        public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new OsuPlayfieldAdjustmentContainer();
+
+        protected override ResumeOverlay CreateResumeOverlay() => new OsuResumeOverlay();
+
+        public override DrawableHitObject<OsuHitObject> CreateDrawableRepresentation(OsuHitObject h)
         {
             switch (h)
             {

osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs

@@ -10,7 +10,6 @@ using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Connections;
 using osu.Game.Rulesets.UI;
 using System.Linq;
-using osu.Framework.Graphics.Cursor;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.UI.Cursor;
 
@@ -24,41 +23,28 @@ namespace osu.Game.Rulesets.Osu.UI
 
         public static readonly Vector2 BASE_SIZE = new Vector2(512, 384);
 
-        private readonly PlayfieldAdjustmentContainer adjustmentContainer;
-
-        protected override Container CursorTargetContainer => adjustmentContainer;
-
-        protected override CursorContainer CreateCursor() => new GameplayCursorContainer();
+        protected override GameplayCursorContainer CreateCursor() => new OsuCursorContainer();
 
         public OsuPlayfield()
         {
-            Anchor = Anchor.Centre;
-            Origin = Anchor.Centre;
-
-            Size = new Vector2(0.75f);
-
-            InternalChild = adjustmentContainer = new PlayfieldAdjustmentContainer
+            InternalChildren = new Drawable[]
             {
-                RelativeSizeAxes = Axes.Both,
-                Children = new Drawable[]
+                connectionLayer = new FollowPointRenderer
                 {
-                    connectionLayer = new FollowPointRenderer
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Depth = 2,
-                    },
-                    judgementLayer = new JudgementContainer<DrawableOsuJudgement>
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Depth = 1,
-                    },
-                    HitObjectContainer,
-                    approachCircles = new ApproachCircleProxyContainer
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Depth = -1,
-                    },
-                }
+                    RelativeSizeAxes = Axes.Both,
+                    Depth = 2,
+                },
+                judgementLayer = new JudgementContainer<DrawableOsuJudgement>
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Depth = 1,
+                },
+                HitObjectContainer,
+                approachCircles = new ApproachCircleProxyContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Depth = -1,
+                },
             };
         }
 

osu.Game.Rulesets.Osu/UI/OsuPlayfieldAdjustmentContainer.cs

@@ -3,17 +3,23 @@
 
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.UI;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.UI
 {
-    public class PlayfieldAdjustmentContainer : Container
+    public class OsuPlayfieldAdjustmentContainer : PlayfieldAdjustmentContainer
     {
         protected override Container<Drawable> Content => content;
         private readonly Container content;
 
-        public PlayfieldAdjustmentContainer()
+        public OsuPlayfieldAdjustmentContainer()
         {
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            Size = new Vector2(0.75f);
+
             InternalChild = new Container
             {
                 Anchor = Anchor.Centre,

osu.Game.Rulesets.Osu/UI/OsuResumeOverlay.cs

@@ -0,0 +1,109 @@
+// 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.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Game.Rulesets.Osu.UI.Cursor;
+using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.UI
+{
+    public class OsuResumeOverlay : ResumeOverlay
+    {
+        private OsuClickToResumeCursor clickToResumeCursor;
+
+        private GameplayCursorContainer localCursorContainer;
+
+        public override CursorContainer LocalCursor => State == Visibility.Visible ? localCursorContainer : null;
+
+        protected override string Message => "Click the orange cursor to resume";
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Add(clickToResumeCursor = new OsuClickToResumeCursor { ResumeRequested = Resume });
+        }
+
+        public override void Show()
+        {
+            base.Show();
+            clickToResumeCursor.ShowAt(GameplayCursor.ActiveCursor.Position);
+
+            if (localCursorContainer == null)
+                Add(localCursorContainer = new OsuCursorContainer());
+        }
+
+        public override void Hide()
+        {
+            localCursorContainer?.Expire();
+            localCursorContainer = null;
+
+            base.Hide();
+        }
+
+        protected override bool OnHover(HoverEvent e) => true;
+
+        public class OsuClickToResumeCursor : OsuCursor, IKeyBindingHandler<OsuAction>
+        {
+            public override bool HandlePositionalInput => true;
+
+            public Action ResumeRequested;
+
+            public OsuClickToResumeCursor()
+            {
+                RelativePositionAxes = Axes.Both;
+            }
+
+            protected override bool OnHover(HoverEvent e)
+            {
+                updateColour();
+                return base.OnHover(e);
+            }
+
+            protected override void OnHoverLost(HoverLostEvent e)
+            {
+                updateColour();
+                base.OnHoverLost(e);
+            }
+
+            public bool OnPressed(OsuAction action)
+            {
+                switch (action)
+                {
+                    case OsuAction.LeftButton:
+                    case OsuAction.RightButton:
+                        if (!IsHovered) return false;
+
+                        this.ScaleTo(new Vector2(2), TRANSITION_TIME, Easing.OutQuint);
+
+                        ResumeRequested?.Invoke();
+                        return true;
+                }
+
+                return false;
+            }
+
+            public bool OnReleased(OsuAction action) => false;
+
+            public void ShowAt(Vector2 activeCursorPosition) => Schedule(() =>
+            {
+                updateColour();
+                this.MoveTo(activeCursorPosition);
+                this.ScaleTo(new Vector2(4)).Then().ScaleTo(Vector2.One, 1000, Easing.OutQuint);
+            });
+
+            private void updateColour()
+            {
+                this.FadeColour(IsHovered ? Color4.White : Color4.Orange, 400, Easing.OutQuint);
+            }
+        }
+    }
+}

osu.Game.Rulesets.Taiko.Tests/osu.Game.Rulesets.Taiko.Tests.csproj

@@ -2,9 +2,9 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.0.1" />
     <PackageReference Include="NUnit" Version="3.11.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.12.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.13.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmap.cs

@@ -3,8 +3,8 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Beatmaps;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Taiko.Objects;
 
 namespace osu.Game.Rulesets.Taiko.Beatmaps
@@ -23,19 +23,19 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                 {
                     Name = @"Hit Count",
                     Content = hits.ToString(),
-                    Icon = FontAwesome.fa_circle_o
+                    Icon = FontAwesome.Regular.Circle
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Drumroll Count",
                     Content = drumrolls.ToString(),
-                    Icon = FontAwesome.fa_circle
+                    Icon = FontAwesome.Regular.Circle
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Swell Count",
                     Content = swells.ToString(),
-                    Icon = FontAwesome.fa_circle
+                    Icon = FontAwesome.Regular.Circle
                 }
             };
         }

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableBarLine.cs

@@ -44,17 +44,14 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             RelativeSizeAxes = Axes.Y;
             Width = tracker_width;
 
-            InternalChildren = new[]
+            AddInternal(Tracker = new Box
             {
-                Tracker = new Box
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    RelativeSizeAxes = Axes.Both,
-                    EdgeSmoothness = new Vector2(0.5f, 0),
-                    Alpha = 0.75f
-                }
-            };
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Both,
+                EdgeSmoothness = new Vector2(0.5f, 0),
+                Alpha = 0.75f
+            });
         }
 
         protected override void UpdateState(ArmedState state)

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         protected DrawableTaikoHitObject(TaikoHitObject hitObject)
             : base(hitObject)
         {
-            InternalChildren = new[]
+            AddRangeInternal(new[]
             {
                 nonProxiedContent = new Container
                 {
@@ -32,7 +32,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                     Child = Content = new Container { RelativeSizeAxes = Axes.Both }
                 },
                 proxiedContent = new ProxiedContentContainer { RelativeSizeAxes = Axes.Both }
-            };
+            });
         }
 
         /// <summary>

osu.Game.Rulesets.Taiko/Objects/Drawables/Pieces/SwellSymbolPiece.cs

@@ -4,7 +4,7 @@
 using osuTK;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Graphics;
+using osu.Framework.Graphics.Sprites;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces
 {
@@ -27,7 +27,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces
                 new SpriteIcon
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Icon = FontAwesome.fa_asterisk,
+                    Icon = FontAwesome.Solid.Asterisk,
                     Shadow = false
                 }
             };

osu.Game.Rulesets.Taiko/Replays/TaikoFramedReplayInputHandler.cs

@@ -18,6 +18,6 @@ namespace osu.Game.Rulesets.Taiko.Replays
 
         protected override bool IsImportant(TaikoReplayFrame frame) => frame.Actions.Any();
 
-        public override List<IInput> GetPendingInputs() => new List<IInput> { new ReplayState<TaikoAction> { PressedActions = CurrentFrame.Actions } };
+        public override List<IInput> GetPendingInputs() => new List<IInput> { new ReplayState<TaikoAction> { PressedActions = CurrentFrame?.Actions ?? new List<TaikoAction>() } };
     }
 }

osu.Game.Rulesets.Taiko/TaikoRuleset.cs

@@ -9,6 +9,7 @@ using osu.Game.Rulesets.Taiko.UI;
 using osu.Game.Rulesets.UI;
 using System.Collections.Generic;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Rulesets.Taiko.Objects;
@@ -114,7 +115,7 @@ namespace osu.Game.Rulesets.Taiko
 
         public override string ShortName => "taiko";
 
-        public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_taiko_o };
+        public override Drawable CreateIcon() => new SpriteIcon { Icon = OsuIcon.RulesetTaiko };
 
         public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new TaikoDifficultyCalculator(this, beatmap);
 

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

@@ -81,11 +81,13 @@ namespace osu.Game.Rulesets.Taiko.UI
 
         public override ScoreProcessor CreateScoreProcessor() => new TaikoScoreProcessor(this);
 
+        public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new TaikoPlayfieldAdjustmentContainer();
+
         protected override PassThroughInputManager CreateInputManager() => new TaikoInputManager(Ruleset.RulesetInfo);
 
         protected override Playfield CreatePlayfield() => new TaikoPlayfield(Beatmap.ControlPointInfo);
 
-        public override DrawableHitObject<TaikoHitObject> GetVisualRepresentation(TaikoHitObject h)
+        public override DrawableHitObject<TaikoHitObject> CreateDrawableRepresentation(TaikoHitObject h)
         {
             switch (h)
             {

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

@@ -55,143 +55,137 @@ namespace osu.Game.Rulesets.Taiko.UI
 
         public TaikoPlayfield(ControlPointInfo controlPoints)
         {
-            InternalChild = new PlayfieldAdjustmentContainer
+            InternalChildren = new Drawable[]
             {
-                Anchor = Anchor.CentreLeft,
-                Origin = Anchor.CentreLeft,
-                RelativeSizeAxes = Axes.Both,
-                Children = new Drawable[]
+                backgroundContainer = new Container
                 {
-                    backgroundContainer = new Container
+                    Name = "Transparent playfield background",
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    EdgeEffect = new EdgeEffectParameters
                     {
-                        Name = "Transparent playfield background",
-                        RelativeSizeAxes = Axes.Both,
-                        Masking = true,
-                        EdgeEffect = new EdgeEffectParameters
+                        Type = EdgeEffectType.Shadow,
+                        Colour = Color4.Black.Opacity(0.2f),
+                        Radius = 5,
+                    },
+                    Children = new Drawable[]
+                    {
+                        background = new Box
                         {
-                            Type = EdgeEffectType.Shadow,
-                            Colour = Color4.Black.Opacity(0.2f),
-                            Radius = 5,
+                            RelativeSizeAxes = Axes.Both,
+                            Alpha = 0.6f
                         },
-                        Children = new Drawable[]
-                        {
-                            background = new Box
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Alpha = 0.6f
-                            },
-                        }
-                    },
-                    new Container
-                    {
-                        Name = "Right area",
-                        RelativeSizeAxes = Axes.Both,
-                        Padding = new MarginPadding { Left = left_area_size },
-                        Children = new Drawable[]
-                        {
-                            new Container
-                            {
-                                Name = "Masked elements before hit objects",
-                                RelativeSizeAxes = Axes.Both,
-                                Padding = new MarginPadding { Left = HIT_TARGET_OFFSET },
-                                Masking = true,
-                                Children = new Drawable[]
-                                {
-                                    hitExplosionContainer = new Container<HitExplosion>
-                                    {
-                                        RelativeSizeAxes = Axes.Both,
-                                        FillMode = FillMode.Fit,
-                                        Blending = BlendingMode.Additive,
-                                    },
-                                    HitTarget = new HitTarget
-                                    {
-                                        Anchor = Anchor.CentreLeft,
-                                        Origin = Anchor.Centre,
-                                        RelativeSizeAxes = Axes.Both,
-                                        FillMode = FillMode.Fit
-                                    }
-                                }
-                            },
-                            barlineContainer = new Container
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Padding = new MarginPadding { Left = HIT_TARGET_OFFSET }
-                            },
-                            new Container
-                            {
-                                Name = "Hit objects",
-                                RelativeSizeAxes = Axes.Both,
-                                Padding = new MarginPadding { Left = HIT_TARGET_OFFSET },
-                                Masking = true,
-                                Child = HitObjectContainer
-                            },
-                            kiaiExplosionContainer = new Container<KiaiHitExplosion>
-                            {
-                                Name = "Kiai hit explosions",
-                                RelativeSizeAxes = Axes.Both,
-                                FillMode = FillMode.Fit,
-                                Margin = new MarginPadding { Left = HIT_TARGET_OFFSET },
-                                Blending = BlendingMode.Additive
-                            },
-                            judgementContainer = new JudgementContainer<DrawableTaikoJudgement>
-                            {
-                                Name = "Judgements",
-                                RelativeSizeAxes = Axes.Y,
-                                Margin = new MarginPadding { Left = HIT_TARGET_OFFSET },
-                                Blending = BlendingMode.Additive
-                            },
-                        }
-                    },
-                    overlayBackgroundContainer = new Container
-                    {
-                        Name = "Left overlay",
-                        RelativeSizeAxes = Axes.Y,
-                        Size = new Vector2(left_area_size, 1),
-                        Children = new Drawable[]
-                        {
-                            overlayBackground = new Box
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                            },
-                            new InputDrum(controlPoints)
-                            {
-                                Anchor = Anchor.CentreRight,
-                                Origin = Anchor.CentreRight,
-                                Scale = new Vector2(0.9f),
-                                Margin = new MarginPadding { Right = 20 }
-                            },
-                            new Box
-                            {
-                                Anchor = Anchor.TopRight,
-                                RelativeSizeAxes = Axes.Y,
-                                Width = 10,
-                                Colour = Framework.Graphics.Colour.ColourInfo.GradientHorizontal(Color4.Black.Opacity(0.6f), Color4.Black.Opacity(0)),
-                            },
-                        }
-                    },
-                    new Container
-                    {
-                        Name = "Border",
-                        RelativeSizeAxes = Axes.Both,
-                        Masking = true,
-                        MaskingSmoothness = 0,
-                        BorderThickness = 2,
-                        AlwaysPresent = true,
-                        Children = new[]
-                        {
-                            new Box
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Alpha = 0,
-                                AlwaysPresent = true
-                            }
-                        }
-                    },
-                    topLevelHitContainer = new Container
-                    {
-                        Name = "Top level hit objects",
-                        RelativeSizeAxes = Axes.Both,
                     }
+                },
+                new Container
+                {
+                    Name = "Right area",
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Left = left_area_size },
+                    Children = new Drawable[]
+                    {
+                        new Container
+                        {
+                            Name = "Masked elements before hit objects",
+                            RelativeSizeAxes = Axes.Both,
+                            Padding = new MarginPadding { Left = HIT_TARGET_OFFSET },
+                            Masking = true,
+                            Children = new Drawable[]
+                            {
+                                hitExplosionContainer = new Container<HitExplosion>
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    FillMode = FillMode.Fit,
+                                    Blending = BlendingMode.Additive,
+                                },
+                                HitTarget = new HitTarget
+                                {
+                                    Anchor = Anchor.CentreLeft,
+                                    Origin = Anchor.Centre,
+                                    RelativeSizeAxes = Axes.Both,
+                                    FillMode = FillMode.Fit
+                                }
+                            }
+                        },
+                        barlineContainer = new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Padding = new MarginPadding { Left = HIT_TARGET_OFFSET }
+                        },
+                        new Container
+                        {
+                            Name = "Hit objects",
+                            RelativeSizeAxes = Axes.Both,
+                            Padding = new MarginPadding { Left = HIT_TARGET_OFFSET },
+                            Masking = true,
+                            Child = HitObjectContainer
+                        },
+                        kiaiExplosionContainer = new Container<KiaiHitExplosion>
+                        {
+                            Name = "Kiai hit explosions",
+                            RelativeSizeAxes = Axes.Both,
+                            FillMode = FillMode.Fit,
+                            Margin = new MarginPadding { Left = HIT_TARGET_OFFSET },
+                            Blending = BlendingMode.Additive
+                        },
+                        judgementContainer = new JudgementContainer<DrawableTaikoJudgement>
+                        {
+                            Name = "Judgements",
+                            RelativeSizeAxes = Axes.Y,
+                            Margin = new MarginPadding { Left = HIT_TARGET_OFFSET },
+                            Blending = BlendingMode.Additive
+                        },
+                    }
+                },
+                overlayBackgroundContainer = new Container
+                {
+                    Name = "Left overlay",
+                    RelativeSizeAxes = Axes.Y,
+                    Size = new Vector2(left_area_size, 1),
+                    Children = new Drawable[]
+                    {
+                        overlayBackground = new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                        new InputDrum(controlPoints)
+                        {
+                            Anchor = Anchor.CentreRight,
+                            Origin = Anchor.CentreRight,
+                            Scale = new Vector2(0.9f),
+                            Margin = new MarginPadding { Right = 20 }
+                        },
+                        new Box
+                        {
+                            Anchor = Anchor.TopRight,
+                            RelativeSizeAxes = Axes.Y,
+                            Width = 10,
+                            Colour = Framework.Graphics.Colour.ColourInfo.GradientHorizontal(Color4.Black.Opacity(0.6f), Color4.Black.Opacity(0)),
+                        },
+                    }
+                },
+                new Container
+                {
+                    Name = "Border",
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    MaskingSmoothness = 0,
+                    BorderThickness = 2,
+                    AlwaysPresent = true,
+                    Children = new[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Alpha = 0,
+                            AlwaysPresent = true
+                        }
+                    }
+                },
+                topLevelHitContainer = new Container
+                {
+                    Name = "Top level hit objects",
+                    RelativeSizeAxes = Axes.Both,
                 }
             };
         }

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

@@ -1,16 +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 osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.UI;
 using osuTK;
 
 namespace osu.Game.Rulesets.Taiko.UI
 {
-    public class PlayfieldAdjustmentContainer : Container
+    public class TaikoPlayfieldAdjustmentContainer : PlayfieldAdjustmentContainer
     {
         private const float default_relative_height = TaikoPlayfield.DEFAULT_HEIGHT / 768;
         private const float default_aspect = 16f / 9f;
 
+        public TaikoPlayfieldAdjustmentContainer()
+        {
+            Anchor = Anchor.CentreLeft;
+            Origin = Anchor.CentreLeft;
+        }
+
         protected override void Update()
         {
             base.Update();

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

@@ -29,28 +29,28 @@ namespace osu.Game.Tests.Beatmaps.Formats
 
                 StoryboardLayer background = storyboard.Layers.FirstOrDefault(l => l.Depth == 3);
                 Assert.IsNotNull(background);
-                Assert.AreEqual(16, background.Elements.Count());
+                Assert.AreEqual(16, background.Elements.Count);
                 Assert.IsTrue(background.EnabledWhenFailing);
                 Assert.IsTrue(background.EnabledWhenPassing);
                 Assert.AreEqual("Background", background.Name);
 
                 StoryboardLayer fail = storyboard.Layers.FirstOrDefault(l => l.Depth == 2);
                 Assert.IsNotNull(fail);
-                Assert.AreEqual(0, fail.Elements.Count());
+                Assert.AreEqual(0, fail.Elements.Count);
                 Assert.IsTrue(fail.EnabledWhenFailing);
                 Assert.IsFalse(fail.EnabledWhenPassing);
                 Assert.AreEqual("Fail", fail.Name);
 
                 StoryboardLayer pass = storyboard.Layers.FirstOrDefault(l => l.Depth == 1);
                 Assert.IsNotNull(pass);
-                Assert.AreEqual(0, pass.Elements.Count());
+                Assert.AreEqual(0, pass.Elements.Count);
                 Assert.IsFalse(pass.EnabledWhenFailing);
                 Assert.IsTrue(pass.EnabledWhenPassing);
                 Assert.AreEqual("Pass", pass.Name);
 
                 StoryboardLayer foreground = storyboard.Layers.FirstOrDefault(l => l.Depth == 0);
                 Assert.IsNotNull(foreground);
-                Assert.AreEqual(151, foreground.Elements.Count());
+                Assert.AreEqual(151, foreground.Elements.Count);
                 Assert.IsTrue(foreground.EnabledWhenFailing);
                 Assert.IsTrue(foreground.EnabledWhenPassing);
                 Assert.AreEqual("Foreground", foreground.Name);
@@ -62,7 +62,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 Assert.AreEqual(15, spriteCount);
                 Assert.AreEqual(1, animationCount);
                 Assert.AreEqual(0, sampleCount);
-                Assert.AreEqual(background.Elements.Count(), spriteCount + animationCount + sampleCount);
+                Assert.AreEqual(background.Elements.Count, spriteCount + animationCount + sampleCount);
 
                 var sprite = background.Elements.ElementAt(0) as StoryboardSprite;
                 Assert.NotNull(sprite);
@@ -70,9 +70,9 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 Assert.AreEqual(new Vector2(320, 240), sprite.InitialPosition);
                 Assert.IsTrue(sprite.IsDrawable);
                 Assert.AreEqual(Anchor.Centre, sprite.Origin);
-                Assert.AreEqual("SB/lyric/ja-21.png", sprite.Path);
+                Assert.AreEqual("SB/black.jpg", sprite.Path);
 
-                var animation = background.Elements.ElementAt(12) as StoryboardAnimation;
+                var animation = background.Elements.OfType<StoryboardAnimation>().First();
                 Assert.NotNull(animation);
                 Assert.AreEqual(141175, animation.EndTime);
                 Assert.AreEqual(10, animation.FrameCount);

osu.Game.Tests/NonVisual/FramedReplayinputHandlerTest.cs

@@ -0,0 +1,284 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Replays;
+
+namespace osu.Game.Tests.NonVisual
+{
+    [TestFixture]
+    public class FramedReplayinputHandlerTest
+    {
+        private Replay replay;
+        private TestInputHandler handler;
+
+        [SetUp]
+        public void SetUp()
+        {
+            handler = new TestInputHandler(replay = new Replay
+            {
+                Frames = new List<ReplayFrame>
+                {
+                    new TestReplayFrame(0),
+                    new TestReplayFrame(1000),
+                    new TestReplayFrame(2000),
+                    new TestReplayFrame(3000, true),
+                    new TestReplayFrame(4000, true),
+                    new TestReplayFrame(5000, true),
+                    new TestReplayFrame(7000, true),
+                    new TestReplayFrame(8000),
+                }
+            });
+        }
+
+        [Test]
+        public void TestNormalPlayback()
+        {
+            Assert.IsNull(handler.CurrentFrame);
+
+            confirmCurrentFrame(null);
+            confirmNextFrame(0);
+
+            setTime(0, 0);
+            confirmCurrentFrame(0);
+            confirmNextFrame(1);
+
+            //if we hit the first frame perfectly, time should progress to it.
+            setTime(1000, 1000);
+            confirmCurrentFrame(1);
+            confirmNextFrame(2);
+
+            //in between non-important frames should progress based on input.
+            setTime(1200, 1200);
+            confirmCurrentFrame(1);
+
+            setTime(1400, 1400);
+            confirmCurrentFrame(1);
+
+            // progressing beyond the next frame should force time to that frame once.
+            setTime(2200, 2000);
+            confirmCurrentFrame(2);
+
+            // second attempt should progress to input time
+            setTime(2200, 2200);
+            confirmCurrentFrame(2);
+
+            // entering important section
+            setTime(3000, 3000);
+            confirmCurrentFrame(3);
+
+            // cannot progress within
+            setTime(3500, null);
+            confirmCurrentFrame(3);
+
+            setTime(4000, 4000);
+            confirmCurrentFrame(4);
+
+            // still cannot progress
+            setTime(4500, null);
+            confirmCurrentFrame(4);
+
+            setTime(5200, 5000);
+            confirmCurrentFrame(5);
+
+            // important section AllowedImportantTimeSpan allowance
+            setTime(5200, 5200);
+            confirmCurrentFrame(5);
+
+            setTime(7200, 7000);
+            confirmCurrentFrame(6);
+
+            setTime(7200, null);
+            confirmCurrentFrame(6);
+
+            // exited important section
+            setTime(8200, 8000);
+            confirmCurrentFrame(7);
+            confirmNextFrame(null);
+
+            setTime(8200, 8200);
+            confirmCurrentFrame(7);
+            confirmNextFrame(null);
+        }
+
+        [Test]
+        public void TestIntroTime()
+        {
+            setTime(-1000, -1000);
+            confirmCurrentFrame(null);
+            confirmNextFrame(0);
+
+            setTime(-500, -500);
+            confirmCurrentFrame(null);
+            confirmNextFrame(0);
+
+            setTime(0, 0);
+            confirmCurrentFrame(0);
+            confirmNextFrame(1);
+        }
+
+        [Test]
+        public void TestBasicRewind()
+        {
+            setTime(2800, 0);
+            setTime(2800, 1000);
+            setTime(2800, 2000);
+            setTime(2800, 2800);
+            confirmCurrentFrame(2);
+            confirmNextFrame(3);
+
+            // pivot without crossing a frame boundary
+            setTime(2700, 2700);
+            confirmCurrentFrame(2);
+            confirmNextFrame(1);
+
+            // cross current frame boundary; should not yet update frame
+            setTime(1980, 1980);
+            confirmCurrentFrame(2);
+            confirmNextFrame(1);
+
+            setTime(1200, 1200);
+            confirmCurrentFrame(2);
+            confirmNextFrame(1);
+
+            //ensure each frame plays out until start
+            setTime(-500, 1000);
+            confirmCurrentFrame(1);
+            confirmNextFrame(0);
+
+            setTime(-500, 0);
+            confirmCurrentFrame(0);
+            confirmNextFrame(null);
+
+            setTime(-500, -500);
+            confirmCurrentFrame(0);
+            confirmNextFrame(null);
+        }
+
+        [Test]
+        public void TestRewindInsideImportantSection()
+        {
+            // fast forward to important section
+            while (handler.SetFrameFromTime(3000) != null)
+            {
+            }
+
+            setTime(4000, 4000);
+            confirmCurrentFrame(4);
+            confirmNextFrame(5);
+
+            setTime(3500, null);
+            confirmCurrentFrame(4);
+            confirmNextFrame(3);
+
+            setTime(3000, 3000);
+            confirmCurrentFrame(3);
+            confirmNextFrame(2);
+
+            setTime(3500, null);
+            confirmCurrentFrame(3);
+            confirmNextFrame(4);
+
+            setTime(4000, 4000);
+            confirmCurrentFrame(4);
+            confirmNextFrame(5);
+
+            setTime(4500, null);
+            confirmCurrentFrame(4);
+            confirmNextFrame(5);
+
+            setTime(4000, null);
+            confirmCurrentFrame(4);
+            confirmNextFrame(5);
+
+            setTime(3500, null);
+            confirmCurrentFrame(4);
+            confirmNextFrame(3);
+
+            setTime(3000, 3000);
+            confirmCurrentFrame(3);
+            confirmNextFrame(2);
+        }
+
+        [Test]
+        public void TestRewindOutOfImportantSection()
+        {
+            // fast forward to important section
+            while (handler.SetFrameFromTime(3500) != null)
+            {
+            }
+
+            confirmCurrentFrame(3);
+            confirmNextFrame(4);
+
+            setTime(3200, null);
+            // next frame doesn't change even though direction reversed, because of important section.
+            confirmCurrentFrame(3);
+            confirmNextFrame(4);
+
+            setTime(3000, null);
+            confirmCurrentFrame(3);
+            confirmNextFrame(4);
+
+            setTime(2800, 2800);
+            confirmCurrentFrame(3);
+            confirmNextFrame(2);
+        }
+
+        private void setTime(double set, double? expect)
+        {
+            Assert.AreEqual(expect, handler.SetFrameFromTime(set));
+        }
+
+        private void confirmCurrentFrame(int? frame)
+        {
+            if (frame.HasValue)
+            {
+                Assert.IsNotNull(handler.CurrentFrame);
+                Assert.AreEqual(replay.Frames[frame.Value].Time, handler.CurrentFrame.Time);
+            }
+            else
+            {
+                Assert.IsNull(handler.CurrentFrame);
+            }
+        }
+
+        private void confirmNextFrame(int? frame)
+        {
+            if (frame.HasValue)
+            {
+                Assert.IsNotNull(handler.NextFrame);
+                Assert.AreEqual(replay.Frames[frame.Value].Time, handler.NextFrame.Time);
+            }
+            else
+            {
+                Assert.IsNull(handler.NextFrame);
+            }
+        }
+
+        private class TestReplayFrame : ReplayFrame
+        {
+            public readonly bool IsImportant;
+
+            public TestReplayFrame(double time, bool isImportant = false)
+                : base(time)
+            {
+                IsImportant = isImportant;
+            }
+        }
+
+        private class TestInputHandler : FramedReplayInputHandler<TestReplayFrame>
+        {
+            public TestInputHandler(Replay replay)
+                : base(replay)
+            {
+            }
+
+            protected override double AllowedImportantTimeSpan => 1000;
+
+            protected override bool IsImportant(TestReplayFrame frame) => frame.IsImportant;
+        }
+    }
+}

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

@@ -9,7 +9,6 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Events;
 using osu.Framework.Input.States;
@@ -33,7 +32,7 @@ using osu.Game.Users;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Background
 {
     [TestFixture]
     public class TestCaseBackgroundScreenBeatmap : ManualInputManagerTestCase
@@ -54,8 +53,6 @@ namespace osu.Game.Tests.Visual
         private BeatmapManager manager;
         private RulesetStore rulesets;
 
-        private ScreenStackCacheContainer screenStackContainer;
-
         [BackgroundDependencyLoader]
         private void load(GameHost host)
         {
@@ -82,8 +79,10 @@ namespace osu.Game.Tests.Visual
         [SetUp]
         public virtual void SetUp() => Schedule(() =>
         {
-            Child = screenStackContainer = new ScreenStackCacheContainer { RelativeSizeAxes = Axes.Both };
-            screenStackContainer.ScreenStack.Push(songSelect = new DummySongSelect());
+            Child = new OsuScreenStack(songSelect = new DummySongSelect())
+            {
+                RelativeSizeAxes = Axes.Both
+            };
         });
 
         /// <summary>
@@ -93,7 +92,7 @@ namespace osu.Game.Tests.Visual
         public void PlayerLoaderSettingsHoverTest()
         {
             setupUserSettings();
-            AddStep("Start player loader", () => songSelect.Push(playerLoader = new TestPlayerLoader(player = new TestPlayer())));
+            AddStep("Start player loader", () => songSelect.Push(playerLoader = new TestPlayerLoader(player = new TestPlayer { BlockLoad = true })));
             AddUntilStep("Wait for Player Loader to load", () => playerLoader?.IsLoaded ?? false);
             AddAssert("Background retained from song select", () => songSelect.IsBackgroundCurrent());
             AddStep("Trigger background preview", () =>
@@ -184,10 +183,10 @@ namespace osu.Game.Tests.Visual
         public void PauseTest()
         {
             performFullSetup(true);
-            AddStep("Pause", () => player.CurrentPausableGameplayContainer.Pause());
+            AddStep("Pause", () => player.Pause());
             waitForDim();
             AddAssert("Screen is dimmed and blur applied", () => songSelect.IsBackgroundDimmed() && songSelect.IsUserBlurApplied());
-            AddStep("Unpause", () => player.CurrentPausableGameplayContainer.Resume());
+            AddStep("Unpause", () => player.Resume());
             waitForDim();
             AddAssert("Screen is dimmed and blur applied", () => songSelect.IsBackgroundDimmed() && songSelect.IsUserBlurApplied());
         }
@@ -256,14 +255,8 @@ namespace osu.Game.Tests.Visual
         {
             setupUserSettings();
 
-            AddStep("Start player loader", () =>
-            {
-                songSelect.Push(playerLoader = new TestPlayerLoader(player = new TestPlayer
-                {
-                    AllowPause = allowPause,
-                    Ready = true,
-                }));
-            });
+            AddStep("Start player loader", () => songSelect.Push(playerLoader = new TestPlayerLoader(player = new TestPlayer(allowPause))));
+
             AddUntilStep("Wait for Player Loader to load", () => playerLoader.IsLoaded);
             AddStep("Move mouse to center of screen", () => InputManager.MoveMouseTo(playerLoader.ScreenPos));
             AddUntilStep("Wait for player to load", () => player.IsLoaded);
@@ -349,46 +342,36 @@ namespace osu.Game.Tests.Visual
                 };
             }
 
-            public PausableGameplayContainer CurrentPausableGameplayContainer => PausableGameplayContainer;
-
             public UserDimContainer CurrentStoryboardContainer => StoryboardContainer;
 
             // Whether or not the player should be allowed to load.
-            public bool Ready;
+            public bool BlockLoad;
 
             public Bindable<bool> StoryboardEnabled;
             public readonly Bindable<bool> ReplacesBackground = new Bindable<bool>();
             public readonly Bindable<bool> IsPaused = new Bindable<bool>();
 
+            public TestPlayer(bool allowPause = true)
+                : base(allowPause)
+            {
+            }
+
             public bool IsStoryboardVisible() => ((TestUserDimContainer)CurrentStoryboardContainer).CurrentAlpha == 1;
 
             public bool IsStoryboardInvisible() => ((TestUserDimContainer)CurrentStoryboardContainer).CurrentAlpha <= 1;
 
             [BackgroundDependencyLoader]
-            private void load(OsuConfigManager config)
+            private void load(OsuConfigManager config, CancellationToken token)
             {
-                while (!Ready)
+                while (BlockLoad && !token.IsCancellationRequested)
                     Thread.Sleep(1);
+
                 StoryboardEnabled = config.GetBindable<bool>(OsuSetting.ShowStoryboard);
                 ReplacesBackground.BindTo(Background.StoryboardReplacesBackground);
                 DrawableRuleset.IsPaused.BindTo(IsPaused);
             }
         }
 
-        private class ScreenStackCacheContainer : Container
-        {
-            [Cached]
-            private BackgroundScreenStack backgroundScreenStack;
-
-            public readonly ScreenStack ScreenStack;
-
-            public ScreenStackCacheContainer()
-            {
-                Add(backgroundScreenStack = new BackgroundScreenStack { RelativeSizeAxes = Axes.Both });
-                Add(ScreenStack = new ScreenStack { RelativeSizeAxes = Axes.Both });
-            }
-        }
-
         private class TestPlayerLoader : PlayerLoader
         {
             public VisualSettings VisualSettingsPos => VisualSettings;

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

@@ -9,7 +9,7 @@ using osu.Game.Input;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Components
 {
     [TestFixture]
     public class TestCaseIdleTracker : ManualInputManagerTestCase

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

@@ -13,7 +13,7 @@ using osu.Game.Online;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Components
 {
     public class TestCasePollingComponent : OsuTestCase
     {

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

@@ -8,7 +8,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Components
 {
     public class TestCasePreviewTrackManager : OsuTestCase, IPreviewTrackOwner
     {

osu.Game.Tests/Visual/Editor/TestCaseBeatDivisorControl.cs

@@ -9,7 +9,7 @@ using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     public class TestCaseBeatDivisorControl : OsuTestCase
     {

osu.Game.Tests/Visual/Editor/TestCaseEditorCompose.cs

@@ -9,7 +9,7 @@ using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.Edit.Compose;
 using osu.Game.Tests.Beatmaps;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
     public class TestCaseEditorCompose : EditorClockTestCase

osu.Game.Tests/Visual/Editor/TestCaseEditorComposeRadioButtons.cs

@@ -7,7 +7,7 @@ using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Game.Screens.Edit.Components.RadioButtons;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
     public class TestCaseEditorComposeRadioButtons : OsuTestCase

osu.Game.Tests/Visual/Editor/TestCaseEditorComposeTimeline.cs

@@ -6,7 +6,6 @@ using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osuTK;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -14,9 +13,10 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Screens.Edit.Compose.Components.Timeline;
+using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
     public class TestCaseEditorComposeTimeline : EditorClockTestCase

osu.Game.Tests/Visual/Editor/TestCaseEditorMenuBar.cs

@@ -10,7 +10,7 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Screens.Edit.Components.Menus;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
     public class TestCaseEditorMenuBar : OsuTestCase

osu.Game.Tests/Visual/Editor/TestCaseEditorSeekSnapping.cs

@@ -14,7 +14,7 @@ using osu.Game.Tests.Beatmaps;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
     public class TestCaseEditorSeekSnapping : EditorClockTestCase

osu.Game.Tests/Visual/Editor/TestCaseEditorSummaryTimeline.cs

@@ -6,12 +6,12 @@ using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osuTK;
-using osu.Game.Screens.Edit.Components.Timelines.Summary;
 using osu.Game.Rulesets.Osu;
+using osu.Game.Screens.Edit.Components.Timelines.Summary;
 using osu.Game.Tests.Beatmaps;
+using osuTK;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
     public class TestCaseEditorSummaryTimeline : EditorClockTestCase

osu.Game.Tests/Visual/Editor/TestCaseHitObjectComposer.cs

@@ -7,7 +7,6 @@ using JetBrains.Annotations;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Timing;
-using osuTK;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
@@ -20,8 +19,9 @@ using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Screens.Edit.Compose;
 using osu.Game.Screens.Edit.Compose.Components;
 using osu.Game.Tests.Beatmaps;
+using osuTK;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
     [Cached(Type = typeof(IPlacementHandler))]

osu.Game.Tests/Visual/Editor/TestCasePlaybackControl.cs

@@ -10,7 +10,7 @@ using osu.Game.Screens.Edit.Components;
 using osu.Game.Tests.Beatmaps;
 using osuTK;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
     public class TestCasePlaybackControl : OsuTestCase

osu.Game.Tests/Visual/Editor/TestCaseWaveContainer.cs

@@ -12,7 +12,7 @@ using osu.Game.Graphics.Sprites;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
     public class TestCaseWaveContainer : OsuTestCase

osu.Game.Tests/Visual/Editor/TestCaseWaveform.cs

@@ -2,16 +2,16 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
-using osuTK;
-using osuTK.Graphics;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Audio;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics.Sprites;
+using osuTK;
+using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
     public class TestCaseWaveform : OsuTestCase

osu.Game.Tests/Visual/Editor/TestCaseZoomableScrollContainer.cs

@@ -14,7 +14,7 @@ using osu.Game.Screens.Edit.Compose.Components.Timeline;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     public class TestCaseZoomableScrollContainer : ManualInputManagerTestCase
     {

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

@@ -7,7 +7,7 @@ using osu.Game.Rulesets;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     [Description("Player instantiated with an autoplay mod.")]
     public class TestCaseAutoplay : AllPlayersTestCase
@@ -15,12 +15,7 @@ namespace osu.Game.Tests.Visual
         protected override Player CreatePlayer(Ruleset ruleset)
         {
             Beatmap.Value.Mods.Value = Beatmap.Value.Mods.Value.Concat(new[] { ruleset.GetAutoplayMod() });
-            return new ScoreAccessiblePlayer
-            {
-                AllowPause = false,
-                AllowLeadIn = false,
-                AllowResults = false,
-            };
+            return new ScoreAccessiblePlayer();
         }
 
         protected override void AddCheckSteps()
@@ -33,6 +28,11 @@ namespace osu.Game.Tests.Visual
         {
             public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
             public new HUDOverlay HUDOverlay => base.HUDOverlay;
+
+            public ScoreAccessiblePlayer()
+                : base(false, false)
+            {
+            }
         }
     }
 }

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

@@ -1,12 +1,12 @@
 // 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.Beatmaps.Timing;
 using System.Collections.Generic;
 using NUnit.Framework;
+using osu.Game.Beatmaps.Timing;
 using osu.Game.Screens.Play;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     [TestFixture]
     public class TestCaseBreakOverlay : OsuTestCase

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

@@ -5,38 +5,48 @@ using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Linq;
-using osuTK.Input;
 using osu.Framework.Allocation;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Logging;
+using osu.Game.Input.Bindings;
 using osu.Game.Screens.Play;
 using osuTK;
+using osuTK.Input;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     [Description("player pause/fail screens")]
     public class TestCaseGameplayMenuOverlay : ManualInputManagerTestCase
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(FailOverlay), typeof(PausableGameplayContainer) };
+        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(FailOverlay), typeof(PauseOverlay) };
 
         private FailOverlay failOverlay;
-        private PausableGameplayContainer.PauseOverlay pauseOverlay;
+        private PauseOverlay pauseOverlay;
+
+        private GlobalActionContainer globalActionContainer;
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(OsuGameBase game)
         {
-            Add(pauseOverlay = new PausableGameplayContainer.PauseOverlay
+            Child = globalActionContainer = new GlobalActionContainer(game)
             {
-                OnResume = () => Logger.Log(@"Resume"),
-                OnRetry = () => Logger.Log(@"Retry"),
-                OnQuit = () => Logger.Log(@"Quit"),
-            });
+                Children = new Drawable[]
+                {
+                    pauseOverlay = new PauseOverlay
+                    {
+                        OnResume = () => Logger.Log(@"Resume"),
+                        OnRetry = () => Logger.Log(@"Retry"),
+                        OnQuit = () => Logger.Log(@"Quit"),
+                    },
+                    failOverlay = new FailOverlay
 
-            Add(failOverlay = new FailOverlay
-            {
-                OnRetry = () => Logger.Log(@"Retry"),
-                OnQuit = () => Logger.Log(@"Quit"),
-            });
+                    {
+                        OnRetry = () => Logger.Log(@"Retry"),
+                        OnQuit = () => Logger.Log(@"Quit"),
+                    }
+                }
+            };
 
             var retryCount = 0;
 
@@ -79,12 +89,6 @@ namespace osu.Game.Tests.Visual
             AddAssert("Overlay state is reset", () => !failOverlay.Buttons.Any(b => b.Selected.Value));
         }
 
-        private void press(Key key)
-        {
-            InputManager.PressKey(key);
-            InputManager.ReleaseKey(key);
-        }
-
         /// <summary>
         /// Tests that pressing enter after an overlay shows doesn't trigger an event because a selection hasn't occurred.
         /// </summary>
@@ -92,7 +96,7 @@ namespace osu.Game.Tests.Visual
         {
             AddStep("Show overlay", () => pauseOverlay.Show());
 
-            AddStep("Press enter", () => press(Key.Enter));
+            AddStep("Press select", () => press(GlobalAction.Select));
             AddAssert("Overlay still open", () => pauseOverlay.State == Visibility.Visible);
 
             AddStep("Hide overlay", () => pauseOverlay.Hide());
@@ -270,5 +274,17 @@ namespace osu.Game.Tests.Visual
             });
             AddAssert("Overlay is closed", () => pauseOverlay.State == Visibility.Hidden);
         }
+
+        private void press(Key key)
+        {
+            InputManager.PressKey(key);
+            InputManager.ReleaseKey(key);
+        }
+
+        private void press(GlobalAction action)
+        {
+            globalActionContainer.TriggerPressed(action);
+            globalActionContainer.TriggerReleased(action);
+        }
     }
 }

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

@@ -10,7 +10,7 @@ using osu.Game.Screens.Play.HUD;
 using osuTK;
 using osuTK.Input;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     [Description("'Hold to Quit' UI element")]
     public class TestCaseHoldForMenuButton : ManualInputManagerTestCase

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

@@ -11,7 +11,7 @@ using osu.Framework.Timing;
 using osu.Game.Screens.Play;
 using osuTK.Input;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     [TestFixture]
     public class TestCaseKeyCounter : ManualInputManagerTestCase
@@ -20,13 +20,13 @@ namespace osu.Game.Tests.Visual
         {
             typeof(KeyCounterKeyboard),
             typeof(KeyCounterMouse),
-            typeof(KeyCounterCollection)
+            typeof(KeyCounterDisplay)
         };
 
         public TestCaseKeyCounter()
         {
             KeyCounterKeyboard rewindTestKeyCounterKeyboard;
-            KeyCounterCollection kc = new KeyCounterCollection
+            KeyCounterDisplay kc = new KeyCounterDisplay
             {
                 Origin = Anchor.Centre,
                 Anchor = Anchor.Centre,

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

@@ -8,7 +8,7 @@ using osu.Game.Overlays;
 using osu.Game.Overlays.MedalSplash;
 using osu.Game.Users;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     [TestFixture]
     public class TestCaseMedalOverlay : OsuTestCase

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

@@ -0,0 +1,205 @@
+// 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;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Screens;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Cursor;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestCasePause : PlayerTestCase
+    {
+        protected new PausePlayer Player => (PausePlayer)base.Player;
+
+        private readonly Container content;
+
+        protected override Container<Drawable> Content => content;
+
+        public TestCasePause()
+            : base(new OsuRuleset())
+        {
+            base.Content.Add(content = new MenuCursorContainer { RelativeSizeAxes = Axes.Both });
+        }
+
+        [Test]
+        public void TestPauseResume()
+        {
+            AddStep("move cursor outside", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.TopLeft - new Vector2(10)));
+            pauseAndConfirm();
+            resumeAndConfirm();
+        }
+
+        [Test]
+        public void TestResumeWithResumeOverlay()
+        {
+            AddStep("move cursor to center", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.Centre));
+            AddUntilStep("wait for hitobjects", () => Player.ScoreProcessor.Health.Value < 1);
+
+            pauseAndConfirm();
+            resume();
+
+            confirmClockRunning(false);
+            confirmPauseOverlayShown(false);
+
+            AddStep("click to resume", () =>
+            {
+                InputManager.PressButton(MouseButton.Left);
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            confirmClockRunning(true);
+        }
+
+        [Test]
+        public void TestResumeWithResumeOverlaySkipped()
+        {
+            AddStep("move cursor to button", () =>
+                InputManager.MoveMouseTo(Player.HUDOverlay.HoldToQuit.Children.OfType<HoldToConfirmContainer>().First().ScreenSpaceDrawQuad.Centre));
+            AddUntilStep("wait for hitobjects", () => Player.ScoreProcessor.Health.Value < 1);
+
+            pauseAndConfirm();
+            resumeAndConfirm();
+        }
+
+        [Test]
+        public void TestPauseTooSoon()
+        {
+            AddStep("move cursor outside", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.TopLeft - new Vector2(10)));
+
+            pauseAndConfirm();
+            resumeAndConfirm();
+
+            pause();
+
+            confirmClockRunning(true);
+            confirmPauseOverlayShown(false);
+        }
+
+        [Test]
+        public void TestExitTooSoon()
+        {
+            pauseAndConfirm();
+
+            resume();
+
+            AddStep("exit too soon", () => Player.Exit());
+
+            confirmClockRunning(true);
+            confirmPauseOverlayShown(false);
+
+            AddAssert("not exited", () => Player.IsCurrentScreen());
+        }
+
+        [Test]
+        public void TestPauseAfterFail()
+        {
+            AddUntilStep("wait for fail", () => Player.HasFailed);
+            AddAssert("fail overlay shown", () => Player.FailOverlayVisible);
+
+            confirmClockRunning(false);
+
+            pause();
+
+            confirmClockRunning(false);
+            confirmPauseOverlayShown(false);
+
+            AddAssert("fail overlay still shown", () => Player.FailOverlayVisible);
+
+            exitAndConfirm();
+        }
+
+        [Test]
+        public void TestExitFromGameplay()
+        {
+            AddStep("exit", () => Player.Exit());
+
+            confirmPaused();
+
+            exitAndConfirm();
+        }
+
+        [Test]
+        public void TestExitFromPause()
+        {
+            pauseAndConfirm();
+            exitAndConfirm();
+        }
+
+        private void pauseAndConfirm()
+        {
+            pause();
+            confirmPaused();
+        }
+
+        private void resumeAndConfirm()
+        {
+            resume();
+            confirmResumed();
+        }
+
+        private void exitAndConfirm()
+        {
+            AddUntilStep("player not exited", () => Player.IsCurrentScreen());
+            AddStep("exit", () => Player.Exit());
+            confirmExited();
+        }
+
+        private void confirmPaused()
+        {
+            confirmClockRunning(false);
+            AddAssert("pause overlay shown", () => Player.PauseOverlayVisible);
+        }
+
+        private void confirmResumed()
+        {
+            confirmClockRunning(true);
+            confirmPauseOverlayShown(false);
+        }
+
+        private void confirmExited()
+        {
+            AddUntilStep("player exited", () => !Player.IsCurrentScreen());
+        }
+
+        private void pause() => AddStep("pause", () => Player.Pause());
+        private void resume() => AddStep("resume", () => Player.Resume());
+
+        private void confirmPauseOverlayShown(bool isShown) =>
+            AddAssert("pause overlay " + (isShown ? "shown" : "hidden"), () => Player.PauseOverlayVisible == isShown);
+
+        private void confirmClockRunning(bool isRunning) =>
+            AddAssert("clock " + (isRunning ? "running" : "stopped"), () => Player.GameplayClockContainer.GameplayClock.IsRunning == isRunning);
+
+        protected override bool AllowFail => true;
+
+        protected override Player CreatePlayer(Ruleset ruleset) => new PausePlayer();
+
+        protected class PausePlayer : Player
+        {
+            public new GameplayClockContainer GameplayClockContainer => base.GameplayClockContainer;
+
+            public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
+
+            public new HUDOverlay HUDOverlay => base.HUDOverlay;
+
+            public bool FailOverlayVisible => FailOverlay.State == Visibility.Visible;
+
+            public bool PauseOverlayVisible => PauseOverlay.State == Visibility.Visible;
+
+            public PausePlayer()
+            {
+                PauseOnFocusLost = false;
+            }
+        }
+    }
+}

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

@@ -9,20 +9,16 @@ using osu.Game.Beatmaps;
 using osu.Game.Screens;
 using osu.Game.Screens.Play;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     public class TestCasePlayerLoader : ManualInputManagerTestCase
     {
         private PlayerLoader loader;
-        private readonly ScreenStack stack;
-
-        [Cached]
-        private BackgroundScreenStack backgroundStack;
+        private readonly OsuScreenStack stack;
 
         public TestCasePlayerLoader()
         {
-            InputManager.Add(backgroundStack = new BackgroundScreenStack { RelativeSizeAxes = Axes.Both });
-            InputManager.Add(stack = new ScreenStack { RelativeSizeAxes = Axes.Both });
+            InputManager.Add(stack = new OsuScreenStack { RelativeSizeAxes = Axes.Both });
         }
 
         [BackgroundDependencyLoader]
@@ -30,12 +26,7 @@ namespace osu.Game.Tests.Visual
         {
             Beatmap.Value = new DummyWorkingBeatmap(game);
 
-            AddStep("load dummy beatmap", () => stack.Push(loader = new PlayerLoader(() => new Player
-            {
-                AllowPause = false,
-                AllowLeadIn = false,
-                AllowResults = false,
-            })));
+            AddStep("load dummy beatmap", () => stack.Push(loader = new PlayerLoader(() => new Player(false, false))));
 
             AddUntilStep("wait for current", () => loader.IsCurrentScreen());
 
@@ -51,12 +42,7 @@ namespace osu.Game.Tests.Visual
             {
                 SlowLoadPlayer slow = null;
 
-                stack.Push(loader = new PlayerLoader(() => slow = new SlowLoadPlayer
-                {
-                    AllowPause = false,
-                    AllowLeadIn = false,
-                    AllowResults = false,
-                }));
+                stack.Push(loader = new PlayerLoader(() => slow = new SlowLoadPlayer(false, false)));
 
                 Scheduler.AddDelayed(() => slow.Ready = true, 5000);
             });
@@ -68,6 +54,11 @@ namespace osu.Game.Tests.Visual
         {
             public bool Ready;
 
+            public SlowLoadPlayer(bool allowPause = true, bool showResults = true)
+                : base(allowPause, showResults)
+            {
+            }
+
             [BackgroundDependencyLoader]
             private void load()
             {

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

@@ -8,7 +8,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets;
 using osu.Game.Screens.Play;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     public class TestCasePlayerReferenceLeaking : AllPlayersTestCase
     {

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

@@ -8,7 +8,7 @@ using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     [Description("Player instantiated with a replay.")]
     public class TestCaseReplay : AllPlayersTestCase