Merge branch 'master' into url-parsing-support

osu-framework

@@ -1 +1 @@
-Subproject commit 8480ab5009b2b4a7810a817a12433959424d5339
+Subproject commit 5da6990a8e68dea852495950996e1362a293dbd5

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

@@ -9,6 +9,7 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Osu.Judgements;
+using osu.Framework.Graphics.Primitives;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -165,6 +166,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         }
 
         public Drawable ProxiedLayer => initialCircle.ApproachCircle;
+
+        public override Vector2 SelectionPoint => ToScreenSpace(body.Position);
+        public override Quad SelectionQuad => body.PathDrawQuad;
     }
 
     internal interface ISliderProgress

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

@@ -14,6 +14,7 @@ using osu.Game.Configuration;
 using OpenTK;
 using OpenTK.Graphics.ES30;
 using OpenTK.Graphics;
+using osu.Framework.Graphics.Primitives;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
@@ -49,6 +50,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             }
         }
 
+        public Quad PathDrawQuad => container.ScreenSpaceDrawQuad;
+
         private int textureWidth => (int)PathWidth * 2;
 
         private readonly Slider slider;
@@ -182,4 +185,4 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             SetRange(start, end);
         }
     }
-}
+}

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -5,7 +5,6 @@ using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.OsuDifficulty;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.UI;
@@ -18,6 +17,8 @@ using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Osu.Edit;
 using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Osu
 {
@@ -33,21 +34,35 @@ namespace osu.Game.Rulesets.Osu
             new KeyBinding(InputKey.MouseRight, OsuAction.RightButton),
         };
 
-        public override IEnumerable<BeatmapStatistic> GetBeatmapStatistics(WorkingBeatmap beatmap) => new[]
+        public override IEnumerable<BeatmapStatistic> GetBeatmapStatistics(WorkingBeatmap beatmap)
         {
-            new BeatmapStatistic
+            IEnumerable<HitObject> hitObjects = beatmap.Beatmap.HitObjects;
+            IEnumerable<HitObject> circles = hitObjects.Where(c => !(c is IHasEndTime));
+            IEnumerable<HitObject> sliders = hitObjects.Where(s => s is IHasCurve);
+            IEnumerable<HitObject> spinners = hitObjects.Where(s => s is IHasEndTime && !(s is IHasCurve));
+
+            return new[]
             {
-                Name = @"Circle count",
+                new BeatmapStatistic
-                Content = beatmap.Beatmap.HitObjects.Count(h => h is HitCircle).ToString(),
+                {
-                Icon = FontAwesome.fa_dot_circle_o
+                    Name = @"Circle Count",
-            },
+                    Content = circles.Count().ToString(),
-            new BeatmapStatistic
+                    Icon = FontAwesome.fa_circle_o
-            {
+                },
-                Name = @"Slider count",
+                new BeatmapStatistic
-                Content = beatmap.Beatmap.HitObjects.Count(h => h is Slider).ToString(),
+                {
-                Icon = FontAwesome.fa_circle_o
+                    Name = @"Slider Count",
-            }
+                    Content = sliders.Count().ToString(),
-        };
+                    Icon = FontAwesome.fa_circle
+                },
+                new BeatmapStatistic
+                {
+                    Name = @"Spinner Count",
+                    Content = spinners.Count().ToString(),
+                    Icon = FontAwesome.fa_circle
+                }
+            };
+        }
 
         public override IEnumerable<Mod> GetModsFor(ModType type)
         {

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

@@ -31,6 +31,9 @@ namespace osu.Game.Rulesets.Osu.UI
         {
             get
             {
+                if (Parent == null)
+                    return Vector2.Zero;
+
                 var parentSize = Parent.DrawSize;
                 var aspectSize = parentSize.X * 0.75f < parentSize.Y ? new Vector2(parentSize.X, parentSize.X * 0.75f) : new Vector2(parentSize.Y * 4f / 3f, parentSize.Y);
 

osu.Game.Tests/Visual/TestCaseBeatmapCarousel.cs

@@ -0,0 +1,342 @@
+// 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.Text;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Screens.Select;
+using osu.Game.Screens.Select.Carousel;
+using osu.Game.Screens.Select.Filter;
+
+namespace osu.Game.Tests.Visual
+{
+    internal class TestCaseBeatmapCarousel : OsuTestCase
+    {
+        private TestBeatmapCarousel carousel;
+
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(CarouselItem),
+            typeof(CarouselGroup),
+            typeof(CarouselGroupEagerSelect),
+            typeof(CarouselBeatmap),
+            typeof(CarouselBeatmapSet),
+
+            typeof(DrawableCarouselItem),
+            typeof(CarouselItemState),
+
+            typeof(DrawableCarouselBeatmap),
+            typeof(DrawableCarouselBeatmapSet),
+        };
+
+
+        private readonly Stack<BeatmapSetInfo> selectedSets = new Stack<BeatmapSetInfo>();
+
+        private BeatmapInfo currentSelection;
+
+        private const int set_count = 5;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Add(carousel = new TestBeatmapCarousel
+            {
+                RelativeSizeAxes = Axes.Both,
+            });
+
+            List<BeatmapSetInfo> beatmapSets = new List<BeatmapSetInfo>();
+
+            for (int i = 1; i <= set_count; i++)
+                beatmapSets.Add(createTestBeatmapSet(i));
+
+            carousel.SelectionChanged = s => currentSelection = s;
+
+            AddStep("Load Beatmaps", () => { carousel.BeatmapSets = beatmapSets; });
+
+            AddUntilStep(() => carousel.BeatmapSets.Any(), "Wait for load");
+
+            testTraversal();
+            testFiltering();
+            testRandom();
+            testAddRemove();
+            testSorting();
+
+            testRemoveAll();
+        }
+
+        private void ensureRandomFetchSuccess() =>
+            AddAssert("ensure prev random fetch worked", () => selectedSets.Peek() == carousel.SelectedBeatmapSet);
+
+        private void checkSelected(int set, int? diff = null) =>
+            AddAssert($"selected is set{set}{(diff.HasValue ? $" diff{diff.Value}" : "")}", () =>
+            {
+                if (diff != null)
+                    return carousel.SelectedBeatmap == carousel.BeatmapSets.Skip(set - 1).First().Beatmaps.Skip(diff.Value - 1).First();
+
+                return carousel.BeatmapSets.Skip(set - 1).First().Beatmaps.Contains(carousel.SelectedBeatmap);
+            });
+
+        private void setSelected(int set, int diff) =>
+            AddStep($"select set{set} diff{diff}", () =>
+                carousel.SelectBeatmap(carousel.BeatmapSets.Skip(set - 1).First().Beatmaps.Skip(diff - 1).First()));
+
+        private void advanceSelection(bool diff, int direction = 1, int count = 1)
+        {
+            if (count == 1)
+                AddStep($"select {(direction > 0 ? "next" : "prev")} {(diff ? "diff" : "set")}", () =>
+                    carousel.SelectNext(direction, !diff));
+            else
+            {
+                AddRepeatStep($"select {(direction > 0 ? "next" : "prev")} {(diff ? "diff" : "set")}", () =>
+                    carousel.SelectNext(direction, !diff), count);
+            }
+        }
+
+        private void checkVisibleItemCount(bool diff, int count) =>
+            AddAssert($"{count} {(diff ? "diffs" : "sets")} visible", () =>
+                carousel.Items.Count(s => (diff ? s.Item is CarouselBeatmap : s.Item is CarouselBeatmapSet) && s.Item.Visible) == count);
+
+        private void nextRandom() =>
+            AddStep("select random next", () =>
+            {
+                carousel.RandomAlgorithm.Value = RandomSelectAlgorithm.RandomPermutation;
+
+                if (!selectedSets.Any() && carousel.SelectedBeatmap != null)
+                    selectedSets.Push(carousel.SelectedBeatmapSet);
+
+                carousel.SelectNextRandom();
+                selectedSets.Push(carousel.SelectedBeatmapSet);
+            });
+
+        private void ensureRandomDidntRepeat() =>
+            AddAssert("ensure no repeats", () => selectedSets.Distinct().Count() == selectedSets.Count);
+
+        private void prevRandom() => AddStep("select random last", () =>
+        {
+            carousel.SelectPreviousRandom();
+            selectedSets.Pop();
+        });
+
+        /// <summary>
+        /// Test keyboard traversal
+        /// </summary>
+        private void testTraversal()
+        {
+            advanceSelection(direction: 1, diff: false);
+            checkSelected(1, 1);
+
+            advanceSelection(direction: 1, diff: true);
+            checkSelected(1, 2);
+
+            advanceSelection(direction: -1, diff: false);
+            checkSelected(set_count, 1);
+
+            advanceSelection(direction: -1, diff: true);
+            checkSelected(set_count - 1, 3);
+
+            advanceSelection(diff: false);
+            advanceSelection(diff: false);
+            checkSelected(1, 2);
+
+            advanceSelection(direction: -1, diff: true);
+            advanceSelection(direction: -1, diff: true);
+            checkSelected(set_count, 3);
+        }
+
+        /// <summary>
+        /// Test filtering
+        /// </summary>
+        private void testFiltering()
+        {
+            // basic filtering
+
+            setSelected(1, 1);
+
+            AddStep("Filter", () => carousel.Filter(new FilterCriteria { SearchText = "set #3!" }, false));
+            checkVisibleItemCount(diff: false, count: 1);
+            checkVisibleItemCount(diff: true, count: 3);
+            checkSelected(3, 1);
+
+            advanceSelection(diff: true, count: 4);
+            checkSelected(3, 2);
+
+            AddStep("Un-filter (debounce)", () => carousel.Filter(new FilterCriteria()));
+            AddUntilStep(() => !carousel.PendingFilterTask, "Wait for debounce");
+            checkVisibleItemCount(diff: false, count: set_count);
+            checkVisibleItemCount(diff: true, count: 3);
+
+            // test filtering some difficulties (and keeping current beatmap set selected).
+
+            setSelected(1, 2);
+            AddStep("Filter some difficulties", () => carousel.Filter(new FilterCriteria { SearchText = "Normal" }, false));
+            checkSelected(1, 1);
+
+            AddStep("Un-filter", () => carousel.Filter(new FilterCriteria(), false));
+            checkSelected(1, 1);
+
+            AddStep("Filter all", () => carousel.Filter(new FilterCriteria { SearchText = "Dingo" }, false));
+
+            checkVisibleItemCount(false, 0);
+            checkVisibleItemCount(true, 0);
+            AddAssert("Selection is null", () => currentSelection == null);
+
+            AddStep("Un-filter", () => carousel.Filter(new FilterCriteria(), false));
+
+            AddAssert("Selection is non-null", () => currentSelection != null);
+        }
+
+        /// <summary>
+        /// Test random non-repeating algorithm
+        /// </summary>
+        private void testRandom()
+        {
+            setSelected(1, 1);
+
+            nextRandom();
+            ensureRandomDidntRepeat();
+            nextRandom();
+            ensureRandomDidntRepeat();
+            nextRandom();
+            ensureRandomDidntRepeat();
+
+            prevRandom();
+            ensureRandomFetchSuccess();
+            prevRandom();
+            ensureRandomFetchSuccess();
+
+            nextRandom();
+            ensureRandomDidntRepeat();
+            nextRandom();
+            ensureRandomDidntRepeat();
+
+            nextRandom();
+            AddAssert("ensure repeat", () => selectedSets.Contains(carousel.SelectedBeatmapSet));
+        }
+
+        /// <summary>
+        /// Test adding and removing beatmap sets
+        /// </summary>
+        private void testAddRemove()
+        {
+            AddStep("Add new set", () => carousel.UpdateBeatmapSet(createTestBeatmapSet(set_count + 1)));
+            AddStep("Add new set", () => carousel.UpdateBeatmapSet(createTestBeatmapSet(set_count + 2)));
+
+            checkVisibleItemCount(false, set_count + 2);
+
+            AddStep("Remove set", () => carousel.RemoveBeatmapSet(createTestBeatmapSet(set_count + 2)));
+
+            checkVisibleItemCount(false, set_count + 1);
+
+            setSelected(set_count + 1, 1);
+
+            AddStep("Remove set", () => carousel.RemoveBeatmapSet(createTestBeatmapSet(set_count + 1)));
+
+            checkVisibleItemCount(false, set_count);
+
+            checkSelected(set_count);
+        }
+
+        /// <summary>
+        /// Test sorting
+        /// </summary>
+        private void testSorting()
+        {
+            AddStep("Sort by author", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Author }, false));
+            AddAssert("Check zzzzz is at bottom", () => carousel.BeatmapSets.Last().Metadata.AuthorString == "zzzzz");
+            AddStep("Sort by artist", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Artist }, false));
+            AddAssert($"Check #{set_count} is at bottom", () => carousel.BeatmapSets.Last().Metadata.Title.EndsWith($"#{set_count}!"));
+        }
+
+        private void testRemoveAll()
+        {
+            setSelected(2, 1);
+            AddAssert("Selection is non-null", () => currentSelection != null);
+
+            AddStep("Remove selected", () => carousel.RemoveBeatmapSet(carousel.SelectedBeatmapSet));
+            checkSelected(2);
+
+            AddStep("Remove first", () => carousel.RemoveBeatmapSet(carousel.BeatmapSets.First()));
+            AddStep("Remove first", () => carousel.RemoveBeatmapSet(carousel.BeatmapSets.First()));
+            checkSelected(1);
+
+            AddUntilStep(() =>
+            {
+                if (!carousel.BeatmapSets.Any()) return true;
+
+                carousel.RemoveBeatmapSet(carousel.BeatmapSets.Last());
+                return false;
+            }, "Remove all");
+
+            AddAssert("Selection is null", () => currentSelection == null);
+        }
+
+
+        private BeatmapSetInfo createTestBeatmapSet(int i)
+        {
+            return new BeatmapSetInfo
+            {
+                ID = i,
+                OnlineBeatmapSetID = i,
+                Hash = new MemoryStream(Encoding.UTF8.GetBytes(Guid.NewGuid().ToString())).ComputeMD5Hash(),
+                Metadata = new BeatmapMetadata
+                {
+                    OnlineBeatmapSetID = i,
+                    // Create random metadata, then we can check if sorting works based on these
+                    Artist = $"peppy{i.ToString().PadLeft(6, '0')}",
+                    Title = $"test set #{i}!",
+                    AuthorString = string.Concat(Enumerable.Repeat((char)('z' - Math.Min(25, i - 1)), 5))
+                },
+                Beatmaps = new List<BeatmapInfo>(new[]
+                {
+                    new BeatmapInfo
+                    {
+                        OnlineBeatmapID = i * 10,
+                        Path = "normal.osu",
+                        Version = "Normal",
+                        StarDifficulty = 2,
+                        BaseDifficulty = new BeatmapDifficulty
+                        {
+                            OverallDifficulty = 3.5f,
+                        }
+                    },
+                    new BeatmapInfo
+                    {
+                        OnlineBeatmapID = i * 10 + 1,
+                        Path = "hard.osu",
+                        Version = "Hard",
+                        StarDifficulty = 5,
+                        BaseDifficulty = new BeatmapDifficulty
+                        {
+                            OverallDifficulty = 5,
+                        }
+                    },
+                    new BeatmapInfo
+                    {
+                        OnlineBeatmapID = i * 10 + 2,
+                        Path = "insane.osu",
+                        Version = "Insane",
+                        StarDifficulty = 6,
+                        BaseDifficulty = new BeatmapDifficulty
+                        {
+                            OverallDifficulty = 7,
+                        }
+                    },
+                }),
+            };
+        }
+
+        private class TestBeatmapCarousel : BeatmapCarousel
+        {
+            public new List<DrawableCarouselItem> Items => base.Items;
+
+            public bool PendingFilterTask => FilterTask != null;
+        }
+    }
+}

osu.Game.Tests/Visual/TestCaseBeatmapInfoWedge.cs

@@ -0,0 +1,69 @@
+// 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 osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+using osu.Game.Screens.Select;
+
+namespace osu.Game.Tests.Visual
+{
+    internal class TestCaseBeatmapInfoWedge : OsuTestCase
+    {
+        private BeatmapManager beatmaps;
+        private readonly Random random;
+        private readonly BeatmapInfoWedge infoWedge;
+        private readonly Bindable<WorkingBeatmap> beatmap = new Bindable<WorkingBeatmap>();
+
+        public TestCaseBeatmapInfoWedge()
+        {
+            random = new Random(0123);
+
+            Add(infoWedge = new BeatmapInfoWedge
+            {
+                Size = new Vector2(0.5f, 245),
+                RelativeSizeAxes = Axes.X,
+                Margin = new MarginPadding
+                {
+                    Top = 20,
+                },
+            });
+
+            AddStep("show", () =>
+            {
+                Content.FadeInFromZero(250);
+                infoWedge.State = Visibility.Visible;
+                infoWedge.UpdateBeatmap(beatmap);
+            });
+            AddStep("hide", () =>
+            {
+                infoWedge.State = Visibility.Hidden;
+                Content.FadeOut(100);
+            });
+            AddStep("random beatmap", randomBeatmap);
+            AddStep("null beatmap", () => infoWedge.UpdateBeatmap(beatmap.Default));
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuGameBase game, BeatmapManager beatmaps)
+        {
+            this.beatmaps = beatmaps;
+            beatmap.BindTo(game.Beatmap);
+        }
+
+        private void randomBeatmap()
+        {
+            var sets = beatmaps.GetAllUsableBeatmapSets();
+            if (sets.Count == 0)
+                return;
+
+            var b = sets[random.Next(0, sets.Count)].Beatmaps[0];
+            beatmap.Value = beatmaps.GetWorkingBeatmap(b);
+            infoWedge.UpdateBeatmap(beatmap);
+        }
+    }
+}

osu.Game.Tests/Visual/TestCaseEditorSelectionLayer.cs

@@ -0,0 +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 System;
+using System.Collections.Generic;
+using OpenTK;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Timing;
+using osu.Game.Rulesets.Edit.Layers.Selection;
+using osu.Game.Rulesets.Osu.Edit;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+
+namespace osu.Game.Tests.Visual
+{
+    public class TestCaseEditorSelectionLayer : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(SelectionLayer) };
+
+        public TestCaseEditorSelectionLayer()
+        {
+            var playfield = new OsuEditPlayfield
+            {
+                new DrawableHitCircle(new HitCircle { Position = new Vector2(256, 192), Scale = 0.5f }),
+                new DrawableHitCircle(new HitCircle { Position = new Vector2(344, 148), Scale = 0.5f }),
+                new DrawableSlider(new Slider
+                {
+                    ControlPoints = new List<Vector2>
+                    {
+                        new Vector2(128, 256),
+                        new Vector2(344, 256),
+                    },
+                    Distance = 400,
+                    Position = new Vector2(128, 256),
+                    Velocity = 1,
+                    TickDistance = 100,
+                    Scale = 0.5f
+                })
+            };
+
+            Children = new Drawable[]
+            {
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Clock = new FramedClock(new StopwatchClock()),
+                    Child = playfield
+                },
+                new SelectionLayer(playfield)
+            };
+        }
+    }
+}

osu.Game.Tests/Visual/TestCaseGameplayMenuOverlay.cs

@@ -0,0 +1,258 @@
+// 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.ComponentModel;
+using System.Linq;
+using OpenTK.Input;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Input;
+using osu.Framework.Logging;
+using osu.Game.Screens.Play;
+
+namespace osu.Game.Tests.Visual
+{
+    [Description("player pause/fail screens")]
+    internal class TestCaseGameplayMenuOverlay : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(FailOverlay), typeof(PauseContainer) };
+
+        private FailOverlay failOverlay;
+        private PauseContainer.PauseOverlay pauseOverlay;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Add(pauseOverlay = new PauseContainer.PauseOverlay
+            {
+                OnResume = () => Logger.Log(@"Resume"),
+                OnRetry = () => Logger.Log(@"Retry"),
+                OnQuit = () => Logger.Log(@"Quit"),
+            });
+
+            Add(failOverlay = new FailOverlay
+            {
+                OnRetry = () => Logger.Log(@"Retry"),
+                OnQuit = () => Logger.Log(@"Quit"),
+            });
+
+            var retryCount = 0;
+
+            AddStep("Add retry", () =>
+            {
+                retryCount++;
+                pauseOverlay.Retries = failOverlay.Retries = retryCount;
+            });
+
+            AddToggleStep("Toggle pause overlay", t => pauseOverlay.ToggleVisibility());
+            AddToggleStep("Toggle fail overlay", t => failOverlay.ToggleVisibility());
+
+            testHideResets();
+
+            testEnterWithoutSelection();
+            testKeyUpFromInitial();
+            testKeyDownFromInitial();
+            testKeyUpWrapping();
+            testKeyDownWrapping();
+
+            testMouseSelectionAfterKeySelection();
+            testKeySelectionAfterMouseSelection();
+
+            testMouseDeselectionResets();
+
+            testClickSelection();
+            testEnterKeySelection();
+        }
+
+        /// <summary>
+        /// Test that hiding the overlay after hovering a button will reset the overlay to the initial state with no buttons selected.
+        /// </summary>
+        private void testHideResets()
+        {
+            AddStep("Show overlay", () => failOverlay.Show());
+
+            AddStep("Hover first button", () => failOverlay.Buttons.First().TriggerOnHover(null));
+            AddStep("Hide overlay", () => failOverlay.Hide());
+
+            AddAssert("Overlay state is reset", () => !failOverlay.Buttons.Any(b => b.Selected));
+        }
+
+        /// <summary>
+        /// Tests that pressing enter after an overlay shows doesn't trigger an event because a selection hasn't occurred.
+        /// </summary>
+        private void testEnterWithoutSelection()
+        {
+            AddStep("Show overlay", () => pauseOverlay.Show());
+
+            AddStep("Press enter", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Enter }));
+            AddAssert("Overlay still open", () => pauseOverlay.State == Visibility.Visible);
+
+            AddStep("Hide overlay", () => pauseOverlay.Hide());
+        }
+
+        /// <summary>
+        /// Tests that pressing the up arrow from the initial state selects the last button.
+        /// </summary>
+        private void testKeyUpFromInitial()
+        {
+            AddStep("Show overlay", () => pauseOverlay.Show());
+
+            AddStep("Up arrow", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Up }));
+            AddAssert("Last button selected", () => pauseOverlay.Buttons.Last().Selected);
+
+            AddStep("Hide overlay", () => pauseOverlay.Hide());
+        }
+
+        /// <summary>
+        /// Tests that pressing the down arrow from the initial state selects the first button.
+        /// </summary>
+        private void testKeyDownFromInitial()
+        {
+            AddStep("Show overlay", () => pauseOverlay.Show());
+
+            AddStep("Down arrow", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
+            AddAssert("First button selected", () => pauseOverlay.Buttons.First().Selected);
+
+            AddStep("Hide overlay", () => pauseOverlay.Hide());
+        }
+
+        /// <summary>
+        /// Tests that pressing the up arrow repeatedly causes the selected button to wrap correctly.
+        /// </summary>
+        private void testKeyUpWrapping()
+        {
+            AddStep("Show overlay", () => failOverlay.Show());
+
+            AddStep("Up arrow", () => failOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Up }));
+            AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected);
+            AddStep("Up arrow", () => failOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Up }));
+            AddAssert("First button selected", () => failOverlay.Buttons.First().Selected);
+            AddStep("Up arrow", () => failOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Up }));
+            AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected);
+
+            AddStep("Hide overlay", () => failOverlay.Hide());
+        }
+
+        /// <summary>
+        /// Tests that pressing the down arrow repeatedly causes the selected button to wrap correctly.
+        /// </summary>
+        private void testKeyDownWrapping()
+        {
+            AddStep("Show overlay", () => failOverlay.Show());
+
+            AddStep("Down arrow", () => failOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
+            AddAssert("First button selected", () => failOverlay.Buttons.First().Selected);
+            AddStep("Down arrow", () => failOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
+            AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected);
+            AddStep("Down arrow", () => failOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
+            AddAssert("First button selected", () => failOverlay.Buttons.First().Selected);
+
+            AddStep("Hide overlay", () => failOverlay.Hide());
+        }
+
+        /// <summary>
+        /// Tests that hovering a button that was previously selected with the keyboard correctly selects the new button and deselects the previous button.
+        /// </summary>
+        private void testMouseSelectionAfterKeySelection()
+        {
+            AddStep("Show overlay", () => pauseOverlay.Show());
+
+            var secondButton = pauseOverlay.Buttons.Skip(1).First();
+
+            AddStep("Down arrow", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
+            AddStep("Hover second button", () => secondButton.TriggerOnHover(null));
+            AddAssert("First button not selected", () => !pauseOverlay.Buttons.First().Selected);
+            AddAssert("Second button selected", () => secondButton.Selected);
+
+            AddStep("Hide overlay", () => pauseOverlay.Hide());
+        }
+
+        /// <summary>
+        /// Tests that pressing a key after selecting a button with a hover event correctly selects a new button and deselects the previous button.
+        /// </summary>
+        private void testKeySelectionAfterMouseSelection()
+        {
+            AddStep("Show overlay", () => pauseOverlay.Show());
+
+            var secondButton = pauseOverlay.Buttons.Skip(1).First();
+
+            AddStep("Hover second button", () => secondButton.TriggerOnHover(null));
+            AddStep("Up arrow", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Up }));
+            AddAssert("Second button not selected", () => !secondButton.Selected);
+            AddAssert("First button selected", () => pauseOverlay.Buttons.First().Selected);
+
+            AddStep("Hide overlay", () => pauseOverlay.Hide());
+        }
+
+        /// <summary>
+        /// Tests that deselecting with the mouse by losing hover will reset the overlay to the initial state.
+        /// </summary>
+        private void testMouseDeselectionResets()
+        {
+            AddStep("Show overlay", () => pauseOverlay.Show());
+
+            var secondButton = pauseOverlay.Buttons.Skip(1).First();
+
+            AddStep("Hover second button", () => secondButton.TriggerOnHover(null));
+            AddStep("Unhover second button", () => secondButton.TriggerOnHoverLost(null));
+            AddStep("Down arrow", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
+            AddAssert("First button selected", () => pauseOverlay.Buttons.First().Selected); // Initial state condition
+
+            AddStep("Hide overlay", () => pauseOverlay.Hide());
+        }
+
+        /// <summary>
+        /// Tests that clicking on a button correctly causes a click event for that button.
+        /// </summary>
+        private void testClickSelection()
+        {
+            AddStep("Show overlay", () => pauseOverlay.Show());
+
+            var retryButton = pauseOverlay.Buttons.Skip(1).First();
+
+            bool triggered = false;
+            AddStep("Click retry button", () =>
+            {
+                var lastAction = pauseOverlay.OnRetry;
+                pauseOverlay.OnRetry = () => triggered = true;
+
+                retryButton.TriggerOnClick();
+                pauseOverlay.OnRetry = lastAction;
+            });
+
+            AddAssert("Action was triggered", () => triggered);
+            AddAssert("Overlay is closed", () => pauseOverlay.State == Visibility.Hidden);
+        }
+
+        /// <summary>
+        /// Tests that pressing the enter key with a button selected correctly causes a click event for that button.
+        /// </summary>
+        private void testEnterKeySelection()
+        {
+            AddStep("Show overlay", () => pauseOverlay.Show());
+
+            AddStep("Select second button", () =>
+            {
+                pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down });
+                pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down });
+            });
+
+            var retryButton = pauseOverlay.Buttons.Skip(1).First();
+
+            bool triggered = false;
+            AddStep("Press enter", () =>
+            {
+                var lastAction = pauseOverlay.OnRetry;
+                pauseOverlay.OnRetry = () => triggered = true;
+
+                retryButton.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Enter });
+                pauseOverlay.OnRetry = lastAction;
+            });
+
+            AddAssert("Action was triggered", () => triggered);
+            AddAssert("Overlay is closed", () => pauseOverlay.State == Visibility.Hidden);
+        }
+    }
+}

osu.Game.Tests/Visual/TestCaseMenuOverlays.cs

@@ -1,57 +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 System.ComponentModel;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Logging;
-using osu.Game.Screens.Play;
-
-namespace osu.Game.Tests.Visual
-{
-    [Description("player pause/fail screens")]
-    internal class TestCaseMenuOverlays : OsuTestCase
-    {
-        public TestCaseMenuOverlays()
-        {
-            FailOverlay failOverlay;
-            PauseContainer.PauseOverlay pauseOverlay;
-
-            var retryCount = 0;
-
-            Add(pauseOverlay = new PauseContainer.PauseOverlay
-            {
-                OnResume = () => Logger.Log(@"Resume"),
-                OnRetry = () => Logger.Log(@"Retry"),
-                OnQuit = () => Logger.Log(@"Quit"),
-            });
-            Add(failOverlay = new FailOverlay
-            {
-                OnRetry = () => Logger.Log(@"Retry"),
-                OnQuit = () => Logger.Log(@"Quit"),
-            });
-
-            AddStep(@"Pause", delegate
-            {
-                if (failOverlay.State == Visibility.Visible)
-                {
-                    failOverlay.Hide();
-                }
-                pauseOverlay.Show();
-            });
-            AddStep("Fail", delegate
-            {
-                if (pauseOverlay.State == Visibility.Visible)
-                {
-                    pauseOverlay.Hide();
-                }
-                failOverlay.Show();
-            });
-            AddStep("Add Retry", delegate
-            {
-                retryCount++;
-                pauseOverlay.Retries = retryCount;
-                failOverlay.Retries = retryCount;
-            });
-        }
-    }
-}

osu.Game.Tests/Visual/TestCasePlaySongSelect.cs

@@ -13,6 +13,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Rulesets;
 using osu.Game.Screens.Select;
+using osu.Game.Screens.Select.Carousel;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Tests.Platform;
 
@@ -26,10 +27,28 @@ namespace osu.Game.Tests.Visual
 
         private DependencyContainer dependencies;
 
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(SongSelect),
+            typeof(BeatmapCarousel),
+
+            typeof(CarouselItem),
+            typeof(CarouselGroup),
+            typeof(CarouselGroupEagerSelect),
+            typeof(CarouselBeatmap),
+            typeof(CarouselBeatmapSet),
+
+            typeof(DrawableCarouselItem),
+            typeof(CarouselItemState),
+
+            typeof(DrawableCarouselBeatmap),
+            typeof(DrawableCarouselBeatmapSet),
+        };
+
         protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent) => dependencies = new DependencyContainer(parent);
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(BeatmapManager baseManager)
         {
             PlaySongSelect songSelect;
 
@@ -43,7 +62,10 @@ namespace osu.Game.Tests.Visual
                 Func<OsuDbContext> contextFactory = () => context;
 
                 dependencies.Cache(rulesets = new RulesetStore(contextFactory));
-                dependencies.Cache(manager = new BeatmapManager(storage, contextFactory, rulesets, null));
+                dependencies.Cache(manager = new BeatmapManager(storage, contextFactory, rulesets, null)
+                {
+                    DefaultBeatmap = baseManager.GetWorkingBeatmap(null)
+                });
 
                 for (int i = 0; i < 100; i += 10)
                     manager.Import(createTestBeatmapSet(i));

osu.Game.Tests/osu.Game.Tests.csproj

@@ -88,8 +88,10 @@
     <Compile Include="Beatmaps\IO\ImportBeatmapTest.cs" />
     <Compile Include="Resources\Resource.cs" />
     <Compile Include="Beatmaps\Formats\LegacyBeatmapDecoderTest.cs" />
+    <Compile Include="Visual\TestCaseBeatmapCarousel.cs" />
     <Compile Include="Visual\TestCaseBeatmapDetailArea.cs" />
     <Compile Include="Visual\TestCaseBeatmapDetails.cs" />
+    <Compile Include="Visual\TestCaseBeatmapInfoWedge.cs" />
     <Compile Include="Visual\TestCaseBeatmapOptionsOverlay.cs" />
     <Compile Include="Visual\TestCaseBeatmapScoresContainer.cs" />
     <Compile Include="Visual\TestCaseBeatmapSetOverlay.cs" />
@@ -108,6 +110,7 @@
     <Compile Include="Visual\TestCaseEditorComposeTimeline.cs" />
     <Compile Include="Visual\TestCaseEditorMenuBar.cs" />
     <Compile Include="Visual\TestCaseEditorSummaryTimeline.cs" />
+    <Compile Include="Visual\TestCaseEditorSelectionLayer.cs" />
     <Compile Include="Visual\TestCaseGamefield.cs" />
     <Compile Include="Visual\TestCaseGraph.cs" />
     <Compile Include="Visual\TestCaseHistoricalSection.cs" />
@@ -118,7 +121,7 @@
     <Compile Include="Visual\TestCaseLeaderboard.cs" />
     <Compile Include="Visual\TestCaseMedalOverlay.cs" />
     <Compile Include="Visual\TestCaseButtonSystem.cs" />
-    <Compile Include="Visual\TestCaseMenuOverlays.cs" />
+    <Compile Include="Visual\TestCaseGameplayMenuOverlay.cs" />
     <Compile Include="Visual\TestCaseMods.cs" />
     <Compile Include="Visual\TestCaseMusicController.cs" />
     <Compile Include="Visual\TestCaseNotificationOverlay.cs" />

osu.Game/Beatmaps/BeatmapInfo.cs

@@ -118,6 +118,8 @@ namespace osu.Game.Beatmaps
         [JsonProperty("difficulty_rating")]
         public double StarDifficulty { get; set; }
 
+        public override string ToString() => $"{Metadata} [{Version}]";
+
         public bool Equals(BeatmapInfo other)
         {
             if (ID == 0 || other?.ID == 0)

osu.Game/Beatmaps/BeatmapManager.cs

@@ -374,12 +374,9 @@ namespace osu.Game.Beatmaps
         /// <returns>A <see cref="WorkingBeatmap"/> instance correlating to the provided <see cref="BeatmapInfo"/>.</returns>
         public WorkingBeatmap GetWorkingBeatmap(BeatmapInfo beatmapInfo, WorkingBeatmap previous = null)
         {
-            if (beatmapInfo == null || beatmapInfo == DefaultBeatmap?.BeatmapInfo)
+            if (beatmapInfo?.BeatmapSet == null || beatmapInfo == DefaultBeatmap?.BeatmapInfo)
                 return DefaultBeatmap;
 
-            if (beatmapInfo.BeatmapSet == null)
-                throw new InvalidOperationException($@"Beatmap set {beatmapInfo.BeatmapSetInfoID} is not in the local database.");
-
             if (beatmapInfo.Metadata == null)
                 beatmapInfo.Metadata = beatmapInfo.BeatmapSet.Metadata;
 

osu.Game/Beatmaps/BeatmapMetadata.cs

@@ -57,6 +57,8 @@ namespace osu.Game.Beatmaps
         public string AudioFile { get; set; }
         public string BackgroundFile { get; set; }
 
+        public override string ToString() => $"{Artist} - {Title} ({Author})";
+
         public string[] SearchableTerms => new[]
         {
             Author?.Username,

osu.Game/Beatmaps/BeatmapSetInfo.cs

@@ -33,6 +33,8 @@ namespace osu.Game.Beatmaps
 
         public List<BeatmapSetFileInfo> Files { get; set; }
 
+        public override string ToString() => Metadata.ToString();
+
         public bool Protected { get; set; }
     }
 }

osu.Game/Beatmaps/Drawables/BeatmapGroup.cs

@@ -1,138 +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 System;
-using System.Collections.Generic;
-using System.Linq;
-using osu.Framework;
-using osu.Framework.Graphics;
-
-namespace osu.Game.Beatmaps.Drawables
-{
-    public class BeatmapGroup : IStateful<BeatmapGroupState>
-    {
-        public event Action<BeatmapGroupState> StateChanged;
-
-        public BeatmapPanel SelectedPanel;
-
-        /// <summary>
-        /// Fires when one of our difficulties was selected. Will fire on first expand.
-        /// </summary>
-        public Action<BeatmapGroup, BeatmapPanel> SelectionChanged;
-
-        /// <summary>
-        /// Fires when one of our difficulties is clicked when already selected. Should start playing the map.
-        /// </summary>
-        public Action<BeatmapInfo> StartRequested;
-
-        public Action<BeatmapSetInfo> DeleteRequested;
-
-        public Action<BeatmapSetInfo> RestoreHiddenRequested;
-
-        public Action<BeatmapInfo> HideDifficultyRequested;
-
-        public Action<BeatmapInfo> EditRequested;
-
-        public BeatmapSetHeader Header;
-
-        public List<BeatmapPanel> BeatmapPanels;
-
-        public BeatmapSetInfo BeatmapSet;
-
-        private BeatmapGroupState state;
-        public BeatmapGroupState State
-        {
-            get { return state; }
-            set
-            {
-                state = value;
-
-                switch (value)
-                {
-                    case BeatmapGroupState.Expanded:
-                        Header.State = PanelSelectedState.Selected;
-                        foreach (BeatmapPanel panel in BeatmapPanels)
-                            panel.State = panel == SelectedPanel ? PanelSelectedState.Selected : PanelSelectedState.NotSelected;
-                        break;
-                    case BeatmapGroupState.Collapsed:
-                        Header.State = PanelSelectedState.NotSelected;
-                        foreach (BeatmapPanel panel in BeatmapPanels)
-                            panel.State = PanelSelectedState.Hidden;
-                        break;
-                    case BeatmapGroupState.Hidden:
-                        Header.State = PanelSelectedState.Hidden;
-                        foreach (BeatmapPanel panel in BeatmapPanels)
-                            panel.State = PanelSelectedState.Hidden;
-                        break;
-                }
-
-                StateChanged?.Invoke(state);
-            }
-        }
-
-        public BeatmapGroup(BeatmapSetInfo beatmapSet, BeatmapManager manager)
-        {
-            if (beatmapSet == null)
-                throw new ArgumentNullException(nameof(beatmapSet));
-            if (manager == null)
-                throw new ArgumentNullException(nameof(manager));
-
-            BeatmapSet = beatmapSet;
-            WorkingBeatmap beatmap = manager.GetWorkingBeatmap(BeatmapSet.Beatmaps.FirstOrDefault());
-
-            Header = new BeatmapSetHeader(beatmap)
-            {
-                GainedSelection = headerGainedSelection,
-                DeleteRequested = b => DeleteRequested(b),
-                RestoreHiddenRequested = b => RestoreHiddenRequested(b),
-                RelativeSizeAxes = Axes.X,
-            };
-
-            BeatmapPanels = BeatmapSet.Beatmaps.Where(b => !b.Hidden).OrderBy(b => b.StarDifficulty).Select(b => new BeatmapPanel(b)
-            {
-                Alpha = 0,
-                GainedSelection = panelGainedSelection,
-                HideRequested = p => HideDifficultyRequested?.Invoke(p),
-                StartRequested = p => StartRequested?.Invoke(p.Beatmap),
-                EditRequested = p => EditRequested?.Invoke(p.Beatmap),
-                RelativeSizeAxes = Axes.X,
-            }).ToList();
-
-            Header.AddDifficultyIcons(BeatmapPanels);
-        }
-
-
-        private void headerGainedSelection(BeatmapSetHeader panel)
-        {
-            State = BeatmapGroupState.Expanded;
-
-            //we want to make sure one of our children is selected in the case none have been selected yet.
-            if (SelectedPanel == null)
-                BeatmapPanels.First().State = PanelSelectedState.Selected;
-        }
-
-        private void panelGainedSelection(BeatmapPanel panel)
-        {
-            try
-            {
-                if (SelectedPanel == panel) return;
-
-                if (SelectedPanel != null)
-                    SelectedPanel.State = PanelSelectedState.NotSelected;
-                SelectedPanel = panel;
-            }
-            finally
-            {
-                State = BeatmapGroupState.Expanded;
-                SelectionChanged?.Invoke(this, SelectedPanel);
-            }
-        }
-    }
-
-    public enum BeatmapGroupState
-    {
-        Collapsed,
-        Expanded,
-        Hidden,
-    }
-}

osu.Game/Configuration/OsuConfigManager.cs

@@ -20,7 +20,7 @@ namespace osu.Game.Configuration
             Set(OsuSetting.DisplayStarsMinimum, 0.0, 0, 10, 0.1);
             Set(OsuSetting.DisplayStarsMaximum, 10.0, 0, 10, 0.1);
 
-            Set(OsuSetting.SelectionRandomType, SelectionRandomType.RandomPermutation);
+            Set(OsuSetting.RandomSelectAlgorithm, RandomSelectAlgorithm.RandomPermutation);
 
             Set(OsuSetting.ChatDisplayHeight, ChatOverlay.DEFAULT_HEIGHT, 0.2, 1);
 
@@ -108,7 +108,7 @@ namespace osu.Game.Configuration
         SaveUsername,
         DisplayStarsMinimum,
         DisplayStarsMaximum,
-        SelectionRandomType,
+        RandomSelectAlgorithm,
         SnakingInSliders,
         SnakingOutSliders,
         ShowFpsDisplay,

osu.Game/Configuration/RandomSelectAlgorithm.cs

@@ -5,11 +5,11 @@ using System.ComponentModel;
 
 namespace osu.Game.Configuration
 {
-   public enum SelectionRandomType
+   public enum RandomSelectAlgorithm
     {
         [Description("Never repeat")]
         RandomPermutation,
         [Description("Random")]
         Random
     }
-}
+}

osu.Game/Graphics/SpriteIcon.cs

@@ -15,14 +15,19 @@ namespace osu.Game.Graphics
 {
     public class SpriteIcon : CompositeDrawable
     {
-        private readonly Sprite spriteShadow;
+        private Sprite spriteShadow;
-        private readonly Sprite spriteMain;
+        private Sprite spriteMain;
 
         private Cached layout = new Cached();
-        private readonly Container shadowVisibility;
+        private Container shadowVisibility;
 
-        public SpriteIcon()
+        private FontStore store;
+
+        [BackgroundDependencyLoader]
+        private void load(FontStore store)
         {
+            this.store = store;
+
             InternalChildren = new Drawable[]
             {
                 shadowVisibility = new Container
@@ -39,7 +44,7 @@ namespace osu.Game.Graphics
                         Y = 2,
                         Colour = new Color4(0f, 0f, 0f, 0.2f),
                     },
-                    Alpha = 0,
+                    Alpha = shadow ? 1 : 0,
                 },
                 spriteMain = new Sprite
                 {
@@ -49,14 +54,7 @@ namespace osu.Game.Graphics
                     FillMode = FillMode.Fit
                 },
             };
-        }
 
-        private FontStore store;
-
-        [BackgroundDependencyLoader]
-        private void load(FontStore store)
-        {
-            this.store = store;
             updateTexture();
         }
 
@@ -105,12 +103,15 @@ namespace osu.Game.Graphics
             }
         }
 
+        private bool shadow;
         public bool Shadow
         {
-            get { return spriteShadow.IsPresent; }
+            get { return shadow; }
             set
             {
-                shadowVisibility.Alpha = value ? 1 : 0;
+                shadow = value;
+                if (shadowVisibility != null)
+                    shadowVisibility.Alpha = value ? 1 : 0;
             }
         }
 

osu.Game/Graphics/UserInterface/DialogButton.cs

@@ -12,6 +12,8 @@ using osu.Game.Graphics.Backgrounds;
 using osu.Game.Graphics.Sprites;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Game.Graphics.Containers;
+using osu.Framework.Configuration;
+using osu.Framework.Input;
 
 namespace osu.Game.Graphics.UserInterface
 {
@@ -22,62 +24,7 @@ namespace osu.Game.Graphics.UserInterface
         private const float glow_fade_duration = 250;
         private const float click_duration = 200;
 
-        private Color4 buttonColour;
+        public readonly BindableBool Selected = new BindableBool();
-        public Color4 ButtonColour
-        {
-            get
-            {
-                return buttonColour;
-            }
-            set
-            {
-                buttonColour = value;
-                updateGlow();
-                colourContainer.Colour = value;
-            }
-        }
-
-        private Color4 backgroundColour = OsuColour.Gray(34);
-        public Color4 BackgroundColour
-        {
-            get
-            {
-                return backgroundColour;
-            }
-            set
-            {
-                backgroundColour = value;
-                background.Colour = value;
-            }
-        }
-
-        private string text;
-        public string Text
-        {
-            get
-            {
-                return text;
-            }
-            set
-            {
-                text = value;
-                spriteText.Text = Text;
-            }
-        }
-
-        private float textSize = 28;
-        public float TextSize
-        {
-            get
-            {
-                return textSize;
-            }
-            set
-            {
-                textSize = value;
-                spriteText.TextSize = value;
-            }
-        }
 
         private readonly Container backgroundContainer;
         private readonly Container colourContainer;
@@ -89,71 +36,6 @@ namespace osu.Game.Graphics.UserInterface
         private readonly SpriteText spriteText;
         private Vector2 hoverSpacing => new Vector2(3f, 0f);
 
-        private bool didClick; // Used for making sure that the OnMouseDown animation can call instead of OnHoverLost's when clicking
-
-        public override bool ReceiveMouseInputAt(Vector2 screenSpacePos) => backgroundContainer.ReceiveMouseInputAt(screenSpacePos);
-
-        protected override bool OnClick(Framework.Input.InputState state)
-        {
-            didClick = true;
-            colourContainer.ResizeTo(new Vector2(1.5f, 1f), click_duration, Easing.In);
-            flash();
-
-            this.Delay(click_duration).Schedule(delegate
-            {
-                colourContainer.ResizeTo(new Vector2(0.8f, 1f));
-                spriteText.Spacing = Vector2.Zero;
-                glowContainer.FadeOut();
-            });
-
-            return base.OnClick(state);
-        }
-
-        protected override bool OnHover(Framework.Input.InputState state)
-        {
-            spriteText.TransformSpacingTo(hoverSpacing, hover_duration, Easing.OutElastic);
-
-            colourContainer.ResizeTo(new Vector2(hover_width, 1f), hover_duration, Easing.OutElastic);
-            glowContainer.FadeIn(glow_fade_duration, Easing.Out);
-            base.OnHover(state);
-            return true;
-        }
-
-        protected override void OnHoverLost(Framework.Input.InputState state)
-        {
-            if (!didClick)
-            {
-                colourContainer.ResizeTo(new Vector2(0.8f, 1f), hover_duration, Easing.OutElastic);
-                spriteText.TransformSpacingTo(Vector2.Zero, hover_duration, Easing.OutElastic);
-                glowContainer.FadeOut(glow_fade_duration, Easing.Out);
-            }
-
-            didClick = false;
-        }
-
-        private void flash()
-        {
-            var flash = new Box
-            {
-                RelativeSizeAxes = Axes.Both
-            };
-
-            colourContainer.Add(flash);
-
-            flash.Colour = ButtonColour;
-            flash.Blending = BlendingMode.Additive;
-            flash.Alpha = 0.3f;
-            flash.FadeOutFromOne(click_duration);
-            flash.Expire();
-        }
-
-        private void updateGlow()
-        {
-            leftGlow.Colour = ColourInfo.GradientHorizontal(new Color4(ButtonColour.R, ButtonColour.G, ButtonColour.B, 0f), ButtonColour);
-            centerGlow.Colour = ButtonColour;
-            rightGlow.Colour = ColourInfo.GradientHorizontal(ButtonColour, new Color4(ButtonColour.R, ButtonColour.G, ButtonColour.B, 0f));
-        }
-
         public DialogButton()
         {
             RelativeSizeAxes = Axes.X;
@@ -268,6 +150,135 @@ namespace osu.Game.Graphics.UserInterface
             };
 
             updateGlow();
+
+            Selected.ValueChanged += selectionChanged;
+        }
+
+        private Color4 buttonColour;
+        public Color4 ButtonColour
+        {
+            get
+            {
+                return buttonColour;
+            }
+            set
+            {
+                buttonColour = value;
+                updateGlow();
+                colourContainer.Colour = value;
+            }
+        }
+
+        private Color4 backgroundColour = OsuColour.Gray(34);
+        public Color4 BackgroundColour
+        {
+            get
+            {
+                return backgroundColour;
+            }
+            set
+            {
+                backgroundColour = value;
+                background.Colour = value;
+            }
+        }
+
+        private string text;
+        public string Text
+        {
+            get
+            {
+                return text;
+            }
+            set
+            {
+                text = value;
+                spriteText.Text = Text;
+            }
+        }
+
+        private float textSize = 28;
+        public float TextSize
+        {
+            get
+            {
+                return textSize;
+            }
+            set
+            {
+                textSize = value;
+                spriteText.TextSize = value;
+            }
+        }
+
+        public override bool ReceiveMouseInputAt(Vector2 screenSpacePos) => backgroundContainer.ReceiveMouseInputAt(screenSpacePos);
+
+        protected override bool OnClick(InputState state)
+        {
+            colourContainer.ResizeTo(new Vector2(1.5f, 1f), click_duration, Easing.In);
+            flash();
+
+            this.Delay(click_duration).Schedule(delegate
+            {
+                colourContainer.ResizeTo(new Vector2(0.8f, 1f));
+                spriteText.Spacing = Vector2.Zero;
+                glowContainer.FadeOut();
+            });
+
+            return base.OnClick(state);
+        }
+
+        protected override bool OnHover(InputState state)
+        {
+            base.OnHover(state);
+
+            Selected.Value = true;
+            return true;
+        }
+
+        protected override void OnHoverLost(InputState state)
+        {
+            base.OnHoverLost(state);
+            Selected.Value = false;
+        }
+
+        private void selectionChanged(bool isSelected)
+        {
+            if (isSelected)
+            {
+                spriteText.TransformSpacingTo(hoverSpacing, hover_duration, Easing.OutElastic);
+                colourContainer.ResizeTo(new Vector2(hover_width, 1f), hover_duration, Easing.OutElastic);
+                glowContainer.FadeIn(glow_fade_duration, Easing.Out);
+            }
+            else
+            {
+                colourContainer.ResizeTo(new Vector2(0.8f, 1f), hover_duration, Easing.OutElastic);
+                spriteText.TransformSpacingTo(Vector2.Zero, hover_duration, Easing.OutElastic);
+                glowContainer.FadeOut(glow_fade_duration, Easing.Out);
+            }
+        }
+
+        private void flash()
+        {
+            var flash = new Box
+            {
+                RelativeSizeAxes = Axes.Both
+            };
+
+            colourContainer.Add(flash);
+
+            flash.Colour = ButtonColour;
+            flash.Blending = BlendingMode.Additive;
+            flash.Alpha = 0.3f;
+            flash.FadeOutFromOne(click_duration);
+            flash.Expire();
+        }
+
+        private void updateGlow()
+        {
+            leftGlow.Colour = ColourInfo.GradientHorizontal(new Color4(ButtonColour.R, ButtonColour.G, ButtonColour.B, 0f), ButtonColour);
+            centerGlow.Colour = ButtonColour;
+            rightGlow.Colour = ColourInfo.GradientHorizontal(ButtonColour, new Color4(ButtonColour.R, ButtonColour.G, ButtonColour.B, 0f));
         }
     }
 }

osu.Game/Graphics/UserInterface/StarCounter.cs

@@ -6,6 +6,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.MathUtils;
 using System;
+using System.Linq;
 
 namespace osu.Game.Graphics.UserInterface
 {
@@ -72,16 +73,9 @@ namespace osu.Game.Graphics.UserInterface
                     AutoSizeAxes = Axes.Both,
                     Direction = FillDirection.Horizontal,
                     Spacing = new Vector2(star_spacing),
+                    ChildrenEnumerable = Enumerable.Range(0, StarCount).Select(i => new Star { Alpha = minStarAlpha })
                 }
             };
-
-            for (int i = 0; i < StarCount; i++)
-            {
-                stars.Add(new Star
-                {
-                    Alpha = minStarAlpha,
-                });
-            }
         }
 
         protected override void LoadComplete()
@@ -147,15 +141,12 @@ namespace osu.Game.Graphics.UserInterface
             {
                 Size = new Vector2(star_size);
 
-                Children = new[]
+                Child = Icon = new SpriteIcon
                 {
-                    Icon = new SpriteIcon
+                    Size = new Vector2(star_size),
-                    {
+                    Icon = FontAwesome.fa_star,
-                        Size = new Vector2(star_size),
+                    Anchor = Anchor.Centre,
-                        Icon = FontAwesome.fa_star,
+                    Origin = Anchor.Centre,
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                    }
                 };
             }
         }

osu.Game/Overlays/Profile/ProfileHeader.cs

@@ -51,6 +51,7 @@ namespace osu.Game.Overlays.Profile
                 {
                     RelativeSizeAxes = Axes.X,
                     Height = cover_height,
+                    Masking = true,
                     Children = new Drawable[]
                     {
                         new Box
@@ -300,10 +301,7 @@ namespace osu.Game.Overlays.Profile
 
         public User User
         {
-            get
+            get { return user; }
-            {
-                return user;
-            }
 
             set
             {
@@ -322,8 +320,7 @@ namespace osu.Game.Overlays.Profile
                 FillMode = FillMode.Fill,
                 OnLoadComplete = d => d.FadeInFromZero(200),
                 Depth = float.MaxValue,
-            },
+            }, coverContainer.Add);
-            coverContainer.Add);
 
             if (user.IsSupporter) supporterTag.Show();
 
@@ -343,12 +340,14 @@ namespace osu.Game.Overlays.Profile
             {
                 infoTextLeft.AddText($"{user.Age} years old ", boldItalic);
             }
+
             if (user.Country != null)
             {
                 infoTextLeft.AddText("from ");
                 infoTextLeft.AddText(user.Country.FullName, boldItalic);
                 countryFlag.FlagName = user.Country.FlagName;
             }
+
             infoTextLeft.NewParagraph();
 
             if (user.JoinDate.ToUniversalTime().Year < 2008)
@@ -360,6 +359,7 @@ namespace osu.Game.Overlays.Profile
                 infoTextLeft.AddText("Joined ");
                 infoTextLeft.AddText(user.JoinDate.LocalDateTime.ToShortDateString(), boldItalic);
             }
+
             infoTextLeft.NewLine();
             infoTextLeft.AddText("Last seen ");
             infoTextLeft.AddText(user.LastVisit.LocalDateTime.ToShortDateString(), boldItalic);
@@ -492,17 +492,13 @@ namespace osu.Game.Overlays.Profile
 
             private readonly OsuHoverContainer content;
 
-            protected override Container<Drawable> Content => content ?? (Container<Drawable>)this;
+            protected override Container<Drawable> Content => content;
 
             public override bool HandleInput => true;
 
             public ProfileLink(User user)
             {
-                AddInternal(content = new OsuHoverContainer
+                AddInternal(content = new OsuHoverContainer { AutoSizeAxes = Axes.Both });
-                {
-                    Action = OnLinkClicked,
-                    AutoSizeAxes = Axes.Both,
-                });
 
                 Text = user.Username;
                 Url = $@"https://osu.ppy.sh/users/{user.Id}";

osu.Game/Overlays/Settings/Sections/Gameplay/SongSelectSettings.cs

@@ -34,10 +34,10 @@ namespace osu.Game.Overlays.Settings.Sections.Gameplay
                     Bindable = config.GetBindable<double>(OsuSetting.DisplayStarsMaximum),
                     KeyboardStep = 1f
                 },
-                new SettingsEnumDropdown<SelectionRandomType>
+                new SettingsEnumDropdown<RandomSelectAlgorithm>
                 {
-                    LabelText = "Random beatmap selection",
+                    LabelText = "Random selection algorithm",
-                    Bindable = config.GetBindable<SelectionRandomType>(OsuSetting.SelectionRandomType),
+                    Bindable = config.GetBindable<RandomSelectAlgorithm>(OsuSetting.RandomSelectAlgorithm),
                 }
             };
         }

osu.Game/Rulesets/Edit/HitObjectComposer.cs

@@ -12,6 +12,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Logging;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit.Layers.Selection;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.UI;
 using osu.Game.Screens.Edit.Screens.Compose.RadioButtons;
@@ -77,7 +78,8 @@ namespace osu.Game.Rulesets.Edit
                                     Alpha = 0,
                                     AlwaysPresent = true,
                                 },
-                                rulesetContainer
+                                rulesetContainer,
+                                new SelectionLayer(rulesetContainer.Playfield)
                             }
                         }
                     },

osu.Game/Rulesets/Edit/Layers/Selection/Handle.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 osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input;
+using osu.Game.Graphics;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Edit.Layers.Selection
+{
+    /// <summary>
+    /// Represents a marker visible on the border of a <see cref="HandleContainer"/> which exposes
+    /// properties that are used to resize a <see cref="HitObjectSelectionBox"/>.
+    /// </summary>
+    public class Handle : CompositeDrawable
+    {
+        private const float marker_size = 10;
+
+        /// <summary>
+        /// Invoked when this <see cref="Handle"/> requires the current drag rectangle.
+        /// </summary>
+        public Func<RectangleF> GetDragRectangle;
+
+        /// <summary>
+        /// Invoked when this <see cref="Handle"/> wants to update the drag rectangle.
+        /// </summary>
+        public Action<RectangleF> UpdateDragRectangle;
+
+        /// <summary>
+        /// Invoked when this <see cref="Handle"/> has finished updates to the drag rectangle.
+        /// </summary>
+        public Action FinishDrag;
+
+        private Color4 normalColour;
+        private Color4 hoverColour;
+
+        public Handle()
+        {
+            Size = new Vector2(marker_size);
+
+            InternalChild = new CircularContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Masking = true,
+                Child = new Box { RelativeSizeAxes = Axes.Both }
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Colour = normalColour = colours.Yellow;
+            hoverColour = colours.YellowDarker;
+        }
+
+        protected override bool OnDragStart(InputState state) => true;
+
+        protected override bool OnDrag(InputState state)
+        {
+            var currentRectangle = GetDragRectangle();
+
+            float left = currentRectangle.Left;
+            float right = currentRectangle.Right;
+            float top = currentRectangle.Top;
+            float bottom = currentRectangle.Bottom;
+
+            // Apply modifications to the capture rectangle
+            if ((Anchor & Anchor.y0) > 0)
+                top += state.Mouse.Delta.Y;
+            else if ((Anchor & Anchor.y2) > 0)
+                bottom += state.Mouse.Delta.Y;
+
+            if ((Anchor & Anchor.x0) > 0)
+                left += state.Mouse.Delta.X;
+            else if ((Anchor & Anchor.x2) > 0)
+                right += state.Mouse.Delta.X;
+
+            UpdateDragRectangle(RectangleF.FromLTRB(left, top, right, bottom));
+            return true;
+        }
+
+        protected override bool OnDragEnd(InputState state)
+        {
+            FinishDrag();
+            return true;
+        }
+
+        protected override bool OnHover(InputState state)
+        {
+            this.FadeColour(hoverColour, 100);
+            return true;
+        }
+
+        protected override void OnHoverLost(InputState state)
+        {
+            this.FadeColour(normalColour, 100);
+        }
+    }
+}

osu.Game/Rulesets/Edit/Layers/Selection/HandleContainer.cs

@@ -0,0 +1,92 @@
+// 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 osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+
+namespace osu.Game.Rulesets.Edit.Layers.Selection
+{
+    /// <summary>
+    /// A <see cref="CompositeDrawable"/> that has <see cref="Handle"/>s around its border.
+    /// </summary>
+    public class HandleContainer : CompositeDrawable
+    {
+        /// <summary>
+        /// Invoked when a <see cref="Handle"/> requires the current drag rectangle.
+        /// </summary>
+        public Func<RectangleF> GetDragRectangle;
+
+        /// <summary>
+        /// Invoked when a <see cref="Handle"/> wants to update the drag rectangle.
+        /// </summary>
+        public Action<RectangleF> UpdateDragRectangle;
+
+        /// <summary>
+        /// Invoked when a <see cref="Handle"/> has finished updates to the drag rectangle.
+        /// </summary>
+        public Action FinishDrag;
+
+        public HandleContainer()
+        {
+            InternalChildren = new Drawable[]
+            {
+                new Handle
+                {
+                    Anchor = Anchor.TopLeft,
+                    Origin = Anchor.Centre
+                },
+                new Handle
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.Centre
+                },
+                new Handle
+                {
+                    Anchor = Anchor.TopRight,
+                    Origin = Anchor.Centre
+                },
+                new Handle
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.Centre
+                },
+                new Handle
+                {
+                    Anchor = Anchor.BottomLeft,
+                    Origin = Anchor.Centre
+                },
+                new Handle
+                {
+                    Anchor = Anchor.CentreRight,
+                    Origin = Anchor.Centre
+                },
+                new Handle
+                {
+                    Anchor = Anchor.BottomRight,
+                    Origin = Anchor.Centre
+                },
+                new Handle
+                {
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.Centre
+                },
+                new OriginHandle
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre
+                }
+            };
+
+            InternalChildren.OfType<Handle>().ForEach(m =>
+            {
+                m.GetDragRectangle = () => GetDragRectangle();
+                m.UpdateDragRectangle = r => UpdateDragRectangle(r);
+                m.FinishDrag = () => FinishDrag();
+            });
+        }
+    }
+}

osu.Game/Rulesets/Edit/Layers/Selection/HitObjectSelectionBox.cs

@@ -0,0 +1,178 @@
+// 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.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Objects.Drawables;
+using OpenTK;
+using OpenTK.Graphics;
+using osu.Framework.Configuration;
+
+namespace osu.Game.Rulesets.Edit.Layers.Selection
+{
+    /// <summary>
+    /// A box that represents a drag selection.
+    /// </summary>
+    public class HitObjectSelectionBox : CompositeDrawable
+    {
+        public readonly Bindable<SelectionInfo> Selection = new Bindable<SelectionInfo>();
+
+        /// <summary>
+        /// The <see cref="DrawableHitObject"/>s that can be selected through a drag-selection.
+        /// </summary>
+        public IEnumerable<DrawableHitObject> CapturableObjects;
+
+        private readonly Container borderMask;
+        private readonly Drawable background;
+        private readonly HandleContainer handles;
+
+        private Color4 captureFinishedColour;
+
+        private readonly Vector2 startPos;
+
+        /// <summary>
+        /// Creates a new <see cref="HitObjectSelectionBox"/>.
+        /// </summary>
+        /// <param name="startPos">The point at which the drag was initiated, in the parent's coordinates.</param>
+        public HitObjectSelectionBox(Vector2 startPos)
+        {
+            this.startPos = startPos;
+
+            InternalChildren = new Drawable[]
+            {
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding(-1),
+                    Child = borderMask = new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Masking = true,
+                        BorderColour = Color4.White,
+                        BorderThickness = 2,
+                        MaskingSmoothness = 1,
+                        Child = background = new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Alpha = 0.1f,
+                            AlwaysPresent = true
+                        },
+                    }
+                },
+                handles = new HandleContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 0,
+                    GetDragRectangle = () => dragRectangle,
+                    UpdateDragRectangle = updateDragRectangle,
+                    FinishDrag = FinishCapture
+                }
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            captureFinishedColour = colours.Yellow;
+        }
+
+        /// <summary>
+        /// The secondary corner of the drag selection box. A rectangle will be fit between the starting position and this value.
+        /// </summary>
+        public Vector2 DragEndPosition { set => updateDragRectangle(RectangleF.FromLTRB(startPos.X, startPos.Y, value.X, value.Y)); }
+
+        private RectangleF dragRectangle;
+        private void updateDragRectangle(RectangleF rectangle)
+        {
+            dragRectangle = rectangle;
+
+            Position = new Vector2(
+                Math.Min(rectangle.Left, rectangle.Right),
+                Math.Min(rectangle.Top, rectangle.Bottom));
+
+            Size = new Vector2(
+                Math.Max(rectangle.Left, rectangle.Right) - Position.X,
+                Math.Max(rectangle.Top, rectangle.Bottom) - Position.Y);
+        }
+
+        private readonly List<DrawableHitObject> capturedHitObjects = new List<DrawableHitObject>();
+
+        /// <summary>
+        /// Processes hitobjects to determine which ones are captured by the drag selection.
+        /// Captured hitobjects will be enclosed by the drag selection upon <see cref="FinishCapture"/>.
+        /// </summary>
+        public void BeginCapture()
+        {
+            capturedHitObjects.Clear();
+
+            foreach (var obj in CapturableObjects)
+            {
+                if (!obj.IsAlive || !obj.IsPresent)
+                    continue;
+
+                if (ScreenSpaceDrawQuad.Contains(obj.SelectionPoint))
+                    capturedHitObjects.Add(obj);
+            }
+        }
+
+        /// <summary>
+        /// Encloses hitobjects captured through <see cref="BeginCapture"/> in the drag selection box.
+        /// </summary>
+        public void FinishCapture()
+        {
+            if (capturedHitObjects.Count == 0)
+            {
+                Hide();
+                return;
+            }
+
+            // Move the rectangle to cover the hitobjects
+            var topLeft = new Vector2(float.MaxValue, float.MaxValue);
+            var bottomRight = new Vector2(float.MinValue, float.MinValue);
+
+            foreach (var obj in capturedHitObjects)
+            {
+                topLeft = Vector2.ComponentMin(topLeft, Parent.ToLocalSpace(obj.SelectionQuad.TopLeft));
+                bottomRight = Vector2.ComponentMax(bottomRight, Parent.ToLocalSpace(obj.SelectionQuad.BottomRight));
+            }
+
+            topLeft -= new Vector2(5);
+            bottomRight += new Vector2(5);
+
+            this.MoveTo(topLeft, 200, Easing.OutQuint)
+                .ResizeTo(bottomRight - topLeft, 200, Easing.OutQuint);
+
+            dragRectangle = RectangleF.FromLTRB(topLeft.X, topLeft.Y, bottomRight.X, bottomRight.Y);
+
+            borderMask.BorderThickness = 3;
+            borderMask.FadeColour(captureFinishedColour, 200);
+
+            // Transform into markers to let the user modify the drag selection further.
+            background.Delay(50).FadeOut(200);
+            handles.FadeIn(200);
+
+            Selection.Value = new SelectionInfo
+            {
+                Objects = capturedHitObjects,
+                SelectionQuad = Parent.ToScreenSpace(dragRectangle)
+            };
+        }
+
+        private bool isActive = true;
+        public override bool HandleInput => isActive;
+
+        public override void Hide()
+        {
+            isActive = false;
+            this.FadeOut(400, Easing.OutQuint).Expire();
+
+            Selection.Value = null;
+        }
+    }
+}

osu.Game/Rulesets/Edit/Layers/Selection/OriginHandle.cs

@@ -0,0 +1,50 @@
+// 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.Shapes;
+using osu.Game.Graphics;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Edit.Layers.Selection
+{
+    /// <summary>
+    /// Represents the origin of a <see cref="HandleContainer"/>.
+    /// </summary>
+    public class OriginHandle : CompositeDrawable
+    {
+        private const float marker_size = 10;
+        private const float line_width = 2;
+
+        public OriginHandle()
+        {
+            Size = new Vector2(marker_size);
+
+            InternalChildren = new[]
+            {
+                new Box
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.X,
+                    Height = line_width
+                },
+                new Box
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Y,
+                    Width = line_width
+                },
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Colour = colours.Yellow;
+        }
+    }
+}

osu.Game/Rulesets/Edit/Layers/Selection/SelectionInfo.cs

@@ -0,0 +1,22 @@
+// 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.Framework.Graphics.Primitives;
+using osu.Game.Rulesets.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Edit.Layers.Selection
+{
+    public class SelectionInfo
+    {
+        /// <summary>
+        /// The objects that are captured by the selection.
+        /// </summary>
+        public IEnumerable<DrawableHitObject> Objects;
+
+        /// <summary>
+        /// The screen space quad of the selection box surrounding <see cref="Objects"/>.
+        /// </summary>
+        public Quad SelectionQuad;
+    }
+}

osu.Game/Rulesets/Edit/Layers/Selection/SelectionLayer.cs

@@ -0,0 +1,61 @@
+// 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.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Input;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Edit.Layers.Selection
+{
+    public class SelectionLayer : CompositeDrawable
+    {
+        public readonly Bindable<SelectionInfo> Selection = new Bindable<SelectionInfo>();
+
+        private readonly Playfield playfield;
+
+        public SelectionLayer(Playfield playfield)
+        {
+            this.playfield = playfield;
+
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        private HitObjectSelectionBox selectionBoxBox;
+
+        protected override bool OnDragStart(InputState state)
+        {
+            // Hide the previous drag box - we won't be working with it any longer
+            selectionBoxBox?.Hide();
+
+            AddInternal(selectionBoxBox = new HitObjectSelectionBox(ToLocalSpace(state.Mouse.NativeState.Position))
+            {
+                CapturableObjects = playfield.HitObjects.Objects,
+            });
+
+            Selection.BindTo(selectionBoxBox.Selection);
+
+            return true;
+        }
+
+        protected override bool OnDrag(InputState state)
+        {
+            selectionBoxBox.DragEndPosition = ToLocalSpace(state.Mouse.NativeState.Position);
+            selectionBoxBox.BeginCapture();
+            return true;
+        }
+
+        protected override bool OnDragEnd(InputState state)
+        {
+            selectionBoxBox.FinishCapture();
+            return true;
+        }
+
+        protected override bool OnClick(InputState state)
+        {
+            selectionBoxBox?.Hide();
+            return true;
+        }
+    }
+}

osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs

@@ -14,6 +14,8 @@ using osu.Game.Audio;
 using System.Linq;
 using osu.Game.Graphics;
 using osu.Framework.Configuration;
+using OpenTK;
+using osu.Framework.Graphics.Primitives;
 
 namespace osu.Game.Rulesets.Objects.Drawables
 {
@@ -38,6 +40,16 @@ namespace osu.Game.Rulesets.Objects.Drawables
         {
             HitObject = hitObject;
         }
+
+        /// <summary>
+        /// The screen-space point that causes this <see cref="DrawableHitObject"/> to be selected in the Editor.
+        /// </summary>
+        public virtual Vector2 SelectionPoint => ScreenSpaceDrawQuad.Centre;
+
+        /// <summary>
+        /// The screen-space quad that outlines this <see cref="DrawableHitObject"/> for selections in the Editor.
+        /// </summary>
+        public virtual Quad SelectionQuad => ScreenSpaceDrawQuad;
     }
 
     public abstract class DrawableHitObject<TObject> : DrawableHitObject

osu.Game/Rulesets/UI/RulesetContainer.cs

@@ -55,10 +55,11 @@ namespace osu.Game.Rulesets.UI
 
         public abstract IEnumerable<HitObject> Objects { get; }
 
+        private readonly Lazy<Playfield> playfield;
         /// <summary>
         /// The playfield.
         /// </summary>
-        public Playfield Playfield { get; protected set; }
+        public Playfield Playfield => playfield.Value;
 
         protected readonly Ruleset Ruleset;
 
@@ -69,6 +70,7 @@ namespace osu.Game.Rulesets.UI
         protected RulesetContainer(Ruleset ruleset)
         {
             Ruleset = ruleset;
+            playfield = new Lazy<Playfield>(CreatePlayfield);
         }
 
         public abstract ScoreProcessor CreateScoreProcessor();
@@ -95,6 +97,12 @@ namespace osu.Game.Rulesets.UI
             Replay = replay;
             ReplayInputManager.ReplayInputHandler = replay != null ? CreateReplayInputHandler(replay) : null;
         }
+
+        /// <summary>
+        /// Creates a Playfield.
+        /// </summary>
+        /// <returns>The Playfield.</returns>
+        protected abstract Playfield CreatePlayfield();
     }
 
     /// <summary>
@@ -198,7 +206,7 @@ namespace osu.Game.Rulesets.UI
             });
 
             AddInternal(KeyBindingInputManager);
-            KeyBindingInputManager.Add(Playfield = CreatePlayfield());
+            KeyBindingInputManager.Add(Playfield);
 
             loadObjects();
         }
@@ -286,12 +294,6 @@ namespace osu.Game.Rulesets.UI
         /// <param name="h">The HitObject to make drawable.</param>
         /// <returns>The DrawableHitObject.</returns>
         protected abstract DrawableHitObject<TObject> GetVisualRepresentation(TObject h);
-
-        /// <summary>
-        /// Creates a Playfield.
-        /// </summary>
-        /// <returns>The Playfield.</returns>
-        protected abstract Playfield CreatePlayfield();
     }
 
     /// <summary>

osu.Game/Screens/Play/FailOverlay.cs

@@ -10,7 +10,7 @@ using System.Linq;
 
 namespace osu.Game.Screens.Play
 {
-    public class FailOverlay : MenuOverlay
+    public class FailOverlay : GameplayMenuOverlay
     {
         public override string Header => "failed";
         public override string Description => "you're dead, try again?";
@@ -18,15 +18,15 @@ namespace osu.Game.Screens.Play
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
-            AddButton("Retry", colours.YellowDark, OnRetry);
+            AddButton("Retry", colours.YellowDark, () => OnRetry?.Invoke());
-            AddButton("Quit", new Color4(170, 27, 39, 255), OnQuit);
+            AddButton("Quit", new Color4(170, 27, 39, 255), () => OnQuit?.Invoke());
         }
 
         protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
         {
             if (!args.Repeat && args.Key == Key.Escape)
             {
-                Buttons.Children.Last().TriggerOnClick();
+                InternalButtons.Children.Last().TriggerOnClick();
                 return true;
             }
 

osu.Game/Screens/Play/GameplayMenuOverlay.cs

@@ -13,10 +13,12 @@ using osu.Game.Graphics;
 using osu.Framework.Allocation;
 using osu.Game.Graphics.UserInterface;
 using osu.Framework.Graphics.Shapes;
+using OpenTK.Input;
+using System.Collections.Generic;
 
 namespace osu.Game.Screens.Play
 {
-    public abstract class MenuOverlay : OverlayContainer, IRequireHighFrequencyMousePosition
+    public abstract class GameplayMenuOverlay : OverlayContainer, IRequireHighFrequencyMousePosition
     {
         private const int transition_duration = 200;
         private const int button_height = 70;
@@ -30,75 +32,16 @@ namespace osu.Game.Screens.Play
         public abstract string Header { get; }
         public abstract string Description { get; }
 
-        protected FillFlowContainer<DialogButton> Buttons;
+        protected internal FillFlowContainer<DialogButton> InternalButtons;
-
+        public IReadOnlyList<DialogButton> Buttons => InternalButtons;
-        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 GameplayMenuOverlay()
-
-        protected override void PopIn() => this.FadeIn(transition_duration, Easing.In);
-        protected override void PopOut() => this.FadeOut(transition_duration, Easing.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 OnMouseUp(InputState state, MouseUpEventArgs args) => true;
-
-        protected override bool OnMouseMove(InputState state) => true;
-
-        protected void AddButton(string text, Color4 colour, Action action)
         {
-            Buttons.Add(new Button
+            RelativeSizeAxes = Axes.Both;
-            {
+
-                Text = text,
+            StateChanged += s => selectionIndex = -1;
-                ButtonColour = colour,
-                Origin = Anchor.TopCentre,
-                Anchor = Anchor.TopCentre,
-                Height = button_height,
-                Action = delegate
-                {
-                    action?.Invoke();
-                    Hide();
-                }
-            });
         }
 
         [BackgroundDependencyLoader]
@@ -154,7 +97,7 @@ namespace osu.Game.Screens.Play
                                 }
                             }
                         },
-                        Buttons = new FillFlowContainer<DialogButton>
+                        InternalButtons = new FillFlowContainer<DialogButton>
                         {
                             Origin = Anchor.TopCentre,
                             Anchor = Anchor.TopCentre,
@@ -182,13 +125,140 @@ namespace osu.Game.Screens.Play
             Retries = 0;
         }
 
-        protected MenuOverlay()
+        public int Retries
         {
-            RelativeSizeAxes = Axes.Both;
+            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
+                        }
+                    };
+                }
+            }
         }
 
-        public class Button : DialogButton
+        public override bool HandleInput => State == Visibility.Visible;
+
+        protected override void PopIn() => this.FadeIn(transition_duration, Easing.In);
+        protected override void PopOut() => this.FadeOut(transition_duration, Easing.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 OnMouseUp(InputState state, MouseUpEventArgs args) => true;
+
+        protected override bool OnMouseMove(InputState state) => true;
+
+        protected void AddButton(string text, Color4 colour, Action action)
         {
+            var button = new Button
+            {
+                Text = text,
+                ButtonColour = colour,
+                Origin = Anchor.TopCentre,
+                Anchor = Anchor.TopCentre,
+                Height = button_height,
+                Action = delegate
+                {
+                    action?.Invoke();
+                    Hide();
+                }
+            };
+
+            button.Selected.ValueChanged += s => buttonSelectionChanged(button, s);
+
+            InternalButtons.Add(button);
+        }
+
+        private int _selectionIndex = -1;
+        private int selectionIndex
+        {
+            get { return _selectionIndex; }
+            set
+            {
+                if (_selectionIndex == value)
+                    return;
+
+                // Deselect the previously-selected button
+                if (_selectionIndex != -1)
+                    InternalButtons[_selectionIndex].Selected.Value = false;
+
+                _selectionIndex = value;
+
+                // Select the newly-selected button
+                if (_selectionIndex != -1)
+                    InternalButtons[_selectionIndex].Selected.Value = true;
+            }
+        }
+
+        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        {
+            if (args.Repeat)
+                return false;
+
+            switch (args.Key)
+            {
+                case Key.Up:
+                    if (selectionIndex == -1 || selectionIndex == 0)
+                        selectionIndex = InternalButtons.Count - 1;
+                    else
+                        selectionIndex--;
+                    return true;
+                case Key.Down:
+                    if (selectionIndex == -1 || selectionIndex == InternalButtons.Count - 1)
+                        selectionIndex = 0;
+                    else
+                        selectionIndex++;
+                    return true;
+            }
+
+            return false;
+        }
+
+        private void buttonSelectionChanged(DialogButton button, bool isSelected)
+        {
+            if (!isSelected)
+                selectionIndex = -1;
+            else
+                selectionIndex = InternalButtons.IndexOf(button);
+        }
+
+        private class Button : DialogButton
+        {
+            protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+            {
+                if (args.Repeat || args.Key != Key.Enter || !Selected)
+                    return false;
+
+                OnClick(state);
+                return true;
+            }
         }
     }
 }

osu.Game/Screens/Play/PauseContainer.cs

@@ -119,7 +119,7 @@ namespace osu.Game.Screens.Play
             base.Update();
         }
 
-        public class PauseOverlay : MenuOverlay
+        public class PauseOverlay : GameplayMenuOverlay
         {
             public Action OnResume;
 
@@ -130,7 +130,7 @@ namespace osu.Game.Screens.Play
             {
                 if (!args.Repeat && args.Key == Key.Escape)
                 {
-                    Buttons.Children.First().TriggerOnClick();
+                    InternalButtons.Children.First().TriggerOnClick();
                     return true;
                 }
 
@@ -140,9 +140,9 @@ namespace osu.Game.Screens.Play
             [BackgroundDependencyLoader]
             private void load(OsuColour colours)
             {
-                AddButton("Continue", colours.Green, OnResume);
+                AddButton("Continue", colours.Green, () => OnResume?.Invoke());
-                AddButton("Retry", colours.YellowDark, OnRetry);
+                AddButton("Retry", colours.YellowDark, () => OnRetry?.Invoke());
-                AddButton("Quit", new Color4(170, 27, 39, 255), OnQuit);
+                AddButton("Quit", new Color4(170, 27, 39, 255), () => OnQuit?.Invoke());
             }
         }
     }

osu.Game/Screens/Select/BeatmapCarousel.cs

@@ -7,7 +7,6 @@ using osu.Framework.Graphics.Containers;
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using osu.Game.Beatmaps.Drawables;
 using osu.Game.Configuration;
 using osu.Framework.Input;
 using OpenTK.Input;
@@ -15,477 +14,304 @@ using osu.Framework.MathUtils;
 using System.Diagnostics;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
+using osu.Framework.Caching;
 using osu.Framework.Threading;
 using osu.Framework.Configuration;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Cursor;
+using osu.Game.Screens.Select.Carousel;
 
 namespace osu.Game.Screens.Select
 {
     public class BeatmapCarousel : OsuScrollContainer
     {
-        public BeatmapInfo SelectedBeatmap => selectedPanel?.Beatmap;
+        /// <summary>
+        /// Triggered when the <see cref="BeatmapSets"/> loaded change and are completely loaded.
+        /// </summary>
+        public Action BeatmapSetsChanged;
+
+        /// <summary>
+        /// The currently selected beatmap.
+        /// </summary>
+        public BeatmapInfo SelectedBeatmap => selectedBeatmap?.Beatmap;
+
+        private CarouselBeatmap selectedBeatmap => selectedBeatmapSet?.Beatmaps.FirstOrDefault(s => s.State == CarouselItemState.Selected);
+
+        /// <summary>
+        /// The currently selected beatmap set.
+        /// </summary>
+        public BeatmapSetInfo SelectedBeatmapSet => selectedBeatmapSet?.BeatmapSet;
+
+        private CarouselBeatmapSet selectedBeatmapSet;
+
+        /// <summary>
+        /// Raised when the <see cref="SelectedBeatmap"/> is changed.
+        /// </summary>
+        public Action<BeatmapInfo> SelectionChanged;
 
         public override bool HandleInput => AllowSelection;
 
-        public Action BeatmapsChanged;
+        private IEnumerable<CarouselBeatmapSet> beatmapSets => root.Children.OfType<CarouselBeatmapSet>();
 
-        public IEnumerable<BeatmapSetInfo> Beatmaps
+        public IEnumerable<BeatmapSetInfo> BeatmapSets
         {
-            get { return groups.Select(g => g.BeatmapSet); }
+            get { return beatmapSets.Select(g => g.BeatmapSet); }
             set
             {
-                scrollableContent.Clear(false);
+                CarouselGroup newRoot = new CarouselGroupEagerSelect();
-                panels.Clear();
-                groups.Clear();
-
-                List<BeatmapGroup> newGroups = null;
 
                 Task.Run(() =>
                 {
-                    newGroups = value.Select(createGroup).Where(g => g != null).ToList();
+                    value.Select(createCarouselSet).Where(g => g != null).ForEach(newRoot.AddChild);
-                    criteria.Filter(newGroups);
+                    newRoot.Filter(activeCriteria);
-                }).ContinueWith(t =>
-                {
-                    Schedule(() =>
-                    {
-                        foreach (var g in newGroups)
-                            addGroup(g);
 
-                        computeYPositions();
+                    // preload drawables as the ctor overhead is quite high currently.
-                        BeatmapsChanged?.Invoke();
+                    var _ = newRoot.Drawables;
-                    });
+                }).ContinueWith(_ => Schedule(() =>
-                });
+                {
+                    root = newRoot;
+                    scrollableContent.Clear(false);
+                    itemsCache.Invalidate();
+                    scrollPositionCache.Invalidate();
+                    BeatmapSetsChanged?.Invoke();
+                }));
             }
         }
 
         private readonly List<float> yPositions = new List<float>();
+        private Cached itemsCache = new Cached();
+        private Cached scrollPositionCache = new Cached();
 
-        /// <summary>
+        private readonly Container<DrawableCarouselItem> scrollableContent;
-        /// Required for now unfortunately.
-        /// </summary>
-        private BeatmapManager manager;
 
-        private readonly Container<Panel> scrollableContent;
+        public Bindable<RandomSelectAlgorithm> RandomAlgorithm = new Bindable<RandomSelectAlgorithm>();
+        private readonly List<CarouselBeatmapSet> previouslyVisitedRandomSets = new List<CarouselBeatmapSet>();
+        private readonly Stack<CarouselBeatmap> randomSelectedBeatmaps = new Stack<CarouselBeatmap>();
 
-        private readonly List<BeatmapGroup> groups = new List<BeatmapGroup>();
+        protected List<DrawableCarouselItem> Items = new List<DrawableCarouselItem>();
-
+        private CarouselGroup root = new CarouselGroupEagerSelect();
-        private Bindable<SelectionRandomType> randomType;
-        private readonly List<BeatmapGroup> seenGroups = new List<BeatmapGroup>();
-
-        private readonly List<Panel> panels = new List<Panel>();
-
-        private readonly Stack<KeyValuePair<BeatmapGroup, BeatmapPanel>> randomSelectedBeatmaps = new Stack<KeyValuePair<BeatmapGroup, BeatmapPanel>>();
-
-        private BeatmapGroup selectedGroup;
-        private BeatmapPanel selectedPanel;
 
         public BeatmapCarousel()
         {
-            Add(new OsuContextMenuContainer
+            Child = new OsuContextMenuContainer
             {
                 RelativeSizeAxes = Axes.X,
                 AutoSizeAxes = Axes.Y,
-                Child = scrollableContent = new Container<Panel>
+                Child = scrollableContent = new Container<DrawableCarouselItem>
                 {
                     RelativeSizeAxes = Axes.X,
                 }
-            });
+            };
         }
 
-        public void RemoveBeatmap(BeatmapSetInfo beatmapSet)
+        [BackgroundDependencyLoader(permitNulls: true)]
+        private void load(OsuConfigManager config)
         {
-            Schedule(() => removeGroup(groups.Find(b => b.BeatmapSet.ID == beatmapSet.ID)));
+            config.BindWith(OsuSetting.RandomSelectAlgorithm, RandomAlgorithm);
+        }
+
+        public void RemoveBeatmapSet(BeatmapSetInfo beatmapSet)
+        {
+            Schedule(() =>
+            {
+                var existingSet = beatmapSets.FirstOrDefault(b => b.BeatmapSet.ID == beatmapSet.ID);
+
+                if (existingSet == null)
+                    return;
+
+                root.RemoveChild(existingSet);
+                itemsCache.Invalidate();
+            });
         }
 
         public void UpdateBeatmapSet(BeatmapSetInfo beatmapSet)
         {
-            // todo: this method should be smarter as to not recreate panels that haven't changed, etc.
+            Schedule(() =>
-            var oldGroup = groups.Find(b => b.BeatmapSet.ID == beatmapSet.ID);
-
-            var newGroup = createGroup(beatmapSet);
-
-            int index = groups.IndexOf(oldGroup);
-            if (index >= 0)
-                groups.RemoveAt(index);
-
-            if (newGroup != null)
             {
-                if (index >= 0)
+                CarouselBeatmapSet existingSet = beatmapSets.FirstOrDefault(b => b.BeatmapSet.ID == beatmapSet.ID);
-                    groups.Insert(index, newGroup);
-                else
-                    addGroup(newGroup);
-            }
 
-            bool hadSelection = selectedGroup == oldGroup;
+                bool hadSelection = existingSet?.State?.Value == CarouselItemState.Selected;
 
-            if (hadSelection && newGroup == null)
+                var newSet = createCarouselSet(beatmapSet);
-                selectedGroup = null;
 
-            Filter(null, false);
+                if (existingSet != null)
+                    root.RemoveChild(existingSet);
 
-            //check if we can/need to maintain our current selection.
+                if (newSet == null)
-            if (hadSelection && newGroup != null)
+                {
-            {
+                    itemsCache.Invalidate();
-                var newSelection =
+                    SelectNext();
-                    newGroup.BeatmapPanels.Find(p => p.Beatmap.ID == selectedPanel?.Beatmap.ID);
+                    return;
+                }
 
-                if(newSelection == null && oldGroup != null && selectedPanel != null)
+                root.AddChild(newSet);
-                    newSelection = newGroup.BeatmapPanels[Math.Min(newGroup.BeatmapPanels.Count - 1, oldGroup.BeatmapPanels.IndexOf(selectedPanel))];
 
-                selectGroup(newGroup, newSelection);
+                applyActiveCriteria(false, false);
-            }
+
+                //check if we can/need to maintain our current selection.
+                if (hadSelection)
+                    select((CarouselItem)newSet.Beatmaps.FirstOrDefault(b => b.Beatmap.ID == selectedBeatmap?.Beatmap.ID) ?? newSet);
+
+                itemsCache.Invalidate();
+            });
         }
 
-        public void SelectBeatmap(BeatmapInfo beatmap, bool animated = true)
+        public void SelectBeatmap(BeatmapInfo beatmap)
         {
-            if (beatmap == null || beatmap.Hidden)
+            if (beatmap?.Hidden != false)
-            {
-                SelectNext();
                 return;
-            }
 
-            if (beatmap == SelectedBeatmap) return;
+            foreach (CarouselBeatmapSet group in beatmapSets)
-
-            foreach (BeatmapGroup group in groups)
             {
-                var panel = group.BeatmapPanels.FirstOrDefault(p => p.Beatmap.Equals(beatmap));
+                var item = group.Beatmaps.FirstOrDefault(p => p.Beatmap.Equals(beatmap));
-                if (panel != null)
+                if (item != null)
                 {
-                    selectGroup(group, panel, animated);
+                    select(item);
                     return;
                 }
             }
         }
 
-        public Action<BeatmapInfo> SelectionChanged;
+        /// <summary>
-
+        /// Increment selection in the carousel in a chosen direction.
-        public Action StartRequested;
+        /// </summary>
-
+        /// <param name="direction">The direction to increment. Negative is backwards.</param>
-        public Action<BeatmapSetInfo> DeleteRequested;
+        /// <param name="skipDifficulties">Whether to skip individual difficulties and only increment over full groups.</param>
-
-        public Action<BeatmapSetInfo> RestoreRequested;
-
-        public Action<BeatmapInfo> EditRequested;
-
-        public Action<BeatmapInfo> HideDifficultyRequested;
-
-        private void selectNullBeatmap()
-        {
-            selectedGroup = null;
-            selectedPanel = null;
-            SelectionChanged?.Invoke(null);
-        }
-
         public void SelectNext(int direction = 1, bool skipDifficulties = true)
         {
-            if (groups.All(g => g.State == BeatmapGroupState.Hidden))
+            int originalIndex = Items.IndexOf(selectedBeatmap?.Drawables.First());
-            {
+            int currentIndex = originalIndex;
-                selectNullBeatmap();
-                return;
-            }
 
-            if (!skipDifficulties && selectedGroup != null)
+            // local function to increment the index in the required direction, wrapping over extremities.
-            {
+            int incrementIndex() => currentIndex = (currentIndex + direction + Items.Count) % Items.Count;
-                int i = selectedGroup.BeatmapPanels.IndexOf(selectedPanel) + direction;
 
-                if (i >= 0 && i < selectedGroup.BeatmapPanels.Count)
+            while (incrementIndex() != originalIndex)
+            {
+                var item = Items[currentIndex].Item;
+
+                if (item.Filtered || item.State == CarouselItemState.Selected) continue;
+
+                switch (item)
                 {
-                    //changing difficulty panel, not set.
+                    case CarouselBeatmap beatmap:
-                    selectGroup(selectedGroup, selectedGroup.BeatmapPanels[i]);
+                        if (skipDifficulties) continue;
-                    return;
+                        select(beatmap);
+                        return;
+                    case CarouselBeatmapSet set:
+                        if (skipDifficulties)
+                            select(set);
+                        else
+                            select(direction > 0 ? set.Beatmaps.First(b => !b.Filtered) : set.Beatmaps.Last(b => !b.Filtered));
+                        return;
                 }
             }
-
-            int startIndex = Math.Max(0, groups.IndexOf(selectedGroup));
-            int index = startIndex;
-
-            do
-            {
-                index = (index + direction + groups.Count) % groups.Count;
-                if (groups[index].State != BeatmapGroupState.Hidden)
-                {
-                    if (skipDifficulties)
-                        SelectBeatmap(groups[index].SelectedPanel != null ? groups[index].SelectedPanel.Beatmap : groups[index].BeatmapPanels.First().Beatmap);
-                    else
-                        SelectBeatmap(direction == 1 ? groups[index].BeatmapPanels.First().Beatmap : groups[index].BeatmapPanels.Last().Beatmap);
-
-                    return;
-                }
-            } while (index != startIndex);
         }
 
-        private IEnumerable<BeatmapGroup> getVisibleGroups() => groups.Where(selectGroup => selectGroup.State != BeatmapGroupState.Hidden);
-
         public void SelectNextRandom()
         {
-            if (groups.Count == 0)
+            var visible = beatmapSets.Where(s => !s.Filtered).ToList();
+            if (!visible.Any())
                 return;
 
-            var visibleGroups = getVisibleGroups();
+            if (selectedBeatmap != null)
-            if (!visibleGroups.Any())
-                return;
-
-            if (selectedGroup != null)
-                randomSelectedBeatmaps.Push(new KeyValuePair<BeatmapGroup, BeatmapPanel>(selectedGroup, selectedGroup.SelectedPanel));
-
-            BeatmapGroup group;
-
-            if (randomType == SelectionRandomType.RandomPermutation)
             {
-                var notSeenGroups = visibleGroups.Except(seenGroups);
+                randomSelectedBeatmaps.Push(selectedBeatmap);
-                if (!notSeenGroups.Any())
+
+                // when performing a random, we want to add the current set to the previously visited list
+                // else the user may be "randomised" to the existing selection.
+                if (previouslyVisitedRandomSets.LastOrDefault() != selectedBeatmapSet)
+                    previouslyVisitedRandomSets.Add(selectedBeatmapSet);
+            }
+
+            CarouselBeatmapSet set;
+
+            if (RandomAlgorithm == RandomSelectAlgorithm.RandomPermutation)
+            {
+                var notYetVisitedSets = visible.Except(previouslyVisitedRandomSets).ToList();
+                if (!notYetVisitedSets.Any())
                 {
-                    seenGroups.Clear();
+                    previouslyVisitedRandomSets.Clear();
-                    notSeenGroups = visibleGroups;
+                    notYetVisitedSets = visible;
                 }
 
-                group = notSeenGroups.ElementAt(RNG.Next(notSeenGroups.Count()));
+                set = notYetVisitedSets.ElementAt(RNG.Next(notYetVisitedSets.Count));
-                seenGroups.Add(group);
+                previouslyVisitedRandomSets.Add(set);
             }
             else
-                group = visibleGroups.ElementAt(RNG.Next(visibleGroups.Count()));
+                set = visible.ElementAt(RNG.Next(visible.Count));
 
-            BeatmapPanel panel = group.BeatmapPanels[RNG.Next(group.BeatmapPanels.Count)];
+            select(set.Beatmaps.Skip(RNG.Next(set.Beatmaps.Count())).FirstOrDefault());
-
-            selectGroup(group, panel);
         }
 
         public void SelectPreviousRandom()
         {
-            if (!randomSelectedBeatmaps.Any())
-                return;
-
-            var visibleGroups = getVisibleGroups();
-            if (!visibleGroups.Any())
-                return;
-
             while (randomSelectedBeatmaps.Any())
             {
-                var beatmapCoordinates = randomSelectedBeatmaps.Pop();
+                var beatmap = randomSelectedBeatmaps.Pop();
-                var group = beatmapCoordinates.Key;
+
-                if (visibleGroups.Contains(group))
+                if (!beatmap.Filtered)
                 {
-                    selectGroup(group, beatmapCoordinates.Value);
+                    if (RandomAlgorithm == RandomSelectAlgorithm.RandomPermutation)
+                        previouslyVisitedRandomSets.Remove(selectedBeatmapSet);
+                    select(beatmap);
                     break;
                 }
             }
         }
 
-        private FilterCriteria criteria = new FilterCriteria();
+        private void select(CarouselItem item)
+        {
+            if (item == null) return;
+            item.State.Value = CarouselItemState.Selected;
+        }
 
-        private ScheduledDelegate filterTask;
+        private FilterCriteria activeCriteria = new FilterCriteria();
+
+        protected ScheduledDelegate FilterTask;
 
         public bool AllowSelection = true;
 
-        public void FlushPendingFilters()
+        public void FlushPendingFilterOperations()
         {
-            if (filterTask?.Completed == false)
+            if (FilterTask?.Completed == false)
-                Filter(null, false);
+                applyActiveCriteria(false, false);
         }
 
-        public void Filter(FilterCriteria newCriteria = null, bool debounce = true)
+        public void Filter(FilterCriteria newCriteria, bool debounce = true)
         {
             if (newCriteria != null)
-                criteria = newCriteria;
+                activeCriteria = newCriteria;
 
-            Action perform = delegate
+            applyActiveCriteria(debounce, true);
+        }
+
+        private void applyActiveCriteria(bool debounce, bool scroll)
+        {
+            if (root.Children.Any() != true) return;
+
+            void perform()
             {
-                filterTask = null;
+                FilterTask = null;
 
-                criteria.Filter(groups);
+                root.Filter(activeCriteria);
+                itemsCache.Invalidate();
+                if (scroll) scrollPositionCache.Invalidate();
+            }
 
-                var filtered = new List<BeatmapGroup>(groups);
+            FilterTask?.Cancel();
-
+            FilterTask = null;
-                scrollableContent.Clear(false);
-                panels.Clear();
-                groups.Clear();
-
-                foreach (var g in filtered)
-                    addGroup(g);
-
-                computeYPositions();
-
-                if (selectedGroup == null || selectedGroup.State == BeatmapGroupState.Hidden)
-                    SelectNext();
-                else
-                    selectGroup(selectedGroup, selectedPanel);
-            };
-
-            filterTask?.Cancel();
-            filterTask = null;
 
             if (debounce)
-                filterTask = Scheduler.AddDelayed(perform, 250);
+                FilterTask = Scheduler.AddDelayed(perform, 250);
             else
                 perform();
         }
 
-        public void ScrollToSelected(bool animated = true)
+        private float? scrollTarget;
-        {
-            float selectedY = computeYPositions(animated);
-            ScrollTo(selectedY, animated);
-        }
 
-        private BeatmapGroup createGroup(BeatmapSetInfo beatmapSet)
+        public void ScrollToSelected() => scrollPositionCache.Invalidate();
-        {
-            if (beatmapSet.Beatmaps.All(b => b.Hidden))
-                return null;
-
-            foreach (var b in beatmapSet.Beatmaps)
-            {
-                if (b.Metadata == null)
-                    b.Metadata = beatmapSet.Metadata;
-            }
-
-            return new BeatmapGroup(beatmapSet, manager)
-            {
-                SelectionChanged = (g, p) => selectGroup(g, p),
-                StartRequested = b => StartRequested?.Invoke(),
-                DeleteRequested = b => DeleteRequested?.Invoke(b),
-                RestoreHiddenRequested = s => RestoreRequested?.Invoke(s),
-                EditRequested = b => EditRequested?.Invoke(b),
-                HideDifficultyRequested = b => HideDifficultyRequested?.Invoke(b),
-                State = BeatmapGroupState.Collapsed
-            };
-        }
-
-        [BackgroundDependencyLoader(permitNulls: true)]
-        private void load(BeatmapManager manager, OsuConfigManager config)
-        {
-            this.manager = manager;
-
-            randomType = config.GetBindable<SelectionRandomType>(OsuSetting.SelectionRandomType);
-        }
-
-        private void addGroup(BeatmapGroup group)
-        {
-            // prevent duplicates by concurrent independent actions trying to add a group
-            if (groups.Any(g => g.BeatmapSet.ID == group.BeatmapSet.ID))
-                return;
-
-            groups.Add(group);
-            panels.Add(group.Header);
-            panels.AddRange(group.BeatmapPanels);
-        }
-
-        private void removeGroup(BeatmapGroup group)
-        {
-            if (group == null)
-                return;
-
-            if (selectedGroup == group)
-            {
-                if (getVisibleGroups().Count() == 1)
-                    selectNullBeatmap();
-                else
-                    SelectNext();
-            }
-
-            groups.Remove(group);
-            panels.Remove(group.Header);
-            foreach (var p in group.BeatmapPanels)
-                panels.Remove(p);
-
-            scrollableContent.Remove(group.Header);
-            scrollableContent.RemoveRange(group.BeatmapPanels);
-
-            computeYPositions();
-        }
-
-        /// <summary>
-        /// Computes the target Y positions for every panel in the carousel.
-        /// </summary>
-        /// <returns>The Y position of the currently selected panel.</returns>
-        private float computeYPositions(bool animated = true)
-        {
-            yPositions.Clear();
-
-            float currentY = DrawHeight / 2;
-            float selectedY = currentY;
-
-            foreach (BeatmapGroup group in groups)
-            {
-                movePanel(group.Header, group.State != BeatmapGroupState.Hidden, animated, ref currentY);
-
-                if (group.State == BeatmapGroupState.Expanded)
-                {
-                    group.Header.MoveToX(-100, 500, Easing.OutExpo);
-                    var headerY = group.Header.Position.Y;
-
-                    foreach (BeatmapPanel panel in group.BeatmapPanels)
-                    {
-                        if (panel == selectedPanel)
-                            selectedY = currentY + panel.DrawHeight / 2 - DrawHeight / 2;
-
-                        panel.MoveToX(-50, 500, Easing.OutExpo);
-
-                        //on first display we want to begin hidden under our group's header.
-                        if (panel.Alpha == 0)
-                            panel.MoveToY(headerY);
-
-                        movePanel(panel, true, animated, ref currentY);
-                    }
-                }
-                else
-                {
-                    group.Header.MoveToX(0, 500, Easing.OutExpo);
-
-                    foreach (BeatmapPanel panel in group.BeatmapPanels)
-                    {
-                        panel.MoveToX(0, 500, Easing.OutExpo);
-                        movePanel(panel, false, animated, ref currentY);
-                    }
-                }
-            }
-
-            currentY += DrawHeight / 2;
-            scrollableContent.Height = currentY;
-
-            return selectedY;
-        }
-
-        private void movePanel(Panel panel, bool advance, bool animated, ref float currentY)
-        {
-            yPositions.Add(currentY);
-            panel.MoveToY(currentY, animated ? 750 : 0, Easing.OutExpo);
-
-            if (advance)
-                currentY += panel.DrawHeight + 5;
-        }
-
-        private void selectGroup(BeatmapGroup group, BeatmapPanel panel = null, bool animated = true)
-        {
-            try
-            {
-                if (panel == null)
-                    panel = group.BeatmapPanels.First();
-
-                if (selectedPanel == panel) return;
-
-                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;
-                group.SelectedPanel = panel;
-
-                panel.State = PanelSelectedState.Selected;
-
-                if (selectedPanel == panel) return;
-
-                selectedPanel = panel;
-                selectedGroup = group;
-
-                SelectionChanged?.Invoke(panel.Beatmap);
-            }
-            finally
-            {
-                ScrollToSelected(animated);
-            }
-        }
 
         protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
         {
@@ -521,68 +347,185 @@ namespace osu.Game.Screens.Select
         {
             base.Update();
 
+            if (!itemsCache.IsValid)
+                updateItems();
+
+            if (!scrollPositionCache.IsValid)
+                updateScrollPosition();
+
             float drawHeight = DrawHeight;
 
-            // Remove all panels that should no longer be on-screen
+            // Remove all items that should no longer be on-screen
-            scrollableContent.RemoveAll(delegate(Panel p)
+            scrollableContent.RemoveAll(p => p.Y < Current - p.DrawHeight || p.Y > Current + drawHeight || !p.IsPresent);
-            {
-                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
+            // Find index range of all items that should be on-screen
-            Trace.Assert(panels.Count == yPositions.Count);
+            Trace.Assert(Items.Count == yPositions.Count);
 
-            int firstIndex = yPositions.BinarySearch(Current - Panel.MAX_HEIGHT);
+            int firstIndex = yPositions.BinarySearch(Current - DrawableCarouselItem.MAX_HEIGHT);
             if (firstIndex < 0) firstIndex = ~firstIndex;
             int lastIndex = yPositions.BinarySearch(Current + drawHeight);
-            if (lastIndex < 0)
+            if (lastIndex < 0) lastIndex = ~lastIndex;
-            {
-                lastIndex = ~lastIndex;
 
-                // Add the first panel of the last visible beatmap group to preload its data.
+            int notVisibleCount = 0;
-                if (lastIndex != 0 && panels[lastIndex - 1] is BeatmapSetHeader)
-                    lastIndex++;
-            }
 
-            // Add those panels within the previously found index range that should be displayed.
+            // Add those items within the previously found index range that should be displayed.
             for (int i = firstIndex; i < lastIndex; ++i)
             {
-                Panel panel = panels[i];
+                DrawableCarouselItem item = Items[i];
-                if (panel.State == PanelSelectedState.Hidden)
+
+                if (!item.Item.Visible)
+                {
+                    if (!item.IsPresent)
+                        notVisibleCount++;
                     continue;
+                }
 
                 // Only add if we're not already part of the content.
-                if (!scrollableContent.Contains(panel))
+                if (!scrollableContent.Contains(item))
                 {
-                    // Makes sure headers are always _below_ panels,
+                    // Makes sure headers are always _below_ items,
                     // and depth flows downward.
-                    panel.Depth = i + (panel is BeatmapSetHeader ? panels.Count : 0);
+                    item.Depth = i + (item is DrawableCarouselBeatmapSet ? -Items.Count : 0);
 
-                    switch (panel.LoadState)
+                    switch (item.LoadState)
                     {
                         case LoadState.NotLoaded:
-                            LoadComponentAsync(panel);
+                            LoadComponentAsync(item);
                             break;
                         case LoadState.Loading:
                             break;
                         default:
-                            scrollableContent.Add(panel);
+                            scrollableContent.Add(item);
                             break;
                     }
                 }
             }
 
-            // Update externally controlled state of currently visible panels
+            // this is not actually useful right now, but once we have groups may well be.
+            if (notVisibleCount > 50)
+                itemsCache.Invalidate();
+
+            // Update externally controlled state of currently visible items
             // (e.g. x-offset and opacity).
             float halfHeight = drawHeight / 2;
-            foreach (Panel p in scrollableContent.Children)
+            foreach (DrawableCarouselItem p in scrollableContent.Children)
-                updatePanel(p, halfHeight);
+                updateItem(p, halfHeight);
+        }
+
+        private CarouselBeatmapSet createCarouselSet(BeatmapSetInfo beatmapSet)
+        {
+            if (beatmapSet.Beatmaps.All(b => b.Hidden))
+                return null;
+
+            // todo: remove the need for this.
+            foreach (var b in beatmapSet.Beatmaps)
+            {
+                if (b.Metadata == null)
+                    b.Metadata = beatmapSet.Metadata;
+            }
+
+            var set = new CarouselBeatmapSet(beatmapSet);
+
+            foreach (var c in set.Beatmaps)
+            {
+                c.State.ValueChanged += v =>
+                {
+                    if (v == CarouselItemState.Selected)
+                    {
+                        selectedBeatmapSet = set;
+                        SelectionChanged?.Invoke(c.Beatmap);
+
+                        itemsCache.Invalidate();
+                        scrollPositionCache.Invalidate();
+                    }
+                };
+            }
+
+            return set;
         }
 
         /// <summary>
-        /// Computes the x-offset of currently visible panels. Makes the carousel appear round.
+        /// Computes the target Y positions for every item in the carousel.
+        /// </summary>
+        /// <returns>The Y position of the currently selected item.</returns>
+        private void updateItems()
+        {
+            Items = root.Drawables.ToList();
+
+            yPositions.Clear();
+
+            float currentY = DrawHeight / 2;
+            DrawableCarouselBeatmapSet lastSet = null;
+
+            scrollTarget = null;
+
+            foreach (DrawableCarouselItem d in Items)
+            {
+                if (d.IsPresent)
+                {
+                    switch (d)
+                    {
+                        case DrawableCarouselBeatmapSet set:
+                            lastSet = set;
+
+                            set.MoveToX(set.Item.State == CarouselItemState.Selected ? -100 : 0, 500, Easing.OutExpo);
+                            set.MoveToY(currentY, 750, Easing.OutExpo);
+                            break;
+                        case DrawableCarouselBeatmap beatmap:
+                            if (beatmap.Item.State.Value == CarouselItemState.Selected)
+                                scrollTarget = currentY + beatmap.DrawHeight / 2 - DrawHeight / 2;
+
+                            void performMove(float y, float? startY = null)
+                            {
+                                if (startY != null) beatmap.MoveTo(new Vector2(0, startY.Value));
+                                beatmap.MoveToX(beatmap.Item.State == CarouselItemState.Selected ? -50 : 0, 500, Easing.OutExpo);
+                                beatmap.MoveToY(y, 750, Easing.OutExpo);
+                            }
+
+                            Debug.Assert(lastSet != null);
+
+                            float? setY = null;
+                            if (!d.IsLoaded || beatmap.Alpha == 0) // can't use IsPresent due to DrawableCarouselItem override.
+                                setY = lastSet.Y + lastSet.DrawHeight + 5;
+
+                            if (d.IsLoaded)
+                                performMove(currentY, setY);
+                            else
+                            {
+                                float y = currentY;
+                                d.OnLoadComplete = _ => performMove(y, setY);
+                            }
+
+                            break;
+                    }
+                }
+
+                yPositions.Add(currentY);
+
+                if (d.Item.Visible)
+                    currentY += d.DrawHeight + 5;
+            }
+
+            currentY += DrawHeight / 2;
+            scrollableContent.Height = currentY;
+
+            if (selectedBeatmapSet != null && selectedBeatmapSet.State.Value != CarouselItemState.Selected)
+            {
+                selectedBeatmapSet = null;
+                SelectionChanged?.Invoke(null);
+            }
+
+            itemsCache.Validate();
+        }
+
+        private void updateScrollPosition()
+        {
+            if (scrollTarget != null) ScrollTo(scrollTarget.Value);
+            scrollPositionCache.Validate();
+        }
+
+        /// <summary>
+        /// Computes the x-offset of currently visible items. Makes the carousel appear round.
         /// </summary>
         /// <param name="dist">
         /// Vertical distance from the center of the carousel container
@@ -600,20 +543,20 @@ namespace osu.Game.Screens.Select
         }
 
         /// <summary>
-        /// Update a panel's x position and multiplicative alpha based on its y position and
+        /// Update a item's x position and multiplicative alpha based on its y position and
         /// the current scroll position.
         /// </summary>
-        /// <param name="p">The panel to be updated.</param>
+        /// <param name="p">The item to be updated.</param>
         /// <param name="halfHeight">Half the draw height of the carousel container.</param>
-        private void updatePanel(Panel p, float halfHeight)
+        private void updateItem(DrawableCarouselItem p, float halfHeight)
         {
             var height = p.IsPresent ? p.DrawHeight : 0;
 
-            float panelDrawY = p.Position.Y - Current + height / 2;
+            float itemDrawY = p.Position.Y - Current + height / 2;
-            float dist = Math.Abs(1f - panelDrawY / halfHeight);
+            float dist = Math.Abs(1f - itemDrawY / halfHeight);
 
             // Setting the origin position serves as an additive position on top of potential
-            // local transformation we may want to apply (e.g. when a panel gets selected, we
+            // local transformation we may want to apply (e.g. when a item gets selected, we
             // may want to smoothly transform it leftwards.)
             p.OriginPosition = new Vector2(-offsetX(dist, halfHeight), 0);
 

osu.Game/Screens/Select/BeatmapInfoWedge.cs

@@ -19,6 +19,7 @@ using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Cursor;
 
 namespace osu.Game.Screens.Select
 {
@@ -217,8 +218,8 @@ namespace osu.Game.Screens.Select
                             },
                             new FillFlowContainer
                             {
-                                Margin = new MarginPadding { Top = 20, Left = 10 },
+                                Margin = new MarginPadding { Top = 20 },
-                                Spacing = new Vector2(40, 0),
+                                Spacing = new Vector2(20, 0),
                                 AutoSizeAxes = Axes.Both,
                                 Children = labels
                             },
@@ -232,43 +233,59 @@ namespace osu.Game.Screens.Select
                 double bpmMax = beatmap.ControlPointInfo.BPMMaximum;
                 double bpmMin = beatmap.ControlPointInfo.BPMMinimum;
 
-                if (Precision.AlmostEquals(bpmMin, bpmMax)) return $"{bpmMin:0}bpm";
+                if (Precision.AlmostEquals(bpmMin, bpmMax)) return $"{bpmMin:0}";
 
-                return $"{bpmMin:0}-{bpmMax:0}bpm (mostly {beatmap.ControlPointInfo.BPMMode:0}bpm)";
+                return $"{bpmMin:0}-{bpmMax:0} (mostly {beatmap.ControlPointInfo.BPMMode:0})";
             }
 
-            public class InfoLabel : Container
+            public class InfoLabel : Container, IHasTooltip
             {
+                public string TooltipText { get; private set; }
+
                 public InfoLabel(BeatmapStatistic statistic)
                 {
+                    TooltipText = statistic.Name;
                     AutoSizeAxes = Axes.Both;
+
                     Children = new Drawable[]
                     {
-                        new SpriteIcon
+                        new Container
                         {
-                            Icon = FontAwesome.fa_square,
+                            Anchor = Anchor.CentreLeft,
-                            Origin = Anchor.Centre,
+                            Origin = Anchor.CentreLeft,
-                            Colour = new Color4(68, 17, 136, 255),
-                            Rotation = 45,
-                            Size = new Vector2(20),
-                        },
-                        new SpriteIcon
-                        {
-                            Icon = statistic.Icon,
-                            Origin = Anchor.Centre,
-                            Colour = new Color4(255, 221, 85, 255),
-                            Scale = new Vector2(0.8f),
                             Size = new Vector2(20),
+                            Children = new[]
+                            {
+                                new SpriteIcon
+                                {
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = OsuColour.FromHex(@"441288"),
+                                    Icon = FontAwesome.fa_square,
+                                    Rotation = 45,
+                                },
+                                new SpriteIcon
+                                {
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    RelativeSizeAxes = Axes.Both,
+                                    Scale = new Vector2(0.8f),
+                                    Colour = OsuColour.FromHex(@"f7dd55"),
+                                    Icon = statistic.Icon,
+                                },
+                            }
                         },
                         new OsuSpriteText
                         {
-                            Margin = new MarginPadding { Left = 13 },
+                            Anchor = Anchor.CentreLeft,
-                            Font = @"Exo2.0-Bold",
+                            Origin = Anchor.CentreLeft,
                             Colour = new Color4(255, 221, 85, 255),
+                            Font = @"Exo2.0-Bold",
+                            Margin = new MarginPadding { Left = 30 },
                             Text = statistic.Content,
                             TextSize = 17,
-                            Origin = Anchor.CentreLeft
+                        }
-                        },
                     };
                 }
             }

osu.Game/Screens/Select/Carousel/CarouselBeatmap.cs

@@ -0,0 +1,55 @@
+// 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 osu.Game.Beatmaps;
+using osu.Game.Screens.Select.Filter;
+
+namespace osu.Game.Screens.Select.Carousel
+{
+    public class CarouselBeatmap : CarouselItem
+    {
+        public readonly BeatmapInfo Beatmap;
+
+        public CarouselBeatmap(BeatmapInfo beatmap)
+        {
+            Beatmap = beatmap;
+            State.Value = CarouselItemState.Collapsed;
+        }
+
+        protected override DrawableCarouselItem CreateDrawableRepresentation() => new DrawableCarouselBeatmap(this);
+
+        public override void Filter(FilterCriteria criteria)
+        {
+            base.Filter(criteria);
+
+            bool match = criteria.Ruleset == null || Beatmap.RulesetID == criteria.Ruleset.ID || Beatmap.RulesetID == 0 && criteria.Ruleset.ID > 0 && criteria.AllowConvertedBeatmaps;
+
+            if (!string.IsNullOrEmpty(criteria.SearchText))
+                match &=
+                    Beatmap.Metadata.SearchableTerms.Any(term => term.IndexOf(criteria.SearchText, StringComparison.InvariantCultureIgnoreCase) >= 0) ||
+                    Beatmap.Version.IndexOf(criteria.SearchText, StringComparison.InvariantCultureIgnoreCase) >= 0;
+
+            Filtered.Value = !match;
+        }
+
+        public override int CompareTo(FilterCriteria criteria, CarouselItem other)
+        {
+            if (!(other is CarouselBeatmap otherBeatmap))
+                return base.CompareTo(criteria, other);
+
+            switch (criteria.Sort)
+            {
+                default:
+                case SortMode.Difficulty:
+                    var ruleset = Beatmap.RulesetID.CompareTo(otherBeatmap.Beatmap.RulesetID);
+                    if (ruleset != 0) return ruleset;
+
+                    return Beatmap.StarDifficulty.CompareTo(otherBeatmap.Beatmap.StarDifficulty);
+            }
+        }
+
+        public override string ToString() => Beatmap.ToString();
+    }
+}

osu.Game/Screens/Select/Carousel/CarouselBeatmapSet.cs

@@ -0,0 +1,58 @@
+// 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.Framework.Extensions.IEnumerableExtensions;
+using osu.Game.Beatmaps;
+using osu.Game.Screens.Select.Filter;
+
+namespace osu.Game.Screens.Select.Carousel
+{
+    public class CarouselBeatmapSet : CarouselGroupEagerSelect
+    {
+        public IEnumerable<CarouselBeatmap> Beatmaps => InternalChildren.OfType<CarouselBeatmap>();
+
+        public BeatmapSetInfo BeatmapSet;
+
+        public CarouselBeatmapSet(BeatmapSetInfo beatmapSet)
+        {
+            BeatmapSet = beatmapSet ?? throw new ArgumentNullException(nameof(beatmapSet));
+
+            beatmapSet.Beatmaps
+                      .Where(b => !b.Hidden)
+                      .Select(b => new CarouselBeatmap(b))
+                      .ForEach(AddChild);
+        }
+
+        protected override DrawableCarouselItem CreateDrawableRepresentation() => new DrawableCarouselBeatmapSet(this);
+
+        public override int CompareTo(FilterCriteria criteria, CarouselItem other)
+        {
+            if (!(other is CarouselBeatmapSet otherSet))
+                return base.CompareTo(criteria, other);
+
+            switch (criteria.Sort)
+            {
+                default:
+                case SortMode.Artist:
+                    return string.Compare(BeatmapSet.Metadata.Artist, otherSet.BeatmapSet.Metadata.Artist, StringComparison.InvariantCultureIgnoreCase);
+                case SortMode.Title:
+                    return string.Compare(BeatmapSet.Metadata.Title, otherSet.BeatmapSet.Metadata.Title, StringComparison.InvariantCultureIgnoreCase);
+                case SortMode.Author:
+                    return string.Compare(BeatmapSet.Metadata.Author.Username, otherSet.BeatmapSet.Metadata.Author.Username, StringComparison.InvariantCultureIgnoreCase);
+                case SortMode.Difficulty:
+                    return BeatmapSet.MaxStarDifficulty.CompareTo(otherSet.BeatmapSet.MaxStarDifficulty);
+            }
+        }
+
+        public override void Filter(FilterCriteria criteria)
+        {
+            base.Filter(criteria);
+            Filtered.Value = InternalChildren.All(i => i.Filtered);
+        }
+
+        public override string ToString() => BeatmapSet.ToString();
+    }
+}

osu.Game/Screens/Select/Carousel/CarouselGroup.cs

@@ -0,0 +1,91 @@
+// 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;
+
+namespace osu.Game.Screens.Select.Carousel
+{
+    /// <summary>
+    /// A group which ensures only one child is selected.
+    /// </summary>
+    public class CarouselGroup : CarouselItem
+    {
+        private readonly List<CarouselItem> items;
+
+        protected override DrawableCarouselItem CreateDrawableRepresentation() => null;
+
+        public IReadOnlyList<CarouselItem> Children => InternalChildren;
+
+        protected List<CarouselItem> InternalChildren = new List<CarouselItem>();
+
+        public override List<DrawableCarouselItem> Drawables
+        {
+            get
+            {
+                var drawables = base.Drawables;
+                foreach (var c in InternalChildren)
+                    drawables.AddRange(c.Drawables);
+                return drawables;
+            }
+        }
+
+        public virtual void RemoveChild(CarouselItem i)
+        {
+            InternalChildren.Remove(i);
+
+            // it's important we do the deselection after removing, so any further actions based on
+            // State.ValueChanged make decisions post-removal.
+            i.State.Value = CarouselItemState.Collapsed;
+        }
+
+        public virtual void AddChild(CarouselItem i)
+        {
+            i.State.ValueChanged += v => ChildItemStateChanged(i, v);
+            InternalChildren.Add(i);
+        }
+
+        public CarouselGroup(List<CarouselItem> items = null)
+        {
+            if (items != null) InternalChildren = items;
+
+            State.ValueChanged += v =>
+            {
+                switch (v)
+                {
+                    case CarouselItemState.Collapsed:
+                    case CarouselItemState.NotSelected:
+                        InternalChildren.ForEach(c => c.State.Value = CarouselItemState.Collapsed);
+                        break;
+                    case CarouselItemState.Selected:
+                        InternalChildren.ForEach(c =>
+                        {
+                            if (c.State == CarouselItemState.Collapsed) c.State.Value = CarouselItemState.NotSelected;
+                        });
+                        break;
+                }
+            };
+        }
+
+        public override void Filter(FilterCriteria criteria)
+        {
+            base.Filter(criteria);
+            InternalChildren.Sort((x, y) => x.CompareTo(criteria, y));
+            InternalChildren.ForEach(c => c.Filter(criteria));
+        }
+
+        protected virtual void ChildItemStateChanged(CarouselItem item, CarouselItemState value)
+        {
+            // ensure we are the only item selected
+            if (value == CarouselItemState.Selected)
+            {
+                foreach (var b in InternalChildren)
+                {
+                    if (item == b) continue;
+                    b.State.Value = CarouselItemState.NotSelected;
+                }
+
+                State.Value = CarouselItemState.Selected;
+            }
+        }
+    }
+}

osu.Game/Screens/Select/Carousel/CarouselGroupEagerSelect.cs

@@ -0,0 +1,104 @@
+// 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;
+
+namespace osu.Game.Screens.Select.Carousel
+{
+    /// <summary>
+    /// A group which ensures at least one child is selected (if the group itself is selected).
+    /// </summary>
+    public class CarouselGroupEagerSelect : CarouselGroup
+    {
+        public CarouselGroupEagerSelect()
+        {
+            State.ValueChanged += v =>
+            {
+                if (v == CarouselItemState.Selected)
+                    attemptSelection();
+            };
+        }
+
+        /// <summary>
+        /// We need to keep track of the index for cases where the selection is removed but we want to select a new item based on its old location.
+        /// </summary>
+        private int lastSelectedIndex;
+
+        private CarouselItem lastSelected;
+
+        /// <summary>
+        /// To avoid overhead during filter operations, we don't attempt any selections until after all
+        /// children have been filtered. This bool will be true during the base <see cref="Filter(FilterCriteria)"/>
+        /// operation.
+        /// </summary>
+        private bool filteringChildren;
+
+        public override void Filter(FilterCriteria criteria)
+        {
+            filteringChildren = true;
+            base.Filter(criteria);
+            filteringChildren = false;
+
+            attemptSelection();
+        }
+
+        public override void RemoveChild(CarouselItem i)
+        {
+            base.RemoveChild(i);
+
+            if (i != lastSelected)
+                updateSelectedIndex();
+        }
+
+        public override void AddChild(CarouselItem i)
+        {
+            base.AddChild(i);
+            attemptSelection();
+        }
+
+        protected override void ChildItemStateChanged(CarouselItem item, CarouselItemState value)
+        {
+            base.ChildItemStateChanged(item, value);
+
+            switch (value)
+            {
+                case CarouselItemState.Selected:
+                    updateSelected(item);
+                    break;
+                case CarouselItemState.NotSelected:
+                case CarouselItemState.Collapsed:
+                    attemptSelection();
+                    break;
+            }
+        }
+
+        private void attemptSelection()
+        {
+            if (filteringChildren) return;
+
+            // we only perform eager selection if we are a currently selected group.
+            if (State != CarouselItemState.Selected) return;
+
+            // we only perform eager selection if none of our children are in a selected state already.
+            if (Children.Any(i => i.State == CarouselItemState.Selected)) return;
+
+            CarouselItem nextToSelect =
+                Children.Skip(lastSelectedIndex).FirstOrDefault(i => !i.Filtered) ??
+                Children.Reverse().Skip(InternalChildren.Count - lastSelectedIndex).FirstOrDefault(i => !i.Filtered);
+
+            if (nextToSelect != null)
+                nextToSelect.State.Value = CarouselItemState.Selected;
+            else
+                updateSelected(null);
+        }
+
+        private void updateSelected(CarouselItem newSelection)
+        {
+            lastSelected = newSelection;
+            updateSelectedIndex();
+        }
+
+        private void updateSelectedIndex() => lastSelectedIndex = lastSelected == null ? 0 : Math.Max(0, InternalChildren.IndexOf(lastSelected));
+    }
+}

osu.Game/Screens/Select/Carousel/CarouselItem.cs

@@ -0,0 +1,62 @@
+// 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.Framework.Configuration;
+
+namespace osu.Game.Screens.Select.Carousel
+{
+    public abstract class CarouselItem
+    {
+        public readonly BindableBool Filtered = new BindableBool();
+
+        public readonly Bindable<CarouselItemState> State = new Bindable<CarouselItemState>(CarouselItemState.NotSelected);
+
+        /// <summary>
+        /// This item is not in a hidden state.
+        /// </summary>
+        public bool Visible => State.Value != CarouselItemState.Collapsed && !Filtered;
+
+        public virtual List<DrawableCarouselItem> Drawables
+        {
+            get
+            {
+                var items = new List<DrawableCarouselItem>();
+
+                var self = drawableRepresentation.Value;
+                if (self?.IsPresent == true) items.Add(self);
+
+                return items;
+            }
+        }
+
+        protected CarouselItem()
+        {
+            drawableRepresentation = new Lazy<DrawableCarouselItem>(CreateDrawableRepresentation);
+
+            Filtered.ValueChanged += v =>
+            {
+                if (v && State == CarouselItemState.Selected)
+                    State.Value = CarouselItemState.NotSelected;
+            };
+        }
+
+        private readonly Lazy<DrawableCarouselItem> drawableRepresentation;
+
+        protected abstract DrawableCarouselItem CreateDrawableRepresentation();
+
+        public virtual void Filter(FilterCriteria criteria)
+        {
+        }
+
+        public virtual int CompareTo(FilterCriteria criteria, CarouselItem other) => GetHashCode().CompareTo(other.GetHashCode());
+    }
+
+    public enum CarouselItemState
+    {
+        Collapsed,
+        NotSelected,
+        Selected,
+    }
+}

osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmap.cs

@@ -2,82 +2,56 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Drawables;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Backgrounds;
+using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using OpenTK;
 using OpenTK.Graphics;
-using osu.Framework.Input;
-using osu.Game.Graphics.Sprites;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Graphics.UserInterface;
 
-namespace osu.Game.Beatmaps.Drawables
+namespace osu.Game.Screens.Select.Carousel
 {
-    public class BeatmapPanel : Panel, IHasContextMenu
+    public class DrawableCarouselBeatmap : DrawableCarouselItem, IHasContextMenu
     {
-        public BeatmapInfo Beatmap;
+        private readonly BeatmapInfo beatmap;
-        private readonly Sprite background;
 
-        public Action<BeatmapPanel> GainedSelection;
+        private Sprite background;
-        public Action<BeatmapPanel> StartRequested;
-        public Action<BeatmapPanel> EditRequested;
-        public Action<BeatmapInfo> HideRequested;
 
-        private readonly Triangles triangles;
+        private Action<BeatmapInfo> startRequested;
-        private readonly StarCounter starCounter;
+        private Action<BeatmapInfo> editRequested;
+        private Action<BeatmapInfo> hideRequested;
 
-        protected override void Selected()
+        private Triangles triangles;
+        private StarCounter starCounter;
+
+        public DrawableCarouselBeatmap(CarouselBeatmap panel) : base(panel)
         {
-            base.Selected();
+            beatmap = panel.Beatmap;
-
-            GainedSelection?.Invoke(this);
-
-            background.Colour = ColourInfo.GradientVertical(
-                new Color4(20, 43, 51, 255),
-                new Color4(40, 86, 102, 255));
-
-            triangles.Colour = Color4.White;
-        }
-
-        protected override void Deselected()
-        {
-            base.Deselected();
-
-            background.Colour = new Color4(20, 43, 51, 255);
-            triangles.Colour = OsuColour.Gray(0.5f);
-        }
-
-        protected override bool OnClick(InputState state)
-        {
-            if (State == PanelSelectedState.Selected)
-                StartRequested?.Invoke(this);
-
-            return base.OnClick(state);
-        }
-
-        protected override void ApplyState(PanelSelectedState last = PanelSelectedState.Hidden)
-        {
-            if (!IsLoaded) return;
-
-            base.ApplyState(last);
-
-            if (last == PanelSelectedState.Hidden && State != last)
-                starCounter.ReplayAnimation();
-        }
-
-        public BeatmapPanel(BeatmapInfo beatmap)
-        {
-            if (beatmap == null)
-                throw new ArgumentNullException(nameof(beatmap));
-
-            Beatmap = beatmap;
             Height *= 0.60f;
+        }
+
+        [BackgroundDependencyLoader(true)]
+        private void load(SongSelect songSelect, BeatmapManager manager)
+        {
+            if (songSelect != null)
+            {
+                startRequested = songSelect.Start;
+                editRequested = songSelect.Edit;
+            }
+
+            if (manager != null)
+                hideRequested = manager.Hide;
 
             Children = new Drawable[]
             {
@@ -157,11 +131,46 @@ namespace osu.Game.Beatmaps.Drawables
             };
         }
 
+        protected override void Selected()
+        {
+            base.Selected();
+
+            background.Colour = ColourInfo.GradientVertical(
+                new Color4(20, 43, 51, 255),
+                new Color4(40, 86, 102, 255));
+
+            triangles.Colour = Color4.White;
+        }
+
+        protected override void Deselected()
+        {
+            base.Deselected();
+
+            background.Colour = new Color4(20, 43, 51, 255);
+            triangles.Colour = OsuColour.Gray(0.5f);
+        }
+
+        protected override bool OnClick(InputState state)
+        {
+            if (Item.State == CarouselItemState.Selected)
+                startRequested?.Invoke(beatmap);
+
+            return base.OnClick(state);
+        }
+
+        protected override void ApplyState()
+        {
+            if (Item.State.Value != CarouselItemState.Collapsed && Alpha == 0)
+                starCounter.ReplayAnimation();
+
+            base.ApplyState();
+        }
+
         public MenuItem[] ContextMenuItems => new MenuItem[]
         {
-            new OsuMenuItem("Play", MenuItemType.Highlighted, () => StartRequested?.Invoke(this)),
+            new OsuMenuItem("Play", MenuItemType.Highlighted, () => startRequested?.Invoke(beatmap)),
-            new OsuMenuItem("Edit", MenuItemType.Standard, () => EditRequested?.Invoke(this)),
+            new OsuMenuItem("Edit", MenuItemType.Standard, () => editRequested?.Invoke(beatmap)),
-            new OsuMenuItem("Hide", MenuItemType.Destructive, () => HideRequested?.Invoke(Beatmap)),
+            new OsuMenuItem("Hide", MenuItemType.Destructive, () => hideRequested?.Invoke(beatmap)),
         };
     }
 }

osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmapSet.cs

@@ -4,67 +4,57 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using OpenTK;
-using OpenTK.Graphics;
 using osu.Framework.Allocation;
+using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
-using osu.Framework.Localisation;
-using osu.Game.Graphics.Sprites;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Drawables;
+using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
+using OpenTK;
+using OpenTK.Graphics;
 
-namespace osu.Game.Beatmaps.Drawables
+namespace osu.Game.Screens.Select.Carousel
 {
-    public class BeatmapSetHeader : Panel, IHasContextMenu
+    public class DrawableCarouselBeatmapSet : DrawableCarouselItem, IHasContextMenu
     {
-        public Action<BeatmapSetHeader> GainedSelection;
+        private Action<BeatmapSetInfo> deleteRequested;
+        private Action<BeatmapSetInfo> restoreHiddenRequested;
 
-        public Action<BeatmapSetInfo> DeleteRequested;
+        private readonly BeatmapSetInfo beatmapSet;
-
-        public Action<BeatmapSetInfo> RestoreHiddenRequested;
-
-        private readonly WorkingBeatmap beatmap;
 
         private readonly FillFlowContainer difficultyIcons;
 
-        public BeatmapSetHeader(WorkingBeatmap beatmap)
+        public DrawableCarouselBeatmapSet(CarouselBeatmapSet set)
+            : base(set)
         {
-            if (beatmap == null)
+            beatmapSet = set.BeatmapSet;
-                throw new ArgumentNullException(nameof(beatmap));
-
-            this.beatmap = beatmap;
-
-            difficultyIcons = new FillFlowContainer
-            {
-                Margin = new MarginPadding { Top = 5 },
-                AutoSizeAxes = Axes.Both,
-            };
-        }
-
-        protected override void Selected()
-        {
-            base.Selected();
-            GainedSelection?.Invoke(this);
         }
 
         [BackgroundDependencyLoader]
-        private void load(LocalisationEngine localisation)
+        private void load(LocalisationEngine localisation, BeatmapManager manager)
         {
             if (localisation == null)
                 throw new ArgumentNullException(nameof(localisation));
 
+            restoreHiddenRequested = s => s.Beatmaps.ForEach(manager.Restore);
+            deleteRequested = manager.Delete;
+
             Children = new Drawable[]
             {
                 new DelayedLoadWrapper(
-                    new PanelBackground(beatmap)
+                    new PanelBackground(manager.GetWorkingBeatmap(beatmapSet.Beatmaps.FirstOrDefault()))
                     {
                         RelativeSizeAxes = Axes.Both,
-                        OnLoadComplete = d => d.FadeInFromZero(400, Easing.Out),
+                        OnLoadComplete = d => d.FadeInFromZero(1000, Easing.OutQuint),
-                    }, 300),
+                    }, 300
+                ),
                 new FillFlowContainer
                 {
                     Direction = FillDirection.Vertical,
@@ -75,23 +65,46 @@ namespace osu.Game.Beatmaps.Drawables
                         new OsuSpriteText
                         {
                             Font = @"Exo2.0-BoldItalic",
-                            Current = localisation.GetUnicodePreference(beatmap.Metadata.TitleUnicode, beatmap.Metadata.Title),
+                            Current = localisation.GetUnicodePreference(beatmapSet.Metadata.TitleUnicode, beatmapSet.Metadata.Title),
                             TextSize = 22,
                             Shadow = true,
                         },
                         new OsuSpriteText
                         {
                             Font = @"Exo2.0-SemiBoldItalic",
-                            Current = localisation.GetUnicodePreference(beatmap.Metadata.ArtistUnicode, beatmap.Metadata.Artist),
+                            Current = localisation.GetUnicodePreference(beatmapSet.Metadata.ArtistUnicode, beatmapSet.Metadata.Artist),
                             TextSize = 17,
                             Shadow = true,
                         },
-                        difficultyIcons
+                        new FillFlowContainer<FilterableDifficultyIcon>
+                        {
+                            Margin = new MarginPadding { Top = 5 },
+                            AutoSizeAxes = Axes.Both,
+                            Children = ((CarouselBeatmapSet)Item).Beatmaps.Select(b => new FilterableDifficultyIcon(b)).ToList()
+                        }
                     }
                 }
             };
         }
 
+        public MenuItem[] ContextMenuItems
+        {
+            get
+            {
+                List<MenuItem> items = new List<MenuItem>();
+
+                if (Item.State == CarouselItemState.NotSelected)
+                    items.Add(new OsuMenuItem("Expand", MenuItemType.Highlighted, () => Item.State.Value = CarouselItemState.Selected));
+
+                if (beatmapSet.Beatmaps.Any(b => b.Hidden))
+                    items.Add(new OsuMenuItem("Restore all hidden", MenuItemType.Standard, () => restoreHiddenRequested?.Invoke(beatmapSet)));
+
+                items.Add(new OsuMenuItem("Delete", MenuItemType.Destructive, () => deleteRequested?.Invoke(beatmapSet)));
+
+                return items.ToArray();
+            }
+        }
+
         private class PanelBackground : BufferedContainer
         {
             public PanelBackground(WorkingBeatmap working)
@@ -128,22 +141,19 @@ namespace osu.Game.Beatmaps.Drawables
                             new Box
                             {
                                 RelativeSizeAxes = Axes.Both,
-                                Colour = ColourInfo.GradientHorizontal(
+                                Colour = ColourInfo.GradientHorizontal(Color4.Black, new Color4(0f, 0f, 0f, 0.9f)),
-                                    Color4.Black, new Color4(0f, 0f, 0f, 0.9f)),
                                 Width = 0.05f,
                             },
                             new Box
                             {
                                 RelativeSizeAxes = Axes.Both,
-                                Colour = ColourInfo.GradientHorizontal(
+                                Colour = ColourInfo.GradientHorizontal(new Color4(0f, 0f, 0f, 0.9f), new Color4(0f, 0f, 0f, 0.1f)),
-                                    new Color4(0f, 0f, 0f, 0.9f), new Color4(0f, 0f, 0f, 0.1f)),
                                 Width = 0.2f,
                             },
                             new Box
                             {
                                 RelativeSizeAxes = Axes.Both,
-                                Colour = ColourInfo.GradientHorizontal(
+                                Colour = ColourInfo.GradientHorizontal(new Color4(0f, 0f, 0f, 0.1f), new Color4(0, 0, 0, 0)),
-                                    new Color4(0f, 0f, 0f, 0.1f), new Color4(0, 0, 0, 0)),
                                 Width = 0.05f,
                             },
                         }
@@ -152,30 +162,16 @@ namespace osu.Game.Beatmaps.Drawables
             }
         }
 
-        public void AddDifficultyIcons(IEnumerable<BeatmapPanel> panels)
+        public class FilterableDifficultyIcon : DifficultyIcon
         {
-            if (panels == null)
+            private readonly BindableBool filtered = new BindableBool();
-                throw new ArgumentNullException(nameof(panels));
 
-            foreach (var p in panels)
+            public FilterableDifficultyIcon(CarouselBeatmap item)
-                difficultyIcons.Add(new DifficultyIcon(p.Beatmap));
+                : base(item.Beatmap)
-        }
-
-        public MenuItem[] ContextMenuItems
-        {
-            get
             {
-                List<MenuItem> items = new List<MenuItem>();
+                filtered.BindTo(item.Filtered);
-
+                filtered.ValueChanged += v => Schedule(() => this.FadeTo(v ? 0.1f : 1, 100));
-                if (State == PanelSelectedState.NotSelected)
+                filtered.TriggerChange();
-                    items.Add(new OsuMenuItem("Expand", MenuItemType.Highlighted, () => State = PanelSelectedState.Selected));
-
-                if (beatmap.BeatmapSetInfo.Beatmaps.Any(b => b.Hidden))
-                    items.Add(new OsuMenuItem("Restore all hidden", MenuItemType.Standard, () => RestoreHiddenRequested?.Invoke(beatmap.BeatmapSetInfo)));
-
-                items.Add(new OsuMenuItem("Delete", MenuItemType.Destructive, () => DeleteRequested?.Invoke(beatmap.BeatmapSetInfo)));
-
-                return items.ToArray();
             }
         }
     }

osu.Game/Screens/Select/Carousel/DrawableCarouselItem.cs

@@ -1,45 +1,53 @@
 // 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;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
-using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input;
+using osu.Framework.MathUtils;
+using osu.Game.Graphics;
 using OpenTK;
 using OpenTK.Graphics;
-using osu.Framework.Extensions.Color4Extensions;
-using osu.Framework.MathUtils;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Graphics;
 
-namespace osu.Game.Beatmaps.Drawables
+namespace osu.Game.Screens.Select.Carousel
 {
-    public class Panel : Container, IStateful<PanelSelectedState>
+    public abstract class DrawableCarouselItem : Container
     {
         public const float MAX_HEIGHT = 80;
 
-        public event Action<PanelSelectedState> StateChanged;
-
         public override bool RemoveWhenNotAlive => false;
 
-        private readonly Container nestedContainer;
+        public override bool IsPresent => base.IsPresent || Item.Visible;
 
-        private readonly Container borderContainer;
+        public readonly CarouselItem Item;
 
-        private readonly Box hoverLayer;
+        private Container nestedContainer;
+        private Container borderContainer;
+
+        private Box hoverLayer;
 
         protected override Container<Drawable> Content => nestedContainer;
 
-        protected Panel()
+        protected DrawableCarouselItem(CarouselItem item)
         {
+            Item = item;
+
             Height = MAX_HEIGHT;
             RelativeSizeAxes = Axes.X;
+            Alpha = 0;
+        }
 
-            AddInternal(borderContainer = new Container
+        private SampleChannel sampleHover;
+
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio, OsuColour colours)
+        {
+            InternalChild = borderContainer = new Container
             {
                 RelativeSizeAxes = Axes.Both,
                 Masking = true,
@@ -58,16 +66,8 @@ namespace osu.Game.Beatmaps.Drawables
                         Blending = BlendingMode.Additive,
                     },
                 }
-            });
+            };
 
-            Alpha = 0;
-        }
-
-        private SampleChannel sampleHover;
-
-        [BackgroundDependencyLoader]
-        private void load(AudioManager audio, OsuColour colours)
-        {
             sampleHover = audio.Sample.Get($@"SongSelect/song-ping-variation-{RNG.Next(1, 5)}");
             hoverLayer.Colour = colours.Blue.Opacity(0.1f);
         }
@@ -86,60 +86,41 @@ namespace osu.Game.Beatmaps.Drawables
             base.OnHoverLost(state);
         }
 
-        public void SetMultiplicativeAlpha(float alpha)
+        public void SetMultiplicativeAlpha(float alpha) => borderContainer.Alpha = alpha;
-        {
-            borderContainer.Alpha = alpha;
-        }
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
+
             ApplyState();
+            Item.Filtered.ValueChanged += _ => Schedule(ApplyState);
+            Item.State.ValueChanged += _ => Schedule(ApplyState);
         }
 
-        protected virtual void ApplyState(PanelSelectedState last = PanelSelectedState.Hidden)
+        protected virtual void ApplyState()
         {
             if (!IsLoaded) return;
 
-            switch (state)
+            switch (Item.State.Value)
             {
-                case PanelSelectedState.Hidden:
+                case CarouselItemState.NotSelected:
-                case PanelSelectedState.NotSelected:
                     Deselected();
                     break;
-                case PanelSelectedState.Selected:
+                case CarouselItemState.Selected:
                     Selected();
                     break;
             }
 
-            if (state == PanelSelectedState.Hidden)
+            if (!Item.Visible)
                 this.FadeOut(300, Easing.OutQuint);
             else
                 this.FadeIn(250);
         }
 
-        private PanelSelectedState state = PanelSelectedState.NotSelected;
-
-        public PanelSelectedState State
-        {
-            get { return state; }
-
-            set
-            {
-                if (state == value)
-                    return;
-
-                var last = state;
-                state = value;
-
-                ApplyState(last);
-
-                StateChanged?.Invoke(State);
-            }
-        }
-
         protected virtual void Selected()
         {
+            Item.State.Value = CarouselItemState.Selected;
+
             borderContainer.BorderThickness = 2.5f;
             borderContainer.EdgeEffect = new EdgeEffectParameters
             {
@@ -152,6 +133,8 @@ namespace osu.Game.Beatmaps.Drawables
 
         protected virtual void Deselected()
         {
+            Item.State.Value = CarouselItemState.NotSelected;
+
             borderContainer.BorderThickness = 0;
             borderContainer.EdgeEffect = new EdgeEffectParameters
             {
@@ -164,15 +147,8 @@ namespace osu.Game.Beatmaps.Drawables
 
         protected override bool OnClick(InputState state)
         {
-            State = PanelSelectedState.Selected;
+            Item.State.Value = CarouselItemState.Selected;
             return true;
         }
     }
-
-    public enum PanelSelectedState
-    {
-        Hidden,
-        NotSelected,
-        Selected
-    }
 }

osu.Game/Screens/Select/EditSongSelect.cs

@@ -1,14 +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.Input;
-
 namespace osu.Game.Screens.Select
 {
     public class EditSongSelect : SongSelect
     {
         protected override bool ShowFooter => false;
 
-        protected override void OnSelected(InputState state) => Exit();
+        protected override void Start() => Exit();
     }
 }

osu.Game/Screens/Select/FilterCriteria.cs

@@ -1,10 +1,6 @@
 // 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.Rulesets;
 using osu.Game.Screens.Select.Filter;
 
@@ -17,47 +13,5 @@ namespace osu.Game.Screens.Select
         public string SearchText;
         public RulesetInfo Ruleset;
         public bool AllowConvertedBeatmaps;
-
-        public void Filter(List<BeatmapGroup> groups)
-        {
-            foreach (var g in groups)
-            {
-                var set = g.BeatmapSet;
-
-                bool hasCurrentMode = AllowConvertedBeatmaps || set.Beatmaps.Any(bm => bm.RulesetID == (Ruleset?.ID ?? 0));
-
-                bool match = hasCurrentMode;
-
-                if (!string.IsNullOrEmpty(SearchText))
-                    match &= set.Metadata.SearchableTerms.Any(term => term.IndexOf(SearchText, StringComparison.InvariantCultureIgnoreCase) >= 0);
-
-                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.Username, y.BeatmapSet.Metadata.Author.Username, StringComparison.InvariantCultureIgnoreCase));
-                    break;
-                case SortMode.Difficulty:
-                    groups.Sort((x, y) => x.BeatmapSet.MaxStarDifficulty.CompareTo(y.BeatmapSet.MaxStarDifficulty));
-                    break;
-            }
-        }
     }
 }

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.Framework.Input;
-
 namespace osu.Game.Screens.Select
 {
     public class MatchSongSelect : SongSelect
     {
-        protected override void OnSelected(InputState state) => Exit();
+        protected override void Start() => Exit();
     }
 }

osu.Game/Screens/Select/PlaySongSelect.cs

@@ -8,7 +8,6 @@ using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Input;
 using osu.Framework.Screens;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
@@ -114,11 +113,12 @@ namespace osu.Game.Screens.Select
             return false;
         }
 
-        protected override void OnSelected(InputState state)
+        protected override void Start()
         {
             if (player != null) return;
 
-            if (state?.Keyboard.ControlPressed == true)
+            // Ctrl+Enter should start map with autoplay enabled.
+            if (GetContainingInputManager().CurrentState?.Keyboard.ControlPressed == true)
             {
                 var auto = Ruleset.Value.CreateInstance().GetAutoplayMod();
                 var autoType = auto.GetType();

osu.Game/Screens/Select/SongSelect.cs

@@ -2,7 +2,6 @@
 // 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;
@@ -28,25 +27,11 @@ namespace osu.Game.Screens.Select
 {
     public abstract class SongSelect : OsuScreen
     {
-        private BeatmapManager beatmaps;
-        protected override BackgroundScreen CreateBackground() => new BackgroundScreenBeatmap();
-
-        private readonly BeatmapCarousel carousel;
-        private DialogOverlay dialogOverlay;
-
         private static readonly Vector2 wedged_container_size = new Vector2(0.5f, 245);
-
+        private static readonly Vector2 background_blur = new Vector2(20);
         private const float left_area_padding = 20;
 
-        private readonly BeatmapInfoWedge beatmapInfoWedge;
+        public readonly FilterControl FilterControl;
-
-        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;
 
@@ -66,77 +51,90 @@ namespace osu.Game.Screens.Select
         /// </summary>
         protected readonly Container FooterPanels;
 
-        public readonly FilterControl FilterControl;
+        protected override BackgroundScreen CreateBackground() => new BackgroundScreenBeatmap();
+
+        protected Container LeftContent;
+
+        private readonly BeatmapCarousel carousel;
+        private readonly BeatmapInfoWedge beatmapInfoWedge;
+        private DialogOverlay dialogOverlay;
+        private BeatmapManager beatmaps;
+
+        private SampleChannel sampleChangeDifficulty;
+        private SampleChannel sampleChangeBeatmap;
+
+        private CancellationTokenSource initialAddSetsTask;
+
+        private DependencyContainer dependencies;
+        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent) => dependencies = new DependencyContainer(parent);
 
         protected SongSelect()
         {
             const float carousel_width = 640;
             const float filter_height = 100;
 
-            Add(new ParallaxContainer
+            AddRange(new Drawable[]
             {
-                Padding = new MarginPadding { Top = filter_height },
+                new ParallaxContainer
-                ParallaxAmount = 0.005f,
-                RelativeSizeAxes = Axes.Both,
-                Children = new[]
                 {
-                    new WedgeBackground
+                    Padding = new MarginPadding { Top = filter_height },
+                    ParallaxAmount = 0.005f,
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new[]
                     {
-                        RelativeSizeAxes = Axes.Both,
+                        new WedgeBackground
-                        Padding = new MarginPadding { Right = carousel_width * 0.76f },
+                        {
+                            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 = carouselSelectionChanged,
-                BeatmapsChanged = carouselBeatmapsLoaded,
-                DeleteRequested = promptDelete,
-                RestoreRequested = s => { foreach (var b in s.Beatmaps) beatmaps.Restore(b); },
-                EditRequested = editRequested,
-                HideDifficultyRequested = b => beatmaps.Hide(b),
-                StartRequested = () => carouselRaisedStart(),
-            });
-            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,
                 },
-            });
+                LeftContent = new Container
-            Add(new ResetScrollContainer(() => carousel.ScrollToSelected())
+                {
-            {
+                    Origin = Anchor.BottomLeft,
-                RelativeSizeAxes = Axes.Y,
+                    Anchor = Anchor.BottomLeft,
-                Width = 250,
+                    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,
+                    }
+                },
+                carousel = new BeatmapCarousel
+                {
+                    RelativeSizeAxes = Axes.Y,
+                    Size = new Vector2(carousel_width, 1),
+                    Anchor = Anchor.CentreRight,
+                    Origin = Anchor.CentreRight,
+                    SelectionChanged = carouselSelectionChanged,
+                    BeatmapSetsChanged = carouselBeatmapsLoaded,
+                },
+                FilterControl = new FilterControl
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = filter_height,
+                    FilterChanged = c => carousel.Filter(c),
+                    Exit = Exit,
+                },
+                beatmapInfoWedge = new BeatmapInfoWedge
+                {
+                    Alpha = 0,
+                    Size = wedged_container_size,
+                    RelativeSizeAxes = Axes.X,
+                    Margin = new MarginPadding
+                    {
+                        Top = left_area_padding,
+                        Right = left_area_padding,
+                    },
+                },
+                new ResetScrollContainer(() => carousel.ScrollToSelected())
+                {
+                    RelativeSizeAxes = Axes.Y,
+                    Width = 250,
+                }
             });
 
             if (ShowFooter)
@@ -164,12 +162,14 @@ namespace osu.Game.Screens.Select
         [BackgroundDependencyLoader(permitNulls: true)]
         private void load(BeatmapManager beatmaps, AudioManager audio, DialogOverlay dialog, OsuGame osu, OsuColour colours)
         {
+            dependencies.Cache(this);
+
             if (Footer != null)
             {
                 Footer.AddButton(@"random", colours.Green, triggerRandom, Key.F2);
                 Footer.AddButton(@"options", colours.Blue, BeatmapOptions, Key.F3);
 
-                BeatmapOptions.AddButton(@"Delete", @"Beatmap", FontAwesome.fa_trash, colours.Pink, () => promptDelete(Beatmap.Value.BeatmapSetInfo), Key.Number4, float.MaxValue);
+                BeatmapOptions.AddButton(@"Delete", @"Beatmap", FontAwesome.fa_trash, colours.Pink, () => delete(Beatmap.Value.BeatmapSetInfo), Key.Number4, float.MaxValue);
             }
 
             if (this.beatmaps == null)
@@ -190,51 +190,31 @@ namespace osu.Game.Screens.Select
 
             initialAddSetsTask = new CancellationTokenSource();
 
-            carousel.Beatmaps = this.beatmaps.GetAllUsableBeatmapSets();
+            carousel.BeatmapSets = this.beatmaps.GetAllUsableBeatmapSets();
-
-            Beatmap.ValueChanged += beatmap_ValueChanged;
 
             Beatmap.DisabledChanged += disabled => carousel.AllowSelection = !disabled;
-            carousel.AllowSelection = !Beatmap.Disabled;
+            Beatmap.TriggerChange();
+
+            Beatmap.ValueChanged += b =>
+            {
+                if (IsCurrentScreen)
+                    carousel.SelectBeatmap(b?.BeatmapInfo);
+            };
         }
 
-        private void editRequested(BeatmapInfo beatmap)
+        public void Edit(BeatmapInfo beatmap)
         {
             Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmap, Beatmap);
             Push(new Editor());
         }
 
-        private void onBeatmapRestored(BeatmapInfo beatmap)
+        public void Start(BeatmapInfo beatmap)
-        {
-            Schedule(() =>
-            {
-                var beatmapSet = beatmaps.QueryBeatmapSet(s => s.ID == beatmap.BeatmapSetInfoID);
-                carousel.UpdateBeatmapSet(beatmapSet);
-            });
-        }
-
-        private void onBeatmapHidden(BeatmapInfo beatmap)
-        {
-            Schedule(() =>
-            {
-                var beatmapSet = beatmaps.QueryBeatmapSet(s => s.ID == beatmap.BeatmapSetInfoID);
-                carousel.UpdateBeatmapSet(beatmapSet);
-            });
-        }
-
-        private void carouselBeatmapsLoaded()
-        {
-            if (Beatmap.Value.BeatmapSetInfo?.DeletePending == false)
-                carousel.SelectBeatmap(Beatmap.Value.BeatmapInfo, false);
-            else
-                carousel.SelectNextRandom();
-        }
-
-        private void carouselRaisedStart(InputState state = null)
         {
             // if we have a pending filter operation, we want to run it now.
             // it could change selection (ie. if the ruleset has been changed).
-            carousel.FlushPendingFilters();
+            carousel.FlushPendingFilterOperations();
+
+            carousel.SelectBeatmap(beatmap);
 
             if (selectionChangedDebounce?.Completed == false)
             {
@@ -243,9 +223,14 @@ namespace osu.Game.Screens.Select
                 selectionChangedDebounce = null;
             }
 
-            OnSelected(state);
+            Start();
         }
 
+        /// <summary>
+        /// Called when a selection is made.
+        /// </summary>
+        protected abstract void Start();
+
         private ScheduledDelegate selectionChangedDebounce;
 
         // We need to keep track of the last selected beatmap ignoring debounce to play the correct selection sounds.
@@ -262,7 +247,7 @@ namespace osu.Game.Screens.Select
                 // In these cases, the other component has already loaded the beatmap, so we don't need to do so again.
                 if (beatmap?.Equals(Beatmap.Value.BeatmapInfo) != true)
                 {
-                    bool preview = beatmap?.BeatmapSetInfoID != Beatmap.Value.BeatmapInfo.BeatmapSetInfoID;
+                    bool preview = beatmap?.BeatmapSetInfoID != Beatmap.Value?.BeatmapInfo.BeatmapSetInfoID;
 
                     Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmap, Beatmap);
                     ensurePlayingSelected(preview);
@@ -302,30 +287,11 @@ namespace osu.Game.Screens.Select
                 carousel.SelectNextRandom();
         }
 
-        protected abstract void OnSelected(InputState state);
-
-        private void filterChanged(FilterCriteria criteria, bool debounce = true)
-        {
-            carousel.Filter(criteria, debounce);
-        }
-
-        private void onBeatmapSetAdded(BeatmapSetInfo s)
-        {
-            Schedule(() =>
-            {
-                carousel.UpdateBeatmapSet(s);
-                carousel.SelectBeatmap(s.Beatmaps.First());
-            });
-        }
-
-        private void onBeatmapSetRemoved(BeatmapSetInfo s) => Schedule(() => removeBeatmapSet(s));
-
         protected override void OnEntering(Screen last)
         {
             base.OnEntering(last);
 
             Content.FadeInFromZero(250);
-
             FilterControl.Activate();
         }
 
@@ -354,7 +320,7 @@ namespace osu.Game.Screens.Select
 
             logo.Action = () =>
             {
-                carouselRaisedStart();
+                Start();
                 return false;
             };
         }
@@ -366,13 +332,6 @@ namespace osu.Game.Screens.Select
             logo.FadeOut(logo_transition / 2, Easing.Out);
         }
 
-        private void beatmap_ValueChanged(WorkingBeatmap beatmap)
-        {
-            if (!IsCurrentScreen) return;
-
-            carousel.SelectBeatmap(beatmap?.BeatmapInfo);
-        }
-
         protected override void OnResuming(Screen last)
         {
             if (Beatmap != null && !Beatmap.Value.BeatmapSetInfo.DeletePending)
@@ -433,8 +392,7 @@ namespace osu.Game.Screens.Select
         /// <param name="beatmap">The working beatmap.</param>
         protected virtual void UpdateBeatmap(WorkingBeatmap beatmap)
         {
-            var backgroundModeBeatmap = Background as BackgroundScreenBeatmap;
+            if (Background is BackgroundScreenBeatmap backgroundModeBeatmap)
-            if (backgroundModeBeatmap != null)
             {
                 backgroundModeBeatmap.Beatmap = beatmap;
                 backgroundModeBeatmap.BlurTo(background_blur, 750, Easing.OutQuint);
@@ -459,18 +417,22 @@ namespace osu.Game.Screens.Select
             }
         }
 
-        private void removeBeatmapSet(BeatmapSetInfo beatmapSet)
+        private void onBeatmapSetAdded(BeatmapSetInfo s) => carousel.UpdateBeatmapSet(s);
+        private void onBeatmapSetRemoved(BeatmapSetInfo s) => carousel.RemoveBeatmapSet(s);
+        private void onBeatmapRestored(BeatmapInfo b) => carousel.UpdateBeatmapSet(beatmaps.QueryBeatmapSet(s => s.ID == b.BeatmapSetInfoID));
+        private void onBeatmapHidden(BeatmapInfo b) => carousel.UpdateBeatmapSet(beatmaps.QueryBeatmapSet(s => s.ID == b.BeatmapSetInfoID));
+
+        private void carouselBeatmapsLoaded()
         {
-            carousel.RemoveBeatmap(beatmapSet);
+            if (Beatmap.Value.BeatmapSetInfo?.DeletePending == false)
-            if (carousel.SelectedBeatmap == null)
+                carousel.SelectBeatmap(Beatmap.Value.BeatmapInfo);
-                Beatmap.SetDefault();
+            else
+                carousel.SelectNextRandom();
         }
 
-        private void promptDelete(BeatmapSetInfo beatmap)
+        private void delete(BeatmapSetInfo beatmap)
         {
-            if (beatmap == null)
+            if (beatmap == null) return;
-                return;
-
             dialogOverlay?.Push(new BeatmapDeleteDialog(beatmap));
         }
 
@@ -482,15 +444,16 @@ namespace osu.Game.Screens.Select
             {
                 case Key.KeypadEnter:
                 case Key.Enter:
-                    carouselRaisedStart(state);
+                    Start();
                     return true;
                 case Key.Delete:
                     if (state.Keyboard.ShiftPressed)
                     {
                         if (!Beatmap.IsDefault)
-                            promptDelete(Beatmap.Value.BeatmapSetInfo);
+                            delete(Beatmap.Value.BeatmapSetInfo);
                         return true;
                     }
+
                     break;
             }
 

osu.Game/Users/User.cs

@@ -136,5 +136,7 @@ namespace osu.Game.Users
 
         [JsonProperty(@"rankHistory")]
         public RankHistoryData RankHistory;
+
+        public override string ToString() => Username;
     }
 }

osu.Game/osu.Game.csproj

@@ -262,10 +262,7 @@
     <Compile Include="Beatmaps\ControlPoints\TimingControlPoint.cs" />
     <Compile Include="Beatmaps\DifficultyCalculator.cs" />
     <Compile Include="Beatmaps\Drawables\BeatmapBackgroundSprite.cs" />
-    <Compile Include="Beatmaps\Drawables\BeatmapGroup.cs" />
-    <Compile Include="Beatmaps\Drawables\BeatmapPanel.cs" />
     <Compile Include="Beatmaps\Drawables\BeatmapSetCover.cs" />
-    <Compile Include="Beatmaps\Drawables\BeatmapSetHeader.cs" />
     <Compile Include="Beatmaps\Formats\LegacyDecoder.cs" />
     <Compile Include="Beatmaps\Formats\LegacyStoryboardDecoder.cs" />
     <Compile Include="Database\DatabaseContextFactory.cs" />
@@ -315,13 +312,18 @@
     <Compile Include="Overlays\Profile\Sections\Ranks\DrawableTotalScore.cs" />
     <Compile Include="Overlays\Profile\Sections\Ranks\ScoreModsContainer.cs" />
     <Compile Include="Overlays\Settings\SettingsButton.cs" />
+    <Compile Include="Rulesets\Edit\Layers\Selection\OriginHandle.cs" />
+    <Compile Include="Rulesets\Edit\Layers\Selection\HitObjectSelectionBox.cs" />
+    <Compile Include="Rulesets\Edit\Layers\Selection\Handle.cs" />
+    <Compile Include="Rulesets\Edit\Layers\Selection\HandleContainer.cs" />
+    <Compile Include="Rulesets\Edit\Layers\Selection\SelectionInfo.cs" />
+    <Compile Include="Rulesets\Edit\Layers\Selection\SelectionLayer.cs" />
     <Compile Include="Screens\Edit\Components\BottomBarContainer.cs" />
     <Compile Include="Screens\Edit\Components\PlaybackControl.cs" />
     <Compile Include="Screens\Edit\Components\TimeInfoContainer.cs" />
     <Compile Include="Rulesets\Mods\IApplicableToScoreProcessor.cs" />
     <Compile Include="Beatmaps\Drawables\DifficultyColouredContainer.cs" />
     <Compile Include="Beatmaps\Drawables\DifficultyIcon.cs" />
-    <Compile Include="Beatmaps\Drawables\Panel.cs" />
     <Compile Include="Beatmaps\DummyWorkingBeatmap.cs" />
     <Compile Include="Beatmaps\Formats\Decoder.cs" />
     <Compile Include="Beatmaps\Formats\LegacyBeatmapDecoder.cs" />
@@ -352,7 +354,7 @@
     <Compile Include="Configuration\ReleaseStream.cs" />
     <Compile Include="Configuration\ScoreMeterType.cs" />
     <Compile Include="Configuration\ScreenshotFormat.cs" />
-    <Compile Include="Configuration\SelectionRandomType.cs" />
+    <Compile Include="Configuration\RandomSelectAlgorithm.cs" />
     <Compile Include="Database\DatabaseBackedStore.cs" />
     <Compile Include="Database\OsuDbContext.cs" />
     <Compile Include="Graphics\Backgrounds\Background.cs" />
@@ -728,7 +730,7 @@
     <Compile Include="Screens\Play\KeyCounterCollection.cs" />
     <Compile Include="Screens\Play\KeyCounterKeyboard.cs" />
     <Compile Include="Screens\Play\KeyCounterMouse.cs" />
-    <Compile Include="Screens\Play\MenuOverlay.cs" />
+    <Compile Include="Screens\Play\GameplayMenuOverlay.cs" />
     <Compile Include="Screens\Play\PauseContainer.cs" />
     <Compile Include="Screens\Play\Player.cs" />
     <Compile Include="Screens\Play\PlayerLoader.cs" />
@@ -761,6 +763,14 @@
     <Compile Include="Screens\Select\BeatmapDetailAreaTabControl.cs" />
     <Compile Include="Screens\Select\BeatmapDetails.cs" />
     <Compile Include="Screens\Select\BeatmapInfoWedge.cs" />
+    <Compile Include="Screens\Select\Carousel\CarouselBeatmap.cs" />
+    <Compile Include="Screens\Select\Carousel\CarouselBeatmapSet.cs" />
+    <Compile Include="Screens\Select\Carousel\CarouselGroup.cs" />
+    <Compile Include="Screens\Select\Carousel\CarouselGroupEagerSelect.cs" />
+    <Compile Include="Screens\Select\Carousel\CarouselItem.cs" />
+    <Compile Include="Screens\Select\Carousel\DrawableCarouselBeatmap.cs" />
+    <Compile Include="Screens\Select\Carousel\DrawableCarouselBeatmapSet.cs" />
+    <Compile Include="Screens\Select\Carousel\DrawableCarouselItem.cs" />
     <Compile Include="Screens\Select\Details\AdvancedStats.cs" />
     <Compile Include="Screens\Select\Details\FailRetryGraph.cs" />
     <Compile Include="Screens\Select\Details\UserRatings.cs" />

osu.sln.DotSettings

@@ -602,6 +602,7 @@ Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu-frame
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=Constants/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=EnumMember/@EntryIndexedValue">&lt;Policy Inspect="False" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=LocalConstants/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aa_bb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=LocalFunctions/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateConstants/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aa_bb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateInstanceFields/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb"&gt;&lt;ExtraRule Prefix="_" Suffix="" Style="aaBb" /&gt;&lt;/Policy&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateStaticFields/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>