Merge https://github.com/ppy/osu into song-progress-graph

osu.Game/Screens/BackgroundScreen.cs

@@ -19,8 +19,8 @@ namespace osu.Game.Screens
             return other?.GetType() == GetType();
         }
 
-        const float transition_length = 500;
-        const float x_movement_amount = 50;
+        private const float transition_length = 500;
+        private const float x_movement_amount = 50;
 
         protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
         {
@@ -28,7 +28,7 @@ namespace osu.Game.Screens
             return false;
         }
 
-        Framework.Game game;
+        private Framework.Game game;
 
         [BackgroundDependencyLoader]
         private void load(Framework.Game game)
@@ -58,7 +58,7 @@ namespace osu.Game.Screens
         protected override void Update()
         {
             base.Update();
-            Content.Scale = new Vector2(1 + (x_movement_amount / DrawSize.X) * 2);
+            Content.Scale = new Vector2(1 + x_movement_amount / DrawSize.X * 2);
         }
 
         protected override void OnEntering(Screen last)

osu.Game/Screens/Backgrounds/BackgroundScreenBeatmap.cs

@@ -30,11 +30,7 @@ namespace osu.Game.Screens.Backgrounds
 
                 Schedule(() =>
                 {
-                    Background newBackground;
-                    if (beatmap == null)
-                        newBackground = new Background(@"Backgrounds/bg1");
-                    else
-                        newBackground = new BeatmapBackground(beatmap);
+                    var newBackground = beatmap == null ? new Background(@"Backgrounds/bg1") : new BeatmapBackground(beatmap);
 
                     newBackground.LoadAsync(Game, delegate
                     {
@@ -68,10 +64,13 @@ namespace osu.Game.Screens.Backgrounds
 
         public override bool Equals(BackgroundScreen other)
         {
-            return base.Equals(other) && beatmap == ((BackgroundScreenBeatmap)other).Beatmap;
+            var otherBeatmapBackground = other as BackgroundScreenBeatmap;
+            if (otherBeatmapBackground == null) return false;
+
+            return base.Equals(other) && beatmap == otherBeatmapBackground.Beatmap;
         }
 
-        class BeatmapBackground : Background
+        private class BeatmapBackground : Background
         {
             private WorkingBeatmap beatmap;
 

osu.Game/Screens/Backgrounds/BackgroundScreenCustom.cs

@@ -17,7 +17,10 @@ namespace osu.Game.Screens.Backgrounds
 
         public override bool Equals(BackgroundScreen other)
         {
-            return base.Equals(other) && textureName == ((BackgroundScreenCustom)other).textureName;
+            var backgroundScreenCustom = other as BackgroundScreenCustom;
+            if (backgroundScreenCustom == null) return false;
+
+            return base.Equals(other) && textureName == backgroundScreenCustom.textureName;
         }
     }
 }

osu.Game/Screens/Charts/ChartInfo.cs

@@ -3,7 +3,7 @@
 
 namespace osu.Game.Screens.Charts
 {
-    class ChartInfo : ScreenWhiteBox
+    internal class ChartInfo : ScreenWhiteBox
     {
     }
 }

osu.Game/Screens/Charts/ChartListing.cs

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 
 namespace osu.Game.Screens.Charts
 {
-    class ChartListing : ScreenWhiteBox
+    internal class ChartListing : ScreenWhiteBox
     {
         protected override IEnumerable<Type> PossibleChildren => new[] {
                 typeof(ChartInfo)

osu.Game/Screens/Direct/OnlineListing.cs

@@ -3,7 +3,7 @@
 
 namespace osu.Game.Screens.Direct
 {
-    class OnlineListing : ScreenWhiteBox
+    internal class OnlineListing : ScreenWhiteBox
     {
     }
 }

osu.Game/Screens/Edit/Editor.cs

@@ -1,25 +1,38 @@
 // 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 OpenTK.Graphics;
 using osu.Framework.Screens;
 using osu.Game.Screens.Backgrounds;
-using OpenTK.Graphics;
+using osu.Game.Screens.Select;
 
 namespace osu.Game.Screens.Edit
 {
-    class Editor : ScreenWhiteBox
+    internal class Editor : ScreenWhiteBox
     {
+        protected override IEnumerable<Type> PossibleChildren => new[] { typeof(EditSongSelect) };
+
         protected override BackgroundScreen CreateBackground() => new BackgroundScreenCustom(@"Backgrounds/bg4");
 
+        protected override void OnResuming(Screen last)
+        {
+            Beatmap?.Track?.Stop();
+            base.OnResuming(last);
+        }
+
         protected override void OnEntering(Screen last)
         {
             base.OnEntering(last);
             Background.Schedule(() => Background.FadeColour(Color4.DarkGray, 500));
+            Beatmap?.Track?.Stop();
         }
 
         protected override bool OnExiting(Screen next)
         {
             Background.Schedule(() => Background.FadeColour(Color4.White, 500));
+            Beatmap?.Track?.Start();
             return base.OnExiting(next);
         }
     }

osu.Game/Screens/GameScreenWhiteBox.cs

@@ -21,11 +21,10 @@ namespace osu.Game.Screens
     {
         private BackButton popButton;
 
-        const int transition_time = 1000;
+        private const double transition_time = 1000;
 
         protected virtual IEnumerable<Type> PossibleChildren => null;
 
-        private FillFlowContainer childModeButtons;
         private Container textContainer;
         private Box box;
 
@@ -56,7 +55,7 @@ namespace osu.Game.Screens
 
         protected override bool OnExiting(Screen next)
         {
-            textContainer.MoveTo(new Vector2((DrawSize.X / 16), 0), transition_time, EasingTypes.OutExpo);
+            textContainer.MoveTo(new Vector2(DrawSize.X / 16, 0), transition_time, EasingTypes.OutExpo);
             Content.FadeOut(transition_time, EasingTypes.OutExpo);
 
             return base.OnExiting(next);
@@ -80,6 +79,8 @@ namespace osu.Game.Screens
 
         public ScreenWhiteBox()
         {
+            FillFlowContainer childModeButtons;
+
             Children = new Drawable[]
             {
                 box = new Box
@@ -126,7 +127,7 @@ namespace osu.Game.Screens
                 },
                 childModeButtons = new FillFlowContainer
                 {
-                    Direction = FillDirection.Down,
+                    Direction = FillDirection.Vertical,
                     Anchor = Anchor.TopRight,
                     Origin = Anchor.TopRight,
                     RelativeSizeAxes = Axes.Both,

osu.Game/Screens/Loader.cs

@@ -7,7 +7,7 @@ using osu.Game.Screens.Menu;
 
 namespace osu.Game.Screens
 {
-    class Loader : OsuScreen
+    internal class Loader : OsuScreen
     {
         internal override bool ShowOverlays => false;
 

osu.Game/Screens/Menu/Button.cs

@@ -16,6 +16,7 @@ using osu.Game.Graphics.Sprites;
 using OpenTK;
 using OpenTK.Graphics;
 using OpenTK.Input;
+using osu.Framework.Extensions.Color4Extensions;
 
 namespace osu.Game.Screens.Menu
 {
@@ -27,32 +28,20 @@ namespace osu.Game.Screens.Menu
     {
         private Container iconText;
         private Container box;
-        private Box boxColourLayer;
         private Box boxHoverLayer;
-        private Color4 colour;
         private TextAwesome icon;
         private string internalName;
-        private readonly FontAwesome symbol;
         private Action clickAction;
-        private readonly float extraWidth;
         private Key triggerKey;
-        private string text;
         private SampleChannel sampleClick;
 
-        public override bool Contains(Vector2 screenSpacePos)
-        {
-            return box.Contains(screenSpacePos);
-        }
+        protected override bool InternalContains(Vector2 screenSpacePos) => box.Contains(screenSpacePos);
 
         public Button(string text, string internalName, FontAwesome symbol, Color4 colour, Action clickAction = null, float extraWidth = 0, Key triggerKey = Key.Unknown)
         {
             this.internalName = internalName;
-            this.symbol = symbol;
-            this.colour = colour;
             this.clickAction = clickAction;
-            this.extraWidth = extraWidth;
             this.triggerKey = triggerKey;
-            this.text = text;
 
             AutoSizeAxes = Axes.Both;
             Alpha = 0;
@@ -79,7 +68,7 @@ namespace osu.Game.Screens.Menu
                     Shear = new Vector2(ButtonSystem.WEDGE_WIDTH / boxSize.Y, 0),
                     Children = new []
                     {
-                        boxColourLayer = new Box
+                        new Box
                         {
                             EdgeSmoothness = new Vector2(1.5f, 0),
                             RelativeSizeAxes = Axes.Both,
@@ -107,6 +96,7 @@ namespace osu.Game.Screens.Menu
                         {
                             Shadow = true,
                             Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
                             TextSize = 30,
                             Position = new Vector2(0, 0),
                             Icon = symbol
@@ -232,9 +222,7 @@ namespace osu.Game.Screens.Menu
         [BackgroundDependencyLoader]
         private void load(AudioManager audio)
         {
-            sampleClick = audio.Sample.Get($@"Menu/menu-{internalName}-click");
-            if (sampleClick == null)
-                sampleClick = audio.Sample.Get(internalName.Contains(@"back") ? @"Menu/menuback" : @"Menu/menuhit");
+            sampleClick = audio.Sample.Get($@"Menu/menu-{internalName}-click") ?? audio.Sample.Get(internalName.Contains(@"back") ? @"Menu/menuback" : @"Menu/menuhit");
         }
 
         protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
@@ -257,7 +245,8 @@ namespace osu.Game.Screens.Menu
 
         protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
         {
-            if (args.Repeat) return false;
+            if (args.Repeat || state.Keyboard.ControlPressed || state.Keyboard.ShiftPressed || state.Keyboard.AltPressed)
+                return false;
 
             if (triggerKey == args.Key && triggerKey != Key.Unknown)
             {
@@ -289,7 +278,7 @@ namespace osu.Game.Screens.Menu
 
         public int ContractStyle;
 
-        ButtonState state;
+        private ButtonState state;
 
         public ButtonState State
         {
@@ -320,12 +309,12 @@ namespace osu.Game.Screens.Menu
                     case ButtonState.Expanded:
                         const int expand_duration = 500;
                         box.ScaleTo(new Vector2(1, 1), expand_duration, EasingTypes.OutExpo);
-                        FadeIn(expand_duration / 6);
+                        FadeIn(expand_duration / 6f);
                         break;
                     case ButtonState.Exploded:
                         const int explode_duration = 200;
                         box.ScaleTo(new Vector2(2, 1), explode_duration, EasingTypes.OutExpo);
-                        FadeOut(explode_duration / 4 * 3);
+                        FadeOut(explode_duration / 4f * 3);
                         break;
                 }
             }

osu.Game/Screens/Menu/ButtonSystem.cs

@@ -6,7 +6,6 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Framework;
 using osu.Framework.Allocation;
-using osu.Framework.Audio;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
@@ -20,7 +19,7 @@ using OpenTK.Input;
 
 namespace osu.Game.Screens.Menu
 {
-    public partial class ButtonSystem : Container, IStateful<MenuState>
+    public class ButtonSystem : Container, IStateful<MenuState>
     {
         public Action OnEdit;
         public Action OnExit;
@@ -50,8 +49,8 @@ namespace osu.Game.Screens.Menu
         private Button backButton;
         private Button settingsButton;
 
-        List<Button> buttonsTopLevel = new List<Button>();
-        List<Button> buttonsPlay = new List<Button>();
+        private List<Button> buttonsTopLevel = new List<Button>();
+        private List<Button> buttonsPlay = new List<Button>();
 
         public ButtonSystem()
         {
@@ -78,7 +77,7 @@ namespace osu.Game.Screens.Menu
                         },
                         buttonFlow = new FlowContainerWithOrigin
                         {
-                            Direction = FillDirection.Right,
+                            Direction = FillDirection.Horizontal,
                             Spacing = new Vector2(-WEDGE_WIDTH, 0),
                             Anchor = Anchor.Centre,
                             AutoSizeAxes = Axes.Both,
@@ -188,7 +187,7 @@ namespace osu.Game.Screens.Menu
             }
         }
 
-        MenuState state;
+        private MenuState state;
 
         public override bool HandleInput => state != MenuState.Exit;
 

osu.Game/Screens/Menu/Disclaimer.cs

@@ -13,7 +13,7 @@ using OpenTK.Graphics;
 
 namespace osu.Game.Screens.Menu
 {
-    class Disclaimer : OsuScreen
+    internal class Disclaimer : OsuScreen
     {
         private Intro intro;
         private TextAwesome icon;
@@ -21,6 +21,8 @@ namespace osu.Game.Screens.Menu
 
         internal override bool ShowOverlays => false;
 
+        internal override bool HasLocalCursorDisplayed => true;
+
         public Disclaimer()
         {
             ValidForResume = false;
@@ -32,7 +34,7 @@ namespace osu.Game.Screens.Menu
                     AutoSizeAxes = Axes.Both,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Direction = FillDirection.Down,
+                    Direction = FillDirection.Vertical,
                     Spacing = new Vector2(0, 2),
                     Children = new Drawable[]
                     {

osu.Game/Screens/Menu/Intro.cs

@@ -23,11 +23,13 @@ namespace osu.Game.Screens.Menu
         /// </summary>
         internal bool DidLoadMenu;
 
-        MainMenu mainMenu;
+        private MainMenu mainMenu;
         private SampleChannel welcome;
         private SampleChannel seeya;
         private Track bgm;
 
+        internal override bool HasLocalCursorDisplayed => true;
+
         internal override bool ShowOverlays => false;
 
         protected override BackgroundScreen CreateBackground() => new BackgroundScreenEmpty();

osu.Game/Screens/Menu/MainMenu.cs

@@ -10,20 +10,24 @@ using osu.Game.Graphics.Containers;
 using osu.Game.Screens.Backgrounds;
 using osu.Game.Screens.Charts;
 using osu.Game.Screens.Direct;
+using osu.Game.Screens.Edit;
 using osu.Game.Screens.Multiplayer;
 using OpenTK;
 using osu.Game.Screens.Select;
+using osu.Game.Screens.Tournament;
+using osu.Framework.Input;
+using OpenTK.Input;
 
 namespace osu.Game.Screens.Menu
 {
     public class MainMenu : OsuScreen
     {
         private ButtonSystem buttons;
-        public override string Name => @"Main Menu";
 
         internal override bool ShowOverlays => buttons.State != MenuState.Initial;
 
         private BackgroundScreen background;
+        private Screen songSelect;
 
         protected override BackgroundScreen CreateBackground() => background;
 
@@ -42,8 +46,8 @@ namespace osu.Game.Screens.Menu
                         {
                             OnChart = delegate { Push(new ChartListing()); },
                             OnDirect = delegate { Push(new OnlineListing()); },
-                            OnEdit = delegate { Push(new EditSongSelect()); },
-                            OnSolo = delegate { Push(new PlaySongSelect()); },
+                            OnEdit = delegate { Push(new Editor()); },
+                            OnSolo = delegate { Push(consumeSongSelect()); },
                             OnMulti = delegate { Push(new Lobby()); },
                             OnTest  = delegate { Push(new TestBrowser()); },
                             OnExit = delegate { Exit(); },
@@ -59,6 +63,24 @@ namespace osu.Game.Screens.Menu
             background.LoadAsync(game);
 
             buttons.OnSettings = game.ToggleOptions;
+
+            preloadSongSelect();
+        }
+
+        private void preloadSongSelect()
+        {
+            if (songSelect == null)
+            {
+                songSelect = new PlaySongSelect();
+                songSelect.LoadAsync(Game);
+            }
+        }
+
+        private Screen consumeSongSelect()
+        {
+            var s = songSelect;
+            songSelect = null;
+            return s;
         }
 
         protected override void OnEntering(Screen last)
@@ -83,6 +105,9 @@ namespace osu.Game.Screens.Menu
         {
             base.OnResuming(last);
 
+            //we may have consumed our preloaded instance, so let's make another.
+            preloadSongSelect();
+
             const float length = 300;
 
             buttons.State = MenuState.TopLevel;
@@ -97,5 +122,16 @@ namespace osu.Game.Screens.Menu
             Content.FadeOut(3000);
             return base.OnExiting(next);
         }
+
+        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        {
+            if (!args.Repeat && state.Keyboard.ControlPressed && state.Keyboard.ShiftPressed && args.Key == Key.D)
+            {
+                Push(new Drawings());
+                return true;
+            }
+
+            return base.OnKeyDown(state, args);
+        }
     }
 }

osu.Game/Screens/Menu/OsuLogo.cs

@@ -50,10 +50,7 @@ namespace osu.Game.Screens.Menu
             }
         }
 
-        public override bool Contains(Vector2 screenSpacePos)
-        {
-            return logoContainer.Contains(screenSpacePos);
-        }
+        protected override bool InternalContains(Vector2 screenSpacePos) => logoContainer.Contains(screenSpacePos);
 
         public bool Ripple
         {
@@ -141,7 +138,7 @@ namespace osu.Game.Screens.Menu
                                     Origin = Anchor.Centre,
                                     Children = new Drawable[]
                                     {
-                                        ripple = new Sprite()
+                                        ripple = new Sprite
                                         {
                                             Anchor = Anchor.Centre,
                                             Origin = Anchor.Centre,

osu.Game/Screens/Multiplayer/Lobby.cs

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 
 namespace osu.Game.Screens.Multiplayer
 {
-    class Lobby : ScreenWhiteBox
+    internal class Lobby : ScreenWhiteBox
     {
         protected override IEnumerable<Type> PossibleChildren => new[] {
                 typeof(MatchCreate),

osu.Game/Screens/Multiplayer/Match.cs

@@ -11,7 +11,7 @@ using osu.Game.Screens.Select;
 
 namespace osu.Game.Screens.Multiplayer
 {
-    class Match : ScreenWhiteBox
+    internal class Match : ScreenWhiteBox
     {
         protected override IEnumerable<Type> PossibleChildren => new[] {
             typeof(MatchSongSelect),

osu.Game/Screens/Multiplayer/MatchCreate.cs

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 
 namespace osu.Game.Screens.Multiplayer
 {
-    class MatchCreate : ScreenWhiteBox
+    internal class MatchCreate : ScreenWhiteBox
     {
         protected override IEnumerable<Type> PossibleChildren => new[] {
                 typeof(Match)

osu.Game/Screens/OsuGameScreen.cs

@@ -24,6 +24,8 @@ namespace osu.Game.Screens
 
         protected new OsuGameBase Game => base.Game as OsuGameBase;
 
+        internal virtual bool HasLocalCursorDisplayed => false;
+
         private readonly Bindable<WorkingBeatmap> beatmap = new Bindable<WorkingBeatmap>();
 
         public WorkingBeatmap Beatmap
@@ -69,6 +71,8 @@ namespace osu.Game.Screens
 
             BackgroundScreen bg = CreateBackground();
 
+            OnBeatmapChanged(Beatmap);
+
             if (lastOsu?.Background != null)
             {
                 if (bg == null || lastOsu.Background.Equals(bg))

osu.Game/Screens/Play/FailDialog.cs

@@ -10,7 +10,7 @@ using OpenTK.Graphics;
 
 namespace osu.Game.Screens.Play
 {
-    class FailDialog : OsuScreen
+    internal class FailDialog : OsuScreen
     {
         protected override BackgroundScreen CreateBackground() => new BackgroundScreenBeatmap(Beatmap);
 

osu.Game/Screens/Play/KeyConversionInputManager.cs

@@ -0,0 +1,16 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Input;
+
+namespace osu.Game.Screens.Play
+{
+    /// <summary>
+    /// An InputManager primarily used to map keys to new functions.
+    /// By default this does nothing; override TransformState to make alterations.
+    /// </summary>
+    public class KeyConversionInputManager : PassThroughInputManager
+    {
+
+    }
+}

osu.Game/Screens/Play/KeyCounter.cs

@@ -19,7 +19,6 @@ namespace osu.Game.Screens.Play
         private Container textLayer;
         private SpriteText countSpriteText;
 
-        public override string Name { get; }
         public bool IsCounting { get; set; }
         private int count;
         public int Count
@@ -54,7 +53,7 @@ namespace osu.Game.Screens.Play
         //further: change default values here and in KeyCounterCollection if needed, instead of passing them in every constructor
         public Color4 KeyDownTextColor { get; set; } = Color4.DarkGray;
         public Color4 KeyUpTextColor { get; set; } = Color4.White;
-        public int FadeTime { get; set; } = 0;
+        public int FadeTime { get; set; }
 
         protected KeyCounter(string name)
         {

osu.Game/Screens/Play/KeyCounterCollection.cs

@@ -1,10 +1,11 @@
 // 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.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using OpenTK;
 using OpenTK.Graphics;
+using osu.Framework.Input;
 
 namespace osu.Game.Screens.Play
 {
@@ -12,7 +13,9 @@ namespace osu.Game.Screens.Play
     {
         public KeyCounterCollection()
         {
-            Direction = FillDirection.Right;
+            AlwaysReceiveInput = true;
+
+            Direction = FillDirection.Horizontal;
             AutoSizeAxes = Axes.Both;
         }
 
@@ -31,8 +34,6 @@ namespace osu.Game.Screens.Play
                 counter.ResetCount();
         }
 
-        public override bool Contains(Vector2 screenSpacePos) => true;
-
         //further: change default values here and in KeyCounter if needed, instead of passing them in every constructor
         private bool isCounting;
         public bool IsCounting
@@ -49,7 +50,7 @@ namespace osu.Game.Screens.Play
             }
         }
 
-        private int fadeTime = 0;
+        private int fadeTime;
         public int FadeTime
         {
             get { return fadeTime; }
@@ -93,5 +94,36 @@ namespace osu.Game.Screens.Play
                 }
             }
         }
+
+        public override bool HandleInput => receptor?.IsAlive != true;
+
+        private Receptor receptor;
+
+        public Receptor GetReceptor()
+        {
+            return receptor ?? (receptor = new Receptor(this));
+        }
+
+        public class Receptor : Drawable
+        {
+            private KeyCounterCollection target;
+
+            public Receptor(KeyCounterCollection target)
+            {
+                AlwaysReceiveInput = true;
+                RelativeSizeAxes = Axes.Both;
+                this.target = target;
+            }
+
+            public override bool HandleInput => true;
+
+            protected override bool OnKeyDown(InputState state, KeyDownEventArgs args) => target.Children.Any(c => c.TriggerKeyDown(state, args));
+
+            protected override bool OnKeyUp(InputState state, KeyUpEventArgs args) => target.Children.Any(c => c.TriggerKeyUp(state, args));
+
+            protected override bool OnMouseDown(InputState state, MouseDownEventArgs args) => target.Children.Any(c => c.TriggerMouseDown(state, args));
+
+            protected override bool OnMouseUp(InputState state, MouseUpEventArgs args) => target.Children.Any(c => c.TriggerMouseUp(state, args));
+        }
     }
 }

osu.Game/Screens/Play/KeyCounterKeyboard.cs

@@ -9,7 +9,7 @@ namespace osu.Game.Screens.Play
     public class KeyCounterKeyboard : KeyCounter
     {
         public Key Key { get; }
-        public KeyCounterKeyboard(string name, Key key) : base(name)
+        public KeyCounterKeyboard(Key key) : base(key.ToString())
         {
             Key = key;
         }

osu.Game/Screens/Play/KeyCounterMouse.cs

@@ -2,7 +2,6 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Input;
-using OpenTK;
 using OpenTK.Input;
 
 namespace osu.Game.Screens.Play
@@ -10,12 +9,25 @@ namespace osu.Game.Screens.Play
     public class KeyCounterMouse : KeyCounter
     {
         public MouseButton Button { get; }
-        public KeyCounterMouse(string name, MouseButton button) : base(name)
+
+        public KeyCounterMouse(MouseButton button) : base(getStringRepresentation(button))
         {
+            AlwaysReceiveInput = true;
             Button = button;
         }
 
-        public override bool Contains(Vector2 screenSpacePos) => true;
+        private static string getStringRepresentation(MouseButton button)
+        {
+            switch (button)
+            {
+                default:
+                    return button.ToString();
+                case MouseButton.Left:
+                    return @"M1";
+                case MouseButton.Right:
+                    return @"M2";
+            }
+        }
 
         protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
         {

osu.Game/Screens/Play/ModSelect.cs

@@ -1,26 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Framework.Screens;
-using osu.Game.Screens.Backgrounds;
-using OpenTK.Graphics;
-
-namespace osu.Game.Screens.Play
-{
-    class ModSelect : ScreenWhiteBox
-    {
-        protected override BackgroundScreen CreateBackground() => new BackgroundScreenCustom(@"Backgrounds/bg4");
-
-        protected override void OnEntering(Screen last)
-        {
-            base.OnEntering(last);
-            Background.Schedule(() => Background.FadeColour(Color4.DarkGray, 500));
-        }
-
-        protected override bool OnExiting(Screen next)
-        {
-            Background.Schedule(() => Background.FadeColour(Color4.White, 500));
-            return base.OnExiting(next);
-        }
-    }
-}

osu.Game/Screens/Play/Pause/PauseProgressBar.cs

@@ -0,0 +1,150 @@
+// Copyright (c) 2007-2017 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.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Beatmaps;
+using OpenTK.Graphics;
+
+namespace osu.Game.Screens.Play.Pause
+{
+    public class PauseProgressBar : Container
+    {
+        private Color4 fillColour = new Color4(221, 255, 255, 255);
+        private Color4 glowColour = new Color4(221, 255, 255, 150);
+
+        private Container fill;
+        private WorkingBeatmap current;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuGameBase osuGame)
+        {
+            current = osuGame.Beatmap.Value;
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (current?.TrackLoaded ?? false)
+            {
+                fill.Width = (float)(current.Track.CurrentTime / current.Track.Length);
+            }
+        }
+
+        public PauseProgressBar()
+        {
+            RelativeSizeAxes = Axes.X;
+            Height = 60;
+
+            Children = new Drawable[]
+            {
+                new PauseProgressGraph
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Origin = Anchor.BottomCentre,
+                    Anchor = Anchor.BottomCentre,
+                    Height = 35,
+                    Margin = new MarginPadding
+                    {
+                        Bottom = 5
+                    }
+                },
+                new Container
+                {
+                    Origin = Anchor.BottomRight,
+                    Anchor = Anchor.BottomRight,
+                    RelativeSizeAxes = Axes.X,
+                    Height = 5,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = Color4.Black,
+                            Alpha = 0.5f
+                        }
+                    }
+                },
+                fill = new Container
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Origin = Anchor.BottomLeft,
+                    Anchor = Anchor.BottomLeft,
+                    Width = 0,
+                    Height = 60,
+                    Children = new Drawable[]
+                    {
+                        new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Origin = Anchor.BottomLeft,
+                            Anchor = Anchor.BottomLeft,
+                            Masking = true,
+                            Children = new Drawable[]
+                            {
+                                new Container
+                                {
+                                    Origin = Anchor.BottomLeft,
+                                    Anchor = Anchor.BottomLeft,
+                                    RelativeSizeAxes = Axes.X,
+                                    Height = 5,
+                                    Masking = true,
+                                    EdgeEffect = new EdgeEffect
+                                    {
+                                        Type = EdgeEffectType.Glow,
+                                        Colour = glowColour,
+                                        Radius = 5
+                                    },
+                                    Children = new Drawable[]
+                                    {
+                                        new Box
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            Colour = fillColour
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        new Container
+                        {
+                            Origin = Anchor.BottomRight,
+                            Anchor = Anchor.BottomRight,
+                            Width = 2,
+                            Height = 35,
+                            Children = new Drawable[]
+                            {
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = Color4.White
+                                },
+                                new Container
+                                {
+                                    Origin = Anchor.BottomCentre,
+                                    Anchor = Anchor.TopCentre,
+                                    Width = 14,
+                                    Height = 25,
+                                    CornerRadius = 5,
+                                    Masking = true,
+                                    Children = new Drawable[]
+                                    {
+                                        new Box
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            Colour = Color4.White
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+        }
+    }
+}

osu.Game/Screens/Play/Pause/PauseProgressGraph.cs

@@ -0,0 +1,12 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics.Containers;
+
+namespace osu.Game.Screens.Play.Pause
+{
+    public class PauseProgressGraph : Container
+    {
+        // TODO: Implement the pause progress graph
+    }
+}

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

@@ -0,0 +1,26 @@
+// Copyright (c) 2007-2017 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.Audio;
+using osu.Game.Graphics.UserInterface;
+using OpenTK.Graphics;
+
+namespace osu.Game.Screens.Play.Pause
+{
+    public class QuitButton : DialogButton
+    {
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio)
+        {
+            ButtonColour = new Color4(170, 27, 39, 255); // The red from the design isn't in the palette so it's used directly
+            SampleHover = audio.Sample.Get(@"Menu/menuclick");
+            SampleClick = audio.Sample.Get(@"Menu/menuback");
+        }
+
+        public QuitButton()
+        {
+            Text = @"Quit to Main Menu";
+        }
+    }
+}

osu.Game/Screens/Play/Pause/ResumeButton.cs

@@ -0,0 +1,26 @@
+// Copyright (c) 2007-2017 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.Audio;
+using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
+
+namespace osu.Game.Screens.Play.Pause
+{
+    public class ResumeButton : DialogButton
+    {
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio, OsuColour colours)
+        {
+            ButtonColour = colours.Green;
+            SampleHover = audio.Sample.Get(@"Menu/menuclick");
+            SampleClick = audio.Sample.Get(@"Menu/menuback");
+        }
+
+        public ResumeButton()
+        {
+            Text = @"Continue";
+        }
+    }
+}

osu.Game/Screens/Play/Pause/RetryButton.cs

@@ -0,0 +1,26 @@
+// Copyright (c) 2007-2017 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.Audio;
+using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
+
+namespace osu.Game.Screens.Play.Pause
+{
+    public class RetryButton : DialogButton
+    {
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio, OsuColour colours)
+        {
+            ButtonColour = colours.YellowDark;
+            SampleHover = audio.Sample.Get(@"Menu/menuclick");
+            SampleClick = audio.Sample.Get(@"Menu/menu-play-click");
+        }
+
+        public RetryButton()
+        {
+            Text = @"Retry";
+        }
+    }
+}

osu.Game/Screens/Play/PauseOverlay.cs

@@ -0,0 +1,219 @@
+// 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 osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Transforms;
+using osu.Framework.Input;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Screens.Play.Pause;
+using OpenTK;
+using OpenTK.Graphics;
+using OpenTK.Input;
+
+namespace osu.Game.Screens.Play
+{
+    public class PauseOverlay : OverlayContainer
+    {
+        private const int transition_duration = 200;
+        private const int button_height = 70;
+        private const float background_alpha = 0.75f;
+
+        protected override bool HideOnEscape => false;
+
+        public Action OnResume;
+        public Action OnRetry;
+        public Action OnQuit;
+
+        public int Retries
+        {
+            set
+            {
+                if (retryCounterContainer != null)
+                {
+                    // "You've retried 1,065 times in this session"
+                    // "You've retried 1 time in this session"
+
+                    retryCounterContainer.Children = new Drawable[]
+                    {
+                        new OsuSpriteText
+                        {
+                            Text = "You've retried ",
+                            Shadow = true,
+                            ShadowColour = new Color4(0, 0, 0, 0.25f),
+                            TextSize = 18
+                        },
+                        new OsuSpriteText
+                        {
+                            Text = $"{value:n0}",
+                            Font = @"Exo2.0-Bold",
+                            Shadow = true,
+                            ShadowColour = new Color4(0, 0, 0, 0.25f),
+                            TextSize = 18
+                        },
+                        new OsuSpriteText
+                        {
+                            Text = $" time{(value == 1 ? "" : "s")} in this session",
+                            Shadow = true,
+                            ShadowColour = new Color4(0, 0, 0, 0.25f),
+                            TextSize = 18
+                        }
+                    };
+                }
+            }
+        }
+
+        private FillFlowContainer retryCounterContainer;
+
+        public override bool HandleInput => State == Visibility.Visible;
+
+        protected override void PopIn() => FadeIn(transition_duration, EasingTypes.In);
+        protected override void PopOut() => FadeOut(transition_duration, EasingTypes.In);
+
+        // Don't let mouse down events through the overlay or people can click circles while paused.
+        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args) => true;
+
+        protected override bool OnMouseMove(InputState state) => true;
+
+        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        {
+            if (args.Key == Key.Escape)
+            {
+                if (State == Visibility.Hidden) return false;
+                resume();
+                return true;
+            }
+
+            return base.OnKeyDown(state, args);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Children = new Drawable[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Color4.Black,
+                    Alpha = background_alpha,
+                },
+                new FillFlowContainer
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Direction = FillDirection.Vertical,
+                    Spacing = new Vector2(0, 50),
+                    Origin = Anchor.Centre,
+                    Anchor = Anchor.Centre,
+                    Children = new Drawable[]
+                    {
+                        new FillFlowContainer
+                        {
+                            Origin = Anchor.TopCentre,
+                            Anchor = Anchor.TopCentre,
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            Direction = FillDirection.Vertical,
+                            Spacing = new Vector2(0, 20),
+                            Children = new Drawable[]
+                            {
+                                new OsuSpriteText
+                                {
+                                    Text = @"paused",
+                                    Font = @"Exo2.0-Medium",
+                                    Spacing = new Vector2(5, 0),
+                                    Origin = Anchor.TopCentre,
+                                    Anchor = Anchor.TopCentre,
+                                    TextSize = 30,
+                                    Colour = colours.Yellow,
+                                    Shadow = true,
+                                    ShadowColour = new Color4(0, 0, 0, 0.25f)
+                                },
+                                new OsuSpriteText
+                                {
+                                    Text = @"you're not going to do what i think you're going to do, are ya?",
+                                    Origin = Anchor.TopCentre,
+                                    Anchor = Anchor.TopCentre,
+                                    Shadow = true,
+                                    ShadowColour = new Color4(0, 0, 0, 0.25f)
+                                }
+                            }
+                        },
+                        new FillFlowContainer
+                        {
+                            Origin = Anchor.TopCentre,
+                            Anchor = Anchor.TopCentre,
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            Masking = true,
+                            EdgeEffect = new EdgeEffect
+                            {
+                                Type = EdgeEffectType.Shadow,
+                                Colour = Color4.Black.Opacity(0.6f),
+                                Radius = 50
+                            },
+                            Children = new Drawable[]
+                            {
+                                new ResumeButton
+                                {
+                                    Origin = Anchor.TopCentre,
+                                    Anchor = Anchor.TopCentre,
+                                    Height = button_height,
+                                    Action = resume
+                                },
+                                new RetryButton
+                                {
+                                    Origin = Anchor.TopCentre,
+                                    Anchor = Anchor.TopCentre,
+                                    Height = button_height,
+                                    Action = delegate
+                                    {
+                                        OnRetry?.Invoke();
+                                        Hide();
+                                    }
+                                },
+                                new QuitButton
+                                {
+                                    Origin = Anchor.TopCentre,
+                                    Anchor = Anchor.TopCentre,
+                                    Height = button_height,
+                                    Action = delegate
+                                    {
+                                        OnQuit?.Invoke();
+                                        Hide();
+                                    }
+                                }
+                            }
+                        },
+                        retryCounterContainer = new FillFlowContainer
+                        {
+                            Origin = Anchor.TopCentre,
+                            Anchor = Anchor.TopCentre,
+                            AutoSizeAxes = Axes.Both,
+                        }
+                    }
+                }
+            };
+
+            Retries = 0;
+        }
+
+        private void resume()
+        {
+            OnResume?.Invoke();
+            Hide();
+        }
+
+        public PauseOverlay()
+        {
+            AlwaysReceiveInput = true;
+            RelativeSizeAxes = Axes.Both;
+        }
+    }
+}

osu.Game/Screens/Play/Player.cs

@@ -1,62 +1,54 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using OpenTK;
+using OpenTK.Graphics;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Track;
-using osu.Framework.Extensions.IEnumerableExtensions;
-using osu.Framework.Graphics;
-using osu.Framework.Timing;
-using osu.Game.Database;
-using osu.Game.Modes;
-using osu.Game.Modes.Objects.Drawables;
-using osu.Game.Screens.Backgrounds;
-using OpenTK;
-using osu.Framework.Screens;
-using osu.Game.Modes.UI;
-using osu.Game.Screens.Ranking;
-using osu.Game.Configuration;
-using osu.Game.Overlays.Pause;
 using osu.Framework.Configuration;
-using System;
-using System.Linq;
-using OpenTK.Graphics;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Transforms;
-using osu.Framework.Logging;
 using osu.Framework.Input;
+using osu.Framework.Logging;
+using osu.Framework.Screens;
+using osu.Framework.Timing;
+using osu.Game.Configuration;
+using osu.Game.Database;
+using osu.Game.Input.Handlers;
+using osu.Game.Modes;
+using osu.Game.Modes.UI;
+using osu.Game.Screens.Backgrounds;
+using osu.Game.Screens.Ranking;
+using System;
+using System.Linq;
 
 namespace osu.Game.Screens.Play
 {
     public class Player : OsuScreen
     {
-        public bool Autoplay;
-
         protected override BackgroundScreen CreateBackground() => new BackgroundScreenBeatmap(Beatmap);
 
         internal override bool ShowOverlays => false;
 
+        internal override bool HasLocalCursorDisplayed => !hasReplayLoaded && !IsPaused;
+
+        private bool hasReplayLoaded => hitRenderer.InputManager.ReplayInputHandler != null;
+
         public BeatmapInfo BeatmapInfo;
 
-        public PlayMode PreferredPlayMode;
-
-        private bool isPaused;
-        public bool IsPaused
-        {
-            get
-            {
-                return isPaused;
-            }
-        }
+        public bool IsPaused { get; private set; }
 
         public int RestartCount;
 
         private double pauseCooldown = 1000;
-        private double lastPauseActionTime = 0;
+        private double lastPauseActionTime;
 
-        private bool canPause => Time.Current >= (lastPauseActionTime + pauseCooldown);
+        private bool canPause => Time.Current >= lastPauseActionTime + pauseCooldown;
 
         private IAdjustableClock sourceClock;
+        private IFrameBasedClock interpolatedSourceClock;
 
         private Ruleset ruleset;
 
@@ -65,13 +57,21 @@ namespace osu.Game.Screens.Play
         private Bindable<int> dimLevel;
         private SkipButton skipButton;
 
-        private ScoreOverlay scoreOverlay;
+        private HudOverlay hudOverlay;
         private PauseOverlay pauseOverlay;
-        private PlayerInputManager playerInputManager;
 
         [BackgroundDependencyLoader]
-        private void load(AudioManager audio, BeatmapDatabase beatmaps, OsuGameBase game, OsuConfigManager config)
+        private void load(AudioManager audio, BeatmapDatabase beatmaps, OsuConfigManager config)
         {
+            var beatmap = Beatmap.Beatmap;
+
+            if (beatmap.BeatmapInfo?.Mode > PlayMode.Osu)
+            {
+                //we only support osu! mode for now because the hitobject parsing is crappy and needs a refactor.
+                Exit();
+                return;
+            }
+
             dimLevel = config.GetBindable<int>(OsuConfig.DimLevel);
             mouseWheelDisabled = config.GetBindable<bool>(OsuConfig.MouseDisableWheel);
 
@@ -82,6 +82,9 @@ namespace osu.Game.Screens.Play
 
                 if ((Beatmap?.Beatmap?.HitObjects.Count ?? 0) == 0)
                     throw new Exception("No valid objects were found!");
+
+                if (Beatmap == null)
+                    throw new Exception("Beatmap was not loaded");
             }
             catch (Exception e)
             {
@@ -101,27 +104,21 @@ namespace osu.Game.Screens.Play
             }
 
             sourceClock = (IAdjustableClock)track ?? new StopwatchClock();
+            interpolatedSourceClock = new InterpolatingFramedClock(sourceClock);
 
             Schedule(() =>
             {
                 sourceClock.Reset();
             });
 
-            var beatmap = Beatmap.Beatmap;
+            ruleset = Ruleset.GetRuleset(Beatmap.PlayMode);
+            hitRenderer = ruleset.CreateHitRendererWith(Beatmap);
 
-            if (beatmap.BeatmapInfo?.Mode > PlayMode.Osu)
-            {
-                //we only support osu! mode for now because the hitobject parsing is crappy and needs a refactor.
-                Exit();
-                return;
-            }
+            scoreProcessor = hitRenderer.CreateScoreProcessor();
 
-            PlayMode usablePlayMode = beatmap.BeatmapInfo?.Mode > PlayMode.Osu ? beatmap.BeatmapInfo.Mode : PreferredPlayMode;
-
-            ruleset = Ruleset.GetRuleset(usablePlayMode);
-
-            scoreOverlay = ruleset.CreateScoreOverlay();
-            scoreOverlay.BindProcessor(scoreProcessor = ruleset.CreateScoreProcessor(beatmap.HitObjects.Count));
+            hudOverlay = new StandardHudOverlay();
+            hudOverlay.KeyCounter.Add(ruleset.CreateGameplayKeys());
+            hudOverlay.BindProcessor(scoreProcessor);
 
             pauseOverlay = new PauseOverlay
             {
@@ -135,30 +132,34 @@ namespace osu.Game.Screens.Play
                 OnQuit = Exit
             };
 
-            hitRenderer = ruleset.CreateHitRendererWith(beatmap);
+
+            if (ReplayInputHandler != null)
+                hitRenderer.InputManager.ReplayInputHandler = ReplayInputHandler;
+
+            hudOverlay.BindHitRenderer(hitRenderer);
 
             //bind HitRenderer to ScoreProcessor and ourselves (for a pass situation)
-            hitRenderer.OnJudgement += scoreProcessor.AddJudgement;
-            hitRenderer.OnAllJudged += onPass;
+            hitRenderer.OnAllJudged += onCompletion;
 
             //bind ScoreProcessor to ourselves (for a fail situation)
             scoreProcessor.Failed += onFail;
 
-            if (Autoplay)
-                hitRenderer.Schedule(() => hitRenderer.DrawableObjects.ForEach(h => h.State = ArmedState.Hit));
-
             Children = new Drawable[]
             {
-                playerInputManager = new PlayerInputManager(game.Host)
+                new Container
                 {
-                    Clock = new InterpolatingFramedClock(sourceClock),
+                    RelativeSizeAxes = Axes.Both,
+                    Clock = interpolatedSourceClock,
                     Children = new Drawable[]
                     {
                         hitRenderer,
-                        skipButton = new SkipButton { Alpha = 0 },
+                        skipButton = new SkipButton
+                        {
+                            Alpha = 0
+                        },
                     }
                 },
-                scoreOverlay,
+                hudOverlay,
                 pauseOverlay
             };
         }
@@ -195,30 +196,30 @@ namespace osu.Game.Screens.Play
             if (canPause || force)
             {
                 lastPauseActionTime = Time.Current;
-                scoreOverlay.KeyCounter.IsCounting = false;
+                hudOverlay.KeyCounter.IsCounting = false;
                 pauseOverlay.Retries = RestartCount;
                 pauseOverlay.Show();
                 sourceClock.Stop();
-                isPaused = true;
+                IsPaused = true;
             }
             else
             {
-                isPaused = false;
+                IsPaused = false;
             }
         }
 
         public void Resume()
         {
             lastPauseActionTime = Time.Current;
-            scoreOverlay.KeyCounter.IsCounting = true;
+            hudOverlay.KeyCounter.IsCounting = true;
             pauseOverlay.Hide();
             sourceClock.Start();
-            isPaused = false;
+            IsPaused = false;
         }
 
         public void TogglePaused()
         {
-            isPaused = !IsPaused;
+            IsPaused = !IsPaused;
             if (IsPaused) Pause(); else Resume();
         }
 
@@ -240,15 +241,19 @@ namespace osu.Game.Screens.Play
             });
         }
 
-        private void onPass()
+        private void onCompletion()
         {
+            // Only show the completion screen if the player hasn't failed
+            if (scoreProcessor.HasFailed)
+                return;
+
             Delay(1000);
             Schedule(delegate
             {
                 ValidForResume = false;
                 Push(new Results
                 {
-                    Score = scoreProcessor.GetScore()
+                    Score = scoreProcessor.CreateScore()
                 });
             });
         }
@@ -303,6 +308,9 @@ namespace osu.Game.Screens.Play
         {
             if (pauseOverlay == null) return false;
 
+            if (hasReplayLoaded)
+                return false;
+
             if (pauseOverlay.State != Visibility.Visible && !canPause) return true;
 
             if (!IsPaused && sourceClock.IsRunning) // For if the user presses escape quickly when entering the map
@@ -328,6 +336,8 @@ namespace osu.Game.Screens.Play
 
         private Bindable<bool> mouseWheelDisabled;
 
-        protected override bool OnWheel(InputState state) => mouseWheelDisabled.Value && !isPaused;
+        public ReplayInputHandler ReplayInputHandler;
+
+        protected override bool OnWheel(InputState state) => mouseWheelDisabled.Value && !IsPaused;
     }
 }

osu.Game/Screens/Play/PlayerInputManager.cs

@@ -1,57 +1,71 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK.Input;
-using osu.Framework.Allocation;
-using osu.Framework.Configuration;
 using osu.Framework.Input;
-using osu.Framework.Platform;
-using osu.Game.Configuration;
-using System.Linq;
+using osu.Framework.Timing;
+using osu.Game.Input.Handlers;
 
 namespace osu.Game.Screens.Play
 {
-    class PlayerInputManager : UserInputManager
+    public class PlayerInputManager : PassThroughInputManager
     {
-        public PlayerInputManager(GameHost host)
-            : base(host)
+        private ManualClock clock = new ManualClock();
+        private IFrameBasedClock parentClock;
+
+        private ReplayInputHandler replayInputHandler;
+        public ReplayInputHandler ReplayInputHandler
         {
-        }
-
-        bool leftViaKeyboard;
-        bool rightViaKeyboard;
-        Bindable<bool> mouseDisabled;
-
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
-        {
-            mouseDisabled = config.GetBindable<bool>(OsuConfig.MouseDisableButtons)
-                ?? new Bindable<bool>(false);
-        }
-
-        protected override void TransformState(InputState state)
-        {
-            base.TransformState(state);
-
-            if (state.Keyboard != null)
+            get { return replayInputHandler; }
+            set
             {
-                leftViaKeyboard = state.Keyboard.Keys.Contains(Key.Z);
-                rightViaKeyboard = state.Keyboard.Keys.Contains(Key.X);
+                if (replayInputHandler != null) RemoveHandler(replayInputHandler);
+
+                replayInputHandler = value;
+                UseParentState = replayInputHandler == null;
+
+                if (replayInputHandler != null)
+                    AddHandler(replayInputHandler);
+            }
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            parentClock = Clock;
+            Clock = new FramedClock(clock);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (parentClock == null) return;
+
+            clock.Rate = parentClock.Rate;
+            clock.IsRunning = parentClock.IsRunning;
+
+            //if a replayHandler is not attached, we should just pass-through.
+            if (UseParentState || replayInputHandler == null)
+            {
+                clock.CurrentTime = parentClock.CurrentTime;
+                base.Update();
+                return;
             }
 
-            var mouse = (Framework.Input.MouseState)state.Mouse;
-            if (state.Mouse != null)
+            while (true)
             {
-                if (mouseDisabled.Value)
-                {
-                    mouse.ButtonStates.Find(s => s.Button == MouseButton.Left).State = false;
-                    mouse.ButtonStates.Find(s => s.Button == MouseButton.Right).State = false;
-                }
+                double? newTime = replayInputHandler.SetFrameFromTime(parentClock.CurrentTime);
 
-                if (leftViaKeyboard)
-                    mouse.ButtonStates.Find(s => s.Button == MouseButton.Left).State = true;
-                if (rightViaKeyboard)
-                    mouse.ButtonStates.Find(s => s.Button == MouseButton.Right).State = true;
+                if (newTime == null)
+                    //we shouldn't execute for this time value
+                    break;
+
+                if (clock.CurrentTime == parentClock.CurrentTime)
+                    break;
+
+                clock.CurrentTime = newTime.Value;
+                base.Update();
             }
         }
     }

osu.Game/Screens/Play/PlayerLoader.cs

@@ -95,9 +95,9 @@ namespace osu.Game.Screens.Play
             return base.OnExiting(next);
         }
 
-        class BeatmapMetadataDisplay : Container
+        private class BeatmapMetadataDisplay : Container
         {
-            class MetadataLine : Container
+            private class MetadataLine : Container
             {
                 public MetadataLine(string left, string right)
                 {
@@ -131,12 +131,12 @@ namespace osu.Game.Screens.Play
                 AutoSizeAxes = Axes.Both;
                 Children = new Drawable[]
                 {
-                    new FillFlowContainer()
+                    new FillFlowContainer
                     {
                         AutoSizeAxes = Axes.Both,
                         Origin = Anchor.TopCentre,
                         Anchor = Anchor.TopCentre,
-                        Direction = FillDirection.Down,
+                        Direction = FillDirection.Vertical,
                         Children = new Drawable[]
                         {
                             new OsuSpriteText
@@ -167,7 +167,7 @@ namespace osu.Game.Screens.Play
                                 {
                                     new Sprite
                                     {
-                                        Texture = beatmap.Background,
+                                        Texture = beatmap?.Background,
                                         Origin = Anchor.Centre,
                                         Anchor = Anchor.Centre,
                                         FillMode = FillMode.Fill,
@@ -176,7 +176,7 @@ namespace osu.Game.Screens.Play
                             },
                             new OsuSpriteText
                             {
-                                Text = beatmap.BeatmapInfo?.Version,
+                                Text = beatmap?.BeatmapInfo?.Version,
                                 TextSize = 26,
                                 Font = @"Exo2.0-MediumItalic",
                                 Origin = Anchor.TopCentre,

osu.Game/Screens/Play/SongProgressGraphColumn.cs

@@ -4,9 +4,9 @@
 using OpenTK;
 using OpenTK.Graphics;
 using System.Collections.Generic;
-using osu.Game.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Extensions.Color4Extensions;
 
 namespace osu.Game.Screens.Play
 {

osu.Game/Screens/Ranking/Results.cs

@@ -13,13 +13,13 @@ using OpenTK.Graphics;
 
 namespace osu.Game.Screens.Ranking
 {
-    class Results : OsuScreen
+    internal class Results : OsuScreen
     {
         protected override BackgroundScreen CreateBackground() => new BackgroundScreenBeatmap(Beatmap);
 
         private static readonly Vector2 background_blur = new Vector2(20);
 
-        ScoreDisplay scoreDisplay;
+        private ScoreDisplay scoreDisplay;
 
         protected override void OnEntering(Screen last)
         {
@@ -57,7 +57,7 @@ namespace osu.Game.Screens.Ranking
         }
     }
 
-    class ScoreDisplay : Container
+    internal class ScoreDisplay : Container
     {
         public ScoreDisplay(Score s)
         {
@@ -68,7 +68,7 @@ namespace osu.Game.Screens.Ranking
                 new FillFlowContainer
                 {
                     AutoSizeAxes = Axes.Both,
-                    Direction = FillDirection.Down,
+                    Direction = FillDirection.Vertical,
                     Children = new Drawable[]
                     {
                         new OsuSpriteText

osu.Game/Screens/Select/BeatmapCarousel.cs

@@ -9,110 +9,255 @@ using osu.Game.Database;
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using osu.Framework.Lists;
 using osu.Game.Beatmaps.Drawables;
-using osu.Framework.Timing;
 using osu.Framework.Input;
 using OpenTK.Input;
 using System.Collections;
 using osu.Framework.MathUtils;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using osu.Framework.Allocation;
+using osu.Framework.Threading;
 
 namespace osu.Game.Screens.Select
 {
-    class CarouselContainer : ScrollContainer, IEnumerable<BeatmapGroup>
+    internal class BeatmapCarousel : ScrollContainer, IEnumerable<BeatmapGroup>
     {
-        private Container<Panel> scrollableContent;
-        private List<BeatmapGroup> groups = new List<BeatmapGroup>();
+        public BeatmapInfo SelectedBeatmap => selectedPanel?.Beatmap;
 
-        public BeatmapGroup SelectedGroup { get; private set; }
-        public BeatmapPanel SelectedPanel { get; private set; }
+        public Action BeatmapsChanged;
+
+        public IEnumerable<BeatmapSetInfo> Beatmaps
+        {
+            get
+            {
+                return groups.Select(g => g.BeatmapSet);
+            }
+
+            set
+            {
+                scrollableContent.Clear(false);
+                panels.Clear();
+                groups.Clear();
+
+                List<BeatmapGroup> newGroups = null;
+
+                Task.Run(() =>
+                {
+                    newGroups = value.Select(createGroup).ToList();
+                    criteria.Filter(newGroups);
+                }).ContinueWith(t =>
+                {
+                    Schedule(() =>
+                    {
+                        foreach (var g in newGroups)
+                            addGroup(g);
+
+                        computeYPositions();
+                        BeatmapsChanged?.Invoke();
+                    });
+                });
+            }
+        }
 
         private List<float> yPositions = new List<float>();
-        private CarouselLifetimeList<Panel> lifetime;
 
-        public CarouselContainer()
+        /// <summary>
+        /// Required for now unfortunately.
+        /// </summary>
+        private BeatmapDatabase database;
+
+        private Container<Panel> scrollableContent;
+
+        private List<BeatmapGroup> groups = new List<BeatmapGroup>();
+
+        private List<Panel> panels = new List<Panel>();
+
+        private BeatmapGroup selectedGroup;
+
+        private BeatmapPanel selectedPanel;
+
+        public BeatmapCarousel()
         {
-            DistanceDecayJump = 0.01;
-
-            Add(scrollableContent = new Container<Panel>(lifetime = new CarouselLifetimeList<Panel>(DepthComparer))
+            Add(scrollableContent = new Container<Panel>
             {
                 RelativeSizeAxes = Axes.X,
             });
         }
 
-        internal class CarouselLifetimeList<T> : LifetimeList<Panel>
+        public void AddBeatmap(BeatmapSetInfo beatmapSet)
         {
-            public CarouselLifetimeList(IComparer<Panel> comparer)
-                : base(comparer)
+            var group = createGroup(beatmapSet);
+
+            //for the time being, let's completely load the difficulty panels in the background.
+            //this likely won't scale so well, but allows us to completely async the loading flow.
+            Schedule(delegate
             {
+                addGroup(group);
+                computeYPositions();
+                if (selectedGroup == null)
+                    selectGroup(group);
+            });
+        }
+
+        public void SelectBeatmap(BeatmapInfo beatmap, bool animated = true)
+        {
+            if (beatmap == null)
+            {
+                SelectNext();
+                return;
             }
 
-            public int StartIndex;
-            public int EndIndex;
-
-            public override bool Update(FrameTimeInfo time)
+            foreach (BeatmapGroup group in groups)
             {
-                bool anyAliveChanged = false;
-
-                //check existing items to make sure they haven't died.
-                foreach (var item in AliveItems.ToArray())
+                var panel = group.BeatmapPanels.FirstOrDefault(p => p.Beatmap.Equals(beatmap));
+                if (panel != null)
                 {
-                    item.UpdateTime(time);
-                    if (!item.IsAlive)
-                    {
-                        //todo: make this more efficient
-                        int i = IndexOf(item);
-                        anyAliveChanged |= CheckItem(item, ref i);
-                    }
+                    selectGroup(group, panel, animated);
+                    return;
                 }
-
-                //handle custom range
-                for (int i = StartIndex; i < EndIndex; i++)
-                {
-                    var item = this[i];
-                    item.UpdateTime(time);
-                    anyAliveChanged |= CheckItem(item, ref i);
-                }
-
-                return anyAliveChanged;
             }
         }
 
-        public void AddGroup(BeatmapGroup group)
+        public void RemoveBeatmap(BeatmapSetInfo info) => removeGroup(groups.Find(b => b.BeatmapSet.ID == info.ID));
+
+        public Action<BeatmapGroup, BeatmapInfo> SelectionChanged;
+
+        public Action StartRequested;
+
+        public void SelectNext(int direction = 1, bool skipDifficulties = true)
+        {
+            if (groups.Count == 0)
+            {
+                selectedGroup = null;
+                selectedPanel = null;
+                return;
+            }
+
+            if (!skipDifficulties && selectedGroup != null)
+            {
+                int i = selectedGroup.BeatmapPanels.IndexOf(selectedPanel) + direction;
+
+                if (i >= 0 && i < selectedGroup.BeatmapPanels.Count)
+                {
+                    //changing difficulty panel, not set.
+                    selectGroup(selectedGroup, selectedGroup.BeatmapPanels[i]);
+                    return;
+                }
+            }
+
+            int startIndex = groups.IndexOf(selectedGroup);
+            int index = startIndex;
+
+            do
+            {
+                index = (index + direction + groups.Count) % groups.Count;
+                if (groups[index].State != BeatmapGroupState.Hidden)
+                {
+                    SelectBeatmap(groups[index].BeatmapPanels.First().Beatmap);
+                    return;
+                }
+            } while (index != startIndex);
+        }
+
+        public void SelectRandom()
+        {
+            List<BeatmapGroup> visibleGroups = groups.Where(selectGroup => selectGroup.State != BeatmapGroupState.Hidden).ToList();
+            if (visibleGroups.Count < 1)
+                return;
+            BeatmapGroup group = visibleGroups[RNG.Next(visibleGroups.Count)];
+            BeatmapPanel panel = group?.BeatmapPanels.First();
+
+            if (panel == null)
+                return;
+
+            selectGroup(group, panel);
+        }
+
+        private FilterCriteria criteria = new FilterCriteria();
+
+        private ScheduledDelegate filterTask;
+
+        public void Filter(FilterCriteria newCriteria = null, bool debounce = true)
+        {
+            if (!IsLoaded) return;
+
+            criteria = newCriteria ?? criteria ?? new FilterCriteria();
+
+            Action perform = delegate
+            {
+                filterTask = null;
+
+                criteria.Filter(groups);
+
+                var filtered = new List<BeatmapGroup>(groups);
+
+                scrollableContent.Clear(false);
+                panels.Clear();
+                groups.Clear();
+
+                foreach (var g in filtered)
+                    addGroup(g);
+
+                computeYPositions();
+
+                if (selectedGroup == null || selectedGroup.State == BeatmapGroupState.Hidden)
+                    SelectNext();
+            };
+
+            filterTask?.Cancel();
+            if (debounce)
+                filterTask = Scheduler.AddDelayed(perform, 250);
+            else
+                perform();
+        }
+
+        public IEnumerator<BeatmapGroup> GetEnumerator() => groups.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        private BeatmapGroup createGroup(BeatmapSetInfo beatmapSet)
+        {
+            database.GetChildren(beatmapSet);
+            beatmapSet.Beatmaps.ForEach(b => { if (b.Metadata == null) b.Metadata = beatmapSet.Metadata; });
+
+            return new BeatmapGroup(beatmapSet, database)
+            {
+                SelectionChanged = SelectionChanged,
+                StartRequested = b => StartRequested?.Invoke(),
+                State = BeatmapGroupState.Collapsed
+            };
+        }
+
+        [BackgroundDependencyLoader(permitNulls: true)]
+        private void load(BeatmapDatabase database)
+        {
+            this.database = database;
+        }
+
+        private void addGroup(BeatmapGroup group)
         {
-            group.State = BeatmapGroupState.Collapsed;
             groups.Add(group);
-
-            group.Header.Depth = -scrollableContent.Children.Count();
-            scrollableContent.Add(group.Header);
-
-            foreach (BeatmapPanel panel in group.BeatmapPanels)
-            {
-                panel.Depth = -scrollableContent.Children.Count();
-                scrollableContent.Add(panel);
-            }
-
-            computeYPositions();
+            panels.Add(group.Header);
+            panels.AddRange(group.BeatmapPanels);
         }
 
-        public void RemoveGroup(BeatmapGroup group)
+        private void removeGroup(BeatmapGroup group)
         {
             groups.Remove(group);
+            panels.Remove(group.Header);
+            foreach (var p in group.BeatmapPanels)
+                panels.Remove(p);
+
             scrollableContent.Remove(group.Header);
             scrollableContent.Remove(group.BeatmapPanels);
 
+            if (selectedGroup == group)
+                SelectNext();
+
             computeYPositions();
         }
 
-        private void movePanel(Panel panel, bool advance, bool animated, ref float currentY)
-        {
-            yPositions.Add(currentY);
-            panel.MoveToY(currentY, animated && (panel.IsOnScreen || panel.State != PanelSelectedState.Hidden) ? 750 : 0, EasingTypes.OutExpo);
-
-            if (advance)
-                currentY += panel.DrawHeight + 5;
-        }
-
         /// <summary>
         /// Computes the target Y positions for every panel in the carousel.
         /// </summary>
@@ -135,7 +280,7 @@ namespace osu.Game.Screens.Select
 
                     foreach (BeatmapPanel panel in group.BeatmapPanels)
                     {
-                        if (panel == SelectedPanel)
+                        if (panel == selectedPanel)
                             selectedY = currentY + panel.DrawHeight / 2 - DrawHeight / 2;
 
                         panel.MoveToX(-50, 500, EasingTypes.OutExpo);
@@ -165,85 +310,118 @@ namespace osu.Game.Screens.Select
             return selectedY;
         }
 
-        public void SelectBeatmap(BeatmapInfo beatmap, bool animated = true)
+        private void movePanel(Panel panel, bool advance, bool animated, ref float currentY)
         {
-            foreach (BeatmapGroup group in groups)
-            {
-                var panel = group.BeatmapPanels.FirstOrDefault(p => p.Beatmap.Equals(beatmap));
-                if (panel != null)
-                {
-                    SelectGroup(group, panel, animated);
-                    return;
-                }
-            }
+            yPositions.Add(currentY);
+            panel.MoveToY(currentY, animated ? 750 : 0, EasingTypes.OutExpo);
+
+            if (advance)
+                currentY += panel.DrawHeight + 5;
         }
 
-        public void SelectGroup(BeatmapGroup group, BeatmapPanel panel, bool animated = true)
+        private void selectGroup(BeatmapGroup group, BeatmapPanel panel = null, bool animated = true)
         {
-            if (SelectedGroup != null && SelectedGroup != group && SelectedGroup.State != BeatmapGroupState.Hidden)
-                SelectedGroup.State = BeatmapGroupState.Collapsed;
+            if (panel == null)
+                panel = group.BeatmapPanels.First();
+
+            Trace.Assert(group.BeatmapPanels.Contains(panel), @"Selected panel must be in provided group");
+
+            if (selectedGroup != null && selectedGroup != group && selectedGroup.State != BeatmapGroupState.Hidden)
+                selectedGroup.State = BeatmapGroupState.Collapsed;
 
             group.State = BeatmapGroupState.Expanded;
-            SelectedGroup = group;
+            selectedGroup = group;
             panel.State = PanelSelectedState.Selected;
-            SelectedPanel = panel;
+            selectedPanel = panel;
 
             float selectedY = computeYPositions(animated);
             ScrollTo(selectedY, animated);
         }
 
-        public void Sort(FilterControl.SortMode mode) {
-            switch (mode) { 
-                case FilterControl.SortMode.Artist:
-                    groups.Sort((x, y) => string.Compare(x.BeatmapSet.Metadata.Artist, y.BeatmapSet.Metadata.Artist));
-                    break;
-                case FilterControl.SortMode.Title:
-                    groups.Sort((x, y) => string.Compare(x.BeatmapSet.Metadata.Title, y.BeatmapSet.Metadata.Title));
-                    break;
-                case FilterControl.SortMode.Author:
-                    groups.Sort((x, y) => string.Compare(x.BeatmapSet.Metadata.Author, y.BeatmapSet.Metadata.Author));
-                    break;
-                case FilterControl.SortMode.Difficulty:
-                    groups.Sort((x, y) =>
-                    {
-                        float xAverage=0, yAverage=0;
-                        int counter=0;
-                        foreach (BeatmapInfo set in x.BeatmapSet.Beatmaps) {
-                            xAverage += set.StarDifficulty;
-                            counter++;
-                        }
-                        xAverage /= counter;
-                        counter = 0;
-                        foreach (BeatmapInfo set in y.BeatmapSet.Beatmaps) {
-                            yAverage += set.StarDifficulty;
-                            counter++;
-                        }
-                        yAverage /= counter;
-                        if (xAverage > yAverage)
-                            return 1;
-                        else
-                            return -1;
-                    });
-                    break;
-                default:
-                    throw new NotImplementedException();
-            }
-            scrollableContent.Clear(false);
-            lifetime.Clear();
-            foreach (BeatmapGroup group in groups)
-            {
-                group.Header.Depth = -scrollableContent.Children.Count();
-                scrollableContent.Add(group.Header);
+        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        {
+            int direction = 0;
+            bool skipDifficulties = false;
 
-                foreach (BeatmapPanel panel in group.BeatmapPanels)
+            switch (args.Key)
+            {
+                case Key.Up:
+                    direction = -1;
+                    break;
+                case Key.Down:
+                    direction = 1;
+                    break;
+                case Key.Left:
+                    direction = -1;
+                    skipDifficulties = true;
+                    break;
+                case Key.Right:
+                    direction = 1;
+                    skipDifficulties = true;
+                    break;
+            }
+
+            if (direction == 0)
+                return base.OnKeyDown(state, args);
+
+            SelectNext(direction, skipDifficulties);
+            return true;
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            float drawHeight = DrawHeight;
+
+            // Remove all panels that should no longer be on-screen
+            scrollableContent.RemoveAll(delegate (Panel p)
+            {
+                float panelPosY = p.Position.Y;
+                bool remove = panelPosY < Current - p.DrawHeight || panelPosY > Current + drawHeight || !p.IsPresent;
+                return remove;
+            });
+
+            // Find index range of all panels that should be on-screen
+            Trace.Assert(panels.Count == yPositions.Count);
+
+            int firstIndex = yPositions.BinarySearch(Current - Panel.MAX_HEIGHT);
+            if (firstIndex < 0) firstIndex = ~firstIndex;
+            int lastIndex = yPositions.BinarySearch(Current + drawHeight);
+            if (lastIndex < 0) lastIndex = ~lastIndex;
+
+            // Add those panels within the previously found index range that should be displayed.
+            for (int i = firstIndex; i < lastIndex; ++i)
+            {
+                Panel panel = panels[i];
+                if (panel.State == PanelSelectedState.Hidden)
+                    continue;
+
+                // Only add if we're not already part of the content.
+                if (!scrollableContent.Contains(panel))
                 {
-                    panel.Depth = -scrollableContent.Children.Count();
+                    // Makes sure headers are always _below_ panels,
+                    // and depth flows downward.
+                    panel.Depth = i + (panel is BeatmapSetHeader ? panels.Count : 0);
                     scrollableContent.Add(panel);
                 }
             }
-            SelectGroup(groups.FirstOrDefault(), groups.First().BeatmapPanels.FirstOrDefault());
+
+            // Update externally controlled state of currently visible panels
+            // (e.g. x-offset and opacity).
+            float halfHeight = drawHeight / 2;
+            foreach (Panel p in scrollableContent.Children)
+                updatePanel(p, halfHeight);
         }
 
+        /// <summary>
+        /// Computes the x-offset of currently visible panels. Makes the carousel appear round.
+        /// </summary>
+        /// <param name="dist">
+        /// Vertical distance from the center of the carousel container
+        /// ranging from -1 to 1.
+        /// </param>
+        /// <param name="halfHeight">Half the height of the carousel container.</param>
         private static float offsetX(float dist, float halfHeight)
         {
             // The radius of the circle the carousel moves on.
@@ -277,112 +455,5 @@ namespace osu.Game.Screens.Select
             // layer transformations on top, with a similar reasoning to the previous comment.
             p.SetMultiplicativeAlpha(MathHelper.Clamp(1.75f - 1.5f * dist, 0, 1));
         }
-
-        protected override void Update()
-        {
-            base.Update();
-
-            // Determine which items stopped being on screen for future removal from the lifetimelist.
-            float drawHeight = DrawHeight;
-            float halfHeight = drawHeight / 2;
-
-            foreach (Panel p in lifetime.AliveItems)
-            {
-                float panelPosY = p.Position.Y;
-                p.IsOnScreen = panelPosY >= Current - p.DrawHeight && panelPosY <= Current + drawHeight;
-                updatePanel(p, halfHeight);
-            }
-
-            // Determine range of indices for items that are now definitely on screen to be added
-            // to the lifetimelist in the future.
-            int firstIndex = yPositions.BinarySearch(Current - Panel.MAX_HEIGHT);
-            if (firstIndex < 0) firstIndex = ~firstIndex;
-            int lastIndex = yPositions.BinarySearch(Current + drawHeight);
-            if (lastIndex < 0) lastIndex = ~lastIndex;
-
-            lifetime.StartIndex = firstIndex;
-            lifetime.EndIndex = lastIndex;
-
-            for (int i = firstIndex; i < lastIndex; ++i)
-            {
-                Panel p = lifetime[i];
-                if (p.State != PanelSelectedState.Hidden)
-                    p.IsOnScreen = true; //we don't want to update the on-screen state of hidden pannels as they have incorrect (stacked) y values.
-                updatePanel(p, halfHeight);
-            }
-        }
-
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
-        {
-            int direction = 0;
-            bool skipDifficulties = false;
-
-            switch (args.Key)
-            {
-                case Key.Up:
-                    direction = -1;
-                    break;
-                case Key.Down:
-                    direction = 1;
-                    break;
-                case Key.Left:
-                    direction = -1;
-                    skipDifficulties = true;
-                    break;
-                case Key.Right:
-                    direction = 1;
-                    skipDifficulties = true;
-                    break;
-            }
-
-            if (direction == 0)
-                return base.OnKeyDown(state, args);
-
-            SelectNext(direction, skipDifficulties);
-            return true;
-        }
-
-        public void SelectNext(int direction = 1, bool skipDifficulties = true)
-        {
-            if (!skipDifficulties)
-            {
-                int i = SelectedGroup.BeatmapPanels.IndexOf(SelectedPanel) + direction;
-
-                if (i >= 0 && i < SelectedGroup.BeatmapPanels.Count)
-                {
-                    //changing difficulty panel, not set.
-                    SelectGroup(SelectedGroup, SelectedGroup.BeatmapPanels[i]);
-                    return;
-                }
-            }
-
-            int startIndex = groups.IndexOf(SelectedGroup);
-            int index = startIndex;
-
-            do
-            {
-                index = (index + direction + groups.Count) % groups.Count;
-                if (groups[index].State != BeatmapGroupState.Hidden)
-                {
-                    SelectBeatmap(groups[index].BeatmapPanels.First().Beatmap);
-                    return;
-                }
-            } while (index != startIndex);
-        }
-
-        public void SelectRandom()
-        {
-            if (groups.Count < 1)
-                return;
-            BeatmapGroup group = groups[RNG.Next(groups.Count)];
-            BeatmapPanel panel = group?.BeatmapPanels.First();
-            if (panel == null)
-                return;
-            SelectGroup(group, panel);
-        }
-
-        public IEnumerator<BeatmapGroup> GetEnumerator() => groups.GetEnumerator();
-
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
     }
 }

osu.Game/Screens/Select/BeatmapDeleteDialog.cs

@@ -8,7 +8,7 @@ using osu.Game.Database;
 using osu.Game.Graphics;
 using osu.Game.Overlays.Dialog;
 
-namespace osu.Game
+namespace osu.Game.Screens.Select
 {
     public class BeatmapDeleteDialog : PopupDialog
     {
@@ -22,9 +22,11 @@ namespace osu.Game
 
         public BeatmapDeleteDialog(WorkingBeatmap beatmap)
         {
+            if (beatmap == null) throw new ArgumentNullException(nameof(beatmap));
+
             Icon = FontAwesome.fa_trash_o;
             HeaderText = @"Confirm deletion of";
-            BodyText = $@"{beatmap?.Beatmap?.Metadata?.Artist} - {beatmap?.Beatmap?.Metadata?.Title}";
+            BodyText = $@"{beatmap.Beatmap?.Metadata?.Artist} - {beatmap.Beatmap?.Metadata?.Title}";
             Buttons = new PopupDialogButton[]
             {
                 new PopupDialogOkButton

osu.Game/Screens/Select/BeatmapInfoWedge.cs

@@ -3,27 +3,30 @@
 
 using System;
 using System.Collections.Generic;
-using osu.Framework.Allocation;
+using System.Linq;
 using OpenTK;
 using OpenTK.Graphics;
+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.Primitives;
 using osu.Framework.Graphics.Sprites;
-using osu.Game.Beatmaps;
-using osu.Game.Database;
-using osu.Framework.Graphics.Colour;
-using osu.Game.Beatmaps.Drawables;
-using System.Linq;
-using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics.Transforms;
 using osu.Framework.MathUtils;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Drawables;
+using osu.Game.Database;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Modes;
+using osu.Game.Modes.Objects;
+using osu.Game.Modes.Objects.Types;
 
 namespace osu.Game.Screens.Select
 {
-    class BeatmapInfoWedge : Container
+    internal class BeatmapInfoWedge : OverlayContainer
     {
         private static readonly Vector2 wedged_container_shear = new Vector2(0.15f, 0);
 
@@ -52,11 +55,32 @@ namespace osu.Game.Screens.Select
             this.game = game;
         }
 
+        protected override bool HideOnEscape => false;
+
+        protected override void PopIn()
+        {
+            MoveToX(0, 800, EasingTypes.OutQuint);
+            RotateTo(0, 800, EasingTypes.OutQuint);
+        }
+
+        protected override void PopOut()
+        {
+            MoveToX(-100, 800, EasingTypes.InQuint);
+            RotateTo(10, 800, EasingTypes.InQuint);
+        }
+
         public void UpdateBeatmap(WorkingBeatmap beatmap)
         {
-            if (beatmap == null)
+            if (beatmap?.BeatmapInfo == null)
+            {
+                State = Visibility.Hidden;
+                beatmapInfoContainer?.FadeOut(250);
+                beatmapInfoContainer?.Expire();
+                beatmapInfoContainer = null;
                 return;
+            }
 
+            State = Visibility.Visible;
             var lastContainer = beatmapInfoContainer;
 
             float newDepth = lastContainer?.Depth + 1 ?? 0;
@@ -68,11 +92,14 @@ namespace osu.Game.Screens.Select
 
             if (beatmap.Beatmap != null)
             {
+                HitObject lastObject = beatmap.Beatmap.HitObjects.LastOrDefault();
+                double endTime = (lastObject as IHasEndTime)?.EndTime ?? lastObject?.StartTime ?? 0;
+
                 labels.Add(new InfoLabel(new BeatmapStatistic
                 {
                     Name = "Length",
                     Icon = FontAwesome.fa_clock_o,
-                    Content = beatmap.Beatmap.HitObjects.Count == 0 ? "-" : TimeSpan.FromMilliseconds(beatmap.Beatmap.HitObjects.Last().EndTime - beatmap.Beatmap.HitObjects.First().StartTime).ToString(@"m\:ss"),
+                    Content = beatmap.Beatmap.HitObjects.Count == 0 ? "-" : TimeSpan.FromMilliseconds(endTime - beatmap.Beatmap.HitObjects.First().StartTime).ToString(@"m\:ss"),
                 }));
 
                 labels.Add(new InfoLabel(new BeatmapStatistic
@@ -83,7 +110,7 @@ namespace osu.Game.Screens.Select
                 }));
 
                 //get statistics fromt he current ruleset.
-                Ruleset.GetRuleset(beatmap.BeatmapInfo.Mode).GetBeatmapStatistics(beatmap).ForEach(s => labels.Add(new InfoLabel(s)));
+                labels.AddRange(Ruleset.GetRuleset(beatmap.BeatmapInfo.Mode).GetBeatmapStatistics(beatmap).Select(s => new InfoLabel(s)));
             }
 
             (beatmapInfoContainer = new BufferedContainer
@@ -125,7 +152,7 @@ namespace osu.Game.Screens.Select
                     {
                         Anchor = Anchor.BottomLeft,
                         Origin = Anchor.BottomLeft,
-                        Direction = FillDirection.Down,
+                        Direction = FillDirection.Vertical,
                         Margin = new MarginPadding { Top = 10, Left = 25, Right = 10, Bottom = 20 },
                         AutoSizeAxes = Axes.Both,
                         Children = new Drawable[]
@@ -147,7 +174,7 @@ namespace osu.Game.Screens.Select
                             new FillFlowContainer
                             {
                                 Margin = new MarginPadding { Top = 10 },
-                                Direction = FillDirection.Right,
+                                Direction = FillDirection.Horizontal,
                                 AutoSizeAxes = Axes.Both,
                                 Children = new []
                                 {
@@ -190,12 +217,12 @@ namespace osu.Game.Screens.Select
 
         private string getBPMRange(Beatmap beatmap)
         {
-            double bpmMax = beatmap.BPMMaximum; 
-            double bpmMin = beatmap.BPMMinimum;
+            double bpmMax = beatmap.TimingInfo.BPMMaximum;
+            double bpmMin = beatmap.TimingInfo.BPMMinimum;
 
             if (Precision.AlmostEquals(bpmMin, bpmMax)) return Math.Round(bpmMin) + "bpm";
 
-            return Math.Round(bpmMin) + "-" + Math.Round(bpmMax) + "bpm (mostly " + Math.Round(beatmap.BPMMode) + "bpm)";
+            return Math.Round(bpmMin) + "-" + Math.Round(bpmMax) + "bpm (mostly " + Math.Round(beatmap.TimingInfo.BPMMode) + "bpm)";
         }
 
         public class InfoLabel : Container
@@ -208,14 +235,18 @@ namespace osu.Game.Screens.Select
                     new TextAwesome
                     {
                         Icon = FontAwesome.fa_square,
+                        Origin = Anchor.Centre,
                         Colour = new Color4(68, 17, 136, 255),
-                        Rotation = 45
+                        Rotation = 45,
+                        TextSize = 20
                     },
                     new TextAwesome
                     {
                         Icon = statistic.Icon,
+                        Origin = Anchor.Centre,
                         Colour = new Color4(255, 221, 85, 255),
-                        Scale = new Vector2(0.8f)
+                        Scale = new Vector2(0.8f),
+                        TextSize = 20
                     },
                     new OsuSpriteText
                     {

osu.Game/Screens/Select/EditSongSelect.cs

@@ -1,19 +1,12 @@
 // 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 osu.Game.Screens.Backgrounds;
-using osu.Game.Screens.Edit;
-
 namespace osu.Game.Screens.Select
 {
-    class EditSongSelect : ScreenWhiteBox
+    public class EditSongSelect : SongSelect
     {
-        protected override IEnumerable<Type> PossibleChildren => new[] {
-                typeof(Editor)
-        };
+        protected override bool ShowFooter => false;
 
-        protected override BackgroundScreen CreateBackground() => new BackgroundScreenCustom(@"Backgrounds/bg4");
+        protected override void OnSelected() => Exit();
     }
 }

osu.Game/Screens/Select/Filter/GroupMode.cs

@@ -0,0 +1,41 @@
+// 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.ComponentModel;
+
+namespace osu.Game.Screens.Select.Filter
+{
+    public enum GroupMode
+    {
+        [Description("All")]
+        All,
+        [Description("Artist")]
+        Artist,
+        [Description("Author")]
+        Author,
+        [Description("BPM")]
+        BPM,
+        [Description("Collections")]
+        Collections,
+        [Description("Date Added")]
+        DateAdded,
+        [Description("Difficulty")]
+        Difficulty,
+        [Description("Favorites")]
+        Favorites,
+        [Description("Length")]
+        Length,
+        [Description("My Maps")]
+        MyMaps,
+        [Description("No Grouping")]
+        NoGrouping,
+        [Description("Rank Achieved")]
+        RankAchieved,
+        [Description("Ranked Status")]
+        RankedStatus,
+        [Description("Recently Played")]
+        RecentlyPlayed,
+        [Description("Title")]
+        Title
+    }
+}

osu.Game/Screens/Select/Filter/SortMode.cs

@@ -0,0 +1,27 @@
+// 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.ComponentModel;
+
+namespace osu.Game.Screens.Select.Filter
+{
+    public enum SortMode
+    {
+        [Description("Artist")]
+        Artist,
+        [Description("Author")]
+        Author,
+        [Description("BPM")]
+        BPM,
+        [Description("Date Added")]
+        DateAdded,
+        [Description("Difficulty")]
+        Difficulty,
+        [Description("Length")]
+        Length,
+        [Description("Rank Achieved")]
+        RankAchieved,
+        [Description("Title")]
+        Title
+    }
+}

osu.Game/Screens/Select/FilterControl.cs

@@ -5,38 +5,71 @@ using System;
 using OpenTK;
 using OpenTK.Graphics;
 using osu.Framework.Allocation;
+using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Input;
 using osu.Game.Graphics;
-using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Screens.Select.Filter;
+using Container = osu.Framework.Graphics.Containers.Container;
+using osu.Framework.Input;
+using osu.Game.Modes;
 
 namespace osu.Game.Screens.Select
 {
     public class FilterControl : Container
     {
-        public Action FilterChanged;
+        public Action<FilterCriteria> FilterChanged;
+
+        private OsuTabControl<SortMode> sortTabs;
+
+        private TabControl<GroupMode> groupTabs;
 
-        public string Search => searchTextBox.Text;
         private SortMode sort = SortMode.Title;
-        public SortMode Sort { 
-            get { return sort; } 
-            set {
+        public SortMode Sort
+        {
+            get { return sort; }
+            set
+            {
                 if (sort != value)
                 {
                     sort = value;
-                    FilterChanged?.Invoke();
+                    FilterChanged?.Invoke(CreateCriteria());
                 }
-            } 
+            }
         }
 
+        private GroupMode group = GroupMode.All;
+        public GroupMode Group
+        {
+            get { return group; }
+            set
+            {
+                if (group != value)
+                {
+                    group = value;
+                    FilterChanged?.Invoke(CreateCriteria());
+                }
+            }
+        }
+
+        public FilterCriteria CreateCriteria() => new FilterCriteria
+        {
+            Group = group,
+            Sort = sort,
+            SearchText = searchTextBox.Text,
+            Mode = playMode
+        };
+
         public Action Exit;
 
         private SearchTextBox searchTextBox;
 
+        protected override bool InternalContains(Vector2 screenSpacePos) => base.InternalContains(screenSpacePos) || groupTabs.Contains(screenSpacePos) || sortTabs.Contains(screenSpacePos);
+
         public FilterControl()
         {
             Children = new Drawable[]
@@ -47,30 +80,79 @@ namespace osu.Game.Screens.Select
                     Alpha = 0.8f,
                     RelativeSizeAxes = Axes.Both,
                 },
-                new FillFlowContainer
+                new Container
                 {
                     Padding = new MarginPadding(20),
-                    AutoSizeAxes = Axes.Y,
-                    RelativeSizeAxes = Axes.X,
+                    AlwaysReceiveInput = true,
+                    RelativeSizeAxes = Axes.Both,
+                    Width = 0.5f,
                     Anchor = Anchor.TopRight,
                     Origin = Anchor.TopRight,
-                    Width = 0.4f, // TODO: InnerWidth property or something
-                    Direction = FillDirection.Down,
                     Children = new Drawable[]
                     {
-                        searchTextBox = new SearchTextBox {
+                        searchTextBox = new SearchTextBox
+                        {
                             RelativeSizeAxes = Axes.X,
-                            OnChange = (TextBox sender, bool newText) =>
+                            OnChange = (sender, newText) =>
                             {
                                 if (newText)
-                                    FilterChanged?.Invoke();
+                                    FilterChanged?.Invoke(CreateCriteria());
                             },
                             Exit = () => Exit?.Invoke(),
                         },
-                        new GroupSortTabs()
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            Height = 1,
+                            Colour = OsuColour.Gray(80),
+                            Origin = Anchor.BottomLeft,
+                            Anchor = Anchor.BottomLeft,
+                        },
+                        new FillFlowContainer
+                        {
+                            Anchor = Anchor.BottomRight,
+                            Origin = Anchor.BottomRight,
+                            Direction = FillDirection.Horizontal,
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            AlwaysReceiveInput = true,
+                            Children = new Drawable[]
+                            {
+                                groupTabs = new OsuTabControl<GroupMode>
+                                {
+                                    RelativeSizeAxes = Axes.X,
+                                    Height = 24,
+                                    Width = 0.5f,
+                                    AutoSort = true
+                                },
+                                //spriteText = new OsuSpriteText
+                                //{
+                                //    Font = @"Exo2.0-Bold",
+                                //    Text = "Sort results by",
+                                //    TextSize = 14,
+                                //    Margin = new MarginPadding
+                                //    {
+                                //        Top = 5,
+                                //        Bottom = 5
+                                //    },
+                                //},
+                                sortTabs = new OsuTabControl<SortMode>()
+                                {
+                                    RelativeSizeAxes = Axes.X,
+                                    Width = 0.5f,
+                                    Height = 24,
+                                    AutoSort = true,
+                                }
+                            }
+                        },
                     }
                 }
             };
+
+            groupTabs.PinItem(GroupMode.All);
+            groupTabs.PinItem(GroupMode.RecentlyPlayed);
+            groupTabs.ItemChanged += (sender, value) => Group = value;
+            sortTabs.ItemChanged += (sender, value) => Sort = value;
         }
 
         public void Deactivate()
@@ -78,216 +160,29 @@ namespace osu.Game.Screens.Select
             searchTextBox.HoldFocus = false;
             searchTextBox.TriggerFocusLost();
         }
-        
+
         public void Activate()
         {
             searchTextBox.HoldFocus = true;
         }
 
-        private class TabItem : ClickableContainer
+        private readonly Bindable<PlayMode> playMode = new Bindable<PlayMode>();
+
+        [BackgroundDependencyLoader(permitNulls:true)]
+        private void load(OsuColour colours, OsuGame osu)
         {
-            public string Text
-            {
-                get { return text.Text; }
-                set { text.Text = value; }
-            }
+            sortTabs.AccentColour = colours.GreenLight;
 
-            private void fadeActive()
-            {
-                box.FadeIn(300);
-                text.FadeColour(Color4.White, 300);
-            }
-
-            private void fadeInactive()
-            {
-                box.FadeOut(300);
-                text.FadeColour(fadeColour, 300);
-            }
-
-            private bool active;
-            public bool Active
-            {
-                get { return active; }
-                set
-                {
-                    active = value;
-                    if (active)
-                        fadeActive();
-                    else
-                        fadeInactive();
-                }
-            }
-        
-            private SpriteText text;
-            private Box box;
-            private Color4 fadeColour;
-            
-            protected override bool OnHover(InputState state)
-            {
-                if (!active)
-                    fadeActive();
-                return true;
-            }
-            
-            protected override void OnHoverLost(InputState state)
-            {
-                if (!active)
-                    fadeInactive();
-            }
-        
-            public TabItem()
-            {
-                AutoSizeAxes = Axes.Both;
-                Children = new Drawable[]
-                {
-                    text = new OsuSpriteText
-                    {
-                        Margin = new MarginPadding(5),
-                        TextSize = 14,
-                        Font = @"Exo2.0-Bold",
-                    },
-                    box = new Box
-                    {
-                        RelativeSizeAxes = Axes.X,
-                        Height = 1,
-                        Alpha = 0,
-                        Colour = Color4.White,
-                        Origin = Anchor.BottomLeft,
-                        Anchor = Anchor.BottomLeft,
-                    }
-                };
-            }
-
-            [BackgroundDependencyLoader]
-            private void load(OsuColour colours)
-            {
-                text.Colour = colours.Blue;
-                fadeColour = colours.Blue;
-            }
+            if (osu != null)
+                playMode.BindTo(osu.PlayMode);
         }
 
-        private class GroupSortTabs : Container
-        {
-            private TextAwesome groupsEllipsis, sortEllipsis;
-            private SpriteText sortLabel;
-        
-            public GroupSortTabs()
-            {
-                RelativeSizeAxes = Axes.X;
-                AutoSizeAxes = Axes.Y;
-                Children = new Drawable[]
-                {
-                    new Box
-                    {
-                        RelativeSizeAxes = Axes.X,
-                        Height = 1,
-                        Colour = OsuColour.Gray(80),
-                        Origin = Anchor.BottomLeft,
-                        Anchor = Anchor.BottomLeft,
-                    },
-                    new FillFlowContainer
-                    {
-                        AutoSizeAxes = Axes.Both,
-                        Direction = FillDirection.Right,
-                        Spacing = new Vector2(10, 0),
-                        Children = new Drawable[]
-                        {
-                            new TabItem
-                            {
-                                Text = "All",
-                                Active = true,
-                            },
-                            new TabItem
-                            {
-                                Text = "Recently Played",
-                                Active = false,
-                            },
-                            new TabItem
-                            {
-                                Text = "Collections",
-                                Active = false,
-                            },
-                            groupsEllipsis = new TextAwesome
-                            {
-                                Icon = FontAwesome.fa_ellipsis_h,
-                                TextSize = 14,
-                                Margin = new MarginPadding { Top = 5, Bottom = 5 },
-                                Origin = Anchor.BottomLeft,
-                                Anchor = Anchor.BottomLeft,
-                            }
-                        }
-                    },
-                    new FillFlowContainer
-                    {
-                        AutoSizeAxes = Axes.Both,
-                        Direction = FillDirection.Right,
-                        Spacing = new Vector2(10, 0),
-                        Origin = Anchor.TopRight,
-                        Anchor = Anchor.TopRight,
-                        Children = new Drawable[]
-                        {
-                            sortLabel = new OsuSpriteText
-                            {
-                                Font = @"Exo2.0-Bold",
-                                Text = "Sort results by",
-                                TextSize = 14,
-                                Margin = new MarginPadding { Top = 5, Bottom = 5 },
-                            },
-                            new TabItem
-                            {
-                                Text = "Artist",
-                                Active = true,
-                            },
-                            sortEllipsis = new TextAwesome
-                            {
-                                Icon = FontAwesome.fa_ellipsis_h,
-                                TextSize = 14,
-                                Margin = new MarginPadding { Top = 5, Bottom = 5 },
-                                Origin = Anchor.BottomLeft,
-                                Anchor = Anchor.BottomLeft,
-                            }
-                        }
-                    },
-                };
-            }
+        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args) => true;
 
-            [BackgroundDependencyLoader]
-            private void load(OsuColour colours)
-            {
-                groupsEllipsis.Colour = colours.Blue;
-                sortLabel.Colour = colours.GreenLight;
-                sortEllipsis.Colour = colours.GreenLight;
-            }
-        }
-        
-        public enum SortMode
-        {
-            Artist,
-            BPM,
-            Author,
-            DateAdded,
-            Difficulty,
-            Length,
-            RankAchieved,
-            Title
-        }
+        protected override bool OnMouseMove(InputState state) => true;
 
-        public enum GroupMode
-        {
-            NoGrouping,
-            Artist,
-            BPM,
-            Author,
-            DateAdded,
-            Difficulty,
-            Length,
-            RankAchieved,
-            Title,
-            Collections,
-            Favorites,
-            MyMaps,
-            RankedStatus,
-            RecentlyPlayed
-        }
+        protected override bool OnClick(InputState state) => true;
+
+        protected override bool OnDragStart(InputState state) => true;
     }
 }

osu.Game/Screens/Select/FilterCriteria.cs

@@ -0,0 +1,65 @@
+// 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 System.Linq;
+using osu.Game.Beatmaps.Drawables;
+using osu.Game.Modes;
+using osu.Game.Screens.Select.Filter;
+
+namespace osu.Game.Screens.Select
+{
+    public class FilterCriteria
+    {
+        public GroupMode Group;
+        public SortMode Sort;
+        public string SearchText;
+        public PlayMode Mode;
+
+        public void Filter(List<BeatmapGroup> groups)
+        {
+            foreach (var g in groups)
+            {
+                var set = g.BeatmapSet;
+
+                bool hasCurrentMode = set.Beatmaps.Any(bm => bm.Mode == Mode);
+
+                bool match = hasCurrentMode;
+
+                match &= string.IsNullOrEmpty(SearchText)
+                    || (set.Metadata.Artist ?? string.Empty).IndexOf(SearchText, StringComparison.InvariantCultureIgnoreCase) != -1
+                    || (set.Metadata.ArtistUnicode ?? string.Empty).IndexOf(SearchText, StringComparison.InvariantCultureIgnoreCase) != -1
+                    || (set.Metadata.Title ?? string.Empty).IndexOf(SearchText, StringComparison.InvariantCultureIgnoreCase) != -1
+                    || (set.Metadata.TitleUnicode ?? string.Empty).IndexOf(SearchText, StringComparison.InvariantCultureIgnoreCase) != -1;
+
+                switch (g.State)
+                {
+                    case BeatmapGroupState.Hidden:
+                        if (match) g.State = BeatmapGroupState.Collapsed;
+                        break;
+                    default:
+                        if (!match) g.State = BeatmapGroupState.Hidden;
+                        break;
+                }
+            }
+
+            switch (Sort)
+            {
+                default:
+                case SortMode.Artist:
+                    groups.Sort((x, y) => string.Compare(x.BeatmapSet.Metadata.Artist, y.BeatmapSet.Metadata.Artist, StringComparison.InvariantCultureIgnoreCase));
+                    break;
+                case SortMode.Title:
+                    groups.Sort((x, y) => string.Compare(x.BeatmapSet.Metadata.Title, y.BeatmapSet.Metadata.Title, StringComparison.InvariantCultureIgnoreCase));
+                    break;
+                case SortMode.Author:
+                    groups.Sort((x, y) => string.Compare(x.BeatmapSet.Metadata.Author, y.BeatmapSet.Metadata.Author, StringComparison.InvariantCultureIgnoreCase));
+                    break;
+                case SortMode.Difficulty:
+                    groups.Sort((x, y) => x.BeatmapSet.MaxStarDifficulty.CompareTo(y.BeatmapSet.MaxStarDifficulty));
+                    break;
+            }
+        }
+    }
+}

osu.Game/Screens/Select/Footer.cs

@@ -4,11 +4,12 @@
 using System;
 using OpenTK;
 using OpenTK.Graphics;
+using OpenTK.Input;
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Transforms;
-using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Screens.Menu;
 
@@ -25,8 +26,6 @@ namespace osu.Game.Screens.Select
 
         private const float padding = 80;
 
-        public override bool Contains(Vector2 screenSpacePos) => true;
-
         public Action OnBack;
         public Action OnStart;
 
@@ -34,15 +33,25 @@ namespace osu.Game.Screens.Select
 
         public OsuLogo StartButton;
 
-        public void AddButton(string text, Color4 colour, Action action)
+        /// <param name="text">Text on the button.</param>
+        /// <param name="colour">Colour of the button.</param>
+        /// <param name="hotkey">Hotkey of the button.</param>
+        /// <param name="action">Action the button does.</param>
+        /// <param name="depth">
+        /// <para>Higher depth to be put on the left, and lower to be put on the right.</para>
+        /// <para>Notice this is different to <see cref="Options.BeatmapOptionsOverlay"/>!</para>
+        /// </param>
+        public void AddButton(string text, Color4 colour, Action action, Key? hotkey = null, float depth = 0)
         {
             var button = new FooterButton
             {
                 Text = text,
                 Height = play_song_select_button_height,
                 Width = play_song_select_button_width,
+                Depth = depth,
                 SelectedColour = colour,
                 DeselectedColour = colour.Opacity(0.5f),
+                Hotkey = hotkey,
             };
 
             button.Hovered = () => updateModeLight(button);
@@ -58,6 +67,8 @@ namespace osu.Game.Screens.Select
 
         public Footer()
         {
+            AlwaysReceiveInput = true;
+
             const float bottom_tool_height = 50;
 
             RelativeSizeAxes = Axes.X;
@@ -89,22 +100,22 @@ namespace osu.Game.Screens.Select
                 {
                     Anchor = Anchor.BottomLeft,
                     Origin = Anchor.BottomLeft,
-                    Action = () => OnBack?.Invoke(),
+                    Action = () => OnBack?.Invoke()
                 },
                 new FillFlowContainer
                 {
                     Anchor = Anchor.BottomLeft,
                     Origin = Anchor.BottomLeft,
-                    Position = new Vector2(BackButton.SIZE_EXTENDED.X + padding, 0),
+                    Position = new Vector2(TwoLayerButton.SIZE_EXTENDED.X + padding, 0),
                     RelativeSizeAxes = Axes.Y,
                     AutoSizeAxes = Axes.X,
-                    Direction = FillDirection.Right,
+                    Direction = FillDirection.Horizontal,
                     Spacing = new Vector2(padding, 0),
                     Children = new Drawable[]
                     {
                         buttons = new FillFlowContainer
                         {
-                            Direction = FillDirection.Right,
+                            Direction = FillDirection.Horizontal,
                             Spacing = new Vector2(0.2f, 0),
                             AutoSizeAxes = Axes.Both,
                         }

osu.Game/Screens/Select/FooterButton.cs

@@ -1,14 +1,15 @@
 // 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 OpenTK;
 using OpenTK.Graphics;
+using OpenTK.Input;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Input;
-using System;
 using osu.Framework.Graphics.Transforms;
+using osu.Framework.Input;
 using osu.Game.Graphics.Sprites;
 
 namespace osu.Game.Screens.Select
@@ -34,7 +35,7 @@ namespace osu.Game.Screens.Select
             set
             {
                 deselectedColour = value;
-                if(light.Colour != SelectedColour)
+                if (light.Colour != SelectedColour)
                     light.Colour = value;
             }
         }
@@ -83,6 +84,7 @@ namespace osu.Game.Screens.Select
 
         public Action Hovered;
         public Action HoverLost;
+        public Key? Hotkey;
 
         protected override bool OnHover(InputState state)
         {
@@ -119,5 +121,15 @@ namespace osu.Game.Screens.Select
             return base.OnClick(state);
         }
 
+        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        {
+            if (!args.Repeat && args.Key == Hotkey)
+            {
+                OnClick(state);
+                return true;
+            }
+
+            return base.OnKeyDown(state, args);
+        }
     }
 }

osu.Game/Screens/Select/Leaderboards/DrawableRank.cs

@@ -0,0 +1,39 @@
+// Copyright (c) 2007-2017 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.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Modes;
+using osu.Framework.Extensions;
+
+namespace osu.Game.Screens.Select.Leaderboards
+{
+    public class DrawableRank : Container
+    {
+        private Sprite sprite;
+
+        public ScoreRank Rank { get; private set; }
+
+        [BackgroundDependencyLoader]
+        private void load(TextureStore textures)
+        {
+            sprite.Texture = textures.Get($@"Badges/ScoreRanks/{Rank.GetDescription()}");
+        }
+
+        public DrawableRank(ScoreRank rank)
+        {
+            Rank = rank;
+
+            Children = new Drawable[]
+            {
+                sprite = new Sprite
+                {
+                    RelativeSizeAxes = Axes.Both,
+                },
+            };
+        }
+    }
+}

osu.Game/Screens/Select/Leaderboards/Leaderboard.cs

@@ -0,0 +1,111 @@
+// 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.Collections.Generic;
+using OpenTK;
+using OpenTK.Graphics;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Game.Modes;
+using System;
+
+namespace osu.Game.Screens.Select.Leaderboards
+{
+    public class Leaderboard : Container
+    {
+        private ScrollContainer scrollContainer;
+        private FillFlowContainer<LeaderboardScore> scrollFlow;
+
+        private IEnumerable<Score> scores;
+        public IEnumerable<Score> Scores
+        {
+            get { return scores; }
+            set
+            {
+                scores = value;
+
+                int i = 150;
+                if (scores == null)
+                {
+                    foreach (var c in scrollFlow.Children)
+                        c.FadeOut(i += 10);
+
+                    foreach (var c in scrollFlow.Children)
+                        c.LifetimeEnd = Time.Current + i;
+
+                    return;
+                }
+
+                scrollFlow.Clear();
+
+                i = 0;
+                foreach (var s in scores)
+                {
+                    var ls = new LeaderboardScore(s, 1 + i)
+                    {
+                        AlwaysPresent = true,
+                        State = Visibility.Hidden,
+                    };
+                    scrollFlow.Add(ls);
+
+                    ls.Delay(i++ * 50, true);
+                    ls.Show();
+                }
+
+                scrollContainer.ScrollTo(0f, false);
+            }
+        }
+
+        public Leaderboard()
+        {
+            Children = new Drawable[]
+            {
+                scrollContainer = new ScrollContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    ScrollDraggerVisible = false,
+                    Children = new Drawable[]
+                    {
+                        scrollFlow = new FillFlowContainer<LeaderboardScore>
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            Spacing = new Vector2(0f, 5f),
+                            Padding = new MarginPadding(5),
+                        },
+                    },
+                },
+            };
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            var fadeStart = scrollContainer.Current + scrollContainer.DrawHeight;
+
+            if (!scrollContainer.IsScrolledToEnd())
+                fadeStart -= LeaderboardScore.HEIGHT;
+
+            foreach (var c in scrollFlow.Children)
+            {
+                var topY = c.ToSpaceOfOtherDrawable(Vector2.Zero, scrollFlow).Y;
+                var bottomY = topY + LeaderboardScore.HEIGHT;
+
+                if (bottomY < fadeStart)
+                    c.Colour = Color4.White;
+                else if (topY > fadeStart + LeaderboardScore.HEIGHT)
+                    c.Colour = Color4.Transparent;
+                else
+                {
+                    c.ColourInfo = ColourInfo.GradientVertical(
+                        Color4.White.Opacity(Math.Min(1 - (topY - fadeStart) / LeaderboardScore.HEIGHT, 1)),
+                        Color4.White.Opacity(Math.Min(1 - (bottomY - fadeStart) / LeaderboardScore.HEIGHT, 1)));
+                }
+            }
+        }
+    }
+}

osu.Game/Screens/Select/Leaderboards/LeaderboardScore.cs

@@ -0,0 +1,386 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK;
+using OpenTK.Graphics;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Transforms;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Modes;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Game.Modes.Mods;
+using osu.Game.Users;
+using osu.Framework;
+
+namespace osu.Game.Screens.Select.Leaderboards
+{
+    public class LeaderboardScore : Container, IStateful<Visibility>
+    {
+        public static readonly float HEIGHT = 60;
+
+        public readonly int RankPosition;
+        public readonly Score Score;
+
+        private const float corner_radius = 5;
+        private const float edge_margin = 5;
+        private const float background_alpha = 0.25f;
+        private const float rank_width = 30;
+
+        private Box background;
+        private Container content, avatar;
+        private DrawableRank scoreRank;
+        private OsuSpriteText nameLabel;
+        private GlowingSpriteText scoreLabel;
+        private ScoreComponentLabel maxCombo, accuracy;
+        private Container flagBadgeContainer;
+        private FillFlowContainer<ScoreModIcon> modsContainer;
+
+        private Visibility state;
+        public Visibility State
+        {
+            get { return state; }
+            set
+            {
+                state = value;
+
+                switch (state)
+                {
+                    case Visibility.Hidden:
+                        foreach (var d in new Drawable[] { avatar, nameLabel, scoreLabel, scoreRank, flagBadgeContainer, maxCombo, accuracy, modsContainer })
+                            d.FadeOut();
+
+                        Alpha = 0;
+
+                        content.MoveToY(75);
+                        avatar.MoveToX(75);
+                        nameLabel.MoveToX(150);
+                        break;
+                    case Visibility.Visible:
+                        FadeIn(200);
+                        content.MoveToY(0, 800, EasingTypes.OutQuint);
+
+                        Delay(100, true);
+                        avatar.FadeIn(300, EasingTypes.OutQuint);
+                        nameLabel.FadeIn(350, EasingTypes.OutQuint);
+
+                        avatar.MoveToX(0, 300, EasingTypes.OutQuint);
+                        nameLabel.MoveToX(0, 350, EasingTypes.OutQuint);
+
+                        Delay(250, true);
+                        scoreLabel.FadeIn(200);
+                        scoreRank.FadeIn(200);
+
+                        Delay(50, true);
+                        var drawables = new Drawable[] { flagBadgeContainer, maxCombo, accuracy, modsContainer, };
+
+                        for (int i = 0; i < drawables.Length; i++)
+                        {
+                            drawables[i].FadeIn(100 + i * 50);
+                        }
+
+                        break;
+                }
+            }
+        }
+
+        public LeaderboardScore(Score score, int rank)
+        {
+            Score = score;
+            RankPosition = rank;
+
+            RelativeSizeAxes = Axes.X;
+            Height = HEIGHT;
+
+            Children = new Drawable[]
+            {
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Y,
+                    Width = rank_width,
+                    Children = new[]
+                    {
+                        new OsuSpriteText
+                        {
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                            Font = @"Exo2.0-MediumItalic",
+                            TextSize = 22,
+                            Text = RankPosition.ToString(),
+                        },
+                    },
+                },
+                content = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Left = rank_width, },
+                    Children = new Drawable[]
+                    {
+                        new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            CornerRadius = corner_radius,
+                            Masking = true,
+                            Children = new[]
+                            {
+                                background = new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = Color4.Black,
+                                    Alpha = background_alpha,
+                                },
+                            },
+                        },
+                        new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Padding = new MarginPadding(edge_margin),
+                            Children = new Drawable[]
+                            {
+                                avatar = new Avatar
+                                {
+                                    Size = new Vector2(HEIGHT - edge_margin * 2, HEIGHT - edge_margin * 2),
+                                    CornerRadius = corner_radius,
+                                    Masking = true,
+                                    EdgeEffect = new EdgeEffect
+                                    {
+                                        Type = EdgeEffectType.Shadow,
+                                        Radius = 1,
+                                        Colour = Color4.Black.Opacity(0.2f),
+                                    },
+                                    UserId = Score.User?.Id ?? Score.UserID,
+                                },
+                                new Container
+                                {
+                                    RelativeSizeAxes = Axes.Y,
+                                    AutoSizeAxes = Axes.X,
+                                    Position = new Vector2(HEIGHT - edge_margin, 0f),
+                                    Children = new Drawable[]
+                                    {
+                                        nameLabel = new OsuSpriteText
+                                        {
+                                            Text = Score.User?.Username ?? Score.Username,
+                                            Font = @"Exo2.0-BoldItalic",
+                                            TextSize = 23,
+                                        },
+                                        new FillFlowContainer
+                                        {
+                                            Origin = Anchor.BottomLeft,
+                                            Anchor = Anchor.BottomLeft,
+                                            AutoSizeAxes = Axes.Both,
+                                            Direction = FillDirection.Horizontal,
+                                            Spacing = new Vector2(10f, 0f),
+                                            Children = new Drawable[]
+                                            {
+                                                flagBadgeContainer = new Container
+                                                {
+                                                    Size = new Vector2(87f, 20f),
+                                                    Masking = true,
+                                                    Children = new Drawable[]
+                                                    {
+                                                        new DrawableFlag(Score.User?.Country?.FlagName ?? "__")
+                                                        {
+                                                            Width = 30,
+                                                            RelativeSizeAxes = Axes.Y,
+                                                        },
+                                                    },
+                                                },
+                                                new FillFlowContainer
+                                                {
+                                                    AutoSizeAxes = Axes.Both,
+                                                    Direction = FillDirection.Horizontal,
+                                                    Spacing = new Vector2(10f, 0f),
+                                                    Margin = new MarginPadding { Left = edge_margin, },
+                                                    Children = new Drawable[]
+                                                    {
+                                                        maxCombo = new ScoreComponentLabel(FontAwesome.fa_link, Score.MaxCombo.ToString()),
+                                                        accuracy = new ScoreComponentLabel(FontAwesome.fa_crosshairs, string.Format(Score.Accuracy % 1 == 0 ? @"{0:0}" : @"{0:0.00}", Score.Accuracy)),
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                                new FillFlowContainer
+                                {
+                                    AutoSizeAxes = Axes.Both,
+                                    Anchor = Anchor.TopRight,
+                                    Origin = Anchor.TopRight,
+                                    Direction = FillDirection.Horizontal,
+                                    Spacing = new Vector2(5f, 0f),
+                                    Children = new Drawable[]
+                                    {
+                                        scoreLabel = new GlowingSpriteText(Score.TotalScore.ToString(@"N0"), @"Venera", 23, Color4.White, OsuColour.FromHex(@"83ccfa")),
+                                        new Container
+                                        {
+                                            Size = new Vector2(40f, 20f),
+                                            Children = new[]
+                                            {
+                                                scoreRank = new DrawableRank(Score.Rank)
+                                                {
+                                                    Anchor = Anchor.Centre,
+                                                    Origin = Anchor.Centre,
+                                                    Size = new Vector2(40f),
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                                modsContainer = new FillFlowContainer<ScoreModIcon>
+                                {
+                                    Anchor = Anchor.BottomRight,
+                                    Origin = Anchor.BottomRight,
+                                    AutoSizeAxes = Axes.Both,
+                                    Direction = FillDirection.Horizontal,
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+
+            if (Score.Mods != null)
+            {
+                foreach (Mod mod in Score.Mods)
+                {
+                    // TODO: Get actual mod colours
+                    modsContainer.Add(new ScoreModIcon(mod.Icon, OsuColour.FromHex(@"ffcc22")));
+                }
+            }
+        }
+
+        public void ToggleVisibility() => State = State == Visibility.Visible ? Visibility.Hidden : Visibility.Visible;
+
+        public override void Hide() => State = Visibility.Hidden;
+        public override void Show() => State = Visibility.Visible;
+
+        protected override bool OnHover(Framework.Input.InputState state)
+        {
+            background.FadeTo(0.5f, 300, EasingTypes.OutQuint);
+            return base.OnHover(state);
+        }
+
+        protected override void OnHoverLost(Framework.Input.InputState state)
+        {
+            background.FadeTo(background_alpha, 200, EasingTypes.OutQuint);
+            base.OnHoverLost(state);
+        }
+
+        private class GlowingSpriteText : Container
+        {
+            public GlowingSpriteText(string text, string font, int textSize, Color4 textColour, Color4 glowColour)
+            {
+                AutoSizeAxes = Axes.Both;
+
+                Children = new Drawable[]
+                {
+                    new BufferedContainer
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        BlurSigma = new Vector2(4),
+                        CacheDrawnFrameBuffer = true,
+                        RelativeSizeAxes = Axes.Both,
+                        BlendingMode = BlendingMode.Additive,
+                        Size = new Vector2(3f),
+                        Children = new[]
+                        {
+                            new OsuSpriteText
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Font = font,
+                                TextSize = textSize,
+                                FixedWidth = true,
+                                Text = text,
+                                Colour = glowColour,
+                                Shadow = false,
+                            },
+                        },
+                    },
+                    new OsuSpriteText
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Font = font,
+                        FixedWidth = true,
+                        TextSize = textSize,
+                        Text = text,
+                        Colour = textColour,
+                        Shadow = false,
+                    },
+                };
+            }
+        }
+
+        private class ScoreModIcon : Container
+        {
+            public ScoreModIcon(FontAwesome icon, Color4 colour)
+            {
+                AutoSizeAxes = Axes.Both;
+
+                Children = new[]
+                {
+                    new TextAwesome
+                    {
+                        Origin = Anchor.Centre,
+                        Anchor = Anchor.Centre,
+                        Icon = FontAwesome.fa_osu_mod_bg,
+                        Colour = colour,
+                        Shadow = true,
+                        TextSize = 30,
+                        UseFullGlyphHeight = false,
+                    },
+                    new TextAwesome
+                    {
+                        Origin = Anchor.Centre,
+                        Anchor = Anchor.Centre,
+                        Icon = icon,
+                        Colour = OsuColour.Gray(84),
+                        TextSize = 18,
+                        Position = new Vector2(0f, 2f),
+                        UseFullGlyphHeight = false,
+                    },
+                };
+            }
+        }
+
+        private class ScoreComponentLabel : Container
+        {
+            public ScoreComponentLabel(FontAwesome icon, string value)
+            {
+                Anchor = Anchor.CentreLeft;
+                Origin = Anchor.CentreLeft;
+                Size = new Vector2(60f, 20f);
+                Padding = new MarginPadding { Top = 10f, };
+
+                Children = new Drawable[]
+                {
+                    new TextAwesome
+                    {
+                        Origin = Anchor.Centre,
+                        Icon = FontAwesome.fa_square,
+                        Colour = OsuColour.FromHex(@"3087ac"),
+                        Rotation = 45,
+                        Shadow = true,
+                    },
+                    new TextAwesome
+                    {
+                        Origin = Anchor.Centre,
+                        Icon = icon,
+                        Colour = OsuColour.FromHex(@"a4edff"),
+                        Scale = new Vector2(0.8f),
+                    },
+                    new GlowingSpriteText(value, @"Exo2.0-Bold", 17, Color4.White, OsuColour.FromHex(@"83ccfa"))
+                    {
+                        Origin = Anchor.CentreLeft,
+                        Margin = new MarginPadding { Left = 15, },
+                    },
+                };
+            }
+        }
+    }
+}

osu.Game/Screens/Select/MatchSongSelect.cs

@@ -1,12 +1,10 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Game.Screens.Backgrounds;
-
 namespace osu.Game.Screens.Select
 {
-    class MatchSongSelect : ScreenWhiteBox
+    public class MatchSongSelect : SongSelect
     {
-        protected override BackgroundScreen CreateBackground() => new BackgroundScreenCustom(@"Backgrounds/bg4");
+        protected override void OnSelected() => Exit();
     }
 }

osu.Game/Screens/Select/Options/BeatmapOptionsButton.cs

@@ -0,0 +1,167 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK;
+using OpenTK.Graphics;
+using OpenTK.Input;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Transforms;
+using osu.Framework.Input;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+
+namespace osu.Game.Screens.Select.Options
+{
+    public class BeatmapOptionsButton : ClickableContainer
+    {
+        private static readonly float width = 130;
+
+        private Box background, flash;
+        private TextAwesome iconText;
+        private OsuSpriteText firstLine, secondLine;
+        private Container box;
+
+        public Color4 ButtonColour
+        {
+            get { return background.Colour; }
+            set { background.Colour = value; }
+        }
+
+        public FontAwesome Icon
+        {
+            get { return iconText.Icon; }
+            set { iconText.Icon = value; }
+        }
+
+        public string FirstLineText
+        {
+            get { return firstLine.Text; }
+            set { firstLine.Text = value; }
+        }
+
+        public string SecondLineText
+        {
+            get { return secondLine.Text; }
+            set { secondLine.Text = value; }
+        }
+
+        public Key? HotKey;
+
+        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        {
+            flash.FadeTo(0.1f, 1000, EasingTypes.OutQuint);
+            return base.OnMouseDown(state, args);
+        }
+
+        protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+        {
+            flash.FadeTo(0, 1000, EasingTypes.OutQuint);
+            return base.OnMouseUp(state, args);
+        }
+
+        protected override bool OnClick(InputState state)
+        {
+            flash.ClearTransforms();
+            flash.Alpha = 0.9f;
+            flash.FadeOut(800, EasingTypes.OutExpo);
+
+            return base.OnClick(state);
+        }
+
+        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        {
+            if (!args.Repeat && args.Key == HotKey)
+            {
+                OnClick(state);
+                return true;
+            }
+
+            return false;
+        }
+
+        protected override bool InternalContains(Vector2 screenSpacePos) => box.Contains(screenSpacePos);
+
+        public BeatmapOptionsButton()
+        {
+            Width = width;
+            RelativeSizeAxes = Axes.Y;
+
+            Children = new Drawable[]
+            {
+                box = new Container
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Shear = new Vector2(0.2f, 0f),
+                    Masking = true,
+                    EdgeEffect = new EdgeEffect
+                    {
+                        Type = EdgeEffectType.Shadow,
+                        Colour = Color4.Black.Opacity(0.2f),
+                        Roundness = 5,
+                        Radius = 8,
+                    },
+                    Children = new Drawable[]
+                    {
+                        background = new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            EdgeSmoothness = new Vector2(1.5f, 0),
+                            Colour = Color4.Black,
+                        },
+                        flash = new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            EdgeSmoothness = new Vector2(1.5f, 0),
+                            BlendingMode = BlendingMode.Additive,
+                            Colour = Color4.White,
+                            Alpha = 0,
+                        },
+                    },
+                },
+                new FillFlowContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Direction = FillDirection.Vertical,
+                    Children = new Drawable[]
+                    {
+                        iconText = new TextAwesome
+                        {
+                            Origin = Anchor.TopCentre,
+                            Anchor = Anchor.TopCentre,
+                            TextSize = 30,
+                            Shadow = true,
+                            Icon = FontAwesome.fa_close,
+                            Margin = new MarginPadding
+                            {
+                                Bottom = 5,
+                            },
+                        },
+                        firstLine = new OsuSpriteText
+                        {
+                            Origin = Anchor.TopCentre,
+                            Anchor = Anchor.TopCentre,
+                            Font = @"Exo2.0-Bold",
+                            Text = @"",
+                        },
+                        secondLine = new OsuSpriteText
+                        {
+                            Origin = Anchor.TopCentre,
+                            Anchor = Anchor.TopCentre,
+                            Font = @"Exo2.0-Bold",
+                            Text = @"",
+                        },
+                    },
+                },
+            };
+        }
+    }
+}

osu.Game/Screens/Select/Options/BeatmapOptionsOverlay.cs

@@ -0,0 +1,125 @@
+// 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 System.Linq;
+using OpenTK;
+using OpenTK.Graphics;
+using OpenTK.Input;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Transforms;
+using osu.Game.Graphics;
+
+namespace osu.Game.Screens.Select.Options
+{
+    public class BeatmapOptionsOverlay : FocusedOverlayContainer
+    {
+        private const float transition_duration = 500;
+        private const float x_position = 0.2f;
+        private const float x_movement = 0.8f;
+
+        private const float height = 100;
+
+        private Box holder;
+        private FillFlowContainer<BeatmapOptionsButton> buttonsContainer;
+
+        protected override void PopIn()
+        {
+            base.PopIn();
+
+            FadeIn(transition_duration, EasingTypes.OutQuint);
+
+            if (buttonsContainer.Position.X == 1 || Alpha == 0)
+                buttonsContainer.MoveToX(x_position - x_movement);
+
+            holder.ScaleTo(new Vector2(1, 1), transition_duration / 2, EasingTypes.OutQuint);
+
+            buttonsContainer.MoveToX(x_position, transition_duration, EasingTypes.OutQuint);
+            buttonsContainer.TransformSpacingTo(Vector2.Zero, transition_duration, EasingTypes.OutQuint);
+        }
+
+        protected override void PopOut()
+        {
+            base.PopOut();
+
+            holder.ScaleTo(new Vector2(1, 0), transition_duration / 2, EasingTypes.InSine);
+
+            buttonsContainer.MoveToX(x_position + x_movement, transition_duration, EasingTypes.InSine);
+            buttonsContainer.TransformSpacingTo(new Vector2(200f, 0f), transition_duration, EasingTypes.InSine);
+
+            FadeOut(transition_duration, EasingTypes.InQuint);
+        }
+
+        public BeatmapOptionsOverlay()
+        {
+            AutoSizeAxes = Axes.Y;
+            RelativeSizeAxes = Axes.X;
+            Anchor = Anchor.BottomLeft;
+            Origin = Anchor.BottomLeft;
+
+            Children = new Drawable[]
+            {
+                holder = new Box
+                {
+                    Origin = Anchor.BottomLeft,
+                    Anchor = Anchor.BottomLeft,
+                    RelativeSizeAxes = Axes.Both,
+                    Height = 0.5f,
+                    Scale = new Vector2(1, 0),
+                    Colour = Color4.Black.Opacity(0.5f),
+                },
+                buttonsContainer = new ButtonFlow
+                {
+                    Height = height,
+                    RelativePositionAxes = Axes.X,
+                    AutoSizeAxes = Axes.X,
+                    Origin = Anchor.BottomLeft,
+                    Anchor = Anchor.BottomLeft,
+                },
+            };
+        }
+
+        /// <param name="firstLine">Text in the first line.</param>
+        /// <param name="secondLine">Text in the second line.</param>
+        /// <param name="colour">Colour of the button.</param>
+        /// <param name="icon">Icon of the button.</param>
+        /// <param name="hotkey">Hotkey of the button.</param>
+        /// <param name="action">Action the button does.</param>
+        /// <param name="depth">
+        /// <para>Lower depth to be put on the left, and higher to be put on the right.</para>
+        /// <para>Notice this is different to <see cref="Footer"/>!</para>
+        /// </param>
+        public void AddButton(string firstLine, string secondLine, FontAwesome icon, Color4 colour, Action action, Key? hotkey = null, float depth = 0)
+        {
+            buttonsContainer.Add(new BeatmapOptionsButton
+            {
+                FirstLineText = firstLine,
+                SecondLineText = secondLine,
+                Icon = icon,
+                ButtonColour = colour,
+                Depth = depth,
+                Action = () =>
+                {
+                    Hide();
+                    action?.Invoke();
+                },
+                HotKey = hotkey
+            });
+        }
+
+        private class ButtonFlow : FillFlowContainer<BeatmapOptionsButton>
+        {
+            protected override IComparer<Drawable> DepthComparer => new ReverseCreationOrderDepthComparer();
+            protected override IEnumerable<BeatmapOptionsButton> FlowingChildren => base.FlowingChildren.Reverse();
+
+            public ButtonFlow()
+            {
+                Direction = FillDirection.Horizontal;
+            }
+        }
+    }
+}

osu.Game/Screens/Select/PlaySongSelect.cs

@@ -1,418 +1,94 @@
 // 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.Linq;
-using System.Threading;
-using System.Threading.Tasks;
+using OpenTK.Input;
 using osu.Framework.Allocation;
-using osu.Framework.Audio;
-using osu.Framework.Audio.Track;
-using osu.Framework.Configuration;
-using osu.Framework.Screens;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Primitives;
+using osu.Framework.Screens;
 using osu.Game.Beatmaps;
-using osu.Game.Database;
-using osu.Game.Modes;
-using osu.Game.Screens.Backgrounds;
-using OpenTK;
-using osu.Game.Screens.Play;
-using osu.Framework.Audio.Sample;
-using osu.Framework.Graphics.Transforms;
-using osu.Game.Beatmaps.Drawables;
-using osu.Game.Graphics.Containers;
 using osu.Game.Graphics;
-using osu.Framework.Input;
-using OpenTK.Input;
-using System.Collections.Generic;
-using osu.Framework.Threading;
-using osu.Game.Overlays;
+using osu.Game.Online.API.Requests;
+using osu.Game.Overlays.Mods;
+using osu.Game.Screens.Edit;
+using osu.Game.Screens.Play;
+using osu.Game.Screens.Select.Leaderboards;
 
 namespace osu.Game.Screens.Select
 {
-    public class PlaySongSelect : OsuScreen
+    public class PlaySongSelect : SongSelect
     {
-        private Bindable<PlayMode> playMode;
-        private BeatmapDatabase database;
-        protected override BackgroundScreen CreateBackground() => new BackgroundScreenBeatmap(Beatmap);
+        private OsuScreen player;
+        private ModSelectOverlay modSelect;
+        private Leaderboard leaderboard;
 
-        private CarouselContainer carousel;
-        private TrackManager trackManager;
-        private DialogOverlay dialogOverlay;
-
-        private static readonly Vector2 wedged_container_size = new Vector2(0.5f, 225);
-        private BeatmapInfoWedge beatmapInfoWedge;
-
-        private static readonly Vector2 background_blur = new Vector2(20);
-        private CancellationTokenSource initialAddSetsTask;
-
-        private SampleChannel sampleChangeDifficulty;
-        private SampleChannel sampleChangeBeatmap;
-
-        private List<BeatmapGroup> beatmapGroups;
-
-        private Footer footer;
-
-        OsuScreen player;
-
-        private FilterControl filter;
-        public FilterControl Filter
+        public PlaySongSelect()
         {
-            get
+            Add(modSelect = new ModSelectOverlay
             {
-                return filter;
-            }
-            private set
+                RelativeSizeAxes = Axes.X,
+                Origin = Anchor.BottomCentre,
+                Anchor = Anchor.BottomCentre,
+                Margin = new MarginPadding { Bottom = 50 }
+            });
+
+            LeftContent.Add(leaderboard = new Leaderboard
             {
-                if (filter != value)
-                {
-                    filter = value;
-                    filterChanged();
-                }
-            }
+                RelativeSizeAxes = Axes.Both,
+            });
         }
 
-        [BackgroundDependencyLoader(permitNulls: true)]
-        private void load(BeatmapDatabase beatmaps, AudioManager audio, DialogOverlay dialog, Framework.Game game,
-            OsuGame osuGame, OsuColour colours)
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
         {
-            const float carousel_width = 640;
-            const float filter_height = 100;
+            Footer.AddButton(@"mods", colours.Yellow, modSelect.ToggleVisibility, Key.F1, float.MaxValue);
 
-            beatmapGroups = new List<BeatmapGroup>();
-            Children = new Drawable[]
+            BeatmapOptions.AddButton(@"Remove", @"from unplayed", FontAwesome.fa_times_circle_o, colours.Purple, null, Key.Number1);
+            BeatmapOptions.AddButton(@"Clear", @"local scores", FontAwesome.fa_eraser, colours.Purple, null, Key.Number2);
+            BeatmapOptions.AddButton(@"Edit", @"Beatmap", FontAwesome.fa_pencil, colours.Yellow, () =>
             {
-                new ParallaxContainer
-                {
-                    Padding = new MarginPadding { Top = filter_height },
-                    ParallaxAmount = 0.005f,
-                    RelativeSizeAxes = Axes.Both,
-                    Children = new[]
-                    {
-                        new WedgeBackground
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            Padding = new MarginPadding
-                            {
-                                Right = carousel_width * 0.76f
-                            },
-                        },
-                    }
-                },
-                carousel = new CarouselContainer
-                {
-                    RelativeSizeAxes = Axes.Y,
-                    Size = new Vector2(carousel_width, 1),
-                    Anchor = Anchor.CentreRight,
-                    Origin = Anchor.CentreRight,
-                },
-                filter = new FilterControl
-                {
-                    RelativeSizeAxes = Axes.X,
-                    Height = filter_height,
-                    FilterChanged = filterChanged,
-                    Exit = Exit,
-                },
-                beatmapInfoWedge = new BeatmapInfoWedge
-                {
-                    Alpha = 0,
-                    Size = wedged_container_size,
-                    RelativeSizeAxes = Axes.X,
-                    Margin = new MarginPadding
-                    {
-                        Top = 20,
-                        Right = 20,
-                    },
-                },
-                footer = new Footer
-                {
-                    OnBack = Exit,
-                    OnStart = () =>
-                    {
-                        if (player != null || Beatmap == null)
-                            return;
-
-                        (player = new PlayerLoader(new Player
-                        {
-                            BeatmapInfo = carousel.SelectedGroup.SelectedPanel.Beatmap,
-                            PreferredPlayMode = playMode.Value
-                        })).LoadAsync(Game, l => Push(player));
-                    }
-                },
-            };
-
-            footer.AddButton(@"mods", colours.Yellow, null);
-            footer.AddButton(@"random", colours.Green, carousel.SelectRandom);
-            footer.AddButton(@"options", colours.Blue, null);
-
-            if (osuGame != null)
-            {
-                playMode = osuGame.PlayMode;
-                playMode.ValueChanged += playMode_ValueChanged;
-            }
-
-            if (database == null)
-                database = beatmaps;
-
-            database.BeatmapSetAdded += onBeatmapSetAdded;
-            database.BeatmapSetRemoved += onBeatmapSetRemoved;
-
-            trackManager = audio.Track;
-            dialogOverlay = dialog;
-
-            sampleChangeDifficulty = audio.Sample.Get(@"SongSelect/select-difficulty");
-            sampleChangeBeatmap = audio.Sample.Get(@"SongSelect/select-expand");
-
-            initialAddSetsTask = new CancellationTokenSource();
-
-            Task.Factory.StartNew(() => addBeatmapSets(game, initialAddSetsTask.Token), initialAddSetsTask.Token);
+                ValidForResume = false;
+                Push(new Editor());
+            }, Key.Number3);
         }
 
-        private ScheduledDelegate filterTask;
+        private GetScoresRequest getScoresRequest;
 
-        private void filterChanged()
+        protected override void OnBeatmapChanged(WorkingBeatmap beatmap)
         {
-            filterTask?.Cancel();
-            filterTask = Scheduler.AddDelayed(() =>
-            {
-                filterTask = null;
-                var search = filter.Search;
-                BeatmapGroup newSelection = null;
-                carousel.Sort(filter.Sort);
-                foreach (var beatmapGroup in carousel)
-                {
-                    var set = beatmapGroup.BeatmapSet;
-                    bool match = string.IsNullOrEmpty(search)
-                        || (set.Metadata.Artist ?? "").IndexOf(search, StringComparison.InvariantCultureIgnoreCase) != -1
-                        || (set.Metadata.ArtistUnicode ?? "").IndexOf(search, StringComparison.InvariantCultureIgnoreCase) != -1
-                        || (set.Metadata.Title ?? "").IndexOf(search, StringComparison.InvariantCultureIgnoreCase) != -1
-                        || (set.Metadata.TitleUnicode ?? "").IndexOf(search, StringComparison.InvariantCultureIgnoreCase) != -1;
-                    if (match)
-                    {
-                        beatmapGroup.State = BeatmapGroupState.Collapsed;
-                        if (newSelection == null || beatmapGroup.BeatmapSet.OnlineBeatmapSetID == Beatmap.BeatmapSetInfo.OnlineBeatmapSetID)
-                            newSelection = beatmapGroup;
-                    }
-                    else
-                    {
-                        beatmapGroup.State = BeatmapGroupState.Hidden;
-                    }
-                }
-                if (newSelection != null)
-                    carousel.SelectBeatmap(newSelection.BeatmapSet.Beatmaps[0], false);
-            }, 250);
+            beatmap?.Mods.BindTo(modSelect.SelectedMods);
+
+            updateLeaderboard(beatmap);
+
+            base.OnBeatmapChanged(beatmap);
         }
 
-        private void onBeatmapSetAdded(BeatmapSetInfo s) => Schedule(() => addBeatmapSet(s, Game, true));
-
-        private void onBeatmapSetRemoved(BeatmapSetInfo s) => Schedule(() => removeBeatmapSet(s));
-
-        protected override void OnEntering(Screen last)
+        private void updateLeaderboard(WorkingBeatmap beatmap)
         {
-            base.OnEntering(last);
-            ensurePlayingSelected();
+            leaderboard.Scores = null;
+            getScoresRequest?.Cancel();
 
-            changeBackground(Beatmap);
+            if (beatmap?.BeatmapInfo == null) return;
 
-            Content.FadeInFromZero(250);
-
-            beatmapInfoWedge.MoveToX(-50);
-            beatmapInfoWedge.MoveToX(0, 800, EasingTypes.OutQuint);
-
-            filter.Activate();
+            getScoresRequest = new GetScoresRequest(beatmap.BeatmapInfo);
+            getScoresRequest.Success += r => leaderboard.Scores = r.Scores;
+            Game.API.Queue(getScoresRequest);
         }
 
         protected override void OnResuming(Screen last)
         {
             player = null;
-
-            changeBackground(Beatmap);
-            ensurePlayingSelected();
             base.OnResuming(last);
-
-            Content.FadeIn(250);
-
-            Content.ScaleTo(1, 250, EasingTypes.OutSine);
-
-            filter.Activate();
         }
 
-        protected override void OnSuspending(Screen next)
+        protected override void OnSelected()
         {
-            Content.ScaleTo(1.1f, 250, EasingTypes.InSine);
+            if (player != null) return;
 
-            Content.FadeOut(250);
-
-            filter.Deactivate();
-            base.OnSuspending(next);
-        }
-
-        protected override bool OnExiting(Screen next)
-        {
-            beatmapInfoWedge.MoveToX(-100, 800, EasingTypes.InQuint);
-            beatmapInfoWedge.RotateTo(10, 800, EasingTypes.InQuint);
-
-            Content.FadeOut(100);
-
-            filter.Deactivate();
-            return base.OnExiting(next);
-        }
-
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-            if (playMode != null)
-                playMode.ValueChanged -= playMode_ValueChanged;
-
-            database.BeatmapSetAdded -= onBeatmapSetAdded;
-            database.BeatmapSetRemoved -= onBeatmapSetRemoved;
-
-            initialAddSetsTask.Cancel();
-        }
-
-        private void playMode_ValueChanged(object sender, EventArgs e)
-        {
-        }
-
-        private void changeBackground(WorkingBeatmap beatmap)
-        {
-            var backgroundModeBeatmap = Background as BackgroundScreenBeatmap;
-            if (backgroundModeBeatmap != null)
+            (player = new PlayerLoader(new Player
             {
-                backgroundModeBeatmap.Beatmap = beatmap;
-                backgroundModeBeatmap.BlurTo(background_blur, 1000);
-                backgroundModeBeatmap.FadeTo(1, 250);
-            }
-
-            if (beatmap != null)
-                beatmapInfoWedge.UpdateBeatmap(beatmap);
-        }
-
-        /// <summary>
-        /// The global Beatmap was changed.
-        /// </summary>
-        protected override void OnBeatmapChanged(WorkingBeatmap beatmap)
-        {
-            base.OnBeatmapChanged(beatmap);
-
-            //todo: change background in selectionChanged instead; support per-difficulty backgrounds.
-            changeBackground(beatmap);
-            carousel.SelectBeatmap(beatmap?.BeatmapInfo);
-        }
-
-        /// <summary>
-        /// selection has been changed as the result of interaction with the carousel.
-        /// </summary>
-        private void selectionChanged(BeatmapGroup group, BeatmapInfo beatmap)
-        {
-            bool beatmapSetChange = false;
-
-            if (!beatmap.Equals(Beatmap?.BeatmapInfo))
-            {
-                if (beatmap.BeatmapSetInfoID == Beatmap?.BeatmapInfo.BeatmapSetInfoID)
-                    sampleChangeDifficulty.Play();
-                else
-                {
-                    sampleChangeBeatmap.Play();
-                    beatmapSetChange = true;
-                }
-                Beatmap = database.GetWorkingBeatmap(beatmap, Beatmap);
-            }
-            ensurePlayingSelected(beatmapSetChange);
-        }
-
-        private void ensurePlayingSelected(bool preview = false)
-        {
-            Track track = Beatmap?.Track;
-
-            if (track != null)
-            {
-                trackManager.SetExclusive(track);
-                if (preview)
-                    track.Seek(Beatmap.Beatmap.Metadata.PreviewTime);
-                track.Start();
-            }
-        }
-
-        private void addBeatmapSet(BeatmapSetInfo beatmapSet, Framework.Game game, bool select = false)
-        {
-            beatmapSet = database.GetWithChildren<BeatmapSetInfo>(beatmapSet.ID);
-            beatmapSet.Beatmaps.ForEach(b =>
-            {
-                database.GetChildren(b);
-                if (b.Metadata == null) b.Metadata = beatmapSet.Metadata;
-            });
-
-            var group = new BeatmapGroup(beatmapSet, database)
-            {
-                SelectionChanged = selectionChanged,
-                StartRequested = b => footer.StartButton.TriggerClick()
-            };
-
-            //for the time being, let's completely load the difficulty panels in the background.
-            //this likely won't scale so well, but allows us to completely async the loading flow.
-            Task.WhenAll(group.BeatmapPanels.Select(panel => panel.LoadAsync(game))).ContinueWith(task => Schedule(delegate
-            {
-                beatmapGroups.Add(group);
-
-                carousel.AddGroup(group);
-
-                if (Beatmap == null || select)
-                    carousel.SelectBeatmap(beatmapSet.Beatmaps.First());
-                else
-                {
-                    var panel = group.BeatmapPanels.FirstOrDefault(p => p.Beatmap.Equals(Beatmap.BeatmapInfo));
-                    if (panel != null)
-                        carousel.SelectGroup(group, panel);
-                }
-            }));
-        }
-
-        private void removeBeatmapSet(BeatmapSetInfo beatmapSet)
-        {
-            var group = beatmapGroups.Find(b => b.BeatmapSet.ID == beatmapSet.ID);
-            if (group == null) return;
-
-            if (carousel.SelectedGroup == group)
-                carousel.SelectNext();
-
-            beatmapGroups.Remove(group);
-            carousel.RemoveGroup(group);
-
-            if (beatmapGroups.Count == 0)
-                Beatmap = null;
-        }
-
-        private void addBeatmapSets(Framework.Game game, CancellationToken token)
-        {
-            foreach (var beatmapSet in database.Query<BeatmapSetInfo>().Where(b => !b.DeletePending))
-            {
-                if (token.IsCancellationRequested) return;
-                addBeatmapSet(beatmapSet, game);
-            }
-            filterChanged();
-        }
-
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
-        {
-            switch (args.Key)
-            {
-                case Key.Enter:
-                    footer.StartButton.TriggerClick();
-                    return true;
-                case Key.Delete:
-                    if (state.Keyboard.ShiftPressed)
-                    {
-                        if (Beatmap != null)
-                            dialogOverlay?.Push(new BeatmapDeleteDialog(Beatmap));
-
-                        return true;
-                    }
-                    break;
-            }
-
-            return base.OnKeyDown(state, args);
+                Beatmap = Beatmap, //eagerly set this so it's present before push.
+            })).LoadAsync(Game, l => Push(player));
         }
     }
 }

osu.Game/Screens/Select/SearchTextBox.cs

@@ -26,6 +26,7 @@ namespace osu.Game.Screens.Select
                     Origin = Anchor.CentreRight,
                     Anchor = Anchor.CentreRight,
                     Margin = new MarginPadding { Right = 10 },
+                    TextSize = 20
                 }
             });
 

osu.Game/Screens/Select/SongSelect.cs

@@ -0,0 +1,369 @@
+// 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.Linq;
+using System.Threading;
+using OpenTK;
+using OpenTK.Input;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Audio.Track;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Transforms;
+using osu.Framework.Input;
+using osu.Framework.Screens;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Drawables;
+using osu.Game.Database;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Modes;
+using osu.Game.Overlays;
+using osu.Game.Screens.Backgrounds;
+using osu.Game.Screens.Select.Options;
+
+namespace osu.Game.Screens.Select
+{
+    public abstract class SongSelect : OsuScreen
+    {
+        private Bindable<PlayMode> playMode = new Bindable<PlayMode>();
+        private BeatmapDatabase database;
+        protected override BackgroundScreen CreateBackground() => new BackgroundScreenBeatmap(Beatmap);
+
+        private BeatmapCarousel carousel;
+        private TrackManager trackManager;
+        private DialogOverlay dialogOverlay;
+
+
+        private static readonly Vector2 wedged_container_size = new Vector2(0.5f, 245);
+
+        private const float left_area_padding = 20;
+
+        private BeatmapInfoWedge beatmapInfoWedge;
+
+        protected Container LeftContent;
+
+        private static readonly Vector2 background_blur = new Vector2(20);
+        private CancellationTokenSource initialAddSetsTask;
+
+        private SampleChannel sampleChangeDifficulty;
+        private SampleChannel sampleChangeBeatmap;
+
+        protected virtual bool ShowFooter => true;
+
+        /// <summary>
+        /// Can be null if <see cref="ShowFooter"/> is false.
+        /// </summary>
+        protected readonly BeatmapOptionsOverlay BeatmapOptions;
+
+        /// <summary>
+        /// Can be null if <see cref="ShowFooter"/> is false.
+        /// </summary>
+        protected readonly Footer Footer;
+
+        public readonly FilterControl FilterControl;
+
+        protected SongSelect()
+        {
+            const float carousel_width = 640;
+            const float filter_height = 100;
+
+            Add(new ParallaxContainer
+            {
+                Padding = new MarginPadding { Top = filter_height },
+                ParallaxAmount = 0.005f,
+                RelativeSizeAxes = Axes.Both,
+                Children = new[]
+                {
+                    new WedgeBackground
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Padding = new MarginPadding { Right = carousel_width * 0.76f },
+                    }
+                }
+            });
+            Add(LeftContent = new Container
+            {
+                Origin = Anchor.BottomLeft,
+                Anchor = Anchor.BottomLeft,
+                RelativeSizeAxes = Axes.Both,
+                Size = new Vector2(wedged_container_size.X, 1),
+                Padding = new MarginPadding
+                {
+                    Bottom = 50,
+                    Top = wedged_container_size.Y + left_area_padding,
+                    Left = left_area_padding,
+                    Right = left_area_padding * 2,
+                }
+            });
+            Add(carousel = new BeatmapCarousel
+            {
+                RelativeSizeAxes = Axes.Y,
+                Size = new Vector2(carousel_width, 1),
+                Anchor = Anchor.CentreRight,
+                Origin = Anchor.CentreRight,
+                SelectionChanged = selectionChanged,
+                StartRequested = raiseSelect
+            });
+            Add(FilterControl = new FilterControl
+            {
+                RelativeSizeAxes = Axes.X,
+                Height = filter_height,
+                FilterChanged = criteria => filterChanged(criteria),
+                Exit = Exit,
+            });
+            Add(beatmapInfoWedge = new BeatmapInfoWedge
+            {
+                Alpha = 0,
+                Size = wedged_container_size,
+                RelativeSizeAxes = Axes.X,
+                Margin = new MarginPadding
+                {
+                    Top = left_area_padding,
+                    Right = left_area_padding,
+                },
+                X = -50,
+            });
+
+            if (ShowFooter)
+            {
+                Add(BeatmapOptions = new BeatmapOptionsOverlay
+                {
+                    Margin = new MarginPadding
+                    {
+                        Bottom = 50,
+                    },
+                });
+                Add(Footer = new Footer
+                {
+                    OnBack = Exit,
+                    OnStart = raiseSelect,
+                });
+            }
+        }
+
+        [BackgroundDependencyLoader(permitNulls: true)]
+        private void load(BeatmapDatabase beatmaps, AudioManager audio, DialogOverlay dialog, OsuGame osu, OsuColour colours)
+        {
+            if (Footer != null)
+            {
+                Footer.AddButton(@"random", colours.Green, SelectRandom, Key.F2);
+                Footer.AddButton(@"options", colours.Blue, BeatmapOptions.ToggleVisibility, Key.F3);
+
+                BeatmapOptions.AddButton(@"Delete", @"Beatmap", FontAwesome.fa_trash, colours.Pink, promptDelete, Key.Number4, float.MaxValue);
+            }
+
+            if (osu != null)
+                playMode.BindTo(osu.PlayMode);
+            playMode.ValueChanged += playMode_ValueChanged;
+
+            if (database == null)
+                database = beatmaps;
+
+            database.BeatmapSetAdded += onBeatmapSetAdded;
+            database.BeatmapSetRemoved += onBeatmapSetRemoved;
+
+            trackManager = audio.Track;
+            dialogOverlay = dialog;
+
+            sampleChangeDifficulty = audio.Sample.Get(@"SongSelect/select-difficulty");
+            sampleChangeBeatmap = audio.Sample.Get(@"SongSelect/select-expand");
+
+            initialAddSetsTask = new CancellationTokenSource();
+
+            carousel.BeatmapsChanged = beatmapsLoaded;
+            carousel.Beatmaps = database.Query<BeatmapSetInfo>().Where(b => !b.DeletePending);
+        }
+
+        private void beatmapsLoaded()
+        {
+            if (Beatmap != null)
+                carousel.SelectBeatmap(Beatmap.BeatmapInfo, false);
+            else
+                carousel.SelectNext();
+        }
+
+        private void raiseSelect()
+        {
+            if (Beatmap == null) return;
+
+            Beatmap.PreferredPlayMode = playMode.Value;
+            OnSelected();
+        }
+
+        public void SelectRandom() => carousel.SelectRandom();
+
+        protected abstract void OnSelected();
+
+        private void filterChanged(FilterCriteria criteria, bool debounce = true)
+        {
+            carousel.Filter(criteria, debounce);
+        }
+
+        private void onBeatmapSetAdded(BeatmapSetInfo s) => carousel.AddBeatmap(s);
+
+        private void onBeatmapSetRemoved(BeatmapSetInfo s) => Schedule(() => removeBeatmapSet(s));
+
+        protected override void OnEntering(Screen last)
+        {
+            base.OnEntering(last);
+            ensurePlayingSelected();
+
+            changeBackground(Beatmap);
+
+            Content.FadeInFromZero(250);
+
+            beatmapInfoWedge.State = Visibility.Visible;
+
+            FilterControl.Activate();
+        }
+
+        protected override void OnResuming(Screen last)
+        {
+            changeBackground(Beatmap);
+            ensurePlayingSelected();
+            base.OnResuming(last);
+
+            Content.FadeIn(250);
+
+            Content.ScaleTo(1, 250, EasingTypes.OutSine);
+
+            FilterControl.Activate();
+        }
+
+        protected override void OnSuspending(Screen next)
+        {
+            Content.ScaleTo(1.1f, 250, EasingTypes.InSine);
+
+            Content.FadeOut(250);
+
+            FilterControl.Deactivate();
+            base.OnSuspending(next);
+        }
+
+        protected override bool OnExiting(Screen next)
+        {
+            beatmapInfoWedge.State = Visibility.Hidden;
+
+            Content.FadeOut(100);
+
+            FilterControl.Deactivate();
+            return base.OnExiting(next);
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            database.BeatmapSetAdded -= onBeatmapSetAdded;
+            database.BeatmapSetRemoved -= onBeatmapSetRemoved;
+
+            initialAddSetsTask.Cancel();
+        }
+
+        private void playMode_ValueChanged(object sender, EventArgs e) => carousel.Filter();
+
+        private void changeBackground(WorkingBeatmap beatmap)
+        {
+            var backgroundModeBeatmap = Background as BackgroundScreenBeatmap;
+            if (backgroundModeBeatmap != null)
+            {
+                backgroundModeBeatmap.Beatmap = beatmap;
+                backgroundModeBeatmap.BlurTo(background_blur, 1000);
+                backgroundModeBeatmap.FadeTo(1, 250);
+            }
+
+            beatmapInfoWedge.UpdateBeatmap(beatmap);
+        }
+
+        /// <summary>
+        /// The global Beatmap was changed.
+        /// </summary>
+        protected override void OnBeatmapChanged(WorkingBeatmap beatmap)
+        {
+            base.OnBeatmapChanged(beatmap);
+
+            //todo: change background in selectionChanged instead; support per-difficulty backgrounds.
+            changeBackground(beatmap);
+            carousel.SelectBeatmap(beatmap?.BeatmapInfo);
+        }
+
+        /// <summary>
+        /// selection has been changed as the result of interaction with the carousel.
+        /// </summary>
+        private void selectionChanged(BeatmapGroup group, BeatmapInfo beatmap)
+        {
+            bool beatmapSetChange = false;
+
+            if (!beatmap.Equals(Beatmap?.BeatmapInfo))
+            {
+                if (beatmap.BeatmapSetInfoID == Beatmap?.BeatmapInfo.BeatmapSetInfoID)
+                    sampleChangeDifficulty.Play();
+                else
+                {
+                    sampleChangeBeatmap.Play();
+                    beatmapSetChange = true;
+                }
+                Beatmap = database.GetWorkingBeatmap(beatmap, Beatmap);
+            }
+            ensurePlayingSelected(beatmapSetChange);
+        }
+
+        private void ensurePlayingSelected(bool preview = false)
+        {
+            Track track = Beatmap?.Track;
+
+            if (track != null)
+            {
+                trackManager.SetExclusive(track);
+                if (preview)
+                    track.Seek(Beatmap.Beatmap.Metadata.PreviewTime);
+                track.Start();
+            }
+        }
+
+        private void selectBeatmap(BeatmapSetInfo beatmapSet = null)
+        {
+            carousel.SelectBeatmap(beatmapSet != null ? beatmapSet.Beatmaps.First() : Beatmap?.BeatmapInfo);
+        }
+
+        private void removeBeatmapSet(BeatmapSetInfo beatmapSet)
+        {
+            carousel.RemoveBeatmap(beatmapSet);
+            if (carousel.SelectedBeatmap == null)
+                Beatmap = null;
+        }
+
+        private void promptDelete()
+        {
+            if (Beatmap != null)
+                dialogOverlay?.Push(new BeatmapDeleteDialog(Beatmap));
+        }
+
+        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        {
+            if (args.Repeat) return false;
+
+            switch (args.Key)
+            {
+                case Key.Enter:
+                    raiseSelect();
+                    return true;
+                case Key.Delete:
+                    if (state.Keyboard.ShiftPressed)
+                    {
+                        promptDelete();
+                        return true;
+                    }
+                    break;
+            }
+
+            return base.OnKeyDown(state, args);
+        }
+    }
+}

osu.Game/Screens/Select/WedgeBackground.cs

@@ -1,10 +1,10 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
-using osu.Game.Graphics;
 using OpenTK;
 using OpenTK.Graphics;
 

osu.Game/Screens/Tournament/Components/DrawingsConfigManager.cs

@@ -0,0 +1,30 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Configuration;
+using osu.Framework.Platform;
+
+namespace osu.Game.Screens.Tournament.Components
+{
+    public class DrawingsConfigManager : ConfigManager<DrawingsConfig>
+    {
+        protected override string Filename => @"drawings.ini";
+
+        protected override void InitialiseDefaults()
+        {
+            Set(DrawingsConfig.Groups, 8, 1, 8);
+            Set(DrawingsConfig.TeamsPerGroup, 8, 1, 8);
+        }
+
+        public DrawingsConfigManager(Storage storage)
+            : base(storage)
+        {
+        }
+    }
+
+    public enum DrawingsConfig
+    {
+        Groups,
+        TeamsPerGroup
+    }
+}

osu.Game/Screens/Tournament/Components/VisualiserContainer.cs

@@ -0,0 +1,124 @@
+// Copyright (c) 2007-2017 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.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.MathUtils;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace osu.Game.Screens.Tournament.Components
+{
+    internal class VisualiserContainer : Container
+    {
+        /// <summary>
+        /// Number of lines in the visualiser.
+        /// </summary>
+        public int Lines
+        {
+            get { return allLines.Count; }
+            set
+            {
+                while (value > allLines.Count)
+                    addLine();
+
+                while (value < allLines.Count)
+                    removeLine();
+            }
+        }
+
+        private List<VisualiserLine> allLines = new List<VisualiserLine>();
+
+        private float offset;
+
+        private void addLine()
+        {
+            VisualiserLine newLine = new VisualiserLine
+            {
+                RelativeSizeAxes = Axes.Both,
+
+                Offset = offset,
+                CycleTime = RNG.Next(10000, 12000),
+            };
+
+            allLines.Add(newLine);
+            Add(newLine);
+
+            offset += RNG.Next(100, 5000);
+        }
+
+        private void removeLine()
+        {
+            if (allLines.Count == 0)
+                return;
+
+            Remove(allLines.First());
+            allLines.Remove(allLines.First());
+        }
+
+        private class VisualiserLine : Container
+        {
+            /// <summary>
+            /// Time offset.
+            /// </summary>
+            public float Offset;
+
+            public double CycleTime;
+
+            private float leftPos => -(float)((Time.Current + Offset) / CycleTime) + expiredCount;
+
+            private Texture texture;
+
+            private int expiredCount;
+
+            [BackgroundDependencyLoader]
+            private void load(TextureStore textures)
+            {
+                texture = textures.Get("Drawings/visualiser-line");
+            }
+
+            protected override void UpdateAfterChildren()
+            {
+                base.UpdateAfterChildren();
+
+                while (Children.Count() < 3)
+                    addLine();
+
+                float pos = leftPos;
+
+                foreach (var c in Children)
+                {
+                    if (c.Position.X < -1)
+                    {
+                        c.ClearTransforms();
+                        c.Expire();
+                        expiredCount++;
+                    }
+                    else
+                        c.MoveToX(pos, 100);
+
+                    pos += 1;
+                }
+            }
+
+            private void addLine()
+            {
+                Add(new Sprite
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+
+                    RelativePositionAxes = Axes.Both,
+                    RelativeSizeAxes = Axes.Both,
+
+                    Texture = texture,
+
+                    X = leftPos + 1
+                });
+            }
+        }
+    }
+}

osu.Game/Screens/Tournament/Drawings.cs

@@ -0,0 +1,337 @@
+// 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 System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Logging;
+using osu.Framework.Platform;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Screens.Backgrounds;
+using osu.Game.Screens.Tournament.Components;
+using osu.Game.Screens.Tournament.Teams;
+using OpenTK;
+using OpenTK.Graphics;
+using osu.Game.Users;
+
+namespace osu.Game.Screens.Tournament
+{
+    public class Drawings : OsuScreen
+    {
+        private const string results_filename = "drawings_results.txt";
+
+        internal override bool ShowOverlays => false;
+
+        protected override BackgroundScreen CreateBackground() => new BackgroundScreenDefault();
+
+        private ScrollingTeamContainer teamsContainer;
+        private GroupContainer groupsContainer;
+        private OsuSpriteText fullTeamNameText;
+
+        private List<Country> allTeams = new List<Country>();
+
+        private DrawingsConfigManager drawingsConfig;
+
+        private Task writeOp;
+
+        private Storage storage;
+
+        public ITeamList TeamList;
+
+        [BackgroundDependencyLoader]
+        private void load(TextureStore textures, Storage storage)
+        {
+            this.storage = storage;
+
+            if (TeamList == null)
+                TeamList = new StorageBackedTeamList(storage);
+
+            if (!TeamList.Teams.Any())
+            {
+                Exit();
+                return;
+            }
+
+            drawingsConfig = new DrawingsConfigManager(storage);
+
+            Children = new Drawable[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = new Color4(77, 77, 77, 255)
+                },
+                new Sprite
+                {
+                    FillMode = FillMode.Fill,
+                    Texture = textures.Get(@"Backgrounds/Drawings/background.png")
+                },
+                new FillFlowContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Direction = FillDirection.Horizontal,
+
+                    Children = new Drawable[]
+                    {
+                        // Main container
+                        new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Width = 0.85f,
+
+                            Children = new Drawable[]
+                            {
+                                // Visualiser
+                                new VisualiserContainer
+                                {
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+
+                                    RelativeSizeAxes = Axes.X,
+                                    Size = new Vector2(1, 10),
+
+                                    Colour = new Color4(255, 204, 34, 255),
+
+                                    Lines = 6
+                                },
+                                // Groups
+                                groupsContainer = new GroupContainer(drawingsConfig.Get<int>(DrawingsConfig.Groups), drawingsConfig.Get<int>(DrawingsConfig.TeamsPerGroup))
+                                {
+                                    Anchor = Anchor.TopCentre,
+                                    Origin = Anchor.TopCentre,
+
+                                    RelativeSizeAxes = Axes.Y,
+                                    AutoSizeAxes = Axes.X,
+
+                                    Padding = new MarginPadding
+                                    {
+                                        Top = 35f,
+                                        Bottom = 35f
+                                    }
+                                },
+                                // Scrolling teams
+                                teamsContainer = new ScrollingTeamContainer
+                                {
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+
+                                    RelativeSizeAxes = Axes.X,
+                                },
+                                // Scrolling team name
+                                fullTeamNameText = new OsuSpriteText
+                                {
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.TopCentre,
+
+                                    Position = new Vector2(0, 45f),
+
+                                    Alpha = 0,
+
+                                    Font = "Exo2.0-Light",
+                                    TextSize = 42f
+                                }
+                            }
+                        },
+                        // Control panel container
+                        new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Width = 0.15f,
+
+                            Children = new Drawable[]
+                            {
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = new Color4(54, 54, 54, 255)
+                                },
+                                new OsuSpriteText
+                                {
+                                    Anchor = Anchor.TopCentre,
+                                    Origin = Anchor.TopCentre,
+
+                                    Text = "Control Panel",
+                                    TextSize = 22f,
+                                    Font = "Exo2.0-Bold"
+                                },
+                                new FillFlowContainer
+                                {
+                                    Anchor = Anchor.TopCentre,
+                                    Origin = Anchor.TopCentre,
+
+                                    RelativeSizeAxes = Axes.X,
+                                    AutoSizeAxes = Axes.Y,
+                                    Width = 0.75f,
+
+                                    Position = new Vector2(0, 35f),
+
+                                    Direction = FillDirection.Vertical,
+                                    Spacing = new Vector2(0, 5f),
+
+                                    Children = new Drawable[]
+                                    {
+                                        new OsuButton
+                                        {
+                                            RelativeSizeAxes = Axes.X,
+
+                                            Text = "Begin random",
+                                            Action = teamsContainer.StartScrolling,
+                                        },
+                                        new OsuButton
+                                        {
+                                            RelativeSizeAxes = Axes.X,
+
+                                            Text = "Stop random",
+                                            Action = teamsContainer.StopScrolling,
+                                        },
+                                        new OsuButton
+                                        {
+                                            RelativeSizeAxes = Axes.X,
+
+                                            Text = "Reload",
+                                            Action = reloadTeams
+                                        }
+                                    }
+                                },
+                                new FillFlowContainer
+                                {
+                                    Anchor = Anchor.BottomCentre,
+                                    Origin = Anchor.BottomCentre,
+
+                                    RelativeSizeAxes = Axes.X,
+                                    AutoSizeAxes = Axes.Y,
+                                    Width = 0.75f,
+
+                                    Position = new Vector2(0, -5f),
+
+                                    Direction = FillDirection.Vertical,
+                                    Spacing = new Vector2(0, 5f),
+
+                                    Children = new Drawable[]
+                                    {
+                                        new OsuButton
+                                        {
+                                            RelativeSizeAxes = Axes.X,
+
+                                            Text = "Reset",
+                                            Action = () => reset(false)
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            teamsContainer.OnSelected += onTeamSelected;
+            teamsContainer.OnScrollStarted += () => fullTeamNameText.FadeOut(200);
+
+            reset(true);
+        }
+
+        private void onTeamSelected(Country team)
+        {
+            groupsContainer.AddTeam(team);
+
+            fullTeamNameText.Text = team.FullName;
+            fullTeamNameText.FadeIn(200);
+
+            writeResults(groupsContainer.GetStringRepresentation());
+        }
+
+        private void writeResults(string text)
+        {
+            Action writeAction = () =>
+            {
+                try
+                {
+                    // Write to drawings_results
+                    using (Stream stream = storage.GetStream(results_filename, FileAccess.Write, FileMode.Create))
+                    using (StreamWriter sw = new StreamWriter(stream))
+                    {
+                        sw.Write(text);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Logger.Error(ex, "Failed to write results.");
+                }
+            };
+
+            writeOp = writeOp?.ContinueWith(t => { writeAction(); }) ?? Task.Run(writeAction);
+        }
+
+        private void reloadTeams()
+        {
+            teamsContainer.ClearTeams();
+            allTeams.Clear();
+
+            foreach (Country t in TeamList.Teams)
+            {
+                if (groupsContainer.ContainsTeam(t.FullName))
+                    continue;
+
+                allTeams.Add(t);
+                teamsContainer.AddTeam(t);
+            }
+        }
+
+        private void reset(bool loadLastResults = false)
+        {
+            groupsContainer.ClearTeams();
+
+            reloadTeams();
+
+            if (!storage.Exists(results_filename))
+                return;
+
+            if (loadLastResults)
+            {
+                try
+                {
+                    // Read from drawings_results
+                    using (Stream stream = storage.GetStream(results_filename, FileAccess.Read, FileMode.Open))
+                    using (StreamReader sr = new StreamReader(stream))
+                    {
+                        string line;
+                        while ((line = sr.ReadLine()?.Trim()) != null)
+                        {
+                            if (string.IsNullOrEmpty(line))
+                                continue;
+
+                            if (line.ToUpper().StartsWith("GROUP"))
+                                continue;
+
+                            Country teamToAdd = allTeams.FirstOrDefault(t => t.FullName == line);
+
+                            if (teamToAdd == null)
+                                continue;
+
+                            groupsContainer.AddTeam(teamToAdd);
+                            teamsContainer.RemoveTeam(teamToAdd);
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Logger.Error(ex, "Failed to read last drawings results.");
+                }
+
+            }
+            else
+            {
+                writeResults(string.Empty);
+            }
+        }
+    }
+}

osu.Game/Screens/Tournament/Group.cs

@@ -0,0 +1,187 @@
+// 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.Collections.Generic;
+using System.Linq;
+using System.Text;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Graphics.Sprites;
+using OpenTK;
+using OpenTK.Graphics;
+using osu.Game.Users;
+
+namespace osu.Game.Screens.Tournament
+{
+    public class Group : Container
+    {
+        public readonly string GroupName;
+
+        public int TeamsCount { get; private set; }
+
+        private FlowContainer<GroupTeam> teams;
+
+        private List<GroupTeam> allTeams = new List<GroupTeam>();
+
+        public Group(string name)
+        {
+            GroupName = name;
+
+            Size = new Vector2(176, 128);
+
+            Masking = true;
+            CornerRadius = 4;
+
+            Children = new Drawable[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = new Color4(54, 54, 54, 255)
+                },
+                // Group name
+                new OsuSpriteText
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
+
+                    Position = new Vector2(0, 7f),
+
+                    Text = $"GROUP {name.ToUpper()}",
+                    TextSize = 8f,
+                    Font = @"Exo2.0-Bold",
+                    Colour = new Color4(255, 204, 34, 255),
+                },
+                teams = new FillFlowContainer<GroupTeam>
+                {
+                    RelativeSizeAxes = Axes.Both,
+
+                    Spacing = new Vector2(6f, 22),
+
+                    Margin = new MarginPadding
+                    {
+                        Top = 21f,
+                        Bottom = 7f,
+                        Left = 7f,
+                        Right = 7f
+                    }
+                }
+            };
+        }
+
+        public void AddTeam(Country team)
+        {
+            GroupTeam gt = new GroupTeam(team);
+
+            if (TeamsCount < 8)
+            {
+                teams.Add(gt);
+                allTeams.Add(gt);
+
+                TeamsCount++;
+            }
+        }
+
+        public bool ContainsTeam(string fullName)
+        {
+            return allTeams.Any(t => t.Team.FullName == fullName);
+        }
+
+        public bool RemoveTeam(Country team)
+        {
+            allTeams.RemoveAll(gt => gt.Team == team);
+
+            if (teams.RemoveAll(gt => gt.Team == team) > 0)
+            {
+                TeamsCount--;
+                return true;
+            }
+
+            return false;
+        }
+
+        public void ClearTeams()
+        {
+            allTeams.Clear();
+            teams.Clear();
+
+            TeamsCount = 0;
+        }
+
+        public string GetStringRepresentation()
+        {
+            StringBuilder sb = new StringBuilder();
+            foreach (GroupTeam gt in allTeams)
+                sb.AppendLine(gt.Team.FullName);
+            return sb.ToString();
+        }
+
+        private class GroupTeam : Container
+        {
+            public Country Team;
+
+            private FillFlowContainer innerContainer;
+            private Sprite flagSprite;
+
+            public GroupTeam(Country team)
+            {
+                Team = team;
+
+                Width = 36;
+                AutoSizeAxes = Axes.Y;
+
+                Children = new Drawable[]
+                {
+                    innerContainer = new FillFlowContainer
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+
+                        Direction = FillDirection.Vertical,
+                        Spacing = new Vector2(0, 5f),
+
+                        Children = new Drawable[]
+                        {
+                            flagSprite = new Sprite
+                            {
+                                Anchor = Anchor.TopCentre,
+                                Origin = Anchor.TopCentre,
+
+                                FillMode = FillMode.Fit
+                            },
+                            new OsuSpriteText
+                            {
+                                Anchor = Anchor.TopCentre,
+                                Origin = Anchor.TopCentre,
+
+                                Text = team.Acronym.ToUpper(),
+                                TextSize = 10f,
+                                Font = @"Exo2.0-Bold"
+                            }
+                        }
+                    }
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                innerContainer.ScaleTo(1.5f);
+                innerContainer.ScaleTo(1f, 200);
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(TextureStore textures)
+            {
+                flagSprite.Texture = textures.Get($@"Flags/{Team.FlagName}");
+            }
+        }
+    }
+}

osu.Game/Screens/Tournament/GroupContainer.cs

@@ -0,0 +1,105 @@
+// 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 System.Linq;
+using System.Text;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using OpenTK;
+using osu.Game.Users;
+
+namespace osu.Game.Screens.Tournament
+{
+    public class GroupContainer : Container
+    {
+        private List<Group> groups = new List<Group>();
+
+        private int maxTeams;
+        private int currentGroup;
+
+        public GroupContainer(int numGroups, int teamsPerGroup)
+        {
+            FlowContainer<Group> bottomGroups;
+            FlowContainer<Group> topGroups;
+
+            maxTeams = teamsPerGroup;
+
+            char nextGroupName = 'A';
+
+            Children = new[]
+            {
+                topGroups = new FillFlowContainer<Group>
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
+
+                    AutoSizeAxes = Axes.Both,
+
+                    Spacing = new Vector2(7f, 0)
+                },
+                bottomGroups = new FillFlowContainer<Group>
+                {
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.BottomCentre,
+
+                    AutoSizeAxes = Axes.Both,
+
+                    Spacing = new Vector2(7f, 0)
+                }
+            };
+
+            for (int i = 0; i < numGroups; i++)
+            {
+                Group g = new Group(nextGroupName.ToString());
+
+                groups.Add(g);
+                nextGroupName++;
+
+                if (i < (int)Math.Ceiling(numGroups / 2f))
+                    topGroups.Add(g);
+                else
+                    bottomGroups.Add(g);
+            }
+        }
+
+        public void AddTeam(Country team)
+        {
+            if (groups[currentGroup].TeamsCount == maxTeams)
+                return;
+
+            groups[currentGroup].AddTeam(team);
+
+            currentGroup = (currentGroup + 1) % groups.Count;
+        }
+
+        public bool ContainsTeam(string fullName)
+        {
+            return groups.Any(g => g.ContainsTeam(fullName));
+        }
+
+        public void ClearTeams()
+        {
+            foreach (Group g in groups)
+                g.ClearTeams();
+
+            currentGroup = 0;
+        }
+
+        public string GetStringRepresentation()
+        {
+            StringBuilder sb = new StringBuilder();
+
+            foreach (Group g in groups)
+            {
+                if (g != groups.First())
+                    sb.AppendLine();
+                sb.AppendLine($"Group {g.GroupName}");
+                sb.Append(g.GetStringRepresentation());
+            }
+
+            return sb.ToString();
+        }
+    }
+}

osu.Game/Screens/Tournament/ScrollingTeamContainer.cs

@@ -0,0 +1,386 @@
+// 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 System.Diagnostics;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Graphics.Transforms;
+using osu.Framework.Threading;
+using OpenTK;
+using OpenTK.Graphics;
+using osu.Game.Users;
+
+namespace osu.Game.Screens.Tournament
+{
+    public class ScrollingTeamContainer : Container
+    {
+        public event Action OnScrollStarted;
+        public event Action<Country> OnSelected;
+
+        private readonly List<Country> availableTeams = new List<Country>();
+
+        private Container tracker;
+
+        private float speed;
+        private int expiredCount;
+
+        private float offset;
+        private float timeOffset;
+        private float leftPos => offset + timeOffset + expiredCount * ScrollingTeam.WIDTH;
+
+        private double lastTime;
+
+        private ScheduledDelegate delayedStateChangeDelegate;
+
+        public ScrollingTeamContainer()
+        {
+            AutoSizeAxes = Axes.Y;
+
+            Children = new Drawable[]
+            {
+                tracker = new Container
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+
+                    AutoSizeAxes = Axes.Both,
+
+                    Masking = true,
+                    CornerRadius = 10f,
+                    Alpha = 0,
+
+                    Children = new[]
+                    {
+                        new Box
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.BottomCentre,
+                            Size = new Vector2(2, 55),
+
+                            ColourInfo = ColourInfo.GradientVertical(Color4.Transparent, Color4.White)
+                        },
+                        new Box
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.TopCentre,
+                            Size = new Vector2(2, 55),
+
+                            ColourInfo = ColourInfo.GradientVertical(Color4.White, Color4.Transparent)
+                        }
+                    }
+                }
+            };
+        }
+
+        private ScrollState _scrollState;
+        private ScrollState scrollState
+        {
+            get { return _scrollState; }
+            set
+            {
+                if (_scrollState == value)
+                    return;
+
+                _scrollState = value;
+
+                delayedStateChangeDelegate?.Cancel();
+
+                switch (value)
+                {
+                    case ScrollState.Scrolling:
+                        resetSelected();
+
+                        OnScrollStarted?.Invoke();
+
+                        speedTo(1000f, 200);
+                        tracker.FadeOut(100);
+                        break;
+                    case ScrollState.Stopping:
+                        speedTo(0f, 2000);
+                        tracker.FadeIn(200);
+
+                        delayedStateChangeDelegate = Delay(2300).Schedule(() => scrollState = ScrollState.Stopped);
+                        break;
+                    case ScrollState.Stopped:
+                        // Find closest to center
+                        if (!Children.Any())
+                            break;
+
+                        Drawable closest = null;
+
+                        foreach (var c in Children)
+                        {
+                            if (!(c is ScrollingTeam))
+                                continue;
+
+                            if (closest == null)
+                            {
+                                closest = c;
+                                continue;
+                            }
+
+                            float o = Math.Abs(c.Position.X + c.DrawWidth / 2f - DrawWidth / 2f);
+                            float lastOffset = Math.Abs(closest.Position.X + closest.DrawWidth / 2f - DrawWidth / 2f);
+
+                            if (o < lastOffset)
+                                closest = c;
+                        }
+
+                        Trace.Assert(closest != null, "closest != null");
+
+                        offset += DrawWidth / 2f - (closest.Position.X + closest.DrawWidth / 2f);
+
+                        ScrollingTeam st = closest as ScrollingTeam;
+
+                        availableTeams.RemoveAll(at => at == st.Team);
+
+                        st.Selected = true;
+                        OnSelected?.Invoke(st.Team);
+
+                        delayedStateChangeDelegate = Delay(10000).Schedule(() => scrollState = ScrollState.Idle);
+                        break;
+                    case ScrollState.Idle:
+                        resetSelected();
+
+                        OnScrollStarted?.Invoke();
+
+                        speedTo(40f, 200);
+                        tracker.FadeOut(100);
+                        break;
+                }
+            }
+        }
+
+        public void AddTeam(Country team)
+        {
+            if (availableTeams.Contains(team))
+                return;
+
+            availableTeams.Add(team);
+
+            RemoveAll(c => c is ScrollingTeam);
+            scrollState = ScrollState.Idle;
+        }
+
+        public void AddTeams(IEnumerable<Country> teams)
+        {
+            if (teams == null)
+                return;
+
+            foreach (Country t in teams)
+                AddTeam(t);
+        }
+
+        public void ClearTeams()
+        {
+            availableTeams.Clear();
+            RemoveAll(c => c is ScrollingTeam);
+            scrollState = ScrollState.Idle;
+        }
+
+        public void RemoveTeam(Country team)
+        {
+            availableTeams.Remove(team);
+
+            foreach (var c in Children)
+            {
+                ScrollingTeam st = c as ScrollingTeam;
+
+                if (st == null)
+                    continue;
+
+                if (st.Team == team)
+                {
+                    st.FadeOut(200);
+                    st.Expire();
+                }
+            }
+        }
+
+        public void StartScrolling()
+        {
+            if (availableTeams.Count == 0)
+                return;
+
+            scrollState = ScrollState.Scrolling;
+        }
+
+        public void StopScrolling()
+        {
+            if (availableTeams.Count == 0)
+                return;
+
+            switch (scrollState)
+            {
+                case ScrollState.Stopped:
+                case ScrollState.Idle:
+                    return;
+            }
+
+            scrollState = ScrollState.Stopping;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            scrollState = ScrollState.Idle;
+        }
+
+        protected override void UpdateAfterChildren()
+        {
+            timeOffset -= (float)(Time.Current - lastTime) / 1000 * speed;
+            lastTime = Time.Current;
+
+            if (availableTeams.Count > 0)
+            {
+                // Fill more than required to account for transformation + scrolling speed
+                while (Children.Count(c => c is ScrollingTeam) < DrawWidth * 2 / ScrollingTeam.WIDTH)
+                    addFlags();
+            }
+
+            float pos = leftPos;
+
+            foreach (var c in Children)
+            {
+                if (!(c is ScrollingTeam))
+                    continue;
+
+                if (c.Position.X + c.DrawWidth < 0)
+                {
+                    c.ClearTransforms();
+                    c.Expire();
+                    expiredCount++;
+                }
+                else
+                {
+                    c.MoveToX(pos, 100);
+                    c.FadeTo(1.0f - Math.Abs(pos - DrawWidth / 2f) / (DrawWidth / 2.5f), 100);
+                }
+
+                pos += ScrollingTeam.WIDTH;
+            }
+        }
+
+        private void addFlags()
+        {
+            foreach (Country t in availableTeams)
+            {
+                Add(new ScrollingTeam(t)
+                {
+                    X = leftPos + DrawWidth
+                });
+            }
+        }
+
+        private void resetSelected()
+        {
+            foreach (var c in Children)
+            {
+                ScrollingTeam st = c as ScrollingTeam;
+                if (st == null)
+                    continue;
+
+                if (st.Selected)
+                {
+                    st.Selected = false;
+                    RemoveTeam(st.Team);
+                }
+            }
+        }
+
+        private void speedTo(float value, double duration = 0, EasingTypes easing = EasingTypes.None)
+        {
+            DelayReset();
+
+            UpdateTransformsOfType(typeof(TransformScrollSpeed));
+            TransformFloatTo(speed, value, duration, easing, new TransformScrollSpeed());
+        }
+
+        private enum ScrollState
+        {
+            None,
+            Idle,
+            Stopping,
+            Stopped,
+            Scrolling
+        }
+
+        public class TransformScrollSpeed : TransformFloat
+        {
+            public override void Apply(Drawable d)
+            {
+                base.Apply(d);
+                ((ScrollingTeamContainer)d).speed = CurrentValue;
+            }
+        }
+
+        public class ScrollingTeam : Container
+        {
+            public const float WIDTH = 58;
+            public const float HEIGHT = 41;
+
+            public Country Team;
+
+            private Sprite flagSprite;
+            private Box outline;
+
+            private bool selected;
+            public bool Selected
+            {
+                get { return selected; }
+                set
+                {
+                    selected = value;
+
+                    if (selected)
+                        outline.FadeIn(100);
+                    else
+                        outline.FadeOut(100);
+                }
+            }
+
+            public ScrollingTeam(Country team)
+            {
+                Team = team;
+
+                Anchor = Anchor.CentreLeft;
+                Origin = Anchor.CentreLeft;
+
+                Size = new Vector2(WIDTH, HEIGHT);
+                Masking = true;
+                CornerRadius = 8f;
+
+                Alpha = 0;
+
+                Children = new Drawable[]
+                {
+                    outline = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Alpha = 0
+                    },
+                    flagSprite = new Sprite
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+
+                        Size = new Vector2(WIDTH, HEIGHT) - new Vector2(8)
+                    }
+                };
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(TextureStore textures)
+            {
+                flagSprite.Texture = textures.Get($@"Flags/{Team.FlagName}");
+            }
+        }
+    }
+}

osu.Game/Screens/Tournament/Teams/ITeamList.cs

@@ -0,0 +1,13 @@
+// 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.Collections.Generic;
+using osu.Game.Users;
+
+namespace osu.Game.Screens.Tournament.Teams
+{
+    public interface ITeamList
+    {
+        IEnumerable<Country> Teams { get; }
+    }
+}

osu.Game/Screens/Tournament/Teams/StorageBackedTeamList.cs

@@ -0,0 +1,74 @@
+// 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 System.IO;
+using osu.Framework.Logging;
+using osu.Framework.Platform;
+using osu.Game.Users;
+
+namespace osu.Game.Screens.Tournament.Teams
+{
+    public class StorageBackedTeamList : ITeamList
+    {
+        private const string teams_filename = "drawings.txt";
+
+        private Storage storage;
+
+        public StorageBackedTeamList(Storage storage)
+        {
+            this.storage = storage;
+        }
+
+        public IEnumerable<Country> Teams
+        {
+            get
+            {
+                var teams = new List<Country>();
+
+                try
+                {
+                    using (Stream stream = storage.GetStream(teams_filename, FileAccess.Read, FileMode.Open))
+                    using (StreamReader sr = new StreamReader(stream))
+                    {
+                        while (sr.Peek() != -1)
+                        {
+                            string line = sr.ReadLine()?.Trim();
+
+                            if (string.IsNullOrEmpty(line))
+                                continue;
+
+                            string[] split = line.Split(':');
+
+                            if (split.Length < 2)
+                            {
+                                Logger.Log($"Invalid team definition: {line}. Expected \"flag_name : team_name : team_acronym\".");
+                                continue;
+                            }
+
+                            string flagName = split[0].Trim();
+                            string teamName = split[1].Trim();
+
+                            string acronym = split.Length >= 3 ? split[2].Trim() : teamName;
+                            acronym = acronym.Substring(0, Math.Min(3, acronym.Length));
+
+                            teams.Add(new Country
+                            {
+                                FlagName = flagName,
+                                FullName = teamName,
+                                Acronym = acronym
+                            });
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Logger.Error(ex, "Failed to read teams.");
+                }
+
+                return teams;
+            }
+        }
+    }
+}