Merge pull request #1172 from smoogipooo/fix_taiko_sizing

Fix taiko hit objects being able to be scaled down depending on the timing section

.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())
+                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";
 

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,14 @@
 
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Testing;
 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()
         {

osu.Desktop.Tests/Visual/TestCaseManiaPlayfield.cs

@@ -1,25 +1,24 @@
 // 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.Framework.Configuration;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Input;
+using osu.Framework.Timing;
+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 OpenTK;
+using OpenTK.Input;
 
-namespace osu.Desktop.VisualTests.Tests
+namespace osu.Desktop.Tests.Visual
 {
-    internal class TestCaseManiaPlayfield : TestCase
+    internal class TestCaseManiaPlayfield : OsuTestCase
     {
         public override string Description => @"Mania playfield";
 

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,226 @@
+// 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.Reversed.Toggle();
+                verticalRulesetContainer.Playfield.Reversed.Toggle();
+            });
+        }
+
+        [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 }
+                };
+            }
+        }
+
+
+        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/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/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

@@ -27,8 +27,6 @@ namespace osu.Desktop.Overlays
         private UpdateManager updateManager;
         private NotificationOverlay notificationOverlay;
 
-        protected override bool HideOnEscape => false;
-
         public override bool HandleInput => false;
 
         [BackgroundDependencyLoader]
@@ -209,13 +207,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,21 @@
+// 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.Bindings;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Mania
+{
+    public class ManiaInputManager : RulesetInputManager<ManiaAction>
+    {
+        public ManiaInputManager(RulesetInfo ruleset)
+            : base(ruleset, 0, SimultaneousBindingMode.Unique)
+        {
+        }
+    }
+
+    public enum ManiaAction
+    {
+        // placeholder
+    }
+}

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -2,13 +2,13 @@
 // 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.Game.Graphics;
 using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Scoring;
 
@@ -16,7 +16,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 +104,21 @@ 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)
+        {
+        }
     }
 }

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/DrawableManiaHitObject.cs

@@ -4,7 +4,6 @@
 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;
 
@@ -27,9 +26,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
             if (key != null)
                 Key.BindTo(key);
-
-            RelativePositionAxes = Axes.Y;
-            Y = (float)HitObject.StartTime;
         }
 
         public override Color4 AccentColour

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

@@ -14,11 +14,13 @@ using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using System;
 using osu.Framework.Configuration;
-using osu.Game.Rulesets.Timing;
+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,13 +32,6 @@ 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>
@@ -46,14 +41,15 @@ namespace osu.Game.Rulesets.Mania.UI
         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,11 +93,10 @@ 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
@@ -150,6 +145,8 @@ namespace osu.Game.Rulesets.Mania.UI
             };
         }
 
+        public override Axes RelativeSizeAxes => Axes.Y;
+
         private bool isSpecial;
         public bool IsSpecial
         {
@@ -192,11 +189,14 @@ 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)

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

@@ -15,23 +15,15 @@ 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.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...
@@ -56,13 +48,8 @@ namespace osu.Game.Rulesets.Mania.UI
         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 +57,14 @@ 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[]
+            InternalChildren = new Drawable[]
             {
                 new Container
                 {
@@ -120,13 +108,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
                                 }
                             }
@@ -136,7 +123,14 @@ namespace osu.Game.Rulesets.Mania.UI
             };
 
             for (int i = 0; i < columnCount; i++)
-                columns.Add(new Column { VisibleTimeRange = visibleTimeRange });
+            {
+                var c = new Column();
+                c.Reversed.BindTo(Reversed);
+                c.VisibleTimeRange.BindTo(VisibleTimeRange);
+
+                columns.Add(c);
+                AddNested(c);
+            }
         }
 
         [BackgroundDependencyLoader]
@@ -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,129 @@
+// 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.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);
+
+        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)
+        {
+            Bindable<Key> key = Playfield.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);
+
+        protected override SpeedAdjustmentContainer CreateSpeedAdjustmentContainer(MultiplierControlPoint controlPoint) => new ManiaSpeedAdjustmentContainer(controlPoint, ScrollingAlgorithm.Basic);
+    }
+}

osu.Game.Rulesets.Mania/osu.Game.Rulesets.Mania.csproj

@@ -79,11 +79,11 @@
     <Compile Include="Objects\ManiaHitObject.cs" />
     <Compile Include="Objects\Note.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Timing\BasicScrollingDrawableTimingSection.cs" />
-    <Compile Include="Timing\GravityScrollingDrawableTimingSection.cs" />
+    <Compile Include="ManiaInputManager.cs" />
+    <Compile Include="Timing\GravityScrollingContainer.cs" />
     <Compile Include="Timing\ScrollingAlgorithm.cs" />
     <Compile Include="UI\Column.cs" />
-    <Compile Include="UI\ManiaHitRenderer.cs" />
+    <Compile Include="UI\ManiaRulesetContainer.cs" />
     <Compile Include="UI\ManiaPlayfield.cs" />
     <Compile Include="ManiaRuleset.cs" />
     <Compile Include="Mods\ManiaMod.cs" />

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

@@ -51,6 +51,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         protected virtual void UpdateCurrentState(ArmedState state)
         {
         }
+
+        private OsuInputManager osuActionInputManager;
+        internal OsuInputManager OsuActionInputManager => osuActionInputManager ?? (osuActionInputManager = GetContainingInputManager() as OsuInputManager);
     }
 
     public enum ComboResult

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

@@ -1,6 +1,7 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -28,7 +29,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         private readonly CirclePiece circle;
         private readonly GlowPiece glow;
 
-        private readonly TextAwesome symbol;
+        private readonly SpriteIcon symbol;
 
         private readonly Color4 baseColour = OsuColour.FromHex(@"002c3c");
         private readonly Color4 fillColour = OsuColour.FromHex(@"005b7c");
@@ -64,12 +65,11 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                             Anchor = Anchor.Centre,
                         },
                         new RingPiece(),
-                        symbol = new TextAwesome
+                        symbol = new SpriteIcon
                         {
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,
-                            UseFullGlyphHeight = true,
-                            TextSize = 48,
+                            Size = new Vector2(48),
                             Icon = FontAwesome.fa_asterisk,
                             Shadow = false,
                         },
@@ -166,6 +166,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             glow.Colour = colours.BlueDark;
         }
 
+        protected override void Update()
+        {
+            disc.Tracking = OsuActionInputManager.PressedActions.Any(x => x == OsuAction.LeftButton || x == OsuAction.RightButton);
+
+            base.Update();
+        }
+
         protected override void UpdateAfterChildren()
         {
             base.UpdateAfterChildren();

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

@@ -7,12 +7,12 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Input;
+using osu.Framework.Input.Bindings;
 using OpenTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
-    public class CirclePiece : Container
+    public class CirclePiece : Container, IKeyBindingHandler<OsuAction>
     {
         private readonly Sprite disc;
 
@@ -49,9 +49,18 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             disc.Texture = textures.Get(@"Play/osu/disc");
         }
 
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        public bool OnPressed(OsuAction action)
         {
-            return Hit?.Invoke() ?? false;
+            switch (action)
+            {
+                case OsuAction.LeftButton:
+                case OsuAction.RightButton:
+                    return IsHovered && (Hit?.Invoke() ?? false);
+            }
+
+            return false;
         }
+
+        public bool OnReleased(OsuAction action) => false;
     }
 }