Merge branch 'master' into match-songselect-playlist-logic

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

@@ -7,7 +7,9 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Testing.Input;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Osu.UI.Cursor;
+using osu.Game.Screens.Play;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
@@ -21,12 +23,50 @@ namespace osu.Game.Rulesets.Osu.Tests
             typeof(CursorTrail)
         };
 
-        [BackgroundDependencyLoader]
+        [Cached]
-        private void load()
+        private GameplayBeatmap gameplayBeatmap;
+
+        private ClickingCursorContainer lastContainer;
+
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
+        public TestSceneGameplayCursor()
+        {
+            gameplayBeatmap = new GameplayBeatmap(CreateBeatmap(new OsuRuleset().RulesetInfo));
+        }
+
+        [TestCase(1, 1)]
+        [TestCase(5, 1)]
+        [TestCase(10, 1)]
+        [TestCase(1, 1.5f)]
+        [TestCase(5, 1.5f)]
+        [TestCase(10, 1.5f)]
+        public void TestSizing(int circleSize, float userScale)
+        {
+            AddStep($"set user scale to {userScale}", () => config.Set(OsuSetting.GameplayCursorSize, userScale));
+            AddStep($"adjust cs to {circleSize}", () => gameplayBeatmap.BeatmapInfo.BaseDifficulty.CircleSize = circleSize);
+            AddStep("turn on autosizing", () => config.Set(OsuSetting.AutoCursorSize, true));
+
+            AddStep("load content", loadContent);
+
+            AddUntilStep("cursor size correct", () => lastContainer.ActiveCursor.Scale.X == OsuCursorContainer.GetScaleForCircleSize(circleSize) * userScale);
+
+            AddStep("set user scale to 1", () => config.Set(OsuSetting.GameplayCursorSize, 1f));
+            AddUntilStep("cursor size correct", () => lastContainer.ActiveCursor.Scale.X == OsuCursorContainer.GetScaleForCircleSize(circleSize));
+
+            AddStep("turn off autosizing", () => config.Set(OsuSetting.AutoCursorSize, false));
+            AddUntilStep("cursor size correct", () => lastContainer.ActiveCursor.Scale.X == 1);
+
+            AddStep($"set user scale to {userScale}", () => config.Set(OsuSetting.GameplayCursorSize, userScale));
+            AddUntilStep("cursor size correct", () => lastContainer.ActiveCursor.Scale.X == userScale);
+        }
+
+        private void loadContent()
         {
             SetContents(() => new MovingCursorInputManager
             {
-                Child = new ClickingCursorContainer
+                Child = lastContainer = new ClickingCursorContainer
                 {
                     RelativeSizeAxes = Axes.Both,
                     Masking = true,

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

@@ -9,6 +9,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.UI;
 using static osu.Game.Input.Handlers.ReplayInputHandler;
 
@@ -19,69 +20,18 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Description => @"You don't need to click. Give your clicking/tapping fingers a break from the heat of things.";
         public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(OsuModAutopilot)).ToArray();
 
-        public void Update(Playfield playfield)
+        /// <summary>
-        {
+        /// How early before a hitobject's start time to trigger a hit.
-            bool requiresHold = false;
+        /// </summary>
-            bool requiresHit = false;
+        private const float relax_leniency = 3;
 
-            const float relax_leniency = 3;
+        private bool isDownState;
-
-            foreach (var drawable in playfield.HitObjectContainer.AliveObjects)
-            {
-                if (!(drawable is DrawableOsuHitObject osuHit))
-                    continue;
-
-                double time = osuHit.Clock.CurrentTime;
-                double relativetime = time - osuHit.HitObject.StartTime;
-
-                if (time < osuHit.HitObject.StartTime - relax_leniency) continue;
-
-                if ((osuHit.HitObject is IHasEndTime hasEnd && time > hasEnd.EndTime) || osuHit.IsHit)
-                    continue;
-
-                if (osuHit is DrawableHitCircle && osuHit.IsHovered)
-                {
-                    Debug.Assert(osuHit.HitObject.HitWindows != null);
-                    requiresHit |= osuHit.HitObject.HitWindows.CanBeHit(relativetime);
-                }
-
-                requiresHold |= (osuHit is DrawableSlider slider && (slider.Ball.IsHovered || osuHit.IsHovered)) || osuHit is DrawableSpinner;
-            }
-
-            if (requiresHit)
-            {
-                addAction(false);
-                addAction(true);
-            }
-
-            addAction(requiresHold);
-        }
-
-        private bool wasHit;
         private bool wasLeft;
 
         private OsuInputManager osuInputManager;
 
-        private void addAction(bool hitting)
+        private ReplayState<OsuAction> state;
-        {
+        private double lastStateChangeTime;
-            if (wasHit == hitting)
-                return;
-
-            wasHit = hitting;
-
-            var state = new ReplayState<OsuAction>
-            {
-                PressedActions = new List<OsuAction>()
-            };
-
-            if (hitting)
-            {
-                state.PressedActions.Add(wasLeft ? OsuAction.LeftButton : OsuAction.RightButton);
-                wasLeft = !wasLeft;
-            }
-
-            state.Apply(osuInputManager.CurrentState, osuInputManager);
-        }
 
         public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
         {
@@ -89,5 +39,85 @@ namespace osu.Game.Rulesets.Osu.Mods
             osuInputManager = (OsuInputManager)drawableRuleset.KeyBindingInputManager;
             osuInputManager.AllowUserPresses = false;
         }
+
+        public void Update(Playfield playfield)
+        {
+            bool requiresHold = false;
+            bool requiresHit = false;
+
+            double time = playfield.Clock.CurrentTime;
+
+            foreach (var h in playfield.HitObjectContainer.AliveObjects.OfType<DrawableOsuHitObject>())
+            {
+                // we are not yet close enough to the object.
+                if (time < h.HitObject.StartTime - relax_leniency)
+                    break;
+
+                // already hit or beyond the hittable end time.
+                if (h.IsHit || (h.HitObject is IHasEndTime hasEnd && time > hasEnd.EndTime))
+                    continue;
+
+                switch (h)
+                {
+                    case DrawableHitCircle circle:
+                        handleHitCircle(circle);
+                        break;
+
+                    case DrawableSlider slider:
+                        // Handles cases like "2B" beatmaps, where sliders may be overlapping and simply holding is not enough.
+                        if (!slider.HeadCircle.IsHit)
+                            handleHitCircle(slider.HeadCircle);
+
+                        requiresHold |= slider.Ball.IsHovered || h.IsHovered;
+                        break;
+
+                    case DrawableSpinner _:
+                        requiresHold = true;
+                        break;
+                }
+            }
+
+            if (requiresHit)
+            {
+                changeState(false);
+                changeState(true);
+            }
+
+            if (requiresHold)
+                changeState(true);
+            else if (isDownState && time - lastStateChangeTime > AutoGenerator.KEY_UP_DELAY)
+                changeState(false);
+
+            void handleHitCircle(DrawableHitCircle circle)
+            {
+                if (!circle.IsHovered)
+                    return;
+
+                Debug.Assert(circle.HitObject.HitWindows != null);
+                requiresHit |= circle.HitObject.HitWindows.CanBeHit(time - circle.HitObject.StartTime);
+            }
+
+            void changeState(bool down)
+            {
+                if (isDownState == down)
+                    return;
+
+                isDownState = down;
+                lastStateChangeTime = time;
+
+                state = new ReplayState<OsuAction>
+                {
+                    PressedActions = new List<OsuAction>()
+                };
+
+                if (down)
+                {
+                    state.PressedActions.Add(wasLeft ? OsuAction.LeftButton : OsuAction.RightButton);
+                    wasLeft = !wasLeft;
+                }
+
+                state?.Apply(osuInputManager.CurrentState, osuInputManager);
+            }
+        }
     }
 }

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

@@ -12,6 +12,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Osu.Configuration;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play;
 using osu.Game.Skinning;
 using osuTK;
 
@@ -29,10 +30,10 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
 
         private readonly Drawable cursorTrail;
 
-        public Bindable<float> CursorScale;
+        public Bindable<float> CursorScale = new BindableFloat(1);
+
         private Bindable<float> userCursorScale;
         private Bindable<bool> autoCursorScale;
-        private readonly IBindable<WorkingBeatmap> beatmap = new Bindable<WorkingBeatmap>();
 
         public OsuCursorContainer()
         {
@@ -43,37 +44,16 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
             };
         }
 
+        [Resolved(canBeNull: true)]
+        private GameplayBeatmap beatmap { get; set; }
+
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
         [BackgroundDependencyLoader(true)]
-        private void load(OsuConfigManager config, OsuRulesetConfigManager rulesetConfig, IBindable<WorkingBeatmap> beatmap)
+        private void load(OsuConfigManager config, OsuRulesetConfigManager rulesetConfig)
         {
             rulesetConfig?.BindWith(OsuRulesetSetting.ShowCursorTrail, showTrail);
-
-            this.beatmap.BindTo(beatmap);
-            this.beatmap.ValueChanged += _ => calculateScale();
-
-            userCursorScale = config.GetBindable<float>(OsuSetting.GameplayCursorSize);
-            userCursorScale.ValueChanged += _ => calculateScale();
-
-            autoCursorScale = config.GetBindable<bool>(OsuSetting.AutoCursorSize);
-            autoCursorScale.ValueChanged += _ => calculateScale();
-
-            CursorScale = new BindableFloat();
-            CursorScale.ValueChanged += e => ActiveCursor.Scale = cursorTrail.Scale = new Vector2(e.NewValue);
-
-            calculateScale();
-        }
-
-        private void calculateScale()
-        {
-            float scale = userCursorScale.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 *= 1f - 0.7f * (1f + beatmap.Value.BeatmapInfo.BaseDifficulty.CircleSize - BeatmapDifficulty.DEFAULT_DIFFICULTY) / BeatmapDifficulty.DEFAULT_DIFFICULTY;
-            }
-
-            CursorScale.Value = scale;
         }
 
         protected override void LoadComplete()
@@ -81,6 +61,46 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
             base.LoadComplete();
 
             showTrail.BindValueChanged(v => cursorTrail.FadeTo(v.NewValue ? 1 : 0, 200), true);
+
+            userCursorScale = config.GetBindable<float>(OsuSetting.GameplayCursorSize);
+            userCursorScale.ValueChanged += _ => calculateScale();
+
+            autoCursorScale = config.GetBindable<bool>(OsuSetting.AutoCursorSize);
+            autoCursorScale.ValueChanged += _ => calculateScale();
+
+            CursorScale.ValueChanged += e =>
+            {
+                var newScale = new Vector2(e.NewValue);
+
+                ActiveCursor.Scale = newScale;
+                cursorTrail.Scale = newScale;
+            };
+
+            calculateScale();
+        }
+
+        /// <summary>
+        /// Get the scale applicable to the ActiveCursor based on a beatmap's circle size.
+        /// </summary>
+        public static float GetScaleForCircleSize(float circleSize) =>
+            1f - 0.7f * (1f + circleSize - BeatmapDifficulty.DEFAULT_DIFFICULTY) / BeatmapDifficulty.DEFAULT_DIFFICULTY;
+
+        private void calculateScale()
+        {
+            float scale = userCursorScale.Value;
+
+            if (autoCursorScale.Value && beatmap != null)
+            {
+                // if we have a beatmap available, let's get its circle size to figure out an automatic cursor scale modifier.
+                scale *= GetScaleForCircleSize(beatmap.BeatmapInfo.BaseDifficulty.CircleSize);
+            }
+
+            CursorScale.Value = scale;
+
+            var newScale = new Vector2(scale);
+
+            ActiveCursor.ScaleTo(newScale, 400, Easing.OutQuint);
+            cursorTrail.Scale = newScale;
         }
 
         private int downCount;

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

@@ -91,9 +91,44 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddStep("load dummy beatmap", () => ResetPlayer(false));
             AddUntilStep("wait for current", () => loader.IsCurrentScreen());
-            AddRepeatStep("move mouse", () => InputManager.MoveMouseTo(loader.VisualSettings.ScreenSpaceDrawQuad.TopLeft + (loader.VisualSettings.ScreenSpaceDrawQuad.BottomRight - loader.VisualSettings.ScreenSpaceDrawQuad.TopLeft) * RNG.NextSingle()), 20);
+
+            AddUntilStep("wait for load ready", () =>
+            {
+                moveMouse();
+                return player.LoadState == LoadState.Ready;
+            });
+            AddRepeatStep("move mouse", moveMouse, 20);
+
             AddAssert("loader still active", () => loader.IsCurrentScreen());
             AddUntilStep("loads after idle", () => !loader.IsCurrentScreen());
+
+            void moveMouse()
+            {
+                InputManager.MoveMouseTo(
+                    loader.VisualSettings.ScreenSpaceDrawQuad.TopLeft
+                    + (loader.VisualSettings.ScreenSpaceDrawQuad.BottomRight - loader.VisualSettings.ScreenSpaceDrawQuad.TopLeft)
+                    * RNG.NextSingle());
+            }
+        }
+
+        [Test]
+        public void TestBlockLoadViaFocus()
+        {
+            OsuFocusedOverlayContainer overlay = null;
+
+            AddStep("load dummy beatmap", () => ResetPlayer(false));
+            AddUntilStep("wait for current", () => loader.IsCurrentScreen());
+
+            AddStep("show focused overlay", () => { container.Add(overlay = new ChangelogOverlay { State = { Value = Visibility.Visible } }); });
+            AddUntilStep("overlay visible", () => overlay.IsPresent);
+
+            AddUntilStep("wait for load ready", () => player.LoadState == LoadState.Ready);
+            AddRepeatStep("twiddle thumbs", () => { }, 20);
+
+            AddAssert("loader still active", () => loader.IsCurrentScreen());
+
+            AddStep("hide overlay", () => overlay.Hide());
+            AddUntilStep("loads after idle", () => !loader.IsCurrentScreen());
         }
 
         [Test]
@@ -159,13 +194,22 @@ namespace osu.Game.Tests.Visual.Gameplay
         }
 
         [Test]
-        public void TestMutedNotificationMasterVolume() => addVolumeSteps("master volume", () => audioManager.Volume.Value = 0, null, () => audioManager.Volume.IsDefault);
+        public void TestMutedNotificationMasterVolume()
+        {
+            addVolumeSteps("master volume", () => audioManager.Volume.Value = 0, null, () => audioManager.Volume.IsDefault);
+        }
 
         [Test]
-        public void TestMutedNotificationTrackVolume() => addVolumeSteps("music volume", () => audioManager.VolumeTrack.Value = 0, null, () => audioManager.VolumeTrack.IsDefault);
+        public void TestMutedNotificationTrackVolume()
+        {
+            addVolumeSteps("music volume", () => audioManager.VolumeTrack.Value = 0, null, () => audioManager.VolumeTrack.IsDefault);
+        }
 
         [Test]
-        public void TestMutedNotificationMuteButton() => addVolumeSteps("mute button", null, () => container.VolumeOverlay.IsMuted.Value = true, () => !container.VolumeOverlay.IsMuted.Value);
+        public void TestMutedNotificationMuteButton()
+        {
+            addVolumeSteps("mute button", null, () => container.VolumeOverlay.IsMuted.Value = true, () => !container.VolumeOverlay.IsMuted.Value);
+        }
 
         /// <remarks>
         /// Created for avoiding copy pasting code for the same steps.
@@ -179,7 +223,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("reset notification lock", () => sessionStatics.GetBindable<bool>(Static.MutedAudioNotificationShownOnce).Value = false);
 
             AddStep("load player", () => ResetPlayer(false, beforeLoad, afterLoad));
-            AddUntilStep("wait for player", () => player.IsLoaded);
+            AddUntilStep("wait for player", () => player.LoadState == LoadState.Ready);
 
             AddAssert("check for notification", () => container.NotificationOverlay.UnreadCount.Value == 1);
             AddStep("click notification", () =>
@@ -193,6 +237,8 @@ namespace osu.Game.Tests.Visual.Gameplay
             });
 
             AddAssert("check " + volumeName, assert);
+
+            AddUntilStep("wait for player load", () => player.IsLoaded);
         }
 
         private class TestPlayerLoaderContainer : Container

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

@@ -1,37 +1,25 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Utils;
-using osu.Game.Beatmaps;
 using osu.Game.Online.Multiplayer;
-using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.Multi.Components;
+using osu.Game.Tests.Beatmaps;
 using osuTK;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
     public class TestSceneMatchBeatmapDetailArea : MultiplayerTestScene
     {
-        [Resolved]
-        private BeatmapManager beatmapManager { get; set; }
-
-        [Resolved]
-
-        private RulesetStore rulesetStore { get; set; }
-
-        private MatchBeatmapDetailArea detailArea;
-
         [SetUp]
         public void Setup() => Schedule(() =>
         {
             Room.Playlist.Clear();
 
-            Child = detailArea = new MatchBeatmapDetailArea
+            Child = new MatchBeatmapDetailArea
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
@@ -42,19 +30,11 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         private void createNewItem()
         {
-            var set = beatmapManager.GetAllUsableBeatmapSetsEnumerable().First();
-            var rulesets = rulesetStore.AvailableRulesets.ToList();
-
-            var beatmap = set.Beatmaps[RNG.Next(0, set.Beatmaps.Count)];
-
-            beatmap.BeatmapSet = set;
-            beatmap.Metadata = set.Metadata;
-
             Room.Playlist.Add(new PlaylistItem
             {
                 ID = Room.Playlist.Count,
-                Beatmap = { Value = beatmap },
+                Beatmap = { Value = new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo },
-                Ruleset = { Value = rulesets[RNG.Next(0, rulesets.Count)] },
+                Ruleset = { Value = new OsuRuleset().RulesetInfo },
                 RequiredMods =
                 {
                     new OsuModHardRock(),

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

@@ -117,6 +117,8 @@ namespace osu.Game.Tests.Visual.Navigation
             {
                 base.LoadComplete();
                 API.Login("Rhythm Champion", "osu!");
+
+                Dependencies.Get<SessionStatics>().Set(Static.MutedAudioNotificationShownOnce, true);
             }
         }
 

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

@@ -0,0 +1,97 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online;
+using osu.Game.Online.API;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    [TestFixture]
+    public class TestSceneOnlineViewContainer : OsuTestScene
+    {
+        private readonly TestOnlineViewContainer onlineView;
+
+        public TestSceneOnlineViewContainer()
+        {
+            Child = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Child = onlineView = new TestOnlineViewContainer()
+            };
+        }
+
+        [Test]
+        public void TestOnlineStateVisibility()
+        {
+            AddStep("set status to online", () => ((DummyAPIAccess)API).State = APIState.Online);
+
+            AddUntilStep("children are visible", () => onlineView.ViewTarget.IsPresent);
+            AddUntilStep("loading animation is not visible", () => !onlineView.LoadingAnimation.IsPresent);
+        }
+
+        [Test]
+        public void TestOfflineStateVisibility()
+        {
+            AddStep("set status to offline", () => ((DummyAPIAccess)API).State = APIState.Offline);
+
+            AddUntilStep("children are not visible", () => !onlineView.ViewTarget.IsPresent);
+            AddUntilStep("loading animation is not visible", () => !onlineView.LoadingAnimation.IsPresent);
+        }
+
+        [Test]
+        public void TestConnectingStateVisibility()
+        {
+            AddStep("set status to connecting", () => ((DummyAPIAccess)API).State = APIState.Connecting);
+
+            AddUntilStep("children are not visible", () => !onlineView.ViewTarget.IsPresent);
+            AddUntilStep("loading animation is visible", () => onlineView.LoadingAnimation.IsPresent);
+        }
+
+        [Test]
+        public void TestFailingStateVisibility()
+        {
+            AddStep("set status to failing", () => ((DummyAPIAccess)API).State = APIState.Failing);
+
+            AddUntilStep("children are not visible", () => !onlineView.ViewTarget.IsPresent);
+            AddUntilStep("loading animation is visible", () => onlineView.LoadingAnimation.IsPresent);
+        }
+
+        private class TestOnlineViewContainer : OnlineViewContainer
+        {
+            public new LoadingAnimation LoadingAnimation => base.LoadingAnimation;
+
+            public CompositeDrawable ViewTarget => base.Content;
+
+            public TestOnlineViewContainer()
+                : base(@"Please sign in to view dummy test content")
+            {
+                RelativeSizeAxes = Axes.Both;
+
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = Color4.Blue.Opacity(0.8f),
+                    },
+                    new OsuSpriteText
+                    {
+                        Text = "dummy online content",
+                        Font = OsuFont.Default.With(size: 40),
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    }
+                };
+            }
+        }
+    }
+}

osu.Game/Online/API/DummyAPIAccess.cs

@@ -33,7 +33,7 @@ namespace osu.Game.Online.API
         public APIState State
         {
             get => state;
-            private set
+            set
             {
                 if (state == value)
                     return;

osu.Game/Online/Leaderboards/Leaderboard.cs

@@ -152,7 +152,7 @@ namespace osu.Game.Online.Leaderboards
                         break;
 
                     case PlaceholderState.NotLoggedIn:
-                        replacePlaceholder(new LoginPlaceholder());
+                        replacePlaceholder(new LoginPlaceholder(@"Please sign in to view online leaderboards!"));
                         break;
 
                     case PlaceholderState.NotSupporter:

osu.Game/Online/OnlineViewContainer.cs

@@ -0,0 +1,100 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API;
+using osu.Game.Online.Placeholders;
+
+namespace osu.Game.Online
+{
+    /// <summary>
+    /// A <see cref="Container"/> for displaying online content which require a local user to be logged in.
+    /// Shows its children only when the local user is logged in and supports displaying a placeholder if not.
+    /// </summary>
+    public abstract class OnlineViewContainer : Container, IOnlineComponent
+    {
+        protected LoadingAnimation LoadingAnimation { get; private set; }
+
+        protected override Container<Drawable> Content { get; } = new Container { RelativeSizeAxes = Axes.Both };
+
+        private readonly string placeholderMessage;
+
+        private Placeholder placeholder;
+
+        private const double transform_duration = 300;
+
+        [Resolved]
+        protected IAPIProvider API { get; private set; }
+
+        protected OnlineViewContainer(string placeholderMessage)
+        {
+            this.placeholderMessage = placeholderMessage;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChildren = new Drawable[]
+            {
+                Content,
+                placeholder = new LoginPlaceholder(placeholderMessage),
+                LoadingAnimation = new LoadingAnimation
+                {
+                    Alpha = 0,
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            API.Register(this);
+        }
+
+        public virtual void APIStateChanged(IAPIProvider api, APIState state)
+        {
+            switch (state)
+            {
+                case APIState.Offline:
+                    PopContentOut(Content);
+                    placeholder.ScaleTo(0.8f).Then().ScaleTo(1, 3 * transform_duration, Easing.OutQuint);
+                    placeholder.FadeInFromZero(2 * transform_duration, Easing.OutQuint);
+                    LoadingAnimation.Hide();
+                    break;
+
+                case APIState.Online:
+                    PopContentIn(Content);
+                    placeholder.FadeOut(transform_duration / 2, Easing.OutQuint);
+                    LoadingAnimation.Hide();
+                    break;
+
+                case APIState.Failing:
+                case APIState.Connecting:
+                    PopContentOut(Content);
+                    LoadingAnimation.Show();
+                    placeholder.FadeOut(transform_duration / 2, Easing.OutQuint);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Applies a transform to the online content to make it hidden.
+        /// </summary>
+        protected virtual void PopContentOut(Drawable content) => content.FadeOut(transform_duration / 2, Easing.OutQuint);
+
+        /// <summary>
+        /// Applies a transform to the online content to make it visible.
+        /// </summary>
+        protected virtual void PopContentIn(Drawable content) => content.FadeIn(transform_duration, Easing.OutQuint);
+
+        protected override void Dispose(bool isDisposing)
+        {
+            API?.Unregister(this);
+            base.Dispose(isDisposing);
+        }
+    }
+}

osu.Game/Online/Placeholders/LoginPlaceholder.cs

@@ -14,7 +14,7 @@ namespace osu.Game.Online.Placeholders
         [Resolved(CanBeNull = true)]
         private LoginOverlay login { get; set; }
 
-        public LoginPlaceholder()
+        public LoginPlaceholder(string actionMessage)
         {
             AddIcon(FontAwesome.Solid.UserLock, cp =>
             {
@@ -22,7 +22,7 @@ namespace osu.Game.Online.Placeholders
                 cp.Padding = new MarginPadding { Right = 10 };
             });
 
-            AddText(@"Please sign in to view online leaderboards!");
+            AddText(actionMessage);
         }
 
         protected override bool OnMouseDown(MouseDownEvent e)

osu.Game/Rulesets/Replays/AutoGenerator.cs

@@ -32,7 +32,7 @@ namespace osu.Game.Rulesets.Replays
         #region Constants
 
         // Shared amongst all modes
-        protected const double KEY_UP_DELAY = 50;
+        public const double KEY_UP_DELAY = 50;
 
         #endregion
 

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

@@ -2,10 +2,12 @@
 // 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.Transforms;
 using osu.Framework.Input.Events;
+using osu.Framework.Timing;
 using osu.Framework.Utils;
 using osu.Game.Graphics.Containers;
 using osuTK;
@@ -30,6 +32,9 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
         private float currentZoom = 1;
 
+        [Resolved(canBeNull: true)]
+        private IFrameBasedClock editorClock { get; set; }
+
         public ZoomableScrollContainer()
             : base(Direction.Horizontal)
         {
@@ -104,8 +109,15 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
         protected override bool OnScroll(ScrollEvent e)
         {
             if (e.IsPrecise)
+            {
+                // can't handle scroll correctly while playing.
+                // the editor will handle this case for us.
+                if (editorClock?.IsRunning == true)
+                    return false;
+
                 // for now, we don't support zoom when using a precision scroll device. this needs gesture support.
                 return base.OnScroll(e);
+            }
 
             setZoomTarget(zoomTarget + e.ScrollDelta.Y, zoomedContent.ToLocalSpace(e.ScreenSpaceMousePosition).X);
             return true;

osu.Game/Screens/Multi/DrawableRoomPlaylistItem.cs

@@ -76,7 +76,7 @@ namespace osu.Game.Screens.Multi
         {
             base.LoadComplete();
 
-            SelectedItem.BindValueChanged(selected => maskingContainer.BorderThickness = selected.NewValue == Model ? 5 : 0);
+            SelectedItem.BindValueChanged(selected => maskingContainer.BorderThickness = selected.NewValue == Model ? 5 : 0, true);
 
             beatmap.BindValueChanged(_ => scheduleRefresh());
             ruleset.BindValueChanged(_ => scheduleRefresh());

osu.Game/Screens/Play/BeatmapMetadataDisplay.cs

@@ -0,0 +1,180 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Screens.Play.HUD;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Screens.Play
+{
+    /// <summary>
+    /// Displays beatmap metadata inside <see cref="PlayerLoader"/>
+    /// </summary>
+    public class BeatmapMetadataDisplay : Container
+    {
+        private class MetadataLine : Container
+        {
+            public MetadataLine(string left, string right)
+            {
+                AutoSizeAxes = Axes.Both;
+                Children = new Drawable[]
+                {
+                    new OsuSpriteText
+                    {
+                        Anchor = Anchor.TopCentre,
+                        Origin = Anchor.TopRight,
+                        Margin = new MarginPadding { Right = 5 },
+                        Colour = OsuColour.Gray(0.8f),
+                        Text = left,
+                    },
+                    new OsuSpriteText
+                    {
+                        Anchor = Anchor.TopCentre,
+                        Origin = Anchor.TopLeft,
+                        Margin = new MarginPadding { Left = 5 },
+                        Text = string.IsNullOrEmpty(right) ? @"-" : right,
+                    }
+                };
+            }
+        }
+
+        private readonly WorkingBeatmap beatmap;
+        private readonly Bindable<IReadOnlyList<Mod>> mods;
+        private readonly Drawable facade;
+        private LoadingAnimation loading;
+        private Sprite backgroundSprite;
+
+        public IBindable<IReadOnlyList<Mod>> Mods => mods;
+
+        public bool Loading
+        {
+            set
+            {
+                if (value)
+                {
+                    loading.Show();
+                    backgroundSprite.FadeColour(OsuColour.Gray(0.5f), 400, Easing.OutQuint);
+                }
+                else
+                {
+                    loading.Hide();
+                    backgroundSprite.FadeColour(Color4.White, 400, Easing.OutQuint);
+                }
+            }
+        }
+
+        public BeatmapMetadataDisplay(WorkingBeatmap beatmap, Bindable<IReadOnlyList<Mod>> mods, Drawable facade)
+        {
+            this.beatmap = beatmap;
+            this.facade = facade;
+
+            this.mods = new Bindable<IReadOnlyList<Mod>>();
+            this.mods.BindTo(mods);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            var metadata = beatmap.BeatmapInfo?.Metadata ?? new BeatmapMetadata();
+
+            AutoSizeAxes = Axes.Both;
+            Children = new Drawable[]
+            {
+                new FillFlowContainer
+                {
+                    AutoSizeAxes = Axes.Both,
+                    Origin = Anchor.TopCentre,
+                    Anchor = Anchor.TopCentre,
+                    Direction = FillDirection.Vertical,
+                    Children = new[]
+                    {
+                        facade.With(d =>
+                        {
+                            d.Anchor = Anchor.TopCentre;
+                            d.Origin = Anchor.TopCentre;
+                        }),
+                        new OsuSpriteText
+                        {
+                            Text = new LocalisedString((metadata.TitleUnicode, metadata.Title)),
+                            Font = OsuFont.GetFont(size: 36, italics: true),
+                            Origin = Anchor.TopCentre,
+                            Anchor = Anchor.TopCentre,
+                            Margin = new MarginPadding { Top = 15 },
+                        },
+                        new OsuSpriteText
+                        {
+                            Text = new LocalisedString((metadata.ArtistUnicode, metadata.Artist)),
+                            Font = OsuFont.GetFont(size: 26, italics: true),
+                            Origin = Anchor.TopCentre,
+                            Anchor = Anchor.TopCentre,
+                        },
+                        new Container
+                        {
+                            Size = new Vector2(300, 60),
+                            Margin = new MarginPadding(10),
+                            Origin = Anchor.TopCentre,
+                            Anchor = Anchor.TopCentre,
+                            CornerRadius = 10,
+                            Masking = true,
+                            Children = new Drawable[]
+                            {
+                                backgroundSprite = new Sprite
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Texture = beatmap?.Background,
+                                    Origin = Anchor.Centre,
+                                    Anchor = Anchor.Centre,
+                                    FillMode = FillMode.Fill,
+                                },
+                                loading = new LoadingAnimation { Scale = new Vector2(1.3f) }
+                            }
+                        },
+                        new OsuSpriteText
+                        {
+                            Text = beatmap?.BeatmapInfo?.Version,
+                            Font = OsuFont.GetFont(size: 26, italics: true),
+                            Origin = Anchor.TopCentre,
+                            Anchor = Anchor.TopCentre,
+                            Margin = new MarginPadding
+                            {
+                                Bottom = 40
+                            },
+                        },
+                        new MetadataLine("Source", metadata.Source)
+                        {
+                            Origin = Anchor.TopCentre,
+                            Anchor = Anchor.TopCentre,
+                        },
+                        new MetadataLine("Mapper", metadata.AuthorString)
+                        {
+                            Origin = Anchor.TopCentre,
+                            Anchor = Anchor.TopCentre,
+                        },
+                        new ModDisplay
+                        {
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                            AutoSizeAxes = Axes.Both,
+                            Margin = new MarginPadding { Top = 20 },
+                            Current = mods
+                        }
+                    },
+                }
+            };
+
+            Loading = true;
+        }
+    }
+}

osu.Game/Screens/Play/GameplayBeatmap.cs

@@ -0,0 +1,42 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Beatmaps.Timing;
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Screens.Play
+{
+    public class GameplayBeatmap : Component, IBeatmap
+    {
+        public readonly IBeatmap PlayableBeatmap;
+
+        public GameplayBeatmap(IBeatmap playableBeatmap)
+        {
+            PlayableBeatmap = playableBeatmap;
+        }
+
+        public BeatmapInfo BeatmapInfo
+        {
+            get => PlayableBeatmap.BeatmapInfo;
+            set => PlayableBeatmap.BeatmapInfo = value;
+        }
+
+        public BeatmapMetadata Metadata => PlayableBeatmap.Metadata;
+
+        public ControlPointInfo ControlPointInfo => PlayableBeatmap.ControlPointInfo;
+
+        public List<BreakPeriod> Breaks => PlayableBeatmap.Breaks;
+
+        public double TotalBreakTime => PlayableBeatmap.TotalBreakTime;
+
+        public IReadOnlyList<HitObject> HitObjects => PlayableBeatmap.HitObjects;
+
+        public IEnumerable<BeatmapStatistic> GetStatistics() => PlayableBeatmap.GetStatistics();
+
+        public IBeatmap Clone() => PlayableBeatmap.Clone();
+    }
+}

osu.Game/Screens/Play/Player.cs

@@ -110,6 +110,13 @@ namespace osu.Game.Screens.Play
             this.showResults = showResults;
         }
 
+        private GameplayBeatmap gameplayBeatmap;
+
+        private DependencyContainer dependencies;
+
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+            => dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
+
         [BackgroundDependencyLoader]
         private void load(AudioManager audio, IAPIProvider api, OsuConfigManager config)
         {
@@ -143,6 +150,10 @@ namespace osu.Game.Screens.Play
 
             InternalChild = GameplayClockContainer = new GameplayClockContainer(Beatmap.Value, Mods.Value, DrawableRuleset.GameplayStartTime);
 
+            AddInternal(gameplayBeatmap = new GameplayBeatmap(playableBeatmap));
+
+            dependencies.CacheAs(gameplayBeatmap);
+
             addUnderlayComponents(GameplayClockContainer);
             addGameplayComponents(GameplayClockContainer, Beatmap.Value);
             addOverlayComponents(GameplayClockContainer, Beatmap.Value);

osu.Game/Screens/Play/PlayerLoader.cs

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
@@ -12,21 +11,15 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input;
-using osu.Framework.Localisation;
 using osu.Framework.Screens;
 using osu.Framework.Threading;
-using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
-using osu.Game.Graphics.Sprites;
-using osu.Game.Graphics.UserInterface;
 using osu.Game.Input;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
-using osu.Game.Rulesets.Mods;
 using osu.Game.Screens.Menu;
-using osu.Game.Screens.Play.HUD;
 using osu.Game.Screens.Play.PlayerSettings;
 using osu.Game.Users;
 using osuTK;
@@ -38,30 +31,65 @@ namespace osu.Game.Screens.Play
     {
         protected const float BACKGROUND_BLUR = 15;
 
+        public override bool HideOverlaysOnEnter => hideOverlays;
+
+        public override bool DisallowExternalBeatmapRulesetChanges => true;
+
+        // Here because IsHovered will not update unless we do so.
+        public override bool HandlePositionalInput => true;
+
+        // We show the previous screen status
+        protected override UserActivity InitialActivity => null;
+
+        protected override bool PlayResumeSound => false;
+
+        protected BeatmapMetadataDisplay MetadataInfo;
+
+        protected VisualSettings VisualSettings;
+
+        protected Task LoadTask { get; private set; }
+
+        protected Task DisposalTask { get; private set; }
+
+        private bool backgroundBrightnessReduction;
+
+        protected bool BackgroundBrightnessReduction
+        {
+            set
+            {
+                if (value == backgroundBrightnessReduction)
+                    return;
+
+                backgroundBrightnessReduction = value;
+
+                Background.FadeColour(OsuColour.Gray(backgroundBrightnessReduction ? 0.8f : 1), 200);
+            }
+        }
+
+        private bool readyForPush =>
+            // don't push unless the player is completely loaded
+            player.LoadState == LoadState.Ready
+            // don't push if the user is hovering one of the panes, unless they are idle.
+            && (IsHovered || idleTracker.IsIdle.Value)
+            // don't push if the user is dragging a slider or otherwise.
+            && inputManager?.DraggedDrawable == null
+            // don't push if a focused overlay is visible, like settings.
+            && inputManager?.FocusedDrawable == null;
+
         private readonly Func<Player> createPlayer;
 
         private Player player;
 
         private LogoTrackingContainer content;
 
-        protected BeatmapMetadataDisplay MetadataInfo;
-
         private bool hideOverlays;
-        public override bool HideOverlaysOnEnter => hideOverlays;
-
-        protected override UserActivity InitialActivity => null; //shows the previous screen status
-
-        public override bool DisallowExternalBeatmapRulesetChanges => true;
-
-        protected override bool PlayResumeSound => false;
-
-        protected Task LoadTask { get; private set; }
-
-        protected Task DisposalTask { get; private set; }
 
         private InputManager inputManager;
+
         private IdleTracker idleTracker;
 
+        private ScheduledDelegate scheduledPushPlayer;
+
         [Resolved(CanBeNull = true)]
         private NotificationOverlay notificationOverlay { get; set; }
 
@@ -71,19 +99,11 @@ namespace osu.Game.Screens.Play
         [Resolved]
         private AudioManager audioManager { get; set; }
 
-        private Bindable<bool> muteWarningShownOnce;
-
         public PlayerLoader(Func<Player> createPlayer)
         {
             this.createPlayer = createPlayer;
         }
 
-        private void restartRequested()
-        {
-            hideOverlays = true;
-            ValidForResume = true;
-        }
-
         [BackgroundDependencyLoader]
         private void load(SessionStatics sessionStatics)
         {
@@ -127,11 +147,13 @@ namespace osu.Game.Screens.Play
             inputManager = GetContainingInputManager();
         }
 
+        #region Screen handling
+
         public override void OnEntering(IScreen last)
         {
             base.OnEntering(last);
 
-            loadNewPlayer();
+            prepareNewPlayer();
 
             content.ScaleTo(0.7f);
             Background?.FadeColour(Color4.White, 800, Easing.OutQuint);
@@ -141,15 +163,7 @@ namespace osu.Game.Screens.Play
             MetadataInfo.Delay(750).FadeIn(500);
             this.Delay(1800).Schedule(pushWhenLoaded);
 
-            if (!muteWarningShownOnce.Value)
+            showMuteWarningIfNeeded();
-            {
-                //Checks if the notification has not been shown yet and also if master volume is muted, track/music volume is muted or if the whole game is muted.
-                if (volumeOverlay?.IsMuted.Value == true || audioManager.Volume.Value <= audioManager.Volume.MinValue || audioManager.VolumeTrack.Value <= audioManager.VolumeTrack.MinValue)
-                {
-                    notificationOverlay?.Post(new MutedNotification());
-                    muteWarningShownOnce.Value = true;
-                }
-            }
         }
 
         public override void OnResuming(IScreen last)
@@ -160,36 +174,32 @@ namespace osu.Game.Screens.Play
 
             MetadataInfo.Loading = true;
 
-            //we will only be resumed if the player has requested a re-run (see ValidForResume setting above)
+            // we will only be resumed if the player has requested a re-run (see restartRequested).
-            loadNewPlayer();
+            prepareNewPlayer();
 
             this.Delay(400).Schedule(pushWhenLoaded);
         }
 
-        private void loadNewPlayer()
+        public override void OnSuspending(IScreen next)
         {
-            var restartCount = player?.RestartCount + 1 ?? 0;
+            base.OnSuspending(next);
 
-            player = createPlayer();
+            cancelLoad();
-            player.RestartCount = restartCount;
-            player.RestartRequested = restartRequested;
 
-            LoadTask = LoadComponentAsync(player, _ => MetadataInfo.Loading = false);
+            BackgroundBrightnessReduction = false;
         }
 
-        private void contentIn()
+        public override bool OnExiting(IScreen next)
         {
-            content.ScaleTo(1, 650, Easing.OutQuint);
+            cancelLoad();
-            content.FadeInFromZero(400);
-        }
 
-        private void contentOut()
+            content.ScaleTo(0.7f, 150, Easing.InQuint);
-        {
+            this.FadeOut(150);
-            // Ensure the logo is no longer tracking before we scale the content
-            content.StopTracking();
 
-            content.ScaleTo(0.7f, 300, Easing.InQuint);
+            Background.EnableUserDim.Value = false;
-            content.FadeOut(250);
+            BackgroundBrightnessReduction = false;
+
+            return base.OnExiting(next);
         }
 
         protected override void LogoArriving(OsuLogo logo, bool resuming)
@@ -198,10 +208,7 @@ namespace osu.Game.Screens.Play
 
             const double duration = 300;
 
-            if (!resuming)
+            if (!resuming) logo.MoveTo(new Vector2(0.5f), duration, Easing.In);
-            {
-                logo.MoveTo(new Vector2(0.5f), duration, Easing.In);
-            }
 
             logo.ScaleTo(new Vector2(0.15f), duration, Easing.In);
             logo.FadeIn(350);
@@ -219,109 +226,7 @@ namespace osu.Game.Screens.Play
             content.StopTracking();
         }
 
-        private ScheduledDelegate pushDebounce;
+        #endregion
-        protected VisualSettings VisualSettings;
-
-        // Here because IsHovered will not update unless we do so.
-        public override bool HandlePositionalInput => true;
-
-        private bool readyForPush => player.LoadState == LoadState.Ready && (IsHovered || idleTracker.IsIdle.Value) && inputManager?.DraggedDrawable == null;
-
-        private void pushWhenLoaded()
-        {
-            if (!this.IsCurrentScreen()) return;
-
-            try
-            {
-                if (!readyForPush)
-                {
-                    // as the pushDebounce below has a delay, we need to keep checking and cancel a future debounce
-                    // if we become unready for push during the delay.
-                    cancelLoad();
-                    return;
-                }
-
-                if (pushDebounce != null)
-                    return;
-
-                pushDebounce = Scheduler.AddDelayed(() =>
-                {
-                    contentOut();
-
-                    this.Delay(250).Schedule(() =>
-                    {
-                        if (!this.IsCurrentScreen()) return;
-
-                        LoadTask = null;
-
-                        //By default, we want to load the player and never be returned to.
-                        //Note that this may change if the player we load requested a re-run.
-                        ValidForResume = false;
-
-                        if (player.LoadedBeatmapSuccessfully)
-                            this.Push(player);
-                        else
-                            this.Exit();
-                    });
-                }, 500);
-            }
-            finally
-            {
-                Schedule(pushWhenLoaded);
-            }
-        }
-
-        private void cancelLoad()
-        {
-            pushDebounce?.Cancel();
-            pushDebounce = null;
-        }
-
-        public override void OnSuspending(IScreen next)
-        {
-            BackgroundBrightnessReduction = false;
-            base.OnSuspending(next);
-            cancelLoad();
-        }
-
-        public override bool OnExiting(IScreen next)
-        {
-            content.ScaleTo(0.7f, 150, Easing.InQuint);
-            this.FadeOut(150);
-            cancelLoad();
-
-            Background.EnableUserDim.Value = false;
-            BackgroundBrightnessReduction = false;
-
-            return base.OnExiting(next);
-        }
-
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-
-            if (isDisposing)
-            {
-                // if the player never got pushed, we should explicitly dispose it.
-                DisposalTask = LoadTask?.ContinueWith(_ => player.Dispose());
-            }
-        }
-
-        private bool backgroundBrightnessReduction;
-
-        protected bool BackgroundBrightnessReduction
-        {
-            get => backgroundBrightnessReduction;
-            set
-            {
-                if (value == backgroundBrightnessReduction)
-                    return;
-
-                backgroundBrightnessReduction = value;
-
-                Background.FadeColour(OsuColour.Gray(backgroundBrightnessReduction ? 0.8f : 1), 200);
-            }
-        }
 
         protected override void Update()
         {
@@ -350,171 +255,129 @@ namespace osu.Game.Screens.Play
             }
         }
 
-        protected class BeatmapMetadataDisplay : Container
+        private void prepareNewPlayer()
         {
-            private class MetadataLine : Container
+            var restartCount = player?.RestartCount + 1 ?? 0;
-            {
+
-                public MetadataLine(string left, string right)
+            player = createPlayer();
-                {
+            player.RestartCount = restartCount;
-                    AutoSizeAxes = Axes.Both;
+            player.RestartRequested = restartRequested;
-                    Children = new Drawable[]
+
-                    {
+            LoadTask = LoadComponentAsync(player, _ => MetadataInfo.Loading = false);
-                        new OsuSpriteText
-                        {
-                            Anchor = Anchor.TopCentre,
-                            Origin = Anchor.TopRight,
-                            Margin = new MarginPadding { Right = 5 },
-                            Colour = OsuColour.Gray(0.8f),
-                            Text = left,
-                        },
-                        new OsuSpriteText
-                        {
-                            Anchor = Anchor.TopCentre,
-                            Origin = Anchor.TopLeft,
-                            Margin = new MarginPadding { Left = 5 },
-                            Text = string.IsNullOrEmpty(right) ? @"-" : right,
-                        }
-                    };
-                }
         }
 
-            private readonly WorkingBeatmap beatmap;
+        private void restartRequested()
-            private readonly Bindable<IReadOnlyList<Mod>> mods;
-            private readonly Drawable facade;
-            private LoadingAnimation loading;
-            private Sprite backgroundSprite;
-
-            public IBindable<IReadOnlyList<Mod>> Mods => mods;
-
-            public bool Loading
         {
-                set
+            hideOverlays = true;
-                {
+            ValidForResume = true;
-                    if (value)
-                    {
-                        loading.Show();
-                        backgroundSprite.FadeColour(OsuColour.Gray(0.5f), 400, Easing.OutQuint);
         }
+
+        private void contentIn()
+        {
+            content.ScaleTo(1, 650, Easing.OutQuint);
+            content.FadeInFromZero(400);
+        }
+
+        private void contentOut()
+        {
+            // Ensure the logo is no longer tracking before we scale the content
+            content.StopTracking();
+
+            content.ScaleTo(0.7f, 300, Easing.InQuint);
+            content.FadeOut(250);
+        }
+
+        private void pushWhenLoaded()
+        {
+            if (!this.IsCurrentScreen()) return;
+
+            try
+            {
+                if (!readyForPush)
+                {
+                    // as the pushDebounce below has a delay, we need to keep checking and cancel a future debounce
+                    // if we become unready for push during the delay.
+                    cancelLoad();
+                    return;
+                }
+
+                if (scheduledPushPlayer != null)
+                    return;
+
+                scheduledPushPlayer = Scheduler.AddDelayed(() =>
+                {
+                    contentOut();
+
+                    this.Delay(250).Schedule(() =>
+                    {
+                        if (!this.IsCurrentScreen()) return;
+
+                        LoadTask = null;
+
+                        //By default, we want to load the player and never be returned to.
+                        //Note that this may change if the player we load requested a re-run.
+                        ValidForResume = false;
+
+                        if (player.LoadedBeatmapSuccessfully)
+                            this.Push(player);
                         else
-                    {
+                            this.Exit();
-                        loading.Hide();
+                    });
-                        backgroundSprite.FadeColour(Color4.White, 400, Easing.OutQuint);
+                }, 500);
             }
+            finally
+            {
+                Schedule(pushWhenLoaded);
             }
         }
 
-            public BeatmapMetadataDisplay(WorkingBeatmap beatmap, Bindable<IReadOnlyList<Mod>> mods, Drawable facade)
+        private void cancelLoad()
         {
-                this.beatmap = beatmap;
+            scheduledPushPlayer?.Cancel();
-                this.facade = facade;
+            scheduledPushPlayer = null;
-
-                this.mods = new Bindable<IReadOnlyList<Mod>>();
-                this.mods.BindTo(mods);
         }
 
-            [BackgroundDependencyLoader]
+        #region Disposal
-            private void load()
-            {
-                var metadata = beatmap.BeatmapInfo?.Metadata ?? new BeatmapMetadata();
 
-                AutoSizeAxes = Axes.Both;
+        protected override void Dispose(bool isDisposing)
-                Children = new Drawable[]
         {
-                    new FillFlowContainer
+            base.Dispose(isDisposing);
-                    {
-                        AutoSizeAxes = Axes.Both,
-                        Origin = Anchor.TopCentre,
-                        Anchor = Anchor.TopCentre,
-                        Direction = FillDirection.Vertical,
-                        Children = new[]
-                        {
-                            facade.With(d =>
-                            {
-                                d.Anchor = Anchor.TopCentre;
-                                d.Origin = Anchor.TopCentre;
-                            }),
-                            new OsuSpriteText
-                            {
-                                Text = new LocalisedString((metadata.TitleUnicode, metadata.Title)),
-                                Font = OsuFont.GetFont(size: 36, italics: true),
-                                Origin = Anchor.TopCentre,
-                                Anchor = Anchor.TopCentre,
-                                Margin = new MarginPadding { Top = 15 },
-                            },
-                            new OsuSpriteText
-                            {
-                                Text = new LocalisedString((metadata.ArtistUnicode, metadata.Artist)),
-                                Font = OsuFont.GetFont(size: 26, italics: true),
-                                Origin = Anchor.TopCentre,
-                                Anchor = Anchor.TopCentre,
-                            },
-                            new Container
-                            {
-                                Size = new Vector2(300, 60),
-                                Margin = new MarginPadding(10),
-                                Origin = Anchor.TopCentre,
-                                Anchor = Anchor.TopCentre,
-                                CornerRadius = 10,
-                                Masking = true,
-                                Children = new Drawable[]
-                                {
-                                    backgroundSprite = new Sprite
-                                    {
-                                        RelativeSizeAxes = Axes.Both,
-                                        Texture = beatmap?.Background,
-                                        Origin = Anchor.Centre,
-                                        Anchor = Anchor.Centre,
-                                        FillMode = FillMode.Fill,
-                                    },
-                                    loading = new LoadingAnimation { Scale = new Vector2(1.3f) }
-                                }
-                            },
-                            new OsuSpriteText
-                            {
-                                Text = beatmap?.BeatmapInfo?.Version,
-                                Font = OsuFont.GetFont(size: 26, italics: true),
-                                Origin = Anchor.TopCentre,
-                                Anchor = Anchor.TopCentre,
-                                Margin = new MarginPadding
-                                {
-                                    Bottom = 40
-                                },
-                            },
-                            new MetadataLine("Source", metadata.Source)
-                            {
-                                Origin = Anchor.TopCentre,
-                                Anchor = Anchor.TopCentre,
-                            },
-                            new MetadataLine("Mapper", metadata.AuthorString)
-                            {
-                                Origin = Anchor.TopCentre,
-                                Anchor = Anchor.TopCentre,
-                            },
-                            new ModDisplay
-                            {
-                                Anchor = Anchor.TopCentre,
-                                Origin = Anchor.TopCentre,
-                                AutoSizeAxes = Axes.Both,
-                                Margin = new MarginPadding { Top = 20 },
-                                Current = mods
-                            }
-                        },
-                    }
-                };
 
-                Loading = true;
+            if (isDisposing)
+            {
+                // if the player never got pushed, we should explicitly dispose it.
+                DisposalTask = LoadTask?.ContinueWith(_ => player.Dispose());
+            }
+        }
+
+        #endregion
+
+        #region Mute warning
+
+        private Bindable<bool> muteWarningShownOnce;
+
+        private void showMuteWarningIfNeeded()
+        {
+            if (!muteWarningShownOnce.Value)
+            {
+                //Checks if the notification has not been shown yet and also if master volume is muted, track/music volume is muted or if the whole game is muted.
+                if (volumeOverlay?.IsMuted.Value == true || audioManager.Volume.Value <= audioManager.Volume.MinValue || audioManager.VolumeTrack.Value <= audioManager.VolumeTrack.MinValue)
+                {
+                    notificationOverlay?.Post(new MutedNotification());
+                    muteWarningShownOnce.Value = true;
+                }
             }
         }
 
         private class MutedNotification : SimpleNotification
         {
+            public override bool IsImportant => true;
+
             public MutedNotification()
             {
                 Text = "Your music volume is set to 0%! Click here to restore it.";
             }
 
-            public override bool IsImportant => true;
-
             [BackgroundDependencyLoader]
             private void load(OsuColour colours, AudioManager audioManager, NotificationOverlay notificationOverlay, VolumeOverlay volumeOverlay)
             {
@@ -533,5 +396,7 @@ namespace osu.Game.Screens.Play
                 };
             }
         }
+
+        #endregion
     }
 }

osu.Game/Screens/Select/BeatmapDetailArea.cs

@@ -28,11 +28,7 @@ namespace osu.Game.Screens.Select
 
         public readonly BeatmapDetails Details;
 
-        protected Bindable<BeatmapDetailAreaTabItem> CurrentTab
+        protected Bindable<BeatmapDetailAreaTabItem> CurrentTab => tabControl.Current;
-        {
-            get => tabControl.Current;
-            set => tabControl.Current = value;
-        }
 
         private readonly Container content;
         protected override Container<Drawable> Content => content;