diff --git a/osu-framework b/osu-framework
index b28d4ba82a..10cae790c6 160000
--- a/osu-framework
+++ b/osu-framework
@@ -1 +1 @@
-Subproject commit b28d4ba82af0138d38ff8b3f4f3392d9d9068da9
+Subproject commit 10cae790c6f1d559c326f9438958d0b012d61dc6
diff --git a/osu-resources b/osu-resources
index 4287ee8043..e01f71160f 160000
--- a/osu-resources
+++ b/osu-resources
@@ -1 +1 @@
-Subproject commit 4287ee8043fb1419017359bc3a5db5dc06bc643f
+Subproject commit e01f71160fb9b3167efcd177c7d7dba9e5d36604
diff --git a/osu.Desktop/Overlays/VersionManager.cs b/osu.Desktop/Overlays/VersionManager.cs
index 9e13003c3f..c46b0e3d12 100644
--- a/osu.Desktop/Overlays/VersionManager.cs
+++ b/osu.Desktop/Overlays/VersionManager.cs
@@ -110,7 +110,7 @@ namespace osu.Desktop.Overlays
 
                 // only show a notification if we've previously saved a version to the config file (ie. not the first run).
                 if (!string.IsNullOrEmpty(lastVersion))
-                    Scheduler.AddDelayed(() => notificationOverlay.Post(new UpdateCompleteNotification(version)), 5000);
+                    notificationOverlay.Post(new UpdateCompleteNotification(version));
             }
         }
 
diff --git a/osu.Game.Rulesets.Taiko/Audio/DrumSampleMapping.cs b/osu.Game.Rulesets.Taiko/Audio/DrumSampleMapping.cs
index 9d0037b97a..982b339d3a 100644
--- a/osu.Game.Rulesets.Taiko/Audio/DrumSampleMapping.cs
+++ b/osu.Game.Rulesets.Taiko/Audio/DrumSampleMapping.cs
@@ -2,7 +2,6 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Collections.Generic;
-using System.Linq;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Game.Audio;
@@ -13,7 +12,7 @@ namespace osu.Game.Rulesets.Taiko.Audio
     public class DrumSampleMapping
     {
         private readonly ControlPointInfo controlPoints;
-        private readonly Dictionary<SampleControlPoint, DrumSample> mappings = new Dictionary<SampleControlPoint, DrumSample>();
+        private readonly Dictionary<double, DrumSample> mappings = new Dictionary<double, DrumSample>();
 
         public DrumSampleMapping(ControlPointInfo controlPoints, AudioManager audio)
         {
@@ -26,17 +25,17 @@ namespace osu.Game.Rulesets.Taiko.Audio
             else
                 samplePoints = controlPoints.SamplePoints;
 
-            foreach (var s in samplePoints.Distinct())
+            foreach (var s in samplePoints)
             {
-                mappings[s] = new DrumSample
+                mappings[s.Time] = new DrumSample
                 {
-                    Centre = s.GetSampleInfo().GetChannel(audio.Sample),
-                    Rim = s.GetSampleInfo(SampleInfo.HIT_CLAP).GetChannel(audio.Sample)
+                    Centre = s.GetSampleInfo().GetChannel(audio.Sample, "Taiko"),
+                    Rim = s.GetSampleInfo(SampleInfo.HIT_CLAP).GetChannel(audio.Sample, "Taiko")
                 };
             }
         }
 
-        public DrumSample SampleAt(double time) => mappings[controlPoints.SamplePointAt(time)];
+        public DrumSample SampleAt(double time) => mappings[controlPoints.SamplePointAt(time).Time];
 
         public class DrumSample
         {
diff --git a/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs b/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs
index 92da3fe09e..cc7dd2fa0f 100644
--- a/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs
+++ b/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs
@@ -41,6 +41,8 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         // Normal and clap samples are handled by the drum
         protected override IEnumerable<SampleInfo> GetSamples() => HitObject.Samples.Where(s => s.Name != SampleInfo.HIT_NORMAL && s.Name != SampleInfo.HIT_CLAP);
 
+        protected override string SampleNamespace => "Taiko";
+
         protected virtual TaikoPiece CreateMainPiece() => new CirclePiece();
 
         public abstract bool OnPressed(TaikoAction action);
diff --git a/osu.Game.Rulesets.Taiko/Objects/DrumRoll.cs b/osu.Game.Rulesets.Taiko/Objects/DrumRoll.cs
index 5a566fd091..a39d627cc4 100644
--- a/osu.Game.Rulesets.Taiko/Objects/DrumRoll.cs
+++ b/osu.Game.Rulesets.Taiko/Objects/DrumRoll.cs
@@ -3,9 +3,6 @@
 
 using osu.Game.Rulesets.Objects.Types;
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 
@@ -75,13 +72,7 @@ namespace osu.Game.Rulesets.Taiko.Objects
                     FirstTick = first,
                     TickSpacing = tickSpacing,
                     StartTime = t,
-                    IsStrong = IsStrong,
-                    Samples = new List<SampleInfo>(Samples.Select(s => new SampleInfo
-                    {
-                        Bank = s.Bank,
-                        Name = @"slidertick",
-                        Volume = s.Volume
-                    }))
+                    IsStrong = IsStrong
                 });
 
                 first = false;
diff --git a/osu.Game.Rulesets.Taiko/Replays/TaikoAutoGenerator.cs b/osu.Game.Rulesets.Taiko/Replays/TaikoAutoGenerator.cs
index df1a19267f..c43899ebf1 100644
--- a/osu.Game.Rulesets.Taiko/Replays/TaikoAutoGenerator.cs
+++ b/osu.Game.Rulesets.Taiko/Replays/TaikoAutoGenerator.cs
@@ -86,7 +86,7 @@ namespace osu.Game.Rulesets.Taiko.Replays
                 {
                     foreach (var tick in drumRoll.NestedHitObjects.OfType<DrumRollTick>())
                     {
-                        Frames.Add(new ReplayFrame(tick.StartTime, null, null, hitButton ? ReplayButtonState.Left1 : ReplayButtonState.Left2));
+                        Frames.Add(new ReplayFrame(tick.StartTime, null, null, hitButton ? ReplayButtonState.Right1 : ReplayButtonState.Right2));
                         hitButton = !hitButton;
                     }
                 }
diff --git a/osu.Game.Rulesets.Taiko/Tests/TestCaseInputDrum.cs b/osu.Game.Rulesets.Taiko/Tests/TestCaseInputDrum.cs
new file mode 100644
index 0000000000..172c6e9d84
--- /dev/null
+++ b/osu.Game.Rulesets.Taiko/Tests/TestCaseInputDrum.cs
@@ -0,0 +1,44 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using OpenTK;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Audio;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Taiko.Audio;
+using osu.Game.Rulesets.Taiko.UI;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Taiko.Tests
+{
+    [Ignore("getting CI working")]
+    public class TestCaseInputDrum : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(InputDrum),
+            typeof(DrumSampleMapping),
+            typeof(SampleInfo),
+            typeof(SampleControlPoint)
+        };
+
+        public TestCaseInputDrum()
+        {
+            Add(new TaikoInputManager(new RulesetInfo { ID = 1 })
+            {
+                RelativeSizeAxes = Axes.Both,
+                Child = new Container
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(200),
+                    Child = new InputDrum(new ControlPointInfo())
+                }
+            });
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Taiko/UI/InputDrum.cs b/osu.Game.Rulesets.Taiko/UI/InputDrum.cs
index bf1274256b..9b2ea095d2 100644
--- a/osu.Game.Rulesets.Taiko/UI/InputDrum.cs
+++ b/osu.Game.Rulesets.Taiko/UI/InputDrum.cs
@@ -152,14 +152,14 @@ namespace osu.Game.Rulesets.Taiko.UI
                     target = centreHit;
                     back = centre;
 
-                    drumSample.Centre.Play();
+                    drumSample.Centre?.Play();
                 }
                 else if (action == RimAction)
                 {
                     target = rimHit;
                     back = rim;
 
-                    drumSample.Rim.Play();
+                    drumSample.Rim?.Play();
                 }
 
                 if (target != null)
diff --git a/osu.Game.Rulesets.Taiko/osu.Game.Rulesets.Taiko.csproj b/osu.Game.Rulesets.Taiko/osu.Game.Rulesets.Taiko.csproj
index f73831a952..7e44e85e52 100644
--- a/osu.Game.Rulesets.Taiko/osu.Game.Rulesets.Taiko.csproj
+++ b/osu.Game.Rulesets.Taiko/osu.Game.Rulesets.Taiko.csproj
@@ -83,6 +83,7 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Scoring\TaikoScoreProcessor.cs" />
     <Compile Include="TaikoInputManager.cs" />
+    <Compile Include="Tests\TestCaseInputDrum.cs" />
     <Compile Include="Tests\TestCasePerformancePoints.cs" />
     <Compile Include="Tests\TestCaseTaikoPlayfield.cs" />
     <Compile Include="UI\HitTarget.cs" />
diff --git a/osu.Game.Tests/Visual/TestCaseNotificationOverlay.cs b/osu.Game.Tests/Visual/TestCaseNotificationOverlay.cs
index a83cead213..46deca073f 100644
--- a/osu.Game.Tests/Visual/TestCaseNotificationOverlay.cs
+++ b/osu.Game.Tests/Visual/TestCaseNotificationOverlay.cs
@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.MathUtils;
 using osu.Game.Overlays;
@@ -19,11 +20,12 @@ namespace osu.Game.Tests.Visual
 
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
-            typeof(Notification),
+            typeof(NotificationSection),
+            typeof(SimpleNotification),
             typeof(ProgressNotification),
             typeof(ProgressCompletionNotification),
-            typeof(SimpleNotification),
             typeof(IHasCompletionTarget),
+            typeof(Notification)
         };
 
         public TestCaseNotificationOverlay()
@@ -40,17 +42,44 @@ namespace osu.Game.Tests.Visual
 
             Content.Add(displayedCount);
 
+            void setState(Visibility state) => AddStep(state.ToString(), () => manager.State = state);
+            void checkProgressingCount(int expected) => AddAssert($"progressing count is {expected}", () => progressingNotifications.Count == expected);
+
             manager.UnreadCount.ValueChanged += count => { displayedCount.Text = $"displayed count: {count}"; };
 
-            AddStep(@"toggle", manager.ToggleVisibility);
+
+            setState(Visibility.Visible);
             AddStep(@"simple #1", sendHelloNotification);
             AddStep(@"simple #2", sendAmazingNotification);
             AddStep(@"progress #1", sendUploadProgress);
             AddStep(@"progress #2", sendDownloadProgress);
-            AddStep(@"barrage", () => sendBarrage());
+
+            checkProgressingCount(2);
+
+            setState(Visibility.Hidden);
+
+            AddRepeatStep(@"add many simple", sendManyNotifications, 3);
+            AddWaitStep(5);
+
+            checkProgressingCount(0);
+
+            AddStep(@"progress #3", sendUploadProgress);
+
+            checkProgressingCount(1);
+
+            AddAssert("Displayed count is 33", () => manager.UnreadCount.Value == 33);
+
+            AddWaitStep(10);
+
+            checkProgressingCount(0);
+
+
+            setState(Visibility.Visible);
+
+            //AddStep(@"barrage", () => sendBarrage());
         }
 
-        private void sendBarrage(int remaining = 100)
+        private void sendBarrage(int remaining = 10)
         {
             switch (RNG.Next(0, 4))
             {
@@ -80,7 +109,7 @@ namespace osu.Game.Tests.Visual
 
             if (progressingNotifications.Count(n => n.State == ProgressNotificationState.Active) < 3)
             {
-                var p = progressingNotifications.FirstOrDefault(n => n.IsAlive && n.State == ProgressNotificationState.Queued);
+                var p = progressingNotifications.FirstOrDefault(n => n.State == ProgressNotificationState.Queued);
                 if (p != null)
                     p.State = ProgressNotificationState.Active;
             }
@@ -88,7 +117,7 @@ namespace osu.Game.Tests.Visual
             foreach (var n in progressingNotifications.FindAll(n => n.State == ProgressNotificationState.Active))
             {
                 if (n.Progress < 1)
-                    n.Progress += (float)(Time.Elapsed / 2000) * RNG.NextSingle();
+                    n.Progress += (float)(Time.Elapsed / 400) * RNG.NextSingle();
                 else
                     n.State = ProgressNotificationState.Completed;
             }
@@ -125,5 +154,11 @@ namespace osu.Game.Tests.Visual
         {
             manager.Post(new SimpleNotification { Text = @"Welcome to osu!. Enjoy your stay!" });
         }
+
+        private void sendManyNotifications()
+        {
+            for (int i = 0; i < 10; i++)
+                manager.Post(new SimpleNotification { Text = @"Spam incoming!!" });
+        }
     }
 }
diff --git a/osu.Game/Audio/SampleInfo.cs b/osu.Game/Audio/SampleInfo.cs
index 64a9aa50a0..9597acd902 100644
--- a/osu.Game/Audio/SampleInfo.cs
+++ b/osu.Game/Audio/SampleInfo.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using System.IO;
 using osu.Framework.Audio.Sample;
 
 namespace osu.Game.Audio
@@ -14,10 +15,20 @@ namespace osu.Game.Audio
         public const string HIT_NORMAL = @"hitnormal";
         public const string HIT_CLAP = @"hitclap";
 
-        public SampleChannel GetChannel(SampleManager manager)
+        public SampleChannel GetChannel(SampleManager manager, string resourceNamespace = null)
         {
-            var channel = manager.Get($"Gameplay/{Bank}-{Name}");
-            channel.Volume.Value = Volume / 100.0;
+            SampleChannel channel = null;
+
+            if (resourceNamespace != null)
+                channel = manager.Get(Path.Combine("Gameplay", resourceNamespace, $"{Bank}-{Name}"));
+
+            // try without namespace as a fallback.
+            if (channel == null)
+                channel = manager.Get(Path.Combine("Gameplay", $"{Bank}-{Name}"));
+
+            if (channel != null)
+                channel.Volume.Value = Volume / 100.0;
+
             return channel;
         }
 
diff --git a/osu.Game/Beatmaps/ControlPoints/SampleControlPoint.cs b/osu.Game/Beatmaps/ControlPoints/SampleControlPoint.cs
index 40e45da13c..c2c13e1909 100644
--- a/osu.Game/Beatmaps/ControlPoints/SampleControlPoint.cs
+++ b/osu.Game/Beatmaps/ControlPoints/SampleControlPoint.cs
@@ -17,7 +17,7 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// <summary>
         /// The default sample volume at this control point.
         /// </summary>
-        public int SampleVolume;
+        public int SampleVolume = 100;
 
         /// <summary>
         /// Create a SampleInfo based on the sample settings in this control point.
diff --git a/osu.Game/OsuGame.cs b/osu.Game/OsuGame.cs
index 1dc4c487f3..9c852a189a 100644
--- a/osu.Game/OsuGame.cs
+++ b/osu.Game/OsuGame.cs
@@ -65,6 +65,8 @@ namespace osu.Game
 
         public float ToolbarOffset => Toolbar.Position.Y + Toolbar.DrawHeight;
 
+        public readonly BindableBool ShowOverlays = new BindableBool();
+
         private OsuScreen screenStack;
 
         private VolumeControl volume;
@@ -280,6 +282,21 @@ namespace osu.Game
             settings.StateChanged += _ => updateScreenOffset();
             notifications.StateChanged += _ => updateScreenOffset();
 
+            notifications.Enabled.BindTo(ShowOverlays);
+
+            ShowOverlays.ValueChanged += visible =>
+            {
+                //central game screen change logic.
+                if (!visible)
+                {
+                    hideAllOverlays();
+                    musicController.State = Visibility.Hidden;
+                    Toolbar.State = Visibility.Hidden;
+                }
+                else
+                    Toolbar.State = Visibility.Visible;
+            };
+
             Cursor.State = Visibility.Hidden;
         }
 
@@ -361,8 +378,6 @@ namespace osu.Game
 
         public bool OnReleased(GlobalAction action) => false;
 
-        public event Action<Screen> ScreenChanged;
-
         private Container mainContent;
 
         private Container overlayContent;
@@ -380,29 +395,6 @@ namespace osu.Game
             notifications.State = Visibility.Hidden;
         }
 
-        private void screenChanged(Screen newScreen)
-        {
-            currentScreen = newScreen as OsuScreen;
-
-            if (currentScreen == null)
-            {
-                Exit();
-                return;
-            }
-
-            //central game screen change logic.
-            if (!currentScreen.ShowOverlays)
-            {
-                hideAllOverlays();
-                musicController.State = Visibility.Hidden;
-                Toolbar.State = Visibility.Hidden;
-            }
-            else
-                Toolbar.State = Visibility.Visible;
-
-            ScreenChanged?.Invoke(newScreen);
-        }
-
         protected override bool OnExiting()
         {
             if (screenStack.ChildScreen == null) return false;
@@ -450,13 +442,12 @@ namespace osu.Game
         {
             newScreen.ModePushed += screenAdded;
             newScreen.Exited += screenRemoved;
-
-            screenChanged(newScreen);
         }
 
         private void screenRemoved(Screen newScreen)
         {
-            screenChanged(newScreen);
+            if (newScreen == null)
+                Exit();
         }
     }
 }
diff --git a/osu.Game/Overlays/NotificationOverlay.cs b/osu.Game/Overlays/NotificationOverlay.cs
index 2f1c3285ef..5744e8c189 100644
--- a/osu.Game/Overlays/NotificationOverlay.cs
+++ b/osu.Game/Overlays/NotificationOverlay.cs
@@ -2,7 +2,6 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Linq;
-using osu.Framework.Allocation;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -11,7 +10,9 @@ using OpenTK.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics.Containers;
 using System;
+using osu.Framework.Allocation;
 using osu.Framework.Configuration;
+using osu.Framework.Threading;
 
 namespace osu.Game.Overlays
 {
@@ -21,6 +22,11 @@ namespace osu.Game.Overlays
 
         public const float TRANSITION_LENGTH = 600;
 
+        /// <summary>
+        /// Whether posted notifications should be processed.
+        /// </summary>
+        public readonly BindableBool Enabled = new BindableBool(true);
+
         private FlowContainer<NotificationSection> sections;
 
         /// <summary>
@@ -28,6 +34,27 @@ namespace osu.Game.Overlays
         /// </summary>
         public Func<float> GetToolbarHeight;
 
+        public NotificationOverlay()
+        {
+            ScheduledDelegate notificationsEnabler = null;
+            Enabled.ValueChanged += v =>
+            {
+                if (!IsLoaded)
+                {
+                    processingPosts = v;
+                    return;
+                }
+
+                notificationsEnabler?.Cancel();
+
+                if (v)
+                    // we want a slight delay before toggling notifications on to avoid the user becoming overwhelmed.
+                    notificationsEnabler = Scheduler.AddDelayed(() => processingPosts = true, 1000);
+                else
+                    processingPosts = false;
+            };
+        }
+
         [BackgroundDependencyLoader]
         private void load()
         {
@@ -85,14 +112,21 @@ namespace osu.Game.Overlays
 
         private void notificationClosed()
         {
-            // hide ourselves if all notifications have been dismissed.
-            if (totalCount == 0)
-                State = Visibility.Hidden;
+            Schedule(() =>
+            {
+                // hide ourselves if all notifications have been dismissed.
+                if (totalCount == 0)
+                    State = Visibility.Hidden;
+            });
 
             updateCounts();
         }
 
-        public void Post(Notification notification) => Schedule(() =>
+        private readonly Scheduler postScheduler = new Scheduler();
+
+        private bool processingPosts = true;
+
+        public void Post(Notification notification) => postScheduler.Add(() =>
         {
             ++runningDepth;
             notification.Depth = notification.DisplayOnTop ? runningDepth : -runningDepth;
@@ -109,6 +143,13 @@ namespace osu.Game.Overlays
             updateCounts();
         });
 
+        protected override void Update()
+        {
+            base.Update();
+            if (processingPosts)
+                postScheduler.Update();
+        }
+
         protected override void PopIn()
         {
             base.PopIn();
diff --git a/osu.Game/Overlays/Notifications/NotificationSection.cs b/osu.Game/Overlays/Notifications/NotificationSection.cs
index 2bd0321d12..42fcc3aa0f 100644
--- a/osu.Game/Overlays/Notifications/NotificationSection.cs
+++ b/osu.Game/Overlays/Notifications/NotificationSection.cs
@@ -15,7 +15,7 @@ using osu.Game.Graphics.Containers;
 
 namespace osu.Game.Overlays.Notifications
 {
-    public class NotificationSection : FillFlowContainer
+    public class NotificationSection : AlwaysUpdateFillFlowContainer<Drawable>
     {
         private OsuSpriteText titleText;
         private OsuSpriteText countText;
@@ -33,6 +33,7 @@ namespace osu.Game.Overlays.Notifications
         public IEnumerable<Type> AcceptTypes;
 
         private string clearText;
+
         public string ClearText
         {
             get { return clearText; }
@@ -110,7 +111,7 @@ namespace osu.Game.Overlays.Notifications
                         },
                     },
                 },
-                notifications = new FillFlowContainer<Notification>
+                notifications = new AlwaysUpdateFillFlowContainer<Notification>
                 {
                     AutoSizeAxes = Axes.Y,
                     RelativeSizeAxes = Axes.X,
@@ -159,4 +160,13 @@ namespace osu.Game.Overlays.Notifications
             notifications?.Children.ForEach(n => n.Read = true);
         }
     }
+
+    public class AlwaysUpdateFillFlowContainer<T> : FillFlowContainer<T>
+        where T : Drawable
+    {
+        // this is required to ensure correct layout and scheduling on children.
+        // the layout portion of this is being tracked as a framework issue (https://github.com/ppy/osu-framework/issues/1297).
+        protected override bool RequiresChildrenUpdate => true;
+    }
+
 }
diff --git a/osu.Game/Overlays/Notifications/ProgressNotification.cs b/osu.Game/Overlays/Notifications/ProgressNotification.cs
index c39c630858..d797372390 100644
--- a/osu.Game/Overlays/Notifications/ProgressNotification.cs
+++ b/osu.Game/Overlays/Notifications/ProgressNotification.cs
@@ -95,8 +95,8 @@ namespace osu.Game.Overlays.Notifications
 
         protected virtual void Completed()
         {
-            base.Close();
             CompletionTarget?.Invoke(CreateCompletionNotification());
+            base.Close();
         }
 
         public override bool DisplayOnTop => false;
diff --git a/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs b/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
index ab4c04be3f..c118cd5bee 100644
--- a/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
+++ b/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
@@ -74,6 +74,9 @@ namespace osu.Game.Rulesets.Objects.Drawables
         protected List<SampleChannel> Samples = new List<SampleChannel>();
         protected virtual IEnumerable<SampleInfo> GetSamples() => HitObject.Samples;
 
+        // Todo: Rulesets should be overriding the resources instead, but we need to figure out where/when to apply overrides first
+        protected virtual string SampleNamespace => null;
+
         public readonly Bindable<ArmedState> State = new Bindable<ArmedState>();
 
         protected DrawableHitObject(TObject hitObject)
@@ -101,7 +104,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
                         Volume = s.Volume > 0 ? s.Volume : HitObject.SampleControlPoint.SampleVolume
                     };
 
-                    SampleChannel channel = localSampleInfo.GetChannel(audio.Sample);
+                    SampleChannel channel = localSampleInfo.GetChannel(audio.Sample, SampleNamespace);
 
                     if (channel == null)
                         continue;
diff --git a/osu.Game/Screens/Edit/Editor.cs b/osu.Game/Screens/Edit/Editor.cs
index 19d00f3477..76f51d1c33 100644
--- a/osu.Game/Screens/Edit/Editor.cs
+++ b/osu.Game/Screens/Edit/Editor.cs
@@ -24,7 +24,7 @@ namespace osu.Game.Screens.Edit
     {
         protected override BackgroundScreen CreateBackground() => new BackgroundScreenCustom(@"Backgrounds/bg4");
 
-        public override bool ShowOverlays => false;
+        public override bool ShowOverlaysOnEnter => false;
 
         private readonly Box bottomBackground;
         private readonly Container screenContainer;
diff --git a/osu.Game/Screens/Loader.cs b/osu.Game/Screens/Loader.cs
index ec2e8e0cb1..c96194f63d 100644
--- a/osu.Game/Screens/Loader.cs
+++ b/osu.Game/Screens/Loader.cs
@@ -17,7 +17,7 @@ namespace osu.Game.Screens
     {
         private bool showDisclaimer;
 
-        public override bool ShowOverlays => false;
+        public override bool ShowOverlaysOnEnter => false;
 
         public Loader()
         {
diff --git a/osu.Game/Screens/Menu/ButtonSystem.cs b/osu.Game/Screens/Menu/ButtonSystem.cs
index ce7856c5a9..c82d90d16c 100644
--- a/osu.Game/Screens/Menu/ButtonSystem.cs
+++ b/osu.Game/Screens/Menu/ButtonSystem.cs
@@ -11,12 +11,12 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input;
 using osu.Game.Graphics;
-using osu.Game.Overlays.Toolbar;
 using OpenTK;
 using OpenTK.Graphics;
 using OpenTK.Input;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Audio;
+using osu.Framework.Configuration;
 using osu.Framework.Threading;
 
 namespace osu.Game.Screens.Menu
@@ -25,6 +25,8 @@ namespace osu.Game.Screens.Menu
     {
         public event Action<MenuState> StateChanged;
 
+        private readonly BindableBool showOverlays = new BindableBool();
+
         public Action OnEdit;
         public Action OnExit;
         public Action OnDirect;
@@ -34,8 +36,6 @@ namespace osu.Game.Screens.Menu
         public Action OnChart;
         public Action OnTest;
 
-        private Toolbar toolbar;
-
         private readonly FlowContainerWithOrigin buttonFlow;
 
         //todo: make these non-internal somehow.
@@ -131,9 +131,9 @@ namespace osu.Game.Screens.Menu
         }
 
         [BackgroundDependencyLoader(true)]
-        private void load(AudioManager audio, OsuGame game = null)
+        private void load(AudioManager audio, OsuGame game)
         {
-            toolbar = game?.Toolbar;
+            if (game != null) showOverlays.BindTo(game.ShowOverlays);
             sampleBack = audio.Sample.Get(@"Menu/button-back-select");
         }
 
@@ -300,7 +300,7 @@ namespace osu.Game.Screens.Menu
 
                     logoDelayedAction = Scheduler.AddDelayed(() =>
                     {
-                        toolbar?.Hide();
+                        showOverlays.Value = false;
 
                         logo.ClearTransforms(targetMember: nameof(Position));
                         logo.RelativePositionAxes = Axes.Both;
@@ -329,7 +329,7 @@ namespace osu.Game.Screens.Menu
                                 logoTracking = true;
 
                                 logo.Impact();
-                                toolbar?.Show();
+                                showOverlays.Value = true;
                             }, 200);
                             break;
                         default:
diff --git a/osu.Game/Screens/Menu/Disclaimer.cs b/osu.Game/Screens/Menu/Disclaimer.cs
index 532ee71b72..d0ad613640 100644
--- a/osu.Game/Screens/Menu/Disclaimer.cs
+++ b/osu.Game/Screens/Menu/Disclaimer.cs
@@ -18,7 +18,7 @@ namespace osu.Game.Screens.Menu
         private readonly SpriteIcon icon;
         private Color4 iconColour;
 
-        public override bool ShowOverlays => false;
+        public override bool ShowOverlaysOnEnter => false;
 
         public override bool HasLocalCursorDisplayed => true;
 
diff --git a/osu.Game/Screens/Menu/Intro.cs b/osu.Game/Screens/Menu/Intro.cs
index d7beb34a2f..a6a1afa320 100644
--- a/osu.Game/Screens/Menu/Intro.cs
+++ b/osu.Game/Screens/Menu/Intro.cs
@@ -33,7 +33,7 @@ namespace osu.Game.Screens.Menu
 
         public override bool HasLocalCursorDisplayed => true;
 
-        public override bool ShowOverlays => false;
+        public override bool ShowOverlaysOnEnter => false;
 
         protected override BackgroundScreen CreateBackground() => new BackgroundScreenEmpty();
 
diff --git a/osu.Game/Screens/Menu/MainMenu.cs b/osu.Game/Screens/Menu/MainMenu.cs
index 90f68ba9f1..fac0ec1422 100644
--- a/osu.Game/Screens/Menu/MainMenu.cs
+++ b/osu.Game/Screens/Menu/MainMenu.cs
@@ -24,7 +24,7 @@ namespace osu.Game.Screens.Menu
     {
         private readonly ButtonSystem buttons;
 
-        public override bool ShowOverlays => buttons.State != MenuState.Initial;
+        public override bool ShowOverlaysOnEnter => buttons.State != MenuState.Initial;
 
         private readonly BackgroundScreenDefault background;
         private Screen songSelect;
diff --git a/osu.Game/Screens/OsuScreen.cs b/osu.Game/Screens/OsuScreen.cs
index 4a27c7f1ea..0013d1a882 100644
--- a/osu.Game/Screens/OsuScreen.cs
+++ b/osu.Game/Screens/OsuScreen.cs
@@ -28,7 +28,12 @@ namespace osu.Game.Screens
         /// </summary>
         protected virtual BackgroundScreen CreateBackground() => null;
 
-        public virtual bool ShowOverlays => true;
+        protected BindableBool ShowOverlays = new BindableBool();
+
+        /// <summary>
+        /// Whether overlays should be shown when this screen is entered or resumed.
+        /// </summary>
+        public virtual bool ShowOverlaysOnEnter => true;
 
         protected new OsuGameBase Game => base.Game as OsuGameBase;
 
@@ -70,7 +75,10 @@ namespace osu.Game.Screens
             }
 
             if (osuGame != null)
+            {
                 Ruleset.BindTo(osuGame.Ruleset);
+                ShowOverlays.BindTo(osuGame.ShowOverlays);
+            }
 
             sampleExit = audio.Sample.Get(@"UI/screen-back");
         }
@@ -94,6 +102,8 @@ namespace osu.Game.Screens
             base.OnResuming(last);
             logo.AppendAnimatingAction(() => LogoArriving(logo, true), true);
             sampleExit?.Play();
+
+            ShowOverlays.Value = ShowOverlaysOnEnter;
         }
 
         protected override void OnSuspending(Screen next)
@@ -139,6 +149,8 @@ namespace osu.Game.Screens
             logo.AppendAnimatingAction(() => LogoArriving(logo, false), true);
 
             base.OnEntering(last);
+
+            ShowOverlays.Value = ShowOverlaysOnEnter;
         }
 
         protected override bool OnExiting(Screen next)
diff --git a/osu.Game/Screens/Play/Player.cs b/osu.Game/Screens/Play/Player.cs
index 2cbb203c37..35f39e940f 100644
--- a/osu.Game/Screens/Play/Player.cs
+++ b/osu.Game/Screens/Play/Player.cs
@@ -35,7 +35,7 @@ namespace osu.Game.Screens.Play
     {
         protected override BackgroundScreen CreateBackground() => new BackgroundScreenBeatmap(Beatmap);
 
-        public override bool ShowOverlays => false;
+        public override bool ShowOverlaysOnEnter => false;
 
         public override bool HasLocalCursorDisplayed => !pauseContainer.IsPaused && !HasFailed && RulesetContainer.ProvidingUserCursor;
 
@@ -46,6 +46,8 @@ namespace osu.Game.Screens.Play
         public bool HasFailed { get; private set; }
 
         public bool AllowPause { get; set; } = true;
+        public bool AllowLeadIn { get; set; } = true;
+        public bool AllowResults { get; set; } = true;
 
         public int RestartCount;
 
@@ -136,7 +138,10 @@ namespace osu.Game.Screens.Play
             decoupledClock = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
 
             var firstObjectTime = RulesetContainer.Objects.First().StartTime;
-            decoupledClock.Seek(Math.Min(0, firstObjectTime - Math.Max(beatmap.ControlPointInfo.TimingPointAt(firstObjectTime).BeatLength * 4, beatmap.BeatmapInfo.AudioLeadIn)));
+            decoupledClock.Seek(AllowLeadIn
+                ? Math.Min(0, firstObjectTime - Math.Max(beatmap.ControlPointInfo.TimingPointAt(firstObjectTime).BeatLength * 4, beatmap.BeatmapInfo.AudioLeadIn))
+                : firstObjectTime);
+
             decoupledClock.ProcessFrame();
 
             offsetClock = new FramedOffsetClock(decoupledClock);
@@ -273,6 +278,8 @@ namespace osu.Game.Screens.Play
 
             ValidForResume = false;
 
+            if (!AllowResults) return;
+
             using (BeginDelayedSequence(1000))
             {
                 onCompletionEvent = Schedule(delegate
diff --git a/osu.Game/Screens/Play/PlayerLoader.cs b/osu.Game/Screens/Play/PlayerLoader.cs
index a220dcee0e..15a97096e7 100644
--- a/osu.Game/Screens/Play/PlayerLoader.cs
+++ b/osu.Game/Screens/Play/PlayerLoader.cs
@@ -23,7 +23,7 @@ namespace osu.Game.Screens.Play
         private BeatmapMetadataDisplay info;
 
         private bool showOverlays = true;
-        public override bool ShowOverlays => showOverlays;
+        public override bool ShowOverlaysOnEnter => showOverlays;
 
         public override bool AllowBeatmapRulesetChange => false;
 
diff --git a/osu.Game/Screens/Select/BeatmapCarousel.cs b/osu.Game/Screens/Select/BeatmapCarousel.cs
index 9d7867659d..e877633ab3 100644
--- a/osu.Game/Screens/Select/BeatmapCarousel.cs
+++ b/osu.Game/Screens/Select/BeatmapCarousel.cs
@@ -53,6 +53,11 @@ namespace osu.Game.Screens.Select
 
         public override bool HandleInput => AllowSelection;
 
+        /// <summary>
+        /// Used to avoid firing null selections before the initial beatmaps have been loaded via <see cref="BeatmapSets"/>.
+        /// </summary>
+        private bool initialLoadComplete;
+
         private IEnumerable<CarouselBeatmapSet> beatmapSets => root.Children.OfType<CarouselBeatmapSet>();
 
         public IEnumerable<BeatmapSetInfo> BeatmapSets
@@ -76,7 +81,11 @@ namespace osu.Game.Screens.Select
                     itemsCache.Invalidate();
                     scrollPositionCache.Invalidate();
 
-                    Schedule(() => BeatmapSetsChanged?.Invoke());
+                    Schedule(() =>
+                    {
+                        BeatmapSetsChanged?.Invoke();
+                        initialLoadComplete = true;
+                    });
                 }));
             }
         }
@@ -513,7 +522,7 @@ namespace osu.Game.Screens.Select
             currentY += DrawHeight / 2;
             scrollableContent.Height = currentY;
 
-            if (selectedBeatmapSet == null || selectedBeatmap == null || selectedBeatmapSet.State.Value != CarouselItemState.Selected)
+            if (initialLoadComplete && (selectedBeatmapSet == null || selectedBeatmap == null || selectedBeatmapSet.State.Value != CarouselItemState.Selected))
             {
                 selectedBeatmapSet = null;
                 SelectionChanged?.Invoke(null);
diff --git a/osu.Game/Screens/Select/BeatmapInfoWedge.cs b/osu.Game/Screens/Select/BeatmapInfoWedge.cs
index fa1326de8c..729cb458c2 100644
--- a/osu.Game/Screens/Select/BeatmapInfoWedge.cs
+++ b/osu.Game/Screens/Select/BeatmapInfoWedge.cs
@@ -71,10 +71,6 @@ namespace osu.Game.Screens.Select
             {
                 State = beatmap == null ? Visibility.Hidden : Visibility.Visible;
 
-                // ensure we ourselves are visible if not already.
-                if (!IsPresent)
-                    State = Visibility.Visible;
-
                 Info?.FadeOut(250);
                 Info?.Expire();
 
diff --git a/osu.Game/Screens/Tournament/Drawings.cs b/osu.Game/Screens/Tournament/Drawings.cs
index 3e7ab56c99..fbf24eb609 100644
--- a/osu.Game/Screens/Tournament/Drawings.cs
+++ b/osu.Game/Screens/Tournament/Drawings.cs
@@ -29,7 +29,7 @@ namespace osu.Game.Screens.Tournament
     {
         private const string results_filename = "drawings_results.txt";
 
-        public override bool ShowOverlays => false;
+        public override bool ShowOverlaysOnEnter => false;
 
         protected override BackgroundScreen CreateBackground() => new BackgroundScreenDefault();
 
diff --git a/osu.Game/Tests/Beatmaps/TestWorkingBeatmap.cs b/osu.Game/Tests/Beatmaps/TestWorkingBeatmap.cs
index da139775b1..82248c2cb8 100644
--- a/osu.Game/Tests/Beatmaps/TestWorkingBeatmap.cs
+++ b/osu.Game/Tests/Beatmaps/TestWorkingBeatmap.cs
@@ -19,6 +19,6 @@ namespace osu.Game.Tests.Beatmaps
 
         protected override Beatmap GetBeatmap() => beatmap;
         protected override Texture GetBackground() => null;
-        protected override Track GetTrack() => null;
+        protected override Track GetTrack() => new TrackVirtual();
     }
 }
diff --git a/osu.Game/Tests/Visual/TestCasePlayer.cs b/osu.Game/Tests/Visual/TestCasePlayer.cs
index 106f0fa8f3..933781890f 100644
--- a/osu.Game/Tests/Visual/TestCasePlayer.cs
+++ b/osu.Game/Tests/Visual/TestCasePlayer.cs
@@ -22,6 +22,8 @@ namespace osu.Game.Tests.Visual
 
         protected Player Player;
 
+        private TestWorkingBeatmap working;
+
         /// <summary>
         /// Create a TestCase which runs through the Player screen.
         /// </summary>
@@ -75,7 +77,7 @@ namespace osu.Game.Tests.Visual
 
             var instance = r.CreateInstance();
 
-            WorkingBeatmap working = new TestWorkingBeatmap(beatmap);
+            working = new TestWorkingBeatmap(beatmap);
             working.Mods.Value = new[] { instance.GetAllMods().First(m => m is ModNoFail) };
 
             if (Player != null)
@@ -88,10 +90,21 @@ namespace osu.Game.Tests.Visual
             return player;
         }
 
+        protected override void Update()
+        {
+            base.Update();
+
+            if (working != null)
+                // note that this will override any mod rate application
+                working.Track.Rate = Clock.Rate;
+        }
+
         protected virtual Player CreatePlayer(WorkingBeatmap beatmap, Ruleset ruleset) => new Player
         {
             InitialBeatmap = beatmap,
-            AllowPause = false
+            AllowPause = false,
+            AllowLeadIn = false,
+            AllowResults = false,
         };
 
         private const string test_beatmap_data =