Merge pull request #922 from nairaner/unix-nuget-issue

Fix unix nuget issue

.vscode/launch.json

@@ -2,35 +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"
+            },
             "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,21 +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": [
-                // Ask msbuild to generate full paths for file names.
-                "/property:GenerateFullPaths=true"
-            ],
-            // Use the standard MS compiler pattern to detect errors, warnings and infos
-            "problemMatcher": "$msCompile",
+            "taskName": "Build (Debug)",
             "isBuildCommand": true
+        },
+        {
+            "taskName": "Build (Release)",
+            "args": [
+                "/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,10 +1,6 @@
-# osu! [![Build status](https://ci.appveyor.com/api/projects/status/u2p01nx7l6og8buh?svg=true)](https://ci.appveyor.com/project/peppy/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
 
@@ -12,14 +8,14 @@ This is still heavily under development and is not intended for end-user use. Th
 
 # Requirements
 
-- A desktop platform which can compile .NET 4.5.
-- Visual Studio or MonoDevelop is recommended.
+- A desktop platform which can compile .NET 4.5 (tested on macOS, linux and windows). We recommend using [Visual Studio Code](https://code.visualstudio.com/) (all platforms) or [Visual Studio Community Edition](https://www.visualstudio.com/) (windows only), both of which are free.
+- Make sure you initialise and keep submodules up-to-date.
 
 # Contributing
 
 We welcome all contributions, but keep in mind that we already have a lot of the UI designed. If you wish to work on something with the intention on having it included in the official distribution, please open an issue for discussion and we will give you what you need from a design perspective to proceed. If you want to make *changes* to the design, we recommend you open an issue with your intentions before spending too much time, to ensure no effort is wasted.
 
-Contributions can be made via pull requests to this repository. We hope to credit and reward larger contributions via a [bounty system](https://goo.gl/nFdoyI). If you're unsure of what you can help with, check out the [list](https://github.com/ppy/osu/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen+label%3Abounty) of available issues with bounty.
+Contributions can be made via pull requests to this repository. We hope to credit and reward larger contributions via a [bounty system](https://www.bountysource.com/teams/ppy). If you're unsure of what you can help with, check out the [list of open issues](https://github.com/ppy/osu-framework/issues).
 
 Note that while we already have certain standards in place, nothing is set in stone. If you have an issue with the way code is structured; with any libraries we are using; with any processes involved with contributing, *please* bring it up. I welcome all feedback so we can make contributing to this project as pain-free as possible.
 

appveyor.yml

@@ -20,4 +20,4 @@ build:
   verbosity: minimal
 after_build:
   - cmd: inspectcode /o="inspectcodereport.xml" /caches-home="inspectcode" osu.sln
-  - cmd: NVika parsereport "inspectcodereport.xml"
+  - cmd: NVika parsereport "inspectcodereport.xml" --treatwarningsaserrors

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;
@@ -42,7 +41,7 @@ namespace osu.Desktop.VisualTests.Tests
                     StarDifficulty = 5.3f,
                     Metrics = new BeatmapMetrics
                     {
-                        Ratings = Enumerable.Range(0,10),
+                        Ratings = Enumerable.Range(0, 10),
                         Fails = Enumerable.Range(lastRange, 100).Select(i => i % 12 - 6),
                         Retries = Enumerable.Range(lastRange - 3, 100).Select(i => i % 12 - 6),
                     },

osu.Desktop.VisualTests/Tests/TestCaseBreadcrumbs.cs

@@ -0,0 +1,39 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Testing;
+using osu.Game.Graphics.UserInterface;
+using osu.Framework.Graphics;
+
+namespace osu.Desktop.VisualTests.Tests
+{
+    internal class TestCaseBreadcrumbs : TestCase
+    {
+        public override string Description => @"breadcrumb > control";
+
+        public override void Reset()
+        {
+            base.Reset();
+
+            BreadcrumbControl<BreadcrumbTab> c;
+            Add(c = new BreadcrumbControl<BreadcrumbTab>
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.X,
+                Width = 0.5f,
+            });
+
+            AddStep(@"first", () => c.Current.Value = BreadcrumbTab.Click);
+            AddStep(@"second", () => c.Current.Value = BreadcrumbTab.The);
+            AddStep(@"third", () => c.Current.Value = BreadcrumbTab.Circles);
+        }
+
+        private enum BreadcrumbTab
+        {
+            Click,
+            The,
+            Circles,
+        }
+    }
+}

osu.Desktop.VisualTests/Tests/TestCaseDirect.cs

@@ -0,0 +1,199 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Testing;
+using osu.Game.Database;
+using osu.Game.Overlays;
+
+namespace osu.Desktop.VisualTests.Tests
+{
+    public class TestCaseDirect : TestCase
+    {
+        public override string Description => @"osu!direct overlay";
+
+        private DirectOverlay direct;
+        private RulesetDatabase rulesets;
+
+        public override void Reset()
+        {
+            base.Reset();
+
+            Add(direct = new DirectOverlay());
+            newBeatmaps();
+
+            AddStep(@"toggle", direct.ToggleVisibility);
+            AddStep(@"result counts", () => direct.ResultAmounts = new DirectOverlay.ResultCounts(1, 4, 13));
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(RulesetDatabase rulesets)
+        {
+            this.rulesets = rulesets;
+        }
+
+        private void newBeatmaps()
+        {
+            var ruleset = rulesets.GetRuleset(0);
+
+            direct.BeatmapSets = new[]
+            {
+                new BeatmapSetInfo
+                {
+                    Metadata = new BeatmapMetadata
+                    {
+                        Title = @"OrVid",
+                        Artist = @"An",
+                        Author = @"RLC",
+                        Source = @"",
+                    },
+                    Beatmaps = new List<BeatmapInfo>
+                    {
+                        new BeatmapInfo
+                        {
+                            Ruleset = ruleset,
+                            StarDifficulty = 5.35f,
+                            Metadata = new BeatmapMetadata(),
+                            OnlineInfo = new BeatmapOnlineInfo
+                            {
+                                Covers = new[] { @"https://assets.ppy.sh//beatmaps/578332/covers/cover.jpg?1494591390" },
+                                Preview = @"https://b.ppy.sh/preview/578332.mp3",
+                                PlayCount = 97,
+                                FavouriteCount = 72,
+                            },
+                        },
+                    },
+                },
+                new BeatmapSetInfo
+                {
+                    Metadata = new BeatmapMetadata
+                    {
+                        Title = @"tiny lamp",
+                        Artist = @"fhana",
+                        Author = @"Sotarks",
+                        Source = @"ぎんぎつね",
+                    },
+                    Beatmaps = new List<BeatmapInfo>
+                    {
+                        new BeatmapInfo
+                        {
+                            Ruleset = ruleset,
+                            StarDifficulty = 5.81f,
+                            Metadata = new BeatmapMetadata(),
+                            OnlineInfo = new BeatmapOnlineInfo
+                            {
+                                Covers = new[] { @"https://assets.ppy.sh//beatmaps/599627/covers/cover.jpg?1494539318" },
+                                Preview = @"https//b.ppy.sh/preview/599627.mp3",
+                                PlayCount = 3082,
+                                FavouriteCount = 14,
+                            },
+                        },
+                    },
+                },
+                new BeatmapSetInfo
+                {
+                    Metadata = new BeatmapMetadata
+                    {
+                        Title = @"At Gwanghwamun",
+                        Artist = @"KYUHYUN",
+                        Author = @"Cerulean Veyron",
+                        Source = @"",
+                    },
+                    Beatmaps = new List<BeatmapInfo>
+                    {
+                        new BeatmapInfo
+                        {
+                            Ruleset = ruleset,
+                            StarDifficulty = 0.9f,
+                            Metadata = new BeatmapMetadata(),
+                            OnlineInfo = new BeatmapOnlineInfo
+                            {
+                                Covers = new[] { @"https://assets.ppy.sh//beatmaps/513268/covers/cover.jpg?1494502863" },
+                                Preview = @"https//b.ppy.sh/preview/513268.mp3",
+                                PlayCount = 2762,
+                                FavouriteCount = 15,
+                            },
+                        },
+                        new BeatmapInfo
+                        {
+                            Ruleset = ruleset,
+                            StarDifficulty = 1.1f,
+                        },
+                        new BeatmapInfo
+                        {
+                            Ruleset = ruleset,
+                            StarDifficulty = 2.02f,
+                        },
+                        new BeatmapInfo
+                        {
+                            Ruleset = ruleset,
+                            StarDifficulty = 3.49f,
+                        },
+                    },
+                },
+                new BeatmapSetInfo
+                {
+                    Metadata = new BeatmapMetadata
+                    {
+                        Title = @"RHAPSODY OF BLUE SKY",
+                        Artist = @"fhana",
+                        Author = @"[Kamiya]",
+                        Source = @"小林さんちのメイドラゴン",
+                    },
+                    Beatmaps = new List<BeatmapInfo>
+                    {
+                        new BeatmapInfo
+                        {
+                            Ruleset = ruleset,
+                            StarDifficulty = 1.26f,
+                            Metadata = new BeatmapMetadata(),
+                            OnlineInfo = new BeatmapOnlineInfo
+                            {
+                                Covers = new[] { @"https://assets.ppy.sh//beatmaps/586841/covers/cover.jpg?1494052741" },
+                                Preview = @"https//b.ppy.sh/preview/586841.mp3",
+                                PlayCount = 62317,
+                                FavouriteCount = 161,
+                            },
+                        },
+                        new BeatmapInfo
+                        {
+                            Ruleset = ruleset,
+                            StarDifficulty = 2.01f,
+                        },
+                        new BeatmapInfo
+                        {
+                            Ruleset = ruleset,
+                            StarDifficulty = 2.87f,
+                        },
+                        new BeatmapInfo
+                        {
+                            Ruleset = ruleset,
+                            StarDifficulty = 3.76f,
+                        },
+                        new BeatmapInfo
+                        {
+                            Ruleset = ruleset,
+                            StarDifficulty = 3.93f,
+                        },
+                        new BeatmapInfo
+                        {
+                            Ruleset = ruleset,
+                            StarDifficulty = 4.37f,
+                        },
+                        new BeatmapInfo
+                        {
+                            Ruleset = ruleset,
+                            StarDifficulty = 5.13f,
+                        },
+                        new BeatmapInfo
+                        {
+                            Ruleset = ruleset,
+                            StarDifficulty = 5.42f,
+                        },
+                    },
+                },
+            };
+        }
+    }
+}

osu.Desktop.VisualTests/Tests/TestCaseDrawableRoom.cs

@@ -0,0 +1,74 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics;
+using osu.Framework.Testing;
+using osu.Game.Screens.Multiplayer;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Users;
+using osu.Game.Database;
+
+namespace osu.Desktop.VisualTests.Tests
+{
+    internal class TestCaseDrawableRoom : TestCase
+    {
+        public override string Description => @"Select your favourite room";
+
+        public override void Reset()
+        {
+            base.Reset();
+
+            DrawableRoom first;
+            DrawableRoom second;
+            Add(new FillFlowContainer
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                AutoSizeAxes = Axes.Y,
+                Width = 500f,
+                Direction = FillDirection.Vertical,
+                Children = new Drawable[]
+                {
+                    first = new DrawableRoom(new Room()),
+                    second = new DrawableRoom(new Room()),
+                }
+            });
+
+            first.Room.Name.Value = @"Great Room Right Here";
+            first.Room.Host.Value = new User { Username = @"Naeferith", Id = 9492835, Country = new Country { FlagName = @"FR" } };
+            first.Room.Status.Value = new RoomStatusOpen();
+            first.Room.Beatmap.Value = new BeatmapMetadata { Title = @"Seiryu", Artist = @"Critical Crystal" };
+
+            second.Room.Name.Value = @"Relax It's The Weekend";
+            second.Room.Host.Value = new User { Username = @"peppy", Id = 2, Country = new Country { FlagName = @"AU" } };
+            second.Room.Status.Value = new RoomStatusPlaying();
+            second.Room.Beatmap.Value = new BeatmapMetadata { Title = @"ZAQ", Artist = @"Serendipity" };
+
+            AddStep(@"change state", () =>
+            {
+                first.Room.Status.Value = new RoomStatusPlaying();
+            });
+
+            AddStep(@"change name", () =>
+            {
+                first.Room.Name.Value = @"I Changed Name";
+            });
+
+            AddStep(@"change host", () =>
+            {
+                first.Room.Host.Value = new User { Username = @"DrabWeb", Id = 6946022, Country = new Country { FlagName = @"CA" } };
+            });
+
+            AddStep(@"change beatmap", () =>
+            {
+                first.Room.Beatmap.Value = null;
+            });
+
+            AddStep(@"change state", () =>
+            {
+                first.Room.Status.Value = new RoomStatusOpen();
+            });
+        }
+    }
+}

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.ControlPoints;
 
 namespace osu.Desktop.VisualTests.Tests
 {
@@ -52,6 +53,12 @@ namespace osu.Desktop.VisualTests.Tests
                 time += RNG.Next(50, 500);
             }
 
+            var controlPointInfo = new ControlPointInfo();
+            controlPointInfo.TimingPoints.Add(new TimingControlPoint
+            {
+                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",
-                    }
-                }
+                    },
+                },
+                ControlPointInfo = controlPointInfo
             });
 
             Add(new Drawable[]
@@ -77,25 +85,25 @@ namespace osu.Desktop.VisualTests.Tests
                     Clock = new FramedClock(),
                     Children = new Drawable[]
                     {
-                        new OsuHitRenderer(beatmap)
+                        new OsuHitRenderer(beatmap, false)
                         {
                             Scale = new Vector2(0.5f),
                             Anchor = Anchor.TopLeft,
                             Origin = Anchor.TopLeft
                         },
-                        new TaikoHitRenderer(beatmap)
+                        new TaikoHitRenderer(beatmap, false)
                         {
                             Scale = new Vector2(0.5f),
                             Anchor = Anchor.TopRight,
                             Origin = Anchor.TopRight
                         },
-                        new CatchHitRenderer(beatmap)
+                        new CatchHitRenderer(beatmap, false)
                         {
                             Scale = new Vector2(0.5f),
                             Anchor = Anchor.BottomLeft,
                             Origin = Anchor.BottomLeft
                         },
-                        new ManiaHitRenderer(beatmap)
+                        new ManiaHitRenderer(beatmap, false)
                         {
                             Scale = new Vector2(0.5f),
                             Anchor = Anchor.BottomRight,

osu.Desktop.VisualTests/Tests/TestCaseGraph.cs

@@ -30,7 +30,7 @@ namespace osu.Desktop.VisualTests.Tests
                 },
             };
 
-            AddStep("values from 1-10", () => graph.Values = Enumerable.Range(1,10).Select(i => (float)i));
+            AddStep("values from 1-10", () => graph.Values = Enumerable.Range(1, 10).Select(i => (float)i));
             AddStep("values from 1-100", () => graph.Values = Enumerable.Range(1, 100).Select(i => (float)i));
             AddStep("reversed values from 1-10", () => graph.Values = Enumerable.Range(1, 10).Reverse().Select(i => (float)i));
             AddStep("Bottom to top", () => graph.Direction = BarDirection.BottomToTop);

osu.Desktop.VisualTests/Tests/TestCaseHitObjects.cs

@@ -10,7 +10,6 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Testing;
 using osu.Framework.Timing;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Osu.Objects;
@@ -62,15 +61,12 @@ namespace osu.Desktop.VisualTests.Tests
                     add(new DrawableSlider(new Slider
                     {
                         StartTime = framedClock.CurrentTime + 600,
-                        CurveObject = new CurvedHitObject
+                        ControlPoints = new List<Vector2>
                         {
-                            ControlPoints = new List<Vector2>
-                            {
-                                new Vector2(-200, 0),
-                                new Vector2(400, 0),
-                            },
-                            Distance = 400
+                            new Vector2(-200, 0),
+                            new Vector2(400, 0),
                         },
+                        Distance = 400,
                         Position = new Vector2(-200, 0),
                         Velocity = 1,
                         TickDistance = 100,
@@ -133,8 +129,6 @@ namespace osu.Desktop.VisualTests.Tests
             };
 
             Add(clockAdjustContainer);
-
-            load(mode);
         }
 
         private int depth;

osu.Desktop.VisualTests/Tests/TestCaseKeyCounter.cs

@@ -54,7 +54,7 @@ namespace osu.Desktop.VisualTests.Tests
                 Children = new Drawable[]
                 {
                     new SpriteText { Text = "FadeTime" },
-                    sliderBar =new TestSliderBar<int>
+                    sliderBar = new TestSliderBar<int>
                     {
                         Width = 150,
                         Height = 10,

osu.Desktop.VisualTests/Tests/TestCaseManiaHitObjects.cs

@@ -0,0 +1,81 @@
+// 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,
+                                RelativeChildSize = new Vector2(1, 10000),
+                                Children = new[]
+                                {
+                                    new DrawableNote(new Note { StartTime = 5000 }) { AccentColour = Color4.Red },
+                                    new DrawableNote(new Note { StartTime = 6000 }) { AccentColour = Color4.Red }
+                                }
+                            }
+                        }
+                    },
+                    new 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,
+                                RelativeChildSize = 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,148 @@
+// 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 OpenTK;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Timing;
+using osu.Framework.Configuration;
+using OpenTK.Input;
+using osu.Framework.Timing;
+
+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<TimingChange>())
+                {
+                    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<TimingChange> { new TimingChange { 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
+                    }));
+                }
+            };
+
+            Action createPlayfieldWithNotesAcceptingInput = () =>
+            {
+                Clear();
+
+                var rateAdjustClock = new StopwatchClock(true) { Rate = 0.5 };
+
+                ManiaPlayfield playField;
+                Add(playField = new ManiaPlayfield(4, new List<TimingChange> { new TimingChange { BeatLength = 200 } })
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Scale = new Vector2(1, -1),
+                    Clock = new FramedClock(rateAdjustClock)
+                });
+
+                for (int t = 1000; t <= 2000; t += 100)
+                {
+                    playField.Add(new DrawableNote(new Note
+                    {
+                        StartTime = t,
+                        Column = 0
+                    }, new Bindable<Key>(Key.D)));
+
+                    playField.Add(new DrawableNote(new Note
+                    {
+                        StartTime = t,
+                        Column = 3
+                    }, new Bindable<Key>(Key.K)));
+                }
+
+                playField.Add(new DrawableHoldNote(new HoldNote
+                {
+                    StartTime = 1000,
+                    Duration = 1000,
+                    Column = 1
+                }, new Bindable<Key>(Key.F)));
+
+                playField.Add(new DrawableHoldNote(new HoldNote
+                {
+                    StartTime = 1000,
+                    Duration = 1000,
+                    Column = 2
+                }, new Bindable<Key>(Key.J)));
+            };
+
+            AddStep("1 column", () => createPlayfield(1, SpecialColumnPosition.Normal));
+            AddStep("4 columns", () => createPlayfield(4, SpecialColumnPosition.Normal));
+            AddStep("Left special style", () => createPlayfield(4, SpecialColumnPosition.Left));
+            AddStep("Right special style", () => createPlayfield(4, SpecialColumnPosition.Right));
+            AddStep("5 columns", () => createPlayfield(5, SpecialColumnPosition.Normal));
+            AddStep("8 columns", () => createPlayfield(8, SpecialColumnPosition.Normal));
+            AddStep("Left special style", () => createPlayfield(8, SpecialColumnPosition.Left));
+            AddStep("Right special style", () => createPlayfield(8, SpecialColumnPosition.Right));
+
+            AddStep("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);
+
+            AddStep("Notes with input", () => createPlayfieldWithNotesAcceptingInput());
+        }
+
+        private void triggerKeyDown(Column column)
+        {
+            column.TriggerOnKeyDown(new InputState(), new KeyDownEventArgs
+            {
+                Key = column.Key,
+                Repeat = false
+            });
+        }
+
+        private void triggerKeyUp(Column column)
+        {
+            column.TriggerOnKeyUp(new InputState(), new KeyUpEventArgs
+            {
+                Key = column.Key
+            });
+        }
+    }
+}

osu.Desktop.VisualTests/Tests/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"),
@@ -35,7 +35,7 @@ namespace osu.Desktop.VisualTests.Tests
             });
 
             AddStep(@"Pause", delegate {
-                if(failOverlay.State == Visibility.Visible)
+                if (failOverlay.State == Visibility.Visible)
                 {
                     failOverlay.Hide();
                 }

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

@@ -0,0 +1,55 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Framework.Testing;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Screens.Play;
+using osu.Game.Screens.Play.ReplaySettings;
+
+namespace osu.Desktop.VisualTests.Tests
+{
+    internal class TestCaseReplaySettingsOverlay : TestCase
+    {
+        public override string Description => @"Settings visible in replay/auto";
+
+        private ExampleContainer container;
+
+        public override void Reset()
+        {
+            base.Reset();
+
+            Add(new ReplaySettingsOverlay()
+            {
+                Anchor = Anchor.TopRight,
+                Origin = Anchor.TopRight,
+            });
+
+            Add(container = new ExampleContainer());
+
+            AddStep(@"Add button", () => container.Add(new OsuButton
+            {
+                RelativeSizeAxes = Axes.X,
+                Text = @"Button",
+            }));
+
+            AddStep(@"Add checkbox", () => container.Add(new ReplayCheckbox
+            {
+                LabelText = "Checkbox",
+            }));
+
+            AddStep(@"Add textbox", () => container.Add(new FocusedTextBox
+            {
+                RelativeSizeAxes = Axes.X,
+                Height = 30,
+                PlaceholderText = "Textbox",
+                HoldFocus = false,
+            }));
+        }
+
+        private class ExampleContainer : ReplayGroup
+        {
+            protected override string Title => @"example";
+        }
+    }
+}

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
 {
@@ -80,7 +79,8 @@ namespace osu.Desktop.VisualTests.Tests
             {
                 score.Current.Value += 300 + (ulong)(300.0 * (comboCounter.Current > 0 ? comboCounter.Current - 1 : 0) / 25.0);
                 comboCounter.Increment();
-                numerator++; denominator++;
+                numerator++;
+                denominator++;
                 accuracyCounter.SetFraction(numerator, denominator);
             });
 

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

@@ -0,0 +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 osu.Framework.Testing;
+using osu.Game.Screens.Play;
+
+namespace osu.Desktop.VisualTests.Tests
+{
+    internal class TestCaseSkipButton : TestCase
+    {
+        public override string Description => @"Skip skip skippediskip";
+
+        public override void Reset()
+        {
+            base.Reset();
+            Add(new SkipButton(Clock.CurrentTime + 5000));
+        }
+    }
+}

osu.Desktop.VisualTests/Tests/TestCaseSocial.cs

@@ -0,0 +1,85 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Testing;
+using osu.Game.Overlays;
+using osu.Game.Users;
+
+namespace osu.Desktop.VisualTests.Tests
+{
+    public class TestCaseSocial : TestCase
+    {
+        public override string Description => @"social browser overlay";
+
+        public override void Reset()
+        {
+            base.Reset();
+
+            SocialOverlay s = new SocialOverlay
+            {
+                Users = new[]
+                {
+                    new User
+                    {
+                        Username = @"flyte",
+                        Id = 3103765,
+                        Country = new Country { FlagName = @"JP" },
+                        CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c1.jpg",
+                    },
+                    new User
+                    {
+                        Username = @"Cookiezi",
+                        Id = 124493,
+                        Country = new Country { FlagName = @"KR" },
+                        CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c2.jpg",
+                    },
+                    new User
+                    {
+                        Username = @"Angelsim",
+                        Id = 1777162,
+                        Country = new Country { FlagName = @"KR" },
+                        CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                    },
+                    new User
+                    {
+                        Username = @"Rafis",
+                        Id = 2558286,
+                        Country = new Country { FlagName = @"PL" },
+                        CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c4.jpg",
+                    },
+                    new User
+                    {
+                        Username = @"hvick225",
+                        Id = 50265,
+                        Country = new Country { FlagName = @"TW" },
+                        CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c5.jpg",
+                    },
+                    new User
+                    {
+                        Username = @"peppy",
+                        Id = 2,
+                        Country = new Country { FlagName = @"AU" },
+                        CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c6.jpg"
+                    },
+                    new User
+                    {
+                        Username = @"filsdelama",
+                        Id = 2831793,
+                        Country = new Country { FlagName = @"FR" },
+                        CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c7.jpg"
+                    },
+                    new User
+                    {
+                        Username = @"_index",
+                        Id = 652457,
+                        Country = new Country { FlagName = @"RU" },
+                        CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c8.jpg"
+                    },
+                },
+            };
+            Add(s);
+
+            AddStep(@"toggle", s.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,
@@ -38,9 +42,9 @@ namespace osu.Desktop.VisualTests.Tests
                 Origin = Anchor.TopLeft,
             });
 
-            AddStep("Toggle Bar", progress.ToggleBar);
+            AddStep("Toggle Bar", () => progress.AllowSeeking = !progress.AllowSeeking);
             AddWaitStep(5);
-            AddStep("Toggle Bar", progress.ToggleBar);
+            AddStep("Toggle Bar", () => progress.AllowSeeking = !progress.AllowSeeking);
             AddWaitStep(2);
             AddRepeatStep("New Values", displayNewValues, 5);
 
@@ -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/Tests/TestCaseTooltip.cs

@@ -1,92 +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.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Testing;
-using osu.Game.Graphics.Sprites;
-using osu.Game.Graphics.UserInterface;
-using osu.Framework.Configuration;
-using OpenTK;
-using osu.Game.Graphics;
-
-namespace osu.Desktop.VisualTests.Tests
-{
-    internal class TestCaseTooltip : TestCase
-    {
-        public override string Description => "tests tooltips on various elements";
-
-        public override void Reset()
-        {
-            base.Reset();
-            OsuSliderBar<int> slider;
-            OsuSliderBar<double> sliderDouble;
-
-            const float width = 400;
-
-            Children = new Drawable[]
-            {
-                new FillFlowContainer
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Direction = FillDirection.Vertical,
-                    Spacing = new Vector2(0, 10),
-                    Children = new Drawable[]
-                    {
-                        new TooltipTextContainer("text with a tooltip"),
-                        new TooltipTextContainer("more text with another tooltip"),
-                        new TooltipTextbox
-                        {
-                            Text = "a textbox with a tooltip",
-                            Size = new Vector2(width,30),
-                        },
-                        slider = new OsuSliderBar<int>
-                        {
-                            Width = width,
-                        },
-                        sliderDouble = new OsuSliderBar<double>
-                        {
-                            Width = width,
-                        },
-                    },
-                },
-            };
-
-            slider.Current.BindTo(new BindableInt(5)
-            {
-                MaxValue = 10,
-                MinValue = 0
-            });
-
-            sliderDouble.Current.BindTo(new BindableDouble(0.5)
-            {
-                MaxValue = 1,
-                MinValue = 0
-            });
-        }
-
-        private class TooltipTextContainer : Container, IHasTooltip
-        {
-            private readonly OsuSpriteText text;
-
-            public string TooltipText => text.Text;
-
-            public TooltipTextContainer(string tooltipText)
-            {
-                AutoSizeAxes = Axes.Both;
-                Children = new[]
-                {
-                    text = new OsuSpriteText
-                    {
-                        Text = tooltipText,
-                    }
-                };
-            }
-        }
-
-        private class TooltipTextbox : OsuTextBox, IHasTooltip
-        {
-            public string TooltipText => Text;
-        }
-    }
-}

osu.Desktop.VisualTests/Tests/TestCaseTwoLayerButton.cs

@@ -3,20 +3,18 @@
 
 using osu.Framework.Testing;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Screens.Play;
 
 namespace osu.Desktop.VisualTests.Tests
 {
     internal class TestCaseTwoLayerButton : TestCase
     {
-        public override string Description => @"Back and skip and what not";
+        public override string Description => @"Mostly back button";
 
         public override void Reset()
         {
             base.Reset();
 
             Add(new BackButton());
-            Add(new SkipButton());
         }
     }
 }

osu.Desktop.VisualTests/Tests/TestCaseUserPanel.cs

@@ -0,0 +1,57 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Testing;
+using osu.Framework.Graphics;
+using osu.Game.Users;
+using osu.Framework.Graphics.Containers;
+using OpenTK;
+
+namespace osu.Desktop.VisualTests.Tests
+{
+    internal class TestCaseUserPanel : TestCase
+    {
+        public override string Description => @"Panels for displaying a user's status";
+
+        public override void Reset()
+        {
+            base.Reset();
+
+            UserPanel flyte;
+            UserPanel peppy;
+            Add(new FillFlowContainer
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                AutoSizeAxes = Axes.Both,
+                Spacing = new Vector2(10f),
+                Children = new[]
+                {
+                    flyte = new UserPanel(new User
+                    {
+                        Username = @"flyte",
+                        Id = 3103765,
+                        Country = new Country { FlagName = @"JP" },
+                        CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c6.jpg"
+                    }) { Width = 300 },
+                    peppy = new UserPanel(new User
+                    {
+                        Username = @"peppy",
+                        Id = 2,
+                        Country = new Country { FlagName = @"AU" },
+                        CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c3.jpg"
+                    }) { Width = 300 },
+                },
+            });
+
+            flyte.Status.Value = new UserStatusOnline();
+            peppy.Status.Value = new UserStatusSoloGame();
+
+            AddStep(@"spectating", () => { flyte.Status.Value = new UserStatusSpectating(); });
+            AddStep(@"multiplaying", () => { flyte.Status.Value = new UserStatusMultiplayerGame(); });
+            AddStep(@"modding", () => { flyte.Status.Value = new UserStatusModding(); });
+            AddStep(@"offline", () => { flyte.Status.Value = new UserStatusOffline(); });
+            AddStep(@"null status", () => { flyte.Status.Value = null; });
+        }
+    }
+}

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,13 @@
     <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\TestCaseReplaySettingsOverlay.cs" />
     <Compile Include="Tests\TestCasePlayer.cs" />
     <Compile Include="Tests\TestCaseHitObjects.cs" />
     <Compile Include="Tests\TestCaseKeyCounter.cs" />
@@ -200,23 +204,28 @@
     <Compile Include="Tests\TestCaseReplay.cs" />
     <Compile Include="Tests\TestCaseResults.cs" />
     <Compile Include="Tests\TestCaseScoreCounter.cs" />
+    <Compile Include="Tests\TestCaseSkipButton.cs" />
     <Compile Include="Tests\TestCaseTabControl.cs" />
     <Compile Include="Tests\TestCaseTaikoHitObjects.cs" />
     <Compile Include="Tests\TestCaseTaikoPlayfield.cs" />
     <Compile Include="Tests\TestCaseTextAwesome.cs" />
     <Compile Include="Tests\TestCasePlaySongSelect.cs" />
-    <Compile Include="Tests\TestCaseTooltip.cs" />
     <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" />
     <Compile Include="Beatmaps\TestWorkingBeatmap.cs" />
     <Compile Include="Tests\TestCaseBeatmapDetailArea.cs" />
+    <Compile Include="Tests\TestCaseDrawableRoom.cs" />
+    <Compile Include="Tests\TestCaseUserPanel.cs" />
+    <Compile Include="Tests\TestCaseDirect.cs" />
+    <Compile Include="Tests\TestCaseSocial.cs" />
+    <Compile Include="Tests\TestCaseBreadcrumbs.cs" />
   </ItemGroup>
   <ItemGroup />
   <ItemGroup />

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)
         {
@@ -37,5 +37,7 @@ namespace osu.Desktop.Beatmaps.IO
         {
             // no-op
         }
+
+        public override Stream GetUnderlyingStream() => null;
     }
 }

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.Catch/CatchRuleset.cs

@@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Catch
 {
     public class CatchRuleset : Ruleset
     {
-        public override HitRenderer CreateHitRendererWith(WorkingBeatmap beatmap) => new CatchHitRenderer(beatmap);
+        public override HitRenderer CreateHitRendererWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new CatchHitRenderer(beatmap, isForCurrentRuleset);
 
         public override IEnumerable<Mod> GetModsFor(ModType type)
         {
@@ -28,7 +28,14 @@ namespace osu.Game.Rulesets.Catch
                     {
                         new CatchModEasy(),
                         new CatchModNoFail(),
-                        new CatchModHalfTime(),
+                        new MultiMod
+                        {
+                            Mods = new Mod[]
+                            {
+                                new CatchModHalfTime(),
+                                new CatchModDaycore(),
+                            },
+                        },
                     };
 
                 case ModType.DifficultyIncrease:

osu.Game.Rulesets.Catch/Mods/CatchMod.cs

@@ -32,6 +32,11 @@ namespace osu.Game.Rulesets.Catch.Mods
 
     }
 
+    public class CatchModDaycore : ModDaycore
+    {
+        public override double ScoreMultiplier => 0.5;
+    }
+
     public class CatchModDoubleTime : ModDoubleTime
     {
         public override double ScoreMultiplier => 1.06;

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

@@ -15,8 +15,8 @@ namespace osu.Game.Rulesets.Catch.UI
 {
     public class CatchHitRenderer : HitRenderer<CatchBaseHit, CatchJudgement>
     {
-        public CatchHitRenderer(WorkingBeatmap beatmap)
-            : base(beatmap)
+        public CatchHitRenderer(WorkingBeatmap beatmap, bool isForCurrentRuleset)
+            : base(beatmap, isForCurrentRuleset)
         {
         }
 

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

@@ -1,23 +1,203 @@
 // 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;
-using osu.Game.Rulesets.Mania.Objects;
-using System.Collections.Generic;
-using System;
-using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Beatmaps;
+using osu.Game.Rulesets.Mania.Objects;
+using System;
+using System.Collections.Generic;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Mania.Beatmaps.Patterns;
+using osu.Game.Rulesets.Mania.MathUtils;
+using osu.Game.Database;
+using osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy;
+using OpenTK;
+using osu.Game.Audio;
 
 namespace osu.Game.Rulesets.Mania.Beatmaps
 {
-    internal class ManiaBeatmapConverter : BeatmapConverter<ManiaBaseHit>
+    public class ManiaBeatmapConverter : BeatmapConverter<ManiaHitObject>
     {
+        /// <summary>
+        /// Maximum number of previous notes to consider for density calculation.
+        /// </summary>
+        private const int max_notes_for_density = 7;
+
         protected override IEnumerable<Type> ValidConversionTypes { get; } = new[] { typeof(IHasXPosition) };
 
-        protected override IEnumerable<ManiaBaseHit> ConvertHitObject(HitObject original, Beatmap beatmap)
+        private Pattern lastPattern = new Pattern();
+        private FastRandom random;
+        private Beatmap beatmap;
+        private bool isForCurrentRuleset;
+
+        protected override Beatmap<ManiaHitObject> ConvertBeatmap(Beatmap original, bool isForCurrentRuleset)
         {
-            yield return null;
+            this.isForCurrentRuleset = isForCurrentRuleset;
+
+            beatmap = original;
+
+            BeatmapDifficulty difficulty = original.BeatmapInfo.Difficulty;
+
+            int seed = (int)Math.Round(difficulty.DrainRate + difficulty.CircleSize) * 20 + (int)(difficulty.OverallDifficulty * 41.2) + (int)Math.Round(difficulty.ApproachRate);
+            random = new FastRandom(seed);
+
+            return base.ConvertBeatmap(original, isForCurrentRuleset);
+        }
+
+        protected override IEnumerable<ManiaHitObject> ConvertHitObject(HitObject original, Beatmap beatmap)
+        {
+            var maniaOriginal = original as ManiaHitObject;
+            if (maniaOriginal != null)
+            {
+                yield return maniaOriginal;
+                yield break;
+            }
+
+            var objects = isForCurrentRuleset ? generateSpecific(original) : generateConverted(original);
+
+            if (objects == null)
+                yield break;
+
+            foreach (ManiaHitObject obj in objects)
+                yield return obj;
+        }
+
+        private readonly List<double> prevNoteTimes = new List<double>(max_notes_for_density);
+        private double density = int.MaxValue;
+        private void computeDensity(double newNoteTime)
+        {
+            if (prevNoteTimes.Count == max_notes_for_density)
+                prevNoteTimes.RemoveAt(0);
+            prevNoteTimes.Add(newNoteTime);
+
+            density = (prevNoteTimes[prevNoteTimes.Count - 1] - prevNoteTimes[0]) / prevNoteTimes.Count;
+        }
+
+        private double lastTime;
+        private Vector2 lastPosition;
+        private PatternType lastStair;
+        private void recordNote(double time, Vector2 position)
+        {
+            lastTime = time;
+            lastPosition = position;
+        }
+
+        /// <summary>
+        /// Method that generates hit objects for osu!mania specific beatmaps.
+        /// </summary>
+        /// <param name="original">The original hit object.</param>
+        /// <returns>The hit objects generated.</returns>
+        private IEnumerable<ManiaHitObject> generateSpecific(HitObject original)
+        {
+            var generator = new SpecificBeatmapPatternGenerator(random, original, beatmap, lastPattern);
+
+            Pattern newPattern = generator.Generate();
+            lastPattern = newPattern;
+
+            return newPattern.HitObjects;
+        }
+
+        /// <summary>
+        /// Method that generates hit objects for non-osu!mania beatmaps.
+        /// </summary>
+        /// <param name="original">The original hit object.</param>
+        /// <returns>The hit objects generated.</returns>
+        private IEnumerable<ManiaHitObject> generateConverted(HitObject original)
+        {
+            var endTimeData = original as IHasEndTime;
+            var distanceData = original as IHasDistance;
+            var positionData = original as IHasPosition;
+
+            // Following lines currently commented out to appease resharper
+
+            Patterns.PatternGenerator conversion = null;
+
+            if (distanceData != null)
+                conversion = new DistanceObjectPatternGenerator(random, original, beatmap, lastPattern);
+            else if (endTimeData != null)
+                conversion = new EndTimeObjectPatternGenerator(random, original, beatmap);
+            else if (positionData != null)
+            {
+                computeDensity(original.StartTime);
+
+                conversion = new HitObjectPatternGenerator(random, original, beatmap, lastPattern, lastTime, lastPosition, density, lastStair);
+
+                recordNote(original.StartTime, positionData.Position);
+            }
+
+            if (conversion == null)
+                return null;
+
+            Pattern newPattern = conversion.Generate();
+            lastPattern = newPattern;
+
+            var stairPatternGenerator = (HitObjectPatternGenerator)conversion;
+            lastStair = stairPatternGenerator.StairType;
+
+            return newPattern.HitObjects;
+        }
+
+        /// <summary>
+        /// A pattern generator for osu!mania-specific beatmaps.
+        /// </summary>
+        private class SpecificBeatmapPatternGenerator : Patterns.Legacy.PatternGenerator
+        {
+            public SpecificBeatmapPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, Pattern previousPattern)
+                : base(random, hitObject, beatmap, previousPattern)
+            {
+            }
+
+            public override Pattern Generate()
+            {
+                var endTimeData = HitObject as IHasEndTime;
+                var positionData = HitObject as IHasXPosition;
+
+                int column = GetColumn(positionData?.X ?? 0);
+
+                var pattern = new Pattern();
+
+                if (endTimeData != null)
+                {
+                    pattern.Add(new HoldNote
+                    {
+                        StartTime = HitObject.StartTime,
+                        Duration = endTimeData.Duration,
+                        Column = column,
+                        Head = { Samples = sampleInfoListAt(HitObject.StartTime) },
+                        Tail = { Samples = sampleInfoListAt(endTimeData.EndTime) },
+                    });
+                }
+                else if (positionData != null)
+                {
+                    pattern.Add(new Note
+                    {
+                        StartTime = HitObject.StartTime,
+                        Samples = HitObject.Samples,
+                        Column = column
+                    });
+                }
+
+                return pattern;
+            }
+
+            /// <summary>
+            /// Retrieves the sample info list at a point in time.
+            /// </summary>
+            /// <param name="time">The time to retrieve the sample info list from.</param>
+            /// <returns></returns>
+            private SampleInfoList sampleInfoListAt(double time)
+            {
+                var curveData = HitObject as IHasCurve;
+
+                if (curveData == null)
+                    return HitObject.Samples;
+
+                double segmentTime = (curveData.EndTime - HitObject.StartTime) / curveData.RepeatCount;
+
+                int index = (int)(segmentTime == 0 ? 0 : (time - HitObject.StartTime) / segmentTime);
+                return curveData.RepeatSamples[index];
+            }
         }
     }
 }

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

@@ -0,0 +1,488 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Linq;
+using osu.Game.Audio;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.MathUtils;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Beatmaps.ControlPoints;
+
+namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
+{
+    /// <summary>
+    /// A pattern generator for IHasDistance hit objects.
+    /// </summary>
+    internal class DistanceObjectPatternGenerator : PatternGenerator
+    {
+        /// <summary>
+        /// Base osu! slider scoring distance.
+        /// </summary>
+        private const float osu_base_scoring_distance = 100;
+
+        private readonly double endTime;
+        private readonly double segmentDuration;
+        private readonly int repeatCount;
+
+        private PatternType convertType;
+
+        public DistanceObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, Pattern previousPattern)
+            : base(random, hitObject, beatmap, previousPattern)
+        {
+            convertType = PatternType.None;
+            if (Beatmap.ControlPointInfo.EffectPointAt(hitObject.StartTime).KiaiMode)
+                convertType = PatternType.LowProbability;
+
+            var distanceData = hitObject as IHasDistance;
+            var repeatsData = hitObject as IHasRepeats;
+
+            repeatCount = repeatsData?.RepeatCount ?? 1;
+
+            TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(hitObject.StartTime);
+            DifficultyControlPoint difficultyPoint = beatmap.ControlPointInfo.DifficultyPointAt(hitObject.StartTime);
+
+            // The true distance, accounting for any repeats
+            double distance = (distanceData?.Distance ?? 0) * repeatCount;
+            // The velocity of the osu! hit object - calculated as the velocity of a slider
+            double osuVelocity = osu_base_scoring_distance * beatmap.BeatmapInfo.Difficulty.SliderMultiplier / (timingPoint.BeatLength * difficultyPoint.SpeedMultiplier);
+            // The duration of the osu! hit object
+            double osuDuration = distance / osuVelocity;
+
+            endTime = hitObject.StartTime + osuDuration;
+            segmentDuration = (endTime - HitObject.StartTime) / repeatCount;
+        }
+
+        public override Pattern Generate()
+        {
+            if (repeatCount > 1)
+            {
+                if (segmentDuration <= 90)
+                    return generateRandomHoldNotes(HitObject.StartTime, 1);
+
+                if (segmentDuration <= 120)
+                {
+                    convertType |= PatternType.ForceNotStack;
+                    return generateRandomNotes(HitObject.StartTime, repeatCount + 1);
+                }
+
+                if (segmentDuration <= 160)
+                    return generateStair(HitObject.StartTime);
+
+                if (segmentDuration <= 200 && ConversionDifficulty > 3)
+                    return generateRandomMultipleNotes(HitObject.StartTime);
+
+                double duration = endTime - HitObject.StartTime;
+                if (duration >= 4000)
+                    return generateNRandomNotes(HitObject.StartTime, 0.23, 0, 0);
+
+                if (segmentDuration > 400 && repeatCount < AvailableColumns - 1 - RandomStart)
+                    return generateTiledHoldNotes(HitObject.StartTime);
+
+                return generateHoldAndNormalNotes(HitObject.StartTime);
+            }
+
+            if (segmentDuration <= 110)
+            {
+                if (PreviousPattern.ColumnWithObjects < AvailableColumns)
+                    convertType |= PatternType.ForceNotStack;
+                else
+                    convertType &= ~PatternType.ForceNotStack;
+                return generateRandomNotes(HitObject.StartTime, segmentDuration < 80 ? 1 : 2);
+            }
+
+            if (ConversionDifficulty > 6.5)
+            {
+                if ((convertType & PatternType.LowProbability) > 0)
+                    return generateNRandomNotes(HitObject.StartTime, 0.78, 0.3, 0);
+                return generateNRandomNotes(HitObject.StartTime, 0.85, 0.36, 0.03);
+            }
+
+            if (ConversionDifficulty > 4)
+            {
+                if ((convertType & PatternType.LowProbability) > 0)
+                    return generateNRandomNotes(HitObject.StartTime, 0.43, 0.08, 0);
+                return generateNRandomNotes(HitObject.StartTime, 0.56, 0.18, 0);
+            }
+
+            if (ConversionDifficulty > 2.5)
+            {
+                if ((convertType & PatternType.LowProbability) > 0)
+                    return generateNRandomNotes(HitObject.StartTime, 0.3, 0, 0);
+                return generateNRandomNotes(HitObject.StartTime, 0.37, 0.08, 0);
+            }
+
+            if ((convertType & PatternType.LowProbability) > 0)
+                return generateNRandomNotes(HitObject.StartTime, 0.17, 0, 0);
+            return generateNRandomNotes(HitObject.StartTime, 0.27, 0, 0);
+        }
+
+        /// <summary>
+        /// Generates random hold notes that start at an span the same amount of rows.
+        /// </summary>
+        /// <param name="startTime">Start time of each hold note.</param>
+        /// <param name="noteCount">Number of hold notes.</param>
+        /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
+        private Pattern generateRandomHoldNotes(double startTime, int noteCount)
+        {
+            // - - - -
+            // ■ - ■ ■
+            // □ - □ □
+            // ■ - ■ ■
+
+            var pattern = new Pattern();
+
+            int usableColumns = AvailableColumns - RandomStart - PreviousPattern.ColumnWithObjects;
+            int nextColumn = Random.Next(RandomStart, AvailableColumns);
+            for (int i = 0; i < Math.Min(usableColumns, noteCount); i++)
+            {
+                while (pattern.ColumnHasObject(nextColumn) || PreviousPattern.ColumnHasObject(nextColumn))  //find available column
+                    nextColumn = Random.Next(RandomStart, AvailableColumns);
+                addToPattern(pattern, nextColumn, startTime, endTime);
+            }
+
+            // This is can't be combined with the above loop due to RNG
+            for (int i = 0; i < noteCount - usableColumns; i++)
+            {
+                while (pattern.ColumnHasObject(nextColumn))
+                    nextColumn = Random.Next(RandomStart, AvailableColumns);
+                addToPattern(pattern, nextColumn, startTime, endTime);
+            }
+
+            return pattern;
+        }
+
+        /// <summary>
+        /// Generates random notes, with one note per row and no stacking.
+        /// </summary>
+        /// <param name="startTime">The start time.</param>
+        /// <param name="noteCount">The number of notes.</param>
+        /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
+        private Pattern generateRandomNotes(double startTime, int noteCount)
+        {
+            // - - - -
+            // x - - -
+            // - - x -
+            // - - - x
+            // x - - -
+
+            var pattern = new Pattern();
+
+            int nextColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
+            if ((convertType & PatternType.ForceNotStack) > 0 && PreviousPattern.ColumnWithObjects < AvailableColumns)
+            {
+                while (PreviousPattern.ColumnHasObject(nextColumn))
+                    nextColumn = Random.Next(RandomStart, AvailableColumns);
+            }
+
+            int lastColumn = nextColumn;
+            for (int i = 0; i < noteCount; i++)
+            {
+                addToPattern(pattern, nextColumn, startTime, startTime);
+                while (nextColumn == lastColumn)
+                    nextColumn = Random.Next(RandomStart, AvailableColumns);
+
+                lastColumn = nextColumn;
+                startTime += segmentDuration;
+            }
+
+            return pattern;
+        }
+
+        /// <summary>
+        /// Generates a stair of notes, with one note per row.
+        /// </summary>
+        /// <param name="startTime">The start time.</param>
+        /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
+        private Pattern generateStair(double startTime)
+        {
+            // - - - -
+            // x - - -
+            // - x - -
+            // - - x -
+            // - - - x
+            // - - x -
+            // - x - -
+            // x - - -
+
+            var pattern = new Pattern();
+
+            int column = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
+            bool increasing = Random.NextDouble() > 0.5;
+
+            for (int i = 0; i <= repeatCount; i++)
+            {
+                addToPattern(pattern, column, startTime, startTime);
+                startTime += segmentDuration;
+
+                // Check if we're at the borders of the stage, and invert the pattern if so
+                if (increasing)
+                {
+                    if (column >= AvailableColumns - 1)
+                    {
+                        increasing = false;
+                        column--;
+                    }
+                    else
+                        column++;
+                }
+                else
+                {
+                    if (column <= RandomStart)
+                    {
+                        increasing = true;
+                        column++;
+                    }
+                    else
+                        column--;
+                }
+            }
+
+            return pattern;
+        }
+
+        /// <summary>
+        /// Generates random notes with 1-2 notes per row and no stacking.
+        /// </summary>
+        /// <param name="startTime">The start time.</param>
+        /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
+        private Pattern generateRandomMultipleNotes(double startTime)
+        {
+            // - - - -
+            // x - - -
+            // - x x -
+            // - - - x
+            // x - x -
+
+            var pattern = new Pattern();
+
+            bool legacy = AvailableColumns >= 4 && AvailableColumns <= 8;
+            int interval = Random.Next(1, AvailableColumns - (legacy ? 1 : 0));
+
+            int nextColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
+            for (int i = 0; i <= repeatCount; i++)
+            {
+                addToPattern(pattern, nextColumn, startTime, startTime);
+
+                nextColumn += interval;
+                if (nextColumn >= AvailableColumns - RandomStart)
+                    nextColumn = nextColumn - AvailableColumns - RandomStart + (legacy ? 1 : 0);
+                nextColumn += RandomStart;
+
+                // If we're in 2K, let's not add many consecutive doubles
+                if (AvailableColumns > 2)
+                    addToPattern(pattern, nextColumn, startTime, startTime);
+
+                nextColumn = Random.Next(RandomStart, AvailableColumns);
+                startTime += segmentDuration;
+            }
+
+            return pattern;
+        }
+
+        /// <summary>
+        /// Generates random hold notes. The amount of hold notes generated is determined by probabilities.
+        /// </summary>
+        /// <param name="startTime">The hold note start time.</param>
+        /// <param name="p2">The probability required for 2 hold notes to be generated.</param>
+        /// <param name="p3">The probability required for 3 hold notes to be generated.</param>
+        /// <param name="p4">The probability required for 4 hold notes to be generated.</param>
+        /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
+        private Pattern generateNRandomNotes(double startTime, double p2, double p3, double p4)
+        {
+            // - - - -
+            // ■ - ■ ■
+            // □ - □ □
+            // ■ - ■ ■
+
+            switch (AvailableColumns)
+            {
+                case 2:
+                    p2 = 0;
+                    p3 = 0;
+                    p4 = 0;
+                    break;
+                case 3:
+                    p2 = Math.Max(p2, 0.1);
+                    p3 = 0;
+                    p4 = 0;
+                    break;
+                case 4:
+                    p2 = Math.Max(p2, 0.3);
+                    p3 = Math.Max(p3, 0.04);
+                    p4 = 0;
+                    break;
+                case 5:
+                    p2 = Math.Max(p2, 0.34);
+                    p3 = Math.Max(p3, 0.1);
+                    p4 = Math.Max(p4, 0.03);
+                    break;
+            }
+
+            Func<SampleInfo, bool> isDoubleSample = sample => sample.Name == SampleInfo.HIT_CLAP && sample.Name == SampleInfo.HIT_FINISH;
+
+            bool canGenerateTwoNotes = (convertType & PatternType.LowProbability) == 0;
+            canGenerateTwoNotes &= HitObject.Samples.Any(isDoubleSample) || sampleInfoListAt(HitObject.StartTime).Any(isDoubleSample);
+
+            if (canGenerateTwoNotes)
+                p2 = 1;
+
+            return generateRandomHoldNotes(startTime, GetRandomNoteCount(p2, p3, p4));
+        }
+
+        /// <summary>
+        /// Generates tiled hold notes. You can think of this as a stair of hold notes.
+        /// </summary>
+        /// <param name="startTime">The first hold note start time.</param>
+        /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
+        private Pattern generateTiledHoldNotes(double startTime)
+        {
+            // - - - -
+            // ■ ■ ■ ■
+            // □ □ □ □
+            // □ □ □ □
+            // □ □ □ ■
+            // □ □ ■ -
+            // □ ■ - -
+            // ■ - - -
+
+            var pattern = new Pattern();
+
+            int columnRepeat = Math.Min(repeatCount, AvailableColumns);
+
+            int nextColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
+            if ((convertType & PatternType.ForceNotStack) > 0 && PreviousPattern.ColumnWithObjects < AvailableColumns)
+            {
+                while (PreviousPattern.ColumnHasObject(nextColumn))
+                    nextColumn = Random.Next(RandomStart, AvailableColumns);
+            }
+
+            for (int i = 0; i < columnRepeat; i++)
+            {
+                while (pattern.ColumnHasObject(nextColumn))
+                    nextColumn = Random.Next(RandomStart, AvailableColumns);
+
+                addToPattern(pattern, nextColumn, startTime, endTime);
+                startTime += segmentDuration;
+            }
+
+            return pattern;
+        }
+
+        /// <summary>
+        /// Generates a hold note alongside normal notes.
+        /// </summary>
+        /// <param name="startTime">The start time of notes.</param>
+        /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
+        private Pattern generateHoldAndNormalNotes(double startTime)
+        {
+            // - - - -
+            // ■ x x -
+            // ■ - x x
+            // ■ x - x
+            // ■ - x x
+
+            var pattern = new Pattern();
+
+            int holdColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
+            if ((convertType & PatternType.ForceNotStack) > 0 && PreviousPattern.ColumnWithObjects < AvailableColumns)
+            {
+                while (PreviousPattern.ColumnHasObject(holdColumn))
+                    holdColumn = Random.Next(RandomStart, AvailableColumns);
+            }
+
+            // Create the hold note
+            addToPattern(pattern, holdColumn, startTime, endTime);
+
+            int noteCount = 1;
+            if (ConversionDifficulty > 6.5)
+                noteCount = GetRandomNoteCount(0.63, 0);
+            else if (ConversionDifficulty > 4)
+                noteCount = GetRandomNoteCount(AvailableColumns < 6 ? 0.12 : 0.45, 0);
+            else if (ConversionDifficulty > 2.5)
+                noteCount = GetRandomNoteCount(AvailableColumns < 6 ? 0 : 0.24, 0);
+            noteCount = Math.Min(AvailableColumns - 1, noteCount);
+
+            bool ignoreHead = !sampleInfoListAt(startTime).Any(s => s.Name == SampleInfo.HIT_WHISTLE || s.Name == SampleInfo.HIT_FINISH || s.Name == SampleInfo.HIT_CLAP);
+            int nextColumn = Random.Next(RandomStart, AvailableColumns);
+
+            var rowPattern = new Pattern();
+            for (int i = 0; i <= repeatCount; i++)
+            {
+                if (!(ignoreHead && startTime == HitObject.StartTime))
+                {
+                    for (int j = 0; j < noteCount; j++)
+                    {
+                        while (rowPattern.ColumnHasObject(nextColumn) || nextColumn == holdColumn)
+                            nextColumn = Random.Next(RandomStart, AvailableColumns);
+                        addToPattern(rowPattern, nextColumn, startTime, startTime);
+                    }
+                }
+
+                pattern.Add(rowPattern);
+                rowPattern.Clear();
+
+                startTime += segmentDuration;
+            }
+
+            return pattern;
+        }
+
+        /// <summary>
+        /// Retrieves the sample info list at a point in time.
+        /// </summary>
+        /// <param name="time">The time to retrieve the sample info list from.</param>
+        /// <returns></returns>
+        private SampleInfoList sampleInfoListAt(double time)
+        {
+            var curveData = HitObject as IHasCurve;
+
+            if (curveData == null)
+                return HitObject.Samples;
+
+            double segmentTime = (endTime - HitObject.StartTime) / repeatCount;
+
+            int index = (int)(segmentTime == 0 ? 0 : (time - HitObject.StartTime) / segmentTime);
+            return curveData.RepeatSamples[index];
+        }
+
+        /// <summary>
+        /// Constructs and adds a note to a pattern.
+        /// </summary>
+        /// <param name="pattern">The pattern to add to.</param>
+        /// <param name="column">The column to add the note to.</param>
+        /// <param name="startTime">The start time of the note.</param>
+        /// <param name="endTime">The end time of the note (set to <paramref name="startTime"/> for a non-hold note).</param>
+        private void addToPattern(Pattern pattern, int column, double startTime, double endTime)
+        {
+            ManiaHitObject newObject;
+
+            if (startTime == endTime)
+            {
+                newObject = new Note
+                {
+                    StartTime = startTime,
+                    Samples = sampleInfoListAt(startTime),
+                    Column = column
+                };
+            }
+            else
+            {
+                var holdNote = new HoldNote
+                {
+                    StartTime = startTime,
+                    Column = column,
+                    Duration = endTime - startTime,
+                    Head = { Samples = sampleInfoListAt(startTime) },
+                    Tail = { Samples = sampleInfoListAt(endTime) }
+                };
+
+                newObject = holdNote;
+            }
+
+            pattern.Add(newObject);
+        }
+    }
+}

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

@@ -0,0 +1,101 @@
+// 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;
+using osu.Game.Rulesets.Mania.MathUtils;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using System.Linq;
+using osu.Game.Audio;
+using osu.Game.Rulesets.Mania.Objects;
+
+namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
+{
+    internal class EndTimeObjectPatternGenerator : PatternGenerator
+    {
+        private readonly double endTime;
+
+        public EndTimeObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap)
+            : base(random, hitObject, beatmap, new Pattern())
+        {
+            var endtimeData = HitObject as IHasEndTime;
+
+            endTime = endtimeData?.EndTime ?? 0;
+        }
+
+        public override Pattern Generate()
+        {
+            var pattern = new Pattern();
+
+            bool generateHold = endTime - HitObject.StartTime >= 100;
+
+            if (AvailableColumns == 8)
+            {
+                if (HitObject.Samples.Any(s => s.Name == SampleInfo.HIT_FINISH) && endTime - HitObject.StartTime < 1000)
+                    addToPattern(pattern, 0, generateHold);
+                else
+                    addToPattern(pattern, getNextRandomColumn(RandomStart), generateHold);
+            }
+            else if (AvailableColumns > 0)
+                addToPattern(pattern, getNextRandomColumn(0), generateHold);
+
+            return pattern;
+        }
+
+        /// <summary>
+        /// Picks a random column after a column.
+        /// </summary>
+        /// <param name="start">The starting column.</param>
+        /// <returns>A random column after <paramref name="start"/>.</returns>
+        private int getNextRandomColumn(int start)
+        {
+            int nextColumn = Random.Next(start, AvailableColumns);
+
+            while (PreviousPattern.ColumnHasObject(nextColumn))
+                nextColumn = Random.Next(start, AvailableColumns);
+
+            return nextColumn;
+        }
+
+        /// <summary>
+        /// Constructs and adds a note to a pattern.
+        /// </summary>
+        /// <param name="pattern">The pattern to add to.</param>
+        /// <param name="column">The column to add the note to.</param>
+        /// <param name="holdNote">Whether to add a hold note.</param>
+        private void addToPattern(Pattern pattern, int column, bool holdNote)
+        {
+            ManiaHitObject newObject;
+
+            if (holdNote)
+            {
+                var hold = new HoldNote
+                {
+                    StartTime = HitObject.StartTime,
+                    Column = column,
+                    Duration = endTime - HitObject.StartTime
+                };
+
+                hold.Head.Samples.Add(new SampleInfo
+                {
+                    Name = SampleInfo.HIT_NORMAL
+                });
+
+                hold.Tail.Samples = HitObject.Samples;
+
+                newObject = hold;
+            }
+            else
+            {
+                newObject = new Note
+                {
+                    StartTime = HitObject.StartTime,
+                    Samples = HitObject.Samples,
+                    Column = column
+                };
+            }
+
+            pattern.Add(newObject);
+        }
+    }
+}

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

@@ -0,0 +1,404 @@
+// 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.Game.Audio;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Mania.MathUtils;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+
+namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
+{
+    internal class HitObjectPatternGenerator : PatternGenerator
+    {
+        public PatternType StairType { get; private set; }
+
+        private readonly PatternType convertType;
+
+        public HitObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, Pattern previousPattern, double previousTime, Vector2 previousPosition, double density, PatternType lastStair)
+            : base(random, hitObject, beatmap, previousPattern)
+        {
+            StairType = lastStair;
+
+            TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(hitObject.StartTime);
+            EffectControlPoint effectPoint = beatmap.ControlPointInfo.EffectPointAt(hitObject.StartTime);
+
+            var positionData = hitObject as IHasPosition;
+
+            float positionSeparation = ((positionData?.Position ?? Vector2.Zero) - previousPosition).Length;
+            double timeSeparation = hitObject.StartTime - previousTime;
+
+            if (timeSeparation <= 125)
+            {
+                // More than 120 BPM
+                convertType |= PatternType.ForceNotStack;
+            }
+
+            if (timeSeparation <= 80)
+            {
+                // More than 187 BPM
+                convertType |= PatternType.ForceNotStack | PatternType.KeepSingle;
+            }
+            else if (timeSeparation <= 95)
+            {
+                // More than 157 BPM
+                convertType |= PatternType.ForceNotStack | PatternType.KeepSingle | lastStair;
+            }
+            else if (timeSeparation <= 105)
+            {
+                // More than 140 BPM
+                convertType |= PatternType.ForceNotStack | PatternType.LowProbability;
+            }
+            else if (timeSeparation <= 125)
+            {
+                // More than 120 BPM
+                convertType |= PatternType.ForceNotStack;
+            }
+            else if (timeSeparation <= 135 && positionSeparation < 20)
+            {
+                // More than 111 BPM stream
+                convertType |= PatternType.Cycle | PatternType.KeepSingle;
+            }
+            else if (timeSeparation <= 150 & positionSeparation < 20)
+            {
+                // More than 100 BPM stream
+                convertType |= PatternType.ForceStack | PatternType.LowProbability;
+            }
+            else if (positionSeparation < 20 && density >= timingPoint.BeatLength / 2.5)
+            {
+                // Low density stream
+                convertType |= PatternType.Reverse | PatternType.LowProbability;
+            }
+            else if (density < timingPoint.BeatLength / 2.5 || effectPoint.KiaiMode)
+            {
+                // High density
+            }
+            else
+                convertType |= PatternType.LowProbability;
+        }
+
+        public override Pattern Generate()
+        {
+            int lastColumn = PreviousPattern.HitObjects.FirstOrDefault()?.Column ?? 0;
+
+            if ((convertType & PatternType.Reverse) > 0 && PreviousPattern.HitObjects.Any())
+            {
+                // Generate a new pattern by copying the last hit objects in reverse-column order
+                var pattern = new Pattern();
+
+                for (int i = RandomStart; i < AvailableColumns; i++)
+                    if (PreviousPattern.ColumnHasObject(i))
+                        addToPattern(pattern, RandomStart + AvailableColumns - i - 1);
+
+                return pattern;
+            }
+
+            if ((convertType & PatternType.Cycle) > 0 && PreviousPattern.HitObjects.Count() == 1
+                // If we convert to 7K + 1, let's not overload the special key
+                && (AvailableColumns != 8 || lastColumn != 0)
+                // Make sure the last column was not the centre column
+                && (AvailableColumns % 2 == 0 || lastColumn != AvailableColumns / 2))
+            {
+                // Generate a new pattern by cycling backwards (similar to Reverse but for only one hit object)
+                var pattern = new Pattern();
+
+                int column = RandomStart + AvailableColumns - lastColumn - 1;
+                addToPattern(pattern, column);
+
+                return pattern;
+            }
+
+            if ((convertType & PatternType.ForceStack) > 0 && PreviousPattern.HitObjects.Any())
+            {
+                // Generate a new pattern by placing on the already filled columns
+                var pattern = new Pattern();
+
+                for (int i = RandomStart; i < AvailableColumns; i++)
+                    if (PreviousPattern.ColumnHasObject(i))
+                        addToPattern(pattern, i);
+
+                return pattern;
+            }
+
+            if ((convertType & PatternType.Stair) > 0 && PreviousPattern.HitObjects.Count() == 1)
+            {
+                // Generate a new pattern by placing on the next column, cycling back to the start if there is no "next"
+                var pattern = new Pattern();
+
+                int targetColumn = lastColumn + 1;
+                if (targetColumn == AvailableColumns)
+                {
+                    targetColumn = RandomStart;
+                    StairType = PatternType.ReverseStair;
+                }
+
+                addToPattern(pattern, targetColumn);
+                return pattern;
+            }
+
+            if ((convertType & PatternType.ReverseStair) > 0 && PreviousPattern.HitObjects.Count() == 1)
+            {
+                // Generate a new pattern by placing on the previous column, cycling back to the end if there is no "previous"
+                var pattern = new Pattern();
+
+                int targetColumn = lastColumn - 1;
+                if (targetColumn == RandomStart - 1)
+                {
+                    targetColumn = AvailableColumns - 1;
+                    StairType = PatternType.Stair;
+                }
+
+                addToPattern(pattern, targetColumn);
+                return pattern;
+            }
+
+            if ((convertType & PatternType.KeepSingle) > 0)
+                return generateRandomNotes(1);
+
+            if ((convertType & PatternType.Mirror) > 0)
+            {
+                if (ConversionDifficulty > 6.5)
+                    return generateRandomPatternWithMirrored(0.12, 0.38, 0.12);
+                if (ConversionDifficulty > 4)
+                    return generateRandomPatternWithMirrored(0.12, 0.17, 0);
+                return generateRandomPatternWithMirrored(0.12, 0, 0);
+            }
+
+            if (ConversionDifficulty > 6.5)
+            {
+                if ((convertType & PatternType.LowProbability) > 0)
+                    return generateRandomPattern(0.78, 0.42, 0, 0);
+                return generateRandomPattern(1, 0.62, 0, 0);
+            }
+
+            if (ConversionDifficulty > 4)
+            {
+                if ((convertType & PatternType.LowProbability) > 0)
+                    return generateRandomPattern(0.35, 0.08, 0, 0);
+                return generateRandomPattern(0.52, 0.15, 0, 0);
+            }
+
+            if (ConversionDifficulty > 2)
+            {
+                if ((convertType & PatternType.LowProbability) > 0)
+                    return generateRandomPattern(0.18, 0, 0, 0);
+                return generateRandomPattern(0.45, 0, 0, 0);
+            }
+
+            return generateRandomPattern(0, 0, 0, 0);
+        }
+
+        /// <summary>
+        /// Generates random notes.
+        /// <para>
+        /// This will generate as many as it can up to <paramref name="noteCount"/>, accounting for
+        /// any stacks if <see cref="convertType"/> is forcing no stacks.
+        /// </para>
+        /// </summary>
+        /// <param name="noteCount">The amount of notes to generate.</param>
+        /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
+        private Pattern generateRandomNotes(int noteCount)
+        {
+            var pattern = new Pattern();
+
+            bool allowStacking = (convertType & PatternType.ForceNotStack) == 0;
+
+            if (!allowStacking)
+                noteCount = Math.Min(noteCount, AvailableColumns - RandomStart - PreviousPattern.ColumnWithObjects);
+
+            int nextColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
+            for (int i = 0; i < noteCount; i++)
+            {
+                while (pattern.ColumnHasObject(nextColumn) || PreviousPattern.ColumnHasObject(nextColumn) && !allowStacking)
+                {
+                    if ((convertType & PatternType.Gathered) > 0)
+                    {
+                        nextColumn++;
+                        if (nextColumn == AvailableColumns)
+                            nextColumn = RandomStart;
+                    }
+                    else
+                        nextColumn = Random.Next(RandomStart, AvailableColumns);
+                }
+
+                addToPattern(pattern, nextColumn);
+            }
+
+            return pattern;
+        }
+
+        /// <summary>
+        /// Whether this hit object can generate a note in the special column.
+        /// </summary>
+        private bool hasSpecialColumn => HitObject.Samples.Any(s => s.Name == SampleInfo.HIT_CLAP) && HitObject.Samples.Any(s => s.Name == SampleInfo.HIT_FINISH);
+
+        /// <summary>
+        /// Generates a random pattern.
+        /// </summary>
+        /// <param name="p2">Probability for 2 notes to be generated.</param>
+        /// <param name="p3">Probability for 3 notes to be generated.</param>
+        /// <param name="p4">Probability for 4 notes to be generated.</param>
+        /// <param name="p5">Probability for 5 notes to be generated.</param>
+        /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
+        private Pattern generateRandomPattern(double p2, double p3, double p4, double p5)
+        {
+            var pattern = new Pattern();
+
+            pattern.Add(generateRandomNotes(getRandomNoteCount(p2, p3, p4, p5)));
+
+            if (RandomStart > 0 && hasSpecialColumn)
+                addToPattern(pattern, 0);
+
+            return pattern;
+        }
+
+        /// <summary>
+        /// Generates a random pattern which has both normal and mirrored notes.
+        /// </summary>
+        /// <param name="centreProbability">The probability for a note to be added to the centre column.</param>
+        /// <param name="p2">Probability for 2 notes to be generated.</param>
+        /// <param name="p3">Probability for 3 notes to be generated.</param>
+        /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
+        private Pattern generateRandomPatternWithMirrored(double centreProbability, double p2, double p3)
+        {
+            var pattern = new Pattern();
+
+            bool addToCentre;
+            int noteCount = getRandomNoteCountMirrored(centreProbability, p2, p3, out addToCentre);
+
+            int columnLimit = (AvailableColumns % 2 == 0 ? AvailableColumns : AvailableColumns - 1) / 2;
+            int nextColumn = Random.Next(RandomStart, columnLimit);
+            for (int i = 0; i < noteCount; i++)
+            {
+                while (pattern.ColumnHasObject(nextColumn))
+                    nextColumn = Random.Next(RandomStart, columnLimit);
+
+                // Add normal note
+                addToPattern(pattern, nextColumn);
+                // Add mirrored note
+                addToPattern(pattern, RandomStart + AvailableColumns - nextColumn - 1);
+            }
+
+            if (addToCentre)
+                addToPattern(pattern, AvailableColumns / 2);
+
+            if (RandomStart > 0 && hasSpecialColumn)
+                addToPattern(pattern, 0);
+
+            return pattern;
+        }
+
+        /// <summary>
+        /// Generates a count of notes to be generated from a list of probabilities.
+        /// </summary>
+        /// <param name="p2">Probability for 2 notes to be generated.</param>
+        /// <param name="p3">Probability for 3 notes to be generated.</param>
+        /// <param name="p4">Probability for 4 notes to be generated.</param>
+        /// <param name="p5">Probability for 5 notes to be generated.</param>
+        /// <returns>The amount of notes to be generated.</returns>
+        private int getRandomNoteCount(double p2, double p3, double p4, double p5)
+        {
+            switch (AvailableColumns)
+            {
+                case 2:
+                    p2 = 0;
+                    p3 = 0;
+                    p4 = 0;
+                    p5 = 0;
+                    break;
+                case 3:
+                    p2 = Math.Max(p2, 0.1);
+                    p3 = 0;
+                    p4 = 0;
+                    p5 = 0;
+                    break;
+                case 4:
+                    p2 = Math.Max(p2, 0.23);
+                    p3 = Math.Max(p3, 0.04);
+                    p4 = 0;
+                    p5 = 0;
+                    break;
+                case 5:
+                    p3 = Math.Max(p3, 0.15);
+                    p4 = Math.Max(p4, 0.03);
+                    p5 = 0;
+                    break;
+            }
+
+            if (HitObject.Samples.Any(s => s.Name == SampleInfo.HIT_CLAP))
+                p2 = 1;
+
+            return GetRandomNoteCount(p2, p3, p4, p5);
+        }
+
+        /// <summary>
+        /// Generates a count of notes to be generated from a list of probabilities.
+        /// </summary>
+        /// <param name="centreProbability">The probability for a note to be added to the centre column.</param>
+        /// <param name="p2">Probability for 2 notes to be generated.</param>
+        /// <param name="p3">Probability for 3 notes to be generated.</param>
+        /// <param name="addToCentre">Whether to add a note to the centre column.</param>
+        /// <returns>The amount of notes to be generated. The note to be added to the centre column will NOT be part of this count.</returns>
+        private int getRandomNoteCountMirrored(double centreProbability, double p2, double p3, out bool addToCentre)
+        {
+            addToCentre = false;
+
+            if ((convertType & PatternType.ForceNotStack) > 0)
+                return getRandomNoteCount(p2 / 2, p2, (p2 + p3) / 2, p3);
+
+            switch (AvailableColumns)
+            {
+                case 2:
+                    centreProbability = 0;
+                    p2 = 0;
+                    p3 = 0;
+                    break;
+                case 3:
+                    centreProbability = Math.Max(centreProbability, 0.03);
+                    p2 = Math.Max(p2, 0.1);
+                    p3 = 0;
+                    break;
+                case 4:
+                    centreProbability = 0;
+                    p2 = Math.Max(p2 * 2, 0.2);
+                    p3 = 0;
+                    break;
+                case 5:
+                    centreProbability = Math.Max(centreProbability, 0.03);
+                    p3 = 0;
+                    break;
+                case 6:
+                    centreProbability = 0;
+                    p2 = Math.Max(p2 * 2, 0.5);
+                    p3 = Math.Max(p3 * 2, 0.15);
+                    break;
+            }
+
+            double centreVal = Random.NextDouble();
+            int noteCount = GetRandomNoteCount(p2, p3);
+
+            addToCentre = AvailableColumns % 2 != 0 && noteCount != 3 && centreVal > 1 - centreProbability;
+            return noteCount;
+        }
+
+        /// <summary>
+        /// Constructs and adds a note to a pattern.
+        /// </summary>
+        /// <param name="pattern">The pattern to add to.</param>
+        /// <param name="column">The column to add the note to.</param>
+        private void addToPattern(Pattern pattern, int column)
+        {
+            pattern.Add(new Note
+            {
+                StartTime = HitObject.StartTime,
+                Samples = HitObject.Samples,
+                Column = column
+            });
+        }
+    }
+}

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

@@ -0,0 +1,106 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Linq;
+using osu.Game.Beatmaps;
+using osu.Game.Database;
+using osu.Game.Rulesets.Mania.MathUtils;
+using osu.Game.Rulesets.Objects;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
+{
+    /// <summary>
+    /// A pattern generator for legacy hit objects.
+    /// </summary>
+    internal abstract class PatternGenerator : Patterns.PatternGenerator
+    {
+        /// <summary>
+        /// The column index at which to start generating random notes.
+        /// </summary>
+        protected readonly int RandomStart;
+
+        /// <summary>
+        /// The random number generator to use.
+        /// </summary>
+        protected readonly FastRandom Random;
+
+        protected PatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, Pattern previousPattern)
+            : base(hitObject, beatmap, previousPattern)
+        {
+            Random = random;
+
+            RandomStart = AvailableColumns == 8 ? 1 : 0;
+        }
+
+        /// <summary>
+        /// Converts an x-position into a column.
+        /// </summary>
+        /// <param name="position">The x-position.</param>
+        /// <param name="allowSpecial">Whether to treat as 7K + 1.</param>
+        /// <returns>The column.</returns>
+        protected int GetColumn(float position, bool allowSpecial = false)
+        {
+            if (allowSpecial && AvailableColumns == 8)
+            {
+                const float local_x_divisor = 512f / 7;
+                return MathHelper.Clamp((int)Math.Floor(position / local_x_divisor), 0, 6) + 1;
+            }
+
+            float localXDivisor = 512f / AvailableColumns;
+            return MathHelper.Clamp((int)Math.Floor(position / localXDivisor), 0, AvailableColumns - 1);
+        }
+
+        /// <summary>
+        /// Generates a count of notes to be generated from probabilities.
+        /// </summary>
+        /// <param name="p2">Probability for 2 notes to be generated.</param>
+        /// <param name="p3">Probability for 3 notes to be generated.</param>
+        /// <param name="p4">Probability for 4 notes to be generated.</param>
+        /// <param name="p5">Probability for 5 notes to be generated.</param>
+        /// <param name="p6">Probability for 6 notes to be generated.</param>
+        /// <returns>The amount of notes to be generated.</returns>
+        protected int GetRandomNoteCount(double p2, double p3, double p4 = 0, double p5 = 0, double p6 = 0)
+        {
+            double val = Random.NextDouble();
+            if (val >= 1 - p6)
+                return 6;
+            if (val >= 1 - p5)
+                return 5;
+            if (val >= 1 - p4)
+                return 4;
+            if (val >= 1 - p3)
+                return 3;
+            return val >= 1 - p2 ? 2 : 1;
+        }
+
+        private double? conversionDifficulty;
+        /// <summary>
+        /// A difficulty factor used for various conversion methods from osu!stable.
+        /// </summary>
+        protected double ConversionDifficulty
+        {
+            get
+            {
+                if (conversionDifficulty != null)
+                    return conversionDifficulty.Value;
+
+                HitObject lastObject = Beatmap.HitObjects.LastOrDefault();
+                HitObject firstObject = Beatmap.HitObjects.FirstOrDefault();
+
+                double drainTime = (lastObject?.StartTime ?? 0) - (firstObject?.StartTime ?? 0);
+                drainTime -= Beatmap.TotalBreakTime;
+
+                if (drainTime == 0)
+                    drainTime = 10000;
+
+                BeatmapDifficulty difficulty = Beatmap.BeatmapInfo.Difficulty;
+                conversionDifficulty = ((difficulty.DrainRate + MathHelper.Clamp(difficulty.ApproachRate, 4, 7)) / 1.5 + Beatmap.HitObjects.Count / drainTime * 9f) / 38f * 5f / 1.15;
+                conversionDifficulty = Math.Min(conversionDifficulty.Value, 12);
+
+                return conversionDifficulty.Value;
+            }
+        }
+    }
+}

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/PatternType.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 System;
+
+namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
+{
+    /// <summary>
+    /// The type of pattern to generate. Used for legacy patterns.
+    /// </summary>
+    [Flags]
+    internal enum PatternType
+    {
+        None = 0,
+        /// <summary>
+        /// Keep the same as last row.
+        /// </summary>
+        ForceStack = 1 << 0,
+        /// <summary>
+        /// Keep different from last row.
+        /// </summary>
+        ForceNotStack = 1 << 1,
+        /// <summary>
+        /// Keep as single note at its original position.
+        /// </summary>
+        KeepSingle = 1 << 2,
+        /// <summary>
+        /// Use a lower random value.
+        /// </summary>
+        LowProbability = 1 << 3,
+        /// <summary>
+        /// Reserved.
+        /// </summary>
+        Alternate = 1 << 4,
+        /// <summary>
+        /// Ignore the repeat count.
+        /// </summary>
+        ForceSigSlider = 1 << 5,
+        /// <summary>
+        /// Convert slider to circle.
+        /// </summary>
+        ForceNotSlider = 1 << 6,
+        /// <summary>
+        /// Notes gathered together.
+        /// </summary>
+        Gathered = 1 << 7,
+        Mirror = 1 << 8,
+        /// <summary>
+        /// Change 0 -> 6.
+        /// </summary>
+        Reverse = 1 << 9,
+        /// <summary>
+        /// 1 -> 5 -> 1 -> 5 like reverse.
+        /// </summary>
+        Cycle = 1 << 10,
+        /// <summary>
+        /// Next note will be at column + 1.
+        /// </summary>
+        Stair = 1 << 11,
+        /// <summary>
+        /// Next note will be at column - 1.
+        /// </summary>
+        ReverseStair = 1 << 12
+    }
+}

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

@@ -0,0 +1,57 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Game.Rulesets.Mania.Objects;
+
+namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns
+{
+    /// <summary>
+    /// Creates a pattern containing hit objects.
+    /// </summary>
+    internal class Pattern
+    {
+        private readonly List<ManiaHitObject> hitObjects = new List<ManiaHitObject>();
+
+        /// <summary>
+        /// All the hit objects contained in this pattern.
+        /// </summary>
+        public IEnumerable<ManiaHitObject> HitObjects => hitObjects;
+
+        /// <summary>
+        /// Check whether a column of this patterns contains a hit object.
+        /// </summary>
+        /// <param name="column">The column index.</param>
+        /// <returns>Whether the column with index <paramref name="column"/> contains a hit object.</returns>
+        public bool ColumnHasObject(int column) => hitObjects.Exists(h => h.Column == column);
+
+        /// <summary>
+        /// Amount of columns taken up by hit objects in this pattern.
+        /// </summary>
+        public int ColumnWithObjects => HitObjects.GroupBy(h => h.Column).Count();
+
+        /// <summary>
+        /// Adds a hit object to this pattern.
+        /// </summary>
+        /// <param name="hitObject">The hit object to add.</param>
+        public void Add(ManiaHitObject hitObject) => hitObjects.Add(hitObject);
+
+        /// <summary>
+        /// Copies hit object from another pattern to this one.
+        /// </summary>
+        /// <param name="other">The other pattern.</param>
+        public void Add(Pattern other) => hitObjects.AddRange(other.HitObjects);
+
+        /// <summary>
+        /// Clears this pattern, removing all hit objects.
+        /// </summary>
+        public void Clear() => hitObjects.Clear();
+
+        /// <summary>
+        /// Removes a hit object from this pattern.
+        /// </summary>
+        /// <param name="hitObject">The hit object to remove.</param>
+        public bool Remove(ManiaHitObject hitObject) => hitObjects.Remove(hitObject);
+    }
+}

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

@@ -0,0 +1,50 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns
+{
+    /// <summary>
+    /// Generator to create a pattern <see cref="Pattern"/> from a hit object.
+    /// </summary>
+    internal abstract class PatternGenerator
+    {
+        /// <summary>
+        /// The number of columns available to create the pattern.
+        /// </summary>
+        protected readonly int AvailableColumns;
+
+        /// <summary>
+        /// The last pattern.
+        /// </summary>
+        protected readonly Pattern PreviousPattern;
+
+        /// <summary>
+        /// The hit object to create the pattern for.
+        /// </summary>
+        protected readonly HitObject HitObject;
+
+        /// <summary>
+        /// The beatmap which <see cref="HitObject"/> is a part of.
+        /// </summary>
+        protected readonly Beatmap Beatmap;
+
+        protected PatternGenerator(HitObject hitObject, Beatmap beatmap, Pattern previousPattern)
+        {
+            PreviousPattern = previousPattern;
+            HitObject = hitObject;
+            Beatmap = beatmap;
+
+            AvailableColumns = (int)Math.Round(beatmap.BeatmapInfo.Difficulty.CircleSize);
+        }
+
+        /// <summary>
+        /// Generates the pattern for <see cref="HitObject"/>, filled with hit objects.
+        /// </summary>
+        /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
+        public abstract Pattern Generate();
+    }
+}

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

@@ -0,0 +1,199 @@
+// 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>
+        /// Retrieves the hit result for a time offset.
+        /// </summary>
+        /// <param name="hitOffset">The time offset.</param>
+        /// <returns>The hit result, or null if the time offset results in a miss.</returns>
+        public ManiaHitResult? ResultFor(double hitOffset)
+        {
+            if (hitOffset <= Perfect / 2)
+                return ManiaHitResult.Perfect;
+            if (hitOffset <= Great / 2)
+                return ManiaHitResult.Great;
+            if (hitOffset <= Good / 2)
+                return ManiaHitResult.Good;
+            if (hitOffset <= Ok / 2)
+                return ManiaHitResult.Ok;
+            if (hitOffset <= Bad / 2)
+                return ManiaHitResult.Bad;
+            return null;
+        }
+
+        /// <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/Judgements/HoldNoteTailJudgement.cs

@@ -0,0 +1,37 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Rulesets.Mania.Judgements
+{
+    public class HoldNoteTailJudgement : ManiaJudgement
+    {
+        /// <summary>
+        /// Whether the hold note has been released too early and shouldn't give full score for the release.
+        /// </summary>
+        public bool HasBroken;
+
+        public override int NumericResultForScore(ManiaHitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return base.NumericResultForScore(result);
+                case ManiaHitResult.Great:
+                case ManiaHitResult.Perfect:
+                    return base.NumericResultForScore(HasBroken ? ManiaHitResult.Good : result);
+            }
+        }
+
+        public override int NumericResultForAccuracy(ManiaHitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return base.NumericResultForAccuracy(result);
+                case ManiaHitResult.Great:
+                case ManiaHitResult.Perfect:
+                    return base.NumericResultForAccuracy(HasBroken ? ManiaHitResult.Good : result);
+            }
+        }
+    }
+}

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

@@ -0,0 +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
+
+namespace osu.Game.Rulesets.Mania.Judgements
+{
+    public class HoldNoteTickJudgement : ManiaJudgement
+    {
+        public override bool AffectsCombo => false;
+
+        public override int NumericResultForScore(ManiaHitResult result) => 20;
+        public override int NumericResultForAccuracy(ManiaHitResult result) => 0; // Don't count ticks into accuracy
+    }
+}

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

@@ -0,0 +1,21 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.ComponentModel;
+
+namespace osu.Game.Rulesets.Mania.Judgements
+{
+    public enum ManiaHitResult
+    {
+        [Description("PERFECT")]
+        Perfect,
+        [Description("GREAT")]
+        Great,
+        [Description("GOOD")]
+        Good,
+        [Description("OK")]
+        Ok,
+        [Description("BAD")]
+        Bad
+    }
+}

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

@@ -2,13 +2,81 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Mania.Judgements
 {
     public class ManiaJudgement : Judgement
     {
+        /// <summary>
+        /// The maximum possible hit result.
+        /// </summary>
+        public const ManiaHitResult MAX_HIT_RESULT = ManiaHitResult.Perfect;
+
+        /// <summary>
+        /// The result value for the combo portion of the score.
+        /// </summary>
+        public int ResultValueForScore => Result == HitResult.Miss ? 0 : NumericResultForScore(ManiaResult);
+
+        /// <summary>
+        /// The result value for the accuracy portion of the score.
+        /// </summary>
+        public int ResultValueForAccuracy => Result == HitResult.Miss ? 0 : NumericResultForAccuracy(ManiaResult);
+
+        /// <summary>
+        /// The maximum result value for the combo portion of the score.
+        /// </summary>
+        public int MaxResultValueForScore => NumericResultForScore(MAX_HIT_RESULT);
+
+        /// <summary>
+        /// The maximum result value for the accuracy portion of the score.
+        /// </summary>
+        public int MaxResultValueForAccuracy => NumericResultForAccuracy(MAX_HIT_RESULT);
+
         public override string ResultString => string.Empty;
 
         public override string MaxResultString => string.Empty;
+
+        /// <summary>
+        /// The hit result.
+        /// </summary>
+        public ManiaHitResult ManiaResult;
+
+        public virtual int NumericResultForScore(ManiaHitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return 0;
+                case ManiaHitResult.Bad:
+                    return 50;
+                case ManiaHitResult.Ok:
+                    return 100;
+                case ManiaHitResult.Good:
+                    return 200;
+                case ManiaHitResult.Great:
+                case ManiaHitResult.Perfect:
+                    return 300;
+            }
+        }
+
+        public virtual int NumericResultForAccuracy(ManiaHitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return 0;
+                case ManiaHitResult.Bad:
+                    return 50;
+                case ManiaHitResult.Ok:
+                    return 100;
+                case ManiaHitResult.Good:
+                    return 200;
+                case ManiaHitResult.Great:
+                    return 300;
+                case ManiaHitResult.Perfect:
+                    return 305;
+            }
+        }
     }
 }

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

@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Mania
 {
     public class ManiaRuleset : Ruleset
     {
-        public override HitRenderer CreateHitRendererWith(WorkingBeatmap beatmap) => new ManiaHitRenderer(beatmap);
+        public override HitRenderer CreateHitRendererWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new ManiaHitRenderer(beatmap, isForCurrentRuleset);
 
         public override IEnumerable<Mod> GetModsFor(ModType type)
         {
@@ -27,7 +27,14 @@ namespace osu.Game.Rulesets.Mania
                     {
                         new ManiaModEasy(),
                         new ManiaModNoFail(),
-                        new ManiaModHalfTime(),
+                        new MultiMod
+                        {
+                            Mods = new Mod[]
+                            {
+                                new ManiaModHalfTime(),
+                                new ManiaModDaycore(),
+                            },
+                        },
                     };
 
                 case ModType.DifficultyIncrease:

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

@@ -0,0 +1,91 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+
+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 / (uint.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

@@ -34,6 +34,11 @@ namespace osu.Game.Rulesets.Mania.Mods
 
     }
 
+    public class ManiaModDaycore : ModDaycore
+    {
+        public override double ScoreMultiplier => 0.3;
+    }
+
     public class ManiaModDoubleTime : ModDoubleTime
     {
         public override double ScoreMultiplier => 1.0;
@@ -64,6 +69,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/BarLine.cs

@@ -0,0 +1,21 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Beatmaps.ControlPoints;
+
+namespace osu.Game.Rulesets.Mania.Objects
+{
+    public class BarLine : ManiaHitObject
+    {
+        /// <summary>
+        /// The control point which this bar line is part of.
+        /// </summary>
+        public TimingControlPoint ControlPoint;
+
+        /// <summary>
+        /// The index of the beat which this bar line represents within the control point.
+        /// This is a "major" bar line if <see cref="BeatIndex"/> % <see cref="TimingControlPoint.TimeSignature"/> == 0.
+        /// </summary>
+        public int BeatIndex;
+    }
+}

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

@@ -0,0 +1,74 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Rulesets.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Mania.Objects.Drawables
+{
+    /// <summary>
+    /// Visualises a <see cref="BarLine"/>. Although this derives DrawableManiaHitObject,
+    /// this does not handle input/sound like a normal hit object.
+    /// </summary>
+    public class DrawableBarLine : DrawableManiaHitObject<BarLine>
+    {
+        /// <summary>
+        /// Height of major bar line triangles.
+        /// </summary>
+        private const float triangle_height = 12;
+
+        /// <summary>
+        /// Offset of the major bar line triangles from the sides of the bar line.
+        /// </summary>
+        private const float triangle_offset = 9;
+
+        public DrawableBarLine(BarLine barLine)
+            : base(barLine)
+        {
+            RelativeSizeAxes = Axes.X;
+            Height = 1;
+
+            Add(new Box
+            {
+                Name = "Bar line",
+                Anchor = Anchor.BottomCentre,
+                Origin = Anchor.BottomCentre,
+                RelativeSizeAxes = Axes.Both,
+            });
+
+            bool isMajor = barLine.BeatIndex % (int)barLine.ControlPoint.TimeSignature == 0;
+
+            if (isMajor)
+            {
+                Add(new EquilateralTriangle
+                {
+                    Name = "Left triangle",
+                    Anchor = Anchor.BottomLeft,
+                    Origin = Anchor.TopCentre,
+                    Size = new Vector2(triangle_height),
+                    X = -triangle_offset,
+                    Rotation = 90
+                });
+
+                Add(new EquilateralTriangle
+                {
+                    Name = "Right triangle",
+                    Anchor = Anchor.BottomRight,
+                    Origin = Anchor.TopCentre,
+                    Size = new Vector2(triangle_height),
+                    X = triangle_offset,
+                    Rotation = -90
+                });
+            }
+
+            if (!isMajor && barLine.BeatIndex % 2 == 1)
+                Alpha = 0.2f;
+        }
+
+        protected override void UpdateState(ArmedState state)
+        {
+        }
+    }
+}

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

@@ -0,0 +1,240 @@
+// 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;
+using osu.Framework.Configuration;
+using OpenTK.Input;
+using osu.Framework.Input;
+using OpenTK;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Mania.Judgements;
+using osu.Framework.Extensions.IEnumerableExtensions;
+
+namespace osu.Game.Rulesets.Mania.Objects.Drawables
+{
+    /// <summary>
+    /// Visualises a <see cref="HoldNote"/> hit object.
+    /// </summary>
+    public class DrawableHoldNote : DrawableManiaHitObject<HoldNote>
+    {
+        private readonly DrawableNote head;
+        private readonly DrawableNote tail;
+
+        private readonly BodyPiece bodyPiece;
+        private readonly Container<DrawableHoldNoteTick> tickContainer;
+
+        /// <summary>
+        /// Time at which the user started holding this hold note. Null if the user is not holding this hold note.
+        /// </summary>
+        private double? holdStartTime;
+
+        /// <summary>
+        /// Whether the hold note has been released too early and shouldn't give full score for the release.
+        /// </summary>
+        private bool hasBroken;
+
+        public DrawableHoldNote(HoldNote hitObject, Bindable<Key> key = null)
+            : base(hitObject, key)
+        {
+            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,
+                },
+                tickContainer = new Container<DrawableHoldNoteTick>
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    RelativeChildSize = new Vector2(1, (float)HitObject.Duration)
+                },
+                head = new DrawableHeadNote(this, key)
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre
+                },
+                tail = new DrawableTailNote(this, key)
+                {
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.TopCentre
+                }
+            });
+
+            foreach (var tick in HitObject.Ticks)
+            {
+                var drawableTick = new DrawableHoldNoteTick(tick)
+                {
+                    HoldStartTime = () => holdStartTime
+                };
+
+                // To make the ticks relative to ourselves we need to offset them backwards
+                drawableTick.Y -= (float)HitObject.StartTime;
+
+                tickContainer.Add(drawableTick);
+                AddNested(drawableTick);
+            }
+
+            AddNested(head);
+            AddNested(tail);
+        }
+
+        public override Color4 AccentColour
+        {
+            get { return base.AccentColour; }
+            set
+            {
+                if (base.AccentColour == value)
+                    return;
+                base.AccentColour = value;
+
+                tickContainer.Children.ForEach(t => t.AccentColour = value);
+
+                bodyPiece.AccentColour = value;
+                head.AccentColour = value;
+                tail.AccentColour = value;
+            }
+        }
+
+        protected override void UpdateState(ArmedState state)
+        {
+        }
+
+        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        {
+            // Make sure the keypress happened within the body of the hold note
+            if (Time.Current < HitObject.StartTime || Time.Current > HitObject.EndTime)
+                return false;
+
+            if (args.Key != Key)
+                return false;
+
+            if (args.Repeat)
+                return false;
+
+            // The user has pressed during the body of the hold note, after the head note and its hit windows have passed
+            // and within the limited range of the above if-statement. This state will be managed by the head note if the
+            // user has pressed during the hit windows of the head note.
+            holdStartTime = Time.Current;
+
+            return true;
+        }
+
+        protected override bool OnKeyUp(InputState state, KeyUpEventArgs args)
+        {
+            // Make sure that the user started holding the key during the hold note
+            if (!holdStartTime.HasValue)
+                return false;
+
+            if (args.Key != Key)
+                return false;
+
+            holdStartTime = null;
+
+            // If the key has been released too early, the user should not receive full score for the release
+            if (!tail.Judged)
+                hasBroken = true;
+
+            return true;
+        }
+
+        /// <summary>
+        /// The head note of a hold.
+        /// </summary>
+        private class DrawableHeadNote : DrawableNote
+        {
+            private readonly DrawableHoldNote holdNote;
+
+            public DrawableHeadNote(DrawableHoldNote holdNote, Bindable<Key> key = null)
+                : base(holdNote.HitObject.Head, key)
+            {
+                this.holdNote = holdNote;
+
+                RelativePositionAxes = Axes.None;
+                Y = 0;
+            }
+
+            protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+            {
+                if (!base.OnKeyDown(state, args))
+                    return false;
+
+                // We only want to trigger a holding state from the head if the head has received a judgement
+                if (!Judged)
+                    return false;
+
+                // If the key has been released too early, the user should not receive full score for the release
+                if (Judgement.Result == HitResult.Miss)
+                    holdNote.hasBroken = true;
+
+                // The head note also handles early hits before the body, but we want accurate early hits to count as the body being held
+                // The body doesn't handle these early early hits, so we have to explicitly set the holding state here
+                holdNote.holdStartTime = Time.Current;
+
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// The tail note of a hold.
+        /// </summary>
+        private class DrawableTailNote : DrawableNote
+        {
+            private readonly DrawableHoldNote holdNote;
+
+            public DrawableTailNote(DrawableHoldNote holdNote, Bindable<Key> key = null)
+                : base(holdNote.HitObject.Tail, key)
+            {
+                this.holdNote = holdNote;
+
+                RelativePositionAxes = Axes.None;
+                Y = 0;
+            }
+
+            protected override ManiaJudgement CreateJudgement() => new HoldNoteTailJudgement();
+
+            protected override void CheckJudgement(bool userTriggered)
+            {
+                base.CheckJudgement(userTriggered);
+
+                var tailJudgement = Judgement as HoldNoteTailJudgement;
+                if (tailJudgement == null)
+                    return;
+
+                tailJudgement.HasBroken = holdNote.hasBroken;
+            }
+
+            protected override bool OnKeyUp(InputState state, KeyUpEventArgs args)
+            {
+                // Make sure that the user started holding the key during the hold note
+                if (!holdNote.holdStartTime.HasValue)
+                    return false;
+
+                if (Judgement.Result != HitResult.None)
+                    return false;
+
+                if (args.Key != Key)
+                    return false;
+
+                UpdateJudgement(true);
+
+                // Handled by the hold note, which will set holding = false
+                return false;
+            }
+
+            protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+            {
+                // Tail doesn't handle key down
+                return false;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,121 @@
+// 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 OpenTK.Graphics;
+using osu.Framework.Extensions.Color4Extensions;
+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
+{
+    /// <summary>
+    /// Visualises a <see cref="HoldNoteTick"/> hit object.
+    /// </summary>
+    public class DrawableHoldNoteTick : DrawableManiaHitObject<HoldNoteTick>
+    {
+        /// <summary>
+        /// References the time at which the user started holding the hold note.
+        /// </summary>
+        public Func<double?> HoldStartTime;
+
+        /// <summary>
+        /// References whether the user is currently holding the hold note.
+        /// </summary>
+        public Func<bool> IsHolding;
+
+        private readonly Container glowContainer;
+
+        public DrawableHoldNoteTick(HoldNoteTick hitObject)
+            : base(hitObject)
+        {
+            Anchor = Anchor.TopCentre;
+            Origin = Anchor.TopCentre;
+
+            RelativeSizeAxes = Axes.X;
+            Size = new Vector2(1);
+
+            Children = new[]
+            {
+                glowContainer = new CircularContainer
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    Children = new[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Alpha = 0,
+                            AlwaysPresent = true
+                        }
+                    }
+                }
+            };
+
+            // Set the default glow
+            AccentColour = Color4.White;
+        }
+
+        public override Color4 AccentColour
+        {
+            get { return base.AccentColour; }
+            set
+            {
+                base.AccentColour = value;
+
+                glowContainer.EdgeEffect = new EdgeEffect
+                {
+                    Type = EdgeEffectType.Glow,
+                    Radius = 2f,
+                    Roundness = 15f,
+                    Colour = value.Opacity(0.3f)
+                };
+            }
+        }
+
+        protected override ManiaJudgement CreateJudgement() => new HoldNoteTickJudgement();
+
+        protected override void CheckJudgement(bool userTriggered)
+        {
+            if (!userTriggered)
+                return;
+
+            if (Time.Current < HitObject.StartTime)
+                return;
+
+            if (HoldStartTime?.Invoke() > HitObject.StartTime)
+                return;
+
+            Judgement.ManiaResult = ManiaHitResult.Perfect;
+            Judgement.Result = HitResult.Hit;
+        }
+
+        protected override void UpdateState(ArmedState state)
+        {
+            switch (State)
+            {
+                case ArmedState.Hit:
+                    AccentColour = Color4.Green;
+                    break;
+            }
+        }
+
+        protected override void Update()
+        {
+            if (Judgement.Result != HitResult.None)
+                return;
+
+            if (IsHolding?.Invoke() != true)
+                return;
+
+            UpdateJudgement(true);
+        }
+    }
+}

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableManiaHitObject.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 OpenTK.Input;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics;
+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
+    {
+        /// <summary>
+        /// The key that will trigger input for this hit object.
+        /// </summary>
+        protected Bindable<Key> Key { get; private set; } = new Bindable<Key>();
+
+        public new TObject HitObject;
+
+        protected DrawableManiaHitObject(TObject hitObject, Bindable<Key> key = null)
+            : base(hitObject)
+        {
+            HitObject = hitObject;
+
+            if (key != null)
+                Key.BindTo(key);
+
+            RelativePositionAxes = Axes.Y;
+            Y = (float)HitObject.StartTime;
+        }
+
+        public override Color4 AccentColour
+        {
+            get { return base.AccentColour; }
+            set
+            {
+                if (base.AccentColour == value)
+                    return;
+                base.AccentColour = value;
+            }
+        }
+
+        protected override ManiaJudgement CreateJudgement() => new ManiaJudgement();
+    }
+}

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableNote.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 System;
+using OpenTK.Graphics;
+using OpenTK.Input;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics;
+using osu.Framework.Input;
+using osu.Game.Rulesets.Mania.Judgements;
+using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Mania.Objects.Drawables
+{
+    /// <summary>
+    /// Visualises a <see cref="Note"/> hit object.
+    /// </summary>
+    public class DrawableNote : DrawableManiaHitObject<Note>
+    {
+        private readonly NotePiece headPiece;
+
+        public DrawableNote(Note hitObject, Bindable<Key> key = null)
+            : base(hitObject, key)
+        {
+            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 CheckJudgement(bool userTriggered)
+        {
+            if (!userTriggered)
+            {
+                if (Judgement.TimeOffset > HitObject.HitWindows.Bad / 2)
+                    Judgement.Result = HitResult.Miss;
+                return;
+            }
+
+            double offset = Math.Abs(Judgement.TimeOffset);
+
+            if (offset > HitObject.HitWindows.Miss / 2)
+                return;
+
+            ManiaHitResult? tmpResult = HitObject.HitWindows.ResultFor(offset);
+
+            if (tmpResult.HasValue)
+            {
+                Judgement.Result = HitResult.Hit;
+                Judgement.ManiaResult = tmpResult.Value;
+            }
+            else
+                Judgement.Result = HitResult.Miss;
+        }
+
+        protected override void UpdateState(ArmedState state)
+        {
+            switch (State)
+            {
+                case ArmedState.Hit:
+                    Colour = Color4.Green;
+                    break;
+            }
+        }
+
+        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        {
+            if (Judgement.Result != HitResult.None)
+                return false;
+
+            if (args.Key != Key)
+                return false;
+
+            if (args.Repeat)
+                return false;
+
+            return UpdateJudgement(true);
+        }
+    }
+}

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/BodyPiece.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 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;
+
+            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,109 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System.Collections.Generic;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Database;
+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 : ManiaHitObject, IHasEndTime
     {
+        public double EndTime => StartTime + Duration;
+
+        private double duration;
+        public double Duration
+        {
+            get { return duration; }
+            set
+            {
+                duration = value;
+                Tail.StartTime = EndTime;
+            }
+        }
+
+        public override double StartTime
+        {
+            get { return base.StartTime; }
+            set
+            {
+                base.StartTime = value;
+                Head.StartTime = value;
+                Tail.StartTime = EndTime;
+            }
+        }
+
+        /// <summary>
+        /// The head note of the hold.
+        /// </summary>
+        public readonly Note Head = new Note();
+
+        /// <summary>
+        /// The tail note of the hold.
+        /// </summary>
+        public readonly Note Tail = new TailNote();
+
+        /// <summary>
+        /// The time between ticks of this hold.
+        /// </summary>
+        private double tickSpacing = 50;
+
+        public override void ApplyDefaults(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
+        {
+            base.ApplyDefaults(controlPointInfo, difficulty);
+
+            TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
+            tickSpacing = timingPoint.BeatLength / difficulty.SliderTickRate;
+
+            Head.ApplyDefaults(controlPointInfo, difficulty);
+            Tail.ApplyDefaults(controlPointInfo, difficulty);
+        }
+
+        /// <summary>
+        /// The scoring scoring ticks of the hold note.
+        /// </summary>
+        public IEnumerable<HoldNoteTick> Ticks => ticks ?? (ticks = createTicks());
+        private List<HoldNoteTick> ticks;
+
+        private List<HoldNoteTick> createTicks()
+        {
+            var ret = new List<HoldNoteTick>();
+
+            if (tickSpacing == 0)
+                return ret;
+
+            for (double t = StartTime + tickSpacing; t <= EndTime - tickSpacing; t += tickSpacing)
+            {
+                ret.Add(new HoldNoteTick
+                {
+                    StartTime = t
+                });
+            }
+
+            return ret;
+        }
+
+        /// <summary>
+        /// The tail of the hold note.
+        /// </summary>
+        private class TailNote : Note
+        {
+            /// <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 override void ApplyDefaults(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
+            {
+                base.ApplyDefaults(controlPointInfo, difficulty);
+
+                HitWindows *= release_window_lenience;
+            }
+        }
     }
 }

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

@@ -0,0 +1,12 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Rulesets.Mania.Objects
+{
+    /// <summary>
+    /// A scoring tick of a hold note.
+    /// </summary>
+    public class HoldNoteTick : ManiaHitObject
+    {
+    }
+}

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.ControlPoints;
+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>
+        public HitWindows HitWindows { get; protected set; } = new HitWindows();
+
+        public override void ApplyDefaults(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
+        {
+            base.ApplyDefaults(controlPointInfo, 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

@@ -1,26 +1,295 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System;
+using System.Linq;
+using osu.Game.Beatmaps;
+using osu.Game.Database;
 using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Mania.Scoring
 {
-    internal class ManiaScoreProcessor : ScoreProcessor<ManiaBaseHit, ManiaJudgement>
+    internal class ManiaScoreProcessor : ScoreProcessor<ManiaHitObject, ManiaJudgement>
     {
+        /// <summary>
+        /// The maximum score achievable.
+        /// Does _not_ include bonus score - for bonus score see <see cref="bonusScore"/>.
+        /// </summary>
+        private const int max_score = 1000000;
+
+        /// <summary>
+        /// The amount of the score attributed to combo.
+        /// </summary>
+        private const double combo_portion_max = max_score * 0.2;
+
+        /// <summary>
+        /// The amount of the score attributed to accuracy.
+        /// </summary>
+        private const double accuracy_portion_max = max_score * 0.8;
+
+        /// <summary>
+        /// The factor used to determine relevance of combos.
+        /// </summary>
+        private const double combo_base = 4;
+
+        /// <summary>
+        /// The combo value at which hit objects result in the max score possible.
+        /// </summary>
+        private const int combo_relevance_cap = 400;
+
+        /// <summary>
+        /// The hit HP multiplier at OD = 0.
+        /// </summary>
+        private const double hp_multiplier_min = 0.75;
+
+        /// <summary>
+        /// The hit HP multiplier at OD = 0.
+        /// </summary>
+        private const double hp_multiplier_mid = 0.85;
+
+        /// <summary>
+        /// The hit HP multiplier at OD = 0.
+        /// </summary>
+        private const double hp_multiplier_max = 1;
+
+        /// <summary>
+        /// The default BAD hit HP increase.
+        /// </summary>
+        private const double hp_increase_bad = 0.005;
+
+        /// <summary>
+        /// The default OK hit HP increase.
+        /// </summary>
+        private const double hp_increase_ok = 0.010;
+
+        /// <summary>
+        /// The default GOOD hit HP increase.
+        /// </summary>
+        private const double hp_increase_good = 0.035;
+
+        /// <summary>
+        /// The default tick hit HP increase.
+        /// </summary>
+        private const double hp_increase_tick = 0.040;
+
+        /// <summary>
+        /// The default GREAT hit HP increase.
+        /// </summary>
+        private const double hp_increase_great = 0.055;
+
+        /// <summary>
+        /// The default PERFECT hit HP increase.
+        /// </summary>
+        private const double hp_increase_perfect = 0.065;
+
+        /// <summary>
+        /// The MISS HP multiplier at OD = 0.
+        /// </summary>
+        private const double hp_multiplier_miss_min = 0.5;
+
+        /// <summary>
+        /// The MISS HP multiplier at OD = 5.
+        /// </summary>
+        private const double hp_multiplier_miss_mid = 0.75;
+
+        /// <summary>
+        /// The MISS HP multiplier at OD = 10.
+        /// </summary>
+        private const double hp_multiplier_miss_max = 1;
+
+        /// <summary>
+        /// The default MISS HP increase.
+        /// </summary>
+        private const double hp_increase_miss = -0.125;
+
+        /// <summary>
+        /// The MISS HP multiplier. This is multiplied to the miss hp increase.
+        /// </summary>
+        private double hpMissMultiplier = 1;
+
+        /// <summary>
+        /// The HIT HP multiplier. This is multiplied to hit hp increases.
+        /// </summary>
+        private double hpMultiplier = 1;
+
+        /// <summary>
+        /// The cumulative combo portion of the score.
+        /// </summary>
+        private double comboScore => combo_portion_max * comboPortion / maxComboPortion;
+
+        /// <summary>
+        /// The cumulative accuracy portion of the score.
+        /// </summary>
+        private double accuracyScore => accuracy_portion_max * Math.Pow(Accuracy, 4) * totalHits / maxTotalHits;
+
+        /// <summary>
+        /// The cumulative bonus score.
+        /// This is added on top of <see cref="max_score"/>, thus the total score can exceed <see cref="max_score"/>.
+        /// </summary>
+        private double bonusScore;
+
+        /// <summary>
+        /// The <see cref="comboPortion"/> achieved by a perfect playthrough.
+        /// </summary>
+        private double maxComboPortion;
+
+        /// <summary>
+        /// The portion of the score dedicated to combo.
+        /// </summary>
+        private double comboPortion;
+
+        /// <summary>
+        /// The <see cref="totalHits"/> achieved by a perfect playthrough.
+        /// </summary>
+        private int maxTotalHits;
+
+        /// <summary>
+        /// The total hits.
+        /// </summary>
+        private int totalHits;
+
         public ManiaScoreProcessor()
         {
         }
 
-        public ManiaScoreProcessor(HitRenderer<ManiaBaseHit, ManiaJudgement> hitRenderer)
+        public ManiaScoreProcessor(HitRenderer<ManiaHitObject, ManiaJudgement> hitRenderer)
             : base(hitRenderer)
         {
         }
 
+        protected override void ComputeTargets(Beatmap<ManiaHitObject> beatmap)
+        {
+            BeatmapDifficulty difficulty = beatmap.BeatmapInfo.Difficulty;
+            hpMultiplier = BeatmapDifficulty.DifficultyRange(difficulty.DrainRate, hp_multiplier_min, hp_multiplier_mid, hp_multiplier_max);
+            hpMissMultiplier = BeatmapDifficulty.DifficultyRange(difficulty.DrainRate, hp_multiplier_miss_min, hp_multiplier_miss_mid, hp_multiplier_miss_max);
+
+            while (true)
+            {
+                foreach (var obj in beatmap.HitObjects)
+                {
+                    var holdNote = obj as HoldNote;
+
+                    if (obj is Note)
+                    {
+                        AddJudgement(new ManiaJudgement
+                        {
+                            Result = HitResult.Hit,
+                            ManiaResult = ManiaHitResult.Perfect
+                        });
+                    }
+                    else if (holdNote != null)
+                    {
+                        // Head
+                        AddJudgement(new ManiaJudgement
+                        {
+                            Result = HitResult.Hit,
+                            ManiaResult = ManiaJudgement.MAX_HIT_RESULT
+                        });
+
+                        // Ticks
+                        int tickCount = holdNote.Ticks.Count();
+                        for (int i = 0; i < tickCount; i++)
+                        {
+                            AddJudgement(new HoldNoteTickJudgement
+                            {
+                                Result = HitResult.Hit,
+                                ManiaResult = ManiaJudgement.MAX_HIT_RESULT,
+                            });
+                        }
+
+                        AddJudgement(new HoldNoteTailJudgement
+                        {
+                            Result = HitResult.Hit,
+                            ManiaResult = ManiaJudgement.MAX_HIT_RESULT
+                        });
+                    }
+                }
+
+                if (!HasFailed)
+                    break;
+
+                hpMultiplier *= 1.01;
+                hpMissMultiplier *= 0.98;
+
+                Reset();
+            }
+
+            maxTotalHits = totalHits;
+            maxComboPortion = comboPortion;
+        }
+
         protected override void OnNewJudgement(ManiaJudgement judgement)
         {
+            bool isTick = judgement is HoldNoteTickJudgement;
+
+            if (!isTick)
+                totalHits++;
+
+            switch (judgement.Result)
+            {
+                case HitResult.Miss:
+                    Health.Value += hpMissMultiplier * hp_increase_miss;
+                    break;
+                case HitResult.Hit:
+                    if (isTick)
+                    {
+                        Health.Value += hpMultiplier * hp_increase_tick;
+                        bonusScore += judgement.ResultValueForScore;
+                    }
+                    else
+                    {
+                        switch (judgement.ManiaResult)
+                        {
+                            case ManiaHitResult.Bad:
+                                Health.Value += hpMultiplier * hp_increase_bad;
+                                break;
+                            case ManiaHitResult.Ok:
+                                Health.Value += hpMultiplier * hp_increase_ok;
+                                break;
+                            case ManiaHitResult.Good:
+                                Health.Value += hpMultiplier * hp_increase_good;
+                                break;
+                            case ManiaHitResult.Great:
+                                Health.Value += hpMultiplier * hp_increase_great;
+                                break;
+                            case ManiaHitResult.Perfect:
+                                Health.Value += hpMultiplier * hp_increase_perfect;
+                                break;
+                        }
+
+                        // A factor that is applied to make higher combos more relevant
+                        double comboRelevance = Math.Min(Math.Max(0.5, Math.Log(Combo.Value, combo_base)), Math.Log(combo_relevance_cap, combo_base));
+                        comboPortion += judgement.ResultValueForScore * comboRelevance;
+                    }
+                    break;
+            }
+
+            int scoreForAccuracy = 0;
+            int maxScoreForAccuracy = 0;
+
+            foreach (var j in Judgements)
+            {
+                scoreForAccuracy += j.ResultValueForAccuracy;
+                maxScoreForAccuracy += j.MaxResultValueForAccuracy;
+            }
+
+            Accuracy.Value = (double)scoreForAccuracy / maxScoreForAccuracy;
+            TotalScore.Value = comboScore + accuracyScore + bonusScore;
+        }
+
+        protected override void Reset()
+        {
+            base.Reset();
+
+            Health.Value = 1;
+
+            bonusScore = 0;
+            comboPortion = 0;
+            totalHits = 0;
         }
     }
 }

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

@@ -0,0 +1,156 @@
+// 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.ControlPoints;
+using osu.Game.Rulesets.Objects;
+
+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<TimingChange> 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 InvalidOperationException("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 TimingChange 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(TimingChange 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);
+                RelativeChildSize = 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
+            {
+                protected override IComparer<Drawable> DepthComparer => new HitObjectReverseStartTimeComparer();
+
+                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.RequiredParentSizeToFit) == 0)
+                    {
+                        base.InvalidateFromChild(invalidation);
+                        return;
+                    }
+
+                    if (!Children.Any())
+                        return;
+
+                    float height = Children.Select(child => child.Y + child.Height).Max();
+
+                    Height = height;
+                    RelativeChildSize = new Vector2(1, height);
+
+                    base.InvalidateFromChild(invalidation);
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Rulesets.Mania.Timing
+{
+    public class TimingChange
+    {
+        /// <summary>
+        /// The time at which this timing change happened.
+        /// </summary>
+        public double Time;
+
+        /// <summary>
+        /// The beat length.
+        /// </summary>
+        public double BeatLength = 500;
+
+        /// <summary>
+        /// The speed multiplier.
+        /// </summary>
+        public double SpeedMultiplier = 1;
+    }
+}

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

@@ -0,0 +1,240 @@
+// 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 System;
+using osu.Framework.Configuration;
+
+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;
+
+        /// <summary>
+        /// The key that will trigger input actions for this column and hit objects contained inside it.
+        /// </summary>
+        public Bindable<Key> Key = new Bindable<Key>();
+
+        private readonly Box background;
+        private readonly Container hitTargetBar;
+        private readonly Container keyIcon;
+
+        public readonly ControlPointContainer ControlPointContainer;
+
+        public Column(IEnumerable<TimingChange> 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,
+                        },
+                        // For column lighting, we need to capture input events before the notes
+                        new InputTarget
+                        {
+                            KeyDown = onKeyDown,
+                            KeyUp = onKeyUp
+                        }
+                    }
+                },
+                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)
+        {
+            hitObject.AccentColour = AccentColour;
+            ControlPointContainer.Add(hitObject);
+        }
+
+        private 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;
+        }
+
+        private 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;
+        }
+
+        /// <summary>
+        /// This is a simple container which delegates various input events that have to be captured before the notes.
+        /// </summary>
+        private class InputTarget : Container
+        {
+            public Func<InputState, KeyDownEventArgs, bool> KeyDown;
+            public Func<InputState, KeyUpEventArgs, bool> KeyUp;
+
+            public InputTarget()
+            {
+                RelativeSizeAxes = Axes.Both;
+                AlwaysPresent = true;
+                Alpha = 0;
+            }
+
+            protected override bool OnKeyDown(InputState state, KeyDownEventArgs args) => KeyDown?.Invoke(state, args) ?? false;
+            protected override bool OnKeyUp(InputState state, KeyUpEventArgs args) => KeyUp?.Invoke(state, args) ?? false;
+        }
+    }
+}

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

@@ -1,34 +1,143 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using OpenTK;
+using OpenTK.Input;
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics;
+using osu.Framework.Lists;
+using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Beatmaps;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.Scoring;
+using osu.Game.Rulesets.Mania.Timing;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.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)
-            : base(beatmap)
+        public ManiaHitRenderer(WorkingBeatmap beatmap, bool isForCurrentRuleset)
+            : base(beatmap, isForCurrentRuleset)
         {
-            this.columns = columns;
+        }
+
+        protected override Playfield<ManiaHitObject, ManiaJudgement> CreatePlayfield()
+        {
+            double lastSpeedMultiplier = 1;
+            double lastBeatLength = 500;
+
+            // Merge timing + difficulty points
+            var allPoints = new SortedList<ControlPoint>(Comparer<ControlPoint>.Default);
+            allPoints.AddRange(Beatmap.ControlPointInfo.TimingPoints);
+            allPoints.AddRange(Beatmap.ControlPointInfo.DifficultyPoints);
+
+            // Generate the timing points, making non-timing changes use the previous timing change
+            var timingChanges = allPoints.Select(c =>
+            {
+                var timingPoint = c as TimingControlPoint;
+                var difficultyPoint = c as DifficultyControlPoint;
+
+                if (timingPoint != null)
+                    lastBeatLength = timingPoint.BeatLength;
+
+                if (difficultyPoint != null)
+                    lastSpeedMultiplier = difficultyPoint.SpeedMultiplier;
+
+                return new TimingChange
+                {
+                    Time = c.Time,
+                    BeatLength = lastBeatLength,
+                    SpeedMultiplier = lastSpeedMultiplier
+                };
+            });
+
+            double lastObjectTime = (Objects.LastOrDefault() as IHasEndTime)?.EndTime ?? Objects.LastOrDefault()?.StartTime ?? double.MaxValue;
+
+            // 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)
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            var maniaPlayfield = (ManiaPlayfield)Playfield;
+
+            double lastObjectTime = (Objects.LastOrDefault() as IHasEndTime)?.EndTime ?? Objects.LastOrDefault()?.StartTime ?? double.MaxValue;
+
+            SortedList<TimingControlPoint> timingPoints = Beatmap.ControlPointInfo.TimingPoints;
+            for (int i = 0; i < timingPoints.Count; i++)
+            {
+                TimingControlPoint point = timingPoints[i];
+
+                // Stop on the beat before the next timing point, or if there is no next timing point stop slightly past the last object
+                double endTime = i < timingPoints.Count - 1 ? timingPoints[i + 1].Time - point.BeatLength : lastObjectTime + point.BeatLength * (int)point.TimeSignature;
+
+                int index = 0;
+                for (double t = timingPoints[i].Time; Precision.DefinitelyBigger(endTime, t); t += point.BeatLength, index++)
+                {
+                    maniaPlayfield.Add(new DrawableBarLine(new BarLine
+                    {
+                        StartTime = t,
+                        ControlPoint = point,
+                        BeatIndex = index
+                    }));
+                }
+            }
         }
 
         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 maniaPlayfield = Playfield as ManiaPlayfield;
+            if (maniaPlayfield == null)
+                return null;
 
-        protected override DrawableHitObject<ManiaBaseHit, ManiaJudgement> GetVisualRepresentation(ManiaBaseHit h) => null;
+            Bindable<Key> key = maniaPlayfield.Columns.ElementAt(h.Column).Key;
+
+            var holdNote = h as HoldNote;
+            if (holdNote != null)
+                return new DrawableHoldNote(holdNote, key);
+
+            var note = h as Note;
+            if (note != null)
+                return new DrawableNote(note, key);
+
+            return null;
+        }
+
+        protected override Vector2 GetPlayfieldAspectAdjust() => new Vector2(1, 0.8f);
     }
 }

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

@@ -8,29 +8,278 @@ 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.Framework.Graphics.Transforms;
+using osu.Framework.MathUtils;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
 
 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 });
+        private readonly FlowContainer<Column> columns;
+        public IEnumerable<Column> Columns => columns.Children;
 
-            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<TimingChange> timingChanges)
+        {
+            this.columnCount = columnCount;
+
+            if (columnCount <= 0)
+                throw new ArgumentException("Can't have zero or fewer columns.");
+
+            Children = new Drawable[]
+            {
+                new Container
                 {
-                    RelativeSizeAxes = Axes.Y,
-                    Size = new Vector2(2, 1),
-                    RelativePositionAxes = Axes.Both,
-                    Position = new Vector2((float)i / columns, 0),
-                    Alpha = 0.5f,
-                    Colour = Color4.Black
-                });
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    Children = new Drawable[]
+                    {
+                        new Container
+                        {
+                            Name = "Masked elements",
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                            RelativeSizeAxes = Axes.Y,
+                            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
+                        {
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                            RelativeSizeAxes = Axes.Both,
+                            Padding = new MarginPadding { Top = HIT_TARGET_POSITION },
+                            Children = new[]
+                            {
+                                barLineContainer = new ControlPointContainer(timingChanges)
+                                {
+                                    Name = "Bar lines",
+                                    Anchor = Anchor.TopCentre,
+                                    Origin = Anchor.TopCentre,
+                                    RelativeSizeAxes = Axes.Y
+                                    // Width is set in the Update method
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            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.ElementAt(i);
+                column.IsSpecial = isSpecialColumn(i);
+
+                if (!column.IsSpecial)
+                    continue;
+
+                column.Key.Value = Key.Space;
+                column.AccentColour = specialColumnColour;
+            }
+
+            var nonSpecialColumns = Columns.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.Value = default_keys[keyOffset];
+                else
+                    // There is no default key defined for this column. Let's set this to Unknown for now
+                    // however note that this will be gone after bindings are in place
+                    column.Key.Value = Key.Unknown;
+            }
+        }
+
+        /// <summary>
+        /// 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.ElementAt(h.HitObject.Column).Add(h);
+        public void Add(DrawableBarLine barline) => barLineContainer.Add(barline);
+
+        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.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());
+        }
+
+        protected override void Update()
+        {
+            // Due to masking differences, it is not possible to get the width of the columns container automatically
+            // While masking on effectively only the Y-axis, so we need to set the width of the bar line container manually
+            barLineContainer.Width = columns.Width;
+        }
+
+        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

@@ -47,19 +47,44 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Beatmaps\Patterns\Legacy\EndTimeObjectPatternGenerator.cs" />
+    <Compile Include="Beatmaps\Patterns\Legacy\DistanceObjectPatternGenerator.cs" />
+    <Compile Include="Beatmaps\Patterns\Legacy\PatternGenerator.cs" />
+    <Compile Include="Beatmaps\Patterns\PatternGenerator.cs" />
+    <Compile Include="Beatmaps\Patterns\Legacy\HitObjectPatternGenerator.cs" />
+    <Compile Include="Beatmaps\Patterns\Legacy\PatternType.cs" />
     <Compile Include="Beatmaps\ManiaBeatmapConverter.cs" />
+    <Compile Include="Beatmaps\Patterns\Pattern.cs" />
+    <Compile Include="MathUtils\FastRandom.cs" />
+    <Compile Include="Judgements\HitWindows.cs" />
+    <Compile Include="Judgements\HoldNoteTailJudgement.cs" />
+    <Compile Include="Judgements\HoldNoteTickJudgement.cs" />
+    <Compile Include="Judgements\ManiaHitResult.cs" />
     <Compile Include="Judgements\ManiaJudgement.cs" />
     <Compile Include="ManiaDifficultyCalculator.cs" />
+    <Compile Include="Objects\Drawables\DrawableBarLine.cs" />
+    <Compile Include="Objects\Drawables\DrawableHoldNote.cs" />
+    <Compile Include="Objects\Drawables\DrawableHoldNoteTick.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\BarLine.cs" />
     <Compile Include="Objects\HoldNote.cs" />
-    <Compile Include="Objects\ManiaBaseHit.cs" />
+    <Compile Include="Objects\HoldNoteTick.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" />
+    <Compile Include="Timing\TimingChange.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\osu-framework\osu.Framework\osu.Framework.csproj">

osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapConverter.cs

@@ -19,10 +19,10 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
 
         protected override IEnumerable<OsuHitObject> ConvertHitObject(HitObject original, Beatmap beatmap)
         {
-            IHasCurve curveData = original as IHasCurve;
-            IHasEndTime endTimeData = original as IHasEndTime;
-            IHasPosition positionData = original as IHasPosition;
-            IHasCombo comboData = original as IHasCombo;
+            var curveData = original as IHasCurve;
+            var endTimeData = original as IHasEndTime;
+            var positionData = original as IHasPosition;
+            var comboData = original as IHasCombo;
 
             if (curveData != null)
             {
@@ -30,7 +30,11 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                 {
                     StartTime = original.StartTime,
                     Samples = original.Samples,
-                    CurveObject = curveData,
+                    ControlPoints = curveData.ControlPoints,
+                    CurveType = curveData.CurveType,
+                    Distance = curveData.Distance,
+                    RepeatSamples = curveData.RepeatSamples,
+                    RepeatCount = curveData.RepeatCount,
                     Position = positionData?.Position ?? Vector2.Zero,
                     NewCombo = comboData?.NewCombo ?? false
                 };

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

@@ -3,6 +3,7 @@
 
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
+using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using System;
@@ -38,6 +39,11 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModAutopilot) }).ToArray();
     }
 
+    public class OsuModDaycore : ModDaycore
+    {
+        public override double ScoreMultiplier => 0.5;
+    }
+
     public class OsuModDoubleTime : ModDoubleTime
     {
         public override double ScoreMultiplier => 1.12;
@@ -91,11 +97,11 @@ 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
         {
-            Replay = new OsuAutoReplay(beatmap)
+            Replay = new OsuAutoGenerator(beatmap).Generate()
         };
     }
 

osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPoint.cs

@@ -12,16 +12,11 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
 {
     public class FollowPoint : Container
     {
-        public double StartTime;
-        public double EndTime;
-        public Vector2 EndPosition;
-
         private const float width = 8;
 
         public FollowPoint()
         {
             Origin = Anchor.Centre;
-            Alpha = 0;
 
             Masking = true;
             AutoSizeAxes = Axes.Both;
@@ -45,22 +40,5 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
                 },
             };
         }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            Delay(StartTime);
-            FadeIn(DrawableOsuHitObject.TIME_FADEIN);
-            ScaleTo(1.5f);
-            ScaleTo(1, DrawableOsuHitObject.TIME_FADEIN, EasingTypes.Out);
-            MoveTo(EndPosition, DrawableOsuHitObject.TIME_FADEIN, EasingTypes.Out);
-
-            Delay(EndTime - StartTime);
-            FadeOut(DrawableOsuHitObject.TIME_FADEIN);
-
-            Delay(DrawableOsuHitObject.TIME_FADEIN);
-            Expire(true);
-        }
     }
-}
+}

osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPointRenderer.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using OpenTK;
+using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
@@ -80,14 +81,28 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
                         double fadeOutTime = startTime + fraction * duration;
                         double fadeInTime = fadeOutTime - PreEmpt;
 
-                        Add(new FollowPoint
+                        FollowPoint fp;
+
+                        Add(fp = new FollowPoint
                         {
-                            StartTime = fadeInTime,
-                            EndTime = fadeOutTime,
                             Position = pointStartPosition,
-                            EndPosition = pointEndPosition,
                             Rotation = rotation,
+                            Alpha = 0,
+                            Scale = new Vector2(1.5f),
                         });
+
+                        using (fp.BeginAbsoluteSequence(fadeInTime))
+                        {
+                            fp.FadeIn(DrawableOsuHitObject.TIME_FADEIN);
+                            fp.ScaleTo(1, DrawableOsuHitObject.TIME_FADEIN, EasingTypes.Out);
+
+                            fp.MoveTo(pointEndPosition, DrawableOsuHitObject.TIME_FADEIN, EasingTypes.Out);
+
+                            fp.Delay(fadeOutTime - fadeInTime);
+                            fp.FadeOut(DrawableOsuHitObject.TIME_FADEIN);
+                        }
+
+                        fp.Expire(true);
                     }
                 }
                 prevHitObject = currHitObject;

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

@@ -104,10 +104,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             ApproachCircle.ScaleTo(1.1f, TIME_PREEMPT);
         }
 
-        protected override void UpdateState(ArmedState state)
+        protected override void UpdateCurrentState(ArmedState state)
         {
-            base.UpdateState(state);
-
             ApproachCircle.FadeOut();
 
             double endTime = (HitObject as IHasEndTime)?.EndTime ?? HitObject.StartTime;

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

@@ -21,17 +21,23 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         protected override OsuJudgement CreateJudgement() => new OsuJudgement { MaxScore = OsuScoreResult.Hit300 };
 
-        protected override void UpdateState(ArmedState state)
+        protected sealed override void UpdateState(ArmedState state)
         {
             Flush();
 
             UpdateInitialState();
 
-            Delay(HitObject.StartTime - Time.Current - TIME_PREEMPT + Judgement.TimeOffset, true);
+            using (BeginAbsoluteSequence(HitObject.StartTime - TIME_PREEMPT, true))
+            {
+                UpdatePreemptState();
 
-            UpdatePreemptState();
+                using (BeginDelayedSequence(TIME_PREEMPT + Judgement.TimeOffset, true))
+                    UpdateCurrentState(state);
+            }
+        }
 
-            Delay(TIME_PREEMPT, true);
+        protected virtual void UpdateCurrentState(ArmedState state)
+        {
         }
 
         protected virtual void UpdatePreemptState()

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

@@ -158,10 +158,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             ball.Alpha = 0;
         }
 
-        protected override void UpdateState(ArmedState state)
+        protected override void UpdateCurrentState(ArmedState state)
         {
-            base.UpdateState(state);
-
             ball.FadeIn();
 
             Delay(slider.Duration, true);
@@ -181,4 +179,4 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
     {
         void UpdateProgress(double progress, int repeat);
     }
-}
+}

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

@@ -72,10 +72,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             Delay(-animIn);
         }
 
-        protected override void UpdateState(ArmedState state)
+        protected override void UpdateCurrentState(ArmedState state)
         {
-            base.UpdateState(state);
-
             switch (state)
             {
                 case ArmedState.Idle:
@@ -93,4 +91,4 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             }
         }
     }
-}
+}

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,22 @@ 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 readonly Color4 baseColour = OsuColour.FromHex(@"002c3c");
+        private readonly Color4 fillColour = OsuColour.FromHex(@"005b7c");
+
+        private Color4 normalColour;
+        private Color4 completeColour;
 
         public DrawableSpinner(Spinner s) : base(s)
         {
@@ -29,57 +43,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,36 +154,52 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             }
         }
 
-        private Vector2 scaleToCircle => circle.Scale * circle.DrawWidth / DrawWidth * 0.95f;
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            normalColour = baseColour;
 
-        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.75f);
 
-        public float Progress => MathHelper.Clamp(disc.RotationAbsolute / 360 / rotationsNeeded, 0, 1);
+            disc.AccentColour = fillColour;
+            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 UpdateState(ArmedState state)
+        protected override void UpdateCurrentState(ArmedState state)
         {
-            base.UpdateState(state);
-
             Delay(spinner.Duration, true);
 
             FadeOut(160);

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.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
+                {
+                    Hollow = true,
+                    Type = EdgeEffectType.Glow,
+                    Radius = 40,
+                    Colour = value,
+                };
+            }
+        }
+
+        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.2f, 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,57 @@
+// 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.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    public class SpinnerTicks : Container
+    {
+        public SpinnerTicks()
+        {
+            Origin = Anchor.Centre;
+            Anchor = Anchor.Centre;
+            RelativeSizeAxes = Axes.Both;
+
+            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 = 10,
+                        Colour = Color4.Gray.Opacity(0.2f),
+                    },
+                    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/OsuHitObject.cs

@@ -6,8 +6,8 @@ using OpenTK;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using OpenTK.Graphics;
-using osu.Game.Beatmaps.Timing;
 using osu.Game.Database;
+using osu.Game.Beatmaps.ControlPoints;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {
@@ -68,9 +68,9 @@ namespace osu.Game.Rulesets.Osu.Objects
             return OsuScoreResult.Miss;
         }
 
-        public override void ApplyDefaults(TimingInfo timing, BeatmapDifficulty difficulty)
+        public override void ApplyDefaults(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
         {
-            base.ApplyDefaults(timing, difficulty);
+            base.ApplyDefaults(controlPointInfo, difficulty);
 
             Scale = (1.0f - 0.7f * (difficulty.CircleSize - 5) / 5) / 2;
         }

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

@@ -1,201 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using OpenTK;
-using System;
-using System.Diagnostics;
-using System.Linq;
-
-namespace osu.Game.Rulesets.Osu.Objects
-{
-    internal class OsuHitObjectDifficulty
-    {
-        /// <summary>
-        /// Factor by how much speed / aim strain decays per second.
-        /// </summary>
-        /// <remarks>
-        /// These values are results of tweaking a lot and taking into account general feedback.
-        /// Opinionated observation: Speed is easier to maintain than accurate jumps.
-        /// </remarks>
-        internal static readonly double[] DECAY_BASE = { 0.3, 0.15 };
-
-        /// <summary>
-        /// Pseudo threshold values to distinguish between "singles" and "streams"
-        /// </summary>
-        /// <remarks>
-        ///  Of course the border can not be defined clearly, therefore the algorithm has a smooth transition between those values.
-        ///  They also are based on tweaking and general feedback.
-        /// </remarks>
-        private const double stream_spacing_threshold = 110,
-                             single_spacing_threshold = 125;
-
-        /// <summary>
-        /// Scaling values for weightings to keep aim and speed difficulty in balance.
-        /// </summary>
-        /// <remarks>
-        /// Found from testing a very large map pool (containing all ranked maps) and keeping the average values the same.
-        /// </remarks>
-        private static readonly double[] spacing_weight_scaling = { 1400, 26.25 };
-
-        /// <summary>
-        /// Almost the normed diameter of a circle (104 osu pixel). That is -after- position transforming.
-        /// </summary>
-        private const double almost_diameter = 90;
-
-        internal OsuHitObject BaseHitObject;
-        internal double[] Strains = { 1, 1 };
-
-        internal int MaxCombo = 1;
-
-        private readonly float scalingFactor;
-        private float lazySliderLength;
-
-        private readonly Vector2 startPosition;
-        private readonly Vector2 endPosition;
-
-        internal OsuHitObjectDifficulty(OsuHitObject baseHitObject)
-        {
-            BaseHitObject = baseHitObject;
-            float circleRadius = baseHitObject.Scale * 64;
-
-            Slider slider = BaseHitObject as Slider;
-            if (slider != null)
-                MaxCombo += slider.Ticks.Count();
-
-            // We will scale everything by this factor, so we can assume a uniform CircleSize among beatmaps.
-            scalingFactor = 52.0f / circleRadius;
-            if (circleRadius < 30)
-            {
-                float smallCircleBonus = Math.Min(30.0f - circleRadius, 5.0f) / 50.0f;
-                scalingFactor *= 1.0f + smallCircleBonus;
-            }
-
-            lazySliderLength = 0;
-            startPosition = baseHitObject.StackedPosition;
-
-            // Calculate approximation of lazy movement on the slider
-            if (slider != null)
-            {
-                float sliderFollowCircleRadius = circleRadius * 3; // Not sure if this is correct, but here we do not need 100% exact values. This comes pretty darn close in my tests.
-
-                // For simplifying this step we use actual osu! coordinates and simply scale the length, that we obtain by the ScalingFactor later
-                Vector2 cursorPos = startPosition;
-
-                Action<Vector2> addSliderVertex = delegate (Vector2 pos)
-                {
-                    Vector2 difference = pos - cursorPos;
-                    float distance = difference.Length;
-
-                    // Did we move away too far?
-                    if (distance > sliderFollowCircleRadius)
-                    {
-                        // Yep, we need to move the cursor
-                        difference.Normalize(); // Obtain the direction of difference. We do no longer need the actual difference
-                        distance -= sliderFollowCircleRadius;
-                        cursorPos += difference * distance; // We move the cursor just as far as needed to stay in the follow circle
-                        lazySliderLength += distance;
-                    }
-                };
-
-                // Actual computation of the first lazy curve
-                foreach (var tick in slider.Ticks)
-                    addSliderVertex(tick.StackedPosition);
-
-                addSliderVertex(baseHitObject.StackedEndPosition);
-
-                lazySliderLength *= scalingFactor;
-                endPosition = cursorPos;
-            }
-            // We have a normal HitCircle or a spinner
-            else
-                endPosition = startPosition;
-        }
-
-        internal void CalculateStrains(OsuHitObjectDifficulty previousHitObject, double timeRate)
-        {
-            calculateSpecificStrain(previousHitObject, OsuDifficultyCalculator.DifficultyType.Speed, timeRate);
-            calculateSpecificStrain(previousHitObject, OsuDifficultyCalculator.DifficultyType.Aim, timeRate);
-        }
-
-        // Caution: The subjective values are strong with this one
-        private static double spacingWeight(double distance, OsuDifficultyCalculator.DifficultyType type)
-        {
-            switch (type)
-            {
-                case OsuDifficultyCalculator.DifficultyType.Speed:
-                    if (distance > single_spacing_threshold)
-                        return 2.5;
-                    else if (distance > stream_spacing_threshold)
-                        return 1.6 + 0.9 * (distance - stream_spacing_threshold) / (single_spacing_threshold - stream_spacing_threshold);
-                    else if (distance > almost_diameter)
-                        return 1.2 + 0.4 * (distance - almost_diameter) / (stream_spacing_threshold - almost_diameter);
-                    else if (distance > almost_diameter / 2)
-                        return 0.95 + 0.25 * (distance - almost_diameter / 2) / (almost_diameter / 2);
-                    else
-                        return 0.95;
-
-                case OsuDifficultyCalculator.DifficultyType.Aim:
-                    return Math.Pow(distance, 0.99);
-            }
-
-            Debug.Assert(false, "Invalid osu difficulty hit object type.");
-            return 0;
-        }
-
-        private void calculateSpecificStrain(OsuHitObjectDifficulty previousHitObject, OsuDifficultyCalculator.DifficultyType type, double timeRate)
-        {
-            double addition = 0;
-            double timeElapsed = (BaseHitObject.StartTime - previousHitObject.BaseHitObject.StartTime) / timeRate;
-            double decay = Math.Pow(DECAY_BASE[(int)type], timeElapsed / 1000);
-
-            if (BaseHitObject is Spinner)
-            {
-                // Do nothing for spinners
-            }
-            else if (BaseHitObject is Slider)
-            {
-                switch (type)
-                {
-                    case OsuDifficultyCalculator.DifficultyType.Speed:
-
-                        // For speed strain we treat the whole slider as a single spacing entity, since "Speed" is about how hard it is to click buttons fast.
-                        // The spacing weight exists to differentiate between being able to easily alternate or having to single.
-                        addition =
-                            spacingWeight(previousHitObject.lazySliderLength +
-                                          DistanceTo(previousHitObject), type) *
-                            spacing_weight_scaling[(int)type];
-
-                        break;
-                    case OsuDifficultyCalculator.DifficultyType.Aim:
-
-                        // For Aim strain we treat each slider segment and the jump after the end of the slider as separate jumps, since movement-wise there is no difference
-                        // to multiple jumps.
-                        addition =
-                            (
-                                spacingWeight(previousHitObject.lazySliderLength, type) +
-                                spacingWeight(DistanceTo(previousHitObject), type)
-                            ) *
-                            spacing_weight_scaling[(int)type];
-
-                        break;
-                }
-            }
-            else if (BaseHitObject is HitCircle)
-            {
-                addition = spacingWeight(DistanceTo(previousHitObject), type) * spacing_weight_scaling[(int)type];
-            }
-
-            // Scale addition by the time, that elapsed. Filter out HitObjects that are too close to be played anyway to avoid crazy values by division through close to zero.
-            // You will never find maps that require this amongst ranked maps.
-            addition /= Math.Max(timeElapsed, 50);
-
-            Strains[(int)type] = previousHitObject.Strains[(int)type] * decay + addition;
-        }
-
-        internal double DistanceTo(OsuHitObjectDifficulty other)
-        {
-            // Scale the distance by circle size.
-            return (startPosition - other.endPosition).Length * scalingFactor;
-        }
-    }
-}

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

@@ -2,7 +2,6 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using OpenTK;
-using osu.Game.Beatmaps.Timing;
 using osu.Game.Rulesets.Objects.Types;
 using System;
 using System.Collections.Generic;
@@ -10,6 +9,7 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Database;
 using System.Linq;
 using osu.Game.Audio;
+using osu.Game.Beatmaps.ControlPoints;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {
@@ -20,24 +20,33 @@ namespace osu.Game.Rulesets.Osu.Objects
         /// </summary>
         private const float base_scoring_distance = 100;
 
-        public IHasCurve CurveObject { get; set; }
-
-        public SliderCurve Curve => CurveObject.Curve;
+        public readonly SliderCurve Curve = new SliderCurve();
 
         public double EndTime => StartTime + RepeatCount * Curve.Distance / Velocity;
         public double Duration => EndTime - StartTime;
 
         public override Vector2 EndPosition => PositionAt(1);
 
-        public Vector2 PositionAt(double progress) => CurveObject.PositionAt(progress);
-        public double ProgressAt(double progress) => CurveObject.ProgressAt(progress);
-        public int RepeatAt(double progress) => CurveObject.RepeatAt(progress);
+        public List<Vector2> ControlPoints
+        {
+            get { return Curve.ControlPoints; }
+            set { Curve.ControlPoints = value; }
+        }
 
-        public List<Vector2> ControlPoints => CurveObject.ControlPoints;
-        public CurveType CurveType => CurveObject.CurveType;
-        public double Distance => CurveObject.Distance;
+        public CurveType CurveType
+        {
+            get { return Curve.CurveType; }
+            set { Curve.CurveType = value; }
+        }
 
-        public int RepeatCount => CurveObject.RepeatCount;
+        public double Distance
+        {
+            get { return Curve.Distance; }
+            set { Curve.Distance = value; }
+        }
+
+        public List<SampleInfoList> RepeatSamples { get; set; } = new List<SampleInfoList>();
+        public int RepeatCount { get; set; } = 1;
 
         private int stackHeight;
         public override int StackHeight
@@ -53,16 +62,31 @@ namespace osu.Game.Rulesets.Osu.Objects
         public double Velocity;
         public double TickDistance;
 
-        public override void ApplyDefaults(TimingInfo timing, BeatmapDifficulty difficulty)
+        public override void ApplyDefaults(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
         {
-            base.ApplyDefaults(timing, difficulty);
+            base.ApplyDefaults(controlPointInfo, difficulty);
 
-            double scoringDistance = base_scoring_distance * difficulty.SliderMultiplier / timing.SpeedMultiplierAt(StartTime);
+            TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
+            DifficultyControlPoint difficultyPoint = controlPointInfo.DifficultyPointAt(StartTime);
 
-            Velocity = scoringDistance / timing.BeatLengthAt(StartTime);
+            double scoringDistance = base_scoring_distance * difficulty.SliderMultiplier / difficultyPoint.SpeedMultiplier;
+
+            Velocity = scoringDistance / timingPoint.BeatLength;
             TickDistance = scoringDistance / difficulty.SliderTickRate;
         }
 
+        public Vector2 PositionAt(double progress) => Curve.PositionAt(ProgressAt(progress));
+
+        public double ProgressAt(double progress)
+        {
+            double p = progress * RepeatCount % 1;
+            if (RepeatAt(progress) % 2 == 1)
+                p = 1 - p;
+            return p;
+        }
+
+        public int RepeatAt(double progress) => (int)(progress * RepeatCount);
+
         public IEnumerable<SliderTick> Ticks
         {
             get
@@ -96,12 +120,12 @@ namespace osu.Game.Rulesets.Osu.Objects
                             StackHeight = StackHeight,
                             Scale = Scale,
                             ComboColour = ComboColour,
-                            Samples = Samples.Select(s => new SampleInfo
+                            Samples = new SampleInfoList(Samples.Select(s => new SampleInfo
                             {
                                 Bank = s.Bank,
                                 Name = @"slidertick",
                                 Volume = s.Volume
-                            }).ToList()
+                            }))
                         };
                     }
                 }

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.Database;
+using osu.Game.Beatmaps.ControlPoints;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {
@@ -10,6 +12,21 @@ 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(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
+        {
+            base.ApplyDefaults(controlPointInfo, difficulty);
+
+            SpinsRequired = (int)(Duration / 1000 * BeatmapDifficulty.DifficultyRange(difficulty.OverallDifficulty, 3, 5, 7.5));
+
+            // spinning doesn't match 1:1 with stable, so let's fudge them easier for the time being.
+            SpinsRequired = (int)(SpinsRequired * 0.6);
+        }
     }
 }

osu.Game.Rulesets.Osu/OsuAutoReplay.cs

@@ -1,315 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using OpenTK;
-using osu.Framework.MathUtils;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.Objects.Drawables;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using osu.Framework.Graphics;
-using osu.Game.Rulesets.Objects.Types;
-using osu.Game.Rulesets.Replays;
-using osu.Game.Users;
-
-namespace osu.Game.Rulesets.Osu
-{
-    public class OsuAutoReplay : Replay
-    {
-        private static readonly Vector2 spinner_centre = new Vector2(256, 192);
-
-        private const float spin_radius = 50;
-
-        private readonly Beatmap<OsuHitObject> beatmap;
-
-        public OsuAutoReplay(Beatmap<OsuHitObject> beatmap)
-        {
-            this.beatmap = beatmap;
-
-            User = new User
-            {
-                Username = @"Autoplay",
-            };
-
-            createAutoReplay();
-        }
-
-        private class ReplayFrameComparer : IComparer<ReplayFrame>
-        {
-            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");
-
-                return f1.Time.CompareTo(f2.Time);
-            }
-        }
-
-        private static readonly IComparer<ReplayFrame> replay_frame_comparer = new ReplayFrameComparer();
-
-        private int findInsertionIndex(ReplayFrame frame)
-        {
-            int index = Frames.BinarySearch(frame, replay_frame_comparer);
-
-            if (index < 0)
-            {
-                index = ~index;
-            }
-            else
-            {
-                // Go to the first index which is actually bigger
-                while (index < Frames.Count && frame.Time == Frames[index].Time)
-                {
-                    ++index;
-                }
-            }
-
-            return index;
-        }
-
-        private void addFrameToReplay(ReplayFrame frame) => Frames.Insert(findInsertionIndex(frame), frame);
-
-        private static Vector2 circlePosition(double t, double radius) => new Vector2((float)(Math.Cos(t) * radius), (float)(Math.Sin(t) * radius));
-
-        private double applyModsToTime(double v) => v;
-        private double applyModsToRate(double v) => v;
-
-        public bool DelayedMovements; // ModManager.CheckActive(Mods.Relax2);
-
-        private void createAutoReplay()
-        {
-            int buttonIndex = 0;
-
-            EasingTypes preferredEasing = DelayedMovements ? EasingTypes.InOutCubic : EasingTypes.Out;
-
-            addFrameToReplay(new ReplayFrame(-100000, 256, 500, ReplayButtonState.None));
-            addFrameToReplay(new ReplayFrame(beatmap.HitObjects[0].StartTime - 1500, 256, 500, ReplayButtonState.None));
-            addFrameToReplay(new ReplayFrame(beatmap.HitObjects[0].StartTime - 1000, 256, 192, ReplayButtonState.None));
-
-            // We are using ApplyModsToRate and not ApplyModsToTime to counteract the speed up / slow down from HalfTime / DoubleTime so that we remain at a constant framerate of 60 fps.
-            float frameDelay = (float)applyModsToRate(1000.0 / 60.0);
-
-            // Already superhuman, but still somewhat realistic
-            int reactionTime = (int)applyModsToRate(100);
-
-
-            for (int i = 0; i < beatmap.HitObjects.Count; i++)
-            {
-                OsuHitObject h = beatmap.HitObjects[i];
-
-                //if (h.EndTime < InputManager.ReplayStartTime)
-                //{
-                //    h.IsHit = true;
-                //    continue;
-                //}
-
-                int endDelay = h is Spinner ? 1 : 0;
-
-                if (DelayedMovements && i > 0)
-                {
-                    OsuHitObject last = beatmap.HitObjects[i - 1];
-
-                    double endTime = (last as IHasEndTime)?.EndTime ?? last.StartTime;
-
-                    //Make the cursor stay at a hitObject as long as possible (mainly for autopilot).
-                    if (h.StartTime - h.HitWindowFor(OsuScoreResult.Miss) > endTime + h.HitWindowFor(OsuScoreResult.Hit50) + 50)
-                    {
-                        if (!(last is Spinner) && h.StartTime - endTime < 1000) addFrameToReplay(new ReplayFrame(endTime + h.HitWindowFor(OsuScoreResult.Hit50), last.EndPosition.X, last.EndPosition.Y, ReplayButtonState.None));
-                        if (!(h is Spinner)) addFrameToReplay(new ReplayFrame(h.StartTime - h.HitWindowFor(OsuScoreResult.Miss), h.Position.X, h.Position.Y, ReplayButtonState.None));
-                    }
-                    else if (h.StartTime - h.HitWindowFor(OsuScoreResult.Hit50) > endTime + h.HitWindowFor(OsuScoreResult.Hit50) + 50)
-                    {
-                        if (!(last is Spinner) && h.StartTime - endTime < 1000) addFrameToReplay(new ReplayFrame(endTime + h.HitWindowFor(OsuScoreResult.Hit50), last.EndPosition.X, last.EndPosition.Y, ReplayButtonState.None));
-                        if (!(h is Spinner)) addFrameToReplay(new ReplayFrame(h.StartTime - h.HitWindowFor(OsuScoreResult.Hit50), h.Position.X, h.Position.Y, ReplayButtonState.None));
-                    }
-                    else if (h.StartTime - h.HitWindowFor(OsuScoreResult.Hit100) > endTime + h.HitWindowFor(OsuScoreResult.Hit100) + 50)
-                    {
-                        if (!(last is Spinner) && h.StartTime - endTime < 1000) addFrameToReplay(new ReplayFrame(endTime + h.HitWindowFor(OsuScoreResult.Hit100), last.EndPosition.X, last.EndPosition.Y, ReplayButtonState.None));
-                        if (!(h is Spinner)) addFrameToReplay(new ReplayFrame(h.StartTime - h.HitWindowFor(OsuScoreResult.Hit100), h.Position.X, h.Position.Y, ReplayButtonState.None));
-                    }
-                }
-
-
-                Vector2 targetPosition = h.Position;
-                EasingTypes easing = preferredEasing;
-                float spinnerDirection = -1;
-
-                if (h is Spinner)
-                {
-                    targetPosition = Frames[Frames.Count - 1].Position;
-
-                    Vector2 difference = spinner_centre - targetPosition;
-
-                    float differenceLength = difference.Length;
-                    float newLength = (float)Math.Sqrt(differenceLength * differenceLength - spin_radius * spin_radius);
-
-                    if (differenceLength > spin_radius)
-                    {
-                        float angle = (float)Math.Asin(spin_radius / differenceLength);
-
-                        if (angle > 0)
-                        {
-                            spinnerDirection = -1;
-                        }
-                        else
-                        {
-                            spinnerDirection = 1;
-                        }
-
-                        difference.X = difference.X * (float)Math.Cos(angle) - difference.Y * (float)Math.Sin(angle);
-                        difference.Y = difference.X * (float)Math.Sin(angle) + difference.Y * (float)Math.Cos(angle);
-
-                        difference.Normalize();
-                        difference *= newLength;
-
-                        targetPosition += difference;
-
-                        easing = EasingTypes.In;
-                    }
-                    else if (difference.Length > 0)
-                    {
-                        targetPosition = spinner_centre - difference * (spin_radius / difference.Length);
-                    }
-                    else
-                    {
-                        targetPosition = spinner_centre + new Vector2(0, -spin_radius);
-                    }
-                }
-
-
-                // Do some nice easing for cursor movements
-                if (Frames.Count > 0)
-                {
-                    ReplayFrame lastFrame = Frames[Frames.Count - 1];
-
-                    // Wait until Auto could "see and react" to the next note.
-                    double waitTime = h.StartTime - Math.Max(0.0, DrawableOsuHitObject.TIME_PREEMPT - reactionTime);
-                    if (waitTime > lastFrame.Time)
-                    {
-                        lastFrame = new ReplayFrame(waitTime, lastFrame.MouseX, lastFrame.MouseY, lastFrame.ButtonState);
-                        addFrameToReplay(lastFrame);
-                    }
-
-                    Vector2 lastPosition = lastFrame.Position;
-
-                    double timeDifference = applyModsToTime(h.StartTime - lastFrame.Time);
-
-                    // Only "snap" to hitcircles if they are far enough apart. As the time between hitcircles gets shorter the snapping threshold goes up.
-                    if (timeDifference > 0 && // Sanity checks
-                        ((lastPosition - targetPosition).Length > h.Radius * (1.5 + 100.0 / timeDifference) || // Either the distance is big enough
-                        timeDifference >= 266)) // ... or the beats are slow enough to tap anyway.
-                    {
-                        // Perform eased movement
-                        for (double time = lastFrame.Time + frameDelay; time < h.StartTime; time += frameDelay)
-                        {
-                            Vector2 currentPosition = Interpolation.ValueAt(time, lastPosition, targetPosition, lastFrame.Time, h.StartTime, easing);
-                            addFrameToReplay(new ReplayFrame((int)time, currentPosition.X, currentPosition.Y, lastFrame.ButtonState));
-                        }
-
-                        buttonIndex = 0;
-                    }
-                    else
-                    {
-                        buttonIndex++;
-                    }
-                }
-
-                ReplayButtonState button = buttonIndex % 2 == 0 ? ReplayButtonState.Left1 : ReplayButtonState.Right1;
-
-                double hEndTime = ((h as IHasEndTime)?.EndTime ?? h.StartTime) + KEY_UP_DELAY;
-
-                ReplayFrame newFrame = new ReplayFrame(h.StartTime, targetPosition.X, targetPosition.Y, button);
-                ReplayFrame endFrame = new ReplayFrame(hEndTime + endDelay, h.EndPosition.X, h.EndPosition.Y, ReplayButtonState.None);
-
-                // Decrement because we want the previous frame, not the next one
-                int index = findInsertionIndex(newFrame) - 1;
-
-                // Do we have a previous frame? No need to check for < replay.Count since we decremented!
-                if (index >= 0)
-                {
-                    ReplayFrame previousFrame = Frames[index];
-                    var previousButton = previousFrame.ButtonState;
-
-                    // If a button is already held, then we simply alternate
-                    if (previousButton != ReplayButtonState.None)
-                    {
-                        Debug.Assert(previousButton != (ReplayButtonState.Left1 | ReplayButtonState.Right1));
-
-                        // Force alternation if we have the same button. Otherwise we can just keep the naturally to us assigned button.
-                        if (previousButton == button)
-                        {
-                            button = (ReplayButtonState.Left1 | ReplayButtonState.Right1) & ~button;
-                            newFrame.ButtonState = button;
-                        }
-
-                        // We always follow the most recent slider / spinner, so remove any other frames that occur while it exists.
-                        int endIndex = findInsertionIndex(endFrame);
-
-                        if (index < Frames.Count - 1)
-                            Frames.RemoveRange(index + 1, Math.Max(0, endIndex - (index + 1)));
-
-                        // After alternating we need to keep holding the other button in the future rather than the previous one.
-                        for (int j = index + 1; j < Frames.Count; ++j)
-                        {
-                            // Don't affect frames which stop pressing a button!
-                            if (j < Frames.Count - 1 || Frames[j].ButtonState == previousButton)
-                                Frames[j].ButtonState = button;
-                        }
-                    }
-                }
-
-                addFrameToReplay(newFrame);
-
-                // We add intermediate frames for spinning / following a slider here.
-                if (h is Spinner)
-                {
-                    Spinner s = h as Spinner;
-
-                    Vector2 difference = targetPosition - spinner_centre;
-
-                    float radius = difference.Length;
-                    float angle = radius == 0 ? 0 : (float)Math.Atan2(difference.Y, difference.X);
-
-                    double t;
-
-                    for (double j = h.StartTime + frameDelay; j < s.EndTime; j += frameDelay)
-                    {
-                        t = applyModsToTime(j - h.StartTime) * spinnerDirection;
-
-                        Vector2 pos = spinner_centre + circlePosition(t / 20 + angle, spin_radius);
-                        addFrameToReplay(new ReplayFrame((int)j, pos.X, pos.Y, button));
-                    }
-
-                    t = applyModsToTime(s.EndTime - h.StartTime) * spinnerDirection;
-                    Vector2 endPosition = spinner_centre + circlePosition(t / 20 + angle, spin_radius);
-
-                    addFrameToReplay(new ReplayFrame(s.EndTime, endPosition.X, endPosition.Y, button));
-
-                    endFrame.MouseX = endPosition.X;
-                    endFrame.MouseY = endPosition.Y;
-                }
-                else if (h is Slider)
-                {
-                    Slider s = h as Slider;
-
-                    for (double j = frameDelay; j < s.Duration; j += frameDelay)
-                    {
-                        Vector2 pos = s.PositionAt(j / s.Duration);
-                        addFrameToReplay(new ReplayFrame(h.StartTime + j, pos.X, pos.Y, button));
-                    }
-
-                    addFrameToReplay(new ReplayFrame(s.EndTime, s.EndPosition.X, s.EndPosition.Y, button));
-                }
-
-                // We only want to let go of our button if we are at the end of the current replay. Otherwise something is still going on after us so we need to keep the button pressed!
-                if (Frames[Frames.Count - 1].Time <= endFrame.Time)
-                    addFrameToReplay(endFrame);
-            }
-
-            //Player.currentScore.Replay = InputManager.ReplayScore.Replay;
-            //Player.currentScore.PlayerName = "osu!";
-        }
-    }
-}

osu.Game.Rulesets.Osu/OsuDifficulty/OsuDifficultyCalculator.cs

@@ -0,0 +1,73 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Beatmaps;
+using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.OsuDifficulty.Preprocessing;
+using osu.Game.Rulesets.Osu.OsuDifficulty.Skills;
+
+namespace osu.Game.Rulesets.Osu.OsuDifficulty
+{
+    public class OsuDifficultyCalculator : DifficultyCalculator<OsuHitObject>
+    {
+        private const int section_length = 400;
+        private const double difficulty_multiplier = 0.0675;
+
+        public OsuDifficultyCalculator(Beatmap beatmap) : base(beatmap)
+        {
+        }
+
+        protected override void PreprocessHitObjects()
+        {
+            foreach (OsuHitObject h in Objects)
+                (h as Slider)?.Curve?.Calculate();
+        }
+
+        protected override double CalculateInternal(Dictionary<string, string> categoryDifficulty)
+        {
+            OsuDifficultyBeatmap beatmap = new OsuDifficultyBeatmap(Objects);
+            Skill[] skills =
+            {
+                new Aim(),
+                new Speed()
+            };
+
+            double sectionEnd = section_length / TimeRate;
+            foreach (OsuDifficultyHitObject h in beatmap)
+            {
+                while (h.BaseObject.StartTime > sectionEnd)
+                {
+                    foreach (Skill s in skills)
+                    {
+                        s.SaveCurrentPeak();
+                        s.StartNewSectionFrom(sectionEnd);
+                    }
+
+                    sectionEnd += section_length;
+                }
+
+                foreach (Skill s in skills)
+                    s.Process(h);
+            }
+
+            double aimRating = Math.Sqrt(skills[0].DifficultyValue()) * difficulty_multiplier;
+            double speedRating = Math.Sqrt(skills[1].DifficultyValue()) * difficulty_multiplier;
+
+            double starRating = aimRating + speedRating + Math.Abs(aimRating - speedRating) / 2;
+
+            if (categoryDifficulty != null)
+            {
+                categoryDifficulty.Add("Aim", aimRating.ToString("0.00"));
+                categoryDifficulty.Add("Speed", speedRating.ToString("0.00"));
+            }
+
+            return starRating;
+        }
+
+        protected override BeatmapConverter<OsuHitObject> CreateBeatmapConverter() => new OsuBeatmapConverter();
+    }
+}

osu.Game.Rulesets.Osu/OsuDifficulty/Preprocessing/OsuDifficultyBeatmap.cs

@@ -0,0 +1,93 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections;
+using System.Collections.Generic;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.OsuDifficulty.Preprocessing
+{
+    /// <summary>
+    /// An enumerable container wrapping <see cref="OsuHitObject"/> input as <see cref="OsuDifficultyHitObject"/>
+    /// which contains extra data required for difficulty calculation.
+    /// </summary>
+    public class OsuDifficultyBeatmap : IEnumerable<OsuDifficultyHitObject>
+    {
+        private readonly IEnumerator<OsuDifficultyHitObject> difficultyObjects;
+        private readonly Queue<OsuDifficultyHitObject> onScreen = new Queue<OsuDifficultyHitObject>();
+
+        /// <summary>
+        /// Creates an enumerator, which preprocesses a list of <see cref="OsuHitObject"/>s recieved as input, wrapping them as
+        /// <see cref="OsuDifficultyHitObject"/> which contains extra data required for difficulty calculation.
+        /// </summary>
+        public OsuDifficultyBeatmap(List<OsuHitObject> objects)
+        {
+            // Sort OsuHitObjects by StartTime - they are not correctly ordered in some cases.
+            // This should probably happen before the objects reach the difficulty calculator.
+            objects.Sort((a, b) => a.StartTime.CompareTo(b.StartTime));
+            difficultyObjects = createDifficultyObjectEnumerator(objects);
+        }
+
+        /// <summary>
+        /// Returns an enumerator that enumerates all <see cref="OsuDifficultyHitObject"/>s in the <see cref="OsuDifficultyBeatmap"/>.
+        /// The inner loop adds objects that appear on screen into a queue until we need to hit the next object.
+        /// The outer loop returns objects from this queue one at a time, only after they had to be hit, and should no longer be on screen.
+        /// This means that we can loop through every object that is on screen at the time when a new one appears,
+        /// allowing us to determine a reading strain for the object that just appeared.
+        /// </summary>
+        public IEnumerator<OsuDifficultyHitObject> GetEnumerator()
+        {
+            while (true)
+            {
+                // Add upcoming objects to the queue until we have at least one object that had been hit and can be dequeued.
+                // This means there is always at least one object in the queue unless we reached the end of the map.
+                do
+                {
+                    if (!difficultyObjects.MoveNext())
+                        break; // New objects can't be added anymore, but we still need to dequeue and return the ones already on screen.
+
+                    OsuDifficultyHitObject latest = difficultyObjects.Current;
+                    // Calculate flow values here
+
+                    foreach (OsuDifficultyHitObject h in onScreen)
+                    {
+                        h.TimeUntilHit -= latest.DeltaTime;
+                        // Calculate reading strain here
+                    }
+
+                    onScreen.Enqueue(latest);
+                }
+                while (onScreen.Peek().TimeUntilHit > 0); // Keep adding new objects on screen while there is still time before we have to hit the next one.
+
+                if (onScreen.Count == 0) break; // We have reached the end of the map and enumerated all the objects.
+                yield return onScreen.Dequeue(); // Remove and return objects one by one that had to be hit before the latest one appeared.
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        private IEnumerator<OsuDifficultyHitObject> createDifficultyObjectEnumerator(List<OsuHitObject> objects)
+        {
+            // We will process OsuHitObjects in groups of three to form a triangle, so we can calculate an angle for each object.
+            OsuHitObject[] triangle = new OsuHitObject[3];
+
+            // OsuDifficultyHitObject construction requires three components, an extra copy of the first OsuHitObject is used at the beginning.
+            if (objects.Count > 1)
+            {
+                triangle[1] = objects[0]; // This copy will get shifted to the last spot in the triangle.
+                triangle[0] = objects[0]; // This component corresponds to the real first OsuHitOject.
+            }
+
+            // The final component of the first triangle will be the second OsuHitOject of the map, which forms the first jump.
+            // If the map has less than two OsuHitObjects, the enumerator will not return anything.
+            for (int i = 1; i < objects.Count; ++i)
+            {
+                triangle[2] = triangle[1];
+                triangle[1] = triangle[0];
+                triangle[0] = objects[i];
+
+                yield return new OsuDifficultyHitObject(triangle);
+            }
+        }
+    }
+}

osu.Game.Rulesets.Osu/OsuDifficulty/Preprocessing/OsuDifficultyHitObject.cs

@@ -0,0 +1,70 @@
+// 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.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.OsuDifficulty.Preprocessing
+{
+    /// <summary>
+    /// A wrapper around <see cref="OsuHitObject"/> extending it with additional data required for difficulty calculation.
+    /// </summary>
+    public class OsuDifficultyHitObject
+    {
+        /// <summary>
+        /// The <see cref="OsuHitObject"/> this <see cref="OsuDifficultyHitObject"/> refers to.
+        /// </summary>
+        public OsuHitObject BaseObject { get; }
+
+        /// <summary>
+        /// Normalized distance from the <see cref="OsuHitObject.StackedPosition"/> of the previous <see cref="OsuDifficultyHitObject"/>.
+        /// </summary>
+        public double Distance { get; private set; }
+
+        /// <summary>
+        /// Milliseconds elapsed since the StartTime of the previous <see cref="OsuDifficultyHitObject"/>.
+        /// </summary>
+        public double DeltaTime { get; private set; }
+
+        /// <summary>
+        /// Number of milliseconds until the <see cref="OsuDifficultyHitObject"/> has to be hit.
+        /// </summary>
+        public double TimeUntilHit { get; set; }
+
+        private const int normalized_radius = 52;
+
+        private readonly OsuHitObject[] t;
+
+        /// <summary>
+        /// Initializes the object calculating extra data required for difficulty calculation.
+        /// </summary>
+        public OsuDifficultyHitObject(OsuHitObject[] triangle)
+        {
+            t = triangle;
+            BaseObject = t[0];
+            setDistances();
+            setTimingValues();
+            // Calculate angle here
+        }
+
+        private void setDistances()
+        {
+            // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
+            double scalingFactor = normalized_radius / BaseObject.Radius;
+            if (BaseObject.Radius < 30)
+            {
+                double smallCircleBonus = Math.Min(30 - BaseObject.Radius, 5) / 50;
+                scalingFactor *= 1 + smallCircleBonus;
+            }
+
+            Distance = (t[0].StackedPosition - t[1].StackedPosition).Length * scalingFactor;
+        }
+
+        private void setTimingValues()
+        {
+            // Every timing inverval is hard capped at the equivalent of 375 BPM streaming speed as a safety measure.
+            DeltaTime = Math.Max(40, t[0].StartTime - t[1].StartTime);
+            TimeUntilHit = 450; // BaseObject.PreEmpt;
+        }
+    }
+}