Merge branch 'master' into editor-seek-snapping-fix

osu.Game/Screens/Edit/Editor.cs

@@ -13,6 +13,7 @@ using osu.Game.Screens.Edit.Components.Timelines.Summary;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input;
+using osu.Framework.Platform;
 using osu.Framework.Timing;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Screens.Edit.Screens;
@@ -39,13 +40,16 @@ namespace osu.Game.Screens.Edit
         private EditorClock clock;
 
         private DependencyContainer dependencies;
+        private GameHost host;
 
         protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
             => dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
 
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
+        private void load(OsuColour colours, GameHost host)
         {
+            this.host = host;
+
             // TODO: should probably be done at a RulesetContainer level to share logic with Player.
             var sourceClock = (IAdjustableClock)Beatmap.Value.Track ?? new StopwatchClock();
             clock = new EditorClock(Beatmap.Value, beatDivisor) { IsCoupled = false };
@@ -155,7 +159,7 @@ namespace osu.Game.Screens.Edit
 
         private void exportBeatmap()
         {
-            Beatmap.Value.Save();
+            host.OpenFileExternally(Beatmap.Value.Save());
         }
 
         private void onModeChanged(EditorScreenMode mode)
@@ -181,9 +185,9 @@ namespace osu.Game.Screens.Edit
         protected override bool OnScroll(InputState state)
         {
             if (state.Mouse.ScrollDelta.X + state.Mouse.ScrollDelta.Y > 0)
-                clock.SeekBackward(true);
+                clock.SeekBackward(!clock.IsRunning);
             else
-                clock.SeekForward(true);
+                clock.SeekForward(!clock.IsRunning);
             return true;
         }
 

osu.Game/Screens/Multi/Screens/Lounge/Lounge.cs

@@ -164,7 +164,7 @@ namespace osu.Game.Screens.Multi.Screens.Lounge
 
             // open the room if its selected and is clicked again
             if (room.State == SelectionState.Selected)
-                Push(new Match());
+                Push(new Match.Match(room.Room));
         }
 
         private class RoomsFilterContainer : FillFlowContainer<DrawableRoom>, IHasFilterableChildren

osu.Game/Screens/Multi/Screens/Match.cs

@@ -1,37 +0,0 @@
-// Copyright (c) 2007-2018 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 osu.Framework.Graphics;
-using osu.Framework.Screens;
-using osu.Game.Screens.Backgrounds;
-using osu.Game.Screens.Play;
-using osu.Game.Screens.Select;
-using OpenTK.Graphics;
-
-namespace osu.Game.Screens.Multi.Screens
-{
-    public class Match : ScreenWhiteBox
-    {
-        protected override IEnumerable<Type> PossibleChildren => new[] {
-            typeof(MatchSongSelect),
-            typeof(Player),
-        };
-
-        protected override BackgroundScreen CreateBackground() => new BackgroundScreenCustom(@"Backgrounds/bg4");
-
-        protected override void OnEntering(Screen last)
-        {
-            base.OnEntering(last);
-
-            Background.FadeColour(Color4.DarkGray, 500);
-        }
-
-        protected override bool OnExiting(Screen next)
-        {
-            Background.FadeColour(Color4.White, 500);
-            return base.OnExiting(next);
-        }
-    }
-}

osu.Game/Screens/Multi/Screens/Match/Header.cs

@@ -0,0 +1,184 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Drawables;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Overlays.SearchableList;
+using OpenTK.Graphics;
+
+namespace osu.Game.Screens.Multi.Screens.Match
+{
+    public class Header : Container
+    {
+        public const float HEIGHT = 200;
+
+        private readonly Box tabStrip;
+        private readonly UpdateableBeatmapSetCover cover;
+
+        public readonly PageTabControl<MatchHeaderPage> Tabs;
+
+        public BeatmapSetInfo BeatmapSet
+        {
+            set => cover.BeatmapSet = value;
+        }
+
+        public Action OnRequestSelectBeatmap;
+
+        public Header()
+        {
+            RelativeSizeAxes = Axes.X;
+            Height = HEIGHT;
+
+            BeatmapSelectButton beatmapButton;
+            Children = new Drawable[]
+            {
+                cover = new UpdateableBeatmapSetCover
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                },
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = ColourInfo.GradientVertical(Color4.Black.Opacity(0), Color4.Black.Opacity(0.5f)),
+                },
+                tabStrip = new Box
+                {
+                    Anchor = Anchor.BottomLeft,
+                    Origin = Anchor.BottomLeft,
+                    RelativeSizeAxes = Axes.X,
+                    Height = 1,
+                },
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Horizontal = SearchableListOverlay.WIDTH_PADDING },
+                    Children = new Drawable[]
+                    {
+                        new Container
+                        {
+                            Anchor = Anchor.TopRight,
+                            Origin = Anchor.TopRight,
+                            RelativeSizeAxes = Axes.Y,
+                            Width = 200,
+                            Padding = new MarginPadding { Vertical = 5 },
+                            Child = beatmapButton = new BeatmapSelectButton
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                            },
+                        },
+                        Tabs = new PageTabControl<MatchHeaderPage>
+                        {
+                            Anchor = Anchor.BottomLeft,
+                            Origin = Anchor.BottomLeft,
+                            RelativeSizeAxes = Axes.X,
+                        },
+                    },
+                },
+            };
+
+            beatmapButton.Action = () => OnRequestSelectBeatmap?.Invoke();
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            tabStrip.Colour = colours.Yellow;
+        }
+
+        private class BeatmapSelectButton : OsuClickableContainer
+        {
+            private const float corner_radius = 5;
+            private const float bg_opacity = 0.5f;
+            private const float transition_duration = 100;
+
+            private readonly Box bg;
+            private readonly Container border;
+
+            public BeatmapSelectButton()
+            {
+                Masking = true;
+                CornerRadius = corner_radius;
+
+                Children = new Drawable[]
+                {
+                    bg = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = Color4.Black,
+                        Alpha = bg_opacity,
+                    },
+                    new OsuSpriteText
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Font = @"Exo2.0-Bold",
+                        Text = "Select Beatmap",
+                    },
+                    border = new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Masking = true,
+                        CornerRadius = corner_radius,
+                        BorderThickness = 4,
+                        Alpha = 0,
+                        Child = new Box // needs a child to show the border
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Alpha = 0,
+                            AlwaysPresent = true
+                        },
+                    },
+                };
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                border.BorderColour = colours.Yellow;
+            }
+
+            protected override bool OnHover(InputState state)
+            {
+                border.FadeIn(transition_duration);
+                return base.OnHover(state);
+            }
+
+            protected override void OnHoverLost(InputState state)
+            {
+                base.OnHoverLost(state);
+                border.FadeOut(transition_duration);
+            }
+
+            protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+            {
+                bg.FadeTo(0.75f, 1000, Easing.Out);
+                return base.OnMouseDown(state, args);
+            }
+
+            protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+            {
+                bg.FadeTo(bg_opacity, transition_duration);
+                return base.OnMouseUp(state, args);
+            }
+        }
+    }
+
+    public enum MatchHeaderPage
+    {
+        Settings,
+        Room,
+    }
+}

osu.Game/Screens/Multi/Screens/Match/Info.cs

@@ -0,0 +1,210 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Overlays.SearchableList;
+using osu.Game.Screens.Multi.Components;
+using OpenTK;
+
+namespace osu.Game.Screens.Multi.Screens.Match
+{
+    public class Info : Container
+    {
+        public const float HEIGHT = 128;
+
+        private readonly OsuSpriteText name, availabilityStatus;
+        private readonly BeatmapTypeInfo beatmapTypeInfo;
+        private readonly ReadyButton readyButton;
+
+        private OsuColour colours;
+
+        public Bindable<bool> Ready => readyButton.Ready;
+
+        public string Name
+        {
+            set { name.Text = value; }
+        }
+
+        private RoomAvailability availability;
+        public RoomAvailability Availability
+        {
+            set
+            {
+                if (value == availability) return;
+                availability = value;
+
+                if (IsLoaded)
+                    updateAvailabilityStatus();
+            }
+        }
+
+        private RoomStatus status;
+        public RoomStatus Status
+        {
+            set
+            {
+                if (value == status) return;
+                status = value;
+
+                if (IsLoaded)
+                    updateAvailabilityStatus();
+            }
+        }
+
+        public BeatmapInfo Beatmap
+        {
+            set { beatmapTypeInfo.Beatmap = value; }
+        }
+
+        public GameType Type
+        {
+            set { beatmapTypeInfo.Type = value; }
+        }
+
+        public Info()
+        {
+            RelativeSizeAxes = Axes.X;
+            Height = HEIGHT;
+
+            Children = new Drawable[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = OsuColour.FromHex(@"28242d"),
+                },
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Horizontal = SearchableListOverlay.WIDTH_PADDING },
+                    Children = new Drawable[]
+                    {
+                        new Container
+                        {
+                            RelativeSizeAxes = Axes.Y,
+                            AutoSizeAxes = Axes.X,
+                            Padding = new MarginPadding { Vertical = 20 },
+                            Children = new Drawable[]
+                            {
+                                new FillFlowContainer
+                                {
+                                    AutoSizeAxes = Axes.Both,
+                                    Direction = FillDirection.Vertical,
+                                    Children = new Drawable[]
+                                    {
+                                        name = new OsuSpriteText
+                                        {
+                                            TextSize = 30,
+                                        },
+                                        availabilityStatus = new OsuSpriteText
+                                        {
+                                            TextSize = 14,
+                                        },
+                                    },
+                                },
+                                beatmapTypeInfo = new BeatmapTypeInfo
+                                {
+                                    Anchor = Anchor.BottomLeft,
+                                    Origin = Anchor.BottomLeft,
+                                },
+                            },
+                        },
+                        readyButton = new ReadyButton
+                        {
+                            Anchor = Anchor.TopRight,
+                            Origin = Anchor.TopRight,
+                            RelativeSizeAxes = Axes.Y,
+                            Size = new Vector2(200, 1),
+                            Padding = new MarginPadding { Vertical = 10 },
+                        },
+                    },
+                },
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            this.colours = colours;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            updateAvailabilityStatus();
+        }
+
+        private void updateAvailabilityStatus()
+        {
+            if (status != null)
+            {
+                availabilityStatus.FadeColour(status.GetAppropriateColour(colours), 100);
+                availabilityStatus.Text = $"{availability.GetDescription()}, {status.Message}";
+            }
+        }
+
+        private class ReadyButton : TriangleButton
+        {
+            public readonly Bindable<bool> Ready = new Bindable<bool>();
+
+            protected override SpriteText CreateText() => new OsuSpriteText
+            {
+                Depth = -1,
+                Origin = Anchor.Centre,
+                Anchor = Anchor.Centre,
+                Font = @"Exo2.0-Light",
+                TextSize = 30,
+            };
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                BackgroundColour = OsuColour.FromHex(@"1187aa");
+                Triangles.ColourLight = OsuColour.FromHex(@"277b9c");
+                Triangles.ColourDark = OsuColour.FromHex(@"1f6682");
+                Triangles.TriangleScale = 1.5f;
+
+                Container active;
+                Add(active = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 0f,
+                    Child = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Alpha = 0.15f,
+                        Blending = BlendingMode.Additive,
+                    },
+                });
+
+                Action = () => Ready.Value = !Ready.Value;
+
+                Ready.BindValueChanged(value =>
+                {
+                    if (value)
+                    {
+                        Text = "Not Ready";
+                        active.FadeIn(200);
+                    }
+                    else
+                    {
+                        Text = "Ready";
+                        active.FadeOut(200);
+                    }
+                }, true);
+            }
+        }
+    }
+}

osu.Game/Screens/Multi/Screens/Match/Match.cs

@@ -0,0 +1,81 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Screens.Select;
+using osu.Game.Users;
+
+namespace osu.Game.Screens.Multi.Screens.Match
+{
+    public class Match : MultiplayerScreen
+    {
+        private readonly Room room;
+        private readonly Participants participants;
+
+        private readonly Bindable<string> nameBind = new Bindable<string>();
+        private readonly Bindable<RoomStatus> statusBind = new Bindable<RoomStatus>();
+        private readonly Bindable<RoomAvailability> availabilityBind = new Bindable<RoomAvailability>();
+        private readonly Bindable<GameType> typeBind = new Bindable<GameType>();
+        private readonly Bindable<BeatmapInfo> beatmapBind = new Bindable<BeatmapInfo>();
+        private readonly Bindable<int?> maxParticipantsBind = new Bindable<int?>();
+        private readonly Bindable<IEnumerable<User>> participantsBind = new Bindable<IEnumerable<User>>();
+
+        protected override Container<Drawable> TransitionContent => participants;
+
+        public override string Type => "room";
+        public override string Title => room.Name.Value;
+
+        public Match(Room room)
+        {
+            this.room = room;
+            Header header;
+            Info info;
+
+            Children = new Drawable[]
+            {
+                header = new Header(),
+                info = new Info
+                {
+                    Margin = new MarginPadding { Top = Header.HEIGHT },
+                },
+                participants = new Participants
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Top = Header.HEIGHT + Info.HEIGHT },
+                },
+            };
+
+            header.OnRequestSelectBeatmap = () => Push(new MatchSongSelect());
+
+            beatmapBind.BindTo(room.Beatmap);
+            beatmapBind.BindValueChanged(b =>
+            {
+                header.BeatmapSet = b?.BeatmapSet;
+                info.Beatmap = b;
+            }, true);
+
+            nameBind.BindTo(room.Name);
+            nameBind.BindValueChanged(n => info.Name = n, true);
+
+            statusBind.BindTo(room.Status);
+            statusBind.BindValueChanged(s => info.Status = s, true);
+
+            availabilityBind.BindTo(room.Availability);
+            availabilityBind.BindValueChanged(a => info.Availability = a, true);
+
+            typeBind.BindTo(room.Type);
+            typeBind.BindValueChanged(t => info.Type = t, true);
+
+            maxParticipantsBind.BindTo(room.MaxParticipants);
+            maxParticipantsBind.BindValueChanged(m => { participants.Max = m; }, true);
+
+            participantsBind.BindTo(room.Participants);
+            participantsBind.BindValueChanged(p => participants.Users = p, true);
+        }
+    }
+}

osu.Game/Screens/Multi/Screens/Match/Participants.cs

@@ -0,0 +1,74 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Overlays.SearchableList;
+using osu.Game.Screens.Multi.Components;
+using osu.Game.Users;
+using OpenTK;
+
+namespace osu.Game.Screens.Multi.Screens.Match
+{
+    public class Participants : Container
+    {
+        private readonly ParticipantCount count;
+        private readonly FillFlowContainer<UserPanel> usersFlow;
+
+        public IEnumerable<User> Users
+        {
+            set {
+                usersFlow.Children = value.Select(u => new UserPanel(u)
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
+                    Width = 300,
+                    OnLoadComplete = d => d.FadeInFromZero(60),
+                }).ToList();
+
+                count.Count = value.Count();
+            }
+        }
+
+        public int? Max
+        {
+            set => count.Max = value;
+        }
+
+        public Participants()
+        {
+            Child = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Padding = new MarginPadding { Horizontal = SearchableListOverlay.WIDTH_PADDING },
+                Children = new Drawable[]
+                {
+                    new ScrollContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Padding = new MarginPadding { Top = 10 },
+                        Children = new Drawable[]
+                        {
+                            count = new ParticipantCount
+                            {
+                                Anchor = Anchor.TopRight,
+                                Origin = Anchor.TopRight,
+                            },
+                            usersFlow = new FillFlowContainer<UserPanel>
+                            {
+                                RelativeSizeAxes = Axes.X,
+                                AutoSizeAxes = Axes.Y,
+                                Spacing = new Vector2(5),
+                                Padding = new MarginPadding { Top = 40 },
+                                LayoutDuration = 200,
+                                LayoutEasing = Easing.OutQuint,
+                            },
+                        },
+                    },
+                },
+            };
+        }
+    }
+}

osu.Game/Screens/Multi/Screens/MatchCreate.cs

@@ -1,20 +0,0 @@
-// Copyright (c) 2007-2018 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;
-
-namespace osu.Game.Screens.Multi.Screens
-{
-    public class MatchCreate : ScreenWhiteBox
-    {
-        protected override IEnumerable<Type> PossibleChildren => new[] {
-                typeof(Match)
-        };
-
-        public MatchCreate()
-        {
-            ValidForResume = false;
-        }
-    }
-}

osu.Game/Screens/Multi/Screens/MultiplayerScreen.cs

@@ -10,9 +10,6 @@ namespace osu.Game.Screens.Multi.Screens
 {
     public abstract class MultiplayerScreen : OsuScreen
     {
-        private const Easing in_easing = Easing.OutQuint;
-        private const Easing out_easing = Easing.InSine;
-
         protected virtual Container<Drawable> TransitionContent => Content;
 
         /// <summary>
@@ -24,16 +21,15 @@ namespace osu.Game.Screens.Multi.Screens
         {
             base.OnEntering(last);
 
-            TransitionContent.MoveToX(200);
-
-            TransitionContent.FadeInFromZero(WaveContainer.APPEAR_DURATION, in_easing);
-            TransitionContent.MoveToX(0, WaveContainer.APPEAR_DURATION, in_easing);
+            Content.FadeInFromZero(WaveContainer.APPEAR_DURATION, Easing.OutQuint);
+            TransitionContent.FadeInFromZero(WaveContainer.APPEAR_DURATION, Easing.OutQuint);
+            TransitionContent.MoveToX(200).MoveToX(0, WaveContainer.APPEAR_DURATION, Easing.OutQuint);
         }
 
         protected override bool OnExiting(Screen next)
         {
-            Content.FadeOut(WaveContainer.DISAPPEAR_DURATION, out_easing);
-            TransitionContent.MoveToX(200, WaveContainer.DISAPPEAR_DURATION, out_easing);
+            Content.FadeOut(WaveContainer.DISAPPEAR_DURATION, Easing.OutQuint);
+            TransitionContent.MoveToX(200, WaveContainer.DISAPPEAR_DURATION, Easing.OutQuint);
 
             return base.OnExiting(next);
         }
@@ -42,16 +38,16 @@ namespace osu.Game.Screens.Multi.Screens
         {
             base.OnResuming(last);
 
-            Content.FadeIn(WaveContainer.APPEAR_DURATION, in_easing);
-            TransitionContent.MoveToX(0, WaveContainer.APPEAR_DURATION, in_easing);
+            Content.FadeIn(WaveContainer.APPEAR_DURATION, Easing.OutQuint);
+            TransitionContent.MoveToX(0, WaveContainer.APPEAR_DURATION, Easing.OutQuint);
         }
 
         protected override void OnSuspending(Screen next)
         {
             base.OnSuspending(next);
 
-            Content.FadeOut(WaveContainer.DISAPPEAR_DURATION, out_easing);
-            TransitionContent.MoveToX(-200, WaveContainer.DISAPPEAR_DURATION, out_easing);
+            Content.FadeOut(WaveContainer.DISAPPEAR_DURATION, Easing.OutQuint);
+            TransitionContent.MoveToX(-200, WaveContainer.DISAPPEAR_DURATION, Easing.OutQuint);
         }
     }
 }

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

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -182,14 +183,14 @@ namespace osu.Game.Screens.Play.HUD
 
             protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
             {
-                if (!pendingAnimation && state.Mouse.Buttons.Count == 1)
+                if (!pendingAnimation && state.Mouse.Buttons.Count() == 1)
                     BeginConfirm();
                 return true;
             }
 
             protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
             {
-                if (state.Mouse.Buttons.Count == 0)
+                if (!state.Mouse.Buttons.Any())
                     AbortConfirm();
                 return true;
             }

osu.Game/Screens/Select/MatchSongSelect.cs

@@ -7,12 +7,7 @@ namespace osu.Game.Screens.Select
     {
         protected override bool OnStart()
         {
-            Schedule(() =>
-            {
-                // needs to be scheduled else we enter an infinite feedback loop.
-                if (IsCurrentScreen) Exit();
-            });
-
+            if (IsCurrentScreen) Exit();
             return true;
         }
     }