Merge pull request #791 from peppy/spinner-refresh

Spinner design refresh

.vscode/launch.json

@@ -2,46 +2,60 @@
     "version": "0.2.0",
     "configurations": [
         {
-            "name": "Launch VisualTests",
+            "name": "VisualTests (debug)",
             "windows": {
                 "type": "clr"
             },
             "type": "mono",
             "request": "launch",
             "program": "${workspaceRoot}/osu.Desktop.VisualTests/bin/Debug/osu!.exe",
-            "args": [],
             "cwd": "${workspaceRoot}",
-            "preLaunchTask": "build",
+            "preLaunchTask": "Build (Debug)",
             "runtimeExecutable": null,
             "env": {},
             "console": "internalConsole"
         },
         {
-            "name": "Launch Desktop",
+            "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": {
                 "type": "clr"
             },
             "type": "mono",
             "request": "launch",
             "program": "${workspaceRoot}/osu.Desktop/bin/Debug/osu!.exe",
-            "args": [],
             "cwd": "${workspaceRoot}",
-            "preLaunchTask": "build",
+            "preLaunchTask": "Build (Debug)",
             "runtimeExecutable": null,
             "env": {},
             "console": "internalConsole"
         },
         {
-            "name": "Attach",
+            "name": "osu! (release)",
             "windows": {
-                "type": "clr",
-                "request": "attach",
-                "processName": "osu!"
+                "type": "clr"
             },
             "type": "mono",
-            "request": "attach",
-            "address": "localhost",
-            "port": 55555
+            "request": "launch",
+            "program": "${workspaceRoot}/osu.Desktop/bin/Release/osu!.exe",
+            "cwd": "${workspaceRoot}",
+            "preLaunchTask": "Build (Release)",
+            "runtimeExecutable": null,
+            "env": {},
+            "console": "internalConsole"
         }
     ]
 }

.vscode/tasks.json

@@ -1,51 +1,50 @@
 {
     // See https://go.microsoft.com/fwlink/?LinkId=733558
     // for the documentation about the tasks.json format
-    "version": "0.1.0",
-    "taskSelector": "/t:",
+    "version": "2.0.0",
+    "problemMatcher": "$msCompile",
+    "isShellCommand": true,
+    "command": "msbuild",
+    "suppressTaskName": true,
+    "showOutput": "silent",
+    "args": [
+        "/property:GenerateFullPaths=true",
+        "/property:DebugType=portable"
+    ],
+    "windows": {
+        "args": [
+            "/property:GenerateFullPaths=true",
+            "/property:DebugType=portable",
+            "/m" //parallel compiling support. doesn't work well with mono atm
+        ]
+    },
     "tasks": [
         {
-            "taskName": "build",
-            "isShellCommand": true,
-            "showOutput": "silent",
-            "command": "msbuild",
-            "args": [
-                "/property:GenerateFullPaths=true",
-                "/property:DebugType=portable"
-            ],
-            "windows": {
-                "args": [
-                    "/property:GenerateFullPaths=true",
-                    "/property:DebugType=portable",
-                    "/m" //parallel compiling support. doesn't work well with mono atm
-                ]
-            },
-            // Use the standard MS compiler pattern to detect errors, warnings and infos
-            "problemMatcher": "$msCompile",
+            "taskName": "Build (Debug)",
             "isBuildCommand": true
         },
         {
-            "taskName": "rebuild",
-            "isShellCommand": true,
-            "showOutput": "silent",
-            "command": "msbuild",
+            "taskName": "Build (Release)",
             "args": [
-                // Ask msbuild to generate full paths for file names.
-                "/property:GenerateFullPaths=true",
-                "/property:DebugType=portable",
-                "/target:Clean,Build"
-            ],
-            "windows": {
-                "args": [
-                    "/property:GenerateFullPaths=true",
-                    "/property:DebugType=portable",
-                    "/target:Clean,Build",
-                    "/m" //parallel compiling support. doesn't work well with mono atm
-                ]
-            },
-            // Use the standard MS compiler pattern to detect errors, warnings and infos
-            "problemMatcher": "$msCompile",
-            "isBuildCommand": true
+                "/property:Configuration=Release"
+            ]
+        },
+        {
+            "taskName": "Clean All",
+            "dependsOn": ["Clean (Debug)", "Clean (Release)"]
+        },
+        {
+            "taskName": "Clean (Debug)",
+            "args": [
+                "/target:Clean"
+            ]
+        },
+        {
+            "taskName": "Clean (Release)",
+            "args": [
+                "/target:Clean",
+                "/property:Configuration=Release"
+            ]
         }
     ]
 }

README.md

@@ -1,8 +1,6 @@
-# osu! [![Build status](https://ci.appveyor.com/api/projects/status/u2p01nx7l6og8buh?svg=true)](https://ci.appveyor.com/project/peppy/osu)  [![CodeFactor](https://www.codefactor.io/repository/github/ppy/osu/badge)](https://www.codefactor.io/repository/github/ppy/osu)
+# osu! [![Build status](https://ci.appveyor.com/api/projects/status/u2p01nx7l6og8buh?svg=true)](https://ci.appveyor.com/project/peppy/osu)  [![CodeFactor](https://www.codefactor.io/repository/github/ppy/osu/badge)](https://www.codefactor.io/repository/github/ppy/osu) [![dev chat](https://discordapp.com/api/guilds/188630481301012481/widget.png?style=shield)](https://discord.gg/ppy)
 
-[osu! on the web](https://osu.ppy.sh) | [dev chat](https://discord.gg/ppy)
-
-Rhythm is just a *click* away. The future of osu! and the beginning of an open era!
+Rhythm is just a *click* away. The future of [osu!](https://osu.ppy.sh) and the beginning of an open era!
 
 # Status
 

osu.Desktop.VisualTests/Beatmaps/TestWorkingBeatmap.cs

@@ -10,7 +10,7 @@ namespace osu.Desktop.VisualTests.Beatmaps
     public class TestWorkingBeatmap : WorkingBeatmap
     {
         public TestWorkingBeatmap(Beatmap beatmap)
-            : base(beatmap.BeatmapInfo, beatmap.BeatmapInfo.BeatmapSet)
+            : base(beatmap.BeatmapInfo)
         {
             this.beatmap = beatmap;
         }

osu.Desktop.VisualTests/Tests/TestCaseBeatmapDetails.cs

@@ -2,7 +2,6 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Primitives;
 using osu.Framework.Testing;
 using osu.Game.Database;
 using osu.Game.Screens.Select;

osu.Desktop.VisualTests/Tests/TestCaseDrawings.cs

@@ -5,7 +5,6 @@ using System.Collections.Generic;
 using osu.Framework.Testing;
 using osu.Game.Screens.Tournament;
 using osu.Game.Screens.Tournament.Teams;
-using osu.Game.Users;
 
 namespace osu.Desktop.VisualTests.Tests
 {
@@ -25,57 +24,57 @@ namespace osu.Desktop.VisualTests.Tests
 
         private class TestTeamList : ITeamList
         {
-            public IEnumerable<Country> Teams { get; } = new[]
+            public IEnumerable<DrawingsTeam> Teams { get; } = new[]
             {
-                new Country
+                new DrawingsTeam
                 {
                     FlagName = "GB",
                     FullName = "United Kingdom",
                     Acronym = "UK"
                 },
-                new Country
+                new DrawingsTeam
                 {
                     FlagName = "FR",
                     FullName = "France",
                     Acronym = "FRA"
                 },
-                new Country
+                new DrawingsTeam
                 {
                     FlagName = "CN",
                     FullName = "China",
                     Acronym = "CHN"
                 },
-                new Country
+                new DrawingsTeam
                 {
                     FlagName = "AU",
                     FullName = "Australia",
                     Acronym = "AUS"
                 },
-                new Country
+                new DrawingsTeam
                 {
                     FlagName = "JP",
                     FullName = "Japan",
                     Acronym = "JPN"
                 },
-                new Country
+                new DrawingsTeam
                 {
                     FlagName = "RO",
                     FullName = "Romania",
                     Acronym = "ROM"
                 },
-                new Country
+                new DrawingsTeam
                 {
                     FlagName = "IT",
                     FullName = "Italy",
                     Acronym = "PIZZA"
                 },
-                new Country
+                new DrawingsTeam
                 {
                     FlagName = "VE",
                     FullName = "Venezuela",
                     Acronym = "VNZ"
                 },
-                new Country
+                new DrawingsTeam
                 {
                     FlagName = "US",
                     FullName = "United States of America",

osu.Desktop.VisualTests/Tests/TestCaseGamefield.cs

@@ -18,6 +18,7 @@ using osu.Game.Rulesets.Taiko.UI;
 using System.Collections.Generic;
 using osu.Desktop.VisualTests.Beatmaps;
 using osu.Framework.Allocation;
+using osu.Game.Beatmaps.Timing;
 
 namespace osu.Desktop.VisualTests.Tests
 {
@@ -52,6 +53,12 @@ namespace osu.Desktop.VisualTests.Tests
                 time += RNG.Next(50, 500);
             }
 
+            TimingInfo timing = new TimingInfo();
+            timing.ControlPoints.Add(new ControlPoint
+            {
+                BeatLength = 200
+            });
+
             WorkingBeatmap beatmap = new TestWorkingBeatmap(new Beatmap
             {
                 HitObjects = objects,
@@ -64,8 +71,9 @@ namespace osu.Desktop.VisualTests.Tests
                         Artist = @"Unknown",
                         Title = @"Sample Beatmap",
                         Author = @"peppy",
-                    }
-                }
+                    },
+                },
+                TimingInfo = timing
             });
 
             Add(new Drawable[]

osu.Desktop.VisualTests/Tests/TestCaseHitObjects.cs

@@ -129,8 +129,6 @@ namespace osu.Desktop.VisualTests.Tests
             };
 
             Add(clockAdjustContainer);
-
-            load(mode);
         }
 
         private int depth;

osu.Desktop.VisualTests/Tests/TestCaseManiaHitObjects.cs

@@ -0,0 +1,89 @@
+// 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.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using OpenTK.Graphics;
+using OpenTK;
+
+namespace osu.Desktop.VisualTests.Tests
+{
+    internal class TestCaseManiaHitObjects : TestCase
+    {
+        public override void Reset()
+        {
+            base.Reset();
+
+            Add(new FillFlowContainer
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Y,
+                Direction = FillDirection.Horizontal,
+                Spacing = new Vector2(10, 0),
+                // Imagine that the containers containing the drawable notes are the "columns"
+                Children = new Drawable[]
+                {
+                    new Container
+                    {
+                        Name = "Normal note column",
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        RelativeSizeAxes = Axes.Y,
+                        Width = 50,
+                        Children = new[]
+                        {
+                            new Container
+                            {
+                                Name = "Timing section",
+                                RelativeSizeAxes = Axes.Both,
+                                RelativeCoordinateSpace = new Vector2(1, 10000),
+                                Children = new[]
+                                {
+                                    new DrawableNote(new Note
+                                    {
+                                        StartTime = 5000
+                                    })
+                                    {
+                                        AccentColour = Color4.Red
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    new Container
+                    {
+                        Name = "Hold note column",
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        RelativeSizeAxes = Axes.Y,
+                        Width = 50,
+                        Children = new[]
+                        {
+                            new Container
+                            {
+                                Name = "Timing section",
+                                RelativeSizeAxes = Axes.Both,
+                                RelativeCoordinateSpace = new Vector2(1, 10000),
+                                Children = new[]
+                                {
+                                    new DrawableHoldNote(new HoldNote
+                                    {
+                                        StartTime = 5000,
+                                        Duration = 1000
+                                    })
+                                    {
+                                        AccentColour = Color4.Red
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+        }
+    }
+}

osu.Desktop.VisualTests/Tests/TestCaseManiaPlayfield.cs

@@ -0,0 +1,98 @@
+// 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 System.Collections.Generic;
+using osu.Game.Beatmaps.Timing;
+using OpenTK;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.Objects;
+
+namespace osu.Desktop.VisualTests.Tests
+{
+    internal class TestCaseManiaPlayfield : TestCase
+    {
+        public override string Description => @"Mania playfield";
+
+        protected override double TimePerAction => 200;
+
+        public override void Reset()
+        {
+            base.Reset();
+
+            Action<int, SpecialColumnPosition> createPlayfield = (cols, pos) =>
+            {
+                Clear();
+                Add(new ManiaPlayfield(cols, new List<ControlPoint>())
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    SpecialColumnPosition = pos,
+                    Scale = new Vector2(1, -1)
+                });
+            };
+
+            Action<int, SpecialColumnPosition> createPlayfieldWithNotes = (cols, pos) =>
+            {
+                Clear();
+
+                ManiaPlayfield playField;
+                Add(playField = new ManiaPlayfield(cols, new List<ControlPoint> { new ControlPoint { BeatLength = 200 } })
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    SpecialColumnPosition = pos,
+                    Scale = new Vector2(1, -1)
+                });
+
+                for (int i = 0; i < cols; i++)
+                {
+                    playField.Add(new DrawableNote(new Note
+                    {
+                        StartTime = Time.Current + 1000,
+                        Column = i
+                    }));
+                }
+            };
+
+            AddStep("1 column", () => createPlayfield(1, SpecialColumnPosition.Normal));
+            AddStep("4 columns", () => createPlayfield(4, SpecialColumnPosition.Normal));
+            AddStep("Left special style", () => createPlayfield(4, SpecialColumnPosition.Left));
+            AddStep("Right special style", () => createPlayfield(4, SpecialColumnPosition.Right));
+            AddStep("5 columns", () => createPlayfield(5, SpecialColumnPosition.Normal));
+            AddStep("8 columns", () => createPlayfield(8, SpecialColumnPosition.Normal));
+            AddStep("Left special style", () => createPlayfield(8, SpecialColumnPosition.Left));
+            AddStep("Right special style", () => createPlayfield(8, SpecialColumnPosition.Right));
+
+            AddStep("Normal special style", () => createPlayfield(4, SpecialColumnPosition.Normal));
+
+            AddStep("Notes", () => createPlayfieldWithNotes(4, SpecialColumnPosition.Normal));
+            AddWaitStep(10);
+            AddStep("Left special style", () => createPlayfieldWithNotes(4, SpecialColumnPosition.Left));
+            AddWaitStep(10);
+            AddStep("Right special style", () => createPlayfieldWithNotes(4, SpecialColumnPosition.Right));
+            AddWaitStep(10);
+        }
+
+        private void triggerKeyDown(Column column)
+        {
+            column.TriggerKeyDown(new InputState(), new KeyDownEventArgs
+            {
+                Key = column.Key,
+                Repeat = false
+            });
+        }
+
+        private void triggerKeyUp(Column column)
+        {
+            column.TriggerKeyUp(new InputState(), new KeyUpEventArgs
+            {
+                Key = column.Key
+            });
+        }
+    }
+}

osu.Desktop.VisualTests/Tests/TestCaseMenuOverlays.cs

@@ -12,7 +12,7 @@ namespace osu.Desktop.VisualTests.Tests
     {
         public override string Description => @"Tests pause and fail overlays";
 
-        private PauseOverlay pauseOverlay;
+        private PauseContainer.PauseOverlay pauseOverlay;
         private FailOverlay failOverlay;
         private int retryCount;
 
@@ -22,7 +22,7 @@ namespace osu.Desktop.VisualTests.Tests
 
             retryCount = 0;
 
-            Add(pauseOverlay = new PauseOverlay
+            Add(pauseOverlay = new PauseContainer.PauseOverlay
             {
                 OnResume = () => Logger.Log(@"Resume"),
                 OnRetry = () => Logger.Log(@"Retry"),

osu.Desktop.VisualTests/Tests/TestCaseMods.cs

@@ -6,16 +6,21 @@ using osu.Framework.Graphics;
 using osu.Game.Overlays.Mods;
 using osu.Framework.Testing;
 using osu.Game.Database;
+using osu.Game.Screens.Play.HUD;
+using OpenTK;
 
 namespace osu.Desktop.VisualTests.Tests
 {
-    internal class TestCaseModSelectOverlay : TestCase
+    internal class TestCaseMods : TestCase
     {
-        public override string Description => @"Tests the mod select overlay";
+        public override string Description => @"Mod select overlay and in-game display";
 
         private ModSelectOverlay modSelect;
+        private ModDisplay modDisplay;
+
         private RulesetDatabase rulesets;
 
+
         [BackgroundDependencyLoader]
         private void load(RulesetDatabase rulesets)
         {
@@ -33,6 +38,16 @@ namespace osu.Desktop.VisualTests.Tests
                 Anchor = Anchor.BottomCentre,
             });
 
+            Add(modDisplay = new ModDisplay
+            {
+                Anchor = Anchor.TopRight,
+                Origin = Anchor.TopRight,
+                AutoSizeAxes = Axes.Both,
+                Position = new Vector2(0, 25),
+            });
+
+            modDisplay.Current.BindTo(modSelect.SelectedMods);
+
             AddStep("Toggle", modSelect.ToggleVisibility);
 
             foreach (var ruleset in rulesets.AllRulesets)

osu.Desktop.VisualTests/Tests/TestCaseOnScreenDisplay.cs

@@ -0,0 +1,47 @@
+// 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.Configuration;
+using osu.Framework.Testing;
+using osu.Game.Overlays;
+
+namespace osu.Desktop.VisualTests.Tests
+{
+    internal class TestCaseOnScreenDisplay : TestCase
+    {
+        private FrameworkConfigManager config;
+        private Bindable<FrameSync> frameSyncMode;
+
+        public override string Description => @"Make it easier to see setting changes";
+
+        public override void Reset()
+        {
+            base.Reset();
+
+            Add(new OnScreenDisplay());
+
+            frameSyncMode = config.GetBindable<FrameSync>(FrameworkSetting.FrameSync);
+
+            FrameSync initial = frameSyncMode.Value;
+
+            AddRepeatStep(@"Change frame limiter", setNextMode, 3);
+
+            AddStep(@"Restore frame limiter", () => frameSyncMode.Value = initial);
+        }
+
+        private void setNextMode()
+        {
+            var nextMode = frameSyncMode.Value + 1;
+            if (nextMode > FrameSync.Unlimited)
+                nextMode = FrameSync.VSync;
+            frameSyncMode.Value = nextMode;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(FrameworkConfigManager config)
+        {
+            this.config = config;
+        }
+    }
+}

osu.Desktop.VisualTests/Tests/TestCaseResults.cs

@@ -47,7 +47,7 @@ namespace osu.Desktop.VisualTests.Tests
                 Accuracy = 0.98,
                 MaxCombo = 123,
                 Rank = ScoreRank.A,
-                Date = DateTime.Now,
+                Date = DateTimeOffset.Now,
                 Statistics = new Dictionary<string, dynamic>()
                 {
                     { "300", 50 },

osu.Desktop.VisualTests/Tests/TestCaseScoreCounter.cs

@@ -3,12 +3,11 @@
 
 using OpenTK;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.MathUtils;
 using osu.Framework.Testing;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play.HUD;
 
 namespace osu.Desktop.VisualTests.Tests
 {

osu.Desktop.VisualTests/Tests/TestCaseSettings.cs

@@ -6,18 +6,18 @@ using osu.Game.Overlays;
 
 namespace osu.Desktop.VisualTests.Tests
 {
-    internal class TestCaseOptions : TestCase
+    internal class TestCaseSettings : TestCase
     {
-        public override string Description => @"Tests the options overlay";
+        public override string Description => @"Tests the settings overlay";
 
-        private OptionsOverlay options;
+        private SettingsOverlay settings;
 
         public override void Reset()
         {
             base.Reset();
 
-            Children = new[] { options = new OptionsOverlay() };
-            options.ToggleVisibility();
+            Children = new[] { settings = new SettingsOverlay() };
+            settings.ToggleVisibility();
         }
     }
 }

osu.Desktop.VisualTests/Tests/TestCaseSongProgress.cs

@@ -18,10 +18,14 @@ namespace osu.Desktop.VisualTests.Tests
         private SongProgress progress;
         private SongProgressGraph graph;
 
+        private StopwatchClock clock;
+
         public override void Reset()
         {
             base.Reset();
 
+            clock = new StopwatchClock(true);
+
             Add(progress = new SongProgress
             {
                 RelativeSizeAxes = Axes.X,
@@ -55,6 +59,9 @@ namespace osu.Desktop.VisualTests.Tests
 
             progress.Objects = objects;
             graph.Objects = objects;
+
+            progress.AudioClock = clock;
+            progress.OnSeek = pos => clock.Seek(pos);
         }
     }
 }

osu.Desktop.VisualTests/Tests/TestCaseTabControl.cs

@@ -1,8 +1,8 @@
 // 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 OpenTK;
-using osu.Framework.Graphics.Primitives;
 using osu.Framework.Testing;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;

osu.Desktop.VisualTests/VisualTestGame.cs

@@ -29,7 +29,7 @@ namespace osu.Desktop.VisualTests
             host.DrawThread.InactiveHz = host.DrawThread.ActiveHz;
             host.InputThread.InactiveHz = host.InputThread.ActiveHz;
 
-            host.Window.CursorState = CursorState.Hidden;
+            host.Window.CursorState |= CursorState.Hidden;
         }
     }
 }

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

@@ -190,9 +190,12 @@
     <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\TestCaseNotificationManager.cs" />
+    <Compile Include="Tests\TestCaseOnScreenDisplay.cs" />
     <Compile Include="Tests\TestCasePlayer.cs" />
     <Compile Include="Tests\TestCaseHitObjects.cs" />
     <Compile Include="Tests\TestCaseKeyCounter.cs" />
@@ -209,9 +212,9 @@
     <Compile Include="Tests\TestCaseTwoLayerButton.cs" />
     <Compile Include="VisualTestGame.cs" />
     <Compile Include="Platform\TestStorage.cs" />
-    <Compile Include="Tests\TestCaseOptions.cs" />
+    <Compile Include="Tests\TestCaseSettings.cs" />
     <Compile Include="Tests\TestCaseSongProgress.cs" />
-    <Compile Include="Tests\TestCaseModSelectOverlay.cs" />
+    <Compile Include="Tests\TestCaseMods.cs" />
     <Compile Include="Tests\TestCaseDialogOverlay.cs" />
     <Compile Include="Tests\TestCaseBeatmapOptionsOverlay.cs" />
     <Compile Include="Tests\TestCaseLeaderboard.cs" />

osu.Desktop/Beatmaps/IO/LegacyFilesystemReader.cs

@@ -14,7 +14,7 @@ namespace osu.Desktop.Beatmaps.IO
     {
         public static void Register() => AddReader<LegacyFilesystemReader>((storage, path) => Directory.Exists(path));
 
-        private string basePath { get; }
+        private readonly string basePath;
 
         public LegacyFilesystemReader(string path)
         {

osu.Desktop/OsuGameDesktop.cs

@@ -43,7 +43,7 @@ namespace osu.Desktop
             var desktopWindow = host.Window as DesktopGameWindow;
             if (desktopWindow != null)
             {
-                desktopWindow.CursorState = CursorState.Hidden;
+                desktopWindow.CursorState |= CursorState.Hidden;
 
                 desktopWindow.Icon = Icon.ExtractAssociatedIcon(Assembly.GetExecutingAssembly().Location);
                 desktopWindow.Title = Name;

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

@@ -8,16 +8,28 @@ using System;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Beatmaps;
 using osu.Game.Rulesets.Objects;
+using OpenTK;
 
 namespace osu.Game.Rulesets.Mania.Beatmaps
 {
-    internal class ManiaBeatmapConverter : BeatmapConverter<ManiaBaseHit>
+    internal class ManiaBeatmapConverter : BeatmapConverter<ManiaHitObject>
     {
         protected override IEnumerable<Type> ValidConversionTypes { get; } = new[] { typeof(IHasXPosition) };
 
-        protected override IEnumerable<ManiaBaseHit> ConvertHitObject(HitObject original, Beatmap beatmap)
+        protected override IEnumerable<ManiaHitObject> ConvertHitObject(HitObject original, Beatmap beatmap)
         {
-            yield return null;
+            int availableColumns = (int)Math.Round(beatmap.BeatmapInfo.Difficulty.CircleSize);
+
+            var positionData = original as IHasXPosition;
+
+            float localWDivisor = 512.0f / availableColumns;
+            int column = MathHelper.Clamp((int)Math.Floor((positionData?.X ?? 1) / localWDivisor), 0, availableColumns - 1);
+
+            yield return new Note
+            {
+                StartTime = original.StartTime,
+                Column = column,
+            };
         }
     }
 }

osu.Game.Rulesets.Mania/Judgements/HitWindows.cs

@@ -0,0 +1,179 @@
+// 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.Database;
+
+namespace osu.Game.Rulesets.Mania.Judgements
+{
+    public class HitWindows
+    {
+        #region Constants
+
+        /// <summary>
+        /// PERFECT hit window at OD = 10.
+        /// </summary>
+        private const double perfect_min = 27.8;
+        /// <summary>
+        /// PERFECT hit window at OD = 5.
+        /// </summary>
+        private const double perfect_mid = 38.8;
+        /// <summary>
+        /// PERFECT hit window at OD = 0.
+        /// </summary>
+        private const double perfect_max = 44.8;
+
+        /// <summary>
+        /// GREAT hit window at OD = 10.
+        /// </summary>
+        private const double great_min = 68;
+        /// <summary>
+        /// GREAT hit window at OD = 5.
+        /// </summary>
+        private const double great_mid = 98;
+        /// <summary>
+        /// GREAT hit window at OD = 0.
+        /// </summary>
+        private const double great_max = 128;
+
+        /// <summary>
+        /// GOOD hit window at OD = 10.
+        /// </summary>
+        private const double good_min = 134;
+        /// <summary>
+        /// GOOD hit window at OD = 5.
+        /// </summary>
+        private const double good_mid = 164;
+        /// <summary>
+        /// GOOD hit window at OD = 0.
+        /// </summary>
+        private const double good_max = 194;
+
+        /// <summary>
+        /// OK hit window at OD = 10.
+        /// </summary>
+        private const double ok_min = 194;
+        /// <summary>
+        /// OK hit window at OD = 5.
+        /// </summary>
+        private const double ok_mid = 224;
+        /// <summary>
+        /// OK hit window at OD = 0.
+        /// </summary>
+        private const double ok_max = 254;
+
+        /// <summary>
+        /// BAD hit window at OD = 10.
+        /// </summary>
+        private const double bad_min = 242;
+        /// <summary>
+        /// BAD hit window at OD = 5.
+        /// </summary>
+        private const double bad_mid = 272;
+        /// <summary>
+        /// BAD hit window at OD = 0.
+        /// </summary>
+        private const double bad_max = 302;
+
+        /// <summary>
+        /// MISS hit window at OD = 10.
+        /// </summary>
+        private const double miss_min = 316;
+        /// <summary>
+        /// MISS hit window at OD = 5.
+        /// </summary>
+        private const double miss_mid = 346;
+        /// <summary>
+        /// MISS hit window at OD = 0.
+        /// </summary>
+        private const double miss_max = 376;
+
+        #endregion
+
+        /// <summary>
+        /// Hit window for a PERFECT hit.
+        /// </summary>
+        public double Perfect = perfect_mid;
+
+        /// <summary>
+        /// Hit window for a GREAT hit.
+        /// </summary>
+        public double Great = great_mid;
+
+        /// <summary>
+        /// Hit window for a GOOD hit.
+        /// </summary>
+        public double Good = good_mid;
+
+        /// <summary>
+        /// Hit window for an OK hit.
+        /// </summary>
+        public double Ok = ok_mid;
+
+        /// <summary>
+        /// Hit window for a BAD hit.
+        /// </summary>
+        public double Bad = bad_mid;
+
+        /// <summary>
+        /// Hit window for a MISS hit.
+        /// </summary>
+        public double Miss = miss_mid;
+
+        /// <summary>
+        /// Constructs default hit windows.
+        /// </summary>
+        public HitWindows()
+        {
+        }
+
+        /// <summary>
+        /// Constructs hit windows by fitting a parameter to a 2-part piecewise linear function for each hit window.
+        /// </summary>
+        /// <param name="difficulty">The parameter.</param>
+        public HitWindows(double difficulty)
+        {
+            Perfect = BeatmapDifficulty.DifficultyRange(difficulty, perfect_max, perfect_mid, perfect_min);
+            Great = BeatmapDifficulty.DifficultyRange(difficulty, great_max, great_mid, great_min);
+            Good = BeatmapDifficulty.DifficultyRange(difficulty, good_max, good_mid, good_min);
+            Ok = BeatmapDifficulty.DifficultyRange(difficulty, ok_max, ok_mid, ok_min);
+            Bad = BeatmapDifficulty.DifficultyRange(difficulty, bad_max, bad_mid, bad_min);
+            Miss = BeatmapDifficulty.DifficultyRange(difficulty, miss_max, miss_mid, miss_min);
+        }
+
+        /// <summary>
+        /// Constructs new hit windows which have been multiplied by a value.
+        /// </summary>
+        /// <param name="windows">The original hit windows.</param>
+        /// <param name="value">The value to multiply each hit window by.</param>
+        public static HitWindows operator *(HitWindows windows, double value)
+        {
+            return new HitWindows
+            {
+                Perfect = windows.Perfect * value,
+                Great = windows.Great * value,
+                Good = windows.Good * value,
+                Ok = windows.Ok * value,
+                Bad = windows.Bad * value,
+                Miss = windows.Miss * value
+            };
+        }
+
+        /// <summary>
+        /// Constructs new hit windows which have been divided by a value.
+        /// </summary>
+        /// <param name="windows">The original hit windows.</param>
+        /// <param name="value">The value to divide each hit window by.</param>
+        public static HitWindows operator /(HitWindows windows, double value)
+        {
+            return new HitWindows
+            {
+                Perfect = windows.Perfect / value,
+                Great = windows.Great / value,
+                Good = windows.Good / value,
+                Ok = windows.Ok / value,
+                Bad = windows.Bad / value,
+                Miss = windows.Miss / value
+            };
+        }
+    }
+}

osu.Game.Rulesets.Mania/ManiaDifficultyCalculator.cs

@@ -9,7 +9,7 @@ using System.Collections.Generic;
 
 namespace osu.Game.Rulesets.Mania
 {
-    public class ManiaDifficultyCalculator : DifficultyCalculator<ManiaBaseHit>
+    public class ManiaDifficultyCalculator : DifficultyCalculator<ManiaHitObject>
     {
         public ManiaDifficultyCalculator(Beatmap beatmap)
             : base(beatmap)
@@ -21,6 +21,6 @@ namespace osu.Game.Rulesets.Mania
             return 0;
         }
 
-        protected override BeatmapConverter<ManiaBaseHit> CreateBeatmapConverter() => new ManiaBeatmapConverter();
+        protected override BeatmapConverter<ManiaHitObject> CreateBeatmapConverter() => new ManiaBeatmapConverter();
     }
 }

osu.Game.Rulesets.Mania/MathUtils/FastRandom.cs

@@ -0,0 +1,92 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+
+namespace osu.Game.Rulesets.Mania.MathUtils
+{
+    /// <summary>
+    /// A PRNG specified in http://heliosphan.org/fastrandom.html.
+    /// </summary>
+    internal class FastRandom
+    {
+        private const double uint_to_real = 1.0 / (int.MaxValue + 1.0);
+        private const uint int_mask = 0x7FFFFFFF;
+        private const uint y = 842502087;
+        private const uint z = 3579807591;
+        private const uint w = 273326509;
+        private uint _x, _y = y, _z = z, _w = w;
+
+        public FastRandom(int seed)
+        {
+            _x = (uint)seed;
+        }
+
+        public FastRandom()
+            : this(Environment.TickCount)
+        {
+        }
+
+        /// <summary>
+        /// Generates a random unsigned integer within the range [<see cref="uint.MinValue"/>, <see cref="uint.MaxValue"/>).
+        /// </summary>
+        /// <returns>The random value.</returns>
+        public uint NextUInt()
+        {
+            uint t = _x ^ _x << 11;
+            _x = _y;
+            _y = _z;
+            _z = _w;
+            return _w = _w ^ _w >> 19 ^ t ^ t >> 8;
+        }
+
+        /// <summary>
+        /// Generates a random integer value within the range [0, <see cref="int.MaxValue"/>).
+        /// </summary>
+        /// <returns>The random value.</returns>
+        public int Next() => (int)(int_mask & NextUInt());
+
+        /// <summary>
+        /// Generates a random integer value within the range [0, <paramref name="upperBound"/>).
+        /// </summary>
+        /// <param name="upperBound">The upper bound.</param>
+        /// <returns>The random value.</returns>
+        public int Next(int upperBound) => (int)(NextDouble() * upperBound);
+
+        /// <summary>
+        /// Generates a random integer value within the range [<paramref name="lowerBound"/>, <paramref name="upperBound"/>).
+        /// </summary>
+        /// <param name="lowerBound">The lower bound of the range.</param>
+        /// <param name="upperBound">The upper bound of the range.</param>
+        /// <returns>The random value.</returns>
+        public int Next(int lowerBound, int upperBound) => (int)(lowerBound + NextDouble() * (upperBound - lowerBound));
+
+        /// <summary>
+        /// Generates a random double value within the range [0, 1).
+        /// </summary>
+        /// <returns>The random value.</returns>
+        public double NextDouble() => uint_to_real * NextUInt();
+
+        private uint bitBuffer;
+        private int bitIndex = 32;
+
+        /// <summary>
+        /// Generates a reandom boolean value. Cached such that a random value is only generated once in every 32 calls.
+        /// </summary>
+        /// <returns>The random value.</returns>
+        public bool NextBool()
+        {
+            if (bitIndex == 32)
+            {
+                bitBuffer = NextUInt();
+                bitIndex = 1;
+
+                return (bitBuffer & 1) == 1;
+            }
+
+            bitIndex++;
+            return ((bitBuffer >>= 1) & 1) == 1;
+        }
+
+    }
+}

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

@@ -64,6 +64,7 @@ namespace osu.Game.Rulesets.Mania.Mods
     {
         public override string Name => "FadeIn";
         public override FontAwesome Icon => FontAwesome.fa_osu_mod_hidden;
+        public override ModType Type => ModType.DifficultyIncrease;
         public override double ScoreMultiplier => 1;
         public override bool Ranked => true;
         public override Type[] IncompatibleMods => new[] { typeof(ModFlashlight) };

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

@@ -1,36 +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.Allocation;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.Textures;
-using osu.Framework.Graphics.Transforms;
-using osu.Framework.Graphics;
-using OpenTK;
-
-namespace osu.Game.Rulesets.Mania.Objects.Drawable
-{
-    public class DrawableNote : Sprite
-    {
-        private readonly ManiaBaseHit note;
-
-        public DrawableNote(ManiaBaseHit note)
-        {
-            this.note = note;
-            Origin = Anchor.Centre;
-            Scale = new Vector2(0.1f);
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(TextureStore textures)
-        {
-            Texture = textures.Get(@"Menu/logo");
-
-            const double duration = 0;
-
-            Transforms.Add(new TransformPositionY { StartTime = note.StartTime - 200, EndTime = note.StartTime, StartValue = -0.1f, EndValue = 0.9f });
-            Transforms.Add(new TransformAlpha { StartTime = note.StartTime + duration + 200, EndTime = note.StartTime + duration + 400, StartValue = 1, EndValue = 0 });
-            Expire(true);
-        }
-    }
-}

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

@@ -0,0 +1,65 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.Objects.Drawables
+{
+    public class DrawableHoldNote : DrawableManiaHitObject<HoldNote>
+    {
+        private readonly NotePiece headPiece;
+        private readonly BodyPiece bodyPiece;
+        private readonly NotePiece tailPiece;
+
+        public DrawableHoldNote(HoldNote hitObject)
+            : base(hitObject)
+        {
+            RelativeSizeAxes = Axes.Both;
+            Height = (float)HitObject.Duration;
+
+            Add(new Drawable[]
+            {
+                // For now the body piece covers the entire height of the container
+                // whereas possibly in the future we don't want to extend under the head/tail.
+                // This will be fixed when new designs are given or the current design is finalized.
+                bodyPiece = new BodyPiece
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
+                },
+                headPiece = new NotePiece
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre
+                },
+                tailPiece = new NotePiece
+                {
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.BottomCentre
+                }
+            });
+        }
+
+        public override Color4 AccentColour
+        {
+            get { return base.AccentColour; }
+            set
+            {
+                if (base.AccentColour == value)
+                    return;
+                base.AccentColour = value;
+
+                headPiece.AccentColour = value;
+                bodyPiece.AccentColour = value;
+                tailPiece.AccentColour = value;
+            }
+        }
+
+        protected override void UpdateState(ArmedState state)
+        {
+        }
+    }
+}

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

@@ -0,0 +1,64 @@
+// 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 osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Rulesets.Mania.Judgements;
+using osu.Game.Rulesets.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Mania.Objects.Drawables
+{
+    public abstract class DrawableManiaHitObject<TObject> : DrawableHitObject<ManiaHitObject, ManiaJudgement>
+        where TObject : ManiaHitObject
+    {
+        public new TObject HitObject;
+
+        private readonly Container glowContainer;
+
+        protected DrawableManiaHitObject(TObject hitObject)
+            : base(hitObject)
+        {
+            HitObject = hitObject;
+
+            RelativePositionAxes = Axes.Y;
+            Y = (float)HitObject.StartTime;
+
+            Add(glowContainer = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Masking = true,
+                Children = new[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Alpha = 0,
+                        AlwaysPresent = true
+                    }
+                }
+            });
+        }
+
+        public override Color4 AccentColour
+        {
+            get { return base.AccentColour; }
+            set
+            {
+                if (base.AccentColour == value)
+                    return;
+                base.AccentColour = value;
+
+                glowContainer.EdgeEffect = new EdgeEffect
+                {
+                    Type = EdgeEffectType.Glow,
+                    Radius = 5,
+                    Colour = value
+                };
+            }
+        }
+
+        protected override ManiaJudgement CreateJudgement() => new ManiaJudgement();
+    }
+}

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

@@ -0,0 +1,51 @@
+// 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 osu.Framework.Graphics;
+using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Mania.Objects.Drawables
+{
+    public class DrawableNote : DrawableManiaHitObject<Note>
+    {
+        private readonly NotePiece headPiece;
+
+        public DrawableNote(Note hitObject)
+            : base(hitObject)
+        {
+            RelativeSizeAxes = Axes.Both;
+            Height = 100;
+
+            Add(headPiece = new NotePiece
+            {
+                Anchor = Anchor.TopCentre,
+                Origin = Anchor.TopCentre
+            });
+        }
+
+        public override Color4 AccentColour
+        {
+            get { return base.AccentColour; }
+            set
+            {
+                if (base.AccentColour == value)
+                    return;
+                base.AccentColour = value;
+
+                headPiece.AccentColour = value;
+            }
+        }
+
+        protected override void Update()
+        {
+            if (Time.Current > HitObject.StartTime)
+                Colour = Color4.Green;
+        }
+
+        protected override void UpdateState(ArmedState state)
+        {
+        }
+    }
+}

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/BodyPiece.cs

@@ -0,0 +1,48 @@
+// 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 osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Graphics;
+
+namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
+{
+    /// <summary>
+    /// Represents length-wise portion of a hold note.
+    /// </summary>
+    internal class BodyPiece : Container, IHasAccentColour
+    {
+        private readonly Box box;
+
+        public BodyPiece()
+        {
+            RelativeSizeAxes = Axes.Both;
+            Masking = true;
+
+            Children = new[]
+            {
+                box = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 0.3f
+                }
+            };
+        }
+
+        private Color4 accentColour;
+        public Color4 AccentColour
+        {
+            get { return accentColour; }
+            set
+            {
+                if (accentColour == value)
+                    return;
+                accentColour = value;
+
+                box.Colour = accentColour;
+            }
+        }
+    }
+}

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/NotePiece.cs

@@ -0,0 +1,59 @@
+// 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 osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Graphics;
+
+namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
+{
+    /// <summary>
+    /// Represents the static hit markers of notes.
+    /// </summary>
+    internal class NotePiece : Container, IHasAccentColour
+    {
+        private const float head_height = 10;
+        private const float head_colour_height = 6;
+
+        private readonly Box colouredBox;
+
+        public NotePiece()
+        {
+            RelativeSizeAxes = Axes.X;
+            Height = head_height;
+
+            Children = new[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both
+                },
+                colouredBox = new Box
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
+                    RelativeSizeAxes = Axes.X,
+                    Height = head_colour_height,
+                    Alpha = 0.2f
+                }
+            };
+        }
+
+        private Color4 accentColour;
+        public Color4 AccentColour
+        {
+            get { return accentColour; }
+            set
+            {
+                if (accentColour == value)
+                    return;
+                accentColour = value;
+
+                colouredBox.Colour = AccentColour.Lighten(0.9f);
+            }
+        }
+    }
+}

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

@@ -1,9 +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 osu.Game.Beatmaps.Timing;
+using osu.Game.Database;
+using osu.Game.Rulesets.Mania.Judgements;
+using osu.Game.Rulesets.Objects.Types;
+
 namespace osu.Game.Rulesets.Mania.Objects
 {
-    public class HoldNote : Note
+    /// <summary>
+    /// Represents a hit object which requires pressing, holding, and releasing a key.
+    /// </summary>
+    public class HoldNote : Note, IHasEndTime
     {
+        /// <summary>
+        /// Lenience of release hit windows. This is to make cases where the hold note release
+        /// is timed alongside presses of other hit objects less awkward.
+        /// </summary>
+        private const double release_window_lenience = 1.5;
+
+        public double Duration { get; set; }
+        public double EndTime => StartTime + Duration;
+
+        /// <summary>
+        /// The key-release hit windows for this hold note.
+        /// </summary>
+        protected HitWindows ReleaseHitWindows = new HitWindows();
+
+        public override void ApplyDefaults(TimingInfo timing, BeatmapDifficulty difficulty)
+        {
+            base.ApplyDefaults(timing, difficulty);
+
+            ReleaseHitWindows = HitWindows * release_window_lenience;
+        }
     }
 }

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

@@ -1,12 +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.Game.Rulesets.Mania.Objects.Types;
 using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Mania.Objects
 {
-    public abstract class ManiaBaseHit : HitObject
+    public abstract class ManiaHitObject : HitObject, IHasColumn
     {
-        public int Column;
+        public int Column { get; set; }
     }
 }

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

@@ -1,9 +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 osu.Game.Beatmaps.Timing;
+using osu.Game.Database;
+using osu.Game.Rulesets.Mania.Judgements;
+
 namespace osu.Game.Rulesets.Mania.Objects
 {
-    public class Note : ManiaBaseHit
+    /// <summary>
+    /// Represents a hit object which has a single hit press.
+    /// </summary>
+    public class Note : ManiaHitObject
     {
+        /// <summary>
+        /// The key-press hit window for this note.
+        /// </summary>
+        protected HitWindows HitWindows = new HitWindows();
+
+        public override void ApplyDefaults(TimingInfo timing, BeatmapDifficulty difficulty)
+        {
+            base.ApplyDefaults(timing, difficulty);
+
+            HitWindows = new HitWindows(difficulty.OverallDifficulty);
+        }
     }
 }

osu.Game.Rulesets.Mania/Objects/Types/IHasColumn.cs

@@ -0,0 +1,16 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Rulesets.Mania.Objects.Types
+{
+    /// <summary>
+    /// A type of hit object which lies in one of a number of predetermined columns.
+    /// </summary>
+    public interface IHasColumn
+    {
+        /// <summary>
+        /// The column which the hit object lies in.
+        /// </summary>
+        int Column { get; }
+    }
+}

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

@@ -8,13 +8,13 @@ using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Mania.Scoring
 {
-    internal class ManiaScoreProcessor : ScoreProcessor<ManiaBaseHit, ManiaJudgement>
+    internal class ManiaScoreProcessor : ScoreProcessor<ManiaHitObject, ManiaJudgement>
     {
         public ManiaScoreProcessor()
         {
         }
 
-        public ManiaScoreProcessor(HitRenderer<ManiaBaseHit, ManiaJudgement> hitRenderer)
+        public ManiaScoreProcessor(HitRenderer<ManiaHitObject, ManiaJudgement> hitRenderer)
             : base(hitRenderer)
         {
         }

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

@@ -0,0 +1,153 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using OpenTK;
+using osu.Game.Beatmaps.Timing;
+
+namespace osu.Game.Rulesets.Mania.Timing
+{
+    /// <summary>
+    /// A container in which added drawables are put into a relative coordinate space spanned by a length of time.
+    /// <para>
+    /// This container contains <see cref="ControlPoint"/>s which scroll inside this container.
+    /// Drawables added to this container are moved inside the relevant <see cref="ControlPoint"/>,
+    /// and as such, will scroll along with the <see cref="ControlPoint"/>s.
+    /// </para>
+    /// </summary>
+    public class ControlPointContainer : Container<Drawable>
+    {
+        /// <summary>
+        /// The amount of time which this container spans.
+        /// </summary>
+        public double TimeSpan { get; set; }
+
+        private readonly List<DrawableControlPoint> drawableControlPoints;
+
+        public ControlPointContainer(IEnumerable<ControlPoint> timingChanges)
+        {
+            drawableControlPoints = timingChanges.Select(t => new DrawableControlPoint(t)).ToList();
+            Children = drawableControlPoints;
+        }
+
+        /// <summary>
+        /// Adds a drawable to this container. Note that the drawable added must have its Y-position be
+        /// an absolute unit of time that is _not_ relative to <see cref="TimeSpan"/>.
+        /// </summary>
+        /// <param name="drawable">The drawable to add.</param>
+        public override void Add(Drawable drawable)
+        {
+            // Always add timing sections to ourselves
+            if (drawable is DrawableControlPoint)
+            {
+                base.Add(drawable);
+                return;
+            }
+
+            var controlPoint = drawableControlPoints.LastOrDefault(t => t.CanContain(drawable)) ?? drawableControlPoints.FirstOrDefault();
+
+            if (controlPoint == null)
+                throw new Exception("Could not find suitable timing section to add object to.");
+
+            controlPoint.Add(drawable);
+        }
+
+        /// <summary>
+        /// A container that contains drawables within the time span of a timing section.
+        /// <para>
+        /// The content of this container will scroll relative to the current time.
+        /// </para>
+        /// </summary>
+        private class DrawableControlPoint : Container
+        {
+            private readonly ControlPoint timingChange;
+
+            protected override Container<Drawable> Content => content;
+            private readonly Container content;
+
+            /// <summary>
+            /// Creates a drawable control point. The height of this container will be proportional
+            /// to the beat length of the control point it is initialized with such that, e.g. a beat length
+            /// of 500ms results in this container being twice as high as its parent, which further means that
+            /// the content container will scroll at twice the normal rate.
+            /// </summary>
+            /// <param name="timingChange">The control point to create the drawable control point for.</param>
+            public DrawableControlPoint(ControlPoint timingChange)
+            {
+                this.timingChange = timingChange;
+
+                RelativeSizeAxes = Axes.Both;
+
+                AddInternal(content = new AutoTimeRelativeContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    RelativePositionAxes = Axes.Both,
+                    Y = (float)timingChange.Time
+                });
+            }
+
+            protected override void Update()
+            {
+                var parent = (ControlPointContainer)Parent;
+
+                // Adjust our height to account for the speed changes
+                Height = (float)(1000 / timingChange.BeatLength / timingChange.SpeedMultiplier);
+                RelativeCoordinateSpace = new Vector2(1, (float)parent.TimeSpan);
+
+                // Scroll the content
+                content.Y = (float)(timingChange.Time - Time.Current);
+            }
+
+            public override void Add(Drawable drawable)
+            {
+                // The previously relatively-positioned drawable will now become relative to content, but since the drawable has no knowledge of content,
+                // we need to offset it back by content's position position so that it becomes correctly relatively-positioned to content
+                // This can be removed if hit objects were stored such that either their StartTime or their "beat offset" was relative to the timing change
+                // they belonged to, but this requires a radical change to the beatmap format which we're not ready to do just yet
+                drawable.Y -= (float)timingChange.Time;
+
+                base.Add(drawable);
+            }
+
+            /// <summary>
+            /// Whether this control point can contain a drawable. This control point can contain a drawable if the drawable is positioned "after" this control point.
+            /// </summary>
+            /// <param name="drawable">The drawable to check.</param>
+            public bool CanContain(Drawable drawable) => content.Y <= drawable.Y;
+
+            /// <summary>
+            /// A container which always keeps its height and relative coordinate space "auto-sized" to its children.
+            /// <para>
+            /// This is used in the case where children are relatively positioned/sized to time values (e.g. notes/bar lines) to keep
+            /// such children wrapped inside a container, otherwise they would disappear due to container flattening.
+            /// </para>
+            /// </summary>
+            private class AutoTimeRelativeContainer : Container
+            {
+                public override void InvalidateFromChild(Invalidation invalidation)
+                {
+                    // We only want to re-compute our size when a child's size or position has changed
+                    if ((invalidation & Invalidation.Geometry) == 0)
+                    {
+                        base.InvalidateFromChild(invalidation);
+                        return;
+                    }
+
+                    if (!Children.Any())
+                        return;
+
+                    float height = Children.Select(child => child.Y + child.Height).Max();
+
+                    Height = height;
+                    RelativeCoordinateSpace = new Vector2(1, height);
+
+                    base.InvalidateFromChild(invalidation);
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,211 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+
+using OpenTK;
+using OpenTK.Graphics;
+using OpenTK.Input;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Input;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Mania.Timing;
+using System.Collections.Generic;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Judgements;
+using osu.Game.Beatmaps.Timing;
+
+namespace osu.Game.Rulesets.Mania.UI
+{
+    public class Column : Container, IHasAccentColour
+    {
+        private const float key_icon_size = 10;
+        private const float key_icon_corner_radius = 3;
+        private const float key_icon_border_radius = 2;
+
+        private const float hit_target_height = 10;
+        private const float hit_target_bar_height = 2;
+
+        private const float column_width = 45;
+        private const float special_column_width = 70;
+
+        public Key Key;
+
+        private readonly Box background;
+        private readonly Container hitTargetBar;
+        private readonly Container keyIcon;
+
+        public readonly ControlPointContainer ControlPointContainer;
+
+        public Column(IEnumerable<ControlPoint> timingChanges)
+        {
+            RelativeSizeAxes = Axes.Y;
+            Width = column_width;
+
+            Children = new Drawable[]
+            {
+                background = new Box
+                {
+                    Name = "Foreground",
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 0.2f
+                },
+                new Container
+                {
+                    Name = "Hit target + hit objects",
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Top = ManiaPlayfield.HIT_TARGET_POSITION},
+                    Children = new Drawable[]
+                    {
+                        new Container
+                        {
+                            Name = "Hit target",
+                            RelativeSizeAxes = Axes.X,
+                            Height = hit_target_height,
+                            Children = new Drawable[]
+                            {
+                                new Box
+                                {
+                                    Name = "Background",
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = Color4.Black
+                                },
+                                hitTargetBar = new Container
+                                {
+                                    Name = "Bar",
+                                    RelativeSizeAxes = Axes.X,
+                                    Height = hit_target_bar_height,
+                                    Masking = true,
+                                    Children = new[]
+                                    {
+                                        new Box
+                                        {
+                                            RelativeSizeAxes = Axes.Both
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        ControlPointContainer = new ControlPointContainer(timingChanges)
+                        {
+                            Name = "Hit objects",
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                    }
+                },
+                new Container
+                {
+                    Name = "Key",
+                    RelativeSizeAxes = Axes.X,
+                    Height = ManiaPlayfield.HIT_TARGET_POSITION,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            Name = "Key gradient",
+                            RelativeSizeAxes = Axes.Both,
+                            ColourInfo = ColourInfo.GradientVertical(Color4.Black, Color4.Black.Opacity(0)),
+                            Alpha = 0.5f
+                        },
+                        keyIcon = new Container
+                        {
+                            Name = "Key icon",
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Size = new Vector2(key_icon_size),
+                            Masking = true,
+                            CornerRadius = key_icon_corner_radius,
+                            BorderThickness = 2,
+                            BorderColour = Color4.White, // Not true
+                            Children = new[]
+                            {
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Alpha = 0,
+                                    AlwaysPresent = true
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+        }
+
+        private bool isSpecial;
+        public bool IsSpecial
+        {
+            get { return isSpecial; }
+            set
+            {
+                if (isSpecial == value)
+                    return;
+                isSpecial = value;
+
+                Width = isSpecial ? special_column_width : column_width;
+            }
+        }
+
+        private Color4 accentColour;
+        public Color4 AccentColour
+        {
+            get { return accentColour; }
+            set
+            {
+                if (accentColour == value)
+                    return;
+                accentColour = value;
+
+                background.Colour = accentColour;
+
+                hitTargetBar.EdgeEffect = new EdgeEffect
+                {
+                    Type = EdgeEffectType.Glow,
+                    Radius = 5,
+                    Colour = accentColour.Opacity(0.5f),
+                };
+
+                keyIcon.EdgeEffect = new EdgeEffect
+                {
+                    Type = EdgeEffectType.Glow,
+                    Radius = 5,
+                    Colour = accentColour.Opacity(0.5f),
+                };
+            }
+        }
+
+        public void Add(DrawableHitObject<ManiaHitObject, ManiaJudgement> hitObject)
+        {
+            ControlPointContainer.Add(hitObject);
+        }
+
+        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        {
+            if (args.Repeat)
+                return false;
+
+            if (args.Key == Key)
+            {
+                background.FadeTo(background.Alpha + 0.2f, 50, EasingTypes.OutQuint);
+                keyIcon.ScaleTo(1.4f, 50, EasingTypes.OutQuint);
+            }
+
+            return false;
+        }
+
+        protected override bool OnKeyUp(InputState state, KeyUpEventArgs args)
+        {
+            if (args.Key == Key)
+            {
+                background.FadeTo(0.2f, 800, EasingTypes.OutQuart);
+                keyIcon.ScaleTo(1f, 400, EasingTypes.OutQuart);
+            }
+
+            return false;
+        }
+    }
+}

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

@@ -1,34 +1,88 @@
 // 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 OpenTK;
+using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Timing;
 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.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
-    public class ManiaHitRenderer : HitRenderer<ManiaBaseHit, ManiaJudgement>
+    public class ManiaHitRenderer : HitRenderer<ManiaHitObject, ManiaJudgement>
     {
-        private readonly int columns;
+        public int? Columns;
 
-        public ManiaHitRenderer(WorkingBeatmap beatmap, int columns = 5)
+        public ManiaHitRenderer(WorkingBeatmap beatmap)
             : base(beatmap)
         {
-            this.columns = columns;
+        }
+
+        protected override Playfield<ManiaHitObject, ManiaJudgement> CreatePlayfield()
+        {
+            ControlPoint firstTimingChange = Beatmap.TimingInfo.ControlPoints.FirstOrDefault(t => t.TimingChange);
+
+            if (firstTimingChange == null)
+                throw new Exception("The Beatmap contains no timing points!");
+
+            // Generate the timing points, making non-timing changes use the previous timing change
+            var timingChanges = Beatmap.TimingInfo.ControlPoints.Select(c =>
+            {
+                ControlPoint t = c.Clone();
+
+                if (c.TimingChange)
+                    firstTimingChange = c;
+                else
+                    t.BeatLength = firstTimingChange.BeatLength;
+
+                return t;
+            });
+
+            double lastObjectTime = (Objects.Last() as IHasEndTime)?.EndTime ?? Objects.Last().StartTime;
+
+            // Perform some post processing of the timing changes
+            timingChanges = timingChanges
+                // Collapse sections after the last hit object
+                .Where(s => s.Time <= lastObjectTime)
+                // Collapse sections with the same start time
+                .GroupBy(s => s.Time).Select(g => g.Last()).OrderBy(s => s.Time)
+                // Collapse sections with the same beat length
+                .GroupBy(s => s.BeatLength * s.SpeedMultiplier).Select(g => g.First())
+                .ToList();
+
+            return new ManiaPlayfield(Columns ?? (int)Math.Round(Beatmap.BeatmapInfo.Difficulty.CircleSize), timingChanges)
+            {
+                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<ManiaBaseHit> CreateBeatmapConverter() => new ManiaBeatmapConverter();
+        protected override BeatmapConverter<ManiaHitObject> CreateBeatmapConverter() => new ManiaBeatmapConverter();
 
-        protected override Playfield<ManiaBaseHit, ManiaJudgement> CreatePlayfield() => new ManiaPlayfield(columns);
+        protected override DrawableHitObject<ManiaHitObject, ManiaJudgement> GetVisualRepresentation(ManiaHitObject h)
+        {
+            var note = h as Note;
+            if (note != null)
+                return new DrawableNote(note);
 
-        protected override DrawableHitObject<ManiaBaseHit, ManiaJudgement> GetVisualRepresentation(ManiaBaseHit h) => null;
+            return null;
+        }
+
+        protected override Vector2 GetPlayfieldAspectAdjust() => new Vector2(1, 0.8f);
     }
 }

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

@@ -8,29 +8,253 @@ using osu.Game.Rulesets.UI;
 using OpenTK;
 using OpenTK.Graphics;
 using osu.Game.Rulesets.Mania.Judgements;
+using osu.Framework.Graphics.Containers;
+using System;
+using osu.Game.Graphics;
+using osu.Framework.Allocation;
+using OpenTK.Input;
+using System.Linq;
+using System.Collections.Generic;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Mania.Timing;
+using osu.Framework.Input;
+using osu.Game.Beatmaps.Timing;
+using osu.Framework.Graphics.Transforms;
+using osu.Framework.MathUtils;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
-    public class ManiaPlayfield : Playfield<ManiaBaseHit, ManiaJudgement>
+    public class ManiaPlayfield : Playfield<ManiaHitObject, ManiaJudgement>
     {
-        public ManiaPlayfield(int columns)
+        public const float HIT_TARGET_POSITION = 50;
+
+        private const float time_span_default = 5000;
+        private const float time_span_min = 10;
+        private const float time_span_max = 50000;
+        private const float time_span_step = 200;
+
+        /// <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...
+        /// </summary>
+        private static readonly Key[] default_keys = { Key.A, Key.S, Key.D, Key.F, Key.J, Key.K, Key.L, Key.Semicolon };
+
+        private SpecialColumnPosition specialColumnPosition;
+        /// <summary>
+        /// The style to use for the special column.
+        /// </summary>
+        public SpecialColumnPosition SpecialColumnPosition
         {
-            Size = new Vector2(0.8f, 1f);
-            Anchor = Anchor.BottomCentre;
-            Origin = Anchor.BottomCentre;
+            get { return specialColumnPosition; }
+            set
+            {
+                if (IsLoaded)
+                    throw new InvalidOperationException($"Setting {nameof(SpecialColumnPosition)} after the playfield is loaded requires re-creating the playfield.");
+                specialColumnPosition = value;
+            }
+        }
 
-            Add(new Box { RelativeSizeAxes = Axes.Both, Alpha = 0.5f });
+        public readonly FlowContainer<Column> Columns;
 
-            for (int i = 0; i < columns; i++)
-                Add(new Box
+        private readonly ControlPointContainer barlineContainer;
+
+        private List<Color4> normalColumnColours = new List<Color4>();
+        private Color4 specialColumnColour;
+
+        private readonly int columnCount;
+
+        public ManiaPlayfield(int columnCount, IEnumerable<ControlPoint> timingChanges)
+        {
+            this.columnCount = columnCount;
+
+            if (columnCount <= 0)
+                throw new ArgumentException("Can't have zero or fewer columns.");
+
+            Children = new Drawable[]
+            {
+                new Container
                 {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
                     RelativeSizeAxes = Axes.Y,
-                    Size = new Vector2(2, 1),
-                    RelativePositionAxes = Axes.Both,
-                    Position = new Vector2((float)i / columns, 0),
-                    Alpha = 0.5f,
-                    Colour = Color4.Black
-                });
+                    AutoSizeAxes = Axes.X,
+                    Masking = true,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = Color4.Black
+                        },
+                        Columns = new FillFlowContainer<Column>
+                        {
+                            Name = "Columns",
+                            RelativeSizeAxes = Axes.Y,
+                            AutoSizeAxes = Axes.X,
+                            Direction = FillDirection.Horizontal,
+                            Padding = new MarginPadding { Left = 1, Right = 1 },
+                            Spacing = new Vector2(1, 0)
+                        },
+                        new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Padding = new MarginPadding { Top = HIT_TARGET_POSITION },
+                            Children = new[]
+                            {
+                                barlineContainer = new ControlPointContainer(timingChanges)
+                                {
+                                    Name = "Bar lines",
+                                    RelativeSizeAxes = Axes.Both,
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            for (int i = 0; i < columnCount; i++)
+                Columns.Add(new Column(timingChanges));
+
+            TimeSpan = time_span_default;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            normalColumnColours = new List<Color4>
+            {
+                colours.RedDark,
+                colours.GreenDark
+            };
+
+            specialColumnColour = colours.BlueDark;
+
+            // Set the special column + colour + key
+            for (int i = 0; i < columnCount; i++)
+            {
+                Column column = Columns.Children.ElementAt(i);
+                column.IsSpecial = isSpecialColumn(i);
+
+                if (!column.IsSpecial)
+                    continue;
+
+                column.Key = Key.Space;
+                column.AccentColour = specialColumnColour;
+            }
+
+            var nonSpecialColumns = Columns.Children.Where(c => !c.IsSpecial).ToList();
+
+            // We'll set the colours of the non-special columns in a separate loop, because the non-special
+            // column colours are mirrored across their centre and special styles mess with this
+            for (int i = 0; i < Math.Ceiling(nonSpecialColumns.Count / 2f); i++)
+            {
+                Color4 colour = normalColumnColours[i % normalColumnColours.Count];
+                nonSpecialColumns[i].AccentColour = colour;
+                nonSpecialColumns[nonSpecialColumns.Count - 1 - i].AccentColour = colour;
+            }
+
+            // We'll set the keys for non-special columns in another separate loop because it's not mirrored like the above colours
+            // Todo: This needs to go when we get to bindings and use Button1, ..., ButtonN instead
+            for (int i = 0; i < nonSpecialColumns.Count; i++)
+            {
+                Column column = nonSpecialColumns[i];
+
+                int keyOffset = default_keys.Length / 2 - nonSpecialColumns.Count / 2 + i;
+                if (keyOffset >= 0 && keyOffset < default_keys.Length)
+                    column.Key = default_keys[keyOffset];
+                else
+                    // There is no default key defined for this column. Let's set this to Unknown for now
+                    // however note that this will be gone after bindings are in place
+                    column.Key = Key.Unknown;
+            }
+        }
+
+        /// <summary>
+        /// Whether the column index is a special column for this playfield.
+        /// </summary>
+        /// <param name="column">The 0-based column index.</param>
+        /// <returns>Whether the column is a special column.</returns>
+        private bool isSpecialColumn(int column)
+        {
+            switch (SpecialColumnPosition)
+            {
+                default:
+                case SpecialColumnPosition.Normal:
+                    return columnCount % 2 == 1 && column == columnCount / 2;
+                case SpecialColumnPosition.Left:
+                    return column == 0;
+                case SpecialColumnPosition.Right:
+                    return column == columnCount - 1;
+            }
+        }
+
+        public override void Add(DrawableHitObject<ManiaHitObject, ManiaJudgement> h) => Columns.Children.ElementAt(h.HitObject.Column).Add(h);
+
+        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        {
+            if (state.Keyboard.ControlPressed)
+            {
+                switch (args.Key)
+                {
+                    case Key.Minus:
+                        transformTimeSpanTo(TimeSpan + time_span_step, 200, EasingTypes.OutQuint);
+                        break;
+                    case Key.Plus:
+                        transformTimeSpanTo(TimeSpan - time_span_step, 200, EasingTypes.OutQuint);
+                        break;
+                }
+            }
+
+            return false;
+        }
+
+        private double timeSpan;
+        /// <summary>
+        /// The amount of time which the length of the playfield spans.
+        /// </summary>
+        public double TimeSpan
+        {
+            get { return timeSpan; }
+            set
+            {
+                if (timeSpan == value)
+                    return;
+                timeSpan = value;
+
+                timeSpan = MathHelper.Clamp(timeSpan, time_span_min, time_span_max);
+
+                barlineContainer.TimeSpan = value;
+                Columns.Children.ForEach(c => c.ControlPointContainer.TimeSpan = value);
+            }
+        }
+
+        private void transformTimeSpanTo(double newTimeSpan, double duration = 0, EasingTypes easing = EasingTypes.None)
+        {
+            TransformTo(() => TimeSpan, newTimeSpan, duration, easing, new TransformTimeSpan());
+        }
+
+        private class TransformTimeSpan : Transform<double>
+        {
+            public override double CurrentValue
+            {
+                get
+                {
+                    double time = Time?.Current ?? 0;
+                    if (time < StartTime) return StartValue;
+                    if (time >= EndTime) return EndValue;
+
+                    return Interpolation.ValueAt(time, StartValue, EndValue, StartTime, EndTime, Easing);
+                }
+            }
+
+            public override void Apply(Drawable d)
+            {
+                base.Apply(d);
+
+                var p = (ManiaPlayfield)d;
+                p.TimeSpan = CurrentValue;
+            }
         }
     }
-}
+}

osu.Game.Rulesets.Mania/UI/SpecialColumnPosition.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
+
+namespace osu.Game.Rulesets.Mania.UI
+{
+    public enum SpecialColumnPosition
+    {
+        /// <summary>
+        /// The special column will lie in the center of the columns.
+        /// </summary>
+        Normal,
+        /// <summary>
+        /// The special column will lie to the left of the columns.
+        /// </summary>
+        Left,
+        /// <summary>
+        /// The special column will lie to the right of the columns.
+        /// </summary>
+        Right
+    }
+}

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

@@ -48,18 +48,28 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Beatmaps\ManiaBeatmapConverter.cs" />
+    <Compile Include="MathUtils\FastRandom.cs" />
+    <Compile Include="Judgements\HitWindows.cs" />
     <Compile Include="Judgements\ManiaJudgement.cs" />
     <Compile Include="ManiaDifficultyCalculator.cs" />
+    <Compile Include="Objects\Drawables\DrawableHoldNote.cs" />
+    <Compile Include="Objects\Drawables\DrawableManiaHitObject.cs" />
+    <Compile Include="Objects\Drawables\DrawableNote.cs" />
+    <Compile Include="Objects\Drawables\Pieces\BodyPiece.cs" />
+    <Compile Include="Objects\Drawables\Pieces\NotePiece.cs" />
+    <Compile Include="Objects\Types\IHasColumn.cs" />
     <Compile Include="Scoring\ManiaScoreProcessor.cs" />
-    <Compile Include="Objects\Drawable\DrawableNote.cs" />
     <Compile Include="Objects\HoldNote.cs" />
-    <Compile Include="Objects\ManiaBaseHit.cs" />
+    <Compile Include="Objects\ManiaHitObject.cs" />
     <Compile Include="Objects\Note.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="UI\Column.cs" />
     <Compile Include="UI\ManiaHitRenderer.cs" />
     <Compile Include="UI\ManiaPlayfield.cs" />
     <Compile Include="ManiaRuleset.cs" />
     <Compile Include="Mods\ManiaMod.cs" />
+    <Compile Include="UI\SpecialColumnPosition.cs" />
+    <Compile Include="Timing\ControlPointContainer.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\osu-framework\osu.Framework\osu.Framework.csproj">

osu.Game.Rulesets.Osu/Mods/OsuMod.cs

@@ -92,7 +92,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
     public class OsuModAutoplay : ModAutoplay<OsuHitObject>
     {
-        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModAutopilot) }).ToArray();
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModAutopilot), typeof(OsuModSpunOut) }).ToArray();
 
         protected override Score CreateReplayScore(Beatmap<OsuHitObject> beatmap) => new Score
         {

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

@@ -1,15 +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 System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
 using OpenTK;
 using OpenTK.Graphics;
-using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Graphics;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Allocation;
+using osu.Game.Screens.Ranking;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -18,9 +19,19 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         private readonly Spinner spinner;
 
         private readonly SpinnerDisc disc;
+        private readonly SpinnerTicks ticks;
+
+        private readonly Container mainContainer;
+
         private readonly SpinnerBackground background;
         private readonly Container circleContainer;
-        private readonly DrawableHitCircle circle;
+        private readonly CirclePiece circle;
+        private readonly GlowPiece glow;
+
+        private readonly TextAwesome symbol;
+
+        private Color4 normalColour;
+        private Color4 completeColour;
 
         public DrawableSpinner(Spinner s) : base(s)
         {
@@ -29,57 +40,91 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             Origin = Anchor.Centre;
             Position = s.Position;
 
-            //take up full playfield.
-            Size = new Vector2(OsuPlayfield.BASE_SIZE.X);
+            RelativeSizeAxes = Axes.Both;
+
+            // we are slightly bigger than our parent, to clip the top and bottom of the circle
+            Height = 1.3f;
 
             spinner = s;
 
             Children = new Drawable[]
             {
-                background = new SpinnerBackground
-                {
-                    Alpha = 0,
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    DiscColour = Color4.Black
-                },
-                disc = new SpinnerDisc
-                {
-                    Alpha = 0,
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    DiscColour = AccentColour
-                },
                 circleContainer = new Container
                 {
                     AutoSizeAxes = Axes.Both,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Children = new []
+                    Children = new Drawable[]
                     {
-                        circle = new DrawableHitCircle(s)
+                        glow = new GlowPiece(),
+                        circle = new CirclePiece
                         {
-                            Interactive = false,
                             Position = Vector2.Zero,
                             Anchor = Anchor.Centre,
-                        }
+                        },
+                        new RingPiece(),
+                        symbol = new TextAwesome
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            UseFullGlyphHeight = true,
+                            TextSize = 48,
+                            Icon = FontAwesome.fa_asterisk,
+                            Shadow = false,
+                        },
                     }
-                }
+                },
+                mainContainer = new AspectContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Y,
+                    Children = new Drawable[]
+                    {
+                        background = new SpinnerBackground
+                        {
+                            Alpha = 0.6f,
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                        },
+                        disc = new SpinnerDisc(spinner)
+                        {
+                            Scale = Vector2.Zero,
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                        },
+                        circleContainer.CreateProxy(),
+                        ticks = new SpinnerTicks
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                        },
+                    }
+                },
             };
-
-            background.Scale = scaleToCircle;
-            disc.Scale = scaleToCircle;
         }
 
+        public float Progress => MathHelper.Clamp(disc.RotationAbsolute / 360 / spinner.SpinsRequired, 0, 1);
+
         protected override void CheckJudgement(bool userTriggered)
         {
             if (Time.Current < HitObject.StartTime) return;
 
-            disc.ScaleTo(Interpolation.ValueAt(Math.Sqrt(Progress), scaleToCircle, Vector2.One, 0, 1), 100);
-
-            if (Progress >= 1)
+            if (Progress >= 1 && !disc.Complete)
+            {
                 disc.Complete = true;
 
+                const float duration = 200;
+
+                disc.FadeAccent(completeColour, duration);
+
+                background.FadeAccent(completeColour, duration);
+                background.FadeOut(duration);
+
+                circle.FadeColour(completeColour, duration);
+                glow.FadeColour(completeColour, duration);
+            }
+
             if (!userTriggered && Time.Current >= spinner.EndTime)
             {
                 if (Progress >= 1)
@@ -106,30 +151,48 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             }
         }
 
-        private Vector2 scaleToCircle => circle.Scale * circle.DrawWidth / DrawWidth * 0.95f;
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            normalColour = colours.SpinnerBase;
 
-        private const float spins_per_minute_needed = 100 + 5 * 15; //TODO: read per-map OD and place it on the 5
+            background.AccentColour = normalColour;
 
-        private float rotationsNeeded => (float)(spins_per_minute_needed * (spinner.EndTime - spinner.StartTime) / 60000f);
+            completeColour = colours.YellowLight.Opacity(0.6f);
 
-        public float Progress => MathHelper.Clamp(disc.RotationAbsolute / 360 / rotationsNeeded, 0, 1);
+            disc.AccentColour = colours.SpinnerFill;
+            circle.Colour = colours.BlueDark;
+            glow.Colour = colours.BlueDark;
+        }
+
+        protected override void UpdateAfterChildren()
+        {
+            base.UpdateAfterChildren();
+
+            circle.Rotation = disc.Rotation;
+            ticks.Rotation = disc.Rotation;
+
+            float relativeCircleScale = spinner.Scale * circle.DrawHeight / mainContainer.DrawHeight;
+            disc.ScaleTo(relativeCircleScale + (1 - relativeCircleScale) * Progress, 200, EasingTypes.OutQuint);
+
+            symbol.RotateTo(disc.Rotation / 2, 500, EasingTypes.OutQuint);
+        }
 
         protected override void UpdatePreemptState()
         {
             base.UpdatePreemptState();
 
-            circleContainer.ScaleTo(1, 400, EasingTypes.OutElastic);
+            circleContainer.ScaleTo(spinner.Scale * 0.3f);
+            circleContainer.ScaleTo(spinner.Scale, TIME_PREEMPT / 1.4f, EasingTypes.OutQuint);
 
-            background.Delay(TIME_PREEMPT - 500);
+            disc.RotateTo(-720);
+            symbol.RotateTo(-720);
 
-            background.ScaleTo(scaleToCircle * 1.2f, 400, EasingTypes.OutQuint);
-            background.FadeIn(200);
+            mainContainer.ScaleTo(0);
+            mainContainer.ScaleTo(spinner.Scale * circle.DrawHeight / DrawHeight * 1.4f, TIME_PREEMPT - 150, EasingTypes.OutQuint);
 
-            background.Delay(400);
-            background.ScaleTo(1, 250, EasingTypes.OutQuint);
-
-            disc.Delay(TIME_PREEMPT - 50);
-            disc.FadeIn(200);
+            mainContainer.Delay(TIME_PREEMPT - 150);
+            mainContainer.ScaleTo(1, 500, EasingTypes.OutQuint);
         }
 
         protected override void UpdateCurrentState(ArmedState state)

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

@@ -16,7 +16,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
     {
         private readonly Sprite disc;
 
-
         public Func<bool> Hit;
 
         public CirclePiece()

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

@@ -97,8 +97,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
         [BackgroundDependencyLoader]
         private void load(OsuConfigManager config)
         {
-            snakingIn = config.GetBindable<bool>(OsuConfig.SnakingInSliders);
-            snakingOut = config.GetBindable<bool>(OsuConfig.SnakingOutSliders);
+            snakingIn = config.GetBindable<bool>(OsuSetting.SnakingInSliders);
+            snakingOut = config.GetBindable<bool>(OsuSetting.SnakingOutSliders);
 
             reloadTexture();
         }

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

@@ -1,10 +1,55 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using OpenTK.Graphics;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Graphics;
+
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
-    public class SpinnerBackground : SpinnerDisc
+    public class SpinnerBackground : CircularContainer, IHasAccentColour
     {
         public override bool HandleInput => false;
+
+        protected Box Disc;
+
+        public Color4 AccentColour
+        {
+            get
+            {
+                return Disc.Colour;
+            }
+            set
+            {
+                Disc.Colour = value;
+
+                EdgeEffect = new EdgeEffect
+                {
+                    Type = EdgeEffectType.Glow,
+                    Radius = 14,
+                    Colour = value.Opacity(0.3f),
+                };
+            }
+        }
+
+        public SpinnerBackground()
+        {
+            RelativeSizeAxes = Axes.Both;
+            Masking = true;
+
+            Children = new Drawable[]
+            {
+                Disc = new Box
+                {
+                    Origin = Anchor.Centre,
+                    Anchor = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 1,
+                },
+            };
+        }
     }
 }

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

@@ -2,13 +2,8 @@
 // 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.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Transforms;
 using osu.Framework.Input;
 using osu.Game.Graphics;
@@ -17,104 +12,31 @@ using OpenTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
-    public class SpinnerDisc : CircularContainer
+    public class SpinnerDisc : CircularContainer, IHasAccentColour
     {
-        protected Sprite Disc;
+        private readonly Spinner spinner;
 
-        public SRGBColour DiscColour
+        public Color4 AccentColour
         {
-            get { return Disc.Colour; }
-            set { Disc.Colour = value; }
+            get { return background.AccentColour; }
+            set { background.AccentColour = value; }
         }
 
-        private Color4 completeColour;
+        private readonly SpinnerBackground background;
 
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
+        private const float idle_alpha = 0.2f;
+        private const float tracking_alpha = 0.4f;
+
+        public SpinnerDisc(Spinner s)
         {
-            completeColour = colours.YellowLight.Opacity(0.8f);
-            Masking = true;
-        }
+            spinner = s;
 
-        private class SpinnerBorder : Container
-        {
-            public SpinnerBorder()
-            {
-                Origin = Anchor.Centre;
-                Anchor = Anchor.Centre;
-                RelativeSizeAxes = Axes.Both;
-
-                layout();
-            }
-
-            private int lastLayoutDotCount;
-            private void layout()
-            {
-                int count = (int)(MathHelper.Pi * ScreenSpaceDrawQuad.Width / 9);
-
-                if (count == lastLayoutDotCount) return;
-
-                lastLayoutDotCount = count;
-
-                while (Children.Count() < count)
-                {
-                    Add(new CircularContainer
-                    {
-                        Colour = Color4.White,
-                        RelativePositionAxes = Axes.Both,
-                        Masking = true,
-                        Origin = Anchor.Centre,
-                        Size = new Vector2(1 / ScreenSpaceDrawQuad.Width * 2000),
-                        Children = new[]
-                        {
-                            new Box
-                            {
-                                Origin = Anchor.Centre,
-                                Anchor = Anchor.Centre,
-                                RelativeSizeAxes = Axes.Both,
-                            }
-                        }
-                    });
-                }
-
-                var size = new Vector2(1 / ScreenSpaceDrawQuad.Width * 2000);
-
-                int i = 0;
-                foreach (var d in Children)
-                {
-                    d.Size = size;
-                    d.Position = new Vector2(
-                        0.5f + (float)Math.Sin((float)i / count * 2 * MathHelper.Pi) / 2,
-                        0.5f + (float)Math.Cos((float)i / count * 2 * MathHelper.Pi) / 2
-                    );
-
-                    i++;
-                }
-            }
-
-            protected override void Update()
-            {
-                base.Update();
-                layout();
-            }
-        }
-
-        public SpinnerDisc()
-        {
             AlwaysReceiveInput = true;
-
             RelativeSizeAxes = Axes.Both;
 
             Children = new Drawable[]
             {
-                Disc = new Box
-                {
-                    Origin = Anchor.Centre,
-                    Anchor = Anchor.Centre,
-                    RelativeSizeAxes = Axes.Both,
-                    Alpha = 0.2f,
-                },
-                new SpinnerBorder()
+                background = new SpinnerBackground { Alpha = idle_alpha },
             };
         }
 
@@ -125,10 +47,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             set
             {
                 if (value == tracking) return;
-
                 tracking = value;
 
-                Disc.FadeTo(tracking ? 0.5f : 0.2f, 100);
+                background.FadeTo(tracking ? tracking_alpha : idle_alpha, 100);
             }
         }
 
@@ -139,31 +60,28 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             set
             {
                 if (value == complete) return;
-
                 complete = value;
 
-                Disc.FadeColour(completeColour, 200);
-
                 updateCompleteTick();
             }
         }
 
         protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
         {
-            Tracking = true;
+            Tracking |= state.Mouse.HasMainButtonPressed;
             return base.OnMouseDown(state, args);
         }
 
         protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
         {
-            Tracking = false;
+            Tracking &= state.Mouse.HasMainButtonPressed;
             return base.OnMouseUp(state, args);
         }
 
         protected override bool OnMouseMove(InputState state)
         {
             Tracking |= state.Mouse.HasMainButtonPressed;
-            mousePosition = state.Mouse.Position;
+            mousePosition = Parent.ToLocalSpace(state.Mouse.NativeState.Position);
             return base.OnMouseMove(state);
         }
 
@@ -177,13 +95,24 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 
         private bool updateCompleteTick() => completeTick != (completeTick = (int)(RotationAbsolute / 360));
 
+        private bool rotationTransferred;
+
         protected override void Update()
         {
             base.Update();
 
             var thisAngle = -(float)MathHelper.RadiansToDegrees(Math.Atan2(mousePosition.X - DrawSize.X / 2, mousePosition.Y - DrawSize.Y / 2));
-            if (tracking)
+
+            bool validAndTracking = tracking && spinner.StartTime <= Time.Current && spinner.EndTime > Time.Current;
+
+            if (validAndTracking)
             {
+                if (!rotationTransferred)
+                {
+                    currentRotation = Rotation * 2;
+                    rotationTransferred = true;
+                }
+
                 if (thisAngle - lastAngle > 180)
                     lastAngle += 360;
                 else if (lastAngle - thisAngle > 180)
@@ -192,17 +121,18 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                 currentRotation += thisAngle - lastAngle;
                 RotationAbsolute += Math.Abs(thisAngle - lastAngle);
             }
+
             lastAngle = thisAngle;
 
             if (Complete && updateCompleteTick())
             {
-                Disc.Flush(flushType: typeof(TransformAlpha));
-                Disc.FadeTo(0.75f, 30, EasingTypes.OutExpo);
-                Disc.Delay(30);
-                Disc.FadeTo(0.5f, 250, EasingTypes.OutQuint);
+                background.Flush(flushType: typeof(TransformAlpha));
+                background.FadeTo(tracking_alpha + 0.4f, 60, EasingTypes.OutExpo);
+                background.Delay(60);
+                background.FadeTo(tracking_alpha, 250, EasingTypes.OutQuint);
             }
 
-            RotateTo(currentRotation, 100, EasingTypes.OutExpo);
+            RotateTo(currentRotation / 2, validAndTracking ? 500 : 1500, EasingTypes.OutExpo);
         }
     }
 }

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

@@ -0,0 +1,71 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Graphics;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    public class SpinnerTicks : Container
+    {
+        private Color4 glowColour;
+
+        public SpinnerTicks()
+        {
+            Origin = Anchor.Centre;
+            Anchor = Anchor.Centre;
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            glowColour = colours.BlueDarker.Opacity(0.4f);
+            layout();
+        }
+
+        private void layout()
+        {
+            const int count = 18;
+
+            for (int i = 0; i < count; i++)
+            {
+                Add(new Container
+                {
+                    Colour = Color4.Black,
+                    Alpha = 0.4f,
+                    EdgeEffect = new EdgeEffect
+                    {
+                        Type = EdgeEffectType.Glow,
+                        Radius = 20,
+                        Colour = glowColour,
+                    },
+                    RelativePositionAxes = Axes.Both,
+                    Masking = true,
+                    CornerRadius = 5,
+                    Size = new Vector2(60, 10),
+                    Origin = Anchor.Centre,
+                    Position = new Vector2(
+                        0.5f + (float)Math.Sin((float)i / count * 2 * MathHelper.Pi) / 2 * 0.86f,
+                        0.5f + (float)Math.Cos((float)i / count * 2 * MathHelper.Pi) / 2 * 0.86f
+                    ),
+                    Rotation = -(float)i / count * 360 + 90,
+                    Children = new[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                        }
+                    }
+                });
+            }
+        }
+    }
+}

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

@@ -2,6 +2,8 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Beatmaps.Timing;
+using osu.Game.Database;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {
@@ -10,6 +12,18 @@ namespace osu.Game.Rulesets.Osu.Objects
         public double EndTime { get; set; }
         public double Duration => EndTime - StartTime;
 
+        /// <summary>
+        /// Number of spins required to finish the spinner without miss.
+        /// </summary>
+        public int SpinsRequired { get; protected set; } = 1;
+
         public override bool NewCombo => true;
+
+        public override void ApplyDefaults(TimingInfo timing, BeatmapDifficulty difficulty)
+        {
+            base.ApplyDefaults(timing, difficulty);
+
+            SpinsRequired = (int)(Duration / 1000 * BeatmapDifficulty.DifficultyRange(difficulty.OverallDifficulty, 3, 5, 7.5));
+        }
     }
 }

osu.Game.Rulesets.Osu/Replays/OsuAutoGeneratorBase.cs

@@ -58,8 +58,8 @@ namespace osu.Game.Rulesets.Osu.Replays
         {
             public int Compare(ReplayFrame f1, ReplayFrame f2)
             {
-                if (f1 == null) throw new NullReferenceException($@"{nameof(f1)} cannot be null");
-                if (f2 == null) throw new NullReferenceException($@"{nameof(f2)} cannot be null");
+                if (f1 == null) throw new ArgumentNullException(nameof(f1));
+                if (f2 == null) throw new ArgumentNullException(nameof(f2));
 
                 return f1.Time.CompareTo(f2.Time);
             }

osu.Game.Rulesets.Osu/osu.Game.Rulesets.Osu.csproj

@@ -64,6 +64,7 @@
     <Compile Include="Objects\Drawables\Pieces\RingPiece.cs" />
     <Compile Include="Objects\Drawables\Pieces\SliderBouncer.cs" />
     <Compile Include="Objects\Drawables\Pieces\SpinnerDisc.cs" />
+    <Compile Include="Objects\Drawables\Pieces\SpinnerTicks.cs" />
     <Compile Include="Objects\Drawables\Pieces\TrianglesPiece.cs" />
     <Compile Include="Objects\Drawables\Pieces\SliderBall.cs" />
     <Compile Include="Objects\Drawables\Pieces\SliderBody.cs" />
@@ -103,9 +104,7 @@
     <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup />
-  <ItemGroup>
-    <Folder Include="Replays\" />
-  </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
        Other similar extension points exist, see Microsoft.Common.targets.

osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs

@@ -44,7 +44,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
         protected override Beatmap<TaikoHitObject> ConvertBeatmap(Beatmap original)
         {
             // Rewrite the beatmap info to add the slider velocity multiplier
-            BeatmapInfo info = original.BeatmapInfo.DeepClone<BeatmapInfo>();
+            BeatmapInfo info = original.BeatmapInfo.DeepClone();
             info.Difficulty.SliderMultiplier *= legacy_velocity_multiplier;
 
             Beatmap<TaikoHitObject> converted = base.ConvertBeatmap(original);

osu.Game.Rulesets.Taiko/Mods/TaikoMod.cs

@@ -72,7 +72,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
         protected override Score CreateReplayScore(Beatmap<TaikoHitObject> beatmap) => new Score
         {
             User = new User { Username = "mekkadosu!" },
-            Replay = new TaikoAutoReplay(beatmap).Generate(),
+            Replay = new TaikoAutoGenerator(beatmap).Generate(),
         };
     }
 }

osu.Game.Rulesets.Taiko/Objects/Drawables/Pieces/ElongatedCirclePiece.cs

@@ -2,7 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
-using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces
 {

osu.Game.Rulesets.Taiko/Replays/TaikoAutoGenerator.cs

@@ -7,16 +7,24 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Rulesets.Replays;
+using osu.Game.Users;
 
 namespace osu.Game.Rulesets.Taiko.Replays
 {
-    public class TaikoAutoReplay : AutoGenerator<TaikoHitObject>
+    public class TaikoAutoGenerator : AutoGenerator<TaikoHitObject>
     {
         private const double swell_hit_speed = 50;
 
-        public TaikoAutoReplay(Beatmap<TaikoHitObject> beatmap)
+        public TaikoAutoGenerator(Beatmap<TaikoHitObject> beatmap)
             : base(beatmap)
         {
+            Replay = new Replay
+            {
+                User = new User
+                {
+                    Username = @"Autoplay",
+                }
+            };
         }
 
         protected Replay Replay;
@@ -101,7 +109,7 @@ namespace osu.Game.Rulesets.Taiko.Replays
                     Frames.Add(new ReplayFrame(h.StartTime, null, null, button));
                 }
                 else
-                    throw new Exception("Unknown hit object type.");
+                    throw new InvalidOperationException("Unknown hit object type.");
 
                 Frames.Add(new ReplayFrame(endTime + KEY_UP_DELAY, null, null, ReplayButtonState.None));
 

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

@@ -13,7 +13,6 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Extensions.Color4Extensions;
-using osu.Framework.Graphics.Primitives;
 using System.Linq;
 using osu.Game.Rulesets.Taiko.Objects.Drawables;
 using System;
@@ -54,33 +53,33 @@ namespace osu.Game.Rulesets.Taiko.UI
         {
             AddInternal(new Drawable[]
             {
-                rightBackgroundContainer = new Container
-                {
-                    Name = "Transparent playfield background",
-                    RelativeSizeAxes = Axes.Both,
-                    BorderThickness = 2,
-                    Masking = true,
-                    EdgeEffect = new EdgeEffect
-                    {
-                        Type = EdgeEffectType.Shadow,
-                        Colour = Color4.Black.Opacity(0.2f),
-                        Radius = 5,
-                    },
-                    Children = new Drawable[]
-                    {
-                        rightBackground = new Box
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            Alpha = 0.6f
-                        },
-                    }
-                },
                 new ScaleFixContainer
                 {
                     RelativeSizeAxes = Axes.X,
                     Height = DEFAULT_PLAYFIELD_HEIGHT,
                     Children = new[]
                     {
+                        rightBackgroundContainer = new Container
+                        {
+                            Name = "Transparent playfield background",
+                            RelativeSizeAxes = Axes.Both,
+                            BorderThickness = 2,
+                            Masking = true,
+                            EdgeEffect = new EdgeEffect
+                            {
+                                Type = EdgeEffectType.Shadow,
+                                Colour = Color4.Black.Opacity(0.2f),
+                                Radius = 5,
+                            },
+                            Children = new Drawable[]
+                            {
+                                rightBackground = new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Alpha = 0.6f
+                                },
+                            }
+                        },
                         new Container
                         {
                             Name = "Transparent playfield elements",

osu.Game.Rulesets.Taiko/osu.Game.Rulesets.Taiko.csproj

@@ -79,7 +79,7 @@
     <Compile Include="Objects\RimHit.cs" />
     <Compile Include="Objects\Swell.cs" />
     <Compile Include="Replays\TaikoFramedReplayInputHandler.cs" />
-    <Compile Include="Replays\TaikoAutoReplay.cs" />
+    <Compile Include="Replays\TaikoAutoGenerator.cs" />
     <Compile Include="Objects\TaikoHitObject.cs" />
     <Compile Include="Objects\TaikoHitObjectDifficulty.cs" />
     <Compile Include="TaikoDifficultyCalculator.cs" />

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

@@ -26,15 +26,15 @@ namespace osu.Game.Tests.Beatmaps.IO
             //unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
             using (HeadlessGameHost host = new HeadlessGameHost())
             {
-                var osu = loadOsu(host);
+                loadOsu(host);
 
                 var temp = prepareTempCopy(osz_path);
 
                 Assert.IsTrue(File.Exists(temp));
 
-                osu.Dependencies.Get<BeatmapDatabase>().Import(temp);
+                host.Dependencies.Get<BeatmapDatabase>().Import(temp);
 
-                ensureLoaded(osu);
+                ensureLoaded(host);
 
                 Assert.IsFalse(File.Exists(temp));
             }
@@ -49,7 +49,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                 Assert.IsTrue(host.IsPrimaryInstance);
                 Assert.IsTrue(!client.IsPrimaryInstance);
 
-                var osu = loadOsu(host);
+                loadOsu(host);
 
                 var temp = prepareTempCopy(osz_path);
 
@@ -59,7 +59,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                 if (!importer.ImportAsync(temp).Wait(5000))
                     Assert.Fail(@"IPC took too long to send");
 
-                ensureLoaded(osu);
+                ensureLoaded(host);
 
                 Assert.IsFalse(File.Exists(temp));
             }
@@ -71,16 +71,16 @@ namespace osu.Game.Tests.Beatmaps.IO
             //unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
             using (HeadlessGameHost host = new HeadlessGameHost())
             {
-                var osu = loadOsu(host);
+                loadOsu(host);
 
                 var temp = prepareTempCopy(osz_path);
 
                 Assert.IsTrue(File.Exists(temp));
 
                 using (File.OpenRead(temp))
-                    osu.Dependencies.Get<BeatmapDatabase>().Import(temp);
+                    host.Dependencies.Get<BeatmapDatabase>().Import(temp);
 
-                ensureLoaded(osu);
+                ensureLoaded(host);
 
                 Assert.IsTrue(File.Exists(temp));
 
@@ -105,19 +105,19 @@ namespace osu.Game.Tests.Beatmaps.IO
                 Thread.Sleep(1);
 
             //reset beatmap database (sqlite and storage backing)
-            osu.Dependencies.Get<RulesetDatabase>().Reset();
-            osu.Dependencies.Get<BeatmapDatabase>().Reset();
+            host.Dependencies.Get<RulesetDatabase>().Reset();
+            host.Dependencies.Get<BeatmapDatabase>().Reset();
 
             return osu;
         }
 
-        private void ensureLoaded(OsuGameBase osu, int timeout = 10000)
+        private void ensureLoaded(GameHost host, int timeout = 10000)
         {
             IEnumerable<BeatmapSetInfo> resultSets = null;
 
             Action waitAction = () =>
             {
-                while (!(resultSets = osu.Dependencies.Get<BeatmapDatabase>()
+                while (!(resultSets = host.Dependencies.Get<BeatmapDatabase>()
                     .Query<BeatmapSetInfo>().Where(s => s.OnlineBeatmapSetID == 241526)).Any())
                     Thread.Sleep(50);
             };
@@ -134,16 +134,15 @@ namespace osu.Game.Tests.Beatmaps.IO
             //if we don't re-check here, the set will be inserted but the beatmaps won't be present yet.
             waitAction = () =>
             {
-                while ((resultBeatmaps = osu.Dependencies.Get<BeatmapDatabase>()
-                    .Query<BeatmapInfo>().Where(s => s.OnlineBeatmapSetID == 241526 && s.BaseDifficultyID > 0)).Count() != 12)
+                while ((resultBeatmaps = host.Dependencies.Get<BeatmapDatabase>()
+                    .GetAllWithChildren<BeatmapInfo>(s => s.OnlineBeatmapSetID == 241526 && s.BaseDifficultyID > 0)).Count() != 12)
                     Thread.Sleep(50);
             };
 
             Assert.IsTrue(waitAction.BeginInvoke(null, null).AsyncWaitHandle.WaitOne(timeout),
                 @"Beatmaps did not import to the database in allocated time");
 
-            //fetch children and check we can load from the post-storage path...
-            var set = osu.Dependencies.Get<BeatmapDatabase>().GetChildren(resultSets.First());
+            var set = host.Dependencies.Get<BeatmapDatabase>().GetChildren(resultSets.First());
 
             Assert.IsTrue(set.Beatmaps.Count == resultBeatmaps.Count(),
                 $@"Incorrect database beatmap count post-import ({resultBeatmaps.Count()} but should be {set.Beatmaps.Count}).");
@@ -153,16 +152,16 @@ namespace osu.Game.Tests.Beatmaps.IO
 
             Assert.IsTrue(set.Beatmaps.Count > 0);
 
-            var beatmap = osu.Dependencies.Get<BeatmapDatabase>().GetWorkingBeatmap(set.Beatmaps.First(b => b.RulesetID == 0))?.Beatmap;
+            var beatmap = host.Dependencies.Get<BeatmapDatabase>().GetWorkingBeatmap(set.Beatmaps.First(b => b.RulesetID == 0))?.Beatmap;
             Assert.IsTrue(beatmap?.HitObjects.Count > 0);
 
-            beatmap = osu.Dependencies.Get<BeatmapDatabase>().GetWorkingBeatmap(set.Beatmaps.First(b => b.RulesetID == 1))?.Beatmap;
+            beatmap = host.Dependencies.Get<BeatmapDatabase>().GetWorkingBeatmap(set.Beatmaps.First(b => b.RulesetID == 1))?.Beatmap;
             Assert.IsTrue(beatmap?.HitObjects.Count > 0);
 
-            beatmap = osu.Dependencies.Get<BeatmapDatabase>().GetWorkingBeatmap(set.Beatmaps.First(b => b.RulesetID == 2))?.Beatmap;
+            beatmap = host.Dependencies.Get<BeatmapDatabase>().GetWorkingBeatmap(set.Beatmaps.First(b => b.RulesetID == 2))?.Beatmap;
             Assert.IsTrue(beatmap?.HitObjects.Count > 0);
 
-            beatmap = osu.Dependencies.Get<BeatmapDatabase>().GetWorkingBeatmap(set.Beatmaps.First(b => b.RulesetID == 3))?.Beatmap;
+            beatmap = host.Dependencies.Get<BeatmapDatabase>().GetWorkingBeatmap(set.Beatmaps.First(b => b.RulesetID == 3))?.Beatmap;
             Assert.IsTrue(beatmap?.HitObjects.Count > 0);
         }
     }

osu.Game/Audio/SampleInfoList.cs

@@ -11,9 +11,8 @@ namespace osu.Game.Audio
         {
         }
 
-        public SampleInfoList(IEnumerable<SampleInfo> elements)
+        public SampleInfoList(IEnumerable<SampleInfo> elements) : base(elements)
         {
-            AddRange(elements);
         }
     }
 }

osu.Game/Beatmaps/Drawables/BeatmapPanel.cs

@@ -5,7 +5,6 @@ using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Database;
 using osu.Game.Graphics;

osu.Game/Beatmaps/Drawables/BeatmapSetHeader.cs

@@ -9,7 +9,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Graphics.Sprites;
@@ -51,14 +50,12 @@ namespace osu.Game.Beatmaps.Drawables
                         title = new OsuSpriteText
                         {
                             Font = @"Exo2.0-BoldItalic",
-                            Text = beatmap.BeatmapSetInfo.Metadata.Title,
                             TextSize = 22,
                             Shadow = true,
                         },
                         artist = new OsuSpriteText
                         {
                             Font = @"Exo2.0-SemiBoldItalic",
-                            Text = beatmap.BeatmapSetInfo.Metadata.Artist,
                             TextSize = 17,
                             Shadow = true,
                         },
@@ -81,8 +78,8 @@ namespace osu.Game.Beatmaps.Drawables
         [BackgroundDependencyLoader]
         private void load(LocalisationEngine localisation)
         {
-            title.Current = localisation.GetUnicodePreference(beatmap.BeatmapSetInfo.Metadata.TitleUnicode, beatmap.BeatmapSetInfo.Metadata.Title);
-            artist.Current = localisation.GetUnicodePreference(beatmap.BeatmapSetInfo.Metadata.ArtistUnicode, beatmap.BeatmapSetInfo.Metadata.Artist);
+            title.Current = localisation.GetUnicodePreference(beatmap.Metadata.TitleUnicode, beatmap.Metadata.Title);
+            artist.Current = localisation.GetUnicodePreference(beatmap.Metadata.ArtistUnicode, beatmap.Metadata.Artist);
         }
 
         private class PanelBackground : BufferedContainer

osu.Game/Beatmaps/Formats/BeatmapDecoder.cs

@@ -11,7 +11,7 @@ namespace osu.Game.Beatmaps.Formats
 {
     public abstract class BeatmapDecoder
     {
-        private static Dictionary<string, Type> decoders { get; } = new Dictionary<string, Type>();
+        private static readonly Dictionary<string, Type> decoders = new Dictionary<string, Type>();
 
         public static BeatmapDecoder GetDecoder(StreamReader stream)
         {

osu.Game/Beatmaps/IO/ArchiveReader.cs

@@ -13,11 +13,11 @@ namespace osu.Game.Beatmaps.IO
     {
         private class Reader
         {
-            public Func<Storage, string, bool> Test { get; set; }
-            public Type Type { get; set; }
+            public Func<Storage, string, bool> Test;
+            public Type Type;
         }
 
-        private static List<Reader> readers { get; } = new List<Reader>();
+        private static readonly List<Reader> readers = new List<Reader>();
 
         public static ArchiveReader GetReader(Storage storage, string path)
         {
@@ -58,11 +58,9 @@ namespace osu.Game.Beatmaps.IO
                 if (input == null)
                     return null;
 
-                using (MemoryStream ms = new MemoryStream())
-                {
-                    input.CopyTo(ms);
-                    return ms.ToArray();
-                }
+                byte[] buffer = new byte[input.Length];
+                input.Read(buffer, 0, buffer.Length);
+                return buffer;
             }
         }
     }

osu.Game/Beatmaps/Timing/ControlPoint.cs

@@ -7,7 +7,7 @@ namespace osu.Game.Beatmaps.Timing
     {
         public string SampleBank;
         public int SampleVolume;
-        public TimeSignatures TimeSignature;
+        public TimeSignatures TimeSignature = TimeSignatures.SimpleQuadruple;
         public double Time;
         public double BeatLength = 500;
         public double SpeedMultiplier = 1;

osu.Game/Beatmaps/WorkingBeatmap.cs

@@ -18,14 +18,17 @@ namespace osu.Game.Beatmaps
 
         public readonly BeatmapSetInfo BeatmapSetInfo;
 
+        public readonly BeatmapMetadata Metadata;
+
         public readonly Bindable<IEnumerable<Mod>> Mods = new Bindable<IEnumerable<Mod>>(new Mod[] { });
 
         public readonly bool WithStoryboard;
 
-        protected WorkingBeatmap(BeatmapInfo beatmapInfo, BeatmapSetInfo beatmapSetInfo, bool withStoryboard = false)
+        protected WorkingBeatmap(BeatmapInfo beatmapInfo, bool withStoryboard = false)
         {
             BeatmapInfo = beatmapInfo;
-            BeatmapSetInfo = beatmapSetInfo;
+            BeatmapSetInfo = beatmapInfo.BeatmapSet;
+            Metadata = beatmapInfo.Metadata ?? BeatmapSetInfo.Metadata;
             WithStoryboard = withStoryboard;
 
             Mods.ValueChanged += mods => applyRateAdjustments();

osu.Game/Configuration/ConfineMouseMode.cs

@@ -1,12 +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
-
-namespace osu.Game.Configuration
-{
-    public enum ConfineMouseMode
-    {
-        Never,
-        Fullscreen,
-        Always
-    }
-}

osu.Game/Configuration/OsuConfigManager.cs

@@ -1,183 +1,77 @@
 // 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.Configuration;
 using osu.Framework.Platform;
+using osu.Game.Overlays;
 using osu.Game.Screens.Select;
 
 namespace osu.Game.Configuration
 {
-    public class OsuConfigManager : ConfigManager<OsuConfig>
+    public class OsuConfigManager : ConfigManager<OsuSetting>
     {
         protected override void InitialiseDefaults()
         {
-#pragma warning disable CS0612 // Type or member is obsolete
+            // UI/selection defaults
 
-            Set(OsuConfig.Username, string.Empty);
-            Set(OsuConfig.Token, string.Empty);
+            Set(OsuSetting.Ruleset, 0, 0, int.MaxValue);
+            Set(OsuSetting.BeatmapDetailTab, BeatmapDetailTab.Details);
 
-            Set(OsuConfig.Ruleset, 0, 0, int.MaxValue);
+            Set(OsuSetting.DisplayStarsMinimum, 0.0, 0, 10);
+            Set(OsuSetting.DisplayStarsMaximum, 10.0, 0, 10);
 
-            Set(OsuConfig.AudioDevice, string.Empty);
-            Set(OsuConfig.SavePassword, false);
-            Set(OsuConfig.SaveUsername, true);
+            Set(OsuSetting.ChatDisplayHeight, ChatOverlay.DEFAULT_HEIGHT, 0.2, 1);
 
-            Set(OsuConfig.MenuCursorSize, 1.0, 0.5f, 2);
-            Set(OsuConfig.GameplayCursorSize, 1.0, 0.5f, 2);
-            Set(OsuConfig.DimLevel, 0.3, 0, 1);
+            // Online settings
 
-            Set(OsuConfig.MouseDisableButtons, false);
-            Set(OsuConfig.MouseDisableWheel, false);
+            Set(OsuSetting.Username, string.Empty);
+            Set(OsuSetting.Token, string.Empty);
 
-            Set(OsuConfig.SnakingInSliders, true);
-            Set(OsuConfig.SnakingOutSliders, true);
-
-            Set(OsuConfig.MenuParallax, true);
-
-            Set(OsuConfig.MenuVoice, true);
-            Set(OsuConfig.MenuMusic, true);
-
-            Set(OsuConfig.BeatmapDetailTab, BeatmapDetailTab.Details);
-
-            Set(OsuConfig.ShowInterface, true);
-            Set(OsuConfig.KeyOverlay, false);
-
-            //todo: implement all settings below this line (remove the Disabled set when doing so).
-            Set(OsuConfig.AudioOffset, 0, -500.0, 500.0);
-
-            Set(OsuConfig.MouseSpeed, 1.0).Disabled = true;
-            Set(OsuConfig.BeatmapDirectory, @"Songs").Disabled = true; // TODO: use thi.Disabled = trues
-            Set(OsuConfig.AllowPublicInvites, true).Disabled = true;
-            Set(OsuConfig.AutoChatHide, true).Disabled = true;
-            Set(OsuConfig.AutomaticDownload, true).Disabled = true;
-            Set(OsuConfig.AutomaticDownloadNoVideo, false).Disabled = true;
-            Set(OsuConfig.BlockNonFriendPM, false).Disabled = true;
-            Set(OsuConfig.Bloom, false).Disabled = true;
-            Set(OsuConfig.BloomSoftening, false).Disabled = true;
-            Set(OsuConfig.BossKeyFirstActivation, true).Disabled = true;
-            Set(OsuConfig.ChatAudibleHighlight, true).Disabled = true;
-            Set(OsuConfig.ChatChannels, string.Empty).Disabled = true;
-            Set(OsuConfig.ChatFilter, false).Disabled = true;
-            Set(OsuConfig.ChatHighlightName, true).Disabled = true;
-            Set(OsuConfig.ChatMessageNotification, true).Disabled = true;
-            Set(OsuConfig.ChatLastChannel, string.Empty).Disabled = true;
-            Set(OsuConfig.ChatRemoveForeign, false).Disabled = true;
-            //Set(OsuConfig.ChatSortMode, UserSortMode.Rank).Disabled = true;
-            Set(OsuConfig.ComboBurst, true).Disabled = true;
-            Set(OsuConfig.ComboFire, false).Disabled = true;
-            Set(OsuConfig.ComboFireHeight, 3).Disabled = true;
-            Set(OsuConfig.ConfirmExit, false).Disabled = true;
-            Set(OsuConfig.AutoSendNowPlaying, true).Disabled = true;
-            Set(OsuConfig.AutomaticCursorSizing, false).Disabled = true;
-            Set(OsuConfig.Display, 1).Disabled = true;
-            Set(OsuConfig.DisplayCityLocation, false).Disabled = true;
-            Set(OsuConfig.DistanceSpacingEnabled, true).Disabled = true;
-            Set(OsuConfig.EditorTip, 0).Disabled = true;
-            Set(OsuConfig.VideoEditor, true).Disabled = true;
-            Set(OsuConfig.EditorDefaultSkin, false).Disabled = true;
-            Set(OsuConfig.EditorSnakingSliders, true).Disabled = true;
-            Set(OsuConfig.EditorHitAnimations, false).Disabled = true;
-            Set(OsuConfig.EditorFollowPoints, true).Disabled = true;
-            Set(OsuConfig.EditorStacking, true).Disabled = true;
-            Set(OsuConfig.ForceSliderRendering, false).Disabled = true;
-            Set(OsuConfig.FpsCounter, false).Disabled = true;
-            Set(OsuConfig.FrameTimeDisplay, false).Disabled = true;
-            Set(OsuConfig.GuideTips, @"").Disabled = true;
-            Set(OsuConfig.CursorRipple, false).Disabled = true;
-            Set(OsuConfig.HighlightWords, string.Empty).Disabled = true;
-            Set(OsuConfig.HighResolution, false).Disabled = true;
-            Set(OsuConfig.HitLighting, true).Disabled = true;
-            Set(OsuConfig.IgnoreBarline, false).Disabled = true;
-            Set(OsuConfig.IgnoreBeatmapSamples, false).Disabled = true;
-            Set(OsuConfig.IgnoreBeatmapSkins, false).Disabled = true;
-            Set(OsuConfig.IgnoreList, string.Empty).Disabled = true;
-            Set(OsuConfig.AllowNowPlayingHighlights, false).Disabled = true;
-            Set(OsuConfig.LastVersion, string.Empty).Disabled = true;
-            Set(OsuConfig.LastVersionPermissionsFailed, string.Empty).Disabled = true;
-            Set(OsuConfig.LoadSubmittedThread, true).Disabled = true;
-            Set(OsuConfig.LobbyPlayMode, -1).Disabled = true;
-            Set(OsuConfig.ShowInterfaceDuringRelax, false).Disabled = true;
-            Set(OsuConfig.LobbyShowExistingOnly, false).Disabled = true;
-            Set(OsuConfig.LobbyShowFriendsOnly, false).Disabled = true;
-            Set(OsuConfig.LobbyShowFull, false).Disabled = true;
-            Set(OsuConfig.LobbyShowInProgress, true).Disabled = true;
-            Set(OsuConfig.LobbyShowPassworded, true).Disabled = true;
-            Set(OsuConfig.LogPrivateMessages, false).Disabled = true;
-            Set(OsuConfig.LowResolution, false).Disabled = true;
-            //Set(OsuConfig.ManiaSpeed, SpeedMania.SPEED_DEFAULT, SpeedMania.SPEED_MIN, SpeedMania.SPEED_MAX).Disabled = true;
-            Set(OsuConfig.UsePerBeatmapManiaSpeed, true).Disabled = true;
-            Set(OsuConfig.ManiaSpeedBPMScale, true).Disabled = true;
-            Set(OsuConfig.MenuTip, 0).Disabled = true;
-            Set(OsuConfig.MouseSpeed, 1, 0.4, 6).Disabled = true;
-            Set(OsuConfig.ScoreMeterScale, 1, 0.5, 2).Disabled = true;
-            //Set(OsuConfig.ScoreMeterScale, 1, 0.5, OsuGame.Tournament ? 10 : 2).Disabled = true;
-            Set(OsuConfig.DistanceSpacing, 0.8, 0.1, 6).Disabled = true;
-            Set(OsuConfig.EditorBeatDivisor, 1, 1, 16).Disabled = true;
-            Set(OsuConfig.EditorGridSize, 32, 4, 32).Disabled = true;
-            Set(OsuConfig.EditorGridSizeDesign, 32, 4, 32).Disabled = true;
-            Set(OsuConfig.CustomFrameLimit, 240, 240, 999).Disabled = true;
-            Set(OsuConfig.MsnIntegration, false).Disabled = true;
-            Set(OsuConfig.MyPcSucks, false).Disabled = true;
-            Set(OsuConfig.NotifyFriends, true).Disabled = true;
-            Set(OsuConfig.NotifySubmittedThread, true).Disabled = true;
-            Set(OsuConfig.PopupDuringGameplay, true).Disabled = true;
-            Set(OsuConfig.ProgressBarType, ProgressBarType.Pie).Disabled = true;
-            Set(OsuConfig.RankType, RankingType.Top).Disabled = true;
-            Set(OsuConfig.RefreshRate, 60).Disabled = true;
-            Set(OsuConfig.OverrideRefreshRate, Get<int>(OsuConfig.RefreshRate) != 60).Disabled = true;
-            //Set(OsuConfig.ScaleMode, ScaleMode.WidescreenConservative).Disabled = true;
-            Set(OsuConfig.ScoreboardVisible, true).Disabled = true;
-            Set(OsuConfig.ScoreMeter, ScoreMeterType.Error).Disabled = true;
-            //Set(OsuConfig.ScoreMeter, OsuGame.Tournament ? ScoreMeterType.Colour : ScoreMeterType.Error).Disabled = true;
-            Set(OsuConfig.ScreenshotId, 0).Disabled = true;
-            Set(OsuConfig.MenuSnow, false).Disabled = true;
-            Set(OsuConfig.MenuTriangles, true).Disabled = true;
-            Set(OsuConfig.SongSelectThumbnails, true).Disabled = true;
-            Set(OsuConfig.ScreenshotFormat, ScreenshotFormat.Jpg).Disabled = true;
-            Set(OsuConfig.ShowReplayComments, true).Disabled = true;
-            Set(OsuConfig.ShowSpectators, true).Disabled = true;
-            Set(OsuConfig.ShowStoryboard, true).Disabled = true;
-            //Set(OsuConfig.Skin, SkinManager.DEFAULT_SKIN).Disabled = true;
-            Set(OsuConfig.SkinSamples, true).Disabled = true;
-            Set(OsuConfig.SkipTablet, false).Disabled = true;
-            Set(OsuConfig.Tablet, false).Disabled = true;
-            Set(OsuConfig.UpdatePending, false).Disabled = true;
-            Set(OsuConfig.UseSkinCursor, false).Disabled = true;
-            Set(OsuConfig.UseTaikoSkin, false).Disabled = true;
-            Set(OsuConfig.Video, true).Disabled = true;
-            Set(OsuConfig.Wiimote, false).Disabled = true;
-            Set(OsuConfig.YahooIntegration, false).Disabled = true;
-            Set(OsuConfig.ForceFrameFlush, false).Disabled = true;
-            Set(OsuConfig.DetectPerformanceIssues, true).Disabled = true;
-            Set(OsuConfig.RawInput, false).Disabled = true;
-            Set(OsuConfig.AbsoluteToOsuWindow, Get<bool>(OsuConfig.RawInput)).Disabled = true;
-            Set(OsuConfig.ShowMenuTips, true).Disabled = true;
-            Set(OsuConfig.HiddenShowFirstApproach, true).Disabled = true;
-            Set(OsuConfig.ComboColourSliderBall, true).Disabled = true;
-            Set(OsuConfig.AlternativeChatFont, false).Disabled = true;
-            Set(OsuConfig.DisplayStarsMaximum, 10.0, 0.0, 10.0).Disabled = true;
-            Set(OsuConfig.DisplayStarsMinimum, 0.0, 0.0, 10.0).Disabled = true;
-            Set(OsuConfig.ReleaseStream, ReleaseStream.Lazer).Disabled = true;
-            Set(OsuConfig.UpdateFailCount, 0).Disabled = true;
-            //Set(OsuConfig.TreeSortMode, TreeGroupMode.Show_All).Disabled = true;
-            //Set(OsuConfig.TreeSortMode2, TreeSortMode.Title).Disabled = true;
-            Set(OsuConfig.PermanentSongInfo, false).Disabled = true;
-            Set(OsuConfig.Ticker, false).Disabled = true;
-            Set(OsuConfig.CompatibilityContext, false).Disabled = true;
-            Set(OsuConfig.CanForceOptimusCompatibility, true).Disabled = true;
-            Set(OsuConfig.ConfineMouse, Get<bool>(OsuConfig.ConfineMouseToFullscreen) ?
-                ConfineMouseMode.Fullscreen : ConfineMouseMode.Never).Disabled = true;
-
-            GetOriginalBindable<bool>(OsuConfig.SavePassword).ValueChanged += delegate
+            Set(OsuSetting.SavePassword, false).ValueChanged += val =>
             {
-                if (Get<bool>(OsuConfig.SavePassword)) Set(OsuConfig.SaveUsername, true);
+                if (val) Set(OsuSetting.SaveUsername, true);
             };
-            GetOriginalBindable<bool>(OsuConfig.SaveUsername).ValueChanged += delegate
+
+            Set(OsuSetting.SaveUsername, true).ValueChanged += val =>
             {
-                if (!Get<bool>(OsuConfig.SaveUsername)) Set(OsuConfig.SavePassword, false);
+                if (!val) Set(OsuSetting.SavePassword, false);
             };
-#pragma warning restore CS0612 // Type or member is obsolete
+
+            // Audio
+
+            Set(OsuSetting.MenuVoice, true);
+            Set(OsuSetting.MenuMusic, true);
+
+            Set(OsuSetting.AudioOffset, 0, -500.0, 500.0);
+
+            // Input
+
+            Set(OsuSetting.MenuCursorSize, 1.0, 0.5f, 2);
+            Set(OsuSetting.GameplayCursorSize, 1.0, 0.5f, 2);
+            Set(OsuSetting.AutoCursorSize, false);
+
+            Set(OsuSetting.MouseDisableButtons, false);
+            Set(OsuSetting.MouseDisableWheel, false);
+
+            // Graphics
+
+            Set(OsuSetting.ShowFpsDisplay, false);
+
+            Set(OsuSetting.MenuParallax, true);
+
+            Set(OsuSetting.SnakingInSliders, true);
+            Set(OsuSetting.SnakingOutSliders, true);
+
+            // Gameplay
+
+            Set(OsuSetting.DimLevel, 0.3, 0, 1);
+
+            Set(OsuSetting.ShowInterface, true);
+            Set(OsuSetting.KeyOverlay, false);
+
+            // Update
+
+            Set(OsuSetting.ReleaseStream, ReleaseStream.Lazer);
         }
 
         public OsuConfigManager(Storage storage) : base(storage)
@@ -185,152 +79,32 @@ namespace osu.Game.Configuration
         }
     }
 
-    public enum OsuConfig
+    public enum OsuSetting
     {
-        // New osu:
         Ruleset,
         Token,
-        // Imported from old osu:
-        BeatmapDirectory,
-        AllowPublicInvites,
-        AutoChatHide,
-        AutomaticDownload,
-        AutomaticDownloadNoVideo,
-        BlockNonFriendPM,
-        Bloom,
-        BloomSoftening,
-        BossKeyFirstActivation,
-        ChatAudibleHighlight,
-        ChatChannels,
-        ChatFilter,
-        ChatHighlightName,
-        ChatMessageNotification,
-        ChatLastChannel,
-        ChatRemoveForeign,
-        ChatSortMode,
-        ComboBurst,
-        ComboFire,
-        ComboFireHeight,
-        ConfirmExit,
-        AutoSendNowPlaying,
         MenuCursorSize,
         GameplayCursorSize,
-        AutomaticCursorSizing,
+        AutoCursorSize,
         DimLevel,
-        Display,
-        DisplayCityLocation,
-        DistanceSpacingEnabled,
-        EditorTip,
-        VideoEditor,
-        EditorDefaultSkin,
-        EditorSnakingSliders,
-        EditorHitAnimations,
-        EditorFollowPoints,
-        EditorStacking,
-        ForceSliderRendering,
-        FpsCounter,
-        FrameTimeDisplay,
-        GuideTips,
-        CursorRipple,
-        HighlightWords,
-        HighResolution,
-        HitLighting,
-        IgnoreBarline,
-        IgnoreBeatmapSamples,
-        IgnoreBeatmapSkins,
-        IgnoreList,
         KeyOverlay,
-        Language,
-        LastPlayMode,
-        AllowNowPlayingHighlights,
-        LastVersion,
-        LastVersionPermissionsFailed,
-        LoadSubmittedThread,
-        LobbyPlayMode,
         ShowInterface,
-        ShowInterfaceDuringRelax,
-        LobbyShowExistingOnly,
-        LobbyShowFriendsOnly,
-        LobbyShowFull,
-        LobbyShowInProgress,
-        LobbyShowPassworded,
-        LogPrivateMessages,
-        LowResolution,
-        ManiaSpeed,
-        UsePerBeatmapManiaSpeed,
-        ManiaSpeedBPMScale,
-        MenuTip,
         MouseDisableButtons,
         MouseDisableWheel,
-        MouseSpeed,
         AudioOffset,
-        ScoreMeterScale,
-        DistanceSpacing,
-        EditorBeatDivisor,
-        EditorGridSize,
-        EditorGridSizeDesign,
-        CustomFrameLimit,
-        MsnIntegration,
-        MyPcSucks,
-        NotifyFriends,
-        NotifySubmittedThread,
-        PopupDuringGameplay,
-        ProgressBarType,
-        RankType,
-        RefreshRate,
-        OverrideRefreshRate,
-        ScaleMode,
-        ScoreboardVisible,
-        ScoreMeter,
-        ScreenshotId,
-        MenuSnow,
-        MenuTriangles,
-        SongSelectThumbnails,
-        ScreenshotFormat,
-        ShowReplayComments,
-        ShowSpectators,
-        ShowStoryboard,
-        Skin,
-        SkinSamples,
-        SkipTablet,
-        SnakingInSliders,
-        SnakingOutSliders,
-        Tablet,
-        UpdatePending,
-        UserFilter,
-        UseSkinCursor,
-        UseTaikoSkin,
-        Video,
-        Wiimote,
-        YahooIntegration,
-        ForceFrameFlush,
-        DetectPerformanceIssues,
         MenuMusic,
         MenuVoice,
         MenuParallax,
         BeatmapDetailTab,
-        RawInput,
-        AbsoluteToOsuWindow,
-        ConfineMouse,
-        [Obsolete]
-        ConfineMouseToFullscreen,
-        ShowMenuTips,
-        HiddenShowFirstApproach,
-        ComboColourSliderBall,
-        AlternativeChatFont,
         Username,
-        DisplayStarsMaximum,
-        DisplayStarsMinimum,
-        AudioDevice,
         ReleaseStream,
-        UpdateFailCount,
         SavePassword,
         SaveUsername,
-        TreeSortMode,
-        TreeSortMode2,
-        PermanentSongInfo,
-        Ticker,
-        CompatibilityContext,
-        CanForceOptimusCompatibility,
+        DisplayStarsMinimum,
+        DisplayStarsMaximum,
+        SnakingInSliders,
+        SnakingOutSliders,
+        ShowFpsDisplay,
+        ChatDisplayHeight
     }
 }

osu.Game/Configuration/ProgressBarType.cs

@@ -1,18 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System.ComponentModel;
-
-namespace osu.Game.Configuration
-{
-    public enum ProgressBarType
-    {
-        Off,
-        Pie,
-        [Description("Top Right")]
-        TopRight,
-        [Description("Bottom Right")]
-        BottomRight,
-        Bottom
-    }
-}

osu.Game/Database/BeatmapDatabase.cs

@@ -36,14 +36,12 @@ namespace osu.Game.Database
 
         private void deletePending()
         {
-            foreach (var b in Query<BeatmapSetInfo>().Where(b => b.DeletePending))
+            foreach (var b in GetAllWithChildren<BeatmapSetInfo>(b => b.DeletePending))
             {
                 try
                 {
                     Storage.Delete(b.Path);
 
-                    GetChildren(b, true);
-
                     foreach (var i in b.Beatmaps)
                     {
                         if (i.Metadata != null) Connection.Delete(i.Metadata);
@@ -269,20 +267,16 @@ namespace osu.Game.Database
 
         public WorkingBeatmap GetWorkingBeatmap(BeatmapInfo beatmapInfo, WorkingBeatmap previous = null, bool withStoryboard = false)
         {
-            var beatmapSetInfo = Query<BeatmapSetInfo>().FirstOrDefault(s => s.ID == beatmapInfo.BeatmapSetInfoID);
+            if (beatmapInfo.BeatmapSet == null || beatmapInfo.Ruleset == null)
+                beatmapInfo = GetChildren(beatmapInfo, true);
 
-            if (beatmapSetInfo == null)
+            if (beatmapInfo.BeatmapSet == null)
                 throw new InvalidOperationException($@"Beatmap set {beatmapInfo.BeatmapSetInfoID} is not in the local database.");
 
-            //we need metadata
-            GetChildren(beatmapSetInfo);
-            //we also need a ruleset
-            GetChildren(beatmapInfo);
-
             if (beatmapInfo.Metadata == null)
-                beatmapInfo.Metadata = beatmapSetInfo.Metadata;
+                beatmapInfo.Metadata = beatmapInfo.BeatmapSet.Metadata;
 
-            WorkingBeatmap working = new DatabaseWorkingBeatmap(this, beatmapInfo, beatmapSetInfo, withStoryboard);
+            WorkingBeatmap working = new DatabaseWorkingBeatmap(this, beatmapInfo, withStoryboard);
 
             previous?.TransferTo(working);
 

osu.Game/Database/BeatmapDifficulty.cs

@@ -7,12 +7,17 @@ namespace osu.Game.Database
 {
     public class BeatmapDifficulty
     {
+        /// <summary>
+        /// The default value used for all difficulty settings except <see cref="SliderMultiplier"/> and <see cref="SliderTickRate"/>.
+        /// </summary>
+        public const float DEFAULT_DIFFICULTY = 5;
+
         [PrimaryKey, AutoIncrement]
         public int ID { get; set; }
-        public float DrainRate { get; set; } = 5;
-        public float CircleSize { get; set; } = 5;
-        public float OverallDifficulty { get; set; } = 5;
-        public float ApproachRate { get; set; } = 5;
+        public float DrainRate { get; set; } = DEFAULT_DIFFICULTY;
+        public float CircleSize { get; set; } = DEFAULT_DIFFICULTY;
+        public float OverallDifficulty { get; set; } = DEFAULT_DIFFICULTY;
+        public float ApproachRate { get; set; } = DEFAULT_DIFFICULTY;
         public float SliderMultiplier { get; set; } = 1;
         public float SliderTickRate { get; set; } = 1;
 

osu.Game/Database/BeatmapMetadata.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 SQLite.Net.Attributes;
 
 namespace osu.Game.Database
@@ -22,5 +23,15 @@ namespace osu.Game.Database
         public int PreviewTime { get; set; }
         public string AudioFile { get; set; }
         public string BackgroundFile { get; set; }
+
+        public string[] SearchableTerms => new[]
+        {
+            Artist,
+            ArtistUnicode,
+            Title,
+            TitleUnicode,
+            Source,
+            Tags
+        }.Where(s => !string.IsNullOrEmpty(s)).ToArray();
     }
 }

osu.Game/Database/Database.cs

@@ -48,11 +48,9 @@ namespace osu.Game.Database
             return Connection.Table<T>();
         }
 
-        public T GetWithChildren<T>(object id) where T : class
-        {
-            return Connection.GetWithChildren<T>(id);
-        }
-
+        /// <summary>
+        /// This is expensive. Use with caution.
+        /// </summary>
         public List<T> GetAllWithChildren<T>(Expression<Func<T, bool>> filter = null, bool recursive = true)
             where T : class
         {

osu.Game/Database/DatabaseWorkingBeatmap.cs

@@ -14,8 +14,8 @@ namespace osu.Game.Database
     {
         private readonly BeatmapDatabase database;
 
-        public DatabaseWorkingBeatmap(BeatmapDatabase database, BeatmapInfo beatmapInfo, BeatmapSetInfo beatmapSetInfo, bool withStoryboard = false)
-            : base(beatmapInfo, beatmapSetInfo, withStoryboard)
+        public DatabaseWorkingBeatmap(BeatmapDatabase database, BeatmapInfo beatmapInfo, bool withStoryboard = false)
+            : base(beatmapInfo, withStoryboard)
         {
             this.database = database;
         }
@@ -51,13 +51,13 @@ namespace osu.Game.Database
 
         protected override Texture GetBackground()
         {
-            if (BeatmapInfo?.Metadata?.BackgroundFile == null)
+            if (Metadata?.BackgroundFile == null)
                 return null;
 
             try
             {
                 using (var reader = getReader())
-                    return new TextureStore(new RawTextureLoaderStore(reader), false).Get(BeatmapInfo.Metadata.BackgroundFile);
+                    return new TextureStore(new RawTextureLoaderStore(reader), false).Get(Metadata.BackgroundFile);
             }
             catch { return null; }
         }
@@ -66,7 +66,7 @@ namespace osu.Game.Database
         {
             try
             {
-                var trackData = getReader()?.GetStream(BeatmapInfo.Metadata.AudioFile);
+                var trackData = getReader()?.GetStream(Metadata.AudioFile);
                 return trackData == null ? null : new TrackBass(trackData);
             }
             catch { return null; }

osu.Game/Database/ScoreDatabase.cs

@@ -94,13 +94,13 @@ namespace osu.Game.Database
                 {
                     byte[] properties = new byte[5];
                     if (replayInStream.Read(properties, 0, 5) != 5)
-                        throw new Exception("input .lzma is too short");
+                        throw new IOException("input .lzma is too short");
                     long outSize = 0;
                     for (int i = 0; i < 8; i++)
                     {
                         int v = replayInStream.ReadByte();
                         if (v < 0)
-                            throw new Exception("Can't Read 1");
+                            throw new IOException("Can't Read 1");
                         outSize |= (long)(byte)v << (8 * i);
                     }
 

osu.Game/Graphics/Containers/ParallaxContainer.cs

@@ -39,7 +39,7 @@ namespace osu.Game.Graphics.Containers
         private void load(UserInputManager input, OsuConfigManager config)
         {
             this.input = input;
-            parallaxEnabled = config.GetBindable<bool>(OsuConfig.MenuParallax);
+            parallaxEnabled = config.GetBindable<bool>(OsuSetting.MenuParallax);
             parallaxEnabled.ValueChanged += delegate
             {
                 if (!parallaxEnabled)

osu.Game/Graphics/Cursor/CursorTrail.cs

@@ -14,6 +14,7 @@ using OpenTK.Graphics.ES30;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Timing;
+using System.Diagnostics;
 
 namespace osu.Game.Graphics.Cursor
 {
@@ -39,6 +40,8 @@ namespace osu.Game.Graphics.Cursor
 
         private Vector2? lastPosition;
 
+        private readonly InputResampler resampler = new InputResampler();
+
         protected override DrawNode CreateDrawNode() => new TrailDrawNode();
 
         protected override void ApplyDrawNode(DrawNode node)
@@ -75,7 +78,7 @@ namespace osu.Game.Graphics.Cursor
         [BackgroundDependencyLoader]
         private void load(ShaderManager shaders, TextureStore textures)
         {
-            shader = shaders?.Load(@"CursorTrail", FragmentShaderDescriptor.Texture);
+            shader = shaders?.Load(@"CursorTrail", FragmentShaderDescriptor.TEXTURE);
             texture = textures.Get(@"Cursor/cursortrail");
             Scale = new Vector2(1 / texture.ScaleAdjust);
         }
@@ -116,22 +119,26 @@ namespace osu.Game.Graphics.Cursor
             if (lastPosition == null)
             {
                 lastPosition = state.Mouse.NativeState.Position;
+                resampler.AddPosition(lastPosition.Value);
                 return base.OnMouseMove(state);
             }
 
-            Vector2 pos1 = lastPosition.Value;
-            Vector2 pos2 = state.Mouse.NativeState.Position;
-
-            Vector2 diff = pos2 - pos1;
-            float distance = diff.Length;
-            Vector2 direction = diff / distance;
-
-            float interval = size.X / 2 * 0.9f;
-
-            for (float d = interval; d < distance; d += interval)
+            foreach (Vector2 pos2 in resampler.AddPosition(state.Mouse.NativeState.Position))
             {
-                lastPosition = pos1 + direction * d;
-                addPosition(lastPosition.Value);
+                Trace.Assert(lastPosition.HasValue);
+
+                Vector2 pos1 = lastPosition.Value;
+                Vector2 diff = pos2 - pos1;
+                float distance = diff.Length;
+                Vector2 direction = diff / distance;
+
+                float interval = size.X / 2 * 0.9f;
+
+                for (float d = interval; d < distance; d += interval)
+                {
+                    lastPosition = pos1 + direction * d;
+                    addPosition(lastPosition.Value);
+                }
             }
 
             return base.OnMouseMove(state);

osu.Game/Graphics/Cursor/GameplayCursor.cs

@@ -11,7 +11,9 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input;
+using osu.Game.Beatmaps;
 using osu.Game.Configuration;
+using osu.Game.Database;
 
 namespace osu.Game.Graphics.Cursor
 {
@@ -41,7 +43,10 @@ namespace osu.Game.Graphics.Cursor
         public class OsuCursor : Container
         {
             private Container cursorContainer;
+
             private Bindable<double> cursorScale;
+            private Bindable<bool> autoCursorScale;
+            private Bindable<WorkingBeatmap> beatmap;
 
             public OsuCursor()
             {
@@ -50,7 +55,7 @@ namespace osu.Game.Graphics.Cursor
             }
 
             [BackgroundDependencyLoader]
-            private void load(OsuConfigManager config)
+            private void load(OsuConfigManager config, OsuGameBase game)
             {
                 Children = new Drawable[]
                 {
@@ -114,9 +119,29 @@ namespace osu.Game.Graphics.Cursor
                     },
                 };
 
-                cursorScale = config.GetBindable<double>(OsuConfig.GameplayCursorSize);
-                cursorScale.ValueChanged += newScale => cursorContainer.Scale = new Vector2((float)cursorScale);
-                cursorScale.TriggerChange();
+                beatmap = game.Beatmap.GetBoundCopy();
+                beatmap.ValueChanged += v => calculateScale();
+
+                cursorScale = config.GetBindable<double>(OsuSetting.GameplayCursorSize);
+                cursorScale.ValueChanged += v => calculateScale();
+
+                autoCursorScale = config.GetBindable<bool>(OsuSetting.AutoCursorSize);
+                autoCursorScale.ValueChanged += v => calculateScale();
+
+                calculateScale();
+            }
+
+            private void calculateScale()
+            {
+                float scale = (float)cursorScale.Value;
+
+                if (autoCursorScale && beatmap.Value != null)
+                {
+                    // if we have a beatmap available, let's get its circle size to figure out an automatic cursor scale modifier.
+                    scale *= (float)(1 - 0.7 * (1 + beatmap.Value.BeatmapInfo.Difficulty.CircleSize - BeatmapDifficulty.DEFAULT_DIFFICULTY) / BeatmapDifficulty.DEFAULT_DIFFICULTY);
+                }
+
+                cursorContainer.Scale = new Vector2(scale);
             }
         }
     }

osu.Game/Graphics/Cursor/MenuCursor.cs

@@ -128,7 +128,7 @@ namespace osu.Game.Graphics.Cursor
                     }
                 };
 
-                cursorScale = config.GetBindable<double>(OsuConfig.MenuCursorSize);
+                cursorScale = config.GetBindable<double>(OsuSetting.MenuCursorSize);
                 cursorScale.ValueChanged += newScale => cursorContainer.Scale = new Vector2((float)newScale);
                 cursorScale.TriggerChange();
             }

osu.Game/Graphics/Cursor/TooltipContainer.cs

@@ -8,7 +8,6 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
-using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input;
 using osu.Framework.Threading;

osu.Game/Graphics/OsuColour.cs

@@ -16,7 +16,7 @@ namespace osu.Game.Graphics
             switch (hex.Length)
             {
                 default:
-                    throw new Exception(@"Invalid hex string length!");
+                    throw new ArgumentException(@"Invalid hex string length!");
                 case 3:
                     return new Color4(
                         (byte)(Convert.ToByte(hex.Substring(0, 1), 16) * 17),
@@ -33,57 +33,62 @@ namespace osu.Game.Graphics
         }
 
         // See https://github.com/ppy/osu-web/blob/master/resources/assets/less/colors.less
-        public Color4 PurpleLighter = FromHex(@"eeeeff");
-        public Color4 PurpleLight = FromHex(@"aa88ff");
-        public Color4 Purple = FromHex(@"8866ee");
-        public Color4 PurpleDark = FromHex(@"6644cc");
-        public Color4 PurpleDarker = FromHex(@"441188");
+        public readonly Color4 PurpleLighter = FromHex(@"eeeeff");
+        public readonly Color4 PurpleLight = FromHex(@"aa88ff");
+        public readonly Color4 Purple = FromHex(@"8866ee");
+        public readonly Color4 PurpleDark = FromHex(@"6644cc");
+        public readonly Color4 PurpleDarker = FromHex(@"441188");
 
-        public Color4 PinkLighter = FromHex(@"ffddee");
-        public Color4 PinkLight = FromHex(@"ff99cc");
-        public Color4 Pink = FromHex(@"ff66aa");
-        public Color4 PinkDark = FromHex(@"cc5288");
-        public Color4 PinkDarker = FromHex(@"bb1177");
+        public readonly Color4 PinkLighter = FromHex(@"ffddee");
+        public readonly Color4 PinkLight = FromHex(@"ff99cc");
+        public readonly Color4 Pink = FromHex(@"ff66aa");
+        public readonly Color4 PinkDark = FromHex(@"cc5288");
+        public readonly Color4 PinkDarker = FromHex(@"bb1177");
 
-        public Color4 BlueLighter = FromHex(@"ddffff");
-        public Color4 BlueLight = FromHex(@"99eeff");
-        public Color4 Blue = FromHex(@"66ccff");
-        public Color4 BlueDark = FromHex(@"44aadd");
-        public Color4 BlueDarker = FromHex(@"2299bb");
+        public readonly Color4 BlueLighter = FromHex(@"ddffff");
+        public readonly Color4 BlueLight = FromHex(@"99eeff");
+        public readonly Color4 Blue = FromHex(@"66ccff");
+        public readonly Color4 BlueDark = FromHex(@"44aadd");
+        public readonly Color4 BlueDarker = FromHex(@"2299bb");
 
-        public Color4 YellowLighter = FromHex(@"ffffdd");
-        public Color4 YellowLight = FromHex(@"ffdd55");
-        public Color4 Yellow = FromHex(@"ffcc22");
-        public Color4 YellowDark = FromHex(@"eeaa00");
-        public Color4 YellowDarker = FromHex(@"cc6600");
+        public readonly Color4 YellowLighter = FromHex(@"ffffdd");
+        public readonly Color4 YellowLight = FromHex(@"ffdd55");
+        public readonly Color4 Yellow = FromHex(@"ffcc22");
+        public readonly Color4 YellowDark = FromHex(@"eeaa00");
+        public readonly Color4 YellowDarker = FromHex(@"cc6600");
 
-        public Color4 GreenLighter = FromHex(@"eeffcc");
-        public Color4 GreenLight = FromHex(@"b3d944");
-        public Color4 Green = FromHex(@"88b300");
-        public Color4 GreenDark = FromHex(@"668800");
-        public Color4 GreenDarker = FromHex(@"445500");
+        public readonly Color4 GreenLighter = FromHex(@"eeffcc");
+        public readonly Color4 GreenLight = FromHex(@"b3d944");
+        public readonly Color4 Green = FromHex(@"88b300");
+        public readonly Color4 GreenDark = FromHex(@"668800");
+        public readonly Color4 GreenDarker = FromHex(@"445500");
 
-        public Color4 Gray0 = FromHex(@"000");
-        public Color4 Gray1 = FromHex(@"111");
-        public Color4 Gray2 = FromHex(@"222");
-        public Color4 Gray3 = FromHex(@"333");
-        public Color4 Gray4 = FromHex(@"444");
-        public Color4 Gray5 = FromHex(@"555");
-        public Color4 Gray6 = FromHex(@"666");
-        public Color4 Gray7 = FromHex(@"777");
-        public Color4 Gray8 = FromHex(@"888");
-        public Color4 Gray9 = FromHex(@"999");
-        public Color4 GrayA = FromHex(@"aaa");
-        public Color4 GrayB = FromHex(@"bbb");
-        public Color4 GrayC = FromHex(@"ccc");
-        public Color4 GrayD = FromHex(@"ddd");
-        public Color4 GrayE = FromHex(@"eee");
-        public Color4 GrayF = FromHex(@"fff");
+        public readonly Color4 Gray0 = FromHex(@"000");
+        public readonly Color4 Gray1 = FromHex(@"111");
+        public readonly Color4 Gray2 = FromHex(@"222");
+        public readonly Color4 Gray3 = FromHex(@"333");
+        public readonly Color4 Gray4 = FromHex(@"444");
+        public readonly Color4 Gray5 = FromHex(@"555");
+        public readonly Color4 Gray6 = FromHex(@"666");
+        public readonly Color4 Gray7 = FromHex(@"777");
+        public readonly Color4 Gray8 = FromHex(@"888");
+        public readonly Color4 Gray9 = FromHex(@"999");
+        public readonly Color4 GrayA = FromHex(@"aaa");
+        public readonly Color4 GrayB = FromHex(@"bbb");
+        public readonly Color4 GrayC = FromHex(@"ccc");
+        public readonly Color4 GrayD = FromHex(@"ddd");
+        public readonly Color4 GrayE = FromHex(@"eee");
+        public readonly Color4 GrayF = FromHex(@"fff");
 
-        public Color4 RedLighter = FromHex(@"ffeded");
-        public Color4 RedLight = FromHex(@"ed7787");
-        public Color4 Red = FromHex(@"ed1121");
-        public Color4 RedDark = FromHex(@"ba0011");
-        public Color4 RedDarker = FromHex(@"870000");
+        public readonly Color4 RedLighter = FromHex(@"ffeded");
+        public readonly Color4 RedLight = FromHex(@"ed7787");
+        public readonly Color4 Red = FromHex(@"ed1121");
+        public readonly Color4 RedDark = FromHex(@"ba0011");
+        public readonly Color4 RedDarker = FromHex(@"870000");
+
+        public readonly Color4 ChatBlue = FromHex(@"17292e");
+
+        public readonly Color4 SpinnerBase = FromHex(@"002c3c");
+        public readonly Color4 SpinnerFill = FromHex(@"005b7c");
     }
 }

osu.Game/Graphics/UserInterface/OsuCheckbox.cs

@@ -6,7 +6,6 @@ using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input;

osu.Game/Graphics/UserInterface/OsuDropdown.cs

@@ -7,7 +7,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Game.Graphics.Sprites;

osu.Game/Graphics/UserInterface/OsuMenu.cs

@@ -5,7 +5,6 @@ using OpenTK;
 using OpenTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.UserInterface;
 
 namespace osu.Game.Graphics.UserInterface

osu.Game/Graphics/UserInterface/OsuSliderBar.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;
 using OpenTK;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
@@ -13,7 +14,8 @@ using osu.Framework.Input;
 
 namespace osu.Game.Graphics.UserInterface
 {
-    public class OsuSliderBar<T> : SliderBar<T>, IHasTooltip where T : struct
+    public class OsuSliderBar<T> : SliderBar<T>, IHasTooltip
+        where T : struct, IEquatable<T>
     {
         private SampleChannel sample;
         private double lastSampleTime;

osu.Game/Graphics/UserInterface/OsuTabControl.cs

@@ -9,7 +9,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Extensions;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input;
@@ -25,15 +24,15 @@ namespace osu.Game.Graphics.UserInterface
 
         protected override bool InternalContains(Vector2 screenSpacePos) => base.InternalContains(screenSpacePos) || Dropdown.Contains(screenSpacePos);
 
+        private bool isEnumType => typeof(T).IsEnum;
+
         public OsuTabControl()
         {
             TabContainer.Spacing = new Vector2(10f, 0f);
 
-            if (!typeof(T).IsEnum)
-                throw new InvalidOperationException("OsuTabControl only supports enums as the generic type argument");
-
-            foreach (var val in (T[])Enum.GetValues(typeof(T)))
-                AddItem(val);
+            if (isEnumType)
+                foreach (var val in (T[])Enum.GetValues(typeof(T)))
+                    AddItem(val);
         }
 
         [BackgroundDependencyLoader]
@@ -136,7 +135,7 @@ namespace osu.Game.Graphics.UserInterface
                         Margin = new MarginPadding { Top = 5, Bottom = 5 },
                         Origin = Anchor.BottomLeft,
                         Anchor = Anchor.BottomLeft,
-                        Text = (value as Enum)?.GetDescription(),
+                        Text = (value as Enum)?.GetDescription() ?? value.ToString(),
                         TextSize = 14,
                         Font = @"Exo2.0-Bold", // Font should only turn bold when active?
                     },

osu.Game/Graphics/UserInterface/OsuTabControlCheckbox.cs

@@ -6,7 +6,6 @@ using OpenTK.Graphics;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input;

osu.Game/Graphics/UserInterface/OsuTextBox.cs

@@ -3,7 +3,6 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input;

osu.Game/Graphics/UserInterface/RollingCounter.cs

@@ -181,7 +181,7 @@ namespace osu.Game.Graphics.UserInterface
         protected virtual void TransformCount(T currentValue, T newValue)
         {
             Debug.Assert(
-                TransformType.IsSubclassOf(typeof(Transform<T>)) || TransformType == typeof(Transform<T>),
+                typeof(Transform<T>).IsAssignableFrom(TransformType),
                 @"transformType should be a subclass of Transform<T>."
             );
 

osu.Game/Graphics/UserInterface/SearchTextBox.cs

@@ -1,20 +1,19 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK.Input;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Primitives;
 using osu.Framework.Input;
-using osu.Game.Graphics;
-using osu.Game.Graphics.UserInterface;
+using OpenTK.Input;
 
-namespace osu.Game.Screens.Select
+namespace osu.Game.Graphics.UserInterface
 {
     /// <summary>
     /// A textbox which holds focus eagerly.
     /// </summary>
     public class SearchTextBox : FocusedTextBox
     {
+        protected virtual bool AllowCommit => false;
+
         public SearchTextBox()
         {
             Height = 35;
@@ -45,8 +44,10 @@ namespace osu.Game.Screens.Select
                     case Key.Right:
                     case Key.Up:
                     case Key.Down:
-                    case Key.Enter:
                         return false;
+                    case Key.Enter:
+                        if (!AllowCommit) return false;
+                        break;
                 }
             }
 

osu.Game/Graphics/UserInterface/TwoLayerButton.cs

@@ -216,6 +216,11 @@ namespace osu.Game.Graphics.UserInterface
                 });
         }
 
+        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        {
+            return true;
+        }
+
         protected override bool OnClick(InputState state)
         {
             var flash = new Box

osu.Game/Graphics/UserInterface/Volume/VolumeControl.cs

@@ -6,7 +6,6 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Input;
 using osu.Framework.Threading;
 using OpenTK;
-using osu.Framework.Graphics.Primitives;
 using osu.Framework.Audio;
 using osu.Framework.Allocation;
 

osu.Game/IO/Legacy/SerializationReader.cs

@@ -10,7 +10,6 @@ using System.Runtime.Serialization;
 using System.Runtime.Serialization.Formatters;
 using System.Runtime.Serialization.Formatters.Binary;
 using System.Text;
-using System.Threading;
 
 namespace osu.Game.IO.Legacy
 {
@@ -66,7 +65,7 @@ namespace osu.Game.IO.Legacy
         public DateTime ReadDateTime()
         {
             long ticks = ReadInt64();
-            if (ticks < 0) throw new AbandonedMutexException("oops");
+            if (ticks < 0) throw new IOException("Bad ticks count read!");
             return new DateTime(ticks, DateTimeKind.Utc);
         }
 

osu.Game/IO/Serialization/IJsonSerializable.cs

@@ -16,12 +16,13 @@ namespace osu.Game.IO.Serialization
             return JsonConvert.SerializeObject(obj);
         }
 
-        public static T Deserialize<T>(string objString)
+        public static T Deserialize<T>(this string objString)
         {
             return JsonConvert.DeserializeObject<T>(objString);
         }
 
-        public static T DeepClone<T>(this IJsonSerializable obj)
+        public static T DeepClone<T>(this T obj)
+            where T : IJsonSerializable
         {
             return Deserialize<T>(Serialize(obj));
         }

osu.Game/Input/GlobalHotkeys.cs

@@ -1,26 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System;
-using osu.Framework.Graphics;
-using osu.Framework.Input;
-
-namespace osu.Game.Input
-{
-    public class GlobalHotkeys : Drawable
-    {
-        public Func<InputState, KeyDownEventArgs, bool> Handler;
-
-        public override bool HandleInput => true;
-
-        public GlobalHotkeys()
-        {
-            RelativeSizeAxes = Axes.Both;
-        }
-
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
-        {
-            return Handler(state, args);
-        }
-    }
-}

osu.Game/Online/API/APIAccess.cs

@@ -20,7 +20,7 @@ namespace osu.Game.Online.API
     {
         private readonly OAuth authentication;
 
-        public string Endpoint = @"https://new.ppy.sh";
+        public string Endpoint = @"https://osu.ppy.sh";
         private const string client_id = @"5";
         private const string client_secret = @"FGc9GAtyHzeQDshWP5Ah7dega8hJACAJpQtw6OXk";
 
@@ -34,7 +34,7 @@ namespace osu.Game.Online.API
 
         public string Password;
 
-        public Bindable<User> LocalUser = new Bindable<User>();
+        public Bindable<User> LocalUser = new Bindable<User>(createGuestUser());
 
         public string Token
         {
@@ -191,7 +191,7 @@ namespace osu.Game.Online.API
                 req.Perform(this);
 
                 //we could still be in initialisation, at which point we don't want to say we're Online yet.
-                if (LocalUser.Value != null)
+                if (IsLoggedIn)
                     State = APIState.Online;
 
                 failureCount = 0;
@@ -266,6 +266,8 @@ namespace osu.Game.Online.API
             }
         }
 
+        public bool IsLoggedIn => LocalUser.Value.Id > 1;
+
         public void Queue(APIRequest request)
         {
             queue.Enqueue(request);
@@ -295,8 +297,15 @@ namespace osu.Game.Online.API
             clearCredentials();
             authentication.Clear();
             State = APIState.Offline;
+            LocalUser.Value = createGuestUser();
         }
 
+        private static User createGuestUser() => new User
+        {
+            Username = @"Guest",
+            Id = 1,
+        };
+
         public void Update()
         {
             Scheduler.Update();