Merge pull request #1210 from smoogipooo/new-menus

Update framework in line with the new Menu changes

.vscode/launch.json

@@ -1,34 +1,22 @@
 {
     "version": "0.2.0",
-    "configurations": [
-        {
-            "name": "VisualTests (debug)",
+    "configurations": [{
+            "name": "osu! (VisualTests)",
             "windows": {
                 "type": "clr"
             },
             "type": "mono",
             "request": "launch",
-            "program": "${workspaceRoot}/osu.Desktop.VisualTests/bin/Debug/osu!.exe",
+            "program": "${workspaceRoot}/osu.Desktop/bin/Debug/osu!.exe",
+            "args": [
+                "--tests"
+            ],
             "cwd": "${workspaceRoot}",
             "preLaunchTask": "Build (Debug)",
             "runtimeExecutable": null,
             "env": {},
             "console": "internalConsole"
         },
-        {
-            "name": "VisualTests (release)",
-            "windows": {
-                "type": "clr"
-            },
-            "type": "mono",
-            "request": "launch",
-            "program": "${workspaceRoot}/osu.Desktop.VisualTests/bin/Release/osu!.exe",
-            "cwd": "${workspaceRoot}",
-            "preLaunchTask": "Build (Release)",
-            "runtimeExecutable": null,
-            "env": {},
-            "console": "internalConsole"
-        },
         {
             "name": "osu! (debug)",
             "windows": {

.vscode/tasks.json

@@ -2,35 +2,41 @@
     // See https://go.microsoft.com/fwlink/?LinkId=733558
     // for the documentation about the tasks.json format
     "version": "2.0.0",
-    "problemMatcher": "$msCompile",
-    "isShellCommand": true,
     "command": "msbuild",
+    "type": "shell",
     "suppressTaskName": true,
-    "showOutput": "silent",
     "args": [
         "/property:GenerateFullPaths=true",
         "/property:DebugType=portable",
+        "/verbosity:minimal",
         "/m" //parallel compiling support.
     ],
-    "tasks": [
-        {
+    "tasks": [{
             "taskName": "Build (Debug)",
-            "isBuildCommand": true
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "problemMatcher": [
+                "$msCompile"
+            ]
         },
         {
             "taskName": "Build (Release)",
             "args": [
                 "/property:Configuration=Release"
+            ],
+            "problemMatcher": [
+                "$msCompile"
             ]
         },
-        {
-            "taskName": "Clean All",
-            "dependsOn": ["Clean (Debug)", "Clean (Release)"]
-        },
         {
             "taskName": "Clean (Debug)",
             "args": [
                 "/target:Clean"
+            ],
+            "problemMatcher": [
+                "$msCompile"
             ]
         },
         {
@@ -38,6 +44,19 @@
             "args": [
                 "/target:Clean",
                 "/property:Configuration=Release"
+            ],
+            "problemMatcher": [
+                "$msCompile"
+            ]
+        },
+        {
+            "taskName": "Clean All",
+            "dependsOn": [
+                "Clean (Debug)",
+                "Clean (Release)"
+            ],
+            "problemMatcher": [
+                "$msCompile"
             ]
         }
     ]

osu.Desktop.Deploy/Program.cs

@@ -17,8 +17,8 @@ namespace osu.Desktop.Deploy
 {
     internal static class Program
     {
-        private const string nuget_path = @"packages\NuGet.CommandLine.3.5.0\tools\NuGet.exe";
-        private const string squirrel_path = @"packages\squirrel.windows.1.5.2\tools\Squirrel.exe";
+        private const string nuget_path = @"packages\NuGet.CommandLine.4.1.0\tools\NuGet.exe";
+        private const string squirrel_path = @"packages\squirrel.windows.1.7.5\tools\Squirrel.exe";
         private const string msbuild_path = @"C:\Program Files (x86)\MSBuild\14.0\Bin\MSBuild.exe";
 
         public static string StagingFolder = ConfigurationManager.AppSettings["StagingFolder"];

osu.Desktop.Tests/Beatmaps/TestWorkingBeatmap.cs

@@ -5,7 +5,7 @@ using osu.Framework.Audio.Track;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Beatmaps;
 
-namespace osu.Desktop.VisualTests.Beatmaps
+namespace osu.Desktop.Tests.Beatmaps
 {
     public class TestWorkingBeatmap : WorkingBeatmap
     {

osu.Desktop.Tests/Platform/TestStorage.cs

@@ -8,7 +8,7 @@ using SQLite.Net.Interop;
 using SQLite.Net.Platform.Generic;
 using SQLite.Net.Platform.Win32;
 
-namespace osu.Desktop.VisualTests.Platform
+namespace osu.Desktop.Tests.Platform
 {
     public class TestStorage : DesktopStorage
     {

osu.Desktop.Tests/Visual/OsuTestCase.cs

@@ -0,0 +1,37 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using NUnit.Framework;
+using osu.Framework.Desktop.Platform;
+using osu.Framework.Testing;
+using osu.Game;
+
+namespace osu.Desktop.Tests.Visual
+{
+    [TestFixture]
+    public abstract class OsuTestCase : TestCase
+    {
+        [Test]
+        public override void RunTest()
+        {
+            using (var host = new HeadlessGameHost(realtime: false))
+                host.Run(new OsuTestCaseTestRunner(this));
+        }
+
+        public class OsuTestCaseTestRunner : OsuGameBase
+        {
+            private readonly OsuTestCase testCase;
+
+            public OsuTestCaseTestRunner(OsuTestCase testCase)
+            {
+                this.testCase = testCase;
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                Add(new TestCaseTestRunner.TestRunner(testCase));
+            }
+        }
+    }
+}

osu.Desktop.Tests/Visual/TestCaseBeatSyncedContainer.cs

@@ -1,24 +1,23 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Testing;
-using osu.Framework.Graphics;
-using osu.Framework.Timing;
-using osu.Game.Overlays;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Graphics.Containers;
-using osu.Framework.Audio.Track;
-using osu.Game.Beatmaps.ControlPoints;
-using osu.Framework.Graphics.Shapes;
-using OpenTK.Graphics;
-using osu.Game.Graphics.Sprites;
-using osu.Framework.Lists;
 using System;
+using osu.Framework.Audio.Track;
 using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Lists;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Overlays;
+using OpenTK.Graphics;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseBeatSyncedContainer : TestCase
+    internal class TestCaseBeatSyncedContainer : OsuTestCase
     {
         public override string Description => @"Tests beat synced containers.";
 

osu.Desktop.Tests/Visual/TestCaseBeatmapDetailArea.cs

@@ -1,14 +1,15 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK;
+using NUnit.Framework;
 using osu.Framework.Graphics;
-using osu.Framework.Testing;
 using osu.Game.Screens.Select;
+using OpenTK;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseBeatmapDetailArea : TestCase
+    [TestFixture]
+    internal class TestCaseBeatmapDetailArea : OsuTestCase
     {
         public override string Description => @"Beatmap details in song select";
 

osu.Desktop.Tests/Visual/TestCaseBeatmapDetails.cs

@@ -1,15 +1,14 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Graphics;
-using osu.Framework.Testing;
-using osu.Game.Screens.Select;
 using System.Linq;
+using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
+using osu.Game.Screens.Select;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseBeatmapDetails : TestCase
+    internal class TestCaseBeatmapDetails : OsuTestCase
     {
         public override string Description => "BeatmapDetails tab of BeatmapDetailArea";
 

osu.Desktop.Tests/Visual/TestCaseBeatmapOptionsOverlay.cs

@@ -1,15 +1,14 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK.Graphics;
-using OpenTK.Input;
-using osu.Framework.Testing;
 using osu.Game.Graphics;
 using osu.Game.Screens.Select.Options;
+using OpenTK.Graphics;
+using OpenTK.Input;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseBeatmapOptionsOverlay : TestCase
+    internal class TestCaseBeatmapOptionsOverlay : OsuTestCase
     {
         public override string Description => @"Beatmap options in song select";
 

osu.Desktop.Tests/Visual/TestCaseBreadcrumbs.cs

@@ -1,13 +1,12 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Testing;
-using osu.Game.Graphics.UserInterface;
 using osu.Framework.Graphics;
+using osu.Game.Graphics.UserInterface;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseBreadcrumbs : TestCase
+    internal class TestCaseBreadcrumbs : OsuTestCase
     {
         public override string Description => @"breadcrumb > control";
 

osu.Desktop.Tests/Visual/TestCaseCatcher.cs

@@ -0,0 +1,35 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Catch;
+using osu.Game.Rulesets.Catch.UI;
+using OpenTK;
+
+namespace osu.Desktop.Tests.Visual
+{
+    internal class TestCaseCatcher : OsuTestCase
+    {
+        [BackgroundDependencyLoader]
+        private void load(RulesetStore rulesets)
+        {
+            Children = new Drawable[]
+            {
+                new CatchInputManager(rulesets.GetRuleset(2))
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Child = new CatcherArea
+                    {
+                        RelativePositionAxes = Axes.Both,
+                        RelativeSizeAxes = Axes.Both,
+                        Anchor = Anchor.BottomLeft,
+                        Origin = Anchor.BottomLeft,
+                        Size = new Vector2(1, 0.2f),
+                    }
+                },
+            };
+        }
+    }
+}

osu.Desktop.Tests/Visual/TestCaseChatDisplay.cs

@@ -1,13 +1,12 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Testing;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Overlays;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseChatDisplay : TestCase
+    internal class TestCaseChatDisplay : OsuTestCase
     {
         public override string Description => @"Testing chat api and overlay";
 

osu.Desktop.Tests/Visual/TestCaseContextMenu.cs

@@ -1,19 +1,18 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK;
-using OpenTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Testing;
 using osu.Game.Graphics.UserInterface;
+using OpenTK;
+using OpenTK.Graphics;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseContextMenu : TestCase
+    internal class TestCaseContextMenu : OsuTestCase
     {
         public override string Description => @"Menu visible on right click";
 
@@ -70,28 +69,28 @@ namespace osu.Desktop.VisualTests.Tests
 
         private class MyContextMenuContainer : Container, IHasContextMenu
         {
-            public ContextMenuItem[] ContextMenuItems => new ContextMenuItem[]
+            public MenuItem[] ContextMenuItems => new MenuItem[]
             {
-                new OsuContextMenuItem(@"Some option"),
-                new OsuContextMenuItem(@"Highlighted option", MenuItemType.Highlighted),
-                new OsuContextMenuItem(@"Another option"),
-                new OsuContextMenuItem(@"Choose me please"),
-                new OsuContextMenuItem(@"And me too"),
-                new OsuContextMenuItem(@"Trying to fill"),
-                new OsuContextMenuItem(@"Destructive option", MenuItemType.Destructive),
+                new OsuMenuItem(@"Some option"),
+                new OsuMenuItem(@"Highlighted option", MenuItemType.Highlighted),
+                new OsuMenuItem(@"Another option"),
+                new OsuMenuItem(@"Choose me please"),
+                new OsuMenuItem(@"And me too"),
+                new OsuMenuItem(@"Trying to fill"),
+                new OsuMenuItem(@"Destructive option", MenuItemType.Destructive),
             };
         }
 
         private class AnotherContextMenuContainer : Container, IHasContextMenu
         {
-            public ContextMenuItem[] ContextMenuItems => new ContextMenuItem[]
+            public MenuItem[] ContextMenuItems => new MenuItem[]
             {
-                new OsuContextMenuItem(@"Simple option"),
-                new OsuContextMenuItem(@"Simple very very long option"),
-                new OsuContextMenuItem(@"Change width", MenuItemType.Highlighted) { Action = () => this.ResizeWidthTo(Width * 2, 100, Easing.OutQuint) },
-                new OsuContextMenuItem(@"Change height", MenuItemType.Highlighted) { Action = () => this.ResizeHeightTo(Height * 2, 100, Easing.OutQuint) },
-                new OsuContextMenuItem(@"Change width back", MenuItemType.Destructive) { Action = () => this.ResizeWidthTo(Width / 2, 100, Easing.OutQuint) },
-                new OsuContextMenuItem(@"Change height back", MenuItemType.Destructive) { Action = () => this.ResizeHeightTo(Height / 2, 100, Easing.OutQuint) },
+                new OsuMenuItem(@"Simple option"),
+                new OsuMenuItem(@"Simple very very long option"),
+                new OsuMenuItem(@"Change width", MenuItemType.Highlighted, () => this.ResizeWidthTo(Width * 2, 100, Easing.OutQuint)),
+                new OsuMenuItem(@"Change height", MenuItemType.Highlighted, () => this.ResizeHeightTo(Height * 2, 100, Easing.OutQuint)),
+                new OsuMenuItem(@"Change width back", MenuItemType.Destructive, () => this.ResizeWidthTo(Width / 2, 100, Easing.OutQuint)),
+                new OsuMenuItem(@"Change height back", MenuItemType.Destructive, () => this.ResizeHeightTo(Height / 2, 100, Easing.OutQuint)),
             };
         }
     }

osu.Desktop.Tests/Visual/TestCaseDialogOverlay.cs

@@ -1,14 +1,13 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Testing;
 using osu.Game.Graphics;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Dialog;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseDialogOverlay : TestCase
+    internal class TestCaseDialogOverlay : OsuTestCase
     {
         public override string Description => @"Display dialogs";
 

osu.Desktop.Tests/Visual/TestCaseDirect.cs

@@ -3,14 +3,13 @@
 
 using System.Collections.Generic;
 using osu.Framework.Allocation;
-using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Overlays;
 using osu.Game.Rulesets;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    public class TestCaseDirect : TestCase
+    public class TestCaseDirect : OsuTestCase
     {
         public override string Description => @"osu!direct overlay";
 

osu.Desktop.Tests/Visual/TestCaseDrawableRoom.cs

@@ -1,19 +1,18 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics;
-using osu.Framework.Testing;
-using osu.Game.Screens.Multiplayer;
-using osu.Game.Online.Multiplayer;
-using osu.Game.Users;
 using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
+using osu.Game.Online.Multiplayer;
 using osu.Game.Rulesets;
+using osu.Game.Screens.Multiplayer;
+using osu.Game.Users;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseDrawableRoom : TestCase
+    internal class TestCaseDrawableRoom : OsuTestCase
     {
         public override string Description => @"Select your favourite room";
 

osu.Desktop.Tests/Visual/TestCaseDrawings.cs

@@ -2,13 +2,12 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Collections.Generic;
-using osu.Framework.Testing;
 using osu.Game.Screens.Tournament;
 using osu.Game.Screens.Tournament.Teams;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseDrawings : TestCase
+    internal class TestCaseDrawings : OsuTestCase
     {
         public override string Description => "Tournament drawings";
 

osu.Desktop.Tests/Visual/TestCaseGamefield.cs

@@ -1,28 +1,31 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK;
+using System.Collections.Generic;
+using osu.Desktop.Tests.Beatmaps;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.MathUtils;
-using osu.Framework.Testing;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Catch.UI;
-using osu.Game.Rulesets.Mania.UI;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.UI;
-using osu.Game.Rulesets.Taiko.UI;
-using System.Collections.Generic;
-using osu.Desktop.VisualTests.Beatmaps;
-using osu.Framework.Allocation;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Catch;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Mania;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.Taiko;
+using osu.Game.Rulesets.Taiko.UI;
+using OpenTK;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseGamefield : TestCase
+    internal class TestCaseGamefield : OsuTestCase
     {
         private RulesetStore rulesets;
 
@@ -85,25 +88,25 @@ namespace osu.Desktop.VisualTests.Tests
                     Clock = new FramedClock(),
                     Children = new Drawable[]
                     {
-                        new OsuHitRenderer(beatmap, false)
+                        new OsuRulesetContainer(new OsuRuleset(new RulesetInfo()), beatmap, false)
                         {
                             Scale = new Vector2(0.5f),
                             Anchor = Anchor.TopLeft,
                             Origin = Anchor.TopLeft
                         },
-                        new TaikoHitRenderer(beatmap, false)
+                        new TaikoRulesetContainer(new TaikoRuleset(new RulesetInfo()),beatmap, false)
                         {
                             Scale = new Vector2(0.5f),
                             Anchor = Anchor.TopRight,
                             Origin = Anchor.TopRight
                         },
-                        new CatchHitRenderer(beatmap, false)
+                        new CatchRulesetContainer(new CatchRuleset(new RulesetInfo()),beatmap, false)
                         {
                             Scale = new Vector2(0.5f),
                             Anchor = Anchor.BottomLeft,
                             Origin = Anchor.BottomLeft
                         },
-                        new ManiaHitRenderer(beatmap, false)
+                        new ManiaRulesetContainer(new ManiaRuleset(new RulesetInfo()),beatmap, false)
                         {
                             Scale = new Vector2(0.5f),
                             Anchor = Anchor.BottomRight,

osu.Desktop.Tests/Visual/TestCaseGraph.cs

@@ -1,15 +1,14 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK;
-using osu.Framework.Graphics;
-using osu.Framework.Testing;
-using osu.Game.Graphics.UserInterface;
 using System.Linq;
+using osu.Framework.Graphics;
+using osu.Game.Graphics.UserInterface;
+using OpenTK;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseGraph : TestCase
+    internal class TestCaseGraph : OsuTestCase
     {
         public override string Description => "graph";
 

osu.Desktop.Tests/Visual/TestCaseHitObjects.cs

@@ -1,62 +1,39 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK;
-using OpenTK.Graphics;
-using osu.Framework.Configuration;
+using System.Collections.Generic;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Testing;
 using osu.Framework.Timing;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using System.Collections.Generic;
+using OpenTK;
+using osu.Game.Rulesets.Osu;
+using osu.Framework.Allocation;
+using osu.Game.Rulesets;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseHitObjects : TestCase
+    internal class TestCaseHitObjects : OsuTestCase
     {
-        private readonly FramedClock framedClock;
+        private FramedClock framedClock;
 
         private bool auto;
 
-        public TestCaseHitObjects()
+        [BackgroundDependencyLoader]
+        private void load(RulesetStore rulesets)
         {
             var rateAdjustClock = new StopwatchClock(true);
             framedClock = new FramedClock(rateAdjustClock);
-            playbackSpeed.ValueChanged += delegate { rateAdjustClock.Rate = playbackSpeed.Value; };
-
-            playbackSpeed.TriggerChange();
 
             AddStep(@"circles", () => loadHitobjects(HitObjectType.Circle));
             AddStep(@"slider", () => loadHitobjects(HitObjectType.Slider));
             AddStep(@"spinner", () => loadHitobjects(HitObjectType.Spinner));
 
-            AddToggleStep(@"auto", state => { auto = state; loadHitobjects(mode); });
-
-            BasicSliderBar<double> sliderBar;
-            Add(new Container
-            {
-                Anchor = Anchor.TopRight,
-                Origin = Anchor.TopRight,
-                AutoSizeAxes = Axes.Both,
-                Children = new Drawable[]
-                {
-                    new SpriteText { Text = "Playback Speed" },
-                    sliderBar = new BasicSliderBar<double>
-                    {
-                        Width = 150,
-                        Height = 10,
-                        SelectionColor = Color4.Orange,
-                    }
-                }
-            });
-
-            sliderBar.Current.BindTo(playbackSpeed);
+            AddToggleStep("Auto", state => { auto = state; loadHitobjects(mode); });
+            AddSliderStep("Playback speed", 0.0, 2.0, 0.5, v => rateAdjustClock.Rate = v);
 
             framedClock.ProcessFrame();
 
@@ -66,7 +43,7 @@ namespace osu.Desktop.VisualTests.Tests
                 Clock = framedClock,
                 Children = new[]
                 {
-                    playfieldContainer = new Container { RelativeSizeAxes = Axes.Both },
+                    playfieldContainer = new OsuInputManager(rulesets.GetRuleset(0)) { RelativeSizeAxes = Axes.Both },
                     approachContainer = new Container { RelativeSizeAxes = Axes.Both }
                 }
             };
@@ -76,9 +53,8 @@ namespace osu.Desktop.VisualTests.Tests
 
         private HitObjectType mode = HitObjectType.Slider;
 
-        private readonly BindableNumber<double> playbackSpeed = new BindableDouble(0.5) { MinValue = 0, MaxValue = 1 };
-        private readonly Container playfieldContainer;
-        private readonly Container approachContainer;
+        private Container playfieldContainer;
+        private Container approachContainer;
 
         private void loadHitobjects(HitObjectType mode)
         {

osu.Desktop.Tests/Visual/TestCaseKeyConfiguration.cs

@@ -0,0 +1,25 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Overlays;
+
+namespace osu.Desktop.Tests.Visual
+{
+    public class TestCaseKeyConfiguration : OsuTestCase
+    {
+        private readonly KeyBindingOverlay overlay;
+
+        public override string Description => @"Key configuration";
+
+        public TestCaseKeyConfiguration()
+        {
+            Child = overlay = new KeyBindingOverlay();
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            overlay.Show();
+        }
+    }
+}

osu.Desktop.Tests/Visual/TestCaseKeyCounter.cs

@@ -0,0 +1,41 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Framework.MathUtils;
+using osu.Game.Screens.Play;
+using OpenTK.Input;
+
+namespace osu.Desktop.Tests.Visual
+{
+    internal class TestCaseKeyCounter : OsuTestCase
+    {
+        public override string Description => @"Tests key counter";
+
+        public TestCaseKeyCounter()
+        {
+            KeyCounterCollection kc = new KeyCounterCollection
+            {
+                Origin = Anchor.Centre,
+                Anchor = Anchor.Centre,
+                IsCounting = true,
+                Children = new KeyCounter[]
+                {
+                    new KeyCounterKeyboard(Key.Z),
+                    new KeyCounterKeyboard(Key.X),
+                    new KeyCounterMouse(MouseButton.Left),
+                    new KeyCounterMouse(MouseButton.Right),
+                },
+            };
+
+            AddStep("Add random", () =>
+            {
+                Key key = (Key)((int)Key.A + RNG.Next(26));
+                kc.Add(new KeyCounterKeyboard(key));
+            });
+            AddSliderStep("Fade time", 0, 200, 50, v => kc.FadeTime = v);
+
+            Add(kc);
+        }
+    }
+}

osu.Desktop.Tests/Visual/TestCaseLeaderboard.cs

@@ -1,18 +1,17 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK;
 using osu.Framework.Graphics;
-using osu.Framework.Testing;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Users;
+using OpenTK;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseLeaderboard : TestCase
+    internal class TestCaseLeaderboard : OsuTestCase
     {
         public override string Description => @"From song select";
 

osu.Desktop.Tests/Visual/TestCaseManiaHitObjects.cs

@@ -3,15 +3,15 @@
 
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Testing;
+using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
-using OpenTK.Graphics;
 using OpenTK;
+using OpenTK.Graphics;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseManiaHitObjects : TestCase
+    internal class TestCaseManiaHitObjects : OsuTestCase
     {
         public TestCaseManiaHitObjects()
         {
@@ -41,8 +41,8 @@ namespace osu.Desktop.VisualTests.Tests
                                 RelativeChildSize = new Vector2(1, 10000),
                                 Children = new[]
                                 {
-                                    new DrawableNote(new Note { StartTime = 5000 }) { AccentColour = Color4.Red },
-                                    new DrawableNote(new Note { StartTime = 6000 }) { AccentColour = Color4.Red }
+                                    new DrawableNote(new Note { StartTime = 5000 }, ManiaAction.Key1) { AccentColour = Color4.Red },
+                                    new DrawableNote(new Note { StartTime = 6000 }, ManiaAction.Key1) { AccentColour = Color4.Red }
                                 }
                             }
                         }
@@ -67,7 +67,7 @@ namespace osu.Desktop.VisualTests.Tests
                                     {
                                         StartTime = 5000,
                                         Duration = 1000
-                                    }) { AccentColour = Color4.Red }
+                                    }, ManiaAction.Key1) { AccentColour = Color4.Red }
                                 }
                             }
                         }

osu.Desktop.Tests/Visual/TestCaseManiaPlayfield.cs

@@ -0,0 +1,141 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Timing;
+using osu.Game.Rulesets.Mania;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.Timing;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Timing;
+using osu.Game.Rulesets;
+
+namespace osu.Desktop.Tests.Visual
+{
+    internal class TestCaseManiaPlayfield : OsuTestCase
+    {
+        private const double start_time = 500;
+        private const double duration = 500;
+
+        public override string Description => @"Mania playfield";
+
+        protected override double TimePerAction => 200;
+
+        private RulesetInfo maniaRuleset;
+
+        public TestCaseManiaPlayfield()
+        {
+            AddStep("1 column", () => createPlayfield(1, SpecialColumnPosition.Normal));
+            AddStep("4 columns", () => createPlayfield(4, SpecialColumnPosition.Normal));
+            AddStep("Left special style", () => createPlayfield(4, SpecialColumnPosition.Left));
+            AddStep("Right special style", () => createPlayfield(4, SpecialColumnPosition.Right));
+            AddStep("5 columns", () => createPlayfield(5, SpecialColumnPosition.Normal));
+            AddStep("8 columns", () => createPlayfield(8, SpecialColumnPosition.Normal));
+            AddStep("Left special style", () => createPlayfield(8, SpecialColumnPosition.Left));
+            AddStep("Right special style", () => createPlayfield(8, SpecialColumnPosition.Right));
+            AddStep("Reversed", () => createPlayfield(4, SpecialColumnPosition.Normal, true));
+
+            AddStep("Notes with input", () => createPlayfieldWithNotes(false));
+            AddStep("Notes with input (reversed)", () => createPlayfieldWithNotes(false, true));
+            AddStep("Notes with gravity", () => createPlayfieldWithNotes(true));
+            AddStep("Notes with gravity (reversed)", () => createPlayfieldWithNotes(true, true));
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(RulesetStore rulesets)
+        {
+            maniaRuleset = rulesets.GetRuleset(3);
+        }
+
+        private SpeedAdjustmentContainer createTimingChange(double time, bool gravity) => new ManiaSpeedAdjustmentContainer(new MultiplierControlPoint(time)
+        {
+            TimingPoint = { BeatLength = 1000 }
+        }, gravity ? ScrollingAlgorithm.Gravity : ScrollingAlgorithm.Basic);
+
+        private void createPlayfield(int cols, SpecialColumnPosition specialPos, bool inverted = false)
+        {
+            Clear();
+
+            var inputManager = new ManiaInputManager(maniaRuleset, cols) { RelativeSizeAxes = Axes.Both };
+            Add(inputManager);
+
+            ManiaPlayfield playfield;
+            inputManager.Add(playfield = new ManiaPlayfield(cols)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                SpecialColumnPosition = specialPos
+            });
+
+            playfield.Inverted.Value = inverted;
+        }
+
+        private void createPlayfieldWithNotes(bool gravity, bool inverted = false)
+        {
+            Clear();
+
+            var rateAdjustClock = new StopwatchClock(true) { Rate = 1 };
+
+            var inputManager = new ManiaInputManager(maniaRuleset, 4) { RelativeSizeAxes = Axes.Both };
+            Add(inputManager);
+
+            ManiaPlayfield playfield;
+            inputManager.Add(playfield = new ManiaPlayfield(4)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Clock = new FramedClock(rateAdjustClock)
+            });
+
+            playfield.Inverted.Value = inverted;
+
+            if (!gravity)
+                playfield.Columns.ForEach(c => c.Add(createTimingChange(0, false)));
+
+            for (double t = start_time; t <= start_time + duration; t += 100)
+            {
+                if (gravity)
+                    playfield.Columns.ElementAt(0).Add(createTimingChange(t, true));
+
+                playfield.Add(new DrawableNote(new Note
+                {
+                    StartTime = t,
+                    Column = 0
+                }, ManiaAction.Key1));
+
+                if (gravity)
+                    playfield.Columns.ElementAt(3).Add(createTimingChange(t, true));
+
+                playfield.Add(new DrawableNote(new Note
+                {
+                    StartTime = t,
+                    Column = 3
+                }, ManiaAction.Key4));
+            }
+
+            if (gravity)
+                playfield.Columns.ElementAt(1).Add(createTimingChange(start_time, true));
+
+            playfield.Add(new DrawableHoldNote(new HoldNote
+            {
+                StartTime = start_time,
+                Duration = duration,
+                Column = 1
+            }, ManiaAction.Key2));
+
+            if (gravity)
+                playfield.Columns.ElementAt(2).Add(createTimingChange(start_time, true));
+
+            playfield.Add(new DrawableHoldNote(new HoldNote
+            {
+                StartTime = start_time,
+                Duration = duration,
+                Column = 2
+            }, ManiaAction.Key3));
+        }
+    }
+}

osu.Desktop.Tests/Visual/TestCaseMedalOverlay.cs

@@ -1,13 +1,12 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Testing;
 using osu.Game.Overlays;
 using osu.Game.Users;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseMedalOverlay : TestCase
+    internal class TestCaseMedalOverlay : OsuTestCase
     {
         public override string Description => @"medal get!";
 

osu.Desktop.Tests/Visual/TestCaseMenuButtonSystem.cs

@@ -1,15 +1,14 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Testing;
 using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Shapes;
 using osu.Game.Screens.Menu;
 using OpenTK.Graphics;
-using osu.Framework.Graphics.Shapes;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseMenuButtonSystem : TestCase
+    internal class TestCaseMenuButtonSystem : OsuTestCase
     {
         public override string Description => @"Main menu button system";
 

osu.Desktop.Tests/Visual/TestCaseMenuOverlays.cs

@@ -3,12 +3,11 @@
 
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Logging;
-using osu.Framework.Testing;
 using osu.Game.Screens.Play;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseMenuOverlays : TestCase
+    internal class TestCaseMenuOverlays : OsuTestCase
     {
         public override string Description => @"Tests pause and fail overlays";
 

osu.Desktop.Tests/Visual/TestCaseMods.cs

@@ -4,14 +4,13 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Overlays.Mods;
-using osu.Framework.Testing;
 using osu.Game.Rulesets;
 using osu.Game.Screens.Play.HUD;
 using OpenTK;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseMods : TestCase
+    internal class TestCaseMods : OsuTestCase
     {
         public override string Description => @"Mod select overlay and in-game display";
 

osu.Desktop.Tests/Visual/TestCaseMusicController.cs

@@ -5,15 +5,14 @@ using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Testing;
 using osu.Framework.Timing;
 using osu.Game;
 using osu.Game.Beatmaps;
 using osu.Game.Overlays;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseMusicController : TestCase
+    internal class TestCaseMusicController : OsuTestCase
     {
         public override string Description => @"Tests music controller ui.";
 

osu.Desktop.Tests/Visual/TestCaseNotificationOverlay.cs

@@ -2,17 +2,18 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
 using osu.Framework.Graphics;
-using osu.Framework.Testing;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.MathUtils;
 using osu.Game.Overlays;
-using System.Linq;
 using osu.Game.Overlays.Notifications;
-using osu.Framework.Graphics.Containers;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseNotificationOverlay : TestCase
+    [TestFixture]
+    internal class TestCaseNotificationOverlay : OsuTestCase
     {
         public override string Description => @"I handle notifications";
 
@@ -67,7 +68,7 @@ namespace osu.Desktop.VisualTests.Tests
 
             while (progressingNotifications.Count(n => n.State == ProgressNotificationState.Active) < 3)
             {
-                var p = progressingNotifications.FirstOrDefault(n => n.IsLoaded && n.State == ProgressNotificationState.Queued);
+                var p = progressingNotifications.FirstOrDefault(n => n.IsAlive && n.State == ProgressNotificationState.Queued);
                 if (p == null)
                     break;
 

osu.Desktop.Tests/Visual/TestCaseOnScreenDisplay.cs

@@ -3,12 +3,11 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
-using osu.Framework.Testing;
 using osu.Game.Overlays;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseOnScreenDisplay : TestCase
+    internal class TestCaseOnScreenDisplay : OsuTestCase
     {
         private FrameworkConfigManager config;
         private Bindable<FrameSync> frameSyncMode;

osu.Desktop.Tests/Visual/TestCasePlaySongSelect.cs

@@ -2,8 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Collections.Generic;
-using osu.Desktop.VisualTests.Platform;
-using osu.Framework.Testing;
+using osu.Desktop.Tests.Platform;
 using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
@@ -11,9 +10,9 @@ using osu.Game.Rulesets;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Filter;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCasePlaySongSelect : TestCase
+    internal class TestCasePlaySongSelect : OsuTestCase
     {
         private readonly BeatmapManager manager;
 

osu.Desktop.Tests/Visual/TestCasePlayer.cs

@@ -2,22 +2,21 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Collections.Generic;
+using osu.Desktop.Tests.Beatmaps;
 using osu.Framework.Allocation;
-using osu.Framework.Testing;
+using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps;
-using OpenTK;
+using osu.Game.Rulesets;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Screens.Play;
-using OpenTK.Graphics;
-using osu.Desktop.VisualTests.Beatmaps;
 using osu.Game.Rulesets.Osu.UI;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Rulesets;
+using osu.Game.Screens.Play;
+using OpenTK;
+using OpenTK.Graphics;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCasePlayer : TestCase
+    internal class TestCasePlayer : OsuTestCase
     {
         protected Player Player;
         private RulesetStore rulesets;

osu.Desktop.Tests/Visual/TestCaseReplay.cs

@@ -6,7 +6,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.Play;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
     internal class TestCaseReplay : TestCasePlayer
     {

osu.Desktop.Tests/Visual/TestCaseReplaySettingsOverlay.cs

@@ -2,14 +2,13 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Graphics;
-using osu.Framework.Testing;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.ReplaySettings;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseReplaySettingsOverlay : TestCase
+    internal class TestCaseReplaySettingsOverlay : OsuTestCase
     {
         public override string Description => @"Settings visible in replay/auto";
 

osu.Desktop.Tests/Visual/TestCaseResults.cs

@@ -4,15 +4,14 @@
 using System;
 using System.Collections.Generic;
 using osu.Framework.Allocation;
-using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Ranking;
 using osu.Game.Users;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseResults : TestCase
+    internal class TestCaseResults : OsuTestCase
     {
         private BeatmapManager beatmaps;
 

osu.Desktop.Tests/Visual/TestCaseRoomInspector.cs

@@ -1,18 +1,17 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Testing;
-using osu.Framework.Graphics;
-using osu.Game.Screens.Multiplayer;
-using osu.Game.Online.Multiplayer;
-using osu.Game.Users;
 using osu.Framework.Allocation;
+using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
+using osu.Game.Online.Multiplayer;
 using osu.Game.Rulesets;
+using osu.Game.Screens.Multiplayer;
+using osu.Game.Users;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseRoomInspector : TestCase
+    internal class TestCaseRoomInspector : OsuTestCase
     {
         public override string Description => @"from the multiplayer lobby";
 

osu.Desktop.Tests/Visual/TestCaseScoreCounter.cs

@@ -1,17 +1,16 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.MathUtils;
-using osu.Framework.Testing;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Screens.Play.HUD;
+using OpenTK;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseScoreCounter : TestCase
+    internal class TestCaseScoreCounter : OsuTestCase
     {
         public override string Description => @"Tests multiple counters";
 

osu.Desktop.Tests/Visual/TestCaseScrollingPlayfield.cs

@@ -0,0 +1,228 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using OpenTK;
+using osu.Desktop.Tests.Beatmaps;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Beatmaps;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Timing;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Desktop.Tests.Visual
+{
+    /// <summary>
+    /// The most minimal implementation of a playfield with scrolling hit objects.
+    /// </summary>
+    [TestFixture]
+    public class TestCaseScrollingPlayfield : OsuTestCase
+    {
+        public TestCaseScrollingPlayfield()
+        {
+            Clock = new FramedClock();
+
+            var objects = new List<HitObject>();
+
+            int time = 1500;
+            for (int i = 0; i < 50; i++)
+            {
+                objects.Add(new TestHitObject { StartTime = time });
+
+                time += 500;
+            }
+
+            Beatmap b = new Beatmap
+            {
+                HitObjects = objects,
+                BeatmapInfo = new BeatmapInfo
+                {
+                    Difficulty = new BeatmapDifficulty(),
+                    Metadata = new BeatmapMetadata()
+                }
+            };
+
+            WorkingBeatmap beatmap = new TestWorkingBeatmap(b);
+
+            TestRulesetContainer horizontalRulesetContainer;
+            Add(horizontalRulesetContainer = new TestRulesetContainer(Axes.X, beatmap, true));
+
+            TestRulesetContainer verticalRulesetContainer;
+            Add(verticalRulesetContainer = new TestRulesetContainer(Axes.Y, beatmap, true));
+
+            AddStep("Reverse direction", () =>
+            {
+                horizontalRulesetContainer.Playfield.Reverse();
+                verticalRulesetContainer.Playfield.Reverse();
+            });
+        }
+
+        [Test]
+        public void TestSpeedAdjustmentOrdering()
+        {
+            var hitObjectContainer = new ScrollingPlayfield<TestHitObject, TestJudgement>.ScrollingHitObjectContainer(Axes.X);
+
+            var speedAdjustments = new[]
+            {
+                new SpeedAdjustmentContainer(new MultiplierControlPoint()),
+                new SpeedAdjustmentContainer(new MultiplierControlPoint(1000)
+                {
+                    TimingPoint = new TimingControlPoint { BeatLength = 500 }
+                }),
+                new SpeedAdjustmentContainer(new MultiplierControlPoint(2000)
+                {
+                    TimingPoint = new TimingControlPoint { BeatLength = 1000 },
+                    DifficultyPoint = new DifficultyControlPoint { SpeedMultiplier = 2}
+                }),
+                new SpeedAdjustmentContainer(new MultiplierControlPoint(3000)
+                {
+                    TimingPoint = new TimingControlPoint { BeatLength = 1000 },
+                    DifficultyPoint = new DifficultyControlPoint { SpeedMultiplier = 1}
+                }),
+            };
+
+            var hitObjects = new[]
+            {
+                new DrawableTestHitObject(Axes.X, new TestHitObject { StartTime = -1000 }),
+                new DrawableTestHitObject(Axes.X, new TestHitObject()),
+                new DrawableTestHitObject(Axes.X, new TestHitObject { StartTime = 1000 }),
+                new DrawableTestHitObject(Axes.X, new TestHitObject { StartTime = 2000 }),
+                new DrawableTestHitObject(Axes.X, new TestHitObject { StartTime = 3000 }),
+                new DrawableTestHitObject(Axes.X, new TestHitObject { StartTime = 4000 }),
+            };
+
+            hitObjects.ForEach(h => hitObjectContainer.Add(h));
+            speedAdjustments.ForEach(hitObjectContainer.AddSpeedAdjustment);
+
+            // The 0th index in hitObjectContainer.SpeedAdjustments is the "default" control point
+            // Check multiplier of the default speed adjustment
+            Assert.AreEqual(1, hitObjectContainer.SpeedAdjustments[0].ControlPoint.Multiplier);
+            Assert.AreEqual(1, speedAdjustments[0].ControlPoint.Multiplier);
+            Assert.AreEqual(2, speedAdjustments[1].ControlPoint.Multiplier);
+            Assert.AreEqual(2, speedAdjustments[2].ControlPoint.Multiplier);
+            Assert.AreEqual(1, speedAdjustments[3].ControlPoint.Multiplier);
+
+            // Check insertion of hit objects
+            Assert.IsTrue(hitObjectContainer.SpeedAdjustments[4].Contains(hitObjects[0]));
+            Assert.IsTrue(hitObjectContainer.SpeedAdjustments[3].Contains(hitObjects[1]));
+            Assert.IsTrue(hitObjectContainer.SpeedAdjustments[2].Contains(hitObjects[2]));
+            Assert.IsTrue(hitObjectContainer.SpeedAdjustments[1].Contains(hitObjects[3]));
+            Assert.IsTrue(hitObjectContainer.SpeedAdjustments[0].Contains(hitObjects[4]));
+            Assert.IsTrue(hitObjectContainer.SpeedAdjustments[0].Contains(hitObjects[5]));
+
+            hitObjectContainer.RemoveSpeedAdjustment(hitObjectContainer.SpeedAdjustments[3]);
+
+            // The hit object contained in this speed adjustment should be resorted into the one occuring before it
+
+            Assert.IsTrue(hitObjectContainer.SpeedAdjustments[3].Contains(hitObjects[1]));
+        }
+
+        private class TestRulesetContainer : ScrollingRulesetContainer<TestPlayfield, TestHitObject, TestJudgement>
+        {
+            private readonly Axes scrollingAxes;
+
+            public TestRulesetContainer(Axes scrollingAxes, WorkingBeatmap beatmap, bool isForCurrentRuleset)
+                : base(null, beatmap, isForCurrentRuleset)
+            {
+                this.scrollingAxes = scrollingAxes;
+            }
+
+            public new TestPlayfield Playfield => base.Playfield;
+
+            public override ScoreProcessor CreateScoreProcessor() => new TestScoreProcessor();
+
+            public override PassThroughInputManager CreateInputManager() => new PassThroughInputManager();
+
+            protected override BeatmapConverter<TestHitObject> CreateBeatmapConverter() => new TestBeatmapConverter();
+
+            protected override Playfield<TestHitObject, TestJudgement> CreatePlayfield() => new TestPlayfield(scrollingAxes);
+
+            protected override DrawableHitObject<TestHitObject, TestJudgement> GetVisualRepresentation(TestHitObject h) => new DrawableTestHitObject(scrollingAxes, h);
+        }
+
+        private class TestScoreProcessor : ScoreProcessor<TestHitObject, TestJudgement>
+        {
+            protected override void OnNewJudgement(TestJudgement judgement)
+            {
+            }
+        }
+
+        private class TestBeatmapConverter : BeatmapConverter<TestHitObject>
+        {
+            protected override IEnumerable<Type> ValidConversionTypes => new[] { typeof(HitObject) };
+
+            protected override IEnumerable<TestHitObject> ConvertHitObject(HitObject original, Beatmap beatmap)
+            {
+                yield return original as TestHitObject;
+            }
+        }
+
+        private class DrawableTestHitObject : DrawableScrollingHitObject<TestHitObject, TestJudgement>
+        {
+            public DrawableTestHitObject(Axes scrollingAxes, TestHitObject hitObject)
+                : base(hitObject)
+            {
+                Anchor = scrollingAxes == Axes.Y ? Anchor.TopCentre : Anchor.CentreLeft;
+                Origin = Anchor.Centre;
+
+                AutoSizeAxes = Axes.Both;
+
+                Add(new Circle
+                {
+                    Size = new Vector2(50)
+                });
+            }
+
+            protected override TestJudgement CreateJudgement() => new TestJudgement();
+
+            protected override void UpdateState(ArmedState state)
+            {
+            }
+        }
+
+        private class TestPlayfield : ScrollingPlayfield<TestHitObject, TestJudgement>
+        {
+            protected override Container<Drawable> Content => content;
+            private readonly Container<Drawable> content;
+
+            public TestPlayfield(Axes scrollingAxes)
+                : base(scrollingAxes)
+            {
+                InternalChildren = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Alpha = 0.2f
+                    },
+                    content = new Container { RelativeSizeAxes = Axes.Both }
+                };
+            }
+
+            public void Reverse() => Reversed.Toggle();
+        }
+
+
+        private class TestHitObject : HitObject
+        {
+        }
+
+        private class TestJudgement : Judgement
+        {
+            public override string ResultString { get { throw new NotImplementedException(); } }
+            public override string MaxResultString { get { throw new NotImplementedException(); } }
+        }
+    }
+}

osu.Desktop.Tests/Visual/TestCaseSettings.cs

@@ -1,12 +1,11 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Testing;
 using osu.Game.Overlays;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseSettings : TestCase
+    internal class TestCaseSettings : OsuTestCase
     {
         public override string Description => @"Tests the settings overlay";
 
@@ -14,7 +13,7 @@ namespace osu.Desktop.VisualTests.Tests
 
         public TestCaseSettings()
         {
-            Children = new[] { settings = new SettingsOverlay() };
+            Children = new[] { settings = new MainSettings() };
         }
 
         protected override void LoadComplete()

osu.Desktop.Tests/Visual/TestCaseSkipButton.cs

@@ -1,12 +1,11 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Testing;
 using osu.Game.Screens.Play;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseSkipButton : TestCase
+    internal class TestCaseSkipButton : OsuTestCase
     {
         public override string Description => @"Skip skip skippediskip";
 

osu.Desktop.Tests/Visual/TestCaseSocial.cs

@@ -1,13 +1,12 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Testing;
 using osu.Game.Overlays;
 using osu.Game.Users;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    public class TestCaseSocial : TestCase
+    public class TestCaseSocial : OsuTestCase
     {
         public override string Description => @"social browser overlay";
 

osu.Desktop.Tests/Visual/TestCaseSongProgress.cs

@@ -4,14 +4,13 @@
 using System.Collections.Generic;
 using osu.Framework.Graphics;
 using osu.Framework.MathUtils;
-using osu.Framework.Testing;
 using osu.Framework.Timing;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Screens.Play;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseSongProgress : TestCase
+    internal class TestCaseSongProgress : OsuTestCase
     {
         public override string Description => @"With fake data";
 

osu.Desktop.Tests/Visual/TestCaseTabControl.cs

@@ -2,15 +2,14 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Graphics;
-using OpenTK;
-using osu.Framework.Testing;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Screens.Select.Filter;
+using OpenTK;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    public class TestCaseTabControl : TestCase
+    public class TestCaseTabControl : OsuTestCase
     {
         public override string Description => @"Filter for song select";
 

osu.Desktop.Tests/Visual/TestCaseTaikoPlayfield.cs

@@ -1,24 +1,30 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK;
+using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.MathUtils;
-using osu.Framework.Testing;
 using osu.Framework.Timing;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Taiko.Judgements;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Rulesets.Taiko.Objects.Drawables;
 using osu.Game.Rulesets.Taiko.UI;
-using System;
+using OpenTK;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Beatmaps;
+using osu.Desktop.Tests.Beatmaps;
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Objects;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseTaikoPlayfield : TestCase
+    internal class TestCaseTaikoPlayfield : OsuTestCase
     {
-        private const double default_duration = 300;
+        private const double default_duration = 1000;
         private const float scroll_time = 1000;
 
         public override string Description => "Taiko playfield";
@@ -26,12 +32,14 @@ namespace osu.Desktop.VisualTests.Tests
         protected override double TimePerAction => default_duration * 2;
 
         private readonly Random rng = new Random(1337);
-        private readonly TaikoPlayfield playfield;
-        private readonly Container playfieldContainer;
+        private TaikoRulesetContainer rulesetContainer;
+        private Container playfieldContainer;
 
-        public TestCaseTaikoPlayfield()
+        [BackgroundDependencyLoader]
+        private void load(RulesetStore rulesets)
         {
-            AddStep("Hit!", addHitJudgement);
+            AddStep("Hit!", () => addHitJudgement(false));
+            AddStep("Kiai hit", () => addHitJudgement(true));
             AddStep("Miss :(", addMissJudgement);
             AddStep("DrumRoll", () => addDrumRoll(false));
             AddStep("Strong DrumRoll", () => addDrumRoll(true));
@@ -49,6 +57,25 @@ namespace osu.Desktop.VisualTests.Tests
             AddStep("Height test 5", () => changePlayfieldSize(5));
             AddStep("Reset height", () => changePlayfieldSize(6));
 
+            var controlPointInfo = new ControlPointInfo();
+            controlPointInfo.TimingPoints.Add(new TimingControlPoint());
+
+            WorkingBeatmap beatmap = new TestWorkingBeatmap(new Beatmap
+            {
+                HitObjects = new List<HitObject> { new CentreHit() },
+                BeatmapInfo = new BeatmapInfo
+                {
+                    Difficulty = new BeatmapDifficulty(),
+                    Metadata = new BeatmapMetadata
+                    {
+                        Artist = @"Unknown",
+                        Title = @"Sample Beatmap",
+                        Author = @"peppy",
+                    },
+                },
+                ControlPointInfo = controlPointInfo
+            });
+
             var rateAdjustClock = new StopwatchClock(true) { Rate = 1 };
 
             Add(playfieldContainer = new Container
@@ -56,12 +83,9 @@ namespace osu.Desktop.VisualTests.Tests
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
                 RelativeSizeAxes = Axes.X,
-                Height = TaikoPlayfield.DEFAULT_PLAYFIELD_HEIGHT,
+                Height = 768,
                 Clock = new FramedClock(rateAdjustClock),
-                Children = new[]
-                {
-                    playfield = new TaikoPlayfield()
-                }
+                Children = new[] { rulesetContainer = new TaikoRulesetContainer(rulesets.GetRuleset(1).CreateInstance(), beatmap, true) }
             });
         }
 
@@ -85,7 +109,7 @@ namespace osu.Desktop.VisualTests.Tests
                     addDrumRoll(true);
                     break;
                 case 5:
-                    addSwell(1000);
+                    addSwell();
                     delay = scroll_time - 100;
                     break;
             }
@@ -97,16 +121,25 @@ namespace osu.Desktop.VisualTests.Tests
                     playfieldContainer.Delay(delay).ResizeTo(new Vector2(1, rng.Next(25, 400)), 500);
                     break;
                 case 6:
-                    playfieldContainer.Delay(delay).ResizeTo(new Vector2(1, TaikoPlayfield.DEFAULT_PLAYFIELD_HEIGHT), 500);
+                    playfieldContainer.Delay(delay).ResizeTo(new Vector2(1, TaikoPlayfield.DEFAULT_HEIGHT), 500);
                     break;
             }
         }
 
-        private void addHitJudgement()
+        private void addHitJudgement(bool kiai)
         {
             TaikoHitResult hitResult = RNG.Next(2) == 0 ? TaikoHitResult.Good : TaikoHitResult.Great;
 
-            var h = new DrawableTestHit(new Hit())
+            var cpi = new ControlPointInfo();
+            cpi.EffectPoints.Add(new EffectControlPoint
+            {
+                KiaiMode = kiai
+            });
+
+            Hit hit = new Hit();
+            hit.ApplyDefaults(cpi, new BeatmapDifficulty());
+
+            var h = new DrawableTestHit(hit)
             {
                 X = RNG.NextSingle(hitResult == TaikoHitResult.Good ? -0.1f : -0.05f, hitResult == TaikoHitResult.Good ? 0.1f : 0.05f),
                 Judgement = new TaikoJudgement
@@ -117,18 +150,18 @@ namespace osu.Desktop.VisualTests.Tests
                 }
             };
 
-            playfield.OnJudgement(h);
+            rulesetContainer.Playfield.OnJudgement(h);
 
             if (RNG.Next(10) == 0)
             {
                 h.Judgement.SecondHit = true;
-                playfield.OnJudgement(h);
+                rulesetContainer.Playfield.OnJudgement(h);
             }
         }
 
         private void addMissJudgement()
         {
-            playfield.OnJudgement(new DrawableTestHit(new Hit())
+            rulesetContainer.Playfield.OnJudgement(new DrawableTestHit(new Hit())
             {
                 Judgement = new TaikoJudgement
                 {
@@ -140,22 +173,17 @@ namespace osu.Desktop.VisualTests.Tests
 
         private void addBarLine(bool major, double delay = scroll_time)
         {
-            BarLine bl = new BarLine
-            {
-                StartTime = playfield.Time.Current + delay,
-                ScrollTime = scroll_time
-            };
+            BarLine bl = new BarLine { StartTime = rulesetContainer.Playfield.Time.Current + delay };
 
-            playfield.AddBarLine(major ? new DrawableBarLineMajor(bl) : new DrawableBarLine(bl));
+            rulesetContainer.Playfield.Add(major ? new DrawableBarLineMajor(bl) : new DrawableBarLine(bl));
         }
 
         private void addSwell(double duration = default_duration)
         {
-            playfield.Add(new DrawableSwell(new Swell
+            rulesetContainer.Playfield.Add(new DrawableSwell(new Swell
             {
-                StartTime = playfield.Time.Current + scroll_time,
+                StartTime = rulesetContainer.Playfield.Time.Current + scroll_time,
                 Duration = duration,
-                ScrollTime = scroll_time
             }));
         }
 
@@ -166,41 +194,40 @@ namespace osu.Desktop.VisualTests.Tests
 
             var d = new DrumRoll
             {
-                StartTime = playfield.Time.Current + scroll_time,
+                StartTime = rulesetContainer.Playfield.Time.Current + scroll_time,
                 IsStrong = strong,
                 Duration = duration,
-                ScrollTime = scroll_time,
             };
 
-            playfield.Add(new DrawableDrumRoll(d));
+            rulesetContainer.Playfield.Add(new DrawableDrumRoll(d));
         }
 
         private void addCentreHit(bool strong)
         {
             Hit h = new Hit
             {
-                StartTime = playfield.Time.Current + scroll_time,
-                ScrollTime = scroll_time
+                StartTime = rulesetContainer.Playfield.Time.Current + scroll_time,
+                IsStrong = strong
             };
 
             if (strong)
-                playfield.Add(new DrawableCentreHitStrong(h));
+                rulesetContainer.Playfield.Add(new DrawableCentreHitStrong(h));
             else
-                playfield.Add(new DrawableCentreHit(h));
+                rulesetContainer.Playfield.Add(new DrawableCentreHit(h));
         }
 
         private void addRimHit(bool strong)
         {
             Hit h = new Hit
             {
-                StartTime = playfield.Time.Current + scroll_time,
-                ScrollTime = scroll_time
+                StartTime = rulesetContainer.Playfield.Time.Current + scroll_time,
+                IsStrong = strong
             };
 
             if (strong)
-                playfield.Add(new DrawableRimHitStrong(h));
+                rulesetContainer.Playfield.Add(new DrawableRimHitStrong(h));
             else
-                playfield.Add(new DrawableRimHit(h));
+                rulesetContainer.Playfield.Add(new DrawableRimHit(h));
         }
 
         private class DrawableTestHit : DrawableHitObject<TaikoHitObject, TaikoJudgement>

osu.Desktop.Tests/Visual/TestCaseTextAwesome.cs

@@ -2,7 +2,6 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
-using osu.Framework.Testing;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.MathUtils;
@@ -10,9 +9,9 @@ using osu.Game.Graphics;
 using OpenTK;
 using OpenTK.Graphics;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseTextAwesome : TestCase
+    internal class TestCaseTextAwesome : OsuTestCase
     {
         public override string Description => @"Tests display of icons";
 
@@ -31,10 +30,10 @@ namespace osu.Desktop.VisualTests.Tests
             int i = 50;
             foreach (FontAwesome fa in Enum.GetValues(typeof(FontAwesome)))
             {
-                flow.Add(new TextAwesome
+                flow.Add(new SpriteIcon
                 {
                     Icon = fa,
-                    TextSize = 60,
+                    Size = new Vector2(60),
                     Colour = new Color4(
                         Math.Max(0.5f, RNG.NextSingle()),
                         Math.Max(0.5f, RNG.NextSingle()),

osu.Desktop.Tests/Visual/TestCaseTwoLayerButton.cs

@@ -1,12 +1,11 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Testing;
 using osu.Game.Graphics.UserInterface;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseTwoLayerButton : TestCase
+    internal class TestCaseTwoLayerButton : OsuTestCase
     {
         public override string Description => @"Mostly back button";
 

osu.Desktop.Tests/Visual/TestCaseUserPanel.cs

@@ -1,15 +1,14 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Testing;
 using osu.Framework.Graphics;
-using osu.Game.Users;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Users;
 using OpenTK;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseUserPanel : TestCase
+    internal class TestCaseUserPanel : OsuTestCase
     {
         public override string Description => @"Panels for displaying a user's status";
 

osu.Desktop.Tests/Visual/TestCaseUserProfile.cs

@@ -3,13 +3,12 @@
 
 using System;
 using System.Linq;
-using osu.Framework.Testing;
 using osu.Game.Overlays;
 using osu.Game.Users;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseUserProfile : TestCase
+    internal class TestCaseUserProfile : OsuTestCase
     {
         public override string Description => "Tests user's profile page.";
 

osu.Desktop.Tests/VisualTests.cs

@@ -1,22 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using NUnit.Framework;
-using osu.Desktop.VisualTests;
-using osu.Framework.Desktop.Platform;
-
-namespace osu.Desktop.Tests
-{
-    [TestFixture]
-    public class VisualTests
-    {
-        [Test]
-        public void TestVisualTests()
-        {
-            using (var host = new HeadlessGameHost())
-            {
-                host.Run(new AutomatedVisualTestGame());
-            }
-        }
-    }
-}

osu.Desktop.Tests/osu.Desktop.Tests.csproj

@@ -41,6 +41,10 @@
       <HintPath>$(SolutionDir)\packages\NUnit.3.7.1\lib\net45\nunit.framework.dll</HintPath>
       <Private>True</Private>
     </Reference>
+    <Reference Include="OpenTK, Version=3.0.0.0, Culture=neutral, PublicKeyToken=bad199fe84eb3df4, processorArchitecture=MSIL">
+      <HintPath>$(SolutionDir)\packages\ppy.OpenTK.3.0\lib\net45\OpenTK.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="SQLite.Net, Version=3.1.0.0, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>$(SolutionDir)\packages\SQLite.Net.Core-PCL.3.1.1\lib\portable-win8+net45+wp8+wpa81+MonoAndroid1+MonoTouch1\SQLite.Net.dll</HintPath>
@@ -55,15 +59,68 @@
     <Reference Include="SQLite.Net.Platform.Generic">
       <HintPath>$(SolutionDir)\packages\SQLite.Net-PCL.3.1.1\lib\net40\SQLite.Net.Platform.Generic.dll</HintPath>
     </Reference>
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="VisualTests.cs" />
+    <Compile Include="Beatmaps\TestWorkingBeatmap.cs" />
+    <Compile Include="Platform\TestStorage.cs" />
+    <Compile Include="Visual\OsuTestCase.cs" />
+    <Compile Include="Visual\TestCaseBeatmapDetailArea.cs" />
+    <Compile Include="Visual\TestCaseBeatmapDetails.cs" />
+    <Compile Include="Visual\TestCaseBeatmapOptionsOverlay.cs" />
+    <Compile Include="Visual\TestCaseBeatSyncedContainer.cs" />
+    <Compile Include="Visual\TestCaseBreadcrumbs.cs" />
+    <Compile Include="Visual\TestCaseCatcher.cs" />
+    <Compile Include="Visual\TestCaseChatDisplay.cs" />
+    <Compile Include="Visual\TestCaseContextMenu.cs" />
+    <Compile Include="Visual\TestCaseDialogOverlay.cs" />
+    <Compile Include="Visual\TestCaseDirect.cs" />
+    <Compile Include="Visual\TestCaseDrawableRoom.cs" />
+    <Compile Include="Visual\TestCaseDrawings.cs" />
+    <Compile Include="Visual\TestCaseGamefield.cs" />
+    <Compile Include="Visual\TestCaseGraph.cs" />
+    <Compile Include="Visual\TestCaseHitObjects.cs" />
+    <Compile Include="Visual\TestCaseKeyConfiguration.cs" />
+    <Compile Include="Visual\TestCaseKeyCounter.cs" />
+    <Compile Include="Visual\TestCaseLeaderboard.cs" />
+    <Compile Include="Visual\TestCaseManiaHitObjects.cs" />
+    <Compile Include="Visual\TestCaseManiaPlayfield.cs" />
+    <Compile Include="Visual\TestCaseMedalOverlay.cs" />
+    <Compile Include="Visual\TestCaseMenuButtonSystem.cs" />
+    <Compile Include="Visual\TestCaseMenuOverlays.cs" />
+    <Compile Include="Visual\TestCaseMods.cs" />
+    <Compile Include="Visual\TestCaseMusicController.cs" />
+    <Compile Include="Visual\TestCaseNotificationOverlay.cs" />
+    <Compile Include="Visual\TestCaseOnScreenDisplay.cs" />
+    <Compile Include="Visual\TestCasePlayer.cs" />
+    <Compile Include="Visual\TestCasePlaySongSelect.cs" />
+    <Compile Include="Visual\TestCaseReplay.cs" />
+    <Compile Include="Visual\TestCaseReplaySettingsOverlay.cs" />
+    <Compile Include="Visual\TestCaseResults.cs" />
+    <Compile Include="Visual\TestCaseRoomInspector.cs" />
+    <Compile Include="Visual\TestCaseScoreCounter.cs" />
+    <Compile Include="Visual\TestCaseScrollingPlayfield.cs" />
+    <Compile Include="Visual\TestCaseSettings.cs" />
+    <Compile Include="Visual\TestCaseSkipButton.cs" />
+    <Compile Include="Visual\TestCaseSocial.cs" />
+    <Compile Include="Visual\TestCaseSongProgress.cs" />
+    <Compile Include="Visual\TestCaseTabControl.cs" />
+    <Compile Include="Visual\TestCaseTaikoPlayfield.cs" />
+    <Compile Include="Visual\TestCaseTextAwesome.cs" />
+    <Compile Include="Visual\TestCaseTwoLayerButton.cs" />
+    <Compile Include="Visual\TestCaseUserPanel.cs" />
+    <Compile Include="Visual\TestCaseUserProfile.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\osu-framework\osu.Framework.Desktop\osu.Framework.Desktop.csproj">
       <Project>{65DC628F-A640-4111-AB35-3A5652BC1E17}</Project>
       <Name>osu.Framework.Desktop</Name>
     </ProjectReference>
+    <ProjectReference Include="..\osu-framework\osu.Framework.Testing\osu.Framework.Testing.csproj">
+      <Project>{007b2356-ab6f-4bd9-96d5-116fc2dce69a}</Project>
+      <Name>osu.Framework.Testing</Name>
+    </ProjectReference>
     <ProjectReference Include="..\osu-framework\osu.Framework\osu.Framework.csproj">
       <Project>{C76BF5B3-985E-4D39-95FE-97C9C879B83A}</Project>
       <Name>osu.Framework</Name>
@@ -72,10 +129,6 @@
       <Project>{d9a367c9-4c1a-489f-9b05-a0cea2b53b58}</Project>
       <Name>osu.Game.Resources</Name>
     </ProjectReference>
-    <ProjectReference Include="..\osu.Desktop.VisualTests\osu.Desktop.VisualTests.csproj">
-      <Project>{69051C69-12AE-4E7D-A3E6-460D2E282312}</Project>
-      <Name>osu.Desktop.VisualTests</Name>
-    </ProjectReference>
     <ProjectReference Include="..\osu.Game.Rulesets.Catch\osu.Game.Rulesets.Catch.csproj">
       <Project>{58F6C80C-1253-4A0E-A465-B8C85EBEADF3}</Project>
       <Name>osu.Game.Rulesets.Catch</Name>

osu.Desktop.Tests/packages.config

@@ -6,6 +6,7 @@ Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/maste
 <packages>
   <package id="Newtonsoft.Json" version="10.0.2" targetFramework="net45" />
   <package id="NUnit" version="3.7.1" targetFramework="net45" />
+  <package id="ppy.OpenTK" version="3.0" targetFramework="net45" />
   <package id="SQLite.Net.Core-PCL" version="3.1.1" targetFramework="net45" />
   <package id="SQLite.Net-PCL" version="3.1.1" targetFramework="net45" />
   <package id="SQLiteNetExtensions" version="1.3.0" targetFramework="net45" />

osu.Desktop.VisualTests/AutomatedVisualTestGame.cs

@@ -1,20 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Framework.Testing;
-using osu.Game;
-
-namespace osu.Desktop.VisualTests
-{
-    public class AutomatedVisualTestGame : OsuGameBase
-    {
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            // Have to construct this here, rather than in the constructor, because
-            // we depend on some dependencies to be loaded within OsuGameBase.load().
-            Add(new TestRunner(new TestBrowser()));
-        }
-    }
-}

osu.Desktop.VisualTests/Program.cs

@@ -4,6 +4,7 @@
 using System;
 using osu.Framework.Desktop;
 using osu.Framework.Platform;
+using osu.Framework.VisualTests;
 
 namespace osu.Desktop.VisualTests
 {

osu.Desktop.VisualTests/Tests/TestCaseKeyCounter.cs

@@ -1,103 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Framework.Testing;
-using osu.Framework.Graphics;
-using OpenTK.Input;
-using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Configuration;
-using osu.Framework.Graphics.Containers;
-using OpenTK;
-using OpenTK.Graphics;
-using osu.Framework.MathUtils;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Graphics.Sprites;
-using osu.Game.Screens.Play;
-
-namespace osu.Desktop.VisualTests.Tests
-{
-    internal class TestCaseKeyCounter : TestCase
-    {
-        public override string Description => @"Tests key counter";
-
-        public TestCaseKeyCounter()
-        {
-            KeyCounterCollection kc = new KeyCounterCollection
-            {
-                Origin = Anchor.Centre,
-                Anchor = Anchor.Centre,
-                IsCounting = true,
-                Children = new KeyCounter[]
-                {
-                    new KeyCounterKeyboard(Key.Z),
-                    new KeyCounterKeyboard(Key.X),
-                    new KeyCounterMouse(MouseButton.Left),
-                    new KeyCounterMouse(MouseButton.Right),
-                },
-            };
-            BindableInt bindable = new BindableInt { MinValue = 0, MaxValue = 200, Default = 50 };
-            bindable.ValueChanged += delegate { kc.FadeTime = bindable.Value; };
-            AddStep("Add Random", () =>
-            {
-                Key key = (Key)((int)Key.A + RNG.Next(26));
-                kc.Add(new KeyCounterKeyboard(key));
-            });
-
-            TestSliderBar<int> sliderBar;
-
-            Add(new Container
-            {
-                Anchor = Anchor.TopRight,
-                Origin = Anchor.TopRight,
-                AutoSizeAxes = Axes.Both,
-                Children = new Drawable[]
-                {
-                    new SpriteText { Text = "FadeTime" },
-                    sliderBar = new TestSliderBar<int>
-                    {
-                        Width = 150,
-                        Height = 10,
-                        SelectionColor = Color4.Orange,
-                    }
-                }
-            });
-
-            sliderBar.Current.BindTo(bindable);
-
-            Add(kc);
-        }
-        private class TestSliderBar<T> : SliderBar<T> where T : struct
-        {
-            public Color4 Color
-            {
-                get { return Box.Colour; }
-                set { Box.Colour = value; }
-            }
-
-            public Color4 SelectionColor
-            {
-                get { return SelectionBox.Colour; }
-                set { SelectionBox.Colour = value; }
-            }
-
-            protected readonly Box SelectionBox;
-            protected readonly Box Box;
-
-            public TestSliderBar()
-            {
-                Children = new Drawable[]
-                {
-                    Box = new Box { RelativeSizeAxes = Axes.Both },
-                    SelectionBox = new Box { RelativeSizeAxes = Axes.Both }
-                };
-            }
-
-            protected override void UpdateValue(float value)
-            {
-                SelectionBox.ScaleTo(
-                    new Vector2(value, 1),
-                    300, Easing.OutQuint);
-            }
-        }
-    }
-}

osu.Desktop.VisualTests/Tests/TestCaseManiaPlayfield.cs

@@ -1,143 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Framework.Input;
-using osu.Framework.Testing;
-using osu.Framework.Graphics;
-using osu.Game.Rulesets.Mania.UI;
-using System;
-using OpenTK;
-using osu.Game.Rulesets.Mania.Objects.Drawables;
-using osu.Game.Rulesets.Mania.Objects;
-using osu.Framework.Configuration;
-using OpenTK.Input;
-using osu.Framework.Timing;
-using osu.Framework.Extensions.IEnumerableExtensions;
-using System.Linq;
-using osu.Game.Rulesets.Mania.Timing;
-using osu.Game.Rulesets.Timing;
-
-namespace osu.Desktop.VisualTests.Tests
-{
-    internal class TestCaseManiaPlayfield : TestCase
-    {
-        public override string Description => @"Mania playfield";
-
-        protected override double TimePerAction => 200;
-
-        public TestCaseManiaPlayfield()
-        {
-            Action<int, SpecialColumnPosition> createPlayfield = (cols, pos) =>
-            {
-                Clear();
-                Add(new ManiaPlayfield(cols)
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    SpecialColumnPosition = pos,
-                    Scale = new Vector2(1, -1)
-                });
-            };
-
-            const double start_time = 500;
-            const double duration = 500;
-
-            Func<double, bool, SpeedAdjustmentContainer> createTimingChange = (time, gravity) => new ManiaSpeedAdjustmentContainer(new MultiplierControlPoint(time)
-            {
-                TimingPoint = { BeatLength = 1000 }
-            }, gravity ? ScrollingAlgorithm.Gravity : ScrollingAlgorithm.Basic);
-
-            Action<bool> createPlayfieldWithNotes = gravity =>
-            {
-                Clear();
-
-                var rateAdjustClock = new StopwatchClock(true) { Rate = 1 };
-
-                ManiaPlayfield playField;
-                Add(playField = new ManiaPlayfield(4)
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    Scale = new Vector2(1, -1),
-                    Clock = new FramedClock(rateAdjustClock)
-                });
-
-                if (!gravity)
-                    playField.Columns.ForEach(c => c.Add(createTimingChange(0, false)));
-
-                for (double t = start_time; t <= start_time + duration; t += 100)
-                {
-                    if (gravity)
-                        playField.Columns.ElementAt(0).Add(createTimingChange(t, true));
-
-                    playField.Add(new DrawableNote(new Note
-                    {
-                        StartTime = t,
-                        Column = 0
-                    }, new Bindable<Key>(Key.D)));
-
-                    if (gravity)
-                        playField.Columns.ElementAt(3).Add(createTimingChange(t, true));
-
-                    playField.Add(new DrawableNote(new Note
-                    {
-                        StartTime = t,
-                        Column = 3
-                    }, new Bindable<Key>(Key.K)));
-                }
-
-                if (gravity)
-                    playField.Columns.ElementAt(1).Add(createTimingChange(start_time, true));
-
-                playField.Add(new DrawableHoldNote(new HoldNote
-                {
-                    StartTime = start_time,
-                    Duration = duration,
-                    Column = 1
-                }, new Bindable<Key>(Key.F)));
-
-                if (gravity)
-                    playField.Columns.ElementAt(2).Add(createTimingChange(start_time, true));
-
-                playField.Add(new DrawableHoldNote(new HoldNote
-                {
-                    StartTime = start_time,
-                    Duration = duration,
-                    Column = 2
-                }, new Bindable<Key>(Key.J)));
-            };
-
-            AddStep("1 column", () => createPlayfield(1, SpecialColumnPosition.Normal));
-            AddStep("4 columns", () => createPlayfield(4, SpecialColumnPosition.Normal));
-            AddStep("Left special style", () => createPlayfield(4, SpecialColumnPosition.Left));
-            AddStep("Right special style", () => createPlayfield(4, SpecialColumnPosition.Right));
-            AddStep("5 columns", () => createPlayfield(5, SpecialColumnPosition.Normal));
-            AddStep("8 columns", () => createPlayfield(8, SpecialColumnPosition.Normal));
-            AddStep("Left special style", () => createPlayfield(8, SpecialColumnPosition.Left));
-            AddStep("Right special style", () => createPlayfield(8, SpecialColumnPosition.Right));
-
-            AddStep("Notes with input", () => createPlayfieldWithNotes(false));
-            AddWaitStep((int)Math.Ceiling((start_time + duration) / TimePerAction));
-
-            AddStep("Notes with gravity", () => createPlayfieldWithNotes(true));
-            AddWaitStep((int)Math.Ceiling((start_time + duration) / TimePerAction));
-        }
-
-        private void triggerKeyDown(Column column)
-        {
-            column.TriggerOnKeyDown(new InputState(), new KeyDownEventArgs
-            {
-                Key = column.Key,
-                Repeat = false
-            });
-        }
-
-        private void triggerKeyUp(Column column)
-        {
-            column.TriggerOnKeyUp(new InputState(), new KeyUpEventArgs
-            {
-                Key = column.Key
-            });
-        }
-    }
-}

osu.Desktop.VisualTests/Tests/TestCaseScrollingHitObjects.cs

@@ -1,210 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using OpenTK;
-using OpenTK.Graphics;
-using osu.Framework.Configuration;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Testing;
-using osu.Game.Graphics.Sprites;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Timing;
-
-namespace osu.Desktop.VisualTests.Tests
-{
-    public class TestCaseScrollingHitObjects : TestCase
-    {
-        public override string Description => "SpeedAdjustmentContainer/DrawableTimingSection";
-
-        private readonly BindableDouble timeRangeBindable;
-        private readonly OsuSpriteText bottomLabel;
-        private readonly SpriteText topTime;
-        private readonly SpriteText bottomTime;
-
-        public TestCaseScrollingHitObjects()
-        {
-            OsuSpriteText timeRangeText;
-            SpeedAdjustmentCollection adjustmentCollection;
-
-            timeRangeBindable = new BindableDouble(2000)
-            {
-                MinValue = 200,
-                MaxValue = 4000,
-            };
-
-            SliderBar<double> timeRange;
-            Add(timeRange = new BasicSliderBar<double>
-            {
-                Size = new Vector2(200, 20),
-                SelectionColor = Color4.Pink,
-                KeyboardStep = 100
-            });
-
-            Add(timeRangeText = new OsuSpriteText
-            {
-                X = 210,
-                TextSize = 16,
-            });
-
-            timeRange.Current.BindTo(timeRangeBindable);
-            timeRangeBindable.ValueChanged += v => timeRangeText.Text = $"Visible Range: {v:#,#.#}";
-            timeRangeBindable.ValueChanged += v => bottomLabel.Text = $"t minus {v:#,#}";
-
-            AddRange(new Drawable[]
-            {
-                new Container
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    Size = new Vector2(100, 500),
-                    Children = new Drawable[]
-                    {
-                        new Box
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            Alpha = 0.25f
-                        },
-                        adjustmentCollection = new SpeedAdjustmentCollection(Axes.Y)
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            VisibleTimeRange = timeRangeBindable,
-                            Masking = true,
-                        },
-                        new OsuSpriteText
-                        {
-                            Text = "t minus 0",
-                            Margin = new MarginPadding(2),
-                            TextSize = 14,
-                            Anchor = Anchor.TopRight,
-                        },
-                        bottomLabel = new OsuSpriteText
-                        {
-                            Text = "t minus x",
-                            Margin = new MarginPadding(2),
-                            TextSize = 14,
-                            Anchor = Anchor.BottomRight,
-                            Origin = Anchor.BottomLeft,
-                        },
-                        topTime = new OsuSpriteText
-                        {
-                            Margin = new MarginPadding(2),
-                            TextSize = 14,
-                            Anchor = Anchor.TopLeft,
-                            Origin = Anchor.TopRight,
-                        },
-                        bottomTime = new OsuSpriteText
-                        {
-                            Margin = new MarginPadding(2),
-                            TextSize = 14,
-                            Anchor = Anchor.BottomLeft,
-                            Origin = Anchor.BottomRight,
-                        },
-                    }
-                }
-            });
-
-            timeRangeBindable.TriggerChange();
-
-            adjustmentCollection.Add(new TestSpeedAdjustmentContainer(new MultiplierControlPoint()));
-
-            AddStep("Add hit object", () => adjustmentCollection.Add(new TestDrawableHitObject(new HitObject { StartTime = Time.Current + 2000 })));
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-
-            topTime.Text = Time.Current.ToString("#,#");
-            bottomTime.Text = (Time.Current + timeRangeBindable.Value).ToString("#,#");
-        }
-
-        private class TestSpeedAdjustmentContainer : SpeedAdjustmentContainer
-        {
-            public override bool RemoveWhenNotAlive => false;
-
-            public TestSpeedAdjustmentContainer(MultiplierControlPoint controlPoint)
-                : base(controlPoint)
-            {
-            }
-
-            protected override DrawableTimingSection CreateTimingSection() => new TestDrawableTimingSection(ControlPoint);
-
-            private class TestDrawableTimingSection : DrawableTimingSection
-            {
-                private readonly MultiplierControlPoint controlPoint;
-
-                public TestDrawableTimingSection(MultiplierControlPoint controlPoint)
-                {
-                    this.controlPoint = controlPoint;
-                }
-
-                protected override void Update()
-                {
-                    base.Update();
-
-                    Y = (float)(controlPoint.StartTime - Time.Current);
-                }
-            }
-        }
-
-        private class TestDrawableHitObject : DrawableHitObject, IScrollingHitObject
-        {
-            private readonly Box background;
-            private const float height = 14;
-
-            public BindableDouble LifetimeOffset { get; } = new BindableDouble();
-
-            public TestDrawableHitObject(HitObject hitObject)
-                : base(hitObject)
-            {
-                AutoSizeAxes = Axes.Y;
-                RelativeSizeAxes = Axes.X;
-                RelativePositionAxes = Axes.Y;
-
-                Y = (float)hitObject.StartTime;
-
-                Children = new Drawable[]
-                {
-                    background = new Box
-                    {
-                        RelativeSizeAxes = Axes.X,
-                        Height = height,
-                    },
-                    new Box
-                    {
-                        RelativeSizeAxes = Axes.X,
-                        Colour = Color4.Cyan,
-                        Height = 1,
-                    },
-                    new OsuSpriteText
-                    {
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        Colour = Color4.Black,
-                        TextSize = height,
-                        Font = @"Exo2.0-BoldItalic",
-                        Text = $"{hitObject.StartTime:#,#}"
-                    }
-                };
-            }
-
-            protected override void LoadComplete()
-            {
-                base.LoadComplete();
-                this.FadeInFromZero(250, Easing.OutQuint);
-            }
-
-            protected override void Update()
-            {
-                base.Update();
-                if (Time.Current >= HitObject.StartTime)
-                    background.Colour = Color4.Red;
-            }
-        }
-    }
-}

osu.Desktop.VisualTests/Tests/TestCaseTaikoHitObjects.cs

@@ -1,119 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System.Linq;
-using OpenTK;
-using OpenTK.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Testing;
-using osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;
-
-namespace osu.Desktop.VisualTests.Tests
-{
-    internal class TestCaseTaikoHitObjects : TestCase
-    {
-        public override string Description => "Taiko hit objects";
-
-        private bool kiai;
-
-        public TestCaseTaikoHitObjects()
-        {
-            AddToggleStep("Kiai", b =>
-            {
-                kiai = !kiai;
-                updateKiaiState();
-            });
-
-            Add(new CirclePiece
-            {
-                Position = new Vector2(100, 100),
-                AccentColour = Color4.DarkRed,
-                KiaiMode = kiai,
-                Children = new[]
-                {
-                    new CentreHitSymbolPiece()
-                }
-            });
-
-            Add(new CirclePiece(true)
-            {
-                Position = new Vector2(350, 100),
-                AccentColour = Color4.DarkRed,
-                KiaiMode = kiai,
-                Children = new[]
-                {
-                    new CentreHitSymbolPiece()
-                }
-            });
-
-            Add(new CirclePiece
-            {
-                Position = new Vector2(100, 300),
-                AccentColour = Color4.DarkBlue,
-                KiaiMode = kiai,
-                Children = new[]
-                {
-                    new RimHitSymbolPiece()
-                }
-            });
-
-            Add(new CirclePiece(true)
-            {
-                Position = new Vector2(350, 300),
-                AccentColour = Color4.DarkBlue,
-                KiaiMode = kiai,
-                Children = new[]
-                {
-                    new RimHitSymbolPiece()
-                }
-            });
-
-            Add(new CirclePiece
-            {
-                Position = new Vector2(100, 500),
-                AccentColour = Color4.Orange,
-                KiaiMode = kiai,
-                Children = new[]
-                {
-                    new SwellSymbolPiece()
-                }
-            });
-
-            Add(new ElongatedCirclePiece
-            {
-                Position = new Vector2(575, 100),
-                AccentColour = Color4.Orange,
-                KiaiMode = kiai,
-                Length = 0.10f,
-                PlayfieldLengthReference = () => DrawSize.X
-            });
-
-            Add(new ElongatedCirclePiece(true)
-            {
-                Position = new Vector2(575, 300),
-                AccentColour = Color4.Orange,
-                KiaiMode = kiai,
-                Length = 0.10f,
-                PlayfieldLengthReference = () => DrawSize.X
-            });
-        }
-
-        private void updateKiaiState()
-        {
-            foreach (var c in Children.OfType<CirclePiece>())
-                c.KiaiMode = kiai;
-        }
-
-        private abstract class BaseCircle : Container
-        {
-            protected readonly CirclePiece Piece;
-
-            protected BaseCircle(CirclePiece piece)
-            {
-                Piece = piece;
-
-                Add(Piece);
-            }
-        }
-    }
-}

osu.Desktop.VisualTests/VisualTestGame.cs

@@ -2,7 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Platform;
-using osu.Framework.Testing;
+using osu.Framework.VisualTests;
 using osu.Game;
 using osu.Game.Screens.Backgrounds;
 

osu.Desktop.VisualTests/osu.Desktop.VisualTests.csproj

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
   <PropertyGroup>
     <ProjectGuid>{69051C69-12AE-4E7D-A3E6-460D2E282312}</ProjectGuid>
@@ -185,55 +185,8 @@
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="AutomatedVisualTestGame.cs" />
     <Compile Include="Program.cs" />
-    <Compile Include="Tests\TestCaseBeatSyncedContainer.cs" />
-    <Compile Include="Tests\TestCaseChatDisplay.cs" />
-    <Compile Include="Tests\TestCaseBeatmapDetails.cs" />
-    <Compile Include="Tests\TestCaseContextMenu.cs" />
-    <Compile Include="Tests\TestCaseDrawings.cs" />
-    <Compile Include="Tests\TestCaseGamefield.cs" />
-    <Compile Include="Tests\TestCaseGraph.cs" />
-    <Compile Include="Tests\TestCaseManiaHitObjects.cs" />
-    <Compile Include="Tests\TestCaseManiaPlayfield.cs" />
-    <Compile Include="Tests\TestCaseMenuOverlays.cs" />
-    <Compile Include="Tests\TestCaseMusicController.cs" />
-    <Compile Include="Tests\TestCaseNotificationOverlay.cs" />
-    <Compile Include="Tests\TestCaseOnScreenDisplay.cs" />
-    <Compile Include="Tests\TestCaseReplaySettingsOverlay.cs" />
-    <Compile Include="Tests\TestCasePlayer.cs" />
-    <Compile Include="Tests\TestCaseHitObjects.cs" />
-    <Compile Include="Tests\TestCaseKeyCounter.cs" />
-    <Compile Include="Tests\TestCaseMenuButtonSystem.cs" />
-    <Compile Include="Tests\TestCaseReplay.cs" />
-    <Compile Include="Tests\TestCaseResults.cs" />
-    <Compile Include="Tests\TestCaseScoreCounter.cs" />
-    <Compile Include="Tests\TestCaseScrollingHitObjects.cs" />
-    <Compile Include="Tests\TestCaseSkipButton.cs" />
-    <Compile Include="Tests\TestCaseTabControl.cs" />
-    <Compile Include="Tests\TestCaseTaikoHitObjects.cs" />
-    <Compile Include="Tests\TestCaseTaikoPlayfield.cs" />
-    <Compile Include="Tests\TestCaseTextAwesome.cs" />
-    <Compile Include="Tests\TestCasePlaySongSelect.cs" />
-    <Compile Include="Tests\TestCaseTwoLayerButton.cs" />
-    <Compile Include="Tests\TestCaseUserProfile.cs" />
     <Compile Include="VisualTestGame.cs" />
-    <Compile Include="Platform\TestStorage.cs" />
-    <Compile Include="Tests\TestCaseSettings.cs" />
-    <Compile Include="Tests\TestCaseSongProgress.cs" />
-    <Compile Include="Tests\TestCaseMods.cs" />
-    <Compile Include="Tests\TestCaseDialogOverlay.cs" />
-    <Compile Include="Tests\TestCaseBeatmapOptionsOverlay.cs" />
-    <Compile Include="Tests\TestCaseLeaderboard.cs" />
-    <Compile Include="Beatmaps\TestWorkingBeatmap.cs" />
-    <Compile Include="Tests\TestCaseBeatmapDetailArea.cs" />
-    <Compile Include="Tests\TestCaseDrawableRoom.cs" />
-    <Compile Include="Tests\TestCaseUserPanel.cs" />
-    <Compile Include="Tests\TestCaseDirect.cs" />
-    <Compile Include="Tests\TestCaseSocial.cs" />
-    <Compile Include="Tests\TestCaseBreadcrumbs.cs" />
-    <Compile Include="Tests\TestCaseMedalOverlay.cs" />
-    <Compile Include="Tests\TestCaseRoomInspector.cs" />
   </ItemGroup>
   <ItemGroup />
   <ItemGroup />
@@ -258,4 +211,4 @@
     <PostBuildEvent>
     </PostBuildEvent>
   </PropertyGroup>
-</Project>
+</Project>

osu.Desktop/OsuGameDesktop.cs

@@ -20,16 +20,11 @@ namespace osu.Desktop
 {
     internal class OsuGameDesktop : OsuGame
     {
-        private readonly VersionManager versionManager;
+        private VersionManager versionManager;
 
         public OsuGameDesktop(string[] args = null)
             : base(args)
         {
-            versionManager = new VersionManager
-            {
-                Depth = int.MinValue,
-                State = Visibility.Hidden
-            };
         }
 
         public override Storage GetStorageForStableInstall()
@@ -88,11 +83,15 @@ namespace osu.Desktop
         {
             base.LoadComplete();
 
-            LoadComponentAsync(versionManager, Add);
+            LoadComponentAsync(versionManager = new VersionManager { Depth = int.MinValue });
+
             ScreenChanged += s =>
             {
-                if (!versionManager.IsPresent && s is Intro)
+                if (s is Intro && s.ChildScreen == null)
+                {
+                    Add(versionManager);
                     versionManager.State = Visibility.Visible;
+                }
             };
         }
 

osu.Desktop/OsuTestBrowser.cs

@@ -0,0 +1,35 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Platform;
+using osu.Framework.Testing;
+using osu.Game;
+using osu.Game.Screens.Backgrounds;
+
+namespace osu.Desktop
+{
+    internal class OsuTestBrowser : OsuGameBase
+    {
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            LoadComponentAsync(new BackgroundScreenDefault { Depth = 10 }, AddInternal);
+
+            // Have to construct this here, rather than in the constructor, because
+            // we depend on some dependencies to be loaded within OsuGameBase.load().
+            Add(new TestBrowser());
+        }
+
+        public override void SetHost(GameHost host)
+        {
+            base.SetHost(host);
+
+            host.UpdateThread.InactiveHz = host.UpdateThread.ActiveHz;
+            host.DrawThread.InactiveHz = host.DrawThread.ActiveHz;
+            host.InputThread.InactiveHz = host.InputThread.ActiveHz;
+
+            host.Window.CursorState |= CursorState.Hidden;
+        }
+    }
+}

osu.Desktop/Overlays/VersionManager.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using System.Diagnostics;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
@@ -19,6 +20,7 @@ using OpenTK.Graphics;
 using System.Net.Http;
 using osu.Framework.Logging;
 using osu.Game;
+using osu.Game.Configuration;
 
 namespace osu.Desktop.Overlays
 {
@@ -26,19 +28,22 @@ namespace osu.Desktop.Overlays
     {
         private UpdateManager updateManager;
         private NotificationOverlay notificationOverlay;
-
-        protected override bool HideOnEscape => false;
+        private OsuConfigManager config;
+        private OsuGameBase game;
 
         public override bool HandleInput => false;
 
         [BackgroundDependencyLoader]
-        private void load(NotificationOverlay notification, OsuColour colours, TextureStore textures, OsuGameBase game)
+        private void load(NotificationOverlay notification, OsuColour colours, TextureStore textures, OsuGameBase game, OsuConfigManager config)
         {
             notificationOverlay = notification;
+            this.config = config;
+            this.game = game;
 
             AutoSizeAxes = Axes.Both;
             Anchor = Anchor.BottomCentre;
             Origin = Anchor.BottomCentre;
+
             Alpha = 0;
 
             Children = new Drawable[]
@@ -93,6 +98,42 @@ namespace osu.Desktop.Overlays
                 checkForUpdateAsync();
         }
 
+        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))
+                    Scheduler.AddDelayed(() => notificationOverlay.Post(new UpdateCompleteNotification(version)), 5000);
+            }
+        }
+
+        private class UpdateCompleteNotification : SimpleNotification
+        {
+            public UpdateCompleteNotification(string version)
+            {
+                Text = $"You are now running osu!lazer {version}.\nClick to see what's new!";
+                Icon = FontAwesome.fa_check_square;
+                Activated = delegate
+                {
+                    Process.Start($"https://github.com/ppy/osu/releases/tag/v{version}");
+                    return true;
+                };
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                IconBackgound.Colour = colours.BlueDark;
+            }
+        }
+
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
@@ -209,13 +250,13 @@ namespace osu.Desktop.Overlays
                         RelativeSizeAxes = Axes.Both,
                         Colour = ColourInfo.GradientVertical(colours.YellowDark, colours.Yellow)
                     },
-                    new TextAwesome
+                    new SpriteIcon
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
                         Icon = FontAwesome.fa_upload,
                         Colour = Color4.White,
-                        TextSize = 20
+                        Size = new Vector2(20),
                     }
                 });
             }

osu.Desktop/Program.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.IO;
+using System.Linq;
 using osu.Framework.Desktop;
 using osu.Framework.Desktop.Platform;
 using osu.Game.IPC;
@@ -33,7 +34,16 @@ namespace osu.Desktop
                 }
                 else
                 {
-                    host.Run(new OsuGameDesktop(args));
+                    switch (args.FirstOrDefault() ?? string.Empty)
+                    {
+                        case "--tests":
+                            host.Run(new OsuTestBrowser());
+                            break;
+                        default:
+                            host.Run(new OsuGameDesktop(args));
+                            break;
+                    }
+
                 }
                 return 0;
             }

osu.Desktop/osu.Desktop.csproj

@@ -90,6 +90,21 @@
   <PropertyGroup>
     <ApplicationManifest>Properties\app.manifest</ApplicationManifest>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'VisualTests|AnyCPU'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG</DefineConstants>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <WarningLevel>0</WarningLevel>
+    <NoStdLib>true</NoStdLib>
+    <DebugType>full</DebugType>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <UseVSHostingProcess>false</UseVSHostingProcess>
+    <LangVersion>6</LangVersion>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <StartArguments>--tests</StartArguments>
+  </PropertyGroup>
   <ItemGroup>
     <Reference Include="DeltaCompressionDotNet, Version=1.1.0.0, Culture=neutral, PublicKeyToken=1d14d6e5194e7f4a, processorArchitecture=MSIL">
       <HintPath>$(SolutionDir)\packages\DeltaCompressionDotNet.1.1.0\lib\net20\DeltaCompressionDotNet.dll</HintPath>
@@ -195,6 +210,10 @@
       <Project>{65dc628f-a640-4111-ab35-3a5652bc1e17}</Project>
       <Name>osu.Framework.Desktop</Name>
     </ProjectReference>
+    <ProjectReference Include="..\osu-framework\osu.Framework.Testing\osu.Framework.Testing.csproj">
+      <Project>{007B2356-AB6F-4BD9-96D5-116FC2DCE69A}</Project>
+      <Name>osu.Framework.Testing</Name>
+    </ProjectReference>
     <ProjectReference Include="..\osu-framework\osu.Framework\osu.Framework.csproj">
       <Project>{c76bf5b3-985e-4d39-95fe-97c9c879b83a}</Project>
       <Name>osu.Framework</Name>
@@ -203,6 +222,10 @@
       <Project>{d9a367c9-4c1a-489f-9b05-a0cea2b53b58}</Project>
       <Name>osu.Game.Resources</Name>
     </ProjectReference>
+    <ProjectReference Include="..\osu.Desktop.Tests\osu.Desktop.Tests.csproj">
+      <Project>{230ac4f3-7783-49fb-9aec-b83cda3b9f3d}</Project>
+      <Name>osu.Desktop.Tests</Name>
+    </ProjectReference>
     <ProjectReference Include="..\osu.Game.Rulesets.Osu\osu.Game.Rulesets.Osu.csproj">
       <Project>{c92a607b-1fdd-4954-9f92-03ff547d9080}</Project>
       <Name>osu.Game.Rulesets.Osu</Name>
@@ -226,6 +249,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="OsuGameDesktop.cs" />
+    <Compile Include="OsuTestBrowser.cs" />
     <Compile Include="Overlays\VersionManager.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapConverter.cs

@@ -8,6 +8,7 @@ using System;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Beatmaps;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.UI;
 
 namespace osu.Game.Rulesets.Catch.Beatmaps
 {
@@ -15,9 +16,16 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
     {
         protected override IEnumerable<Type> ValidConversionTypes { get; } = new[] { typeof(IHasXPosition) };
 
-        protected override IEnumerable<CatchBaseHit> ConvertHitObject(HitObject original, Beatmap beatmap)
+        protected override IEnumerable<CatchBaseHit> ConvertHitObject(HitObject obj, Beatmap beatmap)
         {
-            yield return null;
+            if (!(obj is IHasXPosition))
+                yield break;
+
+            yield return new Fruit
+            {
+                StartTime = obj.StartTime,
+                Position = ((IHasXPosition)obj).X / OsuPlayfield.BASE_SIZE.X
+            };
         }
     }
 }

osu.Game.Rulesets.Catch/CatchInputManager.cs

@@ -0,0 +1,27 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.ComponentModel;
+using osu.Framework.Input.Bindings;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Catch
+{
+    public class CatchInputManager : RulesetInputManager<CatchAction>
+    {
+        public CatchInputManager(RulesetInfo ruleset)
+            : base(ruleset, 0, SimultaneousBindingMode.Unique)
+        {
+        }
+    }
+
+    public enum CatchAction
+    {
+        [Description("Move left")]
+        MoveLeft,
+        [Description("Move right")]
+        MoveRight,
+        [Description("Engage dash")]
+        Dash
+    }
+}

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -1,23 +1,33 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Catch.Mods;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
-using osu.Game.Screens.Play;
 using System.Collections.Generic;
+using osu.Framework.Graphics;
 using osu.Game.Rulesets.Catch.Scoring;
 using osu.Game.Rulesets.Scoring;
+using osu.Framework.Input.Bindings;
 
 namespace osu.Game.Rulesets.Catch
 {
     public class CatchRuleset : Ruleset
     {
-        public override HitRenderer CreateHitRendererWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new CatchHitRenderer(beatmap, isForCurrentRuleset);
+        public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new CatchRulesetContainer(this, beatmap, isForCurrentRuleset);
+
+        public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0) => new[]
+        {
+            new KeyBinding(InputKey.Z, CatchAction.MoveLeft),
+            new KeyBinding(InputKey.Left, CatchAction.MoveLeft),
+            new KeyBinding(InputKey.X, CatchAction.MoveRight),
+            new KeyBinding(InputKey.Right, CatchAction.MoveRight),
+            new KeyBinding(InputKey.Shift, CatchAction.Dash),
+            new KeyBinding(InputKey.Shift, CatchAction.Dash),
+        };
 
         public override IEnumerable<Mod> GetModsFor(ModType type)
         {
@@ -83,21 +93,21 @@ namespace osu.Game.Rulesets.Catch
             }
         }
 
+        public override Mod GetAutoplayMod() => new ModAutoplay();
+
         public override string Description => "osu!catch";
 
-        public override FontAwesome Icon => FontAwesome.fa_osu_fruits_o;
-
-        public override IEnumerable<KeyCounter> CreateGameplayKeys() => new KeyCounter[]
-        {
-            new KeyCounterKeyboard(Key.ShiftLeft),
-            new KeyCounterMouse(MouseButton.Left),
-            new KeyCounterMouse(MouseButton.Right)
-        };
+        public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_fruits_o };
 
         public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap) => new CatchDifficultyCalculator(beatmap);
 
         public override ScoreProcessor CreateScoreProcessor() => new CatchScoreProcessor();
 
         public override int LegacyID => 2;
+
+        public CatchRuleset(RulesetInfo rulesetInfo)
+            : base(rulesetInfo)
+        {
+        }
     }
 }

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableFruit.cs

@@ -1,36 +1,128 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.Textures;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.MathUtils;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Catch.Judgements;
+using osu.Game.Rulesets.Objects.Drawables;
 using OpenTK;
+using OpenTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {
-    internal class DrawableFruit : Sprite
+    public class DrawableFruit : DrawableScrollingHitObject<CatchBaseHit, CatchJudgement>
     {
-        //private readonly CatchBaseHit h;
+        private const float pulp_size = 30;
 
-        public DrawableFruit(CatchBaseHit h)
+        private class Pulp : Circle, IHasAccentColour
         {
-            //this.h = h;
+            public Pulp()
+            {
+                Size = new Vector2(pulp_size);
 
-            Origin = Anchor.Centre;
-            Scale = new Vector2(0.1f);
-            RelativePositionAxes = Axes.Y;
-            Position = new Vector2(h.Position, -0.1f);
+                EdgeEffect = new EdgeEffectParameters
+                {
+                    Type = EdgeEffectType.Glow,
+                    Radius = 5,
+                    Colour = AccentColour.Opacity(0.5f),
+                };
+            }
+
+            public Color4 AccentColour { get; set; } = Color4.White;
         }
 
-        [BackgroundDependencyLoader]
-        private void load(TextureStore textures)
-        {
-            Texture = textures.Get(@"Menu/logo");
 
-            //Transforms.Add(new TransformPosition { StartTime = h.StartTime - 200, EndTime = h.StartTime, StartValue = new Vector2(h.Position, -0.1f), EndValue = new Vector2(h.Position, 0.9f) });
-            //Transforms.Add(new TransformAlpha { StartTime = h.StartTime + duration + 200, EndTime = h.StartTime + duration + 400, StartValue = 1, EndValue = 0 });
-            Expire(true);
+        public DrawableFruit(CatchBaseHit h)
+            : base(h)
+        {
+            Origin = Anchor.Centre;
+            Size = new Vector2(pulp_size * 2, pulp_size * 2.6f);
+
+            RelativePositionAxes = Axes.Both;
+            X = h.Position;
+
+            Colour = new Color4(RNG.NextSingle(), RNG.NextSingle(), RNG.NextSingle(), 1);
+
+            Rotation = (float)(RNG.NextDouble() - 0.5f) * 40;
+        }
+
+        public Func<CatchBaseHit, bool> CheckPosition;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Children = new Framework.Graphics.Drawable[]
+            {
+                //todo: share this more
+                new BufferedContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    CacheDrawnFrameBuffer = true,
+                    Children = new Framework.Graphics.Drawable[]
+                    {
+                        new Pulp
+                        {
+                            RelativePositionAxes = Axes.Both,
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                            Scale = new Vector2(0.6f),
+                        },
+                        new Pulp
+                        {
+                            RelativePositionAxes = Axes.Both,
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                            Y = -0.08f
+                        },
+                        new Pulp
+                        {
+                            RelativePositionAxes = Axes.Both,
+                            Anchor = Anchor.CentreRight,
+                            Origin = Anchor.CentreRight,
+                            Y = -0.08f
+                        },
+                        new Pulp
+                        {
+                            RelativePositionAxes = Axes.Both,
+                            Anchor = Anchor.BottomCentre,
+                            Origin = Anchor.BottomCentre,
+                        },
+                    }
+                }
+            };
+        }
+
+        protected override CatchJudgement CreateJudgement() => new CatchJudgement();
+
+        private const float preempt = 1000;
+
+        protected override void CheckJudgement(bool userTriggered)
+        {
+            if (Judgement.TimeOffset > 0)
+                Judgement.Result = CheckPosition?.Invoke(HitObject) ?? false ? HitResult.Hit : HitResult.Miss;
+        }
+
+        protected override void UpdateState(ArmedState state)
+        {
+            using (BeginAbsoluteSequence(HitObject.StartTime - preempt))
+            {
+                // animation
+                this.FadeIn(200);
+            }
+
+            switch (state)
+            {
+                case ArmedState.Miss:
+                    using (BeginAbsoluteSequence(HitObject.StartTime, true))
+                        this.FadeOut(250).RotateTo(Rotation * 2, 250, Easing.Out);
+                    break;
+            }
         }
     }
 }

osu.Game.Rulesets.Catch/Scoring/CatchScoreProcessor.cs

@@ -14,11 +14,19 @@ namespace osu.Game.Rulesets.Catch.Scoring
         {
         }
 
-        public CatchScoreProcessor(HitRenderer<CatchBaseHit, CatchJudgement> hitRenderer)
-            : base(hitRenderer)
+        public CatchScoreProcessor(RulesetContainer<CatchBaseHit, CatchJudgement> rulesetContainer)
+            : base(rulesetContainer)
         {
         }
 
+        protected override void Reset()
+        {
+            base.Reset();
+
+            Health.Value = 1;
+            Accuracy.Value = 1;
+        }
+
         protected override void OnNewJudgement(CatchJudgement judgement)
         {
         }

osu.Game.Rulesets.Catch/UI/CatchPlayfield.cs

@@ -2,23 +2,65 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Shapes;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.UI;
 using OpenTK;
 using osu.Game.Rulesets.Catch.Judgements;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Catch.Objects.Drawable;
+using osu.Game.Rulesets.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
-    public class CatchPlayfield : Playfield<CatchBaseHit, CatchJudgement>
+    public class CatchPlayfield : ScrollingPlayfield<CatchBaseHit, CatchJudgement>
     {
-        public CatchPlayfield()
-        {
-            Size = new Vector2(1, 0.9f);
-            Anchor = Anchor.BottomCentre;
-            Origin = Anchor.BottomCentre;
+        protected override Container<Drawable> Content => content;
+        private readonly Container<Drawable> content;
+        private readonly CatcherArea catcherArea;
 
-            Add(new Box { RelativeSizeAxes = Axes.Both, Alpha = 0.5f });
+        public CatchPlayfield()
+            : base(Axes.Y)
+        {
+            Reversed.Value = true;
+
+            Size = new Vector2(1);
+
+            Anchor = Anchor.TopCentre;
+            Origin = Anchor.TopCentre;
+
+            InternalChildren = new Drawable[]
+            {
+                content = new Container<Drawable>
+                {
+                    RelativeSizeAxes = Axes.Both,
+                },
+                catcherArea = new CatcherArea
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Anchor = Anchor.BottomLeft,
+                    Origin = Anchor.TopLeft,
+                    Height = 0.3f
+                }
+            };
+        }
+
+        public override void Add(DrawableHitObject<CatchBaseHit, CatchJudgement> h)
+        {
+            base.Add(h);
+
+            var fruit = (DrawableFruit)h;
+            fruit.CheckPosition = catcherArea.CheckIfWeCanCatch;
+            fruit.OnJudgement += Fruit_OnJudgement;
+        }
+
+        private void Fruit_OnJudgement(DrawableHitObject<CatchBaseHit, CatchJudgement> obj)
+        {
+            if (obj.Judgement.Result == HitResult.Hit)
+            {
+                Vector2 screenPosition = obj.ScreenSpaceDrawQuad.Centre;
+                Remove(obj);
+                catcherArea.Add(obj, screenPosition);
+            }
         }
     }
-}
+}

osu.Game.Rulesets.Catch/UI/CatchRulesetContainer.cs

@@ -1,11 +1,13 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Framework.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Beatmaps;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Catch.Scoring;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
@@ -13,10 +15,10 @@ using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
-    public class CatchHitRenderer : HitRenderer<CatchBaseHit, CatchJudgement>
+    public class CatchRulesetContainer : ScrollingRulesetContainer<CatchPlayfield, CatchBaseHit, CatchJudgement>
     {
-        public CatchHitRenderer(WorkingBeatmap beatmap, bool isForCurrentRuleset)
-            : base(beatmap, isForCurrentRuleset)
+        public CatchRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
+            : base(ruleset, beatmap, isForCurrentRuleset)
         {
         }
 
@@ -26,6 +28,14 @@ namespace osu.Game.Rulesets.Catch.UI
 
         protected override Playfield<CatchBaseHit, CatchJudgement> CreatePlayfield() => new CatchPlayfield();
 
-        protected override DrawableHitObject<CatchBaseHit, CatchJudgement> GetVisualRepresentation(CatchBaseHit h) => null;
+        public override PassThroughInputManager CreateInputManager() => new CatchInputManager(Ruleset.RulesetInfo);
+
+        protected override DrawableHitObject<CatchBaseHit, CatchJudgement> GetVisualRepresentation(CatchBaseHit h)
+        {
+            if (h is Fruit)
+                return new DrawableFruit(h);
+
+            return null;
+        }
     }
 }

osu.Game.Rulesets.Catch/UI/CatcherArea.cs

@@ -0,0 +1,178 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Input.Bindings;
+using osu.Framework.MathUtils;
+using osu.Game.Rulesets.Catch.Judgements;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.Objects.Drawable;
+using osu.Game.Rulesets.Objects.Drawables;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Catch.UI
+{
+    public class CatcherArea : Container
+    {
+        private Catcher catcher;
+
+        public void Add(DrawableHitObject<CatchBaseHit, CatchJudgement> fruit, Vector2 screenPosition) => catcher.AddToStack(fruit, screenPosition);
+
+        public bool CheckIfWeCanCatch(CatchBaseHit obj) => Math.Abs(catcher.Position.X - obj.Position) < catcher.DrawSize.X / DrawSize.X / 2;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Children = new Drawable[]
+            {
+                catcher = new Catcher
+                {
+                    RelativePositionAxes = Axes.Both,
+                    Anchor = Anchor.TopLeft,
+                    Origin = Anchor.TopCentre,
+                    X = 0.5f,
+                }
+            };
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            catcher.Size = new Vector2(DrawSize.Y);
+        }
+
+        private class Catcher : Container, IKeyBindingHandler<CatchAction>
+        {
+            private Texture texture;
+
+            [BackgroundDependencyLoader]
+            private void load(TextureStore textures)
+            {
+                texture = textures.Get(@"Play/Catch/fruit-catcher-idle");
+
+                Child = createCatcherSprite();
+            }
+
+            private int currentDirection;
+
+            private bool dashing;
+
+            protected bool Dashing
+            {
+                get { return dashing; }
+                set
+                {
+                    if (value == dashing) return;
+
+                    dashing = value;
+
+                    if (dashing)
+                        Schedule(addAdditiveSprite);
+                }
+            }
+
+            private void addAdditiveSprite()
+            {
+                if (!dashing) return;
+
+                var additive = createCatcherSprite();
+
+                additive.RelativePositionAxes = Axes.Both;
+                additive.BlendingMode = BlendingMode.Additive;
+                additive.Position = Position;
+                additive.Scale = Scale;
+
+                ((CatcherArea)Parent).Add(additive);
+
+                additive.FadeTo(0.4f).FadeOut(800, Easing.OutQuint).Expire();
+
+                Scheduler.AddDelayed(addAdditiveSprite, 50);
+            }
+
+            private Sprite createCatcherSprite() => new Sprite
+            {
+                RelativeSizeAxes = Axes.Both,
+                FillMode = FillMode.Fit,
+                Texture = texture,
+                OriginPosition = new Vector2(DrawWidth / 2, 10) //temporary until the sprite is aligned correctly.
+            };
+
+            public bool OnPressed(CatchAction action)
+            {
+                switch (action)
+                {
+                    case CatchAction.MoveLeft:
+                        currentDirection--;
+                        return true;
+                    case CatchAction.MoveRight:
+                        currentDirection++;
+                        return true;
+                    case CatchAction.Dash:
+                        Dashing = true;
+                        return true;
+                }
+
+                return false;
+            }
+
+            public bool OnReleased(CatchAction action)
+            {
+                switch (action)
+                {
+                    case CatchAction.MoveLeft:
+                        currentDirection++;
+                        return true;
+                    case CatchAction.MoveRight:
+                        currentDirection--;
+                        return true;
+                    case CatchAction.Dash:
+                        Dashing = false;
+                        return true;
+                }
+
+                return false;
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                if (currentDirection == 0) return;
+
+                float speed = Dashing ? 1.5f : 1;
+
+                Scale = new Vector2(Math.Sign(currentDirection), 1);
+                X = (float)MathHelper.Clamp(X + Math.Sign(currentDirection) * Clock.ElapsedFrameTime / 1800 * speed, 0, 1);
+            }
+
+            public void AddToStack(DrawableHitObject<CatchBaseHit, CatchJudgement> fruit, Vector2 absolutePosition)
+            {
+                fruit.RelativePositionAxes = Axes.None;
+                fruit.Position = new Vector2(ToLocalSpace(absolutePosition).X - DrawSize.X / 2, 0);
+
+                fruit.Anchor = Anchor.TopCentre;
+                fruit.Origin = Anchor.BottomCentre;
+                fruit.Scale *= 0.7f;
+                fruit.LifetimeEnd = double.MaxValue;
+                fruit.Depth = (float)Time.Current;
+
+                float distance = fruit.DrawSize.X / 2 * fruit.Scale.X;
+
+                while (Children.OfType<DrawableFruit>().Any(f => Vector2.DistanceSquared(f.Position, fruit.Position) < distance * distance))
+                {
+                    fruit.X += RNG.Next(-5, 5);
+                    fruit.Y -= RNG.Next(0, 5);
+                }
+
+                Add(fruit);
+            }
+        }
+    }
+}

osu.Game.Rulesets.Catch/osu.Game.Rulesets.Catch.csproj

@@ -38,6 +38,7 @@
       <Private>True</Private>
     </Reference>
     <Reference Include="System" />
+    <Reference Include="System.Collections" />
     <Reference Include="System.Core" />
     <Reference Include="System.Drawing" />
     <Reference Include="System.Xml.Linq" />
@@ -50,6 +51,7 @@
   <ItemGroup>
     <Compile Include="Beatmaps\CatchBeatmapConverter.cs" />
     <Compile Include="CatchDifficultyCalculator.cs" />
+    <Compile Include="CatchInputManager.cs" />
     <Compile Include="Scoring\CatchScoreProcessor.cs" />
     <Compile Include="Judgements\CatchJudgement.cs" />
     <Compile Include="Objects\CatchBaseHit.cs" />
@@ -57,7 +59,8 @@
     <Compile Include="Objects\Droplet.cs" />
     <Compile Include="Objects\Fruit.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="UI\CatchHitRenderer.cs" />
+    <Compile Include="UI\CatcherArea.cs" />
+    <Compile Include="UI\CatchRulesetContainer.cs" />
     <Compile Include="UI\CatchPlayfield.cs" />
     <Compile Include="CatchRuleset.cs" />
     <Compile Include="Mods\CatchMod.cs" />

osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs

@@ -28,12 +28,20 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         private Pattern lastPattern = new Pattern();
         private FastRandom random;
         private Beatmap beatmap;
-        private bool isForCurrentRuleset;
 
-        protected override Beatmap<ManiaHitObject> ConvertBeatmap(Beatmap original, bool isForCurrentRuleset)
+        private readonly int availableColumns;
+        private readonly bool isForCurrentRuleset;
+
+        public ManiaBeatmapConverter(bool isForCurrentRuleset, int availableColumns)
         {
-            this.isForCurrentRuleset = isForCurrentRuleset;
+            if (availableColumns <= 0) throw new ArgumentOutOfRangeException(nameof(availableColumns));
 
+            this.isForCurrentRuleset = isForCurrentRuleset;
+            this.availableColumns = availableColumns;
+        }
+
+        protected override Beatmap<ManiaHitObject> ConvertBeatmap(Beatmap original)
+        {
             beatmap = original;
 
             BeatmapDifficulty difficulty = original.BeatmapInfo.Difficulty;
@@ -41,7 +49,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             int seed = (int)Math.Round(difficulty.DrainRate + difficulty.CircleSize) * 20 + (int)(difficulty.OverallDifficulty * 41.2) + (int)Math.Round(difficulty.ApproachRate);
             random = new FastRandom(seed);
 
-            return base.ConvertBeatmap(original, isForCurrentRuleset);
+            return base.ConvertBeatmap(original);
         }
 
         protected override IEnumerable<ManiaHitObject> ConvertHitObject(HitObject original, Beatmap beatmap)
@@ -89,7 +97,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         /// <returns>The hit objects generated.</returns>
         private IEnumerable<ManiaHitObject> generateSpecific(HitObject original)
         {
-            var generator = new SpecificBeatmapPatternGenerator(random, original, beatmap, lastPattern);
+            var generator = new SpecificBeatmapPatternGenerator(random, original, beatmap, availableColumns, lastPattern);
 
             Pattern newPattern = generator.Generate();
             lastPattern = newPattern;
@@ -113,14 +121,14 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             Patterns.PatternGenerator conversion = null;
 
             if (distanceData != null)
-                conversion = new DistanceObjectPatternGenerator(random, original, beatmap, lastPattern);
+                conversion = new DistanceObjectPatternGenerator(random, original, beatmap, availableColumns, lastPattern);
             else if (endTimeData != null)
-                conversion = new EndTimeObjectPatternGenerator(random, original, beatmap);
+                conversion = new EndTimeObjectPatternGenerator(random, original, beatmap, availableColumns);
             else if (positionData != null)
             {
                 computeDensity(original.StartTime);
 
-                conversion = new HitObjectPatternGenerator(random, original, beatmap, lastPattern, lastTime, lastPosition, density, lastStair);
+                conversion = new HitObjectPatternGenerator(random, original, beatmap, availableColumns, lastPattern, lastTime, lastPosition, density, lastStair);
 
                 recordNote(original.StartTime, positionData.Position);
             }
@@ -142,8 +150,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         /// </summary>
         private class SpecificBeatmapPatternGenerator : Patterns.Legacy.PatternGenerator
         {
-            public SpecificBeatmapPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, Pattern previousPattern)
-                : base(random, hitObject, beatmap, previousPattern)
+            public SpecificBeatmapPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, int availableColumns, Pattern previousPattern)
+                : base(random, hitObject, beatmap, availableColumns, previousPattern)
             {
             }
 

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/DistanceObjectPatternGenerator.cs

@@ -29,8 +29,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
         private PatternType convertType;
 
-        public DistanceObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, Pattern previousPattern)
-            : base(random, hitObject, beatmap, previousPattern)
+        public DistanceObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, int availableColumns, Pattern previousPattern)
+            : base(random, hitObject, beatmap, availableColumns, previousPattern)
         {
             convertType = PatternType.None;
             if (Beatmap.ControlPointInfo.EffectPointAt(hitObject.StartTime).KiaiMode)
@@ -47,7 +47,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             // The true distance, accounting for any repeats
             double distance = (distanceData?.Distance ?? 0) * repeatCount;
             // The velocity of the osu! hit object - calculated as the velocity of a slider
-            double osuVelocity = osu_base_scoring_distance * beatmap.BeatmapInfo.Difficulty.SliderMultiplier / (timingPoint.BeatLength * difficultyPoint.SpeedMultiplier);
+            double osuVelocity = osu_base_scoring_distance * beatmap.BeatmapInfo.Difficulty.SliderMultiplier * difficultyPoint.SpeedMultiplier / timingPoint.BeatLength;
             // The duration of the osu! hit object
             double osuDuration = distance / osuVelocity;
 

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/EndTimeObjectPatternGenerator.cs

@@ -15,8 +15,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
     {
         private readonly double endTime;
 
-        public EndTimeObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap)
-            : base(random, hitObject, beatmap, new Pattern())
+        public EndTimeObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, int availableColumns)
+            : base(random, hitObject, beatmap, availableColumns, new Pattern())
         {
             var endtimeData = HitObject as IHasEndTime;
 

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/HitObjectPatternGenerator.cs

@@ -20,9 +20,12 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
         private readonly PatternType convertType;
 
-        public HitObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, Pattern previousPattern, double previousTime, Vector2 previousPosition, double density, PatternType lastStair)
-            : base(random, hitObject, beatmap, previousPattern)
+        public HitObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, int availableColumns, Pattern previousPattern, double previousTime, Vector2 previousPosition, double density, PatternType lastStair)
+            : base(random, hitObject, beatmap, availableColumns, previousPattern)
         {
+            if (previousTime > hitObject.StartTime) throw new ArgumentOutOfRangeException(nameof(previousTime));
+            if (density < 0) throw new ArgumentOutOfRangeException(nameof(density));
+
             StairType = lastStair;
 
             TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(hitObject.StartTime);
@@ -33,12 +36,6 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             float positionSeparation = ((positionData?.Position ?? Vector2.Zero) - previousPosition).Length;
             double timeSeparation = hitObject.StartTime - previousTime;
 
-            if (timeSeparation <= 125)
-            {
-                // More than 120 BPM
-                convertType |= PatternType.ForceNotStack;
-            }
-
             if (timeSeparation <= 80)
             {
                 // More than 187 BPM
@@ -64,7 +61,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 // More than 111 BPM stream
                 convertType |= PatternType.Cycle | PatternType.KeepSingle;
             }
-            else if (timeSeparation <= 150 & positionSeparation < 20)
+            else if (timeSeparation <= 150 && positionSeparation < 20)
             {
                 // More than 100 BPM stream
                 convertType |= PatternType.ForceStack | PatternType.LowProbability;
@@ -401,4 +398,4 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             });
         }
     }
-}
+}

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/PatternGenerator.cs

@@ -25,11 +25,15 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// </summary>
         protected readonly FastRandom Random;
 
-        protected PatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, Pattern previousPattern)
-            : base(hitObject, beatmap, previousPattern)
+        protected PatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, int availableColumns, Pattern previousPattern)
+            : base(hitObject, beatmap, availableColumns, previousPattern)
         {
-            Random = random;
+            if (random == null) throw new ArgumentNullException(nameof(random));
+            if (beatmap == null) throw new ArgumentNullException(nameof(beatmap));
+            if (availableColumns <= 0) throw new ArgumentOutOfRangeException(nameof(availableColumns));
+            if (previousPattern == null) throw new ArgumentNullException(nameof(previousPattern));
 
+            Random = random;
             RandomStart = AvailableColumns == 8 ? 1 : 0;
         }
 
@@ -62,6 +66,12 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// <returns>The amount of notes to be generated.</returns>
         protected int GetRandomNoteCount(double p2, double p3, double p4 = 0, double p5 = 0, double p6 = 0)
         {
+            if (p2 < 0 || p2 > 1) throw new ArgumentOutOfRangeException(nameof(p2));
+            if (p3 < 0 || p3 > 1) throw new ArgumentOutOfRangeException(nameof(p3));
+            if (p4 < 0 || p4 > 1) throw new ArgumentOutOfRangeException(nameof(p4));
+            if (p5 < 0 || p5 > 1) throw new ArgumentOutOfRangeException(nameof(p5));
+            if (p6 < 0 || p6 > 1) throw new ArgumentOutOfRangeException(nameof(p6));
+
             double val = Random.NextDouble();
             if (val >= 1 - p6)
                 return 6;

osu.Game.Rulesets.Mania/Beatmaps/Patterns/PatternGenerator.cs

@@ -32,13 +32,17 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns
         /// </summary>
         protected readonly Beatmap Beatmap;
 
-        protected PatternGenerator(HitObject hitObject, Beatmap beatmap, Pattern previousPattern)
+        protected PatternGenerator(HitObject hitObject, Beatmap beatmap, int availableColumns, Pattern previousPattern)
         {
-            PreviousPattern = previousPattern;
+            if (hitObject == null) throw new ArgumentNullException(nameof(hitObject));
+            if (beatmap == null) throw new ArgumentNullException(nameof(beatmap));
+            if (availableColumns <= 0) throw new ArgumentOutOfRangeException(nameof(availableColumns));
+            if (previousPattern == null) throw new ArgumentNullException(nameof(previousPattern));
+
             HitObject = hitObject;
             Beatmap = beatmap;
-
-            AvailableColumns = (int)Math.Round(beatmap.BeatmapInfo.Difficulty.CircleSize);
+            AvailableColumns = availableColumns;
+            PreviousPattern = previousPattern;
         }
 
         /// <summary>

osu.Game.Rulesets.Mania/ManiaDifficultyCalculator.cs

@@ -6,6 +6,7 @@ using osu.Game.Rulesets.Beatmaps;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using System.Collections.Generic;
+using System;
 
 namespace osu.Game.Rulesets.Mania
 {
@@ -21,6 +22,6 @@ namespace osu.Game.Rulesets.Mania
             return 0;
         }
 
-        protected override BeatmapConverter<ManiaHitObject> CreateBeatmapConverter() => new ManiaBeatmapConverter();
+        protected override BeatmapConverter<ManiaHitObject> CreateBeatmapConverter() => new ManiaBeatmapConverter(true, (int)Math.Max(1, Math.Round(Beatmap.BeatmapInfo.Difficulty.CircleSize)));
     }
-}
+}

osu.Game.Rulesets.Mania/ManiaInputManager.cs

@@ -0,0 +1,41 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.ComponentModel;
+using osu.Framework.Input.Bindings;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Mania
+{
+    public class ManiaInputManager : RulesetInputManager<ManiaAction>
+    {
+        public ManiaInputManager(RulesetInfo ruleset, int variant)
+            : base(ruleset, variant, SimultaneousBindingMode.Unique)
+        {
+        }
+    }
+
+    public enum ManiaAction
+    {
+        [Description("Special")]
+        Special,
+        [Description("Key 1")]
+        Key1 = 10,
+        [Description("Key 2")]
+        Key2,
+        [Description("Key 3")]
+        Key3,
+        [Description("Key 4")]
+        Key4,
+        [Description("Key 5")]
+        Key5,
+        [Description("Key 6")]
+        Key6,
+        [Description("Key 7")]
+        Key7,
+        [Description("Key 8")]
+        Key8,
+        [Description("Key 9")]
+        Key9
+    }
+}

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -2,13 +2,14 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Game.Beatmaps;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
-using osu.Game.Screens.Play;
 using System.Collections.Generic;
+using osu.Framework.Graphics;
+using osu.Framework.Input.Bindings;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Scoring;
 
@@ -16,7 +17,7 @@ namespace osu.Game.Rulesets.Mania
 {
     public class ManiaRuleset : Ruleset
     {
-        public override HitRenderer CreateHitRendererWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new ManiaHitRenderer(beatmap, isForCurrentRuleset);
+        public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new ManiaRulesetContainer(this, beatmap, isForCurrentRuleset);
 
         public override IEnumerable<Mod> GetModsFor(ModType type)
         {
@@ -104,16 +105,59 @@ namespace osu.Game.Rulesets.Mania
             }
         }
 
+        public override Mod GetAutoplayMod() => new ModAutoplay();
+
         public override string Description => "osu!mania";
 
-        public override FontAwesome Icon => FontAwesome.fa_osu_mania_o;
-
-        public override IEnumerable<KeyCounter> CreateGameplayKeys() => new KeyCounter[] { /* Todo: Should be keymod specific */ };
+        public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_mania_o };
 
         public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap) => new ManiaDifficultyCalculator(beatmap);
 
         public override ScoreProcessor CreateScoreProcessor() => new ManiaScoreProcessor();
 
         public override int LegacyID => 3;
+
+        public ManiaRuleset(RulesetInfo rulesetInfo)
+            : base(rulesetInfo)
+        {
+        }
+
+        public override IEnumerable<int> AvailableVariants => new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+        public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0)
+        {
+            var leftKeys = new[]
+            {
+                InputKey.A,
+                InputKey.S,
+                InputKey.D,
+                InputKey.F
+            };
+
+            var rightKeys = new[]
+            {
+                InputKey.J,
+                InputKey.K,
+                InputKey.L,
+                InputKey.Semicolon
+            };
+
+            ManiaAction currentKey = ManiaAction.Key1;
+
+            var bindings = new List<KeyBinding>();
+
+            for (int i = leftKeys.Length - variant / 2; i < leftKeys.Length; i++)
+                bindings.Add(new KeyBinding(leftKeys[i], currentKey++));
+
+            for (int i = 0; i < variant / 2; i++)
+                bindings.Add(new KeyBinding(rightKeys[i], currentKey++));
+
+            if (variant % 2 == 1)
+                bindings.Add(new KeyBinding(InputKey.Space, ManiaAction.Special));
+
+            return bindings;
+        }
+
+        public override string GetVariantName(int variant) => $"{variant}K";
     }
 }

osu.Game.Rulesets.Mania/Mods/IGenerateSpeedAdjustments.cs

@@ -15,9 +15,9 @@ namespace osu.Game.Rulesets.Mania.Mods
         /// <summary>
         /// Applies this mod to a hit renderer.
         /// </summary>
-        /// <param name="hitRenderer">The hit renderer to apply to.</param>
+        /// <param name="rulesetContainer">The hit renderer to apply to.</param>
         /// <param name="hitObjectTimingChanges">The per-column list of speed adjustments for hit objects.</param>
         /// <param name="barlineTimingChanges">The list of speed adjustments for bar lines.</param>
-        void ApplyToHitRenderer(ManiaHitRenderer hitRenderer, ref List<SpeedAdjustmentContainer>[] hitObjectTimingChanges, ref List<SpeedAdjustmentContainer> barlineTimingChanges);
+        void ApplyToRulesetContainer(ManiaRulesetContainer rulesetContainer, ref List<SpeedAdjustmentContainer>[] hitObjectTimingChanges, ref List<SpeedAdjustmentContainer> barlineTimingChanges);
     }
 }

osu.Game.Rulesets.Mania/Mods/ManiaModGravity.cs

@@ -20,12 +20,12 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override FontAwesome Icon => FontAwesome.fa_sort_desc;
 
-        public void ApplyToHitRenderer(ManiaHitRenderer hitRenderer, ref List<SpeedAdjustmentContainer>[] hitObjectTimingChanges, ref List<SpeedAdjustmentContainer> barlineTimingChanges)
+        public void ApplyToRulesetContainer(ManiaRulesetContainer rulesetContainer, ref List<SpeedAdjustmentContainer>[] hitObjectTimingChanges, ref List<SpeedAdjustmentContainer> barlineTimingChanges)
         {
             // We have to generate one speed adjustment per hit object for gravity
-            foreach (ManiaHitObject obj in hitRenderer.Objects)
+            foreach (ManiaHitObject obj in rulesetContainer.Objects)
             {
-                MultiplierControlPoint controlPoint = hitRenderer.CreateControlPointAt(obj.StartTime);
+                MultiplierControlPoint controlPoint = rulesetContainer.CreateControlPointAt(obj.StartTime);
                 // Beat length has too large of an effect for gravity, so we'll force it to a constant value for now
                 controlPoint.TimingPoint.BeatLength = 1000;
 
@@ -33,9 +33,9 @@ namespace osu.Game.Rulesets.Mania.Mods
             }
 
             // Like with hit objects, we need to generate one speed adjustment per bar line
-            foreach (DrawableBarLine barLine in hitRenderer.BarLines)
+            foreach (DrawableBarLine barLine in rulesetContainer.BarLines)
             {
-                var controlPoint = hitRenderer.CreateControlPointAt(barLine.HitObject.StartTime);
+                var controlPoint = rulesetContainer.CreateControlPointAt(barLine.HitObject.StartTime);
                 // Beat length has too large of an effect for gravity, so we'll force it to a constant value for now
                 controlPoint.TimingPoint.BeatLength = 1000;
 

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

@@ -5,20 +5,18 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using OpenTK.Graphics;
-using osu.Framework.Configuration;
-using OpenTK.Input;
-using osu.Framework.Input;
 using OpenTK;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Mania.Judgements;
 using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Input.Bindings;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables
 {
     /// <summary>
     /// Visualises a <see cref="HoldNote"/> hit object.
     /// </summary>
-    public class DrawableHoldNote : DrawableManiaHitObject<HoldNote>
+    public class DrawableHoldNote : DrawableManiaHitObject<HoldNote>, IKeyBindingHandler<ManiaAction>
     {
         private readonly DrawableNote head;
         private readonly DrawableNote tail;
@@ -36,8 +34,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         /// </summary>
         private bool hasBroken;
 
-        public DrawableHoldNote(HoldNote hitObject, Bindable<Key> key = null)
-            : base(hitObject, key)
+        public DrawableHoldNote(HoldNote hitObject, ManiaAction action)
+            : base(hitObject, action)
         {
             RelativeSizeAxes = Axes.Both;
             Height = (float)HitObject.Duration;
@@ -58,12 +56,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                     RelativeChildOffset = new Vector2(0, (float)HitObject.StartTime),
                     RelativeChildSize = new Vector2(1, (float)HitObject.Duration)
                 },
-                head = new DrawableHeadNote(this, key)
+                head = new DrawableHeadNote(this, action)
                 {
                     Anchor = Anchor.TopCentre,
                     Origin = Anchor.TopCentre
                 },
-                tail = new DrawableTailNote(this, key)
+                tail = new DrawableTailNote(this, action)
                 {
                     Anchor = Anchor.BottomCentre,
                     Origin = Anchor.TopCentre
@@ -106,16 +104,13 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
         }
 
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        public bool OnPressed(ManiaAction action)
         {
-            // Make sure the keypress happened within the body of the hold note
+            // Make sure the action happened within the body of the hold note
             if (Time.Current < HitObject.StartTime || Time.Current > HitObject.EndTime)
                 return false;
 
-            if (args.Key != Key)
-                return false;
-
-            if (args.Repeat)
+            if (action != Action)
                 return false;
 
             // The user has pressed during the body of the hold note, after the head note and its hit windows have passed
@@ -126,13 +121,13 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             return true;
         }
 
-        protected override bool OnKeyUp(InputState state, KeyUpEventArgs args)
+        public bool OnReleased(ManiaAction action)
         {
             // Make sure that the user started holding the key during the hold note
             if (!holdStartTime.HasValue)
                 return false;
 
-            if (args.Key != Key)
+            if (action != Action)
                 return false;
 
             holdStartTime = null;
@@ -151,8 +146,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
             private readonly DrawableHoldNote holdNote;
 
-            public DrawableHeadNote(DrawableHoldNote holdNote, Bindable<Key> key = null)
-                : base(holdNote.HitObject.Head, key)
+            public DrawableHeadNote(DrawableHoldNote holdNote, ManiaAction action)
+                : base(holdNote.HitObject.Head, action)
             {
                 this.holdNote = holdNote;
 
@@ -160,9 +155,9 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 Y = 0;
             }
 
-            protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+            public override bool OnPressed(ManiaAction action)
             {
-                if (!base.OnKeyDown(state, args))
+                if (!base.OnPressed(action))
                     return false;
 
                 // We only want to trigger a holding state from the head if the head has received a judgement
@@ -188,8 +183,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
             private readonly DrawableHoldNote holdNote;
 
-            public DrawableTailNote(DrawableHoldNote holdNote, Bindable<Key> key = null)
-                : base(holdNote.HitObject.Tail, key)
+            public DrawableTailNote(DrawableHoldNote holdNote, ManiaAction action)
+                : base(holdNote.HitObject.Tail, action)
             {
                 this.holdNote = holdNote;
 
@@ -210,7 +205,9 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 tailJudgement.HasBroken = holdNote.hasBroken;
             }
 
-            protected override bool OnKeyUp(InputState state, KeyUpEventArgs args)
+            public override bool OnPressed(ManiaAction action) => false; // Tail doesn't handle key down
+
+            public override bool OnReleased(ManiaAction action)
             {
                 // Make sure that the user started holding the key during the hold note
                 if (!holdNote.holdStartTime.HasValue)
@@ -219,7 +216,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 if (Judgement.Result != HitResult.None)
                     return false;
 
-                if (args.Key != Key)
+                if (action != Action)
                     return false;
 
                 UpdateJudgement(true);
@@ -227,12 +224,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 // Handled by the hold note, which will set holding = false
                 return false;
             }
-
-            protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
-            {
-                // Tail doesn't handle key down
-                return false;
-            }
         }
     }
 }

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

@@ -2,9 +2,6 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using OpenTK.Graphics;
-using OpenTK.Input;
-using osu.Framework.Configuration;
-using osu.Framework.Graphics;
 using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
 
@@ -16,20 +13,17 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         /// <summary>
         /// The key that will trigger input for this hit object.
         /// </summary>
-        protected Bindable<Key> Key { get; private set; } = new Bindable<Key>();
+        protected ManiaAction Action { get; }
 
         public new TObject HitObject;
 
-        protected DrawableManiaHitObject(TObject hitObject, Bindable<Key> key = null)
+        protected DrawableManiaHitObject(TObject hitObject, ManiaAction? action = null)
             : base(hitObject)
         {
             HitObject = hitObject;
 
-            if (key != null)
-                Key.BindTo(key);
-
-            RelativePositionAxes = Axes.Y;
-            Y = (float)HitObject.StartTime;
+            if (action != null)
+                Action = action.Value;
         }
 
         public override Color4 AccentColour

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

@@ -3,10 +3,8 @@
 
 using System;
 using OpenTK.Graphics;
-using OpenTK.Input;
-using osu.Framework.Configuration;
 using osu.Framework.Graphics;
-using osu.Framework.Input;
+using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -16,12 +14,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
     /// <summary>
     /// Visualises a <see cref="Note"/> hit object.
     /// </summary>
-    public class DrawableNote : DrawableManiaHitObject<Note>
+    public class DrawableNote : DrawableManiaHitObject<Note>, IKeyBindingHandler<ManiaAction>
     {
         private readonly NotePiece headPiece;
 
-        public DrawableNote(Note hitObject, Bindable<Key> key = null)
-            : base(hitObject, key)
+        public DrawableNote(Note hitObject, ManiaAction action)
+            : base(hitObject, action)
         {
             RelativeSizeAxes = Axes.X;
             Height = 100;
@@ -81,18 +79,14 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             }
         }
 
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        public virtual bool OnPressed(ManiaAction action)
         {
-            if (Judgement.Result != HitResult.None)
-                return false;
-
-            if (args.Key != Key)
-                return false;
-
-            if (args.Repeat)
+            if (action != Action)
                 return false;
 
             return UpdateJudgement(true);
         }
+
+        public virtual bool OnReleased(ManiaAction action) => false;
     }
 }

osu.Game.Rulesets.Mania/Scoring/ManiaScoreProcessor.cs

@@ -155,8 +155,8 @@ namespace osu.Game.Rulesets.Mania.Scoring
         {
         }
 
-        public ManiaScoreProcessor(HitRenderer<ManiaHitObject, ManiaJudgement> hitRenderer)
-            : base(hitRenderer)
+        public ManiaScoreProcessor(RulesetContainer<ManiaHitObject, ManiaJudgement> rulesetContainer)
+            : base(rulesetContainer)
         {
         }
 

osu.Game.Rulesets.Mania/Timing/BasicScrollingDrawableTimingSection.cs

@@ -1,27 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Game.Rulesets.Timing;
-
-namespace osu.Game.Rulesets.Mania.Timing
-{
-    /// <summary>
-    /// A <see cref="DrawableTimingSection"/> which scrolls relative to the control point start time.
-    /// </summary>
-    internal class BasicScrollingDrawableTimingSection : DrawableTimingSection
-    {
-        private readonly MultiplierControlPoint controlPoint;
-
-        public BasicScrollingDrawableTimingSection(MultiplierControlPoint controlPoint)
-        {
-            this.controlPoint = controlPoint;
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-
-            Y = (float)(controlPoint.StartTime - Time.Current);
-        }
-    }
-}

osu.Game.Rulesets.Mania/Timing/GravityScrollingContainer.cs

@@ -6,13 +6,13 @@ using osu.Game.Rulesets.Timing;
 namespace osu.Game.Rulesets.Mania.Timing
 {
     /// <summary>
-    /// A <see cref="DrawableTimingSection"/> that emulates a form of gravity where hit objects speed up over time.
+    /// A <see cref="ScrollingContainer"/> that emulates a form of gravity where hit objects speed up over time.
     /// </summary>
-    internal class GravityScrollingDrawableTimingSection : DrawableTimingSection
+    internal class GravityScrollingContainer : ScrollingContainer
     {
         private readonly MultiplierControlPoint controlPoint;
 
-        public GravityScrollingDrawableTimingSection(MultiplierControlPoint controlPoint)
+        public GravityScrollingContainer(MultiplierControlPoint controlPoint)
         {
             this.controlPoint = controlPoint;
         }
@@ -51,10 +51,10 @@ namespace osu.Game.Rulesets.Mania.Timing
         private double acceleration => 1 / VisibleTimeRange;
 
         /// <summary>
-        /// Computes the current time relative to <paramref name="time"/>, accounting for <see cref="DrawableTimingSection.VisibleTimeRange"/>.
+        /// Computes the current time relative to <paramref name="time"/>, accounting for <see cref="ScrollingContainer.VisibleTimeRange"/>.
         /// </summary>
         /// <param name="time">The non-offset time.</param>
-        /// <returns>The current time relative to <paramref name="time"/> - <see cref="DrawableTimingSection.VisibleTimeRange"/>. </returns>
+        /// <returns>The current time relative to <paramref name="time"/> - <see cref="ScrollingContainer.VisibleTimeRange"/>. </returns>
         private double relativeTimeAt(double time) => Time.Current - time + VisibleTimeRange;
     }
 }

osu.Game.Rulesets.Mania/Timing/ManiaSpeedAdjustmentContainer.cs

@@ -15,15 +15,14 @@ namespace osu.Game.Rulesets.Mania.Timing
             this.scrollingAlgorithm = scrollingAlgorithm;
         }
 
-        protected override DrawableTimingSection CreateTimingSection()
+        protected override ScrollingContainer CreateScrollingContainer()
         {
             switch (scrollingAlgorithm)
             {
                 default:
-                case ScrollingAlgorithm.Basic:
-                    return new BasicScrollingDrawableTimingSection(ControlPoint);
+                    return base.CreateScrollingContainer();
                 case ScrollingAlgorithm.Gravity:
-                    return new GravityScrollingDrawableTimingSection(ControlPoint);
+                    return new GravityScrollingContainer(ControlPoint);
             }
         }
     }

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

@@ -3,22 +3,22 @@
 
 using OpenTK;
 using OpenTK.Graphics;
-using OpenTK.Input;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Colour;
-using osu.Framework.Input;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using System;
-using osu.Framework.Configuration;
-using osu.Game.Rulesets.Timing;
+using osu.Framework.Input.Bindings;
+using osu.Game.Rulesets.UI;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Judgements;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
-    public class Column : Container, IHasAccentColour
+    public class Column : ScrollingPlayfield<ManiaHitObject, ManiaJudgement>, IHasAccentColour
     {
         private const float key_icon_size = 10;
         private const float key_icon_corner_radius = 3;
@@ -30,30 +30,21 @@ namespace osu.Game.Rulesets.Mania.UI
         private const float column_width = 45;
         private const float special_column_width = 70;
 
-        private readonly BindableDouble visibleTimeRange = new BindableDouble();
-        public BindableDouble VisibleTimeRange
-        {
-            get { return visibleTimeRange; }
-            set { visibleTimeRange.BindTo(value); }
-        }
-
-        /// <summary>
-        /// The key that will trigger input actions for this column and hit objects contained inside it.
-        /// </summary>
-        public Bindable<Key> Key = new Bindable<Key>();
+        public ManiaAction Action;
 
         private readonly Box background;
         private readonly Container hitTargetBar;
         private readonly Container keyIcon;
 
-        private readonly SpeedAdjustmentCollection speedAdjustments;
+        protected override Container<Drawable> Content => content;
+        private readonly Container<Drawable> content;
 
         public Column()
+            : base(Axes.Y)
         {
-            RelativeSizeAxes = Axes.Y;
             Width = column_width;
 
-            Children = new Drawable[]
+            InternalChildren = new Drawable[]
             {
                 background = new Box
                 {
@@ -97,17 +88,16 @@ namespace osu.Game.Rulesets.Mania.UI
                                 }
                             }
                         },
-                        speedAdjustments = new SpeedAdjustmentCollection(Axes.Y)
+                        content = new Container
                         {
                             Name = "Hit objects",
                             RelativeSizeAxes = Axes.Both,
-                            VisibleTimeRange = VisibleTimeRange
                         },
                         // For column lighting, we need to capture input events before the notes
                         new InputTarget
                         {
-                            KeyDown = onKeyDown,
-                            KeyUp = onKeyUp
+                            Pressed = onPressed,
+                            Released = onReleased
                         }
                     }
                 },
@@ -150,6 +140,8 @@ namespace osu.Game.Rulesets.Mania.UI
             };
         }
 
+        public override Axes RelativeSizeAxes => Axes.Y;
+
         private bool isSpecial;
         public bool IsSpecial
         {
@@ -192,19 +184,19 @@ namespace osu.Game.Rulesets.Mania.UI
             }
         }
 
-        public void Add(SpeedAdjustmentContainer speedAdjustment) => speedAdjustments.Add(speedAdjustment);
-        public void Add(DrawableHitObject hitObject)
+        /// <summary>
+        /// Adds a DrawableHitObject to this Playfield.
+        /// </summary>
+        /// <param name="hitObject">The DrawableHitObject to add.</param>
+        public override void Add(DrawableHitObject<ManiaHitObject, ManiaJudgement> hitObject)
         {
             hitObject.AccentColour = AccentColour;
-            speedAdjustments.Add(hitObject);
+            HitObjects.Add(hitObject);
         }
 
-        private bool onKeyDown(InputState state, KeyDownEventArgs args)
+        private bool onPressed(ManiaAction action)
         {
-            if (args.Repeat)
-                return false;
-
-            if (args.Key == Key)
+            if (action == Action)
             {
                 background.FadeTo(background.Alpha + 0.2f, 50, Easing.OutQuint);
                 keyIcon.ScaleTo(1.4f, 50, Easing.OutQuint);
@@ -213,9 +205,9 @@ namespace osu.Game.Rulesets.Mania.UI
             return false;
         }
 
-        private bool onKeyUp(InputState state, KeyUpEventArgs args)
+        private bool onReleased(ManiaAction action)
         {
-            if (args.Key == Key)
+            if (action == Action)
             {
                 background.FadeTo(0.2f, 800, Easing.OutQuart);
                 keyIcon.ScaleTo(1f, 400, Easing.OutQuart);
@@ -227,10 +219,10 @@ namespace osu.Game.Rulesets.Mania.UI
         /// <summary>
         /// This is a simple container which delegates various input events that have to be captured before the notes.
         /// </summary>
-        private class InputTarget : Container
+        private class InputTarget : Container, IKeyBindingHandler<ManiaAction>
         {
-            public Func<InputState, KeyDownEventArgs, bool> KeyDown;
-            public Func<InputState, KeyUpEventArgs, bool> KeyUp;
+            public Func<ManiaAction, bool> Pressed;
+            public Func<ManiaAction, bool> Released;
 
             public InputTarget()
             {
@@ -239,8 +231,8 @@ namespace osu.Game.Rulesets.Mania.UI
                 Alpha = 0;
             }
 
-            protected override bool OnKeyDown(InputState state, KeyDownEventArgs args) => KeyDown?.Invoke(state, args) ?? false;
-            protected override bool OnKeyUp(InputState state, KeyUpEventArgs args) => KeyUp?.Invoke(state, args) ?? false;
+            public bool OnPressed(ManiaAction action) => Pressed?.Invoke(action) ?? false;
+            public bool OnReleased(ManiaAction action) => Released?.Invoke(action) ?? false;
         }
     }
 }

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

@@ -1,172 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using OpenTK;
-using OpenTK.Input;
-using osu.Framework.Allocation;
-using osu.Framework.Configuration;
-using osu.Framework.Extensions.IEnumerableExtensions;
-using osu.Framework.Graphics;
-using osu.Framework.Lists;
-using osu.Framework.MathUtils;
-using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Rulesets.Beatmaps;
-using osu.Game.Rulesets.Mania.Beatmaps;
-using osu.Game.Rulesets.Mania.Judgements;
-using osu.Game.Rulesets.Mania.Mods;
-using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.Mania.Objects.Drawables;
-using osu.Game.Rulesets.Mania.Scoring;
-using osu.Game.Rulesets.Mania.Timing;
-using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Objects.Types;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.Timing;
-using osu.Game.Rulesets.UI;
-
-namespace osu.Game.Rulesets.Mania.UI
-{
-    public class ManiaHitRenderer : SpeedAdjustedHitRenderer<ManiaHitObject, ManiaJudgement>
-    {
-        /// <summary>
-        /// Preferred column count. This will only have an effect during the initialization of the play field.
-        /// </summary>
-        public int PreferredColumns;
-
-        public IEnumerable<DrawableBarLine> BarLines;
-
-        /// <summary>
-        /// Per-column timing changes.
-        /// </summary>
-        private readonly List<SpeedAdjustmentContainer>[] hitObjectSpeedAdjustments;
-
-        /// <summary>
-        /// Bar line timing changes.
-        /// </summary>
-        private readonly List<SpeedAdjustmentContainer> barLineSpeedAdjustments = new List<SpeedAdjustmentContainer>();
-
-        public ManiaHitRenderer(WorkingBeatmap beatmap, bool isForCurrentRuleset)
-            : base(beatmap, isForCurrentRuleset)
-        {
-            // Generate the speed adjustment container lists
-            hitObjectSpeedAdjustments = new List<SpeedAdjustmentContainer>[PreferredColumns];
-            for (int i = 0; i < PreferredColumns; i++)
-                hitObjectSpeedAdjustments[i] = new List<SpeedAdjustmentContainer>();
-
-            // Generate the bar lines
-            double lastObjectTime = (Objects.LastOrDefault() as IHasEndTime)?.EndTime ?? Objects.LastOrDefault()?.StartTime ?? double.MaxValue;
-
-            SortedList<TimingControlPoint> timingPoints = Beatmap.ControlPointInfo.TimingPoints;
-            var barLines = new List<DrawableBarLine>();
-
-            for (int i = 0; i < timingPoints.Count; i++)
-            {
-                TimingControlPoint point = timingPoints[i];
-
-                // Stop on the beat before the next timing point, or if there is no next timing point stop slightly past the last object
-                double endTime = i < timingPoints.Count - 1 ? timingPoints[i + 1].Time - point.BeatLength : lastObjectTime + point.BeatLength * (int)point.TimeSignature;
-
-                int index = 0;
-                for (double t = timingPoints[i].Time; Precision.DefinitelyBigger(endTime, t); t += point.BeatLength, index++)
-                {
-                    barLines.Add(new DrawableBarLine(new BarLine
-                    {
-                        StartTime = t,
-                        ControlPoint = point,
-                        BeatIndex = index
-                    }));
-                }
-            }
-
-            BarLines = barLines;
-
-            // Generate speed adjustments from mods first
-            bool useDefaultSpeedAdjustments = true;
-
-            if (Mods != null)
-            {
-                foreach (var speedAdjustmentMod in Mods.OfType<IGenerateSpeedAdjustments>())
-                {
-                    useDefaultSpeedAdjustments = false;
-                    speedAdjustmentMod.ApplyToHitRenderer(this, ref hitObjectSpeedAdjustments, ref barLineSpeedAdjustments);
-                }
-            }
-
-            // Generate the default speed adjustments
-            if (useDefaultSpeedAdjustments)
-                generateDefaultSpeedAdjustments();
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            var maniaPlayfield = (ManiaPlayfield)Playfield;
-
-            BarLines.ForEach(maniaPlayfield.Add);
-        }
-
-        protected override void ApplyBeatmap()
-        {
-            base.ApplyBeatmap();
-
-            PreferredColumns = (int)Math.Max(1, Math.Round(Beatmap.BeatmapInfo.Difficulty.CircleSize));
-        }
-
-        protected override void ApplySpeedAdjustments()
-        {
-            var maniaPlayfield = (ManiaPlayfield)Playfield;
-
-            for (int i = 0; i < PreferredColumns; i++)
-                foreach (var change in hitObjectSpeedAdjustments[i])
-                    maniaPlayfield.Columns.ElementAt(i).Add(change);
-
-            foreach (var change in barLineSpeedAdjustments)
-                maniaPlayfield.Add(change);
-        }
-
-        private void generateDefaultSpeedAdjustments()
-        {
-            DefaultControlPoints.ForEach(c =>
-            {
-                foreach (List<SpeedAdjustmentContainer> t in hitObjectSpeedAdjustments)
-                    t.Add(new ManiaSpeedAdjustmentContainer(c, ScrollingAlgorithm.Basic));
-                barLineSpeedAdjustments.Add(new ManiaSpeedAdjustmentContainer(c, ScrollingAlgorithm.Basic));
-            });
-        }
-
-        protected sealed override Playfield<ManiaHitObject, ManiaJudgement> CreatePlayfield() => new ManiaPlayfield(PreferredColumns)
-        {
-            Anchor = Anchor.Centre,
-            Origin = Anchor.Centre,
-            // Invert by default for now (should be moved to config/skin later)
-            Scale = new Vector2(1, -1)
-        };
-
-        public override ScoreProcessor CreateScoreProcessor() => new ManiaScoreProcessor(this);
-
-        protected override BeatmapConverter<ManiaHitObject> CreateBeatmapConverter() => new ManiaBeatmapConverter();
-
-        protected override DrawableHitObject<ManiaHitObject, ManiaJudgement> GetVisualRepresentation(ManiaHitObject h)
-        {
-            var maniaPlayfield = (ManiaPlayfield)Playfield;
-
-            Bindable<Key> key = maniaPlayfield.Columns.ElementAt(h.Column).Key;
-
-            var holdNote = h as HoldNote;
-            if (holdNote != null)
-                return new DrawableHoldNote(holdNote, key);
-
-            var note = h as Note;
-            if (note != null)
-                return new DrawableNote(note, key);
-
-            return null;
-        }
-
-        protected override Vector2 GetPlayfieldAspectAdjust() => new Vector2(1, 0.8f);
-    }
-}

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

@@ -14,24 +14,17 @@ using osu.Framework.Allocation;
 using OpenTK.Input;
 using System.Linq;
 using System.Collections.Generic;
-using osu.Game.Rulesets.Objects.Drawables;
-using osu.Framework.Input;
-using osu.Game.Rulesets.Mania.Objects.Drawables;
-using osu.Game.Rulesets.Timing;
 using osu.Framework.Configuration;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Framework.Graphics.Shapes;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
-    public class ManiaPlayfield : Playfield<ManiaHitObject, ManiaJudgement>
+    public class ManiaPlayfield : ScrollingPlayfield<ManiaHitObject, ManiaJudgement>
     {
         public const float HIT_TARGET_POSITION = 50;
 
-        private const double time_span_default = 1500;
-        private const double time_span_min = 50;
-        private const double time_span_max = 10000;
-        private const double time_span_step = 50;
-
         /// <summary>
         /// Default column keys, expanding outwards from the middle as more column are added.
         /// E.g. 2 columns use FJ, 4 columns use DFJK, 6 use SDFJKL, etc...
@@ -53,16 +46,16 @@ namespace osu.Game.Rulesets.Mania.UI
             }
         }
 
+        /// <summary>
+        /// Whether this playfield should be inverted. This flips everything inside the playfield.
+        /// </summary>
+        public readonly Bindable<bool> Inverted = new Bindable<bool>(true);
+
         private readonly FlowContainer<Column> columns;
         public IEnumerable<Column> Columns => columns.Children;
 
-        private readonly BindableDouble visibleTimeRange = new BindableDouble(time_span_default)
-        {
-            MinValue = time_span_min,
-            MaxValue = time_span_max
-        };
-
-        private readonly SpeedAdjustmentCollection barLineContainer;
+        protected override Container<Drawable> Content => content;
+        private readonly Container<Drawable> content;
 
         private List<Color4> normalColumnColours = new List<Color4>();
         private Color4 specialColumnColour;
@@ -70,13 +63,16 @@ namespace osu.Game.Rulesets.Mania.UI
         private readonly int columnCount;
 
         public ManiaPlayfield(int columnCount)
+            : base(Axes.Y)
         {
             this.columnCount = columnCount;
 
             if (columnCount <= 0)
                 throw new ArgumentException("Can't have zero or fewer columns.");
 
-            Children = new Drawable[]
+            Inverted.Value = true;
+
+            InternalChildren = new Drawable[]
             {
                 new Container
                 {
@@ -120,13 +116,12 @@ namespace osu.Game.Rulesets.Mania.UI
                             Padding = new MarginPadding { Top = HIT_TARGET_POSITION },
                             Children = new[]
                             {
-                                barLineContainer = new SpeedAdjustmentCollection(Axes.Y)
+                                content = new Container
                                 {
                                     Name = "Bar lines",
                                     Anchor = Anchor.TopCentre,
                                     Origin = Anchor.TopCentre,
                                     RelativeSizeAxes = Axes.Y,
-                                    VisibleTimeRange = visibleTimeRange
                                     // Width is set in the Update method
                                 }
                             }
@@ -135,8 +130,26 @@ namespace osu.Game.Rulesets.Mania.UI
                 }
             };
 
+            var currentAction = ManiaAction.Key1;
             for (int i = 0; i < columnCount; i++)
-                columns.Add(new Column { VisibleTimeRange = visibleTimeRange });
+            {
+                var c = new Column();
+                c.VisibleTimeRange.BindTo(VisibleTimeRange);
+
+                c.IsSpecial = isSpecialColumn(i);
+                c.Action = c.IsSpecial ? ManiaAction.Special : currentAction++;
+
+                columns.Add(c);
+                AddNested(c);
+            }
+
+            Inverted.ValueChanged += invertedChanged;
+            Inverted.TriggerChange();
+        }
+
+        private void invertedChanged(bool newValue)
+        {
+            Scale = new Vector2(1, newValue ? -1 : 1);
         }
 
         [BackgroundDependencyLoader]
@@ -151,15 +164,11 @@ namespace osu.Game.Rulesets.Mania.UI
             specialColumnColour = colours.BlueDark;
 
             // Set the special column + colour + key
-            for (int i = 0; i < columnCount; i++)
+            foreach (var column in Columns)
             {
-                Column column = Columns.ElementAt(i);
-                column.IsSpecial = isSpecialColumn(i);
-
                 if (!column.IsSpecial)
                     continue;
 
-                column.Key.Value = Key.Space;
                 column.AccentColour = specialColumnColour;
             }
 
@@ -173,21 +182,6 @@ namespace osu.Game.Rulesets.Mania.UI
                 nonSpecialColumns[i].AccentColour = colour;
                 nonSpecialColumns[nonSpecialColumns.Count - 1 - i].AccentColour = colour;
             }
-
-            // We'll set the keys for non-special columns in another separate loop because it's not mirrored like the above colours
-            // Todo: This needs to go when we get to bindings and use Button1, ..., ButtonN instead
-            for (int i = 0; i < nonSpecialColumns.Count; i++)
-            {
-                Column column = nonSpecialColumns[i];
-
-                int keyOffset = default_keys.Length / 2 - nonSpecialColumns.Count / 2 + i;
-                if (keyOffset >= 0 && keyOffset < default_keys.Length)
-                    column.Key.Value = default_keys[keyOffset];
-                else
-                    // There is no default key defined for this column. Let's set this to Unknown for now
-                    // however note that this will be gone after bindings are in place
-                    column.Key.Value = Key.Unknown;
-            }
         }
 
         /// <summary>
@@ -210,37 +204,13 @@ namespace osu.Game.Rulesets.Mania.UI
         }
 
         public override void Add(DrawableHitObject<ManiaHitObject, ManiaJudgement> h) => Columns.ElementAt(h.HitObject.Column).Add(h);
-        public void Add(DrawableBarLine barline) => barLineContainer.Add(barline);
-        public void Add(SpeedAdjustmentContainer speedAdjustment) => barLineContainer.Add(speedAdjustment);
-
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
-        {
-            if (state.Keyboard.ControlPressed)
-            {
-                switch (args.Key)
-                {
-                    case Key.Minus:
-                        transformVisibleTimeRangeTo(visibleTimeRange + time_span_step, 200, Easing.OutQuint);
-                        break;
-                    case Key.Plus:
-                        transformVisibleTimeRangeTo(visibleTimeRange - time_span_step, 200, Easing.OutQuint);
-                        break;
-                }
-            }
-
-            return false;
-        }
-
-        private void transformVisibleTimeRangeTo(double newTimeRange, double duration = 0, Easing easing = Easing.None)
-        {
-            this.TransformTo(nameof(visibleTimeRange), newTimeRange, duration, easing);
-        }
+        public void Add(DrawableBarLine barline) => HitObjects.Add(barline);
 
         protected override void Update()
         {
             // Due to masking differences, it is not possible to get the width of the columns container automatically
             // While masking on effectively only the Y-axis, so we need to set the width of the bar line container manually
-            barLineContainer.Width = columns.Width;
+            content.Width = columns.Width;
         }
     }
 }

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

@@ -0,0 +1,127 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using OpenTK;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Input;
+using osu.Framework.Lists;
+using osu.Framework.MathUtils;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Beatmaps;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Judgements;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.Scoring;
+using osu.Game.Rulesets.Mania.Timing;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Timing;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Mania.UI
+{
+    public class ManiaRulesetContainer : ScrollingRulesetContainer<ManiaPlayfield, ManiaHitObject, ManiaJudgement>
+    {
+        /// <summary>
+        /// The number of columns which the <see cref="ManiaPlayfield"/> should display, and which
+        /// the beatmap converter will attempt to convert beatmaps to use.
+        /// </summary>
+        private int availableColumns;
+
+        public IEnumerable<DrawableBarLine> BarLines;
+
+        public ManiaRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
+            : base(ruleset, beatmap, isForCurrentRuleset)
+        {
+            // Generate the bar lines
+            double lastObjectTime = (Objects.LastOrDefault() as IHasEndTime)?.EndTime ?? Objects.LastOrDefault()?.StartTime ?? double.MaxValue;
+
+            SortedList<TimingControlPoint> timingPoints = Beatmap.ControlPointInfo.TimingPoints;
+            var barLines = new List<DrawableBarLine>();
+
+            for (int i = 0; i < timingPoints.Count; i++)
+            {
+                TimingControlPoint point = timingPoints[i];
+
+                // Stop on the beat before the next timing point, or if there is no next timing point stop slightly past the last object
+                double endTime = i < timingPoints.Count - 1 ? timingPoints[i + 1].Time - point.BeatLength : lastObjectTime + point.BeatLength * (int)point.TimeSignature;
+
+                int index = 0;
+                for (double t = timingPoints[i].Time; Precision.DefinitelyBigger(endTime, t); t += point.BeatLength, index++)
+                {
+                    barLines.Add(new DrawableBarLine(new BarLine
+                    {
+                        StartTime = t,
+                        ControlPoint = point,
+                        BeatIndex = index
+                    }));
+                }
+            }
+
+            BarLines = barLines;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            BarLines.ForEach(Playfield.Add);
+        }
+
+        protected sealed override Playfield<ManiaHitObject, ManiaJudgement> CreatePlayfield() => new ManiaPlayfield(availableColumns)
+        {
+            Anchor = Anchor.Centre,
+            Origin = Anchor.Centre,
+        };
+
+        public override ScoreProcessor CreateScoreProcessor() => new ManiaScoreProcessor(this);
+
+        public override PassThroughInputManager CreateInputManager() => new ManiaInputManager(Ruleset.RulesetInfo, availableColumns);
+
+        protected override BeatmapConverter<ManiaHitObject> CreateBeatmapConverter()
+        {
+            if (IsForCurrentRuleset)
+                availableColumns = (int)Math.Max(1, Math.Round(WorkingBeatmap.BeatmapInfo.Difficulty.CircleSize));
+            else
+            {
+                float percentSliderOrSpinner = (float)WorkingBeatmap.Beatmap.HitObjects.Count(h => h is IHasEndTime) / WorkingBeatmap.Beatmap.HitObjects.Count;
+                if (percentSliderOrSpinner < 0.2)
+                    availableColumns = 7;
+                else if (percentSliderOrSpinner < 0.3 || Math.Round(WorkingBeatmap.BeatmapInfo.Difficulty.CircleSize) >= 5)
+                    availableColumns = Math.Round(WorkingBeatmap.BeatmapInfo.Difficulty.OverallDifficulty) > 5 ? 7 : 6;
+                else if (percentSliderOrSpinner > 0.6)
+                    availableColumns = Math.Round(WorkingBeatmap.BeatmapInfo.Difficulty.OverallDifficulty) > 4 ? 5 : 4;
+                else
+                    availableColumns = Math.Max(4, Math.Min((int)Math.Round(WorkingBeatmap.BeatmapInfo.Difficulty.OverallDifficulty) + 1, 7));
+            }
+
+            return new ManiaBeatmapConverter(IsForCurrentRuleset, availableColumns);
+        }
+
+        protected override DrawableHitObject<ManiaHitObject, ManiaJudgement> GetVisualRepresentation(ManiaHitObject h)
+        {
+            ManiaAction action = Playfield.Columns.ElementAt(h.Column).Action;
+
+            var holdNote = h as HoldNote;
+            if (holdNote != null)
+                return new DrawableHoldNote(holdNote, action);
+
+            var note = h as Note;
+            if (note != null)
+                return new DrawableNote(note, action);
+
+            return null;
+        }
+
+        protected override Vector2 GetPlayfieldAspectAdjust() => new Vector2(1, 0.8f);
+
+        protected override SpeedAdjustmentContainer CreateSpeedAdjustmentContainer(MultiplierControlPoint controlPoint) => new ManiaSpeedAdjustmentContainer(controlPoint, ScrollingAlgorithm.Basic);
+    }
+}