Merge branch 'master' into cleanup-intros

Gemfile.lock

@@ -1,11 +1,11 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    CFPropertyList (3.0.0)
+    CFPropertyList (3.0.1)
-    addressable (2.6.0)
+    addressable (2.7.0)
-      public_suffix (>= 2.0.2, < 4.0)
+      public_suffix (>= 2.0.2, < 5.0)
     atomos (0.1.3)
-    babosa (1.0.2)
+    babosa (1.0.3)
     claide (1.0.3)
     colored (1.2)
     colored2 (3.1.2)
@@ -26,8 +26,8 @@ GEM
       http-cookie (~> 1.0.0)
     faraday_middleware (0.13.1)
       faraday (>= 0.7.4, < 1.0)
-    fastimage (2.1.5)
+    fastimage (2.1.7)
-    fastlane (2.129.0)
+    fastlane (2.131.0)
       CFPropertyList (>= 2.3, < 4.0.0)
       addressable (>= 2.3, < 3.0.0)
       babosa (>= 1.0.2, < 2.0.0)
@@ -77,9 +77,9 @@ GEM
       representable (~> 3.0)
       retriable (>= 2.0, < 4.0)
       signet (~> 0.9)
-    google-cloud-core (1.3.0)
+    google-cloud-core (1.3.1)
       google-cloud-env (~> 1.0)
-    google-cloud-env (1.2.0)
+    google-cloud-env (1.2.1)
       faraday (~> 0.11)
     google-cloud-storage (1.16.0)
       digest-crc (~> 0.4)
@@ -100,9 +100,9 @@ GEM
     json (2.2.0)
     jwt (2.1.0)
     memoist (0.16.0)
-    mime-types (3.2.2)
+    mime-types (3.3)
       mime-types-data (~> 3.2015)
-    mime-types-data (3.2019.0331)
+    mime-types-data (3.2019.0904)
     mini_magick (4.9.5)
     mini_portile2 (2.4.0)
     multi_json (1.13.1)
@@ -121,14 +121,14 @@ GEM
       uber (< 0.2.0)
     retriable (3.1.2)
     rouge (2.0.7)
-    rubyzip (1.2.3)
+    rubyzip (1.2.4)
     security (0.1.3)
     signet (0.11.0)
       addressable (~> 2.3)
       faraday (~> 0.9)
       jwt (>= 1.5, < 3.0)
       multi_json (~> 1.10)
-    simctl (1.6.5)
+    simctl (1.6.6)
       CFPropertyList
       naturally
     slack-notifier (2.3.2)

README.md

@@ -31,12 +31,10 @@ If you are not interested in developing the game, you can still consume our [bin
 
 **Latest build:**
 
-| [Windows (x64)](https://github.com/ppy/osu/releases/latest/download/install.exe)  | [macOS 10.12+](https://github.com/ppy/osu/releases/latest/download/osu.app.zip) |
+| [Windows (x64)](https://github.com/ppy/osu/releases/latest/download/install.exe)  | [macOS 10.12+](https://github.com/ppy/osu/releases/latest/download/osu.app.zip) | [iOS(iOS 10+)](https://testflight.apple.com/join/2tLcjWlF) | [Android (5+)](https://github.com/ppy/osu/releases/latest/download/sh.ppy.osulazer.apk)
-| ------------- | ------------- |
+| ------------- | ------------- | ------------- | ------------- |
 
 - **Linux** users are recommended to self-compile until we have official deployment in place.
-- **iOS** users can join the [TestFlight beta program](https://testflight.apple.com/join/2tLcjWlF) (note that due to high demand this is regularly full).
-- **Android** users can self-compile, and expect a public beta soon.
 
 If your platform is not listed above, there is still a chance you can manually build it by following the instructions below.
 

fastlane/Fastfile

@@ -1,5 +1,83 @@
 update_fastlane
 
+platform :android do
+desc 'Deploy to play store'
+  lane :beta do |options|
+
+    update_version(
+      version: options[:version],
+      build: options[:build],
+    )
+
+    build(options)
+
+    supply(
+      apk: './osu.Android/bin/Release/sh.ppy.osulazer-Signed.apk',
+      package_name: 'sh.ppy.osulazer',
+      track: 'alpha', # upload to alpha, we can promote it later
+      json_key: options[:json_key],
+    )
+  end
+
+  desc 'Deploy to github release'
+  lane :build_github do |options|
+
+    update_version(
+      version: options[:version],
+      build: options[:build],
+    )
+
+    build(options)
+
+    client = HTTPClient.new
+    changelog = client.get_content 'https://gist.githubusercontent.com/peppy/aaa2ec1a323554b619671cac6dbbb776/raw'
+    changelog.gsub!('$BUILD_ID', options[:build])
+
+    set_github_release(
+      repository_name: "ppy/osu",
+      api_token: ENV["GITHUB_TOKEN"],
+      name: options[:build],
+      tag_name: options[:build],
+      is_draft: true,
+      description: changelog,
+      commitish: "master",
+      upload_assets: ["osu.Android/bin/Release/sh.ppy.osulazer.apk"]
+    )
+
+  end
+
+  desc 'Compile the project'
+  lane :build do |options|
+    nuget_restore(
+      project_path: 'osu.Android.sln'
+    )
+
+    souyuz(
+      build_configuration: 'Release',
+      solution_path: 'osu.Android.sln',
+      platform: "android",
+      output_path: "osu.Android/bin/Release/",
+      keystore_path: options[:keystore_path],
+      keystore_alias: options[:keystore_alias],
+      keystore_password: ENV["KEYSTORE_PASSWORD"]
+    )
+  end
+
+  lane :update_version do |options|
+
+    split = options[:build].split('.')
+    split[1] = split[1].to_s.rjust(4, '0')
+    android_build = split.join('')
+
+    app_version(
+      solution_path: 'osu.Android.sln',
+      version: options[:version],
+      build: android_build,
+    )
+  end
+
+end
+
 platform :ios do
   desc 'Deploy to testflight'
   lane :beta do |options|

fastlane/README.md

@@ -15,6 +15,30 @@ Install _fastlane_ using
 or alternatively using `brew cask install fastlane`
 
 # Available Actions
+## Android
+### android beta
+```
+fastlane android beta
+```
+Deploy to play store
+### android build_github
+```
+fastlane android build_github
+```
+Deploy to github release
+### android build
+```
+fastlane android build
+```
+Compile the project
+### android update_version
+```
+fastlane android update_version
+```
+
+
+----
+
 ## iOS
 ### ios beta
 ```

osu.Android.props

@@ -62,6 +62,6 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="ppy.osu.Game.Resources" Version="2019.913.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2019.921.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2019.930.0" />
   </ItemGroup>
 </Project>

osu.Android/OsuGameAndroid.cs

@@ -4,11 +4,37 @@
 using System;
 using Android.App;
 using osu.Game;
+using osu.Game.Updater;
 
 namespace osu.Android
 {
     public class OsuGameAndroid : OsuGame
     {
-        public override Version AssemblyVersion => new Version(Application.Context.ApplicationContext.PackageManager.GetPackageInfo(Application.Context.ApplicationContext.PackageName, 0).VersionName);
+        public override Version AssemblyVersion
+        {
+            get
+            {
+                var packageInfo = Application.Context.ApplicationContext.PackageManager.GetPackageInfo(Application.Context.ApplicationContext.PackageName, 0);
+
+                try
+                {
+                    string versionName = packageInfo.VersionCode.ToString();
+                    // undo play store version garbling
+                    return new Version(int.Parse(versionName.Substring(0, 4)), int.Parse(versionName.Substring(4, 4)), int.Parse(versionName.Substring(8, 1)));
+                }
+                catch
+                {
+                }
+
+                return new Version(packageInfo.VersionName);
+            }
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Add(new SimpleUpdateManager());
+        }
     }
-}
+}

osu.Desktop/OsuGameDesktop.cs

@@ -17,6 +17,7 @@ using osu.Framework.Logging;
 using osu.Framework.Platform.Windows;
 using osu.Framework.Screens;
 using osu.Game.Screens.Menu;
+using osu.Game.Updater;
 
 namespace osu.Desktop
 {

osu.Desktop/Overlays/VersionManager.cs

@@ -8,11 +8,8 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Game;
-using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
-using osu.Game.Overlays;
-using osu.Game.Overlays.Notifications;
 using osuTK;
 using osuTK.Graphics;
 
@@ -20,17 +17,9 @@ namespace osu.Desktop.Overlays
 {
     public class VersionManager : OverlayContainer
     {
-        private OsuConfigManager config;
-        private OsuGameBase game;
-        private NotificationOverlay notificationOverlay;
-
         [BackgroundDependencyLoader]
-        private void load(NotificationOverlay notification, OsuColour colours, TextureStore textures, OsuGameBase game, OsuConfigManager config)
+        private void load(OsuColour colours, TextureStore textures, OsuGameBase game)
         {
-            notificationOverlay = notification;
-            this.config = config;
-            this.game = game;
-
             AutoSizeAxes = Axes.Both;
             Anchor = Anchor.BottomCentre;
             Origin = Anchor.BottomCentre;
@@ -85,48 +74,6 @@ namespace osu.Desktop.Overlays
             };
         }
 
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            var version = game.Version;
-            var lastVersion = config.Get<string>(OsuSetting.Version);
-
-            if (game.IsDeployedBuild && version != lastVersion)
-            {
-                config.Set(OsuSetting.Version, version);
-
-                // only show a notification if we've previously saved a version to the config file (ie. not the first run).
-                if (!string.IsNullOrEmpty(lastVersion))
-                    notificationOverlay.Post(new UpdateCompleteNotification(version));
-            }
-        }
-
-        private class UpdateCompleteNotification : SimpleNotification
-        {
-            private readonly string version;
-
-            public UpdateCompleteNotification(string version)
-            {
-                this.version = version;
-                Text = $"You are now running osu!lazer {version}.\nClick to see what's new!";
-            }
-
-            [BackgroundDependencyLoader]
-            private void load(OsuColour colours, ChangelogOverlay changelog, NotificationOverlay notificationOverlay)
-            {
-                Icon = FontAwesome.Solid.CheckSquare;
-                IconBackgound.Colour = colours.BlueDark;
-
-                Activated = delegate
-                {
-                    notificationOverlay.Hide();
-                    changelog.ShowBuild(OsuGameBase.CLIENT_STREAM_NAME, version);
-                    return true;
-                };
-            }
-        }
-
         protected override void PopIn()
         {
             this.FadeIn(1400, Easing.OutQuint);

osu.Desktop/Updater/SquirrelUpdateManager.cs

@@ -20,7 +20,7 @@ using LogLevel = Splat.LogLevel;
 
 namespace osu.Desktop.Updater
 {
-    public class SquirrelUpdateManager : Component
+    public class SquirrelUpdateManager : osu.Game.Updater.UpdateManager
     {
         private UpdateManager updateManager;
         private NotificationOverlay notificationOverlay;

osu.Desktop/osu.Desktop.csproj

@@ -23,10 +23,10 @@
     <ProjectReference Include="..\osu.Game.Rulesets.Catch\osu.Game.Rulesets.Catch.csproj" />
     <ProjectReference Include="..\osu.Game.Rulesets.Mania\osu.Game.Rulesets.Mania.csproj" />
     <ProjectReference Include="..\osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj" />
-    <PackageReference Include="Microsoft.Win32.Registry" Version="4.5.0" />
+    <PackageReference Include="Microsoft.Win32.Registry" Version="4.6.0" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="System.IO.Packaging" Version="4.5.0" />
+    <PackageReference Include="System.IO.Packaging" Version="4.6.0" />
     <PackageReference Include="ppy.squirrel.windows" Version="1.9.0.4" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.2.6" />

osu.Game.Rulesets.Catch/Objects/CatchHitObject.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Bindables;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Catch.Beatmaps;
@@ -37,9 +38,21 @@ namespace osu.Game.Rulesets.Catch.Objects
 
         public int ComboOffset { get; set; }
 
-        public int IndexInCurrentCombo { get; set; }
+        public Bindable<int> IndexInCurrentComboBindable { get; } = new Bindable<int>();
 
-        public int ComboIndex { get; set; }
+        public int IndexInCurrentCombo
+        {
+            get => IndexInCurrentComboBindable.Value;
+            set => IndexInCurrentComboBindable.Value = value;
+        }
+
+        public Bindable<int> ComboIndexBindable { get; } = new Bindable<int>();
+
+        public int ComboIndex
+        {
+            get => ComboIndexBindable.Value;
+            set => ComboIndexBindable.Value = value;
+        }
 
         /// <summary>
         /// Difference between the distance to the next object
@@ -48,10 +61,16 @@ namespace osu.Game.Rulesets.Catch.Objects
         /// </summary>
         public float DistanceToHyperDash { get; set; }
 
+        public Bindable<bool> LastInComboBindable { get; } = new Bindable<bool>();
+
         /// <summary>
         /// The next fruit starts a new combo. Used for explodey.
         /// </summary>
-        public virtual bool LastInCombo { get; set; }
+        public virtual bool LastInCombo
+        {
+            get => LastInComboBindable.Value;
+            set => LastInComboBindable.Value = value;
+        }
 
         public float Scale { get; set; } = 1;
 

osu.Game.Rulesets.Mania.Tests/ManiaPlacementBlueprintTestScene.cs

@@ -27,8 +27,13 @@ namespace osu.Game.Rulesets.Mania.Tests
         [Cached(typeof(IReadOnlyList<Mod>))]
         private IReadOnlyList<Mod> mods { get; set; } = Array.Empty<Mod>();
 
+        [Cached(typeof(IScrollingInfo))]
+        private IScrollingInfo scrollingInfo;
+
         protected ManiaPlacementBlueprintTestScene()
         {
+            scrollingInfo = ((ScrollingTestContainer)HitObjectContainer).ScrollingInfo;
+
             Add(column = new Column(0)
             {
                 Anchor = Anchor.Centre,
@@ -36,15 +41,8 @@ namespace osu.Game.Rulesets.Mania.Tests
                 AccentColour = Color4.OrangeRed,
                 Clock = new FramedClock(new StopwatchClock()), // No scroll
             });
-        }
 
-        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+            AddStep("change direction", () => ((ScrollingTestContainer)HitObjectContainer).Flip());
-        {
-            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
-
-            dependencies.CacheAs(((ScrollingTestContainer)HitObjectContainer).ScrollingInfo);
-
-            return dependencies;
         }
 
         protected override Container CreateHitObjectContainer() => new ScrollingTestContainer(ScrollingDirection.Down) { RelativeSizeAxes = Axes.Both };

osu.Game.Rulesets.Mania.Tests/TestSceneStage.cs

@@ -15,7 +15,6 @@ using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
 using osuTK;
@@ -67,6 +66,8 @@ namespace osu.Game.Rulesets.Mania.Tests
 
             AddAssert("check note anchors", () => notesInStageAreAnchored(stages[0], Anchor.TopCentre));
             AddAssert("check note anchors", () => notesInStageAreAnchored(stages[1], Anchor.BottomCentre));
+            AddAssert("check bar anchors", () => barsInStageAreAnchored(stages[0], Anchor.TopCentre));
+            AddAssert("check bar anchors", () => barsInStageAreAnchored(stages[1], Anchor.BottomCentre));
 
             AddStep("flip direction", () =>
             {
@@ -76,10 +77,14 @@ namespace osu.Game.Rulesets.Mania.Tests
 
             AddAssert("check note anchors", () => notesInStageAreAnchored(stages[0], Anchor.BottomCentre));
             AddAssert("check note anchors", () => notesInStageAreAnchored(stages[1], Anchor.TopCentre));
+            AddAssert("check bar anchors", () => barsInStageAreAnchored(stages[0], Anchor.BottomCentre));
+            AddAssert("check bar anchors", () => barsInStageAreAnchored(stages[1], Anchor.TopCentre));
         }
 
         private bool notesInStageAreAnchored(ManiaStage stage, Anchor anchor) => stage.Columns.SelectMany(c => c.AllHitObjects).All(o => o.Anchor == anchor);
 
+        private bool barsInStageAreAnchored(ManiaStage stage, Anchor anchor) => stage.AllHitObjects.Where(obj => obj is DrawableBarLine).All(o => o.Anchor == anchor);
+
         private void createNote()
         {
             foreach (var stage in stages)

osu.Game.Rulesets.Mania/Edit/Blueprints/HoldNotePlacementBlueprint.cs

@@ -3,7 +3,6 @@
 
 using System;
 using osu.Framework.Graphics;
-using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Mania.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Mania.Objects;
 using osuTK;
@@ -49,13 +48,13 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 
         private double originalStartTime;
 
-        protected override bool OnMouseMove(MouseMoveEvent e)
+        public override void UpdatePosition(Vector2 screenSpacePosition)
         {
-            base.OnMouseMove(e);
+            base.UpdatePosition(screenSpacePosition);
 
             if (PlacementBegun)
             {
-                var endTime = TimeAt(e.ScreenSpaceMousePosition);
+                var endTime = TimeAt(screenSpacePosition);
 
                 HitObject.StartTime = endTime < originalStartTime ? endTime : originalStartTime;
                 HitObject.Duration = Math.Abs(endTime - originalStartTime);
@@ -65,10 +64,8 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
                 headPiece.Width = tailPiece.Width = SnappedWidth;
                 headPiece.X = tailPiece.X = SnappedMousePosition.X;
 
-                originalStartTime = HitObject.StartTime = TimeAt(e.ScreenSpaceMousePosition);
+                originalStartTime = HitObject.StartTime = TimeAt(screenSpacePosition);
             }
-
-            return true;
         }
     }
 }

osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaPlacementBlueprint.cs

@@ -62,19 +62,18 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             return base.OnMouseUp(e);
         }
 
-        protected override bool OnMouseMove(MouseMoveEvent e)
+        public override void UpdatePosition(Vector2 screenSpacePosition)
         {
             if (!PlacementBegun)
-                Column = ColumnAt(e.ScreenSpaceMousePosition);
+                Column = ColumnAt(screenSpacePosition);
 
-            if (Column == null) return false;
+            if (Column == null) return;
 
             SnappedWidth = Column.DrawWidth;
 
             // Snap to the column
             var parentPos = Parent.ToLocalSpace(Column.ToScreenSpace(new Vector2(Column.DrawWidth / 2, 0)));
-            SnappedMousePosition = new Vector2(parentPos.X, e.MousePosition.Y);
+            SnappedMousePosition = new Vector2(parentPos.X, Parent.ToLocalSpace(screenSpacePosition).Y);
-            return true;
         }
 
         protected double TimeAt(Vector2 screenSpacePosition)
@@ -86,7 +85,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 
             // If we're scrolling downwards, a position of 0 is actually further away from the hit target
             // so we need to flip the vertical coordinate in the hitobject container's space
-            var hitObjectPos = Column.HitObjectContainer.ToLocalSpace(applyPositionOffset(screenSpacePosition, false)).Y;
+            var hitObjectPos = mouseToHitObjectPosition(Column.HitObjectContainer.ToLocalSpace(screenSpacePosition)).Y;
             if (scrollingInfo.Direction.Value == ScrollingDirection.Down)
                 hitObjectPos = hitObjectContainer.DrawHeight - hitObjectPos;
 
@@ -103,16 +102,58 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
                 scrollingInfo.TimeRange.Value,
                 Column.HitObjectContainer.DrawHeight);
 
-            return applyPositionOffset(Column.HitObjectContainer.ToSpaceOfOtherDrawable(new Vector2(0, pos), Parent), true).Y;
+            if (scrollingInfo.Direction.Value == ScrollingDirection.Down)
+                pos = Column.HitObjectContainer.DrawHeight - pos;
+
+            return hitObjectToMousePosition(Column.HitObjectContainer.ToSpaceOfOtherDrawable(new Vector2(0, pos), Parent)).Y;
         }
 
         protected Column ColumnAt(Vector2 screenSpacePosition)
-            => composer.ColumnAt(applyPositionOffset(screenSpacePosition, false));
+            => composer.ColumnAt(screenSpacePosition);
 
-        private Vector2 applyPositionOffset(Vector2 position, bool reverse)
+        /// <summary>
+        /// Converts a mouse position to a hitobject position.
+        /// </summary>
+        /// <remarks>
+        /// Blueprints are centred on the mouse position, such that the hitobject position is anchored at the top or bottom of the blueprint depending on the scroll direction.
+        /// </remarks>
+        /// <param name="mousePosition">The mouse position.</param>
+        /// <returns>The resulting hitobject position, acnhored at the top or bottom of the blueprint depending on the scroll direction.</returns>
+        private Vector2 mouseToHitObjectPosition(Vector2 mousePosition)
         {
-            position.Y += (scrollingInfo.Direction.Value == ScrollingDirection.Up && !reverse ? -1 : 1) * NotePiece.NOTE_HEIGHT / 2;
+            switch (scrollingInfo.Direction.Value)
-            return position;
+            {
+                case ScrollingDirection.Up:
+                    mousePosition.Y -= NotePiece.NOTE_HEIGHT / 2;
+                    break;
+
+                case ScrollingDirection.Down:
+                    mousePosition.Y += NotePiece.NOTE_HEIGHT / 2;
+                    break;
+            }
+
+            return mousePosition;
+        }
+
+        /// <summary>
+        /// Converts a hitobject position to a mouse position.
+        /// </summary>
+        /// <param name="hitObjectPosition">The hitobject position.</param>
+        /// <returns>The resulting mouse position, anchored at the centre of the hitobject.</returns>
+        private Vector2 hitObjectToMousePosition(Vector2 hitObjectPosition)
+        {
+            switch (scrollingInfo.Direction.Value)
+            {
+                case ScrollingDirection.Up:
+                    hitObjectPosition.Y += NotePiece.NOTE_HEIGHT / 2;
+                    break;
+
+                case ScrollingDirection.Down:
+                    hitObjectPosition.Y -= NotePiece.NOTE_HEIGHT / 2;
+                    break;
+            }
+
+            return hitObjectPosition;
         }
     }
 }

osu.Game.Rulesets.Mania/Objects/BarLine.cs

@@ -0,0 +1,12 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Rulesets.Mania.Objects
+{
+    public class BarLine : ManiaHitObject, IBarLine
+    {
+        public bool Major { get; set; }
+    }
+}

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableBarLine.cs

@@ -4,7 +4,6 @@
 using osuTK;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osuTK.Graphics;
 
@@ -14,7 +13,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
     /// Visualises a <see cref="BarLine"/>. Although this derives DrawableManiaHitObject,
     /// this does not handle input/sound like a normal hit object.
     /// </summary>
-    public class DrawableBarLine : DrawableHitObject<BarLine>
+    public class DrawableBarLine : DrawableManiaHitObject<BarLine>
     {
         /// <summary>
         /// Height of major bar line triangles.

osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs

@@ -42,7 +42,7 @@ namespace osu.Game.Rulesets.Mania.UI
         public DrawableManiaRuleset(Ruleset ruleset, IWorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
             : base(ruleset, beatmap, mods)
         {
-            BarLines = new BarLineGenerator(Beatmap).BarLines;
+            BarLines = new BarLineGenerator<BarLine>(Beatmap).BarLines;
         }
 
         [BackgroundDependencyLoader]

osu.Game.Rulesets.Mania/UI/ManiaPlayfield.cs

@@ -8,7 +8,6 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 using osuTK;

osu.Game.Rulesets.Mania/UI/ManiaStage.cs

@@ -12,7 +12,6 @@ using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;

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

@@ -7,6 +7,7 @@ using System.Linq;
 using System.Text;
 using NUnit.Framework;
 using osu.Game.Beatmaps;
+using osu.Game.IO;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Tests.Beatmaps;
@@ -21,7 +22,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         public void TestStacking()
         {
             using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(beatmap_data)))
-            using (var reader = new StreamReader(stream))
+            using (var reader = new LineBufferedReader(stream))
             {
                 var beatmap = Decoder.GetDecoder<Beatmap>(reader).Decode(reader);
                 var converted = new TestWorkingBeatmap(beatmap).GetPlayableBeatmap(new OsuRuleset().RulesetInfo, Array.Empty<Mod>());

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

@@ -0,0 +1,26 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestSceneHitCircleComboChange : TestSceneHitCircle
+    {
+        private readonly Bindable<int> comboIndex = new Bindable<int>();
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            Scheduler.AddDelayed(() => comboIndex.Value++, 250, true);
+        }
+
+        protected override TestDrawableHitCircle CreateDrawableHitCircle(HitCircle circle, bool auto)
+        {
+            circle.ComboIndexBindable.BindTo(comboIndex);
+            circle.IndexInCurrentComboBindable.BindTo(comboIndex);
+            return base.CreateDrawableHitCircle(circle, auto);
+        }
+    }
+}

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

@@ -297,11 +297,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             slider.ApplyDefaults(cpi, new BeatmapDifficulty { CircleSize = circleSize, SliderTickRate = 3 });
 
-            var drawable = new DrawableSlider(slider)
+            var drawable = CreateDrawableSlider(slider);
-            {
-                Anchor = Anchor.Centre,
-                Depth = depthIndex++
-            };
 
             foreach (var mod in Mods.Value.OfType<IApplicableToDrawableHitObjects>())
                 mod.ApplyToDrawableHitObjects(new[] { drawable });
@@ -311,6 +307,12 @@ namespace osu.Game.Rulesets.Osu.Tests
             return drawable;
         }
 
+        protected virtual DrawableSlider CreateDrawableSlider(Slider slider) => new DrawableSlider(slider)
+        {
+            Anchor = Anchor.Centre,
+            Depth = depthIndex++
+        };
+
         private float judgementOffsetDirection = 1;
 
         private void onNewResult(DrawableHitObject judgedObject, JudgementResult result)

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

@@ -0,0 +1,28 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestSceneSliderComboChange : TestSceneSlider
+    {
+        private readonly Bindable<int> comboIndex = new Bindable<int>();
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            Scheduler.AddDelayed(() => comboIndex.Value++, 250, true);
+        }
+
+        protected override DrawableSlider CreateDrawableSlider(Slider slider)
+        {
+            slider.ComboIndexBindable.BindTo(comboIndex);
+            slider.IndexInCurrentComboBindable.BindTo(comboIndex);
+
+            return base.CreateDrawableSlider(slider);
+        }
+    }
+}

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

@@ -0,0 +1,96 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.MathUtils;
+using osu.Framework.Testing;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Tests.Visual;
+using osuTK;
+using System.Collections.Generic;
+using System.Linq;
+using static osu.Game.Tests.Visual.OsuTestScene.ClockBackedTestWorkingBeatmap;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestSceneSpinnerRotation : TestSceneOsuPlayer
+    {
+        [Resolved]
+        private AudioManager audioManager { get; set; }
+
+        private TrackVirtualManual track;
+
+        protected override bool Autoplay => true;
+
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap)
+        {
+            var working = new ClockBackedTestWorkingBeatmap(beatmap, new FramedClock(new ManualClock { Rate = 1 }), audioManager);
+            track = (TrackVirtualManual)working.Track;
+            return working;
+        }
+
+        private DrawableSpinner drawableSpinner;
+
+        [SetUpSteps]
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddUntilStep("wait for track to start running", () => track.IsRunning);
+            AddStep("retrieve spinner", () => drawableSpinner = (DrawableSpinner)((TestPlayer)Player).DrawableRuleset.Playfield.AllHitObjects.First());
+        }
+
+        [Test]
+        public void TestSpinnerRewindingRotation()
+        {
+            addSeekStep(5000);
+            AddAssert("is rotation absolute not almost 0", () => !Precision.AlmostEquals(drawableSpinner.Disc.RotationAbsolute, 0, 100));
+
+            addSeekStep(0);
+            AddAssert("is rotation absolute almost 0", () => Precision.AlmostEquals(drawableSpinner.Disc.RotationAbsolute, 0, 100));
+        }
+
+        [Test]
+        public void TestSpinnerMiddleRewindingRotation()
+        {
+            double estimatedRotation = 0;
+
+            addSeekStep(5000);
+            AddStep("retrieve rotation", () => estimatedRotation = drawableSpinner.Disc.RotationAbsolute);
+
+            addSeekStep(2500);
+            addSeekStep(5000);
+            AddAssert("is rotation absolute almost same", () => Precision.AlmostEquals(drawableSpinner.Disc.RotationAbsolute, estimatedRotation, 100));
+        }
+
+        private void addSeekStep(double time)
+        {
+            AddStep($"seek to {time}", () => track.Seek(time));
+
+            AddUntilStep("wait for seek to finish", () => Precision.AlmostEquals(time, ((TestPlayer)Player).DrawableRuleset.FrameStableClock.CurrentTime, 100));
+        }
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new Beatmap
+        {
+            HitObjects = new List<HitObject>
+            {
+                new Spinner
+                {
+                    Position = new Vector2(256, 192),
+                    EndTime = 5000,
+                },
+                // placeholder object to avoid hitting the results screen
+                new HitObject
+                {
+                    StartTime = 99999,
+                }
+            }
+        };
+    }
+}

osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/HitCirclePlacementBlueprint.cs

@@ -19,14 +19,6 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles
             InternalChild = new HitCirclePiece(HitObject);
         }
 
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            // Fixes a 1-frame position discrepancy due to the first mouse move event happening in the next frame
-            HitObject.Position = Parent?.ToLocalSpace(GetContainingInputManager().CurrentState.Mouse.Position) ?? Vector2.Zero;
-        }
-
         protected override bool OnClick(ClickEvent e)
         {
             HitObject.StartTime = EditorClock.CurrentTime;
@@ -34,10 +26,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles
             return true;
         }
 
-        protected override bool OnMouseMove(MouseMoveEvent e)
+        public override void UpdatePosition(Vector2 screenSpacePosition)
         {
-            HitObject.Position = e.MousePosition;
+            HitObject.Position = ToLocalSpace(screenSpacePosition);
-            return true;
         }
     }
 }

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs

@@ -47,28 +47,18 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             setState(PlacementState.Initial);
         }
 
-        protected override void LoadComplete()
+        public override void UpdatePosition(Vector2 screenSpacePosition)
-        {
-            base.LoadComplete();
-
-            // Fixes a 1-frame position discrepancy due to the first mouse move event happening in the next frame
-            HitObject.Position = Parent?.ToLocalSpace(GetContainingInputManager().CurrentState.Mouse.Position) ?? Vector2.Zero;
-        }
-
-        protected override bool OnMouseMove(MouseMoveEvent e)
         {
             switch (state)
             {
                 case PlacementState.Initial:
-                    HitObject.Position = e.MousePosition;
+                    HitObject.Position = ToLocalSpace(screenSpacePosition);
-                    return true;
+                    break;
 
                 case PlacementState.Body:
-                    cursor = e.MousePosition - HitObject.Position;
+                    cursor = ToLocalSpace(screenSpacePosition) - HitObject.Position;
-                    return true;
+                    break;
             }
-
-            return false;
         }
 
         protected override bool OnClick(ClickEvent e)

osu.Game.Rulesets.Osu/Edit/Blueprints/Spinners/SpinnerPlacementBlueprint.cs

@@ -7,6 +7,7 @@ using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.UI;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners
 {
@@ -43,5 +44,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners
 
             return true;
         }
+
+        public override void UpdatePosition(Vector2 screenSpacePosition)
+        {
+        }
     }
 }

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

@@ -59,7 +59,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                                 return true;
                             },
                         },
-                        CirclePiece = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.HitCircle), _ => new MainCirclePiece(HitObject.IndexInCurrentCombo)),
+                        CirclePiece = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.HitCircle), _ => new MainCirclePiece()),
                         ApproachCircle = new ApproachCircle
                         {
                             Alpha = 0,

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

@@ -20,7 +20,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
         private readonly NumberPiece number;
         private readonly GlowPiece glow;
 
-        public MainCirclePiece(int index)
+        public MainCirclePiece()
         {
             Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
 
@@ -31,10 +31,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             {
                 glow = new GlowPiece(),
                 circle = new CirclePiece(),
-                number = new NumberPiece
+                number = new NumberPiece(),
-                {
-                    Text = (index + 1).ToString(),
-                },
                 ring = new RingPiece(),
                 flash = new FlashPiece(),
                 explode = new ExplodePiece(),
@@ -42,12 +39,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
         }
 
         private readonly IBindable<ArmedState> state = new Bindable<ArmedState>();
-
+        private readonly IBindable<Color4> accentColour = new Bindable<Color4>();
-        private readonly Bindable<Color4> accentColour = new Bindable<Color4>();
+        private readonly IBindable<int> indexInCurrentCombo = new Bindable<int>();
 
         [BackgroundDependencyLoader]
         private void load(DrawableHitObject drawableObject)
         {
+            OsuHitObject osuObject = (OsuHitObject)drawableObject.HitObject;
+
             state.BindTo(drawableObject.State);
             state.BindValueChanged(updateState, true);
 
@@ -58,6 +57,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                 glow.Colour = colour.NewValue;
                 circle.Colour = colour.NewValue;
             }, true);
+
+            indexInCurrentCombo.BindTo(osuObject.IndexInCurrentComboBindable);
+            indexInCurrentCombo.BindValueChanged(index => number.Text = (index.NewValue + 1).ToString(), true);
         }
 
         private void updateState(ValueChangedEvent<ArmedState> state)

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

@@ -111,7 +111,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                     lastAngle -= 360;
 
                 currentRotation += thisAngle - lastAngle;
-                RotationAbsolute += Math.Abs(thisAngle - lastAngle);
+                RotationAbsolute += Math.Abs(thisAngle - lastAngle) * Math.Sign(Clock.ElapsedFrameTime);
             }
 
             lastAngle = thisAngle;

osu.Game.Rulesets.Osu/Objects/OsuHitObject.cs

@@ -58,13 +58,37 @@ namespace osu.Game.Rulesets.Osu.Objects
 
         public virtual bool NewCombo { get; set; }
 
-        public int ComboOffset { get; set; }
+        public readonly Bindable<int> ComboOffsetBindable = new Bindable<int>();
 
-        public virtual int IndexInCurrentCombo { get; set; }
+        public int ComboOffset
+        {
+            get => ComboOffsetBindable.Value;
+            set => ComboOffsetBindable.Value = value;
+        }
 
-        public virtual int ComboIndex { get; set; }
+        public Bindable<int> IndexInCurrentComboBindable { get; } = new Bindable<int>();
 
-        public bool LastInCombo { get; set; }
+        public virtual int IndexInCurrentCombo
+        {
+            get => IndexInCurrentComboBindable.Value;
+            set => IndexInCurrentComboBindable.Value = value;
+        }
+
+        public Bindable<int> ComboIndexBindable { get; } = new Bindable<int>();
+
+        public virtual int ComboIndex
+        {
+            get => ComboIndexBindable.Value;
+            set => ComboIndexBindable.Value = value;
+        }
+
+        public Bindable<bool> LastInComboBindable { get; } = new Bindable<bool>();
+
+        public bool LastInCombo
+        {
+            get => LastInComboBindable.Value;
+            set => LastInComboBindable.Value = value;
+        }
 
         protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
         {

osu.Game.Rulesets.Osu/Objects/Slider.cs

@@ -33,28 +33,6 @@ namespace osu.Game.Rulesets.Osu.Objects
 
         public Vector2 StackedPositionAt(double t) => StackedPosition + this.CurvePositionAt(t);
 
-        public override int ComboIndex
-        {
-            get => base.ComboIndex;
-            set
-            {
-                base.ComboIndex = value;
-                foreach (var n in NestedHitObjects.OfType<IHasComboInformation>())
-                    n.ComboIndex = value;
-            }
-        }
-
-        public override int IndexInCurrentCombo
-        {
-            get => base.IndexInCurrentCombo;
-            set
-            {
-                base.IndexInCurrentCombo = value;
-                foreach (var n in NestedHitObjects.OfType<IHasComboInformation>())
-                    n.IndexInCurrentCombo = value;
-            }
-        }
-
         public readonly Bindable<SliderPath> PathBindable = new Bindable<SliderPath>();
 
         public SliderPath Path
@@ -192,8 +170,6 @@ namespace osu.Game.Rulesets.Osu.Objects
                             Position = Position,
                             Samples = getNodeSamples(0),
                             SampleControlPoint = SampleControlPoint,
-                            IndexInCurrentCombo = IndexInCurrentCombo,
-                            ComboIndex = ComboIndex,
                         });
                         break;
 
@@ -205,8 +181,6 @@ namespace osu.Game.Rulesets.Osu.Objects
                         {
                             StartTime = e.Time,
                             Position = EndPosition,
-                            IndexInCurrentCombo = IndexInCurrentCombo,
-                            ComboIndex = ComboIndex,
                         });
                         break;
 

osu.Game.Rulesets.Osu/Skinning/LegacyMainCirclePiece.cs

@@ -9,7 +9,6 @@ using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Skinning;
 using osuTK;
@@ -25,13 +24,16 @@ namespace osu.Game.Rulesets.Osu.Skinning
         }
 
         private readonly IBindable<ArmedState> state = new Bindable<ArmedState>();
-
         private readonly Bindable<Color4> accentColour = new Bindable<Color4>();
+        private readonly IBindable<int> indexInCurrentCombo = new Bindable<int>();
 
         [BackgroundDependencyLoader]
         private void load(DrawableHitObject drawableObject, ISkinSource skin)
         {
+            OsuHitObject osuObject = (OsuHitObject)drawableObject.HitObject;
+
             Sprite hitCircleSprite;
+            SkinnableSpriteText hitCircleText;
 
             InternalChildren = new Drawable[]
             {
@@ -42,14 +44,11 @@ namespace osu.Game.Rulesets.Osu.Skinning
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                 },
-                new SkinnableSpriteText(new OsuSkinComponent(OsuSkinComponents.HitCircleText), _ => new OsuSpriteText
+                hitCircleText = new SkinnableSpriteText(new OsuSkinComponent(OsuSkinComponents.HitCircleText), _ => new OsuSpriteText
                 {
                     Font = OsuFont.Numeric.With(size: 40),
                     UseFullGlyphHeight = false,
-                }, confineMode: ConfineMode.NoScaling)
+                }, confineMode: ConfineMode.NoScaling),
-                {
-                    Text = (((IHasComboInformation)drawableObject.HitObject).IndexInCurrentCombo + 1).ToString()
-                },
                 new Sprite
                 {
                     Texture = skin.GetTexture("hitcircleoverlay"),
@@ -63,6 +62,9 @@ namespace osu.Game.Rulesets.Osu.Skinning
 
             accentColour.BindTo(drawableObject.AccentColour);
             accentColour.BindValueChanged(colour => hitCircleSprite.Colour = colour.NewValue, true);
+
+            indexInCurrentCombo.BindTo(osuObject.IndexInCurrentComboBindable);
+            indexInCurrentCombo.BindValueChanged(index => hitCircleText.Text = (index.NewValue + 1).ToString(), true);
         }
 
         private void updateState(ValueChangedEvent<ArmedState> state)

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

@@ -40,9 +40,8 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
 
             for (int i = 0; i < max_sprites; i++)
             {
-                // InvalidationID 1 forces an update of each part of the cursor trail the first time ApplyState is run on the draw node
+                // -1 signals that the part is unusable, and should not be drawn
-                // This is to prevent garbage data from being sent to the vertex shader, resulting in visual issues on some platforms
+                parts[i].InvalidationID = -1;
-                parts[i].InvalidationID = 1;
             }
         }
 
@@ -112,7 +111,9 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
             for (int i = 0; i < parts.Length; ++i)
             {
                 parts[i].Time -= time;
-                ++parts[i].InvalidationID;
+
+                if (parts[i].InvalidationID != -1)
+                    ++parts[i].InvalidationID;
             }
 
             time = 0;
@@ -205,8 +206,6 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
             public TrailDrawNode(CursorTrail source)
                 : base(source)
             {
-                for (int i = 0; i < max_sprites; i++)
-                    parts[i].InvalidationID = 0;
             }
 
             public override void ApplyState()
@@ -218,11 +217,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                 size = Source.partSize;
                 time = Source.time;
 
-                for (int i = 0; i < Source.parts.Length; ++i)
+                Source.parts.CopyTo(parts, 0);
-                {
-                    if (Source.parts[i].InvalidationID > parts[i].InvalidationID)
-                        parts[i] = Source.parts[i];
-                }
             }
 
             public override void Draw(Action<TexturedVertex2D> vertexAction)
@@ -234,6 +229,9 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
 
                 for (int i = 0; i < parts.Length; ++i)
                 {
+                    if (parts[i].InvalidationID == -1)
+                        continue;
+
                     vertexBatch.DrawTime = parts[i].Time;
 
                     Vector2 pos = parts[i].Position;

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

@@ -40,6 +40,11 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
         private void load(OsuRulesetConfigManager config)
         {
             config?.BindWith(OsuRulesetSetting.ShowCursorTrail, showTrail);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
 
             showTrail.BindValueChanged(v => cursorTrail.FadeTo(v.NewValue ? 1 : 0, 200), true);
         }

osu.Game.Rulesets.Taiko.Tests/TestSceneTaikoPlayfield.cs

@@ -53,6 +53,11 @@ namespace osu.Game.Rulesets.Taiko.Tests
             AddStep("Strong Rim", () => addRimHit(true));
             AddStep("Add bar line", () => addBarLine(false));
             AddStep("Add major bar line", () => addBarLine(true));
+            AddStep("Add centre w/ bar line", () =>
+            {
+                addCentreHit(false);
+                addBarLine(true);
+            });
             AddStep("Height test 1", () => changePlayfieldSize(1));
             AddStep("Height test 2", () => changePlayfieldSize(2));
             AddStep("Height test 3", () => changePlayfieldSize(3));

osu.Game.Rulesets.Taiko/Objects/BarLine.cs

@@ -0,0 +1,12 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Rulesets.Taiko.Objects
+{
+    public class BarLine : TaikoHitObject, IBarLine
+    {
+        public bool Major { get; set; }
+    }
+}

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableBarLineMajor.cs

@@ -5,7 +5,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osuTK;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {

osu.Game.Rulesets.Taiko/UI/DrawableTaikoRuleset.cs

@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Taiko.UI
         [BackgroundDependencyLoader]
         private void load()
         {
-            new BarLineGenerator(Beatmap).BarLines.ForEach(bar => Playfield.Add(bar.Major ? new DrawableBarLineMajor(bar) : new DrawableBarLine(bar)));
+            new BarLineGenerator<BarLine>(Beatmap).BarLines.ForEach(bar => Playfield.Add(bar.Major ? new DrawableBarLineMajor(bar) : new DrawableBarLine(bar)));
         }
 
         public override ScoreProcessor CreateScoreProcessor() => new TaikoScoreProcessor(this);

osu.Game.Tests/Beatmaps/EditorBeatmapTest.cs

@@ -0,0 +1,154 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using Microsoft.EntityFrameworkCore.Internal;
+using NUnit.Framework;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit;
+
+namespace osu.Game.Tests.Beatmaps
+{
+    [TestFixture]
+    public class EditorBeatmapTest
+    {
+        /// <summary>
+        /// Tests that the addition event is correctly invoked after a hitobject is added.
+        /// </summary>
+        [Test]
+        public void TestHitObjectAddEvent()
+        {
+            var editorBeatmap = new EditorBeatmap<OsuHitObject>(new OsuBeatmap());
+
+            HitObject addedObject = null;
+            editorBeatmap.HitObjectAdded += h => addedObject = h;
+
+            var hitCircle = new HitCircle();
+
+            editorBeatmap.Add(hitCircle);
+            Assert.That(addedObject, Is.EqualTo(hitCircle));
+        }
+
+        /// <summary>
+        /// Tests that the removal event is correctly invoked after a hitobject is removed.
+        /// </summary>
+        [Test]
+        public void HitObjectRemoveEvent()
+        {
+            var hitCircle = new HitCircle();
+            var editorBeatmap = new EditorBeatmap<OsuHitObject>(new OsuBeatmap { HitObjects = { hitCircle } });
+
+            HitObject removedObject = null;
+            editorBeatmap.HitObjectRemoved += h => removedObject = h;
+
+            editorBeatmap.Remove(hitCircle);
+            Assert.That(removedObject, Is.EqualTo(hitCircle));
+        }
+
+        /// <summary>
+        /// Tests that the changed event is correctly invoked after the start time of a hitobject is changed.
+        /// This tests for hitobjects which were already present before the editor beatmap was constructed.
+        /// </summary>
+        [Test]
+        public void TestInitialHitObjectStartTimeChangeEvent()
+        {
+            var hitCircle = new HitCircle();
+            var editorBeatmap = new EditorBeatmap<OsuHitObject>(new OsuBeatmap { HitObjects = { hitCircle } });
+
+            HitObject changedObject = null;
+            editorBeatmap.StartTimeChanged += h => changedObject = h;
+
+            hitCircle.StartTime = 1000;
+            Assert.That(changedObject, Is.EqualTo(hitCircle));
+        }
+
+        /// <summary>
+        /// Tests that the changed event is correctly invoked after the start time of a hitobject is changed.
+        /// This tests for hitobjects which were added to an existing editor beatmap.
+        /// </summary>
+        [Test]
+        public void TestAddedHitObjectStartTimeChangeEvent()
+        {
+            var editorBeatmap = new EditorBeatmap<OsuHitObject>(new OsuBeatmap());
+
+            HitObject changedObject = null;
+            editorBeatmap.StartTimeChanged += h => changedObject = h;
+
+            var hitCircle = new HitCircle();
+
+            editorBeatmap.Add(hitCircle);
+            Assert.That(changedObject, Is.Null);
+
+            hitCircle.StartTime = 1000;
+            Assert.That(changedObject, Is.EqualTo(hitCircle));
+        }
+
+        /// <summary>
+        /// Tests that the channged event is not invoked after a hitobject is removed from the beatmap/
+        /// </summary>
+        [Test]
+        public void TestRemovedHitObjectStartTimeChangeEvent()
+        {
+            var hitCircle = new HitCircle();
+            var editorBeatmap = new EditorBeatmap<OsuHitObject>(new OsuBeatmap { HitObjects = { hitCircle } });
+
+            HitObject changedObject = null;
+            editorBeatmap.StartTimeChanged += h => changedObject = h;
+
+            editorBeatmap.Remove(hitCircle);
+            Assert.That(changedObject, Is.Null);
+
+            hitCircle.StartTime = 1000;
+            Assert.That(changedObject, Is.Null);
+        }
+
+        /// <summary>
+        /// Tests that an added hitobject is correctly inserted to preserve the sorting order of the beatmap.
+        /// </summary>
+        [Test]
+        public void TestAddHitObjectInMiddle()
+        {
+            var editorBeatmap = new EditorBeatmap<OsuHitObject>(new OsuBeatmap
+            {
+                HitObjects =
+                {
+                    new HitCircle(),
+                    new HitCircle { StartTime = 1000 },
+                    new HitCircle { StartTime = 1000 },
+                    new HitCircle { StartTime = 2000 },
+                }
+            });
+
+            var hitCircle = new HitCircle { StartTime = 1000 };
+            editorBeatmap.Add(hitCircle);
+            Assert.That(editorBeatmap.HitObjects.Count(h => h == hitCircle), Is.EqualTo(1));
+            Assert.That(editorBeatmap.HitObjects.IndexOf(hitCircle), Is.EqualTo(3));
+        }
+
+        /// <summary>
+        /// Tests that the beatmap remains correctly sorted after the start time of a hitobject is changed.
+        /// </summary>
+        [Test]
+        public void TestResortWhenStartTimeChanged()
+        {
+            var hitCircle = new HitCircle { StartTime = 1000 };
+            var editorBeatmap = new EditorBeatmap<OsuHitObject>(new OsuBeatmap
+            {
+                HitObjects =
+                {
+                    new HitCircle(),
+                    new HitCircle { StartTime = 1000 },
+                    new HitCircle { StartTime = 1000 },
+                    hitCircle,
+                    new HitCircle { StartTime = 2000 },
+                }
+            });
+
+            hitCircle.StartTime = 0;
+            Assert.That(editorBeatmap.HitObjects.Count(h => h == hitCircle), Is.EqualTo(1));
+            Assert.That(editorBeatmap.HitObjects.IndexOf(hitCircle), Is.EqualTo(1));
+        }
+    }
+}

osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapDecoderTest.cs

@@ -13,6 +13,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.Beatmaps.Timing;
+using osu.Game.IO;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
@@ -30,13 +31,9 @@ namespace osu.Game.Tests.Beatmaps.Formats
         public void TestDecodeBeatmapVersion()
         {
             using (var resStream = TestResources.OpenResource("beatmap-version.osu"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var decoder = Decoder.GetDecoder<Beatmap>(stream);
-
-                stream.BaseStream.Position = 0;
-                stream.DiscardBufferedData();
-
                 var working = new TestWorkingBeatmap(decoder.Decode(stream));
 
                 Assert.AreEqual(6, working.BeatmapInfo.BeatmapVersion);
@@ -51,7 +48,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
 
             using (var resStream = TestResources.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var beatmap = decoder.Decode(stream);
                 var beatmapInfo = beatmap.BeatmapInfo;
@@ -75,7 +72,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LegacyBeatmapDecoder();
 
             using (var resStream = TestResources.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var beatmapInfo = decoder.Decode(stream).BeatmapInfo;
 
@@ -101,7 +98,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LegacyBeatmapDecoder();
 
             using (var resStream = TestResources.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var beatmap = decoder.Decode(stream);
                 var beatmapInfo = beatmap.BeatmapInfo;
@@ -126,7 +123,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LegacyBeatmapDecoder();
 
             using (var resStream = TestResources.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var difficulty = decoder.Decode(stream).BeatmapInfo.BaseDifficulty;
 
@@ -145,7 +142,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
 
             using (var resStream = TestResources.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var beatmap = decoder.Decode(stream);
                 var metadata = beatmap.Metadata;
@@ -164,7 +161,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
 
             using (var resStream = TestResources.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var beatmap = decoder.Decode(stream);
                 var controlPoints = beatmap.ControlPointInfo;
@@ -239,7 +236,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
 
             using (var resStream = TestResources.OpenResource("overlapping-control-points.osu"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var controlPoints = decoder.Decode(stream).ControlPointInfo;
 
@@ -271,7 +268,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LegacySkinDecoder();
 
             using (var resStream = TestResources.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var comboColors = decoder.Decode(stream).ComboColours;
 
@@ -297,7 +294,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LegacyBeatmapDecoder();
 
             using (var resStream = TestResources.OpenResource("hitobject-combo-offset.osu"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var beatmap = decoder.Decode(stream);
 
@@ -320,7 +317,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LegacyBeatmapDecoder();
 
             using (var resStream = TestResources.OpenResource("hitobject-combo-offset.osu"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var beatmap = decoder.Decode(stream);
 
@@ -343,7 +340,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
 
             using (var resStream = TestResources.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var hitObjects = decoder.Decode(stream).HitObjects;
 
@@ -371,7 +368,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
 
             using (var resStream = TestResources.OpenResource("controlpoint-custom-samplebank.osu"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var hitObjects = decoder.Decode(stream).HitObjects;
 
@@ -393,7 +390,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
 
             using (var resStream = TestResources.OpenResource("hitobject-custom-samplebank.osu"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var hitObjects = decoder.Decode(stream).HitObjects;
 
@@ -411,7 +408,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
 
             using (var resStream = TestResources.OpenResource("hitobject-file-samples.osu"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var hitObjects = decoder.Decode(stream).HitObjects;
 
@@ -431,7 +428,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
 
             using (var resStream = TestResources.OpenResource("slider-samples.osu"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var hitObjects = decoder.Decode(stream).HitObjects;
 
@@ -475,7 +472,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
 
             using (var resStream = TestResources.OpenResource("hitobject-no-addition-bank.osu"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var hitObjects = decoder.Decode(stream).HitObjects;
 
@@ -489,10 +486,132 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
 
             using (var badResStream = TestResources.OpenResource("invalid-events.osu"))
-            using (var badStream = new StreamReader(badResStream))
+            using (var badStream = new LineBufferedReader(badResStream))
             {
                 Assert.DoesNotThrow(() => decoder.Decode(badStream));
             }
         }
+
+        [Test]
+        public void TestFallbackDecoderForCorruptedHeader()
+        {
+            Decoder<Beatmap> decoder = null;
+            Beatmap beatmap = null;
+
+            using (var resStream = TestResources.OpenResource("corrupted-header.osu"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                Assert.DoesNotThrow(() => decoder = Decoder.GetDecoder<Beatmap>(stream));
+                Assert.IsInstanceOf<LegacyBeatmapDecoder>(decoder);
+                Assert.DoesNotThrow(() => beatmap = decoder.Decode(stream));
+                Assert.IsNotNull(beatmap);
+                Assert.AreEqual("Beatmap with corrupted header", beatmap.Metadata.Title);
+                Assert.AreEqual("Evil Hacker", beatmap.Metadata.AuthorString);
+            }
+        }
+
+        [Test]
+        public void TestFallbackDecoderForMissingHeader()
+        {
+            Decoder<Beatmap> decoder = null;
+            Beatmap beatmap = null;
+
+            using (var resStream = TestResources.OpenResource("missing-header.osu"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                Assert.DoesNotThrow(() => decoder = Decoder.GetDecoder<Beatmap>(stream));
+                Assert.IsInstanceOf<LegacyBeatmapDecoder>(decoder);
+                Assert.DoesNotThrow(() => beatmap = decoder.Decode(stream));
+                Assert.IsNotNull(beatmap);
+                Assert.AreEqual("Beatmap with no header", beatmap.Metadata.Title);
+                Assert.AreEqual("Incredibly Evil Hacker", beatmap.Metadata.AuthorString);
+            }
+        }
+
+        [Test]
+        public void TestDecodeFileWithEmptyLinesAtStart()
+        {
+            Decoder<Beatmap> decoder = null;
+            Beatmap beatmap = null;
+
+            using (var resStream = TestResources.OpenResource("empty-lines-at-start.osu"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                Assert.DoesNotThrow(() => decoder = Decoder.GetDecoder<Beatmap>(stream));
+                Assert.IsInstanceOf<LegacyBeatmapDecoder>(decoder);
+                Assert.DoesNotThrow(() => beatmap = decoder.Decode(stream));
+                Assert.IsNotNull(beatmap);
+                Assert.AreEqual("Empty lines at start", beatmap.Metadata.Title);
+                Assert.AreEqual("Edge Case Hunter", beatmap.Metadata.AuthorString);
+            }
+        }
+
+        [Test]
+        public void TestDecodeFileWithEmptyLinesAndNoHeader()
+        {
+            Decoder<Beatmap> decoder = null;
+            Beatmap beatmap = null;
+
+            using (var resStream = TestResources.OpenResource("empty-line-instead-of-header.osu"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                Assert.DoesNotThrow(() => decoder = Decoder.GetDecoder<Beatmap>(stream));
+                Assert.IsInstanceOf<LegacyBeatmapDecoder>(decoder);
+                Assert.DoesNotThrow(() => beatmap = decoder.Decode(stream));
+                Assert.IsNotNull(beatmap);
+                Assert.AreEqual("The dog ate the file header", beatmap.Metadata.Title);
+                Assert.AreEqual("Why does this keep happening", beatmap.Metadata.AuthorString);
+            }
+        }
+
+        [Test]
+        public void TestDecodeFileWithContentImmediatelyAfterHeader()
+        {
+            Decoder<Beatmap> decoder = null;
+            Beatmap beatmap = null;
+
+            using (var resStream = TestResources.OpenResource("no-empty-line-after-header.osu"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                Assert.DoesNotThrow(() => decoder = Decoder.GetDecoder<Beatmap>(stream));
+                Assert.IsInstanceOf<LegacyBeatmapDecoder>(decoder);
+                Assert.DoesNotThrow(() => beatmap = decoder.Decode(stream));
+                Assert.IsNotNull(beatmap);
+                Assert.AreEqual("No empty line delimiting header from contents", beatmap.Metadata.Title);
+                Assert.AreEqual("Edge Case Hunter", beatmap.Metadata.AuthorString);
+            }
+        }
+
+        [Test]
+        public void TestDecodeEmptyFile()
+        {
+            using (var resStream = new MemoryStream())
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                Assert.Throws<IOException>(() => Decoder.GetDecoder<Beatmap>(stream));
+            }
+        }
+
+        [Test]
+        public void TestAllowFallbackDecoderOverwrite()
+        {
+            Decoder<Beatmap> decoder = null;
+
+            using (var resStream = TestResources.OpenResource("corrupted-header.osu"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                Assert.DoesNotThrow(() => decoder = Decoder.GetDecoder<Beatmap>(stream));
+                Assert.IsInstanceOf<LegacyBeatmapDecoder>(decoder);
+            }
+
+            Assert.DoesNotThrow(LegacyDifficultyCalculatorBeatmapDecoder.Register);
+
+            using (var resStream = TestResources.OpenResource("corrupted-header.osu"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                Assert.DoesNotThrow(() => decoder = Decoder.GetDecoder<Beatmap>(stream));
+                Assert.IsInstanceOf<LegacyDifficultyCalculatorBeatmapDecoder>(decoder);
+            }
+        }
     }
 }

osu.Game.Tests/Beatmaps/Formats/LegacyDecoderTest.cs

@@ -2,9 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using System.IO;
 using NUnit.Framework;
 using osu.Game.Beatmaps.Formats;
+using osu.Game.IO;
 using osu.Game.Tests.Resources;
 
 namespace osu.Game.Tests.Beatmaps.Formats
@@ -18,7 +18,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LineLoggingDecoder(14);
 
             using (var resStream = TestResources.OpenResource("comments.osu"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 decoder.Decode(stream);
 

osu.Game.Tests/Beatmaps/Formats/LegacyStoryboardDecoderTest.cs

@@ -1,12 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.IO;
 using System.Linq;
 using NUnit.Framework;
 using osuTK;
 using osu.Framework.Graphics;
 using osu.Game.Beatmaps.Formats;
+using osu.Game.IO;
 using osu.Game.Storyboards;
 using osu.Game.Tests.Resources;
 
@@ -21,7 +21,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LegacyStoryboardDecoder();
 
             using (var resStream = TestResources.OpenResource("Himeringo - Yotsuya-san ni Yoroshiku (RLC) [Winber1's Extreme].osu"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var storyboard = decoder.Decode(stream);
 
@@ -94,7 +94,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var decoder = new LegacyStoryboardDecoder();
 
             using (var resStream = TestResources.OpenResource("variable-with-suffix.osb"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var storyboard = decoder.Decode(stream);
 

osu.Game.Tests/Beatmaps/Formats/OsuJsonDecoderTest.cs

@@ -8,6 +8,7 @@ using NUnit.Framework;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Formats;
+using osu.Game.IO;
 using osu.Game.IO.Serialization;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
@@ -148,13 +149,13 @@ namespace osu.Game.Tests.Beatmaps.Formats
         private Beatmap decode(string filename, out Beatmap jsonDecoded)
         {
             using (var stream = TestResources.OpenResource(filename))
-            using (var sr = new StreamReader(stream))
+            using (var sr = new LineBufferedReader(stream))
             {
                 var legacyDecoded = new LegacyBeatmapDecoder { ApplyOffsets = false }.Decode(sr);
 
                 using (var ms = new MemoryStream())
                 using (var sw = new StreamWriter(ms))
-                using (var sr2 = new StreamReader(ms))
+                using (var sr2 = new LineBufferedReader(ms))
                 {
                     sw.Write(legacyDecoded.Serialize());
                     sw.Flush();

osu.Game.Tests/Beatmaps/IO/ImportBeatmapTest.cs

@@ -171,7 +171,7 @@ namespace osu.Game.Tests.Beatmaps.IO
 
                     var breakTemp = TestResources.GetTestBeatmapForImport();
 
-                    MemoryStream brokenOsu = new MemoryStream(new byte[] { 1, 3, 3, 7 });
+                    MemoryStream brokenOsu = new MemoryStream();
                     MemoryStream brokenOsz = new MemoryStream(File.ReadAllBytes(breakTemp));
 
                     File.Delete(breakTemp);

osu.Game.Tests/Beatmaps/IO/LineBufferedReaderTest.cs

@@ -0,0 +1,133 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.IO;
+using System.Text;
+using NUnit.Framework;
+using osu.Game.IO;
+
+namespace osu.Game.Tests.Beatmaps.IO
+{
+    [TestFixture]
+    public class LineBufferedReaderTest
+    {
+        [Test]
+        public void TestReadLineByLine()
+        {
+            const string contents = @"line 1
+line 2
+line 3";
+
+            using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(contents)))
+            using (var bufferedReader = new LineBufferedReader(stream))
+            {
+                Assert.AreEqual("line 1", bufferedReader.ReadLine());
+                Assert.AreEqual("line 2", bufferedReader.ReadLine());
+                Assert.AreEqual("line 3", bufferedReader.ReadLine());
+                Assert.IsNull(bufferedReader.ReadLine());
+            }
+        }
+
+        [Test]
+        public void TestPeekLineOnce()
+        {
+            const string contents = @"line 1
+peek this
+line 3";
+
+            using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(contents)))
+            using (var bufferedReader = new LineBufferedReader(stream))
+            {
+                Assert.AreEqual("line 1", bufferedReader.ReadLine());
+                Assert.AreEqual("peek this", bufferedReader.PeekLine());
+                Assert.AreEqual("peek this", bufferedReader.ReadLine());
+                Assert.AreEqual("line 3", bufferedReader.ReadLine());
+                Assert.IsNull(bufferedReader.ReadLine());
+            }
+        }
+
+        [Test]
+        public void TestPeekLineMultipleTimes()
+        {
+            const string contents = @"peek this once
+line 2
+peek this a lot";
+
+            using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(contents)))
+            using (var bufferedReader = new LineBufferedReader(stream))
+            {
+                Assert.AreEqual("peek this once", bufferedReader.PeekLine());
+                Assert.AreEqual("peek this once", bufferedReader.ReadLine());
+                Assert.AreEqual("line 2", bufferedReader.ReadLine());
+                Assert.AreEqual("peek this a lot", bufferedReader.PeekLine());
+                Assert.AreEqual("peek this a lot", bufferedReader.PeekLine());
+                Assert.AreEqual("peek this a lot", bufferedReader.PeekLine());
+                Assert.AreEqual("peek this a lot", bufferedReader.ReadLine());
+                Assert.IsNull(bufferedReader.ReadLine());
+            }
+        }
+
+        [Test]
+        public void TestPeekLineAtEndOfStream()
+        {
+            const string contents = @"first line
+second line";
+
+            using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(contents)))
+            using (var bufferedReader = new LineBufferedReader(stream))
+            {
+                Assert.AreEqual("first line", bufferedReader.ReadLine());
+                Assert.AreEqual("second line", bufferedReader.ReadLine());
+                Assert.IsNull(bufferedReader.PeekLine());
+                Assert.IsNull(bufferedReader.ReadLine());
+                Assert.IsNull(bufferedReader.PeekLine());
+            }
+        }
+
+        [Test]
+        public void TestPeekReadLineOnEmptyStream()
+        {
+            using (var stream = new MemoryStream())
+            using (var bufferedReader = new LineBufferedReader(stream))
+            {
+                Assert.IsNull(bufferedReader.PeekLine());
+                Assert.IsNull(bufferedReader.ReadLine());
+                Assert.IsNull(bufferedReader.ReadLine());
+                Assert.IsNull(bufferedReader.PeekLine());
+            }
+        }
+
+        [Test]
+        public void TestReadToEndNoPeeks()
+        {
+            const string contents = @"first line
+second line";
+
+            using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(contents)))
+            using (var bufferedReader = new LineBufferedReader(stream))
+            {
+                Assert.AreEqual(contents, bufferedReader.ReadToEnd());
+            }
+        }
+
+        [Test]
+        public void TestReadToEndAfterReadsAndPeeks()
+        {
+            const string contents = @"this line is gone
+this one shouldn't be
+these ones
+definitely not";
+
+            using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(contents)))
+            using (var bufferedReader = new LineBufferedReader(stream))
+            {
+                Assert.AreEqual("this line is gone", bufferedReader.ReadLine());
+                Assert.AreEqual("this one shouldn't be", bufferedReader.PeekLine());
+                const string ending = @"this one shouldn't be
+these ones
+definitely not";
+                Assert.AreEqual(ending, bufferedReader.ReadToEnd());
+            }
+        }
+    }
+}

osu.Game.Tests/Beatmaps/IO/OszArchiveReaderTest.cs

@@ -7,6 +7,7 @@ using NUnit.Framework;
 using osu.Game.Beatmaps;
 using osu.Game.Tests.Resources;
 using osu.Game.Beatmaps.Formats;
+using osu.Game.IO;
 using osu.Game.IO.Archives;
 
 namespace osu.Game.Tests.Beatmaps.IO
@@ -50,7 +51,7 @@ namespace osu.Game.Tests.Beatmaps.IO
 
                 Beatmap beatmap;
 
-                using (var stream = new StreamReader(reader.GetStream("Soleily - Renatus (Deif) [Platter].osu")))
+                using (var stream = new LineBufferedReader(reader.GetStream("Soleily - Renatus (Deif) [Platter].osu")))
                     beatmap = Decoder.GetDecoder<Beatmap>(stream).Decode(stream);
 
                 var meta = beatmap.Metadata;

osu.Game.Tests/NonVisual/Filtering/FilterMatchingTest.cs

@@ -0,0 +1,201 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Screens.Select;
+using osu.Game.Screens.Select.Carousel;
+
+namespace osu.Game.Tests.NonVisual.Filtering
+{
+    [TestFixture]
+    public class FilterMatchingTest
+    {
+        private BeatmapInfo getExampleBeatmap() => new BeatmapInfo
+        {
+            Ruleset = new RulesetInfo { ID = 5 },
+            StarDifficulty = 4.0d,
+            BaseDifficulty = new BeatmapDifficulty
+            {
+                ApproachRate = 5.0f,
+                DrainRate = 3.0f,
+                CircleSize = 2.0f,
+            },
+            Metadata = new BeatmapMetadata
+            {
+                Artist = "The Artist",
+                ArtistUnicode = "check unicode too",
+                Title = "Title goes here",
+                TitleUnicode = "Title goes here",
+                AuthorString = "The Author",
+                Source = "unit tests",
+                Tags = "look for tags too",
+            },
+            Version = "version as well",
+            Length = 2500,
+            BPM = 160,
+            BeatDivisor = 12,
+            Status = BeatmapSetOnlineStatus.Loved
+        };
+
+        [Test]
+        public void TestCriteriaMatchingNoRuleset()
+        {
+            var exampleBeatmapInfo = getExampleBeatmap();
+            var criteria = new FilterCriteria();
+            var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
+            carouselItem.Filter(criteria);
+            Assert.IsFalse(carouselItem.Filtered.Value);
+        }
+
+        [Test]
+        public void TestCriteriaMatchingSpecificRuleset()
+        {
+            var exampleBeatmapInfo = getExampleBeatmap();
+            var criteria = new FilterCriteria
+            {
+                Ruleset = new RulesetInfo { ID = 6 }
+            };
+            var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
+            carouselItem.Filter(criteria);
+            Assert.IsTrue(carouselItem.Filtered.Value);
+        }
+
+        [Test]
+        public void TestCriteriaMatchingConvertedBeatmaps()
+        {
+            var exampleBeatmapInfo = getExampleBeatmap();
+            var criteria = new FilterCriteria
+            {
+                Ruleset = new RulesetInfo { ID = 6 },
+                AllowConvertedBeatmaps = true
+            };
+            var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
+            carouselItem.Filter(criteria);
+            Assert.IsFalse(carouselItem.Filtered.Value);
+        }
+
+        [Test]
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestCriteriaMatchingRangeMin(bool inclusive)
+        {
+            var exampleBeatmapInfo = getExampleBeatmap();
+            var criteria = new FilterCriteria
+            {
+                Ruleset = new RulesetInfo { ID = 6 },
+                AllowConvertedBeatmaps = true,
+                ApproachRate = new FilterCriteria.OptionalRange<float>
+                {
+                    IsLowerInclusive = inclusive,
+                    Min = 5.0f
+                }
+            };
+            var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
+            carouselItem.Filter(criteria);
+            Assert.AreEqual(!inclusive, carouselItem.Filtered.Value);
+        }
+
+        [Test]
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestCriteriaMatchingRangeMax(bool inclusive)
+        {
+            var exampleBeatmapInfo = getExampleBeatmap();
+            var criteria = new FilterCriteria
+            {
+                Ruleset = new RulesetInfo { ID = 6 },
+                AllowConvertedBeatmaps = true,
+                BPM = new FilterCriteria.OptionalRange<double>
+                {
+                    IsUpperInclusive = inclusive,
+                    Max = 160d
+                }
+            };
+            var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
+            carouselItem.Filter(criteria);
+            Assert.AreEqual(!inclusive, carouselItem.Filtered.Value);
+        }
+
+        [Test]
+        [TestCase("artist", false)]
+        [TestCase("artist title author", false)]
+        [TestCase("an artist", true)]
+        [TestCase("tags too", false)]
+        [TestCase("version", false)]
+        [TestCase("an auteur", true)]
+        public void TestCriteriaMatchingTerms(string terms, bool filtered)
+        {
+            var exampleBeatmapInfo = getExampleBeatmap();
+            var criteria = new FilterCriteria
+            {
+                Ruleset = new RulesetInfo { ID = 6 },
+                AllowConvertedBeatmaps = true,
+                SearchText = terms
+            };
+            var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
+            carouselItem.Filter(criteria);
+            Assert.AreEqual(filtered, carouselItem.Filtered.Value);
+        }
+
+        [Test]
+        [TestCase("", false)]
+        [TestCase("The", false)]
+        [TestCase("THE", false)]
+        [TestCase("author", false)]
+        [TestCase("the author", false)]
+        [TestCase("the author AND then something else", true)]
+        [TestCase("unknown", true)]
+        public void TestCriteriaMatchingCreator(string creatorName, bool filtered)
+        {
+            var exampleBeatmapInfo = getExampleBeatmap();
+            var criteria = new FilterCriteria
+            {
+                Creator = new FilterCriteria.OptionalTextFilter { SearchTerm = creatorName }
+            };
+            var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
+            carouselItem.Filter(criteria);
+            Assert.AreEqual(filtered, carouselItem.Filtered.Value);
+        }
+
+        [Test]
+        [TestCase("", false)]
+        [TestCase("The", false)]
+        [TestCase("THE", false)]
+        [TestCase("artist", false)]
+        [TestCase("the artist", false)]
+        [TestCase("the artist AND then something else", true)]
+        [TestCase("unicode too", false)]
+        [TestCase("unknown", true)]
+        public void TestCriteriaMatchingArtist(string artistName, bool filtered)
+        {
+            var exampleBeatmapInfo = getExampleBeatmap();
+            var criteria = new FilterCriteria
+            {
+                Artist = new FilterCriteria.OptionalTextFilter { SearchTerm = artistName }
+            };
+            var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
+            carouselItem.Filter(criteria);
+            Assert.AreEqual(filtered, carouselItem.Filtered.Value);
+        }
+
+        [Test]
+        [TestCase("", false)]
+        [TestCase("artist", false)]
+        [TestCase("unknown", true)]
+        public void TestCriteriaMatchingArtistWithNullUnicodeName(string artistName, bool filtered)
+        {
+            var exampleBeatmapInfo = getExampleBeatmap();
+            exampleBeatmapInfo.Metadata.ArtistUnicode = null;
+
+            var criteria = new FilterCriteria
+            {
+                Artist = new FilterCriteria.OptionalTextFilter { SearchTerm = artistName }
+            };
+            var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
+            carouselItem.Filter(criteria);
+            Assert.AreEqual(filtered, carouselItem.Filtered.Value);
+        }
+    }
+}

osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs

@@ -0,0 +1,184 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Screens.Select;
+
+namespace osu.Game.Tests.NonVisual.Filtering
+{
+    [TestFixture]
+    public class FilterQueryParserTest
+    {
+        [Test]
+        public void TestApplyQueriesBareWords()
+        {
+            const string query = "looking for a beatmap";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.AreEqual("looking for a beatmap", filterCriteria.SearchText);
+            Assert.AreEqual(4, filterCriteria.SearchTerms.Length);
+        }
+
+        /*
+         * The following tests have been written a bit strangely (they don't check exact
+         * bound equality with what the filter says).
+         * This is to account for floating-point arithmetic issues.
+         * For example, specifying a bpm<140 filter would previously match beatmaps with BPM
+         * of 139.99999, which would be displayed in the UI as 140.
+         * Due to this the tests check the last tick inside the range and the first tick
+         * outside of the range.
+         */
+
+        [Test]
+        public void TestApplyStarQueries()
+        {
+            const string query = "stars<4 easy";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.AreEqual("easy", filterCriteria.SearchText.Trim());
+            Assert.AreEqual(1, filterCriteria.SearchTerms.Length);
+            Assert.IsNotNull(filterCriteria.StarDifficulty.Max);
+            Assert.Greater(filterCriteria.StarDifficulty.Max, 3.99d);
+            Assert.Less(filterCriteria.StarDifficulty.Max, 4.00d);
+            Assert.IsNull(filterCriteria.StarDifficulty.Min);
+        }
+
+        [Test]
+        public void TestApplyApproachRateQueries()
+        {
+            const string query = "ar>=9 difficult";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.AreEqual("difficult", filterCriteria.SearchText.Trim());
+            Assert.AreEqual(1, filterCriteria.SearchTerms.Length);
+            Assert.IsNotNull(filterCriteria.ApproachRate.Min);
+            Assert.Greater(filterCriteria.ApproachRate.Min, 8.9f);
+            Assert.Less(filterCriteria.ApproachRate.Min, 9.0f);
+            Assert.IsNull(filterCriteria.ApproachRate.Max);
+        }
+
+        [Test]
+        public void TestApplyDrainRateQueries()
+        {
+            const string query = "dr>2 quite specific dr<:6";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.AreEqual("quite specific", filterCriteria.SearchText.Trim());
+            Assert.AreEqual(2, filterCriteria.SearchTerms.Length);
+            Assert.Greater(filterCriteria.DrainRate.Min, 2.0f);
+            Assert.Less(filterCriteria.DrainRate.Min, 2.1f);
+            Assert.Greater(filterCriteria.DrainRate.Max, 6.0f);
+            Assert.Less(filterCriteria.DrainRate.Min, 6.1f);
+        }
+
+        [Test]
+        public void TestApplyBPMQueries()
+        {
+            const string query = "bpm>:200 gotta go fast";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.AreEqual("gotta go fast", filterCriteria.SearchText.Trim());
+            Assert.AreEqual(3, filterCriteria.SearchTerms.Length);
+            Assert.IsNotNull(filterCriteria.BPM.Min);
+            Assert.Greater(filterCriteria.BPM.Min, 199.99d);
+            Assert.Less(filterCriteria.BPM.Min, 200.00d);
+            Assert.IsNull(filterCriteria.BPM.Max);
+        }
+
+        private static object[] lengthQueryExamples =
+        {
+            new object[] { "6ms", TimeSpan.FromMilliseconds(6), TimeSpan.FromMilliseconds(1) },
+            new object[] { "23s", TimeSpan.FromSeconds(23), TimeSpan.FromSeconds(1) },
+            new object[] { "9m", TimeSpan.FromMinutes(9), TimeSpan.FromMinutes(1) },
+            new object[] { "0.25h", TimeSpan.FromHours(0.25), TimeSpan.FromHours(1) },
+            new object[] { "70", TimeSpan.FromSeconds(70), TimeSpan.FromSeconds(1) },
+        };
+
+        [Test]
+        [TestCaseSource(nameof(lengthQueryExamples))]
+        public void TestApplyLengthQueries(string lengthQuery, TimeSpan expectedLength, TimeSpan scale)
+        {
+            string query = $"length={lengthQuery} time";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.AreEqual("time", filterCriteria.SearchText.Trim());
+            Assert.AreEqual(1, filterCriteria.SearchTerms.Length);
+            Assert.AreEqual(expectedLength.TotalMilliseconds - scale.TotalMilliseconds / 2.0, filterCriteria.Length.Min);
+            Assert.AreEqual(expectedLength.TotalMilliseconds + scale.TotalMilliseconds / 2.0, filterCriteria.Length.Max);
+        }
+
+        [Test]
+        public void TestApplyDivisorQueries()
+        {
+            const string query = "that's a time signature alright! divisor:12";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.AreEqual("that's a time signature alright!", filterCriteria.SearchText.Trim());
+            Assert.AreEqual(5, filterCriteria.SearchTerms.Length);
+            Assert.AreEqual(12, filterCriteria.BeatDivisor.Min);
+            Assert.IsTrue(filterCriteria.BeatDivisor.IsLowerInclusive);
+            Assert.AreEqual(12, filterCriteria.BeatDivisor.Max);
+            Assert.IsTrue(filterCriteria.BeatDivisor.IsUpperInclusive);
+        }
+
+        [Test]
+        public void TestApplyStatusQueries()
+        {
+            const string query = "I want the pp status=ranked";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.AreEqual("I want the pp", filterCriteria.SearchText.Trim());
+            Assert.AreEqual(4, filterCriteria.SearchTerms.Length);
+            Assert.AreEqual(BeatmapSetOnlineStatus.Ranked, filterCriteria.OnlineStatus.Min);
+            Assert.IsTrue(filterCriteria.OnlineStatus.IsLowerInclusive);
+            Assert.AreEqual(BeatmapSetOnlineStatus.Ranked, filterCriteria.OnlineStatus.Max);
+            Assert.IsTrue(filterCriteria.OnlineStatus.IsUpperInclusive);
+        }
+
+        [Test]
+        public void TestApplyCreatorQueries()
+        {
+            const string query = "beatmap specifically by creator=my_fav";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.AreEqual("beatmap specifically by", filterCriteria.SearchText.Trim());
+            Assert.AreEqual(3, filterCriteria.SearchTerms.Length);
+            Assert.AreEqual("my_fav", filterCriteria.Creator.SearchTerm);
+        }
+
+        [Test]
+        public void TestApplyArtistQueries()
+        {
+            const string query = "find me songs by artist=singer please";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.AreEqual("find me songs by  please", filterCriteria.SearchText.Trim());
+            Assert.AreEqual(5, filterCriteria.SearchTerms.Length);
+            Assert.AreEqual("singer", filterCriteria.Artist.SearchTerm);
+        }
+
+        [Test]
+        public void TestApplyArtistQueriesWithSpaces()
+        {
+            const string query = "really like artist=\"name with space\" yes";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.AreEqual("really like  yes", filterCriteria.SearchText.Trim());
+            Assert.AreEqual(3, filterCriteria.SearchTerms.Length);
+            Assert.AreEqual("name with space", filterCriteria.Artist.SearchTerm);
+        }
+
+        [Test]
+        public void TestApplyArtistQueriesOneDoubleQuote()
+        {
+            const string query = "weird artist=double\"quote";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.AreEqual("weird", filterCriteria.SearchText.Trim());
+            Assert.AreEqual(1, filterCriteria.SearchTerms.Length);
+            Assert.AreEqual("double\"quote", filterCriteria.Artist.SearchTerm);
+        }
+    }
+}

osu.Game.Tests/Resources/corrupted-header.osu

@@ -0,0 +1,5 @@
+ow computerosu file format v14
+
+[Metadata]
+Title: Beatmap with corrupted header
+Creator: Evil Hacker

osu.Game.Tests/Resources/empty-line-instead-of-header.osu

@@ -0,0 +1,5 @@
+
+
+[Metadata]
+Title: The dog ate the file header
+Creator: Why does this keep happening

osu.Game.Tests/Resources/empty-lines-at-start.osu

@@ -0,0 +1,8 @@
+
+
+
+osu file format v14
+
+[Metadata]
+Title: Empty lines at start
+Creator: Edge Case Hunter

osu.Game.Tests/Resources/missing-header.osu

@@ -0,0 +1,4 @@
+[Metadata]
+
+Title: Beatmap with no header
+Creator: Incredibly Evil Hacker

osu.Game.Tests/Resources/no-empty-line-after-header.osu

@@ -0,0 +1,4 @@
+osu file format v14
+[Metadata]
+Title: No empty line delimiting header from contents
+Creator: Edge Case Hunter

osu.Game.Tests/Skins/LegacySkinDecoderTest.cs

@@ -2,8 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using System.IO;
 using NUnit.Framework;
+using osu.Game.IO;
 using osu.Game.Skinning;
 using osu.Game.Tests.Resources;
 using osuTK.Graphics;
@@ -20,7 +20,7 @@ namespace osu.Game.Tests.Skins
             var decoder = new LegacySkinDecoder();
 
             using (var resStream = TestResources.OpenResource(hasColours ? "skin.ini" : "skin-empty.ini"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var comboColors = decoder.Decode(stream).ComboColours;
 
@@ -48,7 +48,7 @@ namespace osu.Game.Tests.Skins
             var decoder = new LegacySkinDecoder();
 
             using (var resStream = TestResources.OpenResource("skin.ini"))
-            using (var stream = new StreamReader(resStream))
+            using (var stream = new LineBufferedReader(resStream))
             {
                 var config = decoder.Decode(stream);
 

osu.Game.Tests/Skins/TestSceneSkinConfigurationLookup.cs

@@ -9,6 +9,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Textures;
+using osu.Framework.Testing;
 using osu.Game.Audio;
 using osu.Game.Skinning;
 using osu.Game.Tests.Visual;
@@ -17,6 +18,7 @@ using osuTK.Graphics;
 namespace osu.Game.Tests.Skins
 {
     [TestFixture]
+    [HeadlessTest]
     public class TestSceneSkinConfigurationLookup : OsuTestScene
     {
         private LegacySkin source1;

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

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -115,6 +116,32 @@ namespace osu.Game.Tests.Visual.Gameplay
             assertPosition(4, 1f);
         }
 
+        [Test]
+        public void TestSliderMultiplierDoesNotAffectRelativeBeatLength()
+        {
+            var beatmap = createBeatmap(new TimingControlPoint { BeatLength = time_range });
+            beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier = 2;
+
+            createTest(beatmap, d => d.RelativeScaleBeatLengthsOverride = true);
+            AddStep("adjust time range", () => drawableRuleset.TimeRange.Value = 5000);
+
+            for (int i = 0; i < 5; i++)
+                assertPosition(i, i / 5f);
+        }
+
+        [Test]
+        public void TestSliderMultiplierAffectsNonRelativeBeatLength()
+        {
+            var beatmap = createBeatmap(new TimingControlPoint { BeatLength = time_range });
+            beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier = 2;
+
+            createTest(beatmap);
+            AddStep("adjust time range", () => drawableRuleset.TimeRange.Value = 2000);
+
+            assertPosition(0, 0);
+            assertPosition(1, 1);
+        }
+
         private void assertPosition(int index, float relativeY) => AddAssert($"hitobject {index} at {relativeY}",
             () => Precision.AlmostEquals(drawableRuleset.Playfield.AllHitObjects.ElementAt(index).DrawPosition.Y, drawableRuleset.Playfield.HitObjectContainer.DrawHeight * relativeY));
 
@@ -193,6 +220,8 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             protected override ScrollVisualisationMethod VisualisationMethod => ScrollVisualisationMethod.Overlapping;
 
+            public new Bindable<double> TimeRange => base.TimeRange;
+
             public TestDrawableScrollingRuleset(Ruleset ruleset, IWorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
                 : base(ruleset, beatmap, mods)
             {

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

@@ -127,14 +127,47 @@ namespace osu.Game.Tests.Visual.Gameplay
             exitAndConfirm();
         }
 
+        [Test]
+        public void TestExitFromFailedGameplay()
+        {
+            AddUntilStep("wait for fail", () => Player.HasFailed);
+            AddStep("exit", () => Player.Exit());
+
+            confirmExited();
+        }
+
+        [Test]
+        public void TestQuickRetryFromFailedGameplay()
+        {
+            AddUntilStep("wait for fail", () => Player.HasFailed);
+            AddStep("quick retry", () => Player.GameplayClockContainer.OfType<HotkeyRetryOverlay>().First().Action?.Invoke());
+
+            confirmExited();
+        }
+
+        [Test]
+        public void TestQuickExitFromFailedGameplay()
+        {
+            AddUntilStep("wait for fail", () => Player.HasFailed);
+            AddStep("quick exit", () => Player.GameplayClockContainer.OfType<HotkeyExitOverlay>().First().Action?.Invoke());
+
+            confirmExited();
+        }
+
         [Test]
         public void TestExitFromGameplay()
         {
             AddStep("exit", () => Player.Exit());
 
-            confirmPaused();
+            confirmExited();
+        }
 
-            exitAndConfirm();
+        [Test]
+        public void TestQuickExitFromGameplay()
+        {
+            AddStep("quick exit", () => Player.GameplayClockContainer.OfType<HotkeyExitOverlay>().First().Action?.Invoke());
+
+            confirmExited();
         }
 
         [Test]

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

@@ -7,10 +7,16 @@ using System.Linq;
 using System.Threading;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Audio;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.MathUtils;
 using osu.Framework.Screens;
+using osu.Game.Configuration;
+using osu.Game.Graphics.Containers;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Notifications;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Scoring;
@@ -18,25 +24,49 @@ using osu.Game.Scoring;
 using osu.Game.Screens;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.PlayerSettings;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
     public class TestScenePlayerLoader : ManualInputManagerTestScene
     {
         private TestPlayerLoader loader;
-        private OsuScreenStack stack;
+        private TestPlayerLoaderContainer container;
+        private TestPlayer player;
 
-        [SetUp]
+        [Resolved]
-        public void Setup() => Schedule(() =>
+        private AudioManager audioManager { get; set; }
+
+        [Resolved]
+        private SessionStatics sessionStatics { get; set; }
+
+        /// <summary>
+        /// Sets the input manager child to a new test player loader container instance.
+        /// </summary>
+        /// <param name="interactive">If the test player should behave like the production one.</param>
+        /// <param name="beforeLoadAction">An action to run before player load but after bindable leases are returned.</param>
+        /// <param name="afterLoadAction">An action to run after container load.</param>
+        public void ResetPlayer(bool interactive, Action beforeLoadAction = null, Action afterLoadAction = null)
         {
-            InputManager.Child = stack = new OsuScreenStack { RelativeSizeAxes = Axes.Both };
+            audioManager.Volume.SetDefault();
+
+            InputManager.Clear();
+
+            beforeLoadAction?.Invoke();
             Beatmap.Value = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
-        });
+
+            InputManager.Child = container = new TestPlayerLoaderContainer(
+                loader = new TestPlayerLoader(() =>
+                {
+                    afterLoadAction?.Invoke();
+                    return player = new TestPlayer(interactive, interactive);
+                }));
+        }
 
         [Test]
         public void TestBlockLoadViaMouseMovement()
         {
-            AddStep("load dummy beatmap", () => stack.Push(loader = new TestPlayerLoader(() => new TestPlayer(false, false))));
+            AddStep("load dummy beatmap", () => ResetPlayer(false));
             AddUntilStep("wait for current", () => loader.IsCurrentScreen());
             AddRepeatStep("move mouse", () => InputManager.MoveMouseTo(loader.VisualSettings.ScreenSpaceDrawQuad.TopLeft + (loader.VisualSettings.ScreenSpaceDrawQuad.BottomRight - loader.VisualSettings.ScreenSpaceDrawQuad.TopLeft) * RNG.NextSingle()), 20);
             AddAssert("loader still active", () => loader.IsCurrentScreen());
@@ -46,16 +76,17 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestLoadContinuation()
         {
-            Player player = null;
             SlowLoadPlayer slowPlayer = null;
 
-            AddStep("load dummy beatmap", () => stack.Push(loader = new TestPlayerLoader(() => player = new TestPlayer(false, false))));
+            AddStep("load dummy beatmap", () => ResetPlayer(false));
             AddUntilStep("wait for current", () => loader.IsCurrentScreen());
             AddStep("mouse in centre", () => InputManager.MoveMouseTo(loader.ScreenSpaceDrawQuad.Centre));
             AddUntilStep("wait for player to be current", () => player.IsCurrentScreen());
             AddStep("load slow dummy beatmap", () =>
             {
-                stack.Push(loader = new TestPlayerLoader(() => slowPlayer = new SlowLoadPlayer(false, false)));
+                InputManager.Child = container = new TestPlayerLoaderContainer(
+                    loader = new TestPlayerLoader(() => slowPlayer = new SlowLoadPlayer(false, false)));
+
                 Scheduler.AddDelayed(() => slowPlayer.AllowLoad.Set(), 5000);
             });
 
@@ -65,16 +96,11 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestModReinstantiation()
         {
-            TestPlayer player = null;
             TestMod gameMod = null;
             TestMod playerMod1 = null;
             TestMod playerMod2 = null;
 
-            AddStep("load player", () =>
+            AddStep("load player", () => { ResetPlayer(true, () => Mods.Value = new[] { gameMod = new TestMod() }); });
-            {
-                Mods.Value = new[] { gameMod = new TestMod() };
-                stack.Push(loader = new TestPlayerLoader(() => player = new TestPlayer()));
-            });
 
             AddUntilStep("wait for loader to become current", () => loader.IsCurrentScreen());
             AddStep("mouse in centre", () => InputManager.MoveMouseTo(loader.ScreenSpaceDrawQuad.Centre));
@@ -97,6 +123,75 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("player mods applied", () => playerMod2.Applied);
         }
 
+        [Test]
+        public void TestMutedNotificationMasterVolume() => addVolumeSteps("master volume", () => audioManager.Volume.Value = 0, null, () => audioManager.Volume.IsDefault);
+
+        [Test]
+        public void TestMutedNotificationTrackVolume() => addVolumeSteps("music volume", () => audioManager.VolumeTrack.Value = 0, null, () => audioManager.VolumeTrack.IsDefault);
+
+        [Test]
+        public void TestMutedNotificationMuteButton() => addVolumeSteps("mute button", null, () => container.VolumeOverlay.IsMuted.Value = true, () => !container.VolumeOverlay.IsMuted.Value);
+
+        /// <remarks>
+        /// Created for avoiding copy pasting code for the same steps.
+        /// </remarks>
+        /// <param name="volumeName">What part of the volume system is checked</param>
+        /// <param name="beforeLoad">The action to be invoked to set the volume before loading</param>
+        /// <param name="afterLoad">The action to be invoked to set the volume after loading</param>
+        /// <param name="assert">The function to be invoked and checked</param>
+        private void addVolumeSteps(string volumeName, Action beforeLoad, Action afterLoad, Func<bool> assert)
+        {
+            AddStep("reset notification lock", () => sessionStatics.GetBindable<bool>(Static.MutedAudioNotificationShownOnce).Value = false);
+
+            AddStep("load player", () => ResetPlayer(false, beforeLoad, afterLoad));
+            AddUntilStep("wait for player", () => player.IsLoaded);
+
+            AddAssert("check for notification", () => container.NotificationOverlay.UnreadCount.Value == 1);
+            AddStep("click notification", () =>
+            {
+                var scrollContainer = (OsuScrollContainer)container.NotificationOverlay.Children.Last();
+                var flowContainer = scrollContainer.Children.OfType<FillFlowContainer<NotificationSection>>().First();
+                var notification = flowContainer.First();
+
+                InputManager.MoveMouseTo(notification);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("check " + volumeName, assert);
+        }
+
+        private class TestPlayerLoaderContainer : Container
+        {
+            [Cached]
+            public readonly NotificationOverlay NotificationOverlay;
+
+            [Cached]
+            public readonly VolumeOverlay VolumeOverlay;
+
+            public TestPlayerLoaderContainer(IScreen screen)
+            {
+                RelativeSizeAxes = Axes.Both;
+
+                InternalChildren = new Drawable[]
+                {
+                    new OsuScreenStack(screen)
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                    NotificationOverlay = new NotificationOverlay
+                    {
+                        Anchor = Anchor.TopRight,
+                        Origin = Anchor.TopRight,
+                    },
+                    VolumeOverlay = new VolumeOverlay
+                    {
+                        Anchor = Anchor.TopLeft,
+                        Origin = Anchor.TopLeft,
+                    }
+                };
+            }
+        }
+
         private class TestPlayerLoader : PlayerLoader
         {
             public new VisualSettings VisualSettings => base.VisualSettings;

osu.Game.Tests/Visual/Menus/TestSceneScreenNavigation.cs

@@ -0,0 +1,202 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Platform;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Game.Configuration;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Mods;
+using osu.Game.Screens;
+using osu.Game.Screens.Menu;
+using osu.Game.Screens.Select;
+using osuTK;
+using osuTK.Graphics;
+using osuTK.Input;
+using IntroSequence = osu.Game.Configuration.IntroSequence;
+
+namespace osu.Game.Tests.Visual.Menus
+{
+    public class TestSceneScreenNavigation : ManualInputManagerTestScene
+    {
+        private const float click_padding = 25;
+
+        private GameHost host;
+        private TestOsuGame osuGame;
+
+        private Vector2 backButtonPosition => osuGame.ToScreenSpace(new Vector2(click_padding, osuGame.LayoutRectangle.Bottom - click_padding));
+
+        private Vector2 optionsButtonPosition => osuGame.ToScreenSpace(new Vector2(click_padding, click_padding));
+
+        [BackgroundDependencyLoader]
+        private void load(GameHost host)
+        {
+            this.host = host;
+
+            Child = new Box
+            {
+                RelativeSizeAxes = Axes.Both,
+                Colour = Color4.Black,
+            };
+        }
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("Create new game instance", () =>
+            {
+                if (osuGame != null)
+                {
+                    Remove(osuGame);
+                    osuGame.Dispose();
+                }
+
+                osuGame = new TestOsuGame(LocalStorage, API);
+                osuGame.SetHost(host);
+
+                // todo: this can be removed once we can run audio trakcs without a device present
+                // see https://github.com/ppy/osu/issues/1302
+                osuGame.LocalConfig.Set(OsuSetting.IntroSequence, IntroSequence.Circles);
+
+                Add(osuGame);
+            });
+            AddUntilStep("Wait for load", () => osuGame.IsLoaded);
+            AddUntilStep("Wait for intro", () => osuGame.ScreenStack.CurrentScreen is IntroScreen);
+            confirmAtMainMenu();
+        }
+
+        [Test]
+        public void TestExitSongSelectWithEscape()
+        {
+            TestSongSelect songSelect = null;
+
+            pushAndConfirm(() => songSelect = new TestSongSelect());
+            AddStep("Show mods overlay", () => songSelect.ModSelectOverlay.Show());
+            AddAssert("Overlay was shown", () => songSelect.ModSelectOverlay.State.Value == Visibility.Visible);
+            AddStep("Press escape", () => pressAndRelease(Key.Escape));
+            AddAssert("Overlay was hidden", () => songSelect.ModSelectOverlay.State.Value == Visibility.Hidden);
+            exitViaEscapeAndConfirm();
+        }
+
+        [Test]
+        public void TestExitSongSelectWithClick()
+        {
+            TestSongSelect songSelect = null;
+
+            pushAndConfirm(() => songSelect = new TestSongSelect());
+            AddStep("Show mods overlay", () => songSelect.ModSelectOverlay.Show());
+            AddAssert("Overlay was shown", () => songSelect.ModSelectOverlay.State.Value == Visibility.Visible);
+            AddStep("Move mouse to backButton", () => InputManager.MoveMouseTo(backButtonPosition));
+
+            // BackButton handles hover using its child button, so this checks whether or not any of BackButton's children are hovered.
+            AddUntilStep("Back button is hovered", () => InputManager.HoveredDrawables.Any(d => d.Parent == osuGame.BackButton));
+
+            AddStep("Click back button", () => InputManager.Click(MouseButton.Left));
+            AddUntilStep("Overlay was hidden", () => songSelect.ModSelectOverlay.State.Value == Visibility.Hidden);
+            exitViaBackButtonAndConfirm();
+        }
+
+        [Test]
+        public void TestExitMultiWithEscape()
+        {
+            pushAndConfirm(() => new Screens.Multi.Multiplayer());
+            exitViaEscapeAndConfirm();
+        }
+
+        [Test]
+        public void TestExitMultiWithBackButton()
+        {
+            pushAndConfirm(() => new Screens.Multi.Multiplayer());
+            exitViaBackButtonAndConfirm();
+        }
+
+        [Test]
+        public void TestOpenOptionsAndExitWithEscape()
+        {
+            AddUntilStep("Wait for options to load", () => osuGame.Settings.IsLoaded);
+            AddStep("Enter menu", () => pressAndRelease(Key.Enter));
+            AddStep("Move mouse to options overlay", () => InputManager.MoveMouseTo(optionsButtonPosition));
+            AddStep("Click options overlay", () => InputManager.Click(MouseButton.Left));
+            AddAssert("Options overlay was opened", () => osuGame.Settings.State.Value == Visibility.Visible);
+            AddStep("Hide options overlay using escape", () => pressAndRelease(Key.Escape));
+            AddAssert("Options overlay was closed", () => osuGame.Settings.State.Value == Visibility.Hidden);
+        }
+
+        private void pushAndConfirm(Func<Screen> newScreen)
+        {
+            Screen screen = null;
+            AddStep("Push new screen", () => osuGame.ScreenStack.Push(screen = newScreen()));
+            AddUntilStep("Wait for new screen", () => osuGame.ScreenStack.CurrentScreen == screen && screen.IsLoaded);
+        }
+
+        private void exitViaEscapeAndConfirm()
+        {
+            AddStep("Press escape", () => pressAndRelease(Key.Escape));
+            confirmAtMainMenu();
+        }
+
+        private void exitViaBackButtonAndConfirm()
+        {
+            AddStep("Move mouse to backButton", () => InputManager.MoveMouseTo(backButtonPosition));
+            AddStep("Click back button", () => InputManager.Click(MouseButton.Left));
+            confirmAtMainMenu();
+        }
+
+        private void confirmAtMainMenu() => AddUntilStep("Wait for main menu", () => osuGame.ScreenStack.CurrentScreen is MainMenu menu && menu.IsLoaded);
+
+        private void pressAndRelease(Key key)
+        {
+            InputManager.PressKey(key);
+            InputManager.ReleaseKey(key);
+        }
+
+        private class TestOsuGame : OsuGame
+        {
+            public new ScreenStack ScreenStack => base.ScreenStack;
+
+            public new BackButton BackButton => base.BackButton;
+
+            public new SettingsPanel Settings => base.Settings;
+
+            public new OsuConfigManager LocalConfig => base.LocalConfig;
+
+            protected override Loader CreateLoader() => new TestLoader();
+
+            public TestOsuGame(Storage storage, IAPIProvider api)
+            {
+                Storage = storage;
+                API = api;
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                API.Login("Rhythm Champion", "osu!");
+            }
+        }
+
+        private class TestSongSelect : PlaySongSelect
+        {
+            public ModSelectOverlay ModSelectOverlay => ModSelect;
+        }
+
+        private class TestLoader : Loader
+        {
+            protected override ShaderPrecompiler CreateShaderPrecompiler() => new TestShaderPrecompiler();
+
+            private class TestShaderPrecompiler : ShaderPrecompiler
+            {
+                protected override bool AllLoaded => true;
+            }
+        }
+    }
+}

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

@@ -32,6 +32,12 @@ namespace osu.Game.Tests.Visual.Online
             Id = 4,
         };
 
+        private readonly User longUsernameUser = new User
+        {
+            Username = "Very Long Long Username",
+            Id = 5,
+        };
+
         [Cached]
         private ChannelManager channelManager = new ChannelManager();
 
@@ -99,6 +105,12 @@ namespace osu.Game.Tests.Visual.Online
                 Sender = admin,
                 Content = "Okay okay, calm down guys. Let's do this!"
             }));
+
+            AddStep("message from long username", () => testChannel.AddNewMessages(new Message(sequence++)
+            {
+                Sender = longUsernameUser,
+                Content = "Hi guys, my new username is lit!"
+            }));
         }
     }
 }

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

@@ -107,6 +107,15 @@ namespace osu.Game.Tests.Visual.Online
                 CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c6.jpg"
             }, api.IsLoggedIn));
 
+            AddStep("Show bancho", () => profile.ShowUser(new User
+            {
+                Username = @"BanchoBot",
+                Id = 3,
+                IsBot = true,
+                Country = new Country { FullName = @"Saint Helena", FlagName = @"SH" },
+                CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c4.jpg"
+            }, api.IsLoggedIn));
+
             AddStep("Hide", profile.Hide);
             AddStep("Show without reload", profile.Show);
         }

osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarousel.cs

@@ -43,7 +43,7 @@ namespace osu.Game.Tests.Visual.SongSelect
         private readonly Stack<BeatmapSetInfo> selectedSets = new Stack<BeatmapSetInfo>();
         private readonly HashSet<int> eagerSelectedIDs = new HashSet<int>();
 
-        private BeatmapInfo currentSelection;
+        private BeatmapInfo currentSelection => carousel.SelectedBeatmap;
 
         private const int set_count = 5;
 
@@ -56,45 +56,381 @@ namespace osu.Game.Tests.Visual.SongSelect
             {
                 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;
-
-            loadBeatmaps(beatmapSets);
-
-            testTraversal();
-            testFiltering();
-            testRandom();
-            testAddRemove();
-            testSorting();
-
-            testRemoveAll();
-            testEmptyTraversal();
-            testHiding();
-            testSelectingFilteredRuleset();
-            testCarouselRootIsRandom();
         }
 
-        private void loadBeatmaps(List<BeatmapSetInfo> beatmapSets)
+        /// <summary>
+        /// Test keyboard traversal
+        /// </summary>
+        [Test]
+        public void TestTraversal()
         {
+            loadBeatmaps();
+
+            advanceSelection(direction: 1, diff: false);
+            waitForSelection(1, 1);
+
+            advanceSelection(direction: 1, diff: true);
+            waitForSelection(1, 2);
+
+            advanceSelection(direction: -1, diff: false);
+            waitForSelection(set_count, 1);
+
+            advanceSelection(direction: -1, diff: true);
+            waitForSelection(set_count - 1, 3);
+
+            advanceSelection(diff: false);
+            advanceSelection(diff: false);
+            waitForSelection(1, 2);
+
+            advanceSelection(direction: -1, diff: true);
+            advanceSelection(direction: -1, diff: true);
+            waitForSelection(set_count, 3);
+        }
+
+        /// <summary>
+        /// Test filtering
+        /// </summary>
+        [Test]
+        public void TestFiltering()
+        {
+            loadBeatmaps();
+
+            // 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);
+            waitForSelection(3, 1);
+
+            advanceSelection(diff: true, count: 4);
+            waitForSelection(3, 2);
+
+            AddStep("Un-filter (debounce)", () => carousel.Filter(new FilterCriteria()));
+            AddUntilStep("Wait for debounce", () => !carousel.PendingFilterTask);
+            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));
+            waitForSelection(1, 1);
+
+            AddStep("Un-filter", () => carousel.Filter(new FilterCriteria(), false));
+            waitForSelection(1, 1);
+
+            AddStep("Filter all", () => carousel.Filter(new FilterCriteria { SearchText = "Dingo" }, false));
+
+            checkVisibleItemCount(false, 0);
+            checkVisibleItemCount(true, 0);
+            AddAssert("Selection is null", () => currentSelection == null);
+
+            advanceSelection(true);
+            AddAssert("Selection is null", () => currentSelection == null);
+
+            advanceSelection(false);
+            AddAssert("Selection is null", () => currentSelection == null);
+
+            AddStep("Un-filter", () => carousel.Filter(new FilterCriteria(), false));
+
+            AddAssert("Selection is non-null", () => currentSelection != null);
+
+            setSelected(1, 3);
+        }
+
+        [Test]
+        public void TestFilterRange()
+        {
+            loadBeatmaps();
+
+            // buffer the selection
+            setSelected(3, 2);
+
+            setSelected(1, 3);
+
+            AddStep("Apply a range filter", () => carousel.Filter(new FilterCriteria
+            {
+                SearchText = "#3",
+                StarDifficulty = new FilterCriteria.OptionalRange<double>
+                {
+                    Min = 2,
+                    Max = 5.5,
+                    IsLowerInclusive = true
+                }
+            }, false));
+
+            // should reselect the buffered selection.
+            waitForSelection(3, 2);
+        }
+
+        /// <summary>
+        /// Test random non-repeating algorithm
+        /// </summary>
+        [Test]
+        public void TestRandom()
+        {
+            loadBeatmaps();
+
+            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));
+
+            AddStep("Add set with 100 difficulties", () => carousel.UpdateBeatmapSet(createTestBeatmapSetWithManyDifficulties(set_count + 1)));
+            AddStep("Filter Extra", () => carousel.Filter(new FilterCriteria { SearchText = "Extra 10" }, false));
+            checkInvisibleDifficultiesUnselectable();
+            checkInvisibleDifficultiesUnselectable();
+            checkInvisibleDifficultiesUnselectable();
+            checkInvisibleDifficultiesUnselectable();
+            checkInvisibleDifficultiesUnselectable();
+            AddStep("Un-filter", () => carousel.Filter(new FilterCriteria(), false));
+        }
+
+        /// <summary>
+        /// Test adding and removing beatmap sets
+        /// </summary>
+        [Test]
+        public void TestAddRemove()
+        {
+            loadBeatmaps();
+
+            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);
+
+            waitForSelection(set_count);
+        }
+
+        /// <summary>
+        /// Test sorting
+        /// </summary>
+        [Test]
+        public void TestSorting()
+        {
+            loadBeatmaps();
+
+            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}!"));
+        }
+
+        [Test]
+        public void TestSortingWithFiltered()
+        {
+            List<BeatmapSetInfo> sets = new List<BeatmapSetInfo>();
+
+            for (int i = 0; i < 3; i++)
+            {
+                var set = createTestBeatmapSet(i);
+                set.Beatmaps[0].StarDifficulty = 3 - i;
+                set.Beatmaps[2].StarDifficulty = 6 + i;
+                sets.Add(set);
+            }
+
+            loadBeatmaps(sets);
+
+            AddStep("Filter to normal", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Difficulty, SearchText = "Normal" }, false));
+            AddAssert("Check first set at end", () => carousel.BeatmapSets.First() == sets.Last());
+            AddAssert("Check last set at start", () => carousel.BeatmapSets.Last() == sets.First());
+
+            AddStep("Filter to insane", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Difficulty, SearchText = "Insane" }, false));
+            AddAssert("Check first set at start", () => carousel.BeatmapSets.First() == sets.First());
+            AddAssert("Check last set at end", () => carousel.BeatmapSets.Last() == sets.Last());
+        }
+
+        [Test]
+        public void TestRemoveAll()
+        {
+            loadBeatmaps();
+
+            setSelected(2, 1);
+            AddAssert("Selection is non-null", () => currentSelection != null);
+
+            AddStep("Remove selected", () => carousel.RemoveBeatmapSet(carousel.SelectedBeatmapSet));
+            waitForSelection(2);
+
+            AddStep("Remove first", () => carousel.RemoveBeatmapSet(carousel.BeatmapSets.First()));
+            AddStep("Remove first", () => carousel.RemoveBeatmapSet(carousel.BeatmapSets.First()));
+            waitForSelection(1);
+
+            AddUntilStep("Remove all", () =>
+            {
+                if (!carousel.BeatmapSets.Any()) return true;
+
+                carousel.RemoveBeatmapSet(carousel.BeatmapSets.Last());
+                return false;
+            });
+
+            checkNoSelection();
+        }
+
+        [Test]
+        public void TestEmptyTraversal()
+        {
+            loadBeatmaps(new List<BeatmapSetInfo>());
+
+            advanceSelection(direction: 1, diff: false);
+            checkNoSelection();
+
+            advanceSelection(direction: 1, diff: true);
+            checkNoSelection();
+
+            advanceSelection(direction: -1, diff: false);
+            checkNoSelection();
+
+            advanceSelection(direction: -1, diff: true);
+            checkNoSelection();
+        }
+
+        [Test]
+        public void TestHiding()
+        {
+            BeatmapSetInfo hidingSet = createTestBeatmapSet(1);
+            hidingSet.Beatmaps[1].Hidden = true;
+
+            loadBeatmaps(new List<BeatmapSetInfo> { hidingSet });
+
+            setSelected(1, 1);
+
+            checkVisibleItemCount(true, 2);
+            advanceSelection(true);
+            waitForSelection(1, 3);
+
+            setHidden(3);
+            waitForSelection(1, 1);
+
+            setHidden(2, false);
+            advanceSelection(true);
+            waitForSelection(1, 2);
+
+            setHidden(1);
+            waitForSelection(1, 2);
+
+            setHidden(2);
+            checkNoSelection();
+
+            void setHidden(int diff, bool hidden = true)
+            {
+                AddStep((hidden ? "" : "un") + $"hide diff {diff}", () =>
+                {
+                    hidingSet.Beatmaps[diff - 1].Hidden = hidden;
+                    carousel.UpdateBeatmapSet(hidingSet);
+                });
+            }
+        }
+
+        [Test]
+        public void TestSelectingFilteredRuleset()
+        {
+            var testMixed = createTestBeatmapSet(set_count + 1);
+            AddStep("add mixed ruleset beatmapset", () =>
+            {
+                for (int i = 0; i <= 2; i++)
+                {
+                    testMixed.Beatmaps[i].Ruleset = rulesets.AvailableRulesets.ElementAt(i);
+                    testMixed.Beatmaps[i].RulesetID = i;
+                }
+
+                carousel.UpdateBeatmapSet(testMixed);
+            });
+            AddStep("filter to ruleset 0", () =>
+                carousel.Filter(new FilterCriteria { Ruleset = rulesets.AvailableRulesets.ElementAt(0) }, false));
+            AddStep("select filtered map skipping filtered", () => carousel.SelectBeatmap(testMixed.Beatmaps[1], false));
+            AddAssert("unfiltered beatmap selected", () => carousel.SelectedBeatmap.Equals(testMixed.Beatmaps[0]));
+
+            AddStep("remove mixed set", () =>
+            {
+                carousel.RemoveBeatmapSet(testMixed);
+                testMixed = null;
+            });
+            var testSingle = createTestBeatmapSet(set_count + 2);
+            testSingle.Beatmaps.ForEach(b =>
+            {
+                b.Ruleset = rulesets.AvailableRulesets.ElementAt(1);
+                b.RulesetID = b.Ruleset.ID ?? 1;
+            });
+            AddStep("add single ruleset beatmapset", () => carousel.UpdateBeatmapSet(testSingle));
+            AddStep("select filtered map skipping filtered", () => carousel.SelectBeatmap(testSingle.Beatmaps[0], false));
+            checkNoSelection();
+            AddStep("remove single ruleset set", () => carousel.RemoveBeatmapSet(testSingle));
+        }
+
+        [Test]
+        public void TestCarouselRootIsRandom()
+        {
+            List<BeatmapSetInfo> manySets = new List<BeatmapSetInfo>();
+
+            for (int i = 1; i <= 50; i++)
+                manySets.Add(createTestBeatmapSet(i));
+
+            loadBeatmaps(manySets);
+
+            advanceSelection(direction: 1, diff: false);
+            checkNonmatchingFilter();
+            checkNonmatchingFilter();
+            checkNonmatchingFilter();
+            checkNonmatchingFilter();
+            checkNonmatchingFilter();
+            AddAssert("Selection was random", () => eagerSelectedIDs.Count > 1);
+        }
+
+        private void loadBeatmaps(List<BeatmapSetInfo> beatmapSets = null)
+        {
+            if (beatmapSets == null)
+            {
+                beatmapSets = new List<BeatmapSetInfo>();
+
+                for (int i = 1; i <= set_count; i++)
+                    beatmapSets.Add(createTestBeatmapSet(i));
+            }
+
             bool changed = false;
             AddStep($"Load {beatmapSets.Count} Beatmaps", () =>
             {
+                carousel.Filter(new FilterCriteria());
                 carousel.BeatmapSetsChanged = () => changed = true;
                 carousel.BeatmapSets = beatmapSets;
             });
+
             AddUntilStep("Wait for load", () => changed);
         }
 
         private void ensureRandomFetchSuccess() =>
             AddAssert("ensure prev random fetch worked", () => selectedSets.Peek() == carousel.SelectedBeatmapSet);
 
-        private void checkSelected(int set, int? diff = null) =>
+        private void waitForSelection(int set, int? diff = null) =>
-            AddAssert($"selected is set{set}{(diff.HasValue ? $" diff{diff.Value}" : "")}", () =>
+            AddUntilStep($"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();
@@ -170,275 +506,6 @@ namespace osu.Game.Tests.Visual.SongSelect
             });
         }
 
-        /// <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("Wait for debounce", () => !carousel.PendingFilterTask);
-            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);
-
-            advanceSelection(true);
-            AddAssert("Selection is null", () => currentSelection == null);
-
-            advanceSelection(false);
-            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));
-
-            AddStep("Add set with 100 difficulties", () => carousel.UpdateBeatmapSet(createTestBeatmapSetWithManyDifficulties(set_count + 1)));
-            AddStep("Filter Extra", () => carousel.Filter(new FilterCriteria { SearchText = "Extra 10" }, false));
-            checkInvisibleDifficultiesUnselectable();
-            checkInvisibleDifficultiesUnselectable();
-            checkInvisibleDifficultiesUnselectable();
-            checkInvisibleDifficultiesUnselectable();
-            checkInvisibleDifficultiesUnselectable();
-            AddStep("Un-filter", () => carousel.Filter(new FilterCriteria(), false));
-        }
-
-        /// <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("Remove all", () =>
-            {
-                if (!carousel.BeatmapSets.Any()) return true;
-
-                carousel.RemoveBeatmapSet(carousel.BeatmapSets.Last());
-                return false;
-            });
-
-            checkNoSelection();
-        }
-
-        private void testEmptyTraversal()
-        {
-            advanceSelection(direction: 1, diff: false);
-            checkNoSelection();
-
-            advanceSelection(direction: 1, diff: true);
-            checkNoSelection();
-
-            advanceSelection(direction: -1, diff: false);
-            checkNoSelection();
-
-            advanceSelection(direction: -1, diff: true);
-            checkNoSelection();
-        }
-
-        private void testHiding()
-        {
-            var hidingSet = createTestBeatmapSet(1);
-            hidingSet.Beatmaps[1].Hidden = true;
-            AddStep("Add set with diff 2 hidden", () => carousel.UpdateBeatmapSet(hidingSet));
-            setSelected(1, 1);
-
-            checkVisibleItemCount(true, 2);
-            advanceSelection(true);
-            checkSelected(1, 3);
-
-            setHidden(3);
-            checkSelected(1, 1);
-
-            setHidden(2, false);
-            advanceSelection(true);
-            checkSelected(1, 2);
-
-            setHidden(1);
-            checkSelected(1, 2);
-
-            setHidden(2);
-            checkNoSelection();
-
-            void setHidden(int diff, bool hidden = true)
-            {
-                AddStep((hidden ? "" : "un") + $"hide diff {diff}", () =>
-                {
-                    hidingSet.Beatmaps[diff - 1].Hidden = hidden;
-                    carousel.UpdateBeatmapSet(hidingSet);
-                });
-            }
-        }
-
-        private void testSelectingFilteredRuleset()
-        {
-            var testMixed = createTestBeatmapSet(set_count + 1);
-            AddStep("add mixed ruleset beatmapset", () =>
-            {
-                for (int i = 0; i <= 2; i++)
-                {
-                    testMixed.Beatmaps[i].Ruleset = rulesets.AvailableRulesets.ElementAt(i);
-                    testMixed.Beatmaps[i].RulesetID = i;
-                }
-
-                carousel.UpdateBeatmapSet(testMixed);
-            });
-            AddStep("filter to ruleset 0", () =>
-                carousel.Filter(new FilterCriteria { Ruleset = rulesets.AvailableRulesets.ElementAt(0) }, false));
-            AddStep("select filtered map skipping filtered", () => carousel.SelectBeatmap(testMixed.Beatmaps[1], false));
-            AddAssert("unfiltered beatmap selected", () => carousel.SelectedBeatmap.Equals(testMixed.Beatmaps[0]));
-
-            AddStep("remove mixed set", () =>
-            {
-                carousel.RemoveBeatmapSet(testMixed);
-                testMixed = null;
-            });
-            var testSingle = createTestBeatmapSet(set_count + 2);
-            testSingle.Beatmaps.ForEach(b =>
-            {
-                b.Ruleset = rulesets.AvailableRulesets.ElementAt(1);
-                b.RulesetID = b.Ruleset.ID ?? 1;
-            });
-            AddStep("add single ruleset beatmapset", () => carousel.UpdateBeatmapSet(testSingle));
-            AddStep("select filtered map skipping filtered", () => carousel.SelectBeatmap(testSingle.Beatmaps[0], false));
-            checkNoSelection();
-            AddStep("remove single ruleset set", () => carousel.RemoveBeatmapSet(testSingle));
-        }
-
-        private void testCarouselRootIsRandom()
-        {
-            List<BeatmapSetInfo> beatmapSets = new List<BeatmapSetInfo>();
-
-            for (int i = 1; i <= 50; i++)
-                beatmapSets.Add(createTestBeatmapSet(i));
-
-            loadBeatmaps(beatmapSets);
-            advanceSelection(direction: 1, diff: false);
-            checkNonmatchingFilter();
-            checkNonmatchingFilter();
-            checkNonmatchingFilter();
-            checkNonmatchingFilter();
-            checkNonmatchingFilter();
-            AddAssert("Selection was random", () => eagerSelectedIDs.Count > 1);
-        }
-
         private BeatmapSetInfo createTestBeatmapSet(int id)
         {
             return new BeatmapSetInfo

osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapInfoWedge.cs

@@ -75,7 +75,6 @@ namespace osu.Game.Tests.Visual.SongSelect
 
                 testBeatmapLabels(instance);
 
-                // TODO: adjust cases once more info is shown for other gamemodes
                 switch (instance)
                 {
                     case OsuRuleset _:
@@ -99,8 +98,6 @@ namespace osu.Game.Tests.Visual.SongSelect
                         break;
                 }
             }
-
-            testNullBeatmap();
         }
 
         private void testBeatmapLabels(Ruleset ruleset)
@@ -117,7 +114,8 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddAssert("check info labels count", () => infoWedge.Info.InfoLabelContainer.Children.Count == expectedCount);
         }
 
-        private void testNullBeatmap()
+        [Test]
+        public void TestNullBeatmap()
         {
             selectBeatmap(null);
             AddAssert("check empty version", () => string.IsNullOrEmpty(infoWedge.Info.VersionLabel.Text));
@@ -127,6 +125,12 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddAssert("check no info labels", () => !infoWedge.Info.InfoLabelContainer.Children.Any());
         }
 
+        [Test]
+        public void TestTruncation()
+        {
+            selectBeatmap(createLongMetadata());
+        }
+
         private void selectBeatmap([CanBeNull] IBeatmap b)
         {
             BeatmapInfoWedge.BufferedWedgeInfo infoBefore = null;
@@ -166,6 +170,25 @@ namespace osu.Game.Tests.Visual.SongSelect
             };
         }
 
+        private IBeatmap createLongMetadata()
+        {
+            return new Beatmap
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    Metadata = new BeatmapMetadata
+                    {
+                        AuthorString = "WWWWWWWWWWWWWWW",
+                        Artist = "Verrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrry long Artist",
+                        Source = "Verrrrry long Source",
+                        Title = "Verrrrry long Title"
+                    },
+                    Version = "Verrrrrrrrrrrrrrrrrrrrrrrrrrrrry long Version",
+                    Status = BeatmapSetOnlineStatus.Graveyard,
+                },
+            };
+        }
+
         private class TestBeatmapInfoWedge : BeatmapInfoWedge
         {
             public new BufferedWedgeInfo Info => base.Info;

osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapOptionsOverlay.cs

@@ -18,8 +18,8 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             overlay.AddButton(@"Remove", @"from unplayed", FontAwesome.Regular.TimesCircle, Color4.Purple, null, Key.Number1);
             overlay.AddButton(@"Clear", @"local scores", FontAwesome.Solid.Eraser, Color4.Purple, null, Key.Number2);
-            overlay.AddButton(@"Edit", @"Beatmap", FontAwesome.Solid.PencilAlt, Color4.Yellow, null, Key.Number3);
+            overlay.AddButton(@"Delete", @"all difficulties", FontAwesome.Solid.Trash, Color4.Pink, null, Key.Number3);
-            overlay.AddButton(@"Delete", @"Beatmap", FontAwesome.Solid.Trash, Color4.Pink, null, Key.Number4, float.MaxValue);
+            overlay.AddButton(@"Edit", @"beatmap", FontAwesome.Solid.PencilAlt, Color4.Yellow, null, Key.Number4);
 
             Add(overlay);
 

osu.Game.Tests/Visual/UserInterface/TestSceneBackButton.cs

@@ -22,6 +22,7 @@ namespace osu.Game.Tests.Visual.UserInterface
         public TestSceneBackButton()
         {
             BackButton button;
+            BackButton.Receptor receptor = new BackButton.Receptor();
 
             Child = new Container
             {
@@ -31,12 +32,13 @@ namespace osu.Game.Tests.Visual.UserInterface
                 Masking = true,
                 Children = new Drawable[]
                 {
+                    receptor,
                     new Box
                     {
                         RelativeSizeAxes = Axes.Both,
                         Colour = Color4.SlateGray
                     },
-                    button = new BackButton
+                    button = new BackButton(receptor)
                     {
                         Anchor = Anchor.BottomLeft,
                         Origin = Anchor.BottomLeft,

osu.Game.Tests/Visual/UserInterface/TestSceneLabelledComponent.cs

@@ -6,7 +6,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics.Sprites;
-using osu.Game.Screens.Edit.Setup.Components.LabelledComponents;
+using osu.Game.Graphics.UserInterfaceV2;
 using osuTK.Graphics;
 
 namespace osu.Game.Tests.Visual.UserInterface
@@ -25,7 +25,7 @@ namespace osu.Game.Tests.Visual.UserInterface
         {
             AddStep("create component", () =>
             {
-                LabelledComponent component;
+                LabelledComponent<Drawable> component;
 
                 Child = new Container
                 {
@@ -33,7 +33,7 @@ namespace osu.Game.Tests.Visual.UserInterface
                     Origin = Anchor.Centre,
                     Width = 500,
                     AutoSizeAxes = Axes.Y,
-                    Child = component = padded ? (LabelledComponent)new PaddedLabelledComponent() : new NonPaddedLabelledComponent(),
+                    Child = component = padded ? (LabelledComponent<Drawable>)new PaddedLabelledComponent() : new NonPaddedLabelledComponent(),
                 };
 
                 component.Label = "a sample component";
@@ -41,7 +41,7 @@ namespace osu.Game.Tests.Visual.UserInterface
             });
         }
 
-        private class PaddedLabelledComponent : LabelledComponent
+        private class PaddedLabelledComponent : LabelledComponent<Drawable>
         {
             public PaddedLabelledComponent()
                 : base(true)
@@ -57,7 +57,7 @@ namespace osu.Game.Tests.Visual.UserInterface
             };
         }
 
-        private class NonPaddedLabelledComponent : LabelledComponent
+        private class NonPaddedLabelledComponent : LabelledComponent<Drawable>
         {
             public NonPaddedLabelledComponent()
                 : base(false)

osu.Game.Tests/Visual/UserInterface/TestSceneLabelledSwitchButton.cs

@@ -0,0 +1,49 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics.UserInterfaceV2;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneLabelledSwitchButton : OsuTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(LabelledSwitchButton),
+            typeof(SwitchButton)
+        };
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestSwitchButton(bool hasDescription) => createSwitchButton(hasDescription);
+
+        private void createSwitchButton(bool hasDescription = false)
+        {
+            AddStep("create component", () =>
+            {
+                LabelledSwitchButton component;
+
+                Child = new Container
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Width = 500,
+                    AutoSizeAxes = Axes.Y,
+                    Child = component = new LabelledSwitchButton
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    }
+                };
+
+                component.Label = "a sample component";
+                component.Description = hasDescription ? "this text describes the component" : string.Empty;
+            });
+        }
+    }
+}

osu.Game.Tests/Visual/UserInterface/TestSceneLabelledTextBox.cs

@@ -7,7 +7,8 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Screens.Edit.Setup.Components.LabelledComponents;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterfaceV2;
 
 namespace osu.Game.Tests.Visual.UserInterface
 {
@@ -19,6 +20,36 @@ namespace osu.Game.Tests.Visual.UserInterface
             typeof(LabelledTextBox),
         };
 
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestTextBox(bool hasDescription) => createTextBox(hasDescription);
+
+        private void createTextBox(bool hasDescription = false)
+        {
+            AddStep("create component", () =>
+            {
+                LabelledComponent<OsuTextBox> component;
+
+                Child = new Container
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Width = 500,
+                    AutoSizeAxes = Axes.Y,
+                    Child = component = new LabelledTextBox
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Label = "Testing text",
+                        PlaceholderText = "This is definitely working as intended",
+                    }
+                };
+
+                component.Label = "a sample component";
+                component.Description = hasDescription ? "this text describes the component" : string.Empty;
+            });
+        }
+
         [BackgroundDependencyLoader]
         private void load()
         {
@@ -32,7 +63,7 @@ namespace osu.Game.Tests.Visual.UserInterface
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    LabelText = "Testing text",
+                    Label = "Testing text",
                     PlaceholderText = "This is definitely working as intended",
                 }
             };

osu.Game.Tests/Visual/UserInterface/TestSceneSwitchButton.cs

@@ -0,0 +1,44 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Graphics.UserInterfaceV2;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneSwitchButton : ManualInputManagerTestScene
+    {
+        private SwitchButton switchButton;
+
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            Child = switchButton = new SwitchButton
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+            };
+        });
+
+        [Test]
+        public void TestChangeThroughInput()
+        {
+            AddStep("move to switch button", () => InputManager.MoveMouseTo(switchButton));
+            AddStep("click on", () => InputManager.Click(MouseButton.Left));
+            AddStep("click off", () => InputManager.Click(MouseButton.Left));
+        }
+
+        [Test]
+        public void TestChangeThroughBindable()
+        {
+            BindableBool bindable = null;
+
+            AddStep("bind bindable", () => switchButton.Current.BindTo(bindable = new BindableBool()));
+            AddStep("toggle bindable", () => bindable.Toggle());
+            AddStep("toggle bindable", () => bindable.Toggle());
+        }
+    }
+}

osu.Game.Tests/WaveformTestBeatmap.cs

@@ -9,6 +9,7 @@ using osu.Framework.Graphics.Textures;
 using osu.Framework.Graphics.Video;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Formats;
+using osu.Game.IO;
 using osu.Game.IO.Archives;
 using osu.Game.Tests.Resources;
 
@@ -56,7 +57,7 @@ namespace osu.Game.Tests
         private Beatmap createTestBeatmap()
         {
             using (var beatmapStream = getBeatmapStream())
-            using (var beatmapReader = new StreamReader(beatmapStream))
+            using (var beatmapReader = new LineBufferedReader(beatmapStream))
                 return Decoder.GetDecoder<Beatmap>(beatmapReader).Decode(beatmapReader);
         }
     }

osu.Game.Tournament.Tests/Screens/TestSceneSetupScreen.cs

@@ -0,0 +1,17 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Game.Tournament.Screens;
+
+namespace osu.Game.Tournament.Tests.Screens
+{
+    public class TestSceneSetupScreen : TournamentTestScene
+    {
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Add(new SetupScreen());
+        }
+    }
+}

osu.Game.Tournament/IPC/FileBasedIPC.cs

@@ -9,6 +9,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Logging;
 using osu.Framework.Platform;
 using osu.Framework.Platform.Windows;
+using osu.Framework.Threading;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Online.API;
@@ -26,103 +27,120 @@ namespace osu.Game.Tournament.IPC
         [Resolved]
         protected RulesetStore Rulesets { get; private set; }
 
+        [Resolved]
+        private GameHost host { get; set; }
+
+        [Resolved]
+        private LadderInfo ladder { get; set; }
+
         private int lastBeatmapId;
+        private ScheduledDelegate scheduled;
+
+        public Storage Storage { get; private set; }
 
         [BackgroundDependencyLoader]
-        private void load(LadderInfo ladder, GameHost host)
+        private void load()
         {
-            StableStorage stable;
+            LocateStableStorage();
+        }
+
+        public Storage LocateStableStorage()
+        {
+            scheduled?.Cancel();
+
+            Storage = null;
 
             try
             {
-                stable = new StableStorage(host as DesktopGameHost);
+                Storage = new StableStorage(host as DesktopGameHost);
+
+                const string file_ipc_filename = "ipc.txt";
+                const string file_ipc_state_filename = "ipc-state.txt";
+                const string file_ipc_scores_filename = "ipc-scores.txt";
+                const string file_ipc_channel_filename = "ipc-channel.txt";
+
+                if (Storage.Exists(file_ipc_filename))
+                    scheduled = Scheduler.AddDelayed(delegate
+                    {
+                        try
+                        {
+                            using (var stream = Storage.GetStream(file_ipc_filename))
+                            using (var sr = new StreamReader(stream))
+                            {
+                                var beatmapId = int.Parse(sr.ReadLine());
+                                var mods = int.Parse(sr.ReadLine());
+
+                                if (lastBeatmapId != beatmapId)
+                                {
+                                    lastBeatmapId = beatmapId;
+
+                                    var existing = ladder.CurrentMatch.Value?.Round.Value?.Beatmaps.FirstOrDefault(b => b.ID == beatmapId && b.BeatmapInfo != null);
+
+                                    if (existing != null)
+                                        Beatmap.Value = existing.BeatmapInfo;
+                                    else
+                                    {
+                                        var req = new GetBeatmapRequest(new BeatmapInfo { OnlineBeatmapID = beatmapId });
+                                        req.Success += b => Beatmap.Value = b.ToBeatmap(Rulesets);
+                                        API.Queue(req);
+                                    }
+                                }
+
+                                Mods.Value = (LegacyMods)mods;
+                            }
+                        }
+                        catch
+                        {
+                            // file might be in use.
+                        }
+
+                        try
+                        {
+                            using (var stream = Storage.GetStream(file_ipc_channel_filename))
+                            using (var sr = new StreamReader(stream))
+                            {
+                                ChatChannel.Value = sr.ReadLine();
+                            }
+                        }
+                        catch (Exception)
+                        {
+                            // file might be in use.
+                        }
+
+                        try
+                        {
+                            using (var stream = Storage.GetStream(file_ipc_state_filename))
+                            using (var sr = new StreamReader(stream))
+                            {
+                                State.Value = (TourneyState)Enum.Parse(typeof(TourneyState), sr.ReadLine());
+                            }
+                        }
+                        catch (Exception)
+                        {
+                            // file might be in use.
+                        }
+
+                        try
+                        {
+                            using (var stream = Storage.GetStream(file_ipc_scores_filename))
+                            using (var sr = new StreamReader(stream))
+                            {
+                                Score1.Value = int.Parse(sr.ReadLine());
+                                Score2.Value = int.Parse(sr.ReadLine());
+                            }
+                        }
+                        catch (Exception)
+                        {
+                            // file might be in use.
+                        }
+                    }, 250, true);
             }
             catch (Exception e)
             {
                 Logger.Error(e, "Stable installation could not be found; disabling file based IPC");
-                return;
             }
 
-            const string file_ipc_filename = "ipc.txt";
+            return Storage;
-            const string file_ipc_state_filename = "ipc-state.txt";
-            const string file_ipc_scores_filename = "ipc-scores.txt";
-            const string file_ipc_channel_filename = "ipc-channel.txt";
-
-            if (stable.Exists(file_ipc_filename))
-                Scheduler.AddDelayed(delegate
-                {
-                    try
-                    {
-                        using (var stream = stable.GetStream(file_ipc_filename))
-                        using (var sr = new StreamReader(stream))
-                        {
-                            var beatmapId = int.Parse(sr.ReadLine());
-                            var mods = int.Parse(sr.ReadLine());
-
-                            if (lastBeatmapId != beatmapId)
-                            {
-                                lastBeatmapId = beatmapId;
-
-                                var existing = ladder.CurrentMatch.Value?.Round.Value?.Beatmaps.FirstOrDefault(b => b.ID == beatmapId && b.BeatmapInfo != null);
-
-                                if (existing != null)
-                                    Beatmap.Value = existing.BeatmapInfo;
-                                else
-                                {
-                                    var req = new GetBeatmapRequest(new BeatmapInfo { OnlineBeatmapID = beatmapId });
-                                    req.Success += b => Beatmap.Value = b.ToBeatmap(Rulesets);
-                                    API.Queue(req);
-                                }
-                            }
-
-                            Mods.Value = (LegacyMods)mods;
-                        }
-                    }
-                    catch
-                    {
-                        // file might be in use.
-                    }
-
-                    try
-                    {
-                        using (var stream = stable.GetStream(file_ipc_channel_filename))
-                        using (var sr = new StreamReader(stream))
-                        {
-                            ChatChannel.Value = sr.ReadLine();
-                        }
-                    }
-                    catch (Exception)
-                    {
-                        // file might be in use.
-                    }
-
-                    try
-                    {
-                        using (var stream = stable.GetStream(file_ipc_state_filename))
-                        using (var sr = new StreamReader(stream))
-                        {
-                            State.Value = (TourneyState)Enum.Parse(typeof(TourneyState), sr.ReadLine());
-                        }
-                    }
-                    catch (Exception)
-                    {
-                        // file might be in use.
-                    }
-
-                    try
-                    {
-                        using (var stream = stable.GetStream(file_ipc_scores_filename))
-                        using (var sr = new StreamReader(stream))
-                        {
-                            Score1.Value = int.Parse(sr.ReadLine());
-                            Score2.Value = int.Parse(sr.ReadLine());
-                        }
-                    }
-                    catch (Exception)
-                    {
-                        // file might be in use.
-                    }
-                }, 250, true);
         }
 
         /// <summary>

osu.Game.Tournament/Screens/SetupScreen.cs

@@ -0,0 +1,142 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Online.API;
+using osu.Game.Overlays;
+using osu.Game.Tournament.IPC;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Tournament.Screens
+{
+    public class SetupScreen : TournamentScreen, IProvideVideo
+    {
+        private FillFlowContainer fillFlow;
+
+        private LoginOverlay loginOverlay;
+
+        [Resolved]
+        private MatchIPCInfo ipc { get; set; }
+
+        [Resolved]
+        private IAPIProvider api { get; set; }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChild = fillFlow = new FillFlowContainer
+            {
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                Direction = FillDirection.Vertical,
+                Padding = new MarginPadding(10),
+                Spacing = new Vector2(10),
+            };
+
+            api.LocalUser.BindValueChanged(_ => Schedule(reload));
+            reload();
+        }
+
+        private void reload()
+        {
+            var fileBasedIpc = ipc as FileBasedIPC;
+
+            fillFlow.Children = new Drawable[]
+            {
+                new ActionableInfo
+                {
+                    Label = "Current IPC source",
+                    ButtonText = "Refresh",
+                    Action = () =>
+                    {
+                        fileBasedIpc?.LocateStableStorage();
+                        reload();
+                    },
+                    Value = fileBasedIpc?.Storage?.GetFullPath(string.Empty) ?? "Not found",
+                    Failing = fileBasedIpc?.Storage == null,
+                    Description = "The osu!stable installation which is currently being used as a data source. If a source is not found, make sure you have created an empty ipc.txt in your stable cutting-edge installation, and that it is registered as the default osu! install."
+                },
+                new ActionableInfo
+                {
+                    Label = "Current User",
+                    ButtonText = "Change Login",
+                    Action = () =>
+                    {
+                        api.Logout();
+
+                        if (loginOverlay == null)
+                        {
+                            AddInternal(loginOverlay = new LoginOverlay
+                            {
+                                Anchor = Anchor.TopRight,
+                                Origin = Anchor.TopRight,
+                            });
+                        }
+
+                        loginOverlay.State.Value = Visibility.Visible;
+                    },
+                    Value = api?.LocalUser.Value.Username,
+                    Failing = api?.IsLoggedIn != true,
+                    Description = "In order to access the API and display metadata, a login is required."
+                }
+            };
+        }
+
+        private class ActionableInfo : LabelledComponent<Drawable>
+        {
+            private OsuButton button;
+
+            public ActionableInfo()
+                : base(true)
+            {
+            }
+
+            public string ButtonText
+            {
+                set => button.Text = value;
+            }
+
+            public string Value
+            {
+                set => valueText.Text = value;
+            }
+
+            public bool Failing
+            {
+                set => valueText.Colour = value ? Color4.Red : Color4.White;
+            }
+
+            public Action Action;
+
+            private OsuSpriteText valueText;
+
+            protected override Drawable CreateComponent() => new Container
+            {
+                AutoSizeAxes = Axes.Y,
+                RelativeSizeAxes = Axes.X,
+                Children = new Drawable[]
+                {
+                    valueText = new OsuSpriteText
+                    {
+                        Anchor = Anchor.CentreLeft,
+                        Origin = Anchor.CentreLeft,
+                    },
+                    button = new TriangleButton
+                    {
+                        Anchor = Anchor.CentreRight,
+                        Origin = Anchor.CentreRight,
+                        Size = new Vector2(100, 30),
+                        Action = () => Action?.Invoke()
+                    },
+                }
+            };
+        }
+    }
+}

osu.Game.Tournament/TournamentSceneManager.cs

@@ -69,6 +69,7 @@ namespace osu.Game.Tournament
                             RelativeSizeAxes = Axes.Both,
                             Children = new Drawable[]
                             {
+                                new SetupScreen(),
                                 new ScheduleScreen(),
                                 new LadderScreen(),
                                 new LadderEditorScreen(),
@@ -106,6 +107,8 @@ namespace osu.Game.Tournament
                             Direction = FillDirection.Vertical,
                             Children = new Drawable[]
                             {
+                                new OsuButton { RelativeSizeAxes = Axes.X, Text = "Setup", Action = () => SetScreen(typeof(SetupScreen)) },
+                                new Container { RelativeSizeAxes = Axes.X, Height = 50 },
                                 new OsuButton { RelativeSizeAxes = Axes.X, Text = "Team Editor", Action = () => SetScreen(typeof(TeamEditorScreen)) },
                                 new OsuButton { RelativeSizeAxes = Axes.X, Text = "Rounds Editor", Action = () => SetScreen(typeof(RoundEditorScreen)) },
                                 new OsuButton { RelativeSizeAxes = Axes.X, Text = "Bracket Editor", Action = () => SetScreen(typeof(LadderEditorScreen)) },
@@ -127,7 +130,7 @@ namespace osu.Game.Tournament
                 },
             };
 
-            SetScreen(typeof(ScheduleScreen));
+            SetScreen(typeof(SetupScreen));
         }
 
         public void SetScreen(Type screenType)

osu.Game.Tournament/osu.Game.Tournament.csproj

@@ -11,6 +11,6 @@
     <ProjectReference Include="..\osu.Game\osu.Game.csproj" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.Win32.Registry" Version="4.5.0" />
+    <PackageReference Include="Microsoft.Win32.Registry" Version="4.6.0" />
   </ItemGroup>
 </Project>

osu.Game/Beatmaps/BeatmapManager.cs

@@ -20,6 +20,7 @@ using osu.Framework.Platform;
 using osu.Framework.Threading;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.Database;
+using osu.Game.IO;
 using osu.Game.IO.Archives;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
@@ -264,7 +265,7 @@ namespace osu.Game.Beatmaps
             }
 
             Beatmap beatmap;
-            using (var stream = new StreamReader(reader.GetStream(mapName)))
+            using (var stream = new LineBufferedReader(reader.GetStream(mapName)))
                 beatmap = Decoder.GetDecoder<Beatmap>(stream).Decode(stream);
 
             return new BeatmapSetInfo
@@ -287,7 +288,7 @@ namespace osu.Game.Beatmaps
             {
                 using (var raw = Files.Store.GetStream(file.FileInfo.StoragePath))
                 using (var ms = new MemoryStream()) //we need a memory stream so we can seek
-                using (var sr = new StreamReader(ms))
+                using (var sr = new LineBufferedReader(ms))
                 {
                     raw.CopyTo(ms);
                     ms.Position = 0;

osu.Game/Beatmaps/BeatmapManager_WorkingBeatmap.cs

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.IO;
 using System.Linq;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Track;
@@ -11,6 +10,7 @@ using osu.Framework.Graphics.Video;
 using osu.Framework.IO.Stores;
 using osu.Framework.Logging;
 using osu.Game.Beatmaps.Formats;
+using osu.Game.IO;
 using osu.Game.Skinning;
 using osu.Game.Storyboards;
 
@@ -33,7 +33,7 @@ namespace osu.Game.Beatmaps
             {
                 try
                 {
-                    using (var stream = new StreamReader(store.GetStream(getPathForFile(BeatmapInfo.Path))))
+                    using (var stream = new LineBufferedReader(store.GetStream(getPathForFile(BeatmapInfo.Path))))
                         return Decoder.GetDecoder<Beatmap>(stream).Decode(stream);
                 }
                 catch
@@ -127,7 +127,7 @@ namespace osu.Game.Beatmaps
 
                 try
                 {
-                    using (var stream = new StreamReader(store.GetStream(getPathForFile(BeatmapInfo.Path))))
+                    using (var stream = new LineBufferedReader(store.GetStream(getPathForFile(BeatmapInfo.Path))))
                     {
                         var decoder = Decoder.GetDecoder<Storyboard>(stream);
 
@@ -136,7 +136,7 @@ namespace osu.Game.Beatmaps
                             storyboard = decoder.Decode(stream);
                         else
                         {
-                            using (var secondaryStream = new StreamReader(store.GetStream(getPathForFile(BeatmapSetInfo.StoryboardFile))))
+                            using (var secondaryStream = new LineBufferedReader(store.GetStream(getPathForFile(BeatmapSetInfo.StoryboardFile))))
                                 storyboard = decoder.Decode(stream, secondaryStream);
                         }
                     }

osu.Game/Beatmaps/BeatmapProcessor.cs

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Linq;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Beatmaps
@@ -45,25 +44,6 @@ namespace osu.Game.Beatmaps
 
         public virtual void PostProcess()
         {
-            void updateNestedCombo(HitObject obj, int comboIndex, int indexInCurrentCombo)
-            {
-                if (obj is IHasComboInformation objectComboInfo)
-                {
-                    objectComboInfo.ComboIndex = comboIndex;
-                    objectComboInfo.IndexInCurrentCombo = indexInCurrentCombo;
-                    foreach (var nestedObject in obj.NestedHitObjects)
-                        updateNestedCombo(nestedObject, comboIndex, indexInCurrentCombo);
-                }
-            }
-
-            foreach (var hitObject in Beatmap.HitObjects)
-            {
-                if (hitObject is IHasComboInformation objectComboInfo)
-                {
-                    foreach (var nested in hitObject.NestedHitObjects)
-                        updateNestedCombo(nested, objectComboInfo.ComboIndex, objectComboInfo.IndexInCurrentCombo);
-                }
-            }
         }
     }
 }

osu.Game/Beatmaps/BindableBeatmap.cs

@@ -1,42 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Diagnostics;
-using osu.Framework.Bindables;
-
-namespace osu.Game.Beatmaps
-{
-    /// <summary>
-    /// A <see cref="Bindable{T}"/> for the <see cref="OsuGame"/> beatmap.
-    /// This should be used sparingly in-favour of <see cref="IBindable{WorkingBeatmap}"/>.
-    /// </summary>
-    public abstract class BindableBeatmap : NonNullableBindable<WorkingBeatmap>
-    {
-        private WorkingBeatmap lastBeatmap;
-
-        protected BindableBeatmap(WorkingBeatmap defaultValue)
-            : base(defaultValue)
-        {
-            BindValueChanged(b => updateAudioTrack(b.NewValue), true);
-        }
-
-        private void updateAudioTrack(WorkingBeatmap beatmap)
-        {
-            var trackLoaded = lastBeatmap?.TrackLoaded ?? false;
-
-            // compare to last beatmap as sometimes the two may share a track representation (optimisation, see WorkingBeatmap.TransferTo)
-            if (!trackLoaded || lastBeatmap?.Track != beatmap.Track)
-            {
-                if (trackLoaded)
-                {
-                    Debug.Assert(lastBeatmap != null);
-                    Debug.Assert(lastBeatmap.Track != null);
-
-                    lastBeatmap.RecycleTrack();
-                }
-            }
-
-            lastBeatmap = beatmap;
-        }
-    }
-}

osu.Game/Beatmaps/Formats/Decoder.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using osu.Game.IO;
 
 namespace osu.Game.Beatmaps.Formats
 {
@@ -13,20 +14,21 @@ namespace osu.Game.Beatmaps.Formats
     {
         protected virtual TOutput CreateTemplateObject() => new TOutput();
 
-        public TOutput Decode(StreamReader primaryStream, params StreamReader[] otherStreams)
+        public TOutput Decode(LineBufferedReader primaryStream, params LineBufferedReader[] otherStreams)
         {
             var output = CreateTemplateObject();
-            foreach (StreamReader stream in otherStreams.Prepend(primaryStream))
+            foreach (LineBufferedReader stream in otherStreams.Prepend(primaryStream))
                 ParseStreamInto(stream, output);
             return output;
         }
 
-        protected abstract void ParseStreamInto(StreamReader stream, TOutput output);
+        protected abstract void ParseStreamInto(LineBufferedReader stream, TOutput output);
     }
 
     public abstract class Decoder
     {
         private static readonly Dictionary<Type, Dictionary<string, Func<string, Decoder>>> decoders = new Dictionary<Type, Dictionary<string, Func<string, Decoder>>>();
+        private static readonly Dictionary<Type, Func<Decoder>> fallback_decoders = new Dictionary<Type, Func<Decoder>>();
 
         static Decoder()
         {
@@ -39,7 +41,7 @@ namespace osu.Game.Beatmaps.Formats
         /// Retrieves a <see cref="Decoder"/> to parse a <see cref="Beatmap"/>.
         /// </summary>
         /// <param name="stream">A stream pointing to the <see cref="Beatmap"/>.</param>
-        public static Decoder<T> GetDecoder<T>(StreamReader stream)
+        public static Decoder<T> GetDecoder<T>(LineBufferedReader stream)
             where T : new()
         {
             if (stream == null)
@@ -48,21 +50,31 @@ namespace osu.Game.Beatmaps.Formats
             if (!decoders.TryGetValue(typeof(T), out var typedDecoders))
                 throw new IOException(@"Unknown decoder type");
 
-            string line;
+            // start off with the first line of the file
+            string line = stream.PeekLine()?.Trim();
 
-            do
+            while (line != null && line.Length == 0)
             {
-                line = stream.ReadLine()?.Trim();
+                // consume the previously peeked empty line and advance to the next one
-            } while (line != null && line.Length == 0);
+                stream.ReadLine();
+                line = stream.PeekLine()?.Trim();
+            }
 
             if (line == null)
-                throw new IOException(@"Unknown file format (null)");
+                throw new IOException("Unknown file format (null)");
 
             var decoder = typedDecoders.Select(d => line.StartsWith(d.Key, StringComparison.InvariantCulture) ? d.Value : null).FirstOrDefault();
-            if (decoder == null)
-                throw new IOException($@"Unknown file format ({line})");
 
-            return (Decoder<T>)decoder.Invoke(line);
+            // it's important the magic does NOT get consumed here, since sometimes it's part of the structure
+            // (see JsonBeatmapDecoder - the magic string is the opening brace)
+            // decoder implementations should therefore not die on receiving their own magic
+            if (decoder != null)
+                return (Decoder<T>)decoder.Invoke(line);
+
+            if (!fallback_decoders.TryGetValue(typeof(T), out var fallbackDecoder))
+                throw new IOException($"Unknown file format ({line})");
+
+            return (Decoder<T>)fallbackDecoder.Invoke();
         }
 
         /// <summary>
@@ -77,5 +89,17 @@ namespace osu.Game.Beatmaps.Formats
 
             typedDecoders[magic] = constructor;
         }
+
+        /// <summary>
+        /// Registers a fallback decoder instantiation function.
+        /// The fallback will be returned if the first non-empty line of the decoded stream does not match any known magic.
+        /// Calling this method will overwrite any existing global fallback registration for type <see cref="T"/> - use with caution.
+        /// </summary>
+        /// <typeparam name="T">Type of object being decoded.</typeparam>
+        /// <param name="constructor">A function that constructs the fallback<see cref="Decoder"/>.</param>
+        protected static void SetFallbackDecoder<T>(Func<Decoder> constructor)
+        {
+            fallback_decoders[typeof(T)] = constructor;
+        }
     }
 }

osu.Game/Beatmaps/Formats/JsonBeatmapDecoder.cs

@@ -1,7 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.IO;
+using osu.Game.IO;
 using osu.Game.IO.Serialization;
 
 namespace osu.Game.Beatmaps.Formats
@@ -13,11 +13,8 @@ namespace osu.Game.Beatmaps.Formats
             AddDecoder<Beatmap>("{", m => new JsonBeatmapDecoder());
         }
 
-        protected override void ParseStreamInto(StreamReader stream, Beatmap output)
+        protected override void ParseStreamInto(LineBufferedReader stream, Beatmap output)
         {
-            stream.BaseStream.Position = 0;
-            stream.DiscardBufferedData();
-
             stream.ReadToEnd().DeserializeInto(output);
 
             foreach (var hitObject in output.HitObjects)

osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs

@@ -8,6 +8,7 @@ using osu.Framework.IO.File;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.IO;
 
 namespace osu.Game.Beatmaps.Formats
 {
@@ -25,6 +26,7 @@ namespace osu.Game.Beatmaps.Formats
         public static void Register()
         {
             AddDecoder<Beatmap>(@"osu file format v", m => new LegacyBeatmapDecoder(Parsing.ParseInt(m.Split('v').Last())));
+            SetFallbackDecoder<Beatmap>(() => new LegacyBeatmapDecoder());
         }
 
         /// <summary>
@@ -41,7 +43,7 @@ namespace osu.Game.Beatmaps.Formats
             offset = FormatVersion < 5 ? 24 : 0;
         }
 
-        protected override void ParseStreamInto(StreamReader stream, Beatmap beatmap)
+        protected override void ParseStreamInto(LineBufferedReader stream, Beatmap beatmap)
         {
             this.beatmap = beatmap;
             this.beatmap.BeatmapInfo.BeatmapVersion = FormatVersion;

osu.Game/Beatmaps/Formats/LegacyDecoder.cs

@@ -3,10 +3,10 @@
 
 using System;
 using System.Collections.Generic;
-using System.IO;
 using osu.Framework.Logging;
 using osu.Game.Audio;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.IO;
 using osuTK.Graphics;
 
 namespace osu.Game.Beatmaps.Formats
@@ -21,7 +21,7 @@ namespace osu.Game.Beatmaps.Formats
             FormatVersion = version;
         }
 
-        protected override void ParseStreamInto(StreamReader stream, T output)
+        protected override void ParseStreamInto(LineBufferedReader stream, T output)
         {
             Section section = Section.None;
 

osu.Game/Beatmaps/Formats/LegacyDifficultyCalculatorBeatmapDecoder.cs

@@ -24,6 +24,7 @@ namespace osu.Game.Beatmaps.Formats
         public new static void Register()
         {
             AddDecoder<Beatmap>(@"osu file format v", m => new LegacyDifficultyCalculatorBeatmapDecoder(int.Parse(m.Split('v').Last())));
+            SetFallbackDecoder<Beatmap>(() => new LegacyDifficultyCalculatorBeatmapDecoder());
         }
 
         protected override TimingControlPoint CreateTimingControlPoint()

osu.Game/Beatmaps/Formats/LegacyStoryboardDecoder.cs

@@ -10,6 +10,7 @@ using osuTK;
 using osuTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Framework.IO.File;
+using osu.Game.IO;
 using osu.Game.Storyboards;
 
 namespace osu.Game.Beatmaps.Formats
@@ -33,9 +34,10 @@ namespace osu.Game.Beatmaps.Formats
             // note that this isn't completely correct
             AddDecoder<Storyboard>(@"osu file format v", m => new LegacyStoryboardDecoder());
             AddDecoder<Storyboard>(@"[Events]", m => new LegacyStoryboardDecoder());
+            SetFallbackDecoder<Storyboard>(() => new LegacyStoryboardDecoder());
         }
 
-        protected override void ParseStreamInto(StreamReader stream, Storyboard storyboard)
+        protected override void ParseStreamInto(LineBufferedReader stream, Storyboard storyboard)
         {
             this.storyboard = storyboard;
             base.ParseStreamInto(stream, storyboard);

osu.Game/Configuration/InMemoryConfigManager.cs

@@ -0,0 +1,22 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Configuration;
+
+namespace osu.Game.Configuration
+{
+    public class InMemoryConfigManager<T> : ConfigManager<T>
+        where T : struct
+    {
+        public InMemoryConfigManager()
+        {
+            InitialiseDefaults();
+        }
+
+        protected override void PerformLoad()
+        {
+        }
+
+        protected override bool PerformSave() => true;
+    }
+}

osu.Game/Configuration/IntroSequence.cs

@@ -6,6 +6,7 @@ namespace osu.Game.Configuration
     public enum IntroSequence
     {
         Circles,
-        Triangles
+        Triangles,
+        Random
     }
 }

osu.Game/Configuration/OsuConfigManager.cs

@@ -114,7 +114,7 @@ namespace osu.Game.Configuration
 
             Set(OsuSetting.UIScale, 1f, 0.8f, 1.6f, 0.01f);
 
-            Set(OsuSetting.UIHoldActivationDelay, 200, 0, 500);
+            Set(OsuSetting.UIHoldActivationDelay, 200f, 0f, 500f, 50f);
 
             Set(OsuSetting.IntroSequence, IntroSequence.Triangles);
         }

osu.Game/Configuration/SessionStatics.cs

@@ -0,0 +1,23 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Game.Configuration
+{
+    /// <summary>
+    /// Stores global per-session statics. These will not be stored after exiting the game.
+    /// </summary>
+    public class SessionStatics : InMemoryConfigManager<Static>
+    {
+        protected override void InitialiseDefaults()
+        {
+            Set(Static.LoginOverlayDisplayed, false);
+            Set(Static.MutedAudioNotificationShownOnce, false);
+        }
+    }
+
+    public enum Static
+    {
+        LoginOverlayDisplayed,
+        MutedAudioNotificationShownOnce
+    }
+}

osu.Game/Database/ArchiveModelManager.cs

@@ -400,20 +400,17 @@ namespace osu.Game.Database
 
             int i = 0;
 
-            using (ContextFactory.GetForWrite())
+            foreach (var b in items)
             {
-                foreach (var b in items)
+                if (notification.State == ProgressNotificationState.Cancelled)
-                {
+                    // user requested abort
-                    if (notification.State == ProgressNotificationState.Cancelled)
+                    return;
-                        // user requested abort
-                        return;
 
-                    notification.Text = $"Deleting {HumanisedModelName}s ({++i} of {items.Count})";
+                notification.Text = $"Deleting {HumanisedModelName}s ({++i} of {items.Count})";
 
-                    Delete(b);
+                Delete(b);
 
-                    notification.Progress = (float)i / items.Count;
+                notification.Progress = (float)i / items.Count;
-                }
             }
 
             notification.State = ProgressNotificationState.Completed;
@@ -439,20 +436,17 @@ namespace osu.Game.Database
 
             int i = 0;
 
-            using (ContextFactory.GetForWrite())
+            foreach (var item in items)
             {
-                foreach (var item in items)
+                if (notification.State == ProgressNotificationState.Cancelled)
-                {
+                    // user requested abort
-                    if (notification.State == ProgressNotificationState.Cancelled)
+                    return;
-                        // user requested abort
-                        return;
 
-                    notification.Text = $"Restoring ({++i} of {items.Count})";
+                notification.Text = $"Restoring ({++i} of {items.Count})";
 
-                    Undelete(item);
+                Undelete(item);
 
-                    notification.Progress = (float)i / items.Count;
+                notification.Progress = (float)i / items.Count;
-                }
             }
 
             notification.State = ProgressNotificationState.Completed;

osu.Game/Graphics/Containers/HoldToConfirmContainer.cs

@@ -30,12 +30,12 @@ namespace osu.Game.Graphics.Containers
 
         public Bindable<double> Progress = new BindableDouble();
 
-        private Bindable<int> holdActivationDelay;
+        private Bindable<float> holdActivationDelay;
 
         [BackgroundDependencyLoader]
         private void load(OsuConfigManager config)
         {
-            holdActivationDelay = config.GetBindable<int>(OsuSetting.UIHoldActivationDelay);
+            holdActivationDelay = config.GetBindable<float>(OsuSetting.UIHoldActivationDelay);
         }
 
         protected void BeginConfirm()

osu.Game/Graphics/UserInterface/BackButton.cs

@@ -10,14 +10,16 @@ using osu.Game.Input.Bindings;
 
 namespace osu.Game.Graphics.UserInterface
 {
-    public class BackButton : VisibilityContainer, IKeyBindingHandler<GlobalAction>
+    public class BackButton : VisibilityContainer
     {
         public Action Action;
 
         private readonly TwoLayerButton button;
 
-        public BackButton()
+        public BackButton(Receptor receptor)
         {
+            receptor.OnBackPressed = () => button.Click();
+
             Size = TwoLayerButton.SIZE_EXTENDED;
 
             Child = button = new TwoLayerButton
@@ -37,19 +39,6 @@ namespace osu.Game.Graphics.UserInterface
             button.HoverColour = colours.PinkDark;
         }
 
-        public bool OnPressed(GlobalAction action)
-        {
-            if (action == GlobalAction.Back)
-            {
-                Action?.Invoke();
-                return true;
-            }
-
-            return false;
-        }
-
-        public bool OnReleased(GlobalAction action) => action == GlobalAction.Back;
-
         protected override void PopIn()
         {
             button.MoveToX(0, 400, Easing.OutQuint);
@@ -61,5 +50,24 @@ namespace osu.Game.Graphics.UserInterface
             button.MoveToX(-TwoLayerButton.SIZE_EXTENDED.X / 2, 400, Easing.OutQuint);
             button.FadeOut(400, Easing.OutQuint);
         }
+
+        public class Receptor : Drawable, IKeyBindingHandler<GlobalAction>
+        {
+            public Action OnBackPressed;
+
+            public bool OnPressed(GlobalAction action)
+            {
+                switch (action)
+                {
+                    case GlobalAction.Back:
+                        OnBackPressed?.Invoke();
+                        return true;
+                }
+
+                return false;
+            }
+
+            public bool OnReleased(GlobalAction action) => action == GlobalAction.Back;
+        }
     }
 }

osu.Game/Graphics/UserInterface/FocusedTextBox.cs

@@ -2,22 +2,20 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osuTK.Graphics;
-using System;
 using osu.Framework.Allocation;
 using osu.Framework.Input.Events;
 using osu.Framework.Platform;
 using osu.Game.Input.Bindings;
 using osuTK.Input;
+using osu.Framework.Input.Bindings;
 
 namespace osu.Game.Graphics.UserInterface
 {
     /// <summary>
     /// A textbox which holds focus eagerly.
     /// </summary>
-    public class FocusedTextBox : OsuTextBox
+    public class FocusedTextBox : OsuTextBox, IKeyBindingHandler<GlobalAction>
     {
-        public Action Exit;
-
         private bool focus;
 
         private bool allowImmediateFocus => host?.OnScreenKeyboardOverlapsGameWindow != true;
@@ -63,12 +61,12 @@ namespace osu.Game.Graphics.UserInterface
             if (!HasFocus) return false;
 
             if (e.Key == Key.Escape)
-                return false; // disable the framework-level handling of escape key for confority (we use GlobalAction.Back).
+                return false; // disable the framework-level handling of escape key for conformity (we use GlobalAction.Back).
 
             return base.OnKeyDown(e);
         }
 
-        public override bool OnPressed(GlobalAction action)
+        public bool OnPressed(GlobalAction action)
         {
             if (action == GlobalAction.Back)
             {
@@ -79,14 +77,10 @@ namespace osu.Game.Graphics.UserInterface
                 }
             }
 
-            return base.OnPressed(action);
+            return false;
         }
 
-        protected override void KillFocus()
+        public bool OnReleased(GlobalAction action) => false;
-        {
-            base.KillFocus();
-            Exit?.Invoke();
-        }
 
         public override bool RequestsFocus => HoldFocus;
     }

osu.Game/Graphics/UserInterface/OsuTextBox.cs

@@ -8,13 +8,11 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Game.Graphics.Sprites;
 using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
-using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
-using osu.Game.Input.Bindings;
 
 namespace osu.Game.Graphics.UserInterface
 {
-    public class OsuTextBox : TextBox, IKeyBindingHandler<GlobalAction>
+    public class OsuTextBox : TextBox
     {
         protected override float LeftRightPadding => 10;
 
@@ -57,18 +55,5 @@ namespace osu.Game.Graphics.UserInterface
         }
 
         protected override Drawable GetDrawableCharacter(char c) => new OsuSpriteText { Text = c.ToString(), Font = OsuFont.GetFont(size: CalculatedTextSize) };
-
-        public virtual bool OnPressed(GlobalAction action)
-        {
-            if (action == GlobalAction.Back)
-            {
-                KillFocus();
-                return true;
-            }
-
-            return false;
-        }
-
-        public bool OnReleased(GlobalAction action) => false;
     }
 }

osu.Game/Graphics/UserInterfaceV2/LabelledComponent.cs

@@ -5,13 +5,13 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osuTK;
 
-namespace osu.Game.Screens.Edit.Setup.Components.LabelledComponents
+namespace osu.Game.Graphics.UserInterfaceV2
 {
-    public abstract class LabelledComponent : CompositeDrawable
+    public abstract class LabelledComponent<T> : CompositeDrawable
+        where T : Drawable
     {
         protected const float CONTENT_PADDING_VERTICAL = 10;
         protected const float CONTENT_PADDING_HORIZONTAL = 15;
@@ -20,15 +20,15 @@ namespace osu.Game.Screens.Edit.Setup.Components.LabelledComponents
         /// <summary>
         /// The component that is being displayed.
         /// </summary>
-        protected readonly Drawable Component;
+        protected readonly T Component;
 
         private readonly OsuTextFlowContainer labelText;
         private readonly OsuTextFlowContainer descriptionText;
 
         /// <summary>
-        /// Creates a new <see cref="LabelledComponent"/>.
+        /// Creates a new <see cref="LabelledComponent{T}"/>.
         /// </summary>
-        /// <param name="padded">Whether the component should be padded or should be expanded to the bounds of this <see cref="LabelledComponent"/>.</param>
+        /// <param name="padded">Whether the component should be padded or should be expanded to the bounds of this <see cref="LabelledComponent{T}"/>.</param>
         protected LabelledComponent(bool padded)
         {
             RelativeSizeAxes = Axes.X;
@@ -127,6 +127,6 @@ namespace osu.Game.Screens.Edit.Setup.Components.LabelledComponents
         /// Creates the component that should be displayed.
         /// </summary>
         /// <returns>The component.</returns>
-        protected abstract Drawable CreateComponent();
+        protected abstract T CreateComponent();
     }
 }

osu.Game/Graphics/UserInterfaceV2/LabelledSwitchButton.cs

@@ -0,0 +1,15 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Game.Graphics.UserInterfaceV2
+{
+    public class LabelledSwitchButton : LabelledComponent<SwitchButton>
+    {
+        public LabelledSwitchButton()
+            : base(true)
+        {
+        }
+
+        protected override SwitchButton CreateComponent() => new SwitchButton();
+    }
+}

osu.Game/Graphics/UserInterfaceV2/LabelledTextBox.cs

@@ -0,0 +1,49 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterface;
+
+namespace osu.Game.Graphics.UserInterfaceV2
+{
+    public class LabelledTextBox : LabelledComponent<OsuTextBox>
+    {
+        public event TextBox.OnCommitHandler OnCommit;
+
+        public LabelledTextBox()
+            : base(false)
+        {
+        }
+
+        public bool ReadOnly
+        {
+            set => Component.ReadOnly = value;
+        }
+
+        public string PlaceholderText
+        {
+            set => Component.PlaceholderText = value;
+        }
+
+        public string Text
+        {
+            set => Component.Text = value;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Component.BorderColour = colours.Blue;
+        }
+
+        protected override OsuTextBox CreateComponent() => new OsuTextBox
+        {
+            Anchor = Anchor.Centre,
+            Origin = Anchor.Centre,
+            RelativeSizeAxes = Axes.X,
+            CornerRadius = CORNER_RADIUS,
+        }.With(t => t.OnCommit += (sender, newText) => OnCommit?.Invoke(sender, newText));
+    }
+}

osu.Game/Graphics/UserInterfaceV2/SwitchButton.cs

@@ -0,0 +1,118 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input.Events;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Graphics.UserInterfaceV2
+{
+    public class SwitchButton : Checkbox
+    {
+        private const float border_thickness = 4.5f;
+        private const float padding = 1.25f;
+
+        private readonly Box fill;
+        private readonly Container switchContainer;
+        private readonly Drawable switchCircle;
+        private readonly CircularBorderContainer circularContainer;
+
+        private Color4 enabledColour;
+        private Color4 disabledColour;
+
+        public SwitchButton()
+        {
+            Size = new Vector2(45, 20);
+
+            InternalChild = circularContainer = new CircularBorderContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                BorderColour = Color4.White,
+                BorderThickness = border_thickness,
+                Masking = true,
+                Children = new Drawable[]
+                {
+                    fill = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        AlwaysPresent = true,
+                        Alpha = 0
+                    },
+                    new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Padding = new MarginPadding(border_thickness + padding),
+                        Child = switchContainer = new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Child = switchCircle = new CircularContainer
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                FillMode = FillMode.Fit,
+                                Masking = true,
+                                Child = new Box { RelativeSizeAxes = Axes.Both }
+                            }
+                        }
+                    }
+                }
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            enabledColour = colours.BlueDark;
+            disabledColour = colours.Gray3;
+
+            switchContainer.Colour = enabledColour;
+            fill.Colour = disabledColour;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Current.BindValueChanged(updateState, true);
+            FinishTransforms(true);
+        }
+
+        private void updateState(ValueChangedEvent<bool> state)
+        {
+            switchCircle.MoveToX(state.NewValue ? switchContainer.DrawWidth - switchCircle.DrawWidth : 0, 200, Easing.OutQuint);
+            fill.FadeTo(state.NewValue ? 1 : 0, 250, Easing.OutQuint);
+
+            updateBorder();
+        }
+
+        protected override bool OnHover(HoverEvent e)
+        {
+            updateBorder();
+            return base.OnHover(e);
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            updateBorder();
+            base.OnHoverLost(e);
+        }
+
+        private void updateBorder()
+        {
+            circularContainer.TransformBorderTo((Current.Value ? enabledColour : disabledColour).Lighten(IsHovered ? 0.3f : 0));
+        }
+
+        private class CircularBorderContainer : CircularContainer
+        {
+            public void TransformBorderTo(SRGBColour colour)
+                => this.TransformTo(nameof(BorderColour), colour, 250, Easing.OutQuint);
+        }
+    }
+}