Merge pull request #3345 from peppy/update-framework

Update framework

.github/pull_request_template.md

@@ -0,0 +1,8 @@
+Add any details pertaining to developers above the break.
+
+- [ ] Depends on #PR
+- Closes #ISSUE
+
+---
+
+Add a sentence or two describing this change in plain english. This will be displayed on the [changelog](https://osu.ppy.sh/home/changelog). A single screenshot or short gif is also welcomed.

.gitmodules

@@ -1,6 +1,3 @@
-[submodule "osu-framework"]
-	path = osu-framework
-	url = https://github.com/ppy/osu-framework
 [submodule "osu-resources"]
 	path = osu-resources
-	url = https://github.com/ppy/osu-resources
+	url = https://github.com/ppy/osu-resources

.idea/.idea.osu/.idea/runConfigurations/RulesetTests__catch_.xml

@@ -1,21 +1,17 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="RulesetTests (catch)" type="DotNetProject" factoryName=".NET Project">
-    <option name="EXE_PATH" value="$PROJECT_DIR$/osu.Game.Rulesets.Catch.Tests/bin/Debug/net471/osu.Game.Rulesets.Catch.Tests.exe" />
+    <option name="EXE_PATH" value="$PROJECT_DIR$/osu.Game.Rulesets.Catch.Tests/bin/Debug/netcoreapp2.1/osu.Game.Rulesets.Catch.Tests.dll" />
     <option name="PROGRAM_PARAMETERS" value="" />
     <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/osu.Game.Rulesets.Catch.Tests" />
     <option name="PASS_PARENT_ENVS" value="1" />
-    <envs>
-      <env name="ASPNETCORE_ENVIRONMENT" value="Development" />
-      <env name="ASPNETCORE_URLS" value="http://localhost:5000" />
-    </envs>
-    <option name="USE_MONO" value="0" />
     <option name="USE_EXTERNAL_CONSOLE" value="0" />
+    <option name="USE_MONO" value="0" />
     <option name="PROJECT_PATH" value="$PROJECT_DIR$/osu.Game.Rulesets.Catch.Tests/osu.Game.Rulesets.Catch.Tests.csproj" />
     <option name="PROJECT_EXE_PATH_TRACKING" value="1" />
     <option name="PROJECT_ARGUMENTS_TRACKING" value="1" />
     <option name="PROJECT_WORKING_DIRECTORY_TRACKING" value="1" />
     <option name="PROJECT_KIND" value="DotNetCore" />
-    <option name="PROJECT_TFM" value=".NETFramework,Version=v4.7.1" />
+    <option name="PROJECT_TFM" value=".NETCoreApp,Version=v2.1" />
     <browser url="http://localhost:5000" />
     <method />
   </configuration>

.idea/.idea.osu/.idea/runConfigurations/RulesetTests__mania_.xml

@@ -1,21 +1,17 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="RulesetTests (mania)" type="DotNetProject" factoryName=".NET Project">
-    <option name="EXE_PATH" value="$PROJECT_DIR$/osu.Game.Rulesets.Mania.Tests/bin/Debug/net471/osu.Game.Rulesets.Mania.Tests.exe" />
+    <option name="EXE_PATH" value="$PROJECT_DIR$/osu.Game.Rulesets.Mania.Tests/bin/Debug/netcoreapp2.1/osu.Game.Rulesets.Mania.Tests.dll" />
     <option name="PROGRAM_PARAMETERS" value="" />
     <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/osu.Game.Rulesets.Mania.Tests" />
     <option name="PASS_PARENT_ENVS" value="1" />
-    <envs>
-      <env name="ASPNETCORE_ENVIRONMENT" value="Development" />
-      <env name="ASPNETCORE_URLS" value="http://localhost:5000" />
-    </envs>
-    <option name="USE_MONO" value="0" />
     <option name="USE_EXTERNAL_CONSOLE" value="0" />
+    <option name="USE_MONO" value="0" />
     <option name="PROJECT_PATH" value="$PROJECT_DIR$/osu.Game.Rulesets.Mania.Tests/osu.Game.Rulesets.Mania.Tests.csproj" />
     <option name="PROJECT_EXE_PATH_TRACKING" value="1" />
     <option name="PROJECT_ARGUMENTS_TRACKING" value="1" />
     <option name="PROJECT_WORKING_DIRECTORY_TRACKING" value="1" />
     <option name="PROJECT_KIND" value="DotNetCore" />
-    <option name="PROJECT_TFM" value=".NETFramework,Version=v4.7.1" />
+    <option name="PROJECT_TFM" value=".NETCoreApp,Version=v2.1" />
     <browser url="http://localhost:5000" />
     <method />
   </configuration>

.idea/.idea.osu/.idea/runConfigurations/RulesetTests__osu__.xml

@@ -1,21 +1,17 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="RulesetTests (osu!)" type="DotNetProject" factoryName=".NET Project">
-    <option name="EXE_PATH" value="$PROJECT_DIR$/osu.Game.Rulesets.Osu.Tests/bin/Debug/net471/osu.Game.Rulesets.Osu.Tests.exe" />
+    <option name="EXE_PATH" value="$PROJECT_DIR$/osu.Game.Rulesets.Osu.Tests/bin/Debug/netcoreapp2.1/osu.Game.Rulesets.Osu.Tests.dll" />
     <option name="PROGRAM_PARAMETERS" value="" />
     <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/osu.Game.Rulesets.Osu.Tests" />
     <option name="PASS_PARENT_ENVS" value="1" />
-    <envs>
-      <env name="ASPNETCORE_ENVIRONMENT" value="Development" />
-      <env name="ASPNETCORE_URLS" value="http://localhost:5000" />
-    </envs>
-    <option name="USE_MONO" value="0" />
     <option name="USE_EXTERNAL_CONSOLE" value="0" />
+    <option name="USE_MONO" value="0" />
     <option name="PROJECT_PATH" value="$PROJECT_DIR$/osu.Game.Rulesets.Osu.Tests/osu.Game.Rulesets.Osu.Tests.csproj" />
     <option name="PROJECT_EXE_PATH_TRACKING" value="1" />
     <option name="PROJECT_ARGUMENTS_TRACKING" value="1" />
     <option name="PROJECT_WORKING_DIRECTORY_TRACKING" value="1" />
     <option name="PROJECT_KIND" value="DotNetCore" />
-    <option name="PROJECT_TFM" value=".NETFramework,Version=v4.7.1" />
+    <option name="PROJECT_TFM" value=".NETCoreApp,Version=v2.1" />
     <browser url="http://localhost:5000" />
     <method />
   </configuration>

.idea/.idea.osu/.idea/runConfigurations/RulesetTests__taiko_.xml

@@ -1,21 +1,17 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="RulesetTests (taiko)" type="DotNetProject" factoryName=".NET Project">
-    <option name="EXE_PATH" value="$PROJECT_DIR$/osu.Game.Rulesets.Taiko.Tests/bin/Debug/net471/osu.Game.Rulesets.Taiko.Tests.exe" />
+    <option name="EXE_PATH" value="$PROJECT_DIR$/osu.Game.Rulesets.Taiko.Tests/bin/Debug/netcoreapp2.1/osu.Game.Rulesets.Taiko.Tests.dll" />
     <option name="PROGRAM_PARAMETERS" value="" />
     <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/osu.Game.Rulesets.Taiko.Tests" />
     <option name="PASS_PARENT_ENVS" value="1" />
-    <envs>
-      <env name="ASPNETCORE_ENVIRONMENT" value="Development" />
-      <env name="ASPNETCORE_URLS" value="http://localhost:5000" />
-    </envs>
-    <option name="USE_MONO" value="0" />
     <option name="USE_EXTERNAL_CONSOLE" value="0" />
+    <option name="USE_MONO" value="0" />
     <option name="PROJECT_PATH" value="$PROJECT_DIR$/osu.Game.Rulesets.Taiko.Tests/osu.Game.Rulesets.Taiko.Tests.csproj" />
     <option name="PROJECT_EXE_PATH_TRACKING" value="1" />
     <option name="PROJECT_ARGUMENTS_TRACKING" value="1" />
     <option name="PROJECT_WORKING_DIRECTORY_TRACKING" value="1" />
     <option name="PROJECT_KIND" value="DotNetCore" />
-    <option name="PROJECT_TFM" value=".NETFramework,Version=v4.7.1" />
+    <option name="PROJECT_TFM" value=".NETCoreApp,Version=v2.1" />
     <browser url="http://localhost:5000" />
     <method />
   </configuration>

.idea/.idea.osu/.idea/runConfigurations/VisualTests.xml

@@ -1,12 +1,11 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="VisualTests (netcoreapp2.1)" type="DotNetProject" factoryName=".NET Project">
+  <configuration default="false" name="VisualTests" type="DotNetProject" factoryName=".NET Project">
     <option name="EXE_PATH" value="$PROJECT_DIR$/osu.Game.Tests/bin/Debug/netcoreapp2.1/osu.Game.Tests.dll" />
     <option name="PROGRAM_PARAMETERS" value="" />
     <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/osu.Game.Tests" />
     <option name="PASS_PARENT_ENVS" value="1" />
-    <envs />
-    <option name="USE_MONO" value="0" />
     <option name="USE_EXTERNAL_CONSOLE" value="0" />
+    <option name="USE_MONO" value="0" />
     <option name="PROJECT_PATH" value="$PROJECT_DIR$/osu.Game.Tests/osu.Game.Tests.csproj" />
     <option name="PROJECT_EXE_PATH_TRACKING" value="1" />
     <option name="PROJECT_ARGUMENTS_TRACKING" value="1" />

.idea/.idea.osu/.idea/runConfigurations/VisualTests__net471_.xml

@@ -1,18 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="VisualTests (net471)" type="DotNetProject" factoryName=".NET Project" singleton="true">
-    <option name="EXE_PATH" value="$PROJECT_DIR$/osu.Game.Tests/bin/Debug/net471/osu.Game.Tests.exe" />
-    <option name="PROGRAM_PARAMETERS" value="" />
-    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/osu.Game.Tests" />
-    <option name="PASS_PARENT_ENVS" value="1" />
-    <envs />
-    <option name="USE_MONO" value="0" />
-    <option name="USE_EXTERNAL_CONSOLE" value="0" />
-    <option name="PROJECT_PATH" value="$PROJECT_DIR$/osu.Game.Tests/osu.Game.Tests.csproj" />
-    <option name="PROJECT_EXE_PATH_TRACKING" value="1" />
-    <option name="PROJECT_ARGUMENTS_TRACKING" value="1" />
-    <option name="PROJECT_WORKING_DIRECTORY_TRACKING" value="1" />
-    <option name="PROJECT_KIND" value="DotNetCore" />
-    <option name="PROJECT_TFM" value=".NETFramework,Version=v4.7.1" />
-    <method />
-  </configuration>
-</component>

.idea/.idea.osu/.idea/runConfigurations/osu_.xml

@@ -1,12 +1,11 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="osu! (netcoreapp2.1)" type="DotNetProject" factoryName=".NET Project">
+  <configuration default="false" name="osu!" type="DotNetProject" factoryName=".NET Project">
     <option name="EXE_PATH" value="$PROJECT_DIR$/osu.Desktop/bin/Debug/netcoreapp2.1/osu!.dll" />
     <option name="PROGRAM_PARAMETERS" value="" />
     <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/osu.Desktop" />
     <option name="PASS_PARENT_ENVS" value="1" />
-    <envs />
-    <option name="USE_MONO" value="0" />
     <option name="USE_EXTERNAL_CONSOLE" value="0" />
+    <option name="USE_MONO" value="0" />
     <option name="PROJECT_PATH" value="$PROJECT_DIR$/osu.Desktop/osu.Desktop.csproj" />
     <option name="PROJECT_EXE_PATH_TRACKING" value="1" />
     <option name="PROJECT_ARGUMENTS_TRACKING" value="1" />

.idea/.idea.osu/.idea/runConfigurations/osu___net471_.xml

@@ -1,18 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="osu! (net471)" type="DotNetProject" factoryName=".NET Project" singleton="true">
-    <option name="EXE_PATH" value="$PROJECT_DIR$/osu.Desktop/bin/Debug/net471/osu!.exe" />
-    <option name="PROGRAM_PARAMETERS" value="" />
-    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/osu.Desktop" />
-    <option name="PASS_PARENT_ENVS" value="1" />
-    <envs />
-    <option name="USE_MONO" value="0" />
-    <option name="USE_EXTERNAL_CONSOLE" value="0" />
-    <option name="PROJECT_PATH" value="$PROJECT_DIR$/osu.Desktop/osu.Desktop.csproj" />
-    <option name="PROJECT_EXE_PATH_TRACKING" value="1" />
-    <option name="PROJECT_ARGUMENTS_TRACKING" value="1" />
-    <option name="PROJECT_WORKING_DIRECTORY_TRACKING" value="1" />
-    <option name="PROJECT_KIND" value="DotNetCore" />
-    <option name="PROJECT_TFM" value=".NETFramework,Version=v4.7.1" />
-    <method />
-  </configuration>
-</component>

.vscode/launch.json

@@ -2,63 +2,7 @@
     "version": "0.2.0",
     "configurations": [
         {
-            "name": "VisualTests (Debug, net471)",
-            "windows": {
-                "type": "clr"
-            },
-            "type": "mono",
-            "request": "launch",
-            "program": "${workspaceRoot}/osu.Game.Tests/bin/Debug/net471/osu.Game.Tests.exe",
-            "cwd": "${workspaceRoot}",
-            "preLaunchTask": "Build (Debug, msbuild)",
-            "runtimeExecutable": null,
-            "env": {},
-            "console": "internalConsole"
-        },
-        {
-            "name": "VisualTests (Release, net471)",
-            "windows": {
-                "type": "clr"
-            },
-            "type": "mono",
-            "request": "launch",
-            "program": "${workspaceRoot}/osu.Game.Tests/bin/Release/net471/osu.Game.Tests.exe",
-            "cwd": "${workspaceRoot}",
-            "preLaunchTask": "Build (Release, msbuild)",
-            "runtimeExecutable": null,
-            "env": {},
-            "console": "internalConsole"
-        },
-        {
-            "name": "osu! (Debug, net471)",
-            "windows": {
-                "type": "clr"
-            },
-            "type": "mono",
-            "request": "launch",
-            "program": "${workspaceRoot}/osu.Desktop/bin/Debug/net471/osu!.exe",
-            "cwd": "${workspaceRoot}",
-            "preLaunchTask": "Build (Debug, msbuild)",
-            "runtimeExecutable": null,
-            "env": {},
-            "console": "internalConsole"
-        },
-        {
-            "name": "osu! (Release, net471)",
-            "windows": {
-                "type": "clr"
-            },
-            "type": "mono",
-            "request": "launch",
-            "program": "${workspaceRoot}/osu.Desktop/bin/Release/net471/osu!.exe",
-            "cwd": "${workspaceRoot}",
-            "preLaunchTask": "Build (Release, msbuild)",
-            "runtimeExecutable": null,
-            "env": {},
-            "console": "internalConsole"
-        },
-        {
-            "name": "VisualTests (Debug, netcoreapp2.1)",
+            "name": "VisualTests (Debug)",
             "type": "coreclr",
             "request": "launch",
             "program": "dotnet",
@@ -66,12 +10,16 @@
                 "${workspaceRoot}/osu.Game.Tests/bin/Debug/netcoreapp2.1/osu.Game.Tests.dll"
             ],
             "cwd": "${workspaceRoot}",
-            "preLaunchTask": "Build tests (Debug, dotnet)",
-            "env": {},
+            "preLaunchTask": "Build tests (Debug)",
+            "linux": {
+                "env": {
+                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Game.Tests/bin/Debug/netcoreapp2.1:${env:LD_LIBRARY_PATH}"
+                }
+            },
             "console": "internalConsole"
         },
         {
-            "name": "VisualTests (Release, netcoreapp2.1)",
+            "name": "VisualTests (Release)",
             "type": "coreclr",
             "request": "launch",
             "program": "dotnet",
@@ -79,35 +27,47 @@
                 "${workspaceRoot}/osu.Game.Tests/bin/Release/netcoreapp2.1/osu.Game.Tests.dll"
             ],
             "cwd": "${workspaceRoot}",
-            "preLaunchTask": "Build tests (Release, dotnet)",
-            "env": {},
+            "preLaunchTask": "Build tests (Release)",
+            "linux": {
+                "env": {
+                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Game.Tests/bin/Release/netcoreapp2.1:${env:LD_LIBRARY_PATH}"
+                }
+            },
             "console": "internalConsole"
         },
         {
-            "name": "osu! (Debug, netcoreapp2.1)",
+            "name": "osu! (Debug)",
             "type": "coreclr",
             "request": "launch",
             "program": "dotnet",
             "args": [
-                "${workspaceRoot}/osu.Desktop/bin/Debug/netcoreapp2.1/osu!.dll",
+                "${workspaceRoot}/osu.Desktop/bin/Debug/netcoreapp2.1/osu!.dll"
             ],
             "cwd": "${workspaceRoot}",
-            "preLaunchTask": "Build osu! (Debug, dotnet)",
-            "env": {},
+            "preLaunchTask": "Build osu! (Debug)",
+            "linux": {
+                "env": {
+                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Desktop/bin/Debug/netcoreapp2.1:${env:LD_LIBRARY_PATH}"
+                }
+            },
             "console": "internalConsole"
         },
         {
-            "name": "osu! (Release, netcoreapp2.1)",
+            "name": "osu! (Release)",
             "type": "coreclr",
             "request": "launch",
             "program": "dotnet",
             "args": [
-                "${workspaceRoot}/osu.Desktop/bin/Release/netcoreapp2.1/osu!.dll",
+                "${workspaceRoot}/osu.Desktop/bin/Release/netcoreapp2.1/osu!.dll"
             ],
             "cwd": "${workspaceRoot}",
-            "preLaunchTask": "Build osu! (Release, dotnet)",
-            "env": {},
+            "preLaunchTask": "Build osu! (Release)",
+            "linux": {
+                "env": {
+                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Desktop/bin/Release/netcoreapp2.1:${env:LD_LIBRARY_PATH}"
+                }
+            },
             "console": "internalConsole"
         }
     ]
-}
+}

.vscode/tasks.json

@@ -4,34 +4,7 @@
     "version": "2.0.0",
     "tasks": [
         {
-            "label": "Build (Debug, msbuild)",
-            "type": "shell",
-            "command": "msbuild",
-            "args": [
-                "/p:TargetFramework=net471",
-                "/p:GenerateFullPaths=true",
-                "/m",
-                "/verbosity:m"
-            ],
-            "group": "build",
-            "problemMatcher": "$msCompile"
-        },
-        {
-            "label": "Build (Release, msbuild)",
-            "type": "shell",
-            "command": "msbuild",
-            "args": [
-                "/p:Configuration=Release",
-                "/p:TargetFramework=net471",
-                "/p:GenerateFullPaths=true",
-                "/m",
-                "/verbosity:m"
-            ],
-            "group": "build",
-            "problemMatcher": "$msCompile"
-        },
-        {
-            "label": "Build osu! (Debug, dotnet)",
+            "label": "Build osu! (Debug)",
             "type": "shell",
             "command": "dotnet",
             "args": [
@@ -47,7 +20,7 @@
             "problemMatcher": "$msCompile"
         },
         {
-            "label": "Build osu! (Release, dotnet)",
+            "label": "Build osu! (Release)",
             "type": "shell",
             "command": "dotnet",
             "args": [
@@ -64,7 +37,7 @@
             "problemMatcher": "$msCompile"
         },
         {
-            "label": "Build tests (Debug, dotnet)",
+            "label": "Build tests (Debug)",
             "type": "shell",
             "command": "dotnet",
             "args": [
@@ -80,7 +53,7 @@
             "problemMatcher": "$msCompile"
         },
         {
-            "label": "Build tests (Release, dotnet)",
+            "label": "Build tests (Release)",
             "type": "shell",
             "command": "dotnet",
             "args": [
@@ -96,15 +69,6 @@
             "group": "build",
             "problemMatcher": "$msCompile"
         },
-        {
-            "label": "Restore (net471)",
-            "type": "shell",
-            "command": "nuget",
-            "args": [
-                "restore"
-            ],
-            "problemMatcher": []
-        },
         {
             "label": "Restore (netcoreapp2.1)",
             "type": "shell",

COMPILING.md

@@ -1,36 +0,0 @@
-# Linux
-### 1. Requirements:
-Mono >= 5.4.0 (>= 5.8.0 recommended)
-Please check [here](http://www.mono-project.com/download/) for stable or [here](http://www.mono-project.com/download/alpha/) for an alpha release.  
-NuGet >= 4.4.0  
-msbuild  
-git
-
-### 2. Cloning project
-Clone the entire repository with submodules using
-```
-git clone https://github.com/ppy/osu --recursive
-```
-Then restore NuGet packages from the repository
-```
-nuget restore
-```
-### 3. Compiling
-Simply run `msbuild` where `osu.sln` is located, this will create all binaries in `osu/osu.Desktop/bin/Debug`.
-### 4. Optimizing
-If you want additional performance you can change build type to Release with
-```
-msbuild -p:Configuration=Release
-```
-Additionally, mono provides an AOT utility which attempts to precompile binaries. You can utilize that by running
-```
-mono --aot ./osu\!.exe
-```
-### 5. Troubleshooting
-You may run into trouble with NuGet versioning, as the one in packaging system is almost always out of date. Simply run 
-```
-nuget
-sudo nuget update -self
-```
-**Warning** NuGet creates few config files when it's run for the first time.
-Do not run NuGet as root on the first run or you might run into very peculiar issues.

README.md

@@ -1,18 +1,32 @@
 # 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)
 
-Rhythm is just a *click* away. The future of [osu!](https://osu.ppy.sh) 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! Commonly known by the codename "osu!lazer". Pew pew.
 
 # Status
 
-This is still heavily under development and is not intended for end-user use. This repository is intended for developer collaboration. You're welcome to try and use it but please do not submit bug reports without a patch. Please do not ask for help building or using this software.
+This project is still heavily under development, but is in a state where users are encouraged to try it out and keep it installed alongside the stable osu! client. It will continue to evolve over the coming months and hopefully bring some new unique features to the table.
+
+We are accepting bug reports (please report with as much detail as possible). Feature requests are welcome as long as you read and understand the contribution guidelines listed below.
 
 # Requirements
 
-- A desktop platform that can compile .NET 4.7.1. We recommend using [Visual Studio Community Edition](https://www.visualstudio.com/) (Windows), [Visual Studio for Mac](https://www.visualstudio.com/vs/visual-studio-mac/) (macOS) or [MonoDevelop](http://www.monodevelop.com/download/) (Linux), all of which are free. [Visual Studio Code](https://code.visualstudio.com/) may also be used but requires further setup steps which are not covered here.
+- A desktop platform with the [.NET Core SDK 2.1](https://www.microsoft.com/net/learn/get-started) or higher installed.
+- When working with the codebase, we recommend using an IDE with intellisense and syntax highlighting, such as [Visual Studio Community Edition](https://www.visualstudio.com/) (Windows), [Visual Studio Code](https://code.visualstudio.com/) (with the C# plugin installed) or [Jetbrains Rider](https://www.jetbrains.com/rider/) (commercial).
 
-# Getting Started
-- Clone the repository including submodules (`git clone --recurse-submodules https://github.com/ppy/osu`)
-- Build in your IDE of choice (recommended IDEs automatically restore nuget packages; if you are using an alternative make sure to `nuget restore`)
+# Building and running
+
+If you are not interested in developing the game, please head over to the [releases](https://github.com/ppy/osu/releases) to download a precompiled build with automatic updating enabled (download and run the install executable for your platform).
+
+Clone the repository including submodules
+
+`git clone --recurse-submodules https://github.com/ppy/osu`
+
+Build and run
+
+- Using Visual Studio 2017, Rider or Visual Studio Code (configurations are included)
+- From command line using `dotnet run --project osu.Desktop`
+
+If you run into issues building you may need to restore nuget packages (commonly via `dotnet restore`). Visual Studio Code users must run `Restore` task from debug tab before attempt to build.
 
 # Contributing
 

appveyor.yml

@@ -1,26 +1,22 @@
 clone_depth: 1
 version: '{branch}-{build}'
-image: Visual Studio 2017 preview
+image: Visual Studio 2017
 configuration: Debug
 cache:
   - C:\ProgramData\chocolatey\bin -> appveyor.yml
   - C:\ProgramData\chocolatey\lib -> appveyor.yml
-  - inspectcode -> appveyor.yml
-  - packages -> **\packages.config
 install:
   - cmd: git submodule update --init --recursive --depth=5
   - cmd: choco install resharper-clt -y
   - cmd: choco install nvika -y
-  - cmd: appveyor DownloadFile https://github.com/peppy/CodeFileSanity/releases/download/v0.2.5/CodeFileSanity.exe
+  - cmd: dotnet tool install CodeFileSanity --version 0.0.16 --global
 before_build:
-  - cmd: CodeFileSanity.exe
+  - cmd: CodeFileSanity
   - cmd: nuget restore -verbosity quiet
-environment:
-  TargetFramework: net471
 build:
   project: osu.sln
   parallel: true
   verbosity: minimal
 after_build:
   - cmd: inspectcode --o="inspectcodereport.xml" --projects:osu.Game* --caches-home="inspectcode" osu.sln > NUL
-  - cmd: NVika parsereport "inspectcodereport.xml" --treatwarningsaserrors
+  - cmd: NVika parsereport "inspectcodereport.xml" --treatwarningsaserrors

appveyor_deploy.yml

@@ -1,34 +1,30 @@
-branches:
-  only:
-  - release
-skip_tags: true
-skip_branch_with_pr: true
 clone_depth: 1
-version: '{branch}-{build}'
+version: '{build}'
+skip_non_tags: true
 image: Visual Studio 2017
-configuration: Debug
-cache:
-  - packages -> **\packages.config
 install:
-  - cmd: git submodule update --init --recursive --depth=5
+  - git clone https://github.com/ppy/osu-deploy
 before_build:
+  - ps: if($env:appveyor_repo_tag -eq 'True') { Update-AppveyorBuild -Version $env:appveyor_repo_tag_name }
+  - cmd: git submodule update --init --recursive --depth=5
   - cmd: nuget restore -verbosity quiet
-build:
-  project: osu.Desktop.Deploy/osu.Desktop.Deploy.csproj
-  verbosity: minimal
-after_build:
+build_script:
   - ps: iex ((New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/appveyor/secure-file/master/install.ps1'))
   - appveyor DownloadFile https://puu.sh/A6g5K/4d08705438.enc # signing certificate
   - cmd: appveyor-tools\secure-file -decrypt 4d08705438.enc -secret %decode_secret% -out %HOMEPATH%\deanherbert.pfx
   - appveyor DownloadFile https://puu.sh/A6g75/fdc6f19b04.enc # deploy configuration
-  - cmd: appveyor-tools\secure-file -decrypt fdc6f19b04.enc -secret %decode_secret% -out osu.Desktop.Deploy\bin\Debug\net471\osu.Desktop.Deploy.exe.config
-  - cd osu.Desktop.Deploy\bin\Debug\net471\
-  - osu.Desktop.Deploy.exe %code_signing_password%
+  - cd osu-deploy
+  - nuget restore -verbosity quiet
+  - msbuild osu.Desktop.Deploy.csproj
+  - cmd: ..\appveyor-tools\secure-file -decrypt ..\fdc6f19b04.enc -secret %decode_secret% -out bin\Debug\netcoreapp2.1\osu.Desktop.Deploy.dll.config
+  - dotnet bin/Debug/netcoreapp2.1/osu.Desktop.Deploy.dll %code_signing_password% %APPVEYOR_REPO_TAG_NAME%
 environment:
-  TargetFramework: net471
   decode_secret:
     secure: i67IC2xj6DjjxmA6Oj2jing3+MwzLkq6CbGsjfZ7rdY=
   code_signing_password:
     secure: 34tLNqvjmmZEi97MLKfrnQ==
 artifacts:
-  - path: 'Releases\*'
+  - path: 'osu-deploy/releases/*'
+deploy:
+  - provider: Environment
+    name: github

osu.Desktop.Deploy/.vscode/launch.json

@@ -1,29 +0,0 @@
-{
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [{
-            "name": "Deploy (Debug)",
-            "request": "launch",
-            "type": "mono",
-            "program": "${workspaceRoot}/bin/Debug/net471/osu.Desktop.Deploy.exe",
-            "cwd": "${workspaceRoot}",
-            "preLaunchTask": "Build (Debug)",
-            "runtimeExecutable": null,
-            "env": {},
-            "console": "internalConsole"
-        },
-        {
-            "name": "Deploy (Release)",
-            "request": "launch",
-            "type": "clr",
-            "program": "${workspaceRoot}/bin/Release/net471/osu.Desktop.Deploy.exe",
-            "cwd": "${workspaceRoot}",
-            "preLaunchTask": "Build (Release)",
-            "runtimeExecutable": null,
-            "env": {},
-            "console": "internalConsole"
-        }
-    ]
-}

osu.Desktop.Deploy/.vscode/tasks.json

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

osu.Desktop/OsuGameDesktop.cs

@@ -12,6 +12,8 @@ using osu.Framework.Platform;
 using osu.Game;
 using OpenTK.Input;
 using Microsoft.Win32;
+using osu.Desktop.Updater;
+using osu.Framework;
 using osu.Framework.Platform.Windows;
 
 namespace osu.Desktop
@@ -38,6 +40,51 @@ namespace osu.Desktop
             }
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            if (!noVersionOverlay)
+            {
+                LoadComponentAsync(new VersionManager { Depth = int.MinValue }, v =>
+                {
+                    Add(v);
+                    v.State = Visibility.Visible;
+                });
+
+                if (RuntimeInfo.OS == RuntimeInfo.Platform.Windows)
+                    Add(new SquirrelUpdateManager());
+                else
+                    Add(new SimpleUpdateManager());
+            }
+        }
+
+        public override void SetHost(GameHost host)
+        {
+            base.SetHost(host);
+            var desktopWindow = host.Window as DesktopGameWindow;
+            if (desktopWindow != null)
+            {
+                desktopWindow.CursorState |= CursorState.Hidden;
+
+                desktopWindow.SetIconFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(GetType(), "lazer.ico"));
+                desktopWindow.Title = Name;
+
+                desktopWindow.FileDrop += fileDrop;
+            }
+        }
+
+        private void fileDrop(object sender, FileDropEventArgs e)
+        {
+            var filePaths = new[] { e.FileName };
+
+            var firstExtension = Path.GetExtension(filePaths.First());
+
+            if (filePaths.Any(f => Path.GetExtension(f) != firstExtension)) return;
+
+            Task.Factory.StartNew(() => Import(filePaths), TaskCreationOptions.LongRunning);
+        }
+
         /// <summary>
         /// A method of accessing an osu-stable install in a controlled fashion.
         /// </summary>
@@ -73,49 +120,9 @@ namespace osu.Desktop
             }
 
             public StableStorage()
-                : base(string.Empty)
+                : base(string.Empty, null)
             {
             }
         }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            if (!noVersionOverlay)
-            {
-                LoadComponentAsync(new VersionManager { Depth = int.MinValue }, v =>
-                {
-                    Add(v);
-                    v.State = Visibility.Visible;
-                });
-            }
-        }
-
-        public override void SetHost(GameHost host)
-        {
-            base.SetHost(host);
-            var desktopWindow = host.Window as DesktopGameWindow;
-            if (desktopWindow != null)
-            {
-                desktopWindow.CursorState |= CursorState.Hidden;
-
-                desktopWindow.SetIconFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(GetType(), "lazer.ico"));
-                desktopWindow.Title = Name;
-
-                desktopWindow.FileDrop += fileDrop;
-            }
-        }
-
-        private void fileDrop(object sender, FileDropEventArgs e)
-        {
-            var filePaths = new[] { e.FileName };
-
-            var firstExtension = Path.GetExtension(filePaths.First());
-
-            if (filePaths.Any(f => Path.GetExtension(f) != firstExtension)) return;
-
-            Task.Factory.StartNew(() => Import(filePaths), TaskCreationOptions.LongRunning);
-        }
     }
 }

osu.Desktop/Overlays/VersionManager.cs

@@ -1,19 +1,20 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System.Diagnostics;
+using System;
 using osu.Framework.Allocation;
-using osu.Framework.Development;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
+using osu.Framework.Platform;
 using osu.Game;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
+using osu.Game.Utils;
 using OpenTK;
 using OpenTK.Graphics;
 
@@ -24,16 +25,18 @@ namespace osu.Desktop.Overlays
         private OsuConfigManager config;
         private OsuGameBase game;
         private NotificationOverlay notificationOverlay;
+        private GameHost host;
 
         public override bool HandleKeyboardInput => false;
         public override bool HandleMouseInput => false;
 
         [BackgroundDependencyLoader]
-        private void load(NotificationOverlay notification, OsuColour colours, TextureStore textures, OsuGameBase game, OsuConfigManager config)
+        private void load(NotificationOverlay notification, OsuColour colours, TextureStore textures, OsuGameBase game, OsuConfigManager config, GameHost host)
         {
             notificationOverlay = notification;
             this.config = config;
             this.game = game;
+            this.host = host;
 
             AutoSizeAxes = Axes.Both;
             Anchor = Anchor.BottomCentre;
@@ -88,10 +91,6 @@ namespace osu.Desktop.Overlays
                     }
                 }
             };
-
-#if NET_FRAMEWORK
-            Add(new SquirrelUpdateManager());
-#endif
         }
 
         protected override void LoadComplete()
@@ -106,19 +105,19 @@ namespace osu.Desktop.Overlays
 
                 // only show a notification if we've previously saved a version to the config file (ie. not the first run).
                 if (!string.IsNullOrEmpty(lastVersion))
-                    notificationOverlay.Post(new UpdateCompleteNotification(version));
+                    notificationOverlay.Post(new UpdateCompleteNotification(version, host.OpenUrlExternally));
             }
         }
 
         private class UpdateCompleteNotification : SimpleNotification
         {
-            public UpdateCompleteNotification(string version)
+            public UpdateCompleteNotification(string version, Action<string> openUrl = null)
             {
                 Text = $"You are now running osu!lazer {version}.\nClick to see what's new!";
                 Icon = FontAwesome.fa_check_square;
                 Activated = delegate
                 {
-                    Process.Start($"https://github.com/ppy/osu/releases/tag/v{version}");
+                    openUrl?.Invoke($"https://osu.ppy.sh/home/changelog/lazer/{version}");
                     return true;
                 };
             }

osu.Desktop/Program.cs

@@ -4,12 +4,13 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using osu.Framework;
+using osu.Framework.Development;
+using osu.Framework.Logging;
 using osu.Framework.Platform;
 using osu.Game.IPC;
-#if NET_FRAMEWORK
-using System.Runtime;
-#endif
 
 namespace osu.Desktop
 {
@@ -18,16 +19,13 @@ namespace osu.Desktop
         [STAThread]
         public static int Main(string[] args)
         {
-            // required to initialise native SQLite libraries on some platforms.
-
-            if (!RuntimeInfo.IsMono)
-                useMulticoreJit();
-
             // Back up the cwd before DesktopGameHost changes it
             var cwd = Environment.CurrentDirectory;
 
             using (DesktopGameHost host = Host.GetSuitableHost(@"osu", true))
             {
+                host.ExceptionThrown += handleException;
+
                 if (!host.IsPrimaryInstance)
                 {
                     var importer = new ArchiveImportIPCChannel(host);
@@ -54,13 +52,23 @@ namespace osu.Desktop
             }
         }
 
-        private static void useMulticoreJit()
+        private static int allowableExceptions = DebugUtils.IsDebugBuild ? 0 : 1;
+
+        /// <summary>
+        /// Allow a maximum of one unhandled exception, per second of execution.
+        /// </summary>
+        /// <param name="arg"></param>
+        /// <returns></returns>
+        private static bool handleException(Exception arg)
         {
-#if NET_FRAMEWORK
-            var directory = Directory.CreateDirectory(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Profiles"));
-            ProfileOptimization.SetProfileRoot(directory.FullName);
-            ProfileOptimization.StartProfile("Startup.Profile");
-#endif
+            bool continueExecution = Interlocked.Decrement(ref allowableExceptions) >= 0;
+
+            Logger.Log($"Unhandled exception has been {(continueExecution ? $"allowed with {allowableExceptions} more allowable exceptions" : "denied")} .");
+
+            // restore the stock of allowable exceptions after a short delay.
+            Task.Delay(1000).ContinueWith(_ => Interlocked.Increment(ref allowableExceptions));
+
+            return continueExecution;
         }
     }
 }

osu.Desktop/Updater/SimpleUpdateManager.cs

@@ -0,0 +1,103 @@
+// Copyright (c) 2007-2018 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 System.Threading.Tasks;
+using Newtonsoft.Json;
+using osu.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.IO.Network;
+using osu.Framework.Platform;
+using osu.Game;
+using osu.Game.Graphics;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Notifications;
+
+namespace osu.Desktop.Updater
+{
+    /// <summary>
+    /// An update manager that shows notifications if a newer release is detected.
+    /// Installation is left up to the user.
+    /// </summary>
+    internal class SimpleUpdateManager : CompositeDrawable
+    {
+        private NotificationOverlay notificationOverlay;
+        private string version;
+        private GameHost host;
+
+        [BackgroundDependencyLoader]
+        private void load(NotificationOverlay notification, OsuGameBase game, GameHost host)
+        {
+            notificationOverlay = notification;
+
+            this.host = host;
+            version = game.Version;
+
+            if (game.IsDeployedBuild)
+                Schedule(() => Task.Run(() => checkForUpdateAsync()));
+        }
+
+        private async void checkForUpdateAsync()
+        {
+            var releases = new JsonWebRequest<GitHubRelease>("https://api.github.com/repos/ppy/osu/releases/latest");
+            await releases.PerformAsync();
+
+            var latest = releases.ResponseObject;
+
+            if (latest.TagName != version)
+            {
+                notificationOverlay.Post(new SimpleNotification
+                {
+                    Text = $"A newer release of osu! has been found ({version} → {latest.TagName}).\n\n"
+                           + "Click here to download the new version, which can be installed over the top of your existing installation",
+                    Icon = FontAwesome.fa_upload,
+                    Activated = () =>
+                    {
+                        host.OpenUrlExternally(getBestUrl(latest));
+                        return true;
+                    }
+                });
+            }
+        }
+
+        private string getBestUrl(GitHubRelease release)
+        {
+            GitHubAsset bestAsset = null;
+
+            switch (RuntimeInfo.OS)
+            {
+                case RuntimeInfo.Platform.Windows:
+                    bestAsset = release.Assets?.FirstOrDefault(f => f.Name.EndsWith(".exe"));
+                    break;
+                case RuntimeInfo.Platform.MacOsx:
+                    bestAsset = release.Assets?.FirstOrDefault(f => f.Name.EndsWith(".app.zip"));
+                    break;
+            }
+
+            return bestAsset?.BrowserDownloadUrl ?? release.HtmlUrl;
+        }
+
+        public class GitHubRelease
+        {
+            [JsonProperty("html_url")]
+            public string HtmlUrl { get; set; }
+
+            [JsonProperty("tag_name")]
+            public string TagName { get; set; }
+
+            [JsonProperty("assets")]
+            public List<GitHubAsset> Assets { get; set; }
+        }
+
+        public class GitHubAsset
+        {
+            [JsonProperty("name")]
+            public string Name { get; set; }
+
+            [JsonProperty("browser_download_url")]
+            public string BrowserDownloadUrl { get; set; }
+        }
+    }
+}

osu.Desktop/Updater/SquirrelUpdateManager.cs

@@ -1,8 +1,8 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-#if NET_FRAMEWORK
 using System;
+using System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
@@ -16,7 +16,7 @@ using OpenTK;
 using OpenTK.Graphics;
 using Squirrel;
 
-namespace osu.Desktop.Overlays
+namespace osu.Desktop.Updater
 {
     public class SquirrelUpdateManager : Component
     {
@@ -35,7 +35,7 @@ namespace osu.Desktop.Overlays
             notificationOverlay = notification;
 
             if (game.IsDeployedBuild)
-                Schedule(() => checkForUpdateAsync());
+                Schedule(() => Task.Run(() => checkForUpdateAsync()));
         }
 
         private async void checkForUpdateAsync(bool useDeltaPatching = true, UpdateProgressNotification notification = null)
@@ -161,4 +161,3 @@ namespace osu.Desktop.Overlays
         }
     }
 }
-#endif

osu.Desktop/osu.Desktop.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\osu.Game.props" />
   <PropertyGroup Label="Project">
-    <TargetFrameworks>net471;netcoreapp2.1</TargetFrameworks>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
     <OutputType>WinExe</OutputType>
     <PlatformTarget>AnyCPU</PlatformTarget>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
@@ -13,27 +13,25 @@
     <Version>0.0.0</Version>
     <FileVersion>0.0.0</FileVersion>
   </PropertyGroup>
-  <PropertyGroup Label="Defines">
-    <DefineConstants Condition="'$(TargetFramework)' == 'net471'">$(DefineConstants);NET_FRAMEWORK</DefineConstants>
-  </PropertyGroup>
   <PropertyGroup>
     <StartupObject>osu.Desktop.Program</StartupObject>
   </PropertyGroup>
   <ItemGroup Label="Project References">
-    <ProjectReference Include="..\osu-framework\osu.Framework\osu.Framework.csproj" />
     <ProjectReference Include="..\osu.Game\osu.Game.csproj" />
     <ProjectReference Include="..\osu.Game.Rulesets.Osu\osu.Game.Rulesets.Osu.csproj" />
     <ProjectReference Include="..\osu.Game.Rulesets.Catch\osu.Game.Rulesets.Catch.csproj" />
     <ProjectReference Include="..\osu.Game.Rulesets.Mania\osu.Game.Rulesets.Mania.csproj" />
     <ProjectReference Include="..\osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj" />
     <ProjectReference Include="..\osu-resources\osu.Game.Resources\osu.Game.Resources.csproj" />
-    <PackageReference Include="Microsoft.Win32.Registry" Version="4.4.0" />
+    <PackageReference Include="Microsoft.Win32.Registry" Version="4.5.0" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.0.3" />
-    <PackageReference Include="squirrel.windows" Version="1.8.0" Condition="'$(TargetFramework)' == 'net471'" />
+    <PackageReference Include="System.IO.Packaging" Version="4.5.0" />
+    <PackageReference Include="ppy.squirrel.windows" Version="1.8.0.5" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.2" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.1.2" />
   </ItemGroup>
   <ItemGroup Label="Resources">
     <EmbeddedResource Include="lazer.ico" />
   </ItemGroup>
-</Project>
+</Project>

osu.Desktop/osu.nuspec

@@ -3,7 +3,7 @@
     <metadata>
         <id>osulazer</id>
         <version>0.0.0</version>
-        <title>osulazer</title>
+        <title>osu!lazer</title>
         <authors>ppy Pty Ltd</authors>
         <owners>Dean Herbert</owners>
         <projectUrl>https://osu.ppy.sh/</projectUrl>

osu.Game.Rulesets.Catch.Tests/.vscode/launch.json

@@ -2,35 +2,7 @@
     "version": "0.2.0",
     "configurations": [
         {
-            "name": "VisualTests (Debug, net471)",
-            "windows": {
-                "type": "clr"
-            },
-            "type": "mono",
-            "request": "launch",
-            "program": "${workspaceRoot}/bin/Debug/net471/osu.Game.Rulesets.Catch.Tests.exe",
-            "cwd": "${workspaceRoot}",
-            "preLaunchTask": "Build (Debug, msbuild)",
-            "runtimeExecutable": null,
-            "env": {},
-            "console": "internalConsole"
-        },
-        {
-            "name": "VisualTests (Release, net471)",
-            "windows": {
-                "type": "clr"
-            },
-            "type": "mono",
-            "request": "launch",
-            "program": "${workspaceRoot}/bin/Release/net471/osu.Game.Rulesets.Catch.Tests.exe",
-            "cwd": "${workspaceRoot}",
-            "preLaunchTask": "Build (Release, msbuild)",
-            "runtimeExecutable": null,
-            "env": {},
-            "console": "internalConsole"
-        },
-        {
-            "name": "VisualTests (Debug, netcoreapp2.1)",
+            "name": "VisualTests (Debug)",
             "type": "coreclr",
             "request": "launch",
             "program": "dotnet",
@@ -38,12 +10,12 @@
                 "${workspaceRoot}/bin/Debug/netcoreapp2.1/osu.Game.Rulesets.Catch.Tests.dll"
             ],
             "cwd": "${workspaceRoot}",
-            "preLaunchTask": "Build (Debug, dotnet)",
+            "preLaunchTask": "Build (Debug)",
             "env": {},
             "console": "internalConsole"
         },
         {
-            "name": "VisualTests (Release, netcoreapp2.1)",
+            "name": "VisualTests (Release)",
             "type": "coreclr",
             "request": "launch",
             "program": "dotnet",
@@ -51,7 +23,7 @@
                 "${workspaceRoot}/bin/Release/netcoreapp2.1/osu.Game.Rulesets.Catch.Tests.dll"
             ],
             "cwd": "${workspaceRoot}",
-            "preLaunchTask": "Build (Release, dotnet)",
+            "preLaunchTask": "Build (Release)",
             "env": {},
             "console": "internalConsole"
         }

osu.Game.Rulesets.Catch.Tests/.vscode/tasks.json

@@ -4,43 +4,13 @@
     "version": "2.0.0",
     "tasks": [
         {
-            "label": "Build (Debug, msbuild)",
-            "type": "shell",
-            "command": "msbuild",
-            "args": [
-                "osu.Game.Rulesets.Catch.Tests.csproj",
-                "/p:TargetFramework=net471",
-                "/p:GenerateFullPaths=true",
-                "/m",
-                "/verbosity:m"
-            ],
-            "group": "build",
-            "problemMatcher": "$msCompile"
-        },
-        {
-            "label": "Build (Release, msbuild)",
-            "type": "shell",
-            "command": "msbuild",
-            "args": [
-                "osu.Game.Rulesets.Catch.Tests.csproj",
-                "/p:Configuration=Release",
-                "/p:TargetFramework=net471",
-                "/p:GenerateFullPaths=true",
-                "/m",
-                "/verbosity:m"
-            ],
-            "group": "build",
-            "problemMatcher": "$msCompile"
-        },
-        {
-            "label": "Build (Debug, dotnet)",
+            "label": "Build (Debug)",
             "type": "shell",
             "command": "dotnet",
             "args": [
                 "build",
                 "--no-restore",
                 "osu.Game.Rulesets.Catch.Tests.csproj",
-                "/p:TargetFramework=netcoreapp2.1",
                 "/p:GenerateFullPaths=true",
                 "/m",
                 "/verbosity:m"
@@ -49,14 +19,13 @@
             "problemMatcher": "$msCompile"
         },
         {
-            "label": "Build (Release, dotnet)",
+            "label": "Build (Release)",
             "type": "shell",
             "command": "dotnet",
             "args": [
                 "build",
                 "--no-restore",
                 "osu.Game.Rulesets.Catch.Tests.csproj",
-                "/p:TargetFramework=netcoreapp2.1",
                 "/p:Configuration=Release",
                 "/p:GenerateFullPaths=true",
                 "/m",
@@ -66,16 +35,7 @@
             "problemMatcher": "$msCompile"
         },
         {
-            "label": "Restore (net471)",
-            "type": "shell",
-            "command": "nuget",
-            "args": [
-                "restore"
-            ],
-            "problemMatcher": []
-        },
-        {
-            "label": "Restore (netcoreapp2.1)",
+            "label": "Restore",
             "type": "shell",
             "command": "dotnet",
             "args": [

osu.Game.Rulesets.Catch.Tests/CatchBeatmapConversionTest.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using Newtonsoft.Json;
 using NUnit.Framework;
 using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Catch.Objects;
@@ -12,11 +13,14 @@ using osu.Game.Tests.Beatmaps;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
-    internal class CatchBeatmapConversionTest : BeatmapConversionTest<ConvertValue>
+    [TestFixture]
+    public class CatchBeatmapConversionTest : BeatmapConversionTest<ConvertValue>
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Catch";
 
-        [TestCase("basic"), Ignore("See: https://github.com/ppy/osu/issues/2232")]
+        [TestCase("basic")]
+        [TestCase("spinner")]
+        [TestCase("spinner-and-circles")]
         public new void Test(string name)
         {
             base.Test(name);
@@ -24,39 +28,57 @@ namespace osu.Game.Rulesets.Catch.Tests
 
         protected override IEnumerable<ConvertValue> CreateConvertValue(HitObject hitObject)
         {
-            if (hitObject is JuiceStream stream)
+            switch (hitObject)
             {
-                foreach (var nested in stream.NestedHitObjects)
-                {
-                    yield return new ConvertValue
-                    {
-                        StartTime = nested.StartTime,
-                        Position = ((CatchHitObject)nested).X * CatchPlayfield.BASE_WIDTH
-                    };
-                }
-            }
-            else
-            {
-                yield return new ConvertValue
-                {
-                    StartTime = hitObject.StartTime,
-                    Position = ((CatchHitObject)hitObject).X * CatchPlayfield.BASE_WIDTH
-                };
+                case JuiceStream stream:
+                    foreach (var nested in stream.NestedHitObjects)
+                        yield return new ConvertValue((CatchHitObject)nested);
+                    break;
+                case BananaShower shower:
+                    foreach (var nested in shower.NestedHitObjects)
+                        yield return new ConvertValue((CatchHitObject)nested);
+                    break;
+                default:
+                    yield return new ConvertValue((CatchHitObject)hitObject);
+                    break;
             }
         }
 
         protected override Ruleset CreateRuleset() => new CatchRuleset();
     }
 
-    internal struct ConvertValue : IEquatable<ConvertValue>
+    public struct ConvertValue : IEquatable<ConvertValue>
     {
         /// <summary>
         /// A sane value to account for osu!stable using ints everwhere.
         /// </summary>
         private const float conversion_lenience = 2;
 
-        public double StartTime;
-        public float Position;
+        [JsonIgnore]
+        public readonly CatchHitObject HitObject;
+
+        public ConvertValue(CatchHitObject hitObject)
+        {
+            HitObject = hitObject;
+            startTime = 0;
+            position = 0;
+        }
+
+        private double startTime;
+
+        public double StartTime
+        {
+            get => HitObject?.StartTime ?? startTime;
+            set => startTime = value;
+        }
+
+        private float position;
+
+        public float Position
+        {
+            get => HitObject?.X * CatchPlayfield.BASE_WIDTH ?? position;
+            set => position = value;
+        }
 
         public bool Equals(ConvertValue other)
             => Precision.AlmostEquals(StartTime, other.StartTime, conversion_lenience)

osu.Game.Rulesets.Catch.Tests/TestCaseAutoJuiceStream.cs

@@ -53,10 +53,10 @@ namespace osu.Game.Rulesets.Catch.Tests
             return beatmap;
         }
 
-        protected override Player CreatePlayer(WorkingBeatmap beatmap, Ruleset ruleset)
+        protected override Player CreatePlayer(Ruleset ruleset)
         {
-            beatmap.Mods.Value = beatmap.Mods.Value.Concat(new[] { ruleset.GetAutoplayMod() });
-            return base.CreatePlayer(beatmap, ruleset);
+            Beatmap.Value.Mods.Value = Beatmap.Value.Mods.Value.Concat(new[] { ruleset.GetAutoplayMod() });
+            return base.CreatePlayer(ruleset);
         }
     }
 }

osu.Game.Rulesets.Catch.Tests/TestCaseCatcherArea.cs

@@ -55,7 +55,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             {
             }
 
-            public void ToggleHyperDash(bool status) => MovableCatcher.HyperDashModifier = status ? 2 : 1;
+            public void ToggleHyperDash(bool status) => MovableCatcher.SetHyperDashState(status ? 2 : 1);
         }
     }
 }

osu.Game.Rulesets.Catch.Tests/TestCaseFruitObjects.cs

@@ -55,7 +55,7 @@ namespace osu.Game.Rulesets.Catch.Tests
         private DrawableFruit createDrawable(int index)
         {
             Fruit fruit = index == 5
-                ? new BananaShower.Banana
+                ? new Banana
                 {
                     StartTime = 1000000000000,
                     IndexInBeatmap = index,

osu.Game.Rulesets.Catch.Tests/TestCaseHyperDash.cs

@@ -8,9 +8,9 @@ using osu.Game.Rulesets.Catch.Objects;
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
-    public class TestCaseHyperdash : Game.Tests.Visual.TestCasePlayer
+    public class TestCaseHyperDash : Game.Tests.Visual.TestCasePlayer
     {
-        public TestCaseHyperdash()
+        public TestCaseHyperDash()
             : base(new CatchRuleset())
         {
         }

osu.Game.Rulesets.Catch.Tests/TestCasePerformancePoints.cs

@@ -1,16 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using NUnit.Framework;
-
-namespace osu.Game.Rulesets.Catch.Tests
-{
-    [TestFixture]
-    public class TestCasePerformancePoints : Game.Tests.Visual.TestCasePerformancePoints
-    {
-        public TestCasePerformancePoints()
-            : base(new CatchRuleset())
-        {
-        }
-    }
-}

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

@@ -1,8 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\osu.TestProject.props" />
+  <ItemGroup Label="Package References">
+    <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.8.0" />
+    <PackageReference Include="NUnit" Version="3.10.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.10.0" />
+  </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>
-    <TargetFrameworks>netcoreapp2.1;net471</TargetFrameworks>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
   </PropertyGroup>
   <ItemGroup Label="Project References">
     <ProjectReference Include="..\osu.Game.Rulesets.Catch\osu.Game.Rulesets.Catch.csproj" />

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

@@ -26,22 +26,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
             var positionData = obj as IHasXPosition;
             var comboData = obj as IHasCombo;
             var endTime = obj as IHasEndTime;
-
-            if (positionData == null)
-            {
-                if (endTime != null)
-                {
-                    yield return new BananaShower
-                    {
-                        StartTime = obj.StartTime,
-                        Samples = obj.Samples,
-                        Duration = endTime.Duration,
-                        NewCombo = comboData?.NewCombo ?? false
-                    };
-                }
-
-                yield break;
-            }
+            var legacyOffset = obj as IHasLegacyLastTickOffset;
 
             if (curveData != null)
             {
@@ -54,20 +39,34 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                     Distance = curveData.Distance,
                     RepeatSamples = curveData.RepeatSamples,
                     RepeatCount = curveData.RepeatCount,
-                    X = positionData.X / CatchPlayfield.BASE_WIDTH,
-                    NewCombo = comboData?.NewCombo ?? false
+                    X = (positionData?.X ?? 0) / CatchPlayfield.BASE_WIDTH,
+                    NewCombo = comboData?.NewCombo ?? false,
+                    ComboOffset = comboData?.ComboOffset ?? 0,
+                    LegacyLastTickOffset = legacyOffset?.LegacyLastTickOffset ?? 0
                 };
-
-                yield break;
             }
-
-            yield return new Fruit
+            else if (endTime != null)
             {
-                StartTime = obj.StartTime,
-                Samples = obj.Samples,
-                NewCombo = comboData?.NewCombo ?? false,
-                X = positionData.X / CatchPlayfield.BASE_WIDTH
-            };
+                yield return new BananaShower
+                {
+                    StartTime = obj.StartTime,
+                    Samples = obj.Samples,
+                    Duration = endTime.Duration,
+                    NewCombo = comboData?.NewCombo ?? false,
+                    ComboOffset = comboData?.ComboOffset ?? 0,
+                };
+            }
+            else
+            {
+                yield return new Fruit
+                {
+                    StartTime = obj.StartTime,
+                    Samples = obj.Samples,
+                    NewCombo = comboData?.NewCombo ?? false,
+                    ComboOffset = comboData?.ComboOffset ?? 0,
+                    X = (positionData?.X ?? 0) / CatchPlayfield.BASE_WIDTH
+                };
+            }
         }
 
         protected override Beatmap<CatchHitObject> CreateBeatmap() => new CatchBeatmap();

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

@@ -9,11 +9,14 @@ using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Objects.Types;
 using OpenTK;
+using osu.Game.Rulesets.Catch.MathUtils;
 
 namespace osu.Game.Rulesets.Catch.Beatmaps
 {
     public class CatchBeatmapProcessor : BeatmapProcessor
     {
+        public const int RNG_SEED = 1337;
+
         public CatchBeatmapProcessor(IBeatmap beatmap)
             : base(beatmap)
         {
@@ -21,13 +24,52 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
 
         public override void PostProcess()
         {
-            initialiseHyperDash((List<CatchHitObject>)Beatmap.HitObjects);
-
             base.PostProcess();
 
+            applyPositionOffsets();
+
+            initialiseHyperDash((List<CatchHitObject>)Beatmap.HitObjects);
+
             int index = 0;
             foreach (var obj in Beatmap.HitObjects.OfType<CatchHitObject>())
+            {
                 obj.IndexInBeatmap = index++;
+                if (obj.LastInCombo && obj.NestedHitObjects.LastOrDefault() is IHasComboInformation lastNested)
+                    lastNested.LastInCombo = true;
+            }
+        }
+
+        private void applyPositionOffsets()
+        {
+            var rng = new FastRandom(RNG_SEED);
+            // todo: HardRock displacement should be applied here
+
+            foreach (var obj in Beatmap.HitObjects)
+            {
+                switch (obj)
+                {
+                    case BananaShower bananaShower:
+                        foreach (var banana in bananaShower.NestedHitObjects.OfType<Banana>())
+                        {
+                            banana.X = (float)rng.NextDouble();
+                            rng.Next(); // osu!stable retrieved a random banana type
+                            rng.Next(); // osu!stable retrieved a random banana rotation
+                            rng.Next(); // osu!stable retrieved a random banana colour
+                        }
+                        break;
+                    case JuiceStream juiceStream:
+                        foreach (var nested in juiceStream.NestedHitObjects)
+                        {
+                            var hitObject = (CatchHitObject)nested;
+                            if (hitObject is TinyDroplet)
+                                hitObject.X += rng.Next(-20, 20) / CatchPlayfield.BASE_WIDTH;
+                            else if (hitObject is Droplet)
+                                rng.Next(); // osu!stable retrieved a random droplet rotation
+                            hitObject.X = MathHelper.Clamp(hitObject.X, 0, 1);
+                        }
+                        break;
+                }
+            }
         }
 
         private void initialiseHyperDash(List<CatchHitObject> objects)

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -82,56 +82,23 @@ namespace osu.Game.Rulesets.Catch
                     {
                         new CatchModEasy(),
                         new CatchModNoFail(),
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new CatchModHalfTime(),
-                                new CatchModDaycore(),
-                            },
-                        },
+                        new MultiMod(new CatchModHalfTime(), new CatchModDaycore())
                     };
-
                 case ModType.DifficultyIncrease:
                     return new Mod[]
                     {
                         new CatchModHardRock(),
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new CatchModSuddenDeath(),
-                                new CatchModPerfect(),
-                            },
-                        },
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new CatchModDoubleTime(),
-                                new CatchModNightcore(),
-                            },
-                        },
+                        new MultiMod(new CatchModSuddenDeath(), new CatchModPerfect()),
+                        new MultiMod(new CatchModDoubleTime(), new CatchModNightcore()),
                         new CatchModHidden(),
                         new CatchModFlashlight(),
                     };
-
-                case ModType.Special:
+                case ModType.Automation:
                     return new Mod[]
                     {
+                        new MultiMod(new CatchModAutoplay(), new ModCinema()),
                         new CatchModRelax(),
-                        null,
-                        null,
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new CatchModAutoplay(),
-                                new ModCinema(),
-                            },
-                        },
                     };
-
                 default:
                     return new Mod[] { };
             }
@@ -143,7 +110,7 @@ namespace osu.Game.Rulesets.Catch
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_fruits_o };
 
-        public override DifficultyCalculator CreateDifficultyCalculator(IBeatmap beatmap, Mod[] mods = null) => new CatchDifficultyCalculator(beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new CatchDifficultyCalculator(this, beatmap);
 
         public override int? LegacyID => 2;
 

osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyAttributes.cs

@@ -0,0 +1,19 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mods;
+
+namespace osu.Game.Rulesets.Catch.Difficulty
+{
+    public class CatchDifficultyAttributes : DifficultyAttributes
+    {
+        public double ApproachRate;
+        public int MaxCombo;
+
+        public CatchDifficultyAttributes(Mod[] mods, double starRating)
+            : base(mods, starRating)
+        {
+        }
+    }
+}

osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs

@@ -1,18 +1,149 @@
 // Copyright (c) 2007-2018 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.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
 
 namespace osu.Game.Rulesets.Catch.Difficulty
 {
     public class CatchDifficultyCalculator : DifficultyCalculator
     {
-        public CatchDifficultyCalculator(IBeatmap beatmap) : base(beatmap)
+
+        /// <summary>
+        /// In milliseconds. For difficulty calculation we will only look at the highest strain value in each time interval of size STRAIN_STEP.
+        /// This is to eliminate higher influence of stream over aim by simply having more HitObjects with high strain.
+        /// The higher this value, the less strains there will be, indirectly giving long beatmaps an advantage.
+        /// </summary>
+        private const double strain_step = 750;
+
+        /// <summary>
+        /// The weighting of each strain value decays to this number * it's previous value
+        /// </summary>
+        private const double decay_weight = 0.94;
+
+        private const double star_scaling_factor = 0.145;
+
+        public CatchDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+            : base(ruleset, beatmap)
         {
         }
 
-        public override double Calculate(Dictionary<string, double> categoryDifficulty = null) => 0;
+        protected override DifficultyAttributes Calculate(IBeatmap beatmap, Mod[] mods, double timeRate)
+        {
+            if (!beatmap.HitObjects.Any())
+                return new CatchDifficultyAttributes(mods, 0);
+
+            var catcher = new CatcherArea.Catcher(beatmap.BeatmapInfo.BaseDifficulty);
+            float halfCatchWidth = catcher.CatchWidth * 0.5f;
+
+            var difficultyHitObjects = new List<CatchDifficultyHitObject>();
+
+            foreach (var hitObject in beatmap.HitObjects)
+            {
+                switch (hitObject)
+                {
+                    // We want to only consider fruits that contribute to the combo. Droplets are addressed as accuracy and spinners are not relevant for "skill" calculations.
+                    case Fruit fruit:
+                        difficultyHitObjects.Add(new CatchDifficultyHitObject(fruit, halfCatchWidth));
+                        break;
+                    case JuiceStream _:
+                        difficultyHitObjects.AddRange(hitObject.NestedHitObjects.OfType<CatchHitObject>().Where(o => !(o is TinyDroplet)).Select(o => new CatchDifficultyHitObject(o, halfCatchWidth)));
+                        break;
+                }
+            }
+
+            difficultyHitObjects.Sort((a, b) => a.BaseHitObject.StartTime.CompareTo(b.BaseHitObject.StartTime));
+
+            if (!calculateStrainValues(difficultyHitObjects, timeRate))
+                return new CatchDifficultyAttributes(mods, 0);
+
+            // this is the same as osu!, so there's potential to share the implementation... maybe
+            double preempt = BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450) / timeRate;
+            double starRating = Math.Sqrt(calculateDifficulty(difficultyHitObjects, timeRate)) * star_scaling_factor;
+
+            return new CatchDifficultyAttributes(mods, starRating)
+            {
+                ApproachRate = preempt > 1200.0 ? -(preempt - 1800.0) / 120.0 : -(preempt - 1200.0) / 150.0 + 5.0,
+                MaxCombo = difficultyHitObjects.Count
+            };
+        }
+
+        private bool calculateStrainValues(List<CatchDifficultyHitObject> objects, double timeRate)
+        {
+            CatchDifficultyHitObject lastObject = null;
+
+            if (!objects.Any()) return false;
+
+            // Traverse hitObjects in pairs to calculate the strain value of NextHitObject from the strain value of CurrentHitObject and environment.
+            foreach (var currentObject in objects)
+            {
+                if (lastObject != null)
+                    currentObject.CalculateStrains(lastObject, timeRate);
+
+                lastObject = currentObject;
+            }
+
+            return true;
+        }
+
+        private double calculateDifficulty(List<CatchDifficultyHitObject> objects, double timeRate)
+        {
+            // The strain step needs to be adjusted for the algorithm to be considered equal with speed changing mods
+            double actualStrainStep = strain_step * timeRate;
+
+            // Find the highest strain value within each strain step
+            var highestStrains = new List<double>();
+            double intervalEndTime = actualStrainStep;
+            double maximumStrain = 0; // We need to keep track of the maximum strain in the current interval
+
+            CatchDifficultyHitObject previousHitObject = null;
+            foreach (CatchDifficultyHitObject hitObject in objects)
+            {
+                // While we are beyond the current interval push the currently available maximum to our strain list
+                while (hitObject.BaseHitObject.StartTime > intervalEndTime)
+                {
+                    highestStrains.Add(maximumStrain);
+
+                    // The maximum strain of the next interval is not zero by default! We need to take the last hitObject we encountered, take its strain and apply the decay
+                    // until the beginning of the next interval.
+                    if (previousHitObject == null)
+                    {
+                        maximumStrain = 0;
+                    }
+                    else
+                    {
+                        double decay = Math.Pow(CatchDifficultyHitObject.DECAY_BASE, (intervalEndTime - previousHitObject.BaseHitObject.StartTime) / 1000);
+                        maximumStrain = previousHitObject.Strain * decay;
+                    }
+
+                    // Go to the next time interval
+                    intervalEndTime += actualStrainStep;
+                }
+
+                // Obtain maximum strain
+                maximumStrain = Math.Max(hitObject.Strain, maximumStrain);
+
+                previousHitObject = hitObject;
+            }
+
+            // Build the weighted sum over the highest strains for each interval
+            double difficulty = 0;
+            double weight = 1;
+            highestStrains.Sort((a, b) => b.CompareTo(a)); // Sort from highest to lowest strain.
+
+            foreach (double strain in highestStrains)
+            {
+                difficulty += weight * strain;
+                weight *= decay_weight;
+            }
+
+            return difficulty;
+        }
     }
 }

osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyHitObject.cs

@@ -0,0 +1,130 @@
+// Copyright (c) 2007-2018 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.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Catch.Difficulty
+{
+    public class CatchDifficultyHitObject
+    {
+        internal static readonly double DECAY_BASE = 0.20;
+        private const float normalized_hitobject_radius = 41.0f;
+        private const float absolute_player_positioning_error = 16f;
+        private readonly float playerPositioningError;
+
+        internal CatchHitObject BaseHitObject;
+
+        /// <summary>
+        /// Measures jump difficulty. CtB doesn't have something like button pressing speed or accuracy
+        /// </summary>
+        internal double Strain = 1;
+
+        /// <summary>
+        /// This is required to keep track of lazy player movement (always moving only as far as necessary)
+        /// Without this quick repeat sliders / weirdly shaped streams might become ridiculously overrated
+        /// </summary>
+        internal float PlayerPositionOffset;
+        internal float LastMovement;
+
+        internal float NormalizedPosition;
+        internal float ActualNormalizedPosition => NormalizedPosition + PlayerPositionOffset;
+
+        internal CatchDifficultyHitObject(CatchHitObject baseHitObject, float catcherWidthHalf)
+        {
+            BaseHitObject = baseHitObject;
+
+            // We will scale everything by this factor, so we can assume a uniform CircleSize among beatmaps.
+            float scalingFactor = normalized_hitobject_radius / catcherWidthHalf;
+
+            playerPositioningError = absolute_player_positioning_error; // * scalingFactor;
+            NormalizedPosition = baseHitObject.X * CatchPlayfield.BASE_WIDTH * scalingFactor;
+        }
+
+        private const double direction_change_bonus = 12.5;
+        internal void CalculateStrains(CatchDifficultyHitObject previousHitObject, double timeRate)
+        {
+            // Rather simple, but more specialized things are inherently inaccurate due to the big difference playstyles and opinions make.
+            // See Taiko feedback thread.
+            double timeElapsed = (BaseHitObject.StartTime - previousHitObject.BaseHitObject.StartTime) / timeRate;
+            double decay = Math.Pow(DECAY_BASE, timeElapsed / 1000);
+
+            // Update new position with lazy movement.
+            PlayerPositionOffset =
+                MathHelper.Clamp(
+                    previousHitObject.ActualNormalizedPosition,
+                    NormalizedPosition - (normalized_hitobject_radius - playerPositioningError),
+                    NormalizedPosition + (normalized_hitobject_radius - playerPositioningError)) // Obtain new lazy position, but be stricter by allowing for an error of a certain degree of the player.
+                - NormalizedPosition; // Subtract HitObject position to obtain offset
+
+            LastMovement = DistanceTo(previousHitObject);
+            double addition = spacingWeight(LastMovement);
+
+            if (NormalizedPosition < previousHitObject.NormalizedPosition)
+            {
+                LastMovement = -LastMovement;
+            }
+
+            CatchHitObject previousHitCircle = previousHitObject.BaseHitObject;
+
+            double additionBonus = 0;
+            double sqrtTime = Math.Sqrt(Math.Max(timeElapsed, 25));
+
+            // Direction changes give an extra point!
+            if (Math.Abs(LastMovement) > 0.1)
+            {
+                if (Math.Abs(previousHitObject.LastMovement) > 0.1 && Math.Sign(LastMovement) != Math.Sign(previousHitObject.LastMovement))
+                {
+                    double bonus = direction_change_bonus / sqrtTime;
+
+                    // Weight bonus by how
+                    double bonusFactor = Math.Min(playerPositioningError, Math.Abs(LastMovement)) / playerPositioningError;
+
+                    // We want time to play a role twice here!
+                    addition += bonus * bonusFactor;
+
+                    // Bonus for tougher direction switches and "almost" hyperdashes at this point
+                    if (previousHitCircle != null && previousHitCircle.DistanceToHyperDash <= 10.0f / CatchPlayfield.BASE_WIDTH)
+                    {
+                        additionBonus += 0.3 * bonusFactor;
+                    }
+                }
+
+                // Base bonus for every movement, giving some weight to streams.
+                addition += 7.5 * Math.Min(Math.Abs(LastMovement), normalized_hitobject_radius * 2) / (normalized_hitobject_radius * 6) / sqrtTime;
+            }
+
+            // Bonus for "almost" hyperdashes at corner points
+            if (previousHitCircle != null && previousHitCircle.DistanceToHyperDash <= 10.0f / CatchPlayfield.BASE_WIDTH)
+            {
+                if (!previousHitCircle.HyperDash)
+                {
+                    additionBonus += 1.0;
+                }
+                else
+                {
+                    // After a hyperdash we ARE in the correct position. Always!
+                    PlayerPositionOffset = 0;
+                }
+
+                addition *= 1.0 + additionBonus * ((10 - previousHitCircle.DistanceToHyperDash * CatchPlayfield.BASE_WIDTH) / 10);
+            }
+
+            addition *= 850.0 / Math.Max(timeElapsed, 25);
+
+            Strain = previousHitObject.Strain * decay + addition;
+        }
+
+        private static double spacingWeight(float distance)
+        {
+            return Math.Pow(distance, 1.3) / 500;
+        }
+
+        internal float DistanceTo(CatchDifficultyHitObject other)
+        {
+            return Math.Abs(ActualNormalizedPosition - other.ActualNormalizedPosition);
+        }
+    }
+}

osu.Game.Rulesets.Catch/Judgements/CatchBananaJudgement.cs

@@ -0,0 +1,37 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Catch.Judgements
+{
+    public class CatchBananaJudgement : CatchJudgement
+    {
+        public override bool AffectsCombo => false;
+
+        protected override int NumericResultFor(HitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return 0;
+                case HitResult.Perfect:
+                    return 1100;
+            }
+        }
+
+        protected override float HealthIncreaseFor(HitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return 0;
+                case HitResult.Perfect:
+                    return 8;
+            }
+        }
+
+        public override bool ShouldExplodeFor(JudgementResult result) => true;
+    }
+}

osu.Game.Rulesets.Catch/Judgements/CatchDropletJudgement.cs

@@ -0,0 +1,32 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Catch.Judgements
+{
+    public class CatchDropletJudgement : CatchJudgement
+    {
+        protected override int NumericResultFor(HitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return 0;
+                case HitResult.Perfect:
+                    return 30;
+            }
+        }
+
+        protected override float HealthIncreaseFor(HitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return 0;
+                case HitResult.Perfect:
+                    return 7;
+            }
+        }
+    }
+}

osu.Game.Rulesets.Catch/Judgements/CatchJudgement.cs

@@ -2,11 +2,53 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Catch.Judgements
 {
     public class CatchJudgement : Judgement
     {
-        // todo: wangs
+        public override HitResult MaxResult => HitResult.Perfect;
+
+        protected override int NumericResultFor(HitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return 0;
+                case HitResult.Perfect:
+                    return 300;
+            }
+        }
+
+        /// <summary>
+        /// Retrieves the numeric health increase of a <see cref="HitResult"/>.
+        /// </summary>
+        /// <param name="result">The <see cref="HitResult"/> to find the numeric health increase for.</param>
+        /// <returns>The numeric health increase of <paramref name="result"/>.</returns>
+        protected virtual float HealthIncreaseFor(HitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return 0;
+                case HitResult.Perfect:
+                    return 10.2f;
+            }
+        }
+
+        /// <summary>
+        /// Retrieves the numeric health increase of a <see cref="JudgementResult"/>.
+        /// </summary>
+        /// <param name="result">The <see cref="JudgementResult"/> to find the numeric health increase for.</param>
+        /// <returns>The numeric health increase of <paramref name="result"/>.</returns>
+        public float HealthIncreaseFor(JudgementResult result) => HealthIncreaseFor(result.Type);
+
+        /// <summary>
+        /// Whether fruit on the platter should explode or drop.
+        /// Note that this is only checked if the owning object is also <see cref="IHasComboInformation.LastInCombo" />
+        /// </summary>
+        public virtual bool ShouldExplodeFor(JudgementResult result) => result.IsHit;
     }
 }

osu.Game.Rulesets.Catch/Judgements/CatchTinyDropletJudgement.cs

@@ -0,0 +1,34 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Catch.Judgements
+{
+    public class CatchTinyDropletJudgement : CatchJudgement
+    {
+        public override bool AffectsCombo => false;
+
+        protected override int NumericResultFor(HitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return 0;
+                case HitResult.Perfect:
+                    return 10;
+            }
+        }
+
+        protected override float HealthIncreaseFor(HitResult result)
+        {
+            switch (result)
+            {
+                default:
+                    return 0;
+                case HitResult.Perfect:
+                    return 4;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,91 @@
+// Copyright (c) 2007-2018 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.Catch.MathUtils
+{
+    /// <summary>
+    /// A PRNG specified in http://heliosphan.org/fastrandom.html.
+    /// </summary>
+    public class FastRandom
+    {
+        private const double int_to_real = 1.0 / (int.MaxValue + 1.0);
+        private const uint int_mask = 0x7FFFFFFF;
+        private const uint y = 842502087;
+        private const uint z = 3579807591;
+        private const uint w = 273326509;
+        private uint _x, _y = y, _z = z, _w = w;
+
+        public FastRandom(int seed)
+        {
+            _x = (uint)seed;
+        }
+
+        public FastRandom()
+            : this(Environment.TickCount)
+        {
+        }
+
+        /// <summary>
+        /// Generates a random unsigned integer within the range [<see cref="uint.MinValue"/>, <see cref="uint.MaxValue"/>).
+        /// </summary>
+        /// <returns>The random value.</returns>
+        public uint NextUInt()
+        {
+            uint t = _x ^ _x << 11;
+            _x = _y;
+            _y = _z;
+            _z = _w;
+            return _w = _w ^ _w >> 19 ^ t ^ t >> 8;
+        }
+
+        /// <summary>
+        /// Generates a random integer value within the range [0, <see cref="int.MaxValue"/>).
+        /// </summary>
+        /// <returns>The random value.</returns>
+        public int Next() => (int)(int_mask & NextUInt());
+
+        /// <summary>
+        /// Generates a random integer value within the range [0, <paramref name="upperBound"/>).
+        /// </summary>
+        /// <param name="upperBound">The upper bound.</param>
+        /// <returns>The random value.</returns>
+        public int Next(int upperBound) => (int)(NextDouble() * upperBound);
+
+        /// <summary>
+        /// Generates a random integer value within the range [<paramref name="lowerBound"/>, <paramref name="upperBound"/>).
+        /// </summary>
+        /// <param name="lowerBound">The lower bound of the range.</param>
+        /// <param name="upperBound">The upper bound of the range.</param>
+        /// <returns>The random value.</returns>
+        public int Next(int lowerBound, int upperBound) => (int)(lowerBound + NextDouble() * (upperBound - lowerBound));
+
+        /// <summary>
+        /// Generates a random double value within the range [0, 1).
+        /// </summary>
+        /// <returns>The random value.</returns>
+        public double NextDouble() => int_to_real * Next();
+
+        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.Catch/Objects/Banana.cs

@@ -0,0 +1,15 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Catch.Judgements;
+using osu.Game.Rulesets.Judgements;
+
+namespace osu.Game.Rulesets.Catch.Objects
+{
+    public class Banana : Fruit
+    {
+        public override FruitVisualRepresentation VisualRepresentation => FruitVisualRepresentation.Banana;
+
+        public override Judgement CreateJudgement() => new CatchBananaJudgement();
+    }
+}

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

@@ -1,7 +1,6 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Rulesets.Catch.Objects
@@ -31,18 +30,12 @@ namespace osu.Game.Rulesets.Catch.Objects
                 AddNested(new Banana
                 {
                     Samples = Samples,
-                    StartTime = i,
-                    X = RNG.NextSingle()
+                    StartTime = i
                 });
         }
 
         public double EndTime => StartTime + Duration;
 
         public double Duration { get; set; }
-
-        public class Banana : Fruit
-        {
-            public override FruitVisualRepresentation VisualRepresentation => FruitVisualRepresentation.Banana;
-        }
     }
 }

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

@@ -20,10 +20,17 @@ namespace osu.Game.Rulesets.Catch.Objects
 
         public virtual bool NewCombo { get; set; }
 
+        public int ComboOffset { get; set; }
+
         public int IndexInCurrentCombo { get; set; }
 
         public int ComboIndex { get; set; }
 
+        /// <summary>
+        /// The distance for a fruit to to next hyper if it's not a hyper.
+        /// </summary>
+        public float DistanceToHyperDash { get; set; }
+
         /// <summary>
         /// The next fruit starts a new combo. Used for explodey.
         /// </summary>

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

@@ -0,0 +1,13 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawable
+{
+    public class DrawableBanana : DrawableFruit
+    {
+        public DrawableBanana(Banana h)
+            : base(h)
+        {
+        }
+    }
+}

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

@@ -5,9 +5,7 @@ using System;
 using System.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {
@@ -24,16 +22,10 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
 
             InternalChild = bananaContainer = new Container { RelativeSizeAxes = Axes.Both };
 
-            foreach (var b in s.NestedHitObjects.Cast<BananaShower.Banana>())
+            foreach (var b in s.NestedHitObjects.Cast<Banana>())
                 AddNested(getVisualRepresentation?.Invoke(b));
         }
 
-        protected override void CheckForJudgements(bool userTriggered, double timeOffset)
-        {
-            if (timeOffset >= 0)
-                AddJudgement(new Judgement { Result = NestedHitObjects.Cast<DrawableCatchHitObject>().Any(n => n.Judgements.Any(j => j.IsHit)) ? HitResult.Perfect : HitResult.Miss });
-        }
-
         protected override void AddNested(DrawableHitObject h)
         {
             ((DrawableCatchHitObject)h).CheckPosition = o => CheckPosition?.Invoke(o) ?? false;

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

@@ -2,14 +2,13 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using OpenTK;
+using OpenTK.Graphics;
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
-using OpenTK;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;
-using OpenTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {
@@ -42,6 +41,8 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
     {
         public virtual bool CanBePlated => false;
 
+        public virtual bool StaysOnPlate => CanBePlated;
+
         protected DrawableCatchHitObject(CatchHitObject hitObject)
             : base(hitObject)
         {
@@ -51,12 +52,12 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
 
         public Func<CatchHitObject, bool> CheckPosition;
 
-        protected override void CheckForJudgements(bool userTriggered, double timeOffset)
+        protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
             if (CheckPosition == null) return;
 
-            if (timeOffset >= 0)
-                AddJudgement(new Judgement { Result = CheckPosition.Invoke(HitObject) ? HitResult.Perfect : HitResult.Miss });
+            if (timeOffset >= 0 && Result != null)
+                ApplyResult(r => r.Type = CheckPosition.Invoke(HitObject) ? HitResult.Perfect : HitResult.Miss);
         }
 
         protected override void SkinChanged(ISkinSource skin, bool allowFallback)

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

@@ -13,6 +13,8 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
     {
         private Pulp pulp;
 
+        public override bool StaysOnPlate => false;
+
         public DrawableDroplet(Droplet h)
             : base(h)
         {

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

@@ -26,8 +26,6 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                 AddNested(getVisualRepresentation?.Invoke(o));
         }
 
-        protected override bool ProvidesJudgement => false;
-
         protected override void AddNested(DrawableHitObject h)
         {
             var catchObject = (DrawableCatchHitObject)h;

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

@@ -0,0 +1,16 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawable
+{
+    public class DrawableTinyDroplet : DrawableDroplet
+    {
+        public DrawableTinyDroplet(TinyDroplet h)
+            : base(h)
+        {
+            Size = new Vector2((float)CatchHitObject.OBJECT_RADIUS) / 8;
+        }
+    }
+}

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

@@ -1,9 +1,13 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Game.Rulesets.Catch.Judgements;
+using osu.Game.Rulesets.Judgements;
+
 namespace osu.Game.Rulesets.Catch.Objects
 {
     public class Droplet : CatchHitObject
     {
+        public override Judgement CreateJudgement() => new CatchDropletJudgement();
     }
 }

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

@@ -1,9 +1,13 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Game.Rulesets.Catch.Judgements;
+using osu.Game.Rulesets.Judgements;
+
 namespace osu.Game.Rulesets.Catch.Objects
 {
     public class Fruit : CatchHitObject
     {
+        public override Judgement CreateJudgement() => new CatchJudgement();
     }
 }

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

@@ -42,7 +42,6 @@ namespace osu.Game.Rulesets.Catch.Objects
         protected override void CreateNestedHitObjects()
         {
             base.CreateNestedHitObjects();
-
             createTicks();
         }
 
@@ -78,6 +77,13 @@ namespace osu.Game.Rulesets.Catch.Objects
 
                     double time = spanStartTime + timeProgress * spanDuration;
 
+                    if (LegacyLastTickOffset != null)
+                    {
+                        // If we're the last tick, apply the legacy offset
+                        if (span == this.SpanCount() - 1 && d + tickDistance > length)
+                            time = Math.Max(StartTime + Duration / 2, time - LegacyLastTickOffset.Value);
+                    }
+
                     double tinyTickInterval = time - lastDropletTime;
                     while (tinyTickInterval > 100)
                         tinyTickInterval /= 2;
@@ -153,5 +159,7 @@ namespace osu.Game.Rulesets.Catch.Objects
             get { return Curve.CurveType; }
             set { Curve.CurveType = value; }
         }
+
+        public double? LegacyLastTickOffset { get; set; }
     }
 }

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

@@ -1,9 +1,13 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Game.Rulesets.Catch.Judgements;
+using osu.Game.Rulesets.Judgements;
+
 namespace osu.Game.Rulesets.Catch.Objects
 {
     public class TinyDroplet : Droplet
     {
+        public override Judgement CreateJudgement() => new CatchTinyDropletJudgement();
     }
 }

osu.Game.Rulesets.Catch/Replays/CatchAutoGenerator.cs

@@ -56,7 +56,7 @@ namespace osu.Game.Rulesets.Catch.Replays
                     return;
                 }
 
-                if (h is BananaShower.Banana)
+                if (h is Banana)
                 {
                     // auto bananas unrealistically warp to catch 100% combo.
                     Replay.Frames.Add(new CatchReplayFrame(h.StartTime, h.X));
@@ -105,7 +105,7 @@ namespace osu.Game.Rulesets.Catch.Replays
                 {
                     switch (nestedObj)
                     {
-                        case BananaShower.Banana _:
+                        case Banana _:
                         case TinyDroplet _:
                         case Droplet _:
                         case Fruit _:

osu.Game.Rulesets.Catch/Replays/CatchFramedReplayInputHandler.cs

@@ -2,7 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Collections.Generic;
-using osu.Framework.Input;
+using osu.Framework.Input.StateChanges;
 using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Replays;
 
@@ -28,9 +28,9 @@ namespace osu.Game.Rulesets.Catch.Replays
             }
         }
 
-        public override List<InputState> GetPendingStates()
+        public override List<IInput> GetPendingInputs()
         {
-            if (!Position.HasValue) return new List<InputState>();
+            if (!Position.HasValue) return new List<IInput>();
 
             var actions = new List<CatchAction>();
 
@@ -42,7 +42,7 @@ namespace osu.Game.Rulesets.Catch.Replays
             else if (Position.Value < CurrentFrame.Position)
                 actions.Add(CatchAction.MoveLeft);
 
-            return new List<InputState>
+            return new List<IInput>
             {
                 new CatchReplayState
                 {

osu.Game.Rulesets.Catch/Resources/Testing/Beatmaps/spinner-and-circles-expected-conversion.json

@@ -0,0 +1,65 @@
+{
+    "Mappings": [{
+            "StartTime": 2589,
+            "Objects": [{
+                "StartTime": 2589,
+                "Position": 256
+            }]
+        },
+        {
+            "StartTime": 2915,
+            "Objects": [{
+                    "StartTime": 2915,
+                    "Position": 65
+                },
+                {
+                    "StartTime": 2916,
+                    "Position": 482
+                }
+            ]
+        },
+        {
+            "StartTime": 3078,
+            "Objects": [{
+                    "StartTime": 3078,
+                    "Position": 164
+                },
+                {
+                    "StartTime": 3079,
+                    "Position": 315
+                }
+            ]
+        },
+        {
+            "StartTime": 3241,
+            "Objects": [{
+                    "StartTime": 3241,
+                    "Position": 145
+                },
+                {
+                    "StartTime": 3242,
+                    "Position": 159
+                }
+            ]
+        },
+        {
+            "StartTime": 3404,
+            "Objects": [{
+                    "StartTime": 3404,
+                    "Position": 310
+                },
+                {
+                    "StartTime": 3405,
+                    "Position": 441
+                }
+            ]
+        },
+        {
+            "StartTime": 5197,
+            "Objects": [{
+                "StartTime": 5197,
+                "Position": 256
+            }]
+        }
+    ]
+}

osu.Game.Rulesets.Catch/Resources/Testing/Beatmaps/spinner-and-circles.osu

@@ -0,0 +1,24 @@
+osu file format v14
+
+[General]
+StackLeniency: 0.7
+Mode: 2
+
+[Difficulty]
+HPDrainRate:5
+CircleSize:2
+OverallDifficulty:5
+ApproachRate:8
+SliderMultiplier:1.4
+SliderTickRate:4
+
+[TimingPoints]
+2589,326.086956521739,4,2,1,70,1,0
+
+[HitObjects]
+256,192,2589,5,0,0:0:0:0:
+256,192,2915,12,0,2916,0:0:0:0:
+256,192,3078,12,0,3079,0:0:0:0:
+256,192,3241,12,0,3242,0:0:0:0:
+256,192,3404,12,0,3405,0:0:0:0:
+256,192,5197,5,0,0:0:0:0:

osu.Game.Rulesets.Catch/Resources/Testing/Beatmaps/spinner-expected-conversion.json

@@ -0,0 +1,74 @@
+{
+    "Mappings": [{
+        "StartTime": 18500,
+        "Objects": [{
+                "StartTime": 18500,
+                "Position": 65
+            },
+            {
+                "StartTime": 18559,
+                "Position": 482
+            },
+            {
+                "StartTime": 18618,
+                "Position": 164
+            },
+            {
+                "StartTime": 18678,
+                "Position": 315
+            },
+            {
+                "StartTime": 18737,
+                "Position": 145
+            },
+            {
+                "StartTime": 18796,
+                "Position": 159
+            },
+            {
+                "StartTime": 18856,
+                "Position": 310
+            },
+            {
+                "StartTime": 18915,
+                "Position": 441
+            },
+            {
+                "StartTime": 18975,
+                "Position": 428
+            },
+            {
+                "StartTime": 19034,
+                "Position": 243
+            },
+            {
+                "StartTime": 19093,
+                "Position": 422
+            },
+            {
+                "StartTime": 19153,
+                "Position": 481
+            },
+            {
+                "StartTime": 19212,
+                "Position": 104
+            },
+            {
+                "StartTime": 19271,
+                "Position": 473
+            },
+            {
+                "StartTime": 19331,
+                "Position": 135
+            },
+            {
+                "StartTime": 19390,
+                "Position": 360
+            },
+            {
+                "StartTime": 19450,
+                "Position": 123
+            }
+        ]
+    }]
+}

osu.Game.Rulesets.Catch/Resources/Testing/Beatmaps/spinner.osu

@@ -0,0 +1,20 @@
+osu file format v14
+
+[General]
+Mode: 2
+
+[Difficulty]
+HPDrainRate:6
+CircleSize:4
+OverallDifficulty:7
+ApproachRate:8.3
+SliderMultiplier:1.6
+SliderTickRate:1
+
+[TimingPoints]
+500,500,4,2,1,50,1,0
+13426,-100,4,3,1,45,0,0
+14884,-100,4,2,1,50,0,0
+
+[HitObjects]
+256,192,18500,12,0,19450,0:0:0:0:

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

@@ -1,10 +1,11 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System.Linq;
+using System;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 
@@ -17,28 +18,30 @@ namespace osu.Game.Rulesets.Catch.Scoring
         {
         }
 
-        protected override void SimulateAutoplay(Beatmap<CatchHitObject> beatmap)
+        private float hpDrainRate;
+
+        protected override void ApplyBeatmap(Beatmap<CatchHitObject> beatmap)
         {
-            foreach (var obj in beatmap.HitObjects)
+            base.ApplyBeatmap(beatmap);
+
+            hpDrainRate = beatmap.BeatmapInfo.BaseDifficulty.DrainRate;
+        }
+
+        private const double harshness = 0.01;
+
+        protected override void ApplyResult(JudgementResult result)
+        {
+            base.ApplyResult(result);
+
+            if (result.Type == HitResult.Miss)
             {
-                switch (obj)
-                {
-                    case JuiceStream stream:
-                        foreach (var _ in stream.NestedHitObjects.Cast<CatchHitObject>())
-                            AddJudgement(new CatchJudgement { Result = HitResult.Perfect });
-                        break;
-                    case BananaShower shower:
-                        foreach (var _ in shower.NestedHitObjects.Cast<CatchHitObject>())
-                            AddJudgement(new CatchJudgement { Result = HitResult.Perfect });
-                        AddJudgement(new CatchJudgement { Result = HitResult.Perfect });
-                        break;
-                    case Fruit _:
-                        AddJudgement(new CatchJudgement { Result = HitResult.Perfect });
-                        break;
-                }
+                if (!result.Judgement.IsBonus)
+                    Health.Value -= hpDrainRate * (harshness * 2);
+                return;
             }
 
-            base.SimulateAutoplay(beatmap);
+            if (result.Judgement is CatchJudgement catchJudgement)
+                Health.Value += Math.Max(catchJudgement.HealthIncreaseFor(result) - hpDrainRate, 0) * harshness;
         }
     }
 }

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

@@ -23,8 +23,10 @@ namespace osu.Game.Rulesets.Catch.UI
         private readonly CatcherArea catcherArea;
 
         public CatchPlayfield(BeatmapDifficulty difficulty, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> getVisualRepresentation)
-            : base(ScrollingDirection.Down, BASE_WIDTH)
+            : base(BASE_WIDTH)
         {
+            Direction.Value = ScrollingDirection.Down;
+
             Container explodingFruitContainer;
 
             Anchor = Anchor.TopCentre;
@@ -57,7 +59,7 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public override void Add(DrawableHitObject h)
         {
-            h.OnJudgement += onJudgement;
+            h.OnNewResult += onNewResult;
 
             base.Add(h);
 
@@ -65,6 +67,7 @@ namespace osu.Game.Rulesets.Catch.UI
             fruit.CheckPosition = CheckIfWeCanCatch;
         }
 
-        private void onJudgement(DrawableHitObject judgedObject, Judgement judgement) => catcherArea.OnJudgement((DrawableCatchHitObject)judgedObject, judgement);
+        private void onNewResult(DrawableHitObject judgedObject, JudgementResult result)
+            => catcherArea.OnResult((DrawableCatchHitObject)judgedObject, result);
     }
 }

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

@@ -38,14 +38,16 @@ namespace osu.Game.Rulesets.Catch.UI
         {
             switch (h)
             {
+                case Banana banana:
+                    return new DrawableBanana(banana);
                 case Fruit fruit:
                     return new DrawableFruit(fruit);
                 case JuiceStream stream:
                     return new DrawableJuiceStream(stream, GetVisualRepresentation);
-                case BananaShower banana:
-                    return new DrawableBananaShower(banana, GetVisualRepresentation);
+                case BananaShower shower:
+                    return new DrawableBananaShower(shower, GetVisualRepresentation);
                 case TinyDroplet tiny:
-                    return new DrawableDroplet(tiny) { Scale = new Vector2(0.5f) };
+                    return new DrawableTinyDroplet(tiny);
                 case Droplet droplet:
                     return new DrawableDroplet(droplet);
             }

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

@@ -11,11 +11,13 @@ using osu.Framework.Graphics.Textures;
 using osu.Framework.Input.Bindings;
 using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI;
 using OpenTK;
 using OpenTK.Graphics;
 
@@ -46,9 +48,22 @@ namespace osu.Game.Rulesets.Catch.UI
 
         private DrawableCatchHitObject lastPlateableFruit;
 
-        public void OnJudgement(DrawableCatchHitObject fruit, Judgement judgement)
+        public void OnResult(DrawableCatchHitObject fruit, JudgementResult result)
         {
-            if (judgement.IsHit && fruit.CanBePlated)
+            void runAfterLoaded(Action action)
+            {
+                if (lastPlateableFruit == null)
+                    return;
+
+                // this is required to make this run after the last caught fruit runs UpdateState at least once.
+                // TODO: find a better alternative
+                if (lastPlateableFruit.IsLoaded)
+                    action();
+                else
+                    lastPlateableFruit.OnLoadComplete = _ => action();
+            }
+
+            if (result.IsHit && fruit.CanBePlated)
             {
                 var caughtFruit = (DrawableCatchHitObject)GetVisualRepresentation?.Invoke(fruit.HitObject);
 
@@ -63,21 +78,16 @@ namespace osu.Game.Rulesets.Catch.UI
                 caughtFruit.LifetimeEnd = double.MaxValue;
 
                 MovableCatcher.Add(caughtFruit);
-
                 lastPlateableFruit = caughtFruit;
+
+                if (!fruit.StaysOnPlate)
+                    runAfterLoaded(() => MovableCatcher.Explode(caughtFruit));
             }
 
             if (fruit.HitObject.LastInCombo)
             {
-                if (judgement.IsHit)
-                {
-                    // this is required to make this run after the last caught fruit runs UpdateState at least once.
-                    // TODO: find a better alternative
-                    if (lastPlateableFruit.IsLoaded)
-                        MovableCatcher.Explode();
-                    else
-                        lastPlateableFruit.OnLoadComplete = _ => { MovableCatcher.Explode(); };
-                }
+                if (((CatchJudgement)result.Judgement).ShouldExplodeFor(result))
+                    runAfterLoaded(() => MovableCatcher.Explode());
                 else
                     MovableCatcher.Drop();
             }
@@ -87,7 +97,7 @@ namespace osu.Game.Rulesets.Catch.UI
         {
             base.UpdateAfterChildren();
 
-            var state = GetContainingInputManager().CurrentState as CatchFramedReplayInputHandler.CatchReplayState;
+            var state = (GetContainingInputManager().CurrentState as RulesetInputManagerInputState<CatchAction>)?.LastReplayState as CatchFramedReplayInputHandler.CatchReplayState;
 
             if (state?.CatcherX != null)
                 MovableCatcher.X = state.CatcherX.Value;
@@ -99,6 +109,11 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public class Catcher : Container, IKeyBindingHandler<CatchAction>
         {
+            /// <summary>
+            /// Width of the area that can be used to attempt catches during gameplay.
+            /// </summary>
+            internal float CatchWidth => CATCHER_SIZE * Math.Abs(Scale.X);
+
             private Container<DrawableHitObject> caughtFruit;
 
             public Container ExplodingFruitTarget;
@@ -226,63 +241,74 @@ namespace osu.Game.Rulesets.Catch.UI
             /// <returns>Whether the catch is possible.</returns>
             public bool AttemptCatch(CatchHitObject fruit)
             {
-                double halfCatcherWidth = CATCHER_SIZE * Math.Abs(Scale.X) * 0.5f;
+                float halfCatchWidth = CatchWidth * 0.5f;
 
                 // this stuff wil disappear once we move fruit to non-relative coordinate space in the future.
                 var catchObjectPosition = fruit.X * CatchPlayfield.BASE_WIDTH;
                 var catcherPosition = Position.X * CatchPlayfield.BASE_WIDTH;
 
                 var validCatch =
-                    catchObjectPosition >= catcherPosition - halfCatcherWidth &&
-                    catchObjectPosition <= catcherPosition + halfCatcherWidth;
+                    catchObjectPosition >= catcherPosition - halfCatchWidth &&
+                    catchObjectPosition <= catcherPosition + halfCatchWidth;
 
                 if (validCatch && fruit.HyperDash)
                 {
-                    HyperDashModifier = Math.Abs(fruit.HyperDashTarget.X - fruit.X) / Math.Abs(fruit.HyperDashTarget.StartTime - fruit.StartTime) / BASE_SPEED;
-                    HyperDashDirection = fruit.HyperDashTarget.X - fruit.X;
+                    var target = fruit.HyperDashTarget;
+                    double timeDifference = target.StartTime - fruit.StartTime;
+                    double positionDifference = target.X * CatchPlayfield.BASE_WIDTH - catcherPosition;
+                    double velocity = positionDifference / Math.Max(1.0, timeDifference - 1000.0 / 60.0);
+
+                    SetHyperDashState(Math.Abs(velocity), target.X);
                 }
                 else
-                    HyperDashModifier = 1;
+                {
+                    SetHyperDashState();
+                }
 
                 return validCatch;
             }
 
+            private double hyperDashModifier = 1;
+            private int hyperDashDirection;
+            private float hyperDashTargetPosition;
+
             /// <summary>
-            /// Whether we are hypderdashing or not.
+            /// Whether we are hyper-dashing or not.
             /// </summary>
             public bool HyperDashing => hyperDashModifier != 1;
 
-            private double hyperDashModifier = 1;
-
             /// <summary>
-            /// The direction in which hyperdash is allowed. 0 allows both directions.
+            /// Set hyper-dash state.
             /// </summary>
-            public double HyperDashDirection;
-
-            /// <summary>
-            /// The speed modifier resultant from hyperdash. Will trigger hyperdash when not equal to 1.
-            /// </summary>
-            public double HyperDashModifier
+            /// <param name="modifier">The speed multiplier. If this is less or equals to 1, this catcher will be non-hyper-dashing state.</param>
+            /// <param name="targetPosition">When this catcher crosses this position, this catcher ends hyper-dashing.</param>
+            public void SetHyperDashState(double modifier = 1, float targetPosition = -1)
             {
-                get { return hyperDashModifier; }
-                set
+                const float hyper_dash_transition_length = 180;
+
+                bool previouslyHyperDashing = HyperDashing;
+                if (modifier <= 1 || X == targetPosition)
                 {
-                    if (value == hyperDashModifier) return;
-                    hyperDashModifier = value;
+                    hyperDashModifier = 1;
+                    hyperDashDirection = 0;
 
-                    const float transition_length = 180;
-
-                    if (HyperDashing)
+                    if (previouslyHyperDashing)
                     {
-                        this.FadeColour(Color4.OrangeRed, transition_length, Easing.OutQuint);
-                        this.FadeTo(0.2f, transition_length, Easing.OutQuint);
-                        Trail = true;
+                        this.FadeColour(Color4.White, hyper_dash_transition_length, Easing.OutQuint);
+                        this.FadeTo(1, hyper_dash_transition_length, Easing.OutQuint);
                     }
-                    else
+                }
+                else
+                {
+                    hyperDashModifier = modifier;
+                    hyperDashDirection = Math.Sign(targetPosition - X);
+                    hyperDashTargetPosition = targetPosition;
+
+                    if (!previouslyHyperDashing)
                     {
-                        HyperDashDirection = 0;
-                        this.FadeColour(Color4.White, transition_length, Easing.OutQuint);
-                        this.FadeTo(1, transition_length, Easing.OutQuint);
+                        this.FadeColour(Color4.OrangeRed, hyper_dash_transition_length, Easing.OutQuint);
+                        this.FadeTo(0.2f, hyper_dash_transition_length, Easing.OutQuint);
+                        Trail = true;
                     }
                 }
             }
@@ -337,12 +363,18 @@ namespace osu.Game.Rulesets.Catch.UI
                 var direction = Math.Sign(currentDirection);
 
                 double dashModifier = Dashing ? 1 : 0.5;
-
-                if (hyperDashModifier != 1 && (HyperDashDirection == 0 || direction == Math.Sign(HyperDashDirection)))
-                    dashModifier = hyperDashModifier;
+                double speed = BASE_SPEED * dashModifier * hyperDashModifier;
 
                 Scale = new Vector2(Math.Abs(Scale.X) * direction, Scale.Y);
-                X = (float)MathHelper.Clamp(X + direction * Clock.ElapsedFrameTime * BASE_SPEED * dashModifier, 0, 1);
+                X = (float)MathHelper.Clamp(X + direction * Clock.ElapsedFrameTime * speed, 0, 1);
+
+                // Correct overshooting.
+                if (hyperDashDirection > 0 && hyperDashTargetPosition < X ||
+                    hyperDashDirection < 0 && hyperDashTargetPosition > X)
+                {
+                    X = hyperDashTargetPosition;
+                    SetHyperDashState();
+                }
             }
 
             /// <summary>
@@ -378,28 +410,31 @@ namespace osu.Game.Rulesets.Catch.UI
                 var fruit = caughtFruit.ToArray();
 
                 foreach (var f in fruit)
+                    Explode(f);
+            }
+
+            public void Explode(DrawableHitObject fruit)
+            {
+                var originalX = fruit.X * Scale.X;
+
+                if (ExplodingFruitTarget != null)
                 {
-                    var originalX = f.X * Scale.X;
+                    fruit.Anchor = Anchor.TopLeft;
+                    fruit.Position = caughtFruit.ToSpaceOfOtherDrawable(fruit.DrawPosition, ExplodingFruitTarget);
 
-                    if (ExplodingFruitTarget != null)
-                    {
-                        f.Anchor = Anchor.TopLeft;
-                        f.Position = caughtFruit.ToSpaceOfOtherDrawable(f.DrawPosition, ExplodingFruitTarget);
+                    caughtFruit.Remove(fruit);
 
-                        caughtFruit.Remove(f);
-
-                        ExplodingFruitTarget.Add(f);
-                    }
-
-                    f.MoveToY(f.Y - 50, 250, Easing.OutSine)
-                     .Then()
-                     .MoveToY(f.Y + 50, 500, Easing.InSine);
-
-                    f.MoveToX(f.X + originalX * 6, 1000);
-                    f.FadeOut(750);
-
-                    f.Expire();
+                    ExplodingFruitTarget.Add(fruit);
                 }
+
+                fruit.MoveToY(fruit.Y - 50, 250, Easing.OutSine)
+                 .Then()
+                 .MoveToY(fruit.Y + 50, 500, Easing.InSine);
+
+                fruit.MoveToX(fruit.X + originalX * 6, 1000);
+                fruit.FadeOut(750);
+
+                fruit.Expire();
             }
 
             private class CatcherSprite : Sprite

osu.Game.Rulesets.Mania.Tests/.vscode/launch.json

@@ -2,35 +2,7 @@
     "version": "0.2.0",
     "configurations": [
         {
-            "name": "VisualTests (Debug, net471)",
-            "windows": {
-                "type": "clr"
-            },
-            "type": "mono",
-            "request": "launch",
-            "program": "${workspaceRoot}/bin/Debug/net471/osu.Game.Rulesets.Mania.Tests.exe",
-            "cwd": "${workspaceRoot}",
-            "preLaunchTask": "Build (Debug, msbuild)",
-            "runtimeExecutable": null,
-            "env": {},
-            "console": "internalConsole"
-        },
-        {
-            "name": "VisualTests (Release, net471)",
-            "windows": {
-                "type": "clr"
-            },
-            "type": "mono",
-            "request": "launch",
-            "program": "${workspaceRoot}/bin/Release/net471/osu.Game.Rulesets.Mania.Tests.exe",
-            "cwd": "${workspaceRoot}",
-            "preLaunchTask": "Build (Release, msbuild)",
-            "runtimeExecutable": null,
-            "env": {},
-            "console": "internalConsole"
-        },
-        {
-            "name": "VisualTests (Debug, netcoreapp2.1)",
+            "name": "VisualTests (Debug)",
             "type": "coreclr",
             "request": "launch",
             "program": "dotnet",
@@ -38,12 +10,12 @@
                 "${workspaceRoot}/bin/Debug/netcoreapp2.1/osu.Game.Rulesets.Mania.Tests.dll"
             ],
             "cwd": "${workspaceRoot}",
-            "preLaunchTask": "Build (Debug, dotnet)",
+            "preLaunchTask": "Build (Debug)",
             "env": {},
             "console": "internalConsole"
         },
         {
-            "name": "VisualTests (Release, netcoreapp2.1)",
+            "name": "VisualTests (Release)",
             "type": "coreclr",
             "request": "launch",
             "program": "dotnet",
@@ -51,7 +23,7 @@
                 "${workspaceRoot}/bin/Release/netcoreapp2.1/osu.Game.Rulesets.Mania.Tests.dll"
             ],
             "cwd": "${workspaceRoot}",
-            "preLaunchTask": "Build (Release, dotnet)",
+            "preLaunchTask": "Build (Release)",
             "env": {},
             "console": "internalConsole"
         }

osu.Game.Rulesets.Mania.Tests/.vscode/tasks.json

@@ -4,43 +4,13 @@
     "version": "2.0.0",
     "tasks": [
         {
-            "label": "Build (Debug, msbuild)",
-            "type": "shell",
-            "command": "msbuild",
-            "args": [
-                "osu.Game.Rulesets.Mania.Tests.csproj",
-                "/p:TargetFramework=net471",
-                "/p:GenerateFullPaths=true",
-                "/m",
-                "/verbosity:m"
-            ],
-            "group": "build",
-            "problemMatcher": "$msCompile"
-        },
-        {
-            "label": "Build (Release, msbuild)",
-            "type": "shell",
-            "command": "msbuild",
-            "args": [
-                "osu.Game.Rulesets.Mania.Tests.csproj",
-                "/p:Configuration=Release",
-                "/p:TargetFramework=net471",
-                "/p:GenerateFullPaths=true",
-                "/m",
-                "/verbosity:m"
-            ],
-            "group": "build",
-            "problemMatcher": "$msCompile"
-        },
-        {
-            "label": "Build (Debug, dotnet)",
+            "label": "Build (Debug)",
             "type": "shell",
             "command": "dotnet",
             "args": [
                 "build",
                 "--no-restore",
                 "osu.Game.Rulesets.Mania.Tests.csproj",
-                "/p:TargetFramework=netcoreapp2.1",
                 "/p:GenerateFullPaths=true",
                 "/m",
                 "/verbosity:m"
@@ -49,14 +19,13 @@
             "problemMatcher": "$msCompile"
         },
         {
-            "label": "Build (Release, dotnet)",
+            "label": "Build (Release)",
             "type": "shell",
             "command": "dotnet",
             "args": [
                 "build",
                 "--no-restore",
                 "osu.Game.Rulesets.Mania.Tests.csproj",
-                "/p:TargetFramework=netcoreapp2.1",
                 "/p:Configuration=Release",
                 "/p:GenerateFullPaths=true",
                 "/m",
@@ -66,16 +35,7 @@
             "problemMatcher": "$msCompile"
         },
         {
-            "label": "Restore (net471)",
-            "type": "shell",
-            "command": "nuget",
-            "args": [
-                "restore"
-            ],
-            "problemMatcher": []
-        },
-        {
-            "label": "Restore (netcoreapp2.1)",
+            "label": "Restore",
             "type": "shell",
             "command": "dotnet",
             "args": [

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

@@ -5,6 +5,8 @@ using System;
 using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.MathUtils;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
@@ -12,11 +14,11 @@ using osu.Game.Tests.Beatmaps;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {
-    internal class ManiaBeatmapConversionTest : BeatmapConversionTest<ConvertValue>
+    [TestFixture]
+    public class ManiaBeatmapConversionTest : BeatmapConversionTest<ManiaConvertMapping, ConvertValue>
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Mania";
 
-        [NonParallelizable]
         [TestCase("basic")]
         public new void Test(string name)
         {
@@ -33,10 +35,36 @@ namespace osu.Game.Rulesets.Mania.Tests
             };
         }
 
+        protected override ManiaConvertMapping CreateConvertMapping() => new ManiaConvertMapping(Converter);
+
         protected override Ruleset CreateRuleset() => new ManiaRuleset();
     }
 
-    internal struct ConvertValue : IEquatable<ConvertValue>
+     public class ManiaConvertMapping : ConvertMapping<ConvertValue>, IEquatable<ManiaConvertMapping>
+     {
+         public uint RandomW;
+         public uint RandomX;
+         public uint RandomY;
+         public uint RandomZ;
+
+         public ManiaConvertMapping()
+         {
+         }
+
+         public ManiaConvertMapping(IBeatmapConverter converter)
+         {
+             var maniaConverter = (ManiaBeatmapConverter)converter;
+             RandomW = maniaConverter.Random.W;
+             RandomX = maniaConverter.Random.X;
+             RandomY = maniaConverter.Random.Y;
+             RandomZ = maniaConverter.Random.Z;
+         }
+
+         public bool Equals(ManiaConvertMapping other) => other != null && RandomW == other.RandomW && RandomX == other.RandomX && RandomY == other.RandomY && RandomZ == other.RandomZ;
+         public override bool Equals(ConvertMapping<ConvertValue> other) => base.Equals(other) && Equals(other as ManiaConvertMapping);
+     }
+
+    public struct ConvertValue : IEquatable<ConvertValue>
     {
         /// <summary>
         /// A sane value to account for osu!stable using ints everwhere.

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

@@ -0,0 +1,45 @@
+// Copyright (c) 2007-2018 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.Input.Bindings;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public abstract class ManiaInputTestCase : OsuTestCase
+    {
+        private readonly Container<Drawable> content;
+        protected override Container<Drawable> Content => content ?? base.Content;
+
+        protected ManiaInputTestCase(int keys)
+        {
+            base.Content.Add(content = new LocalInputManager(keys));
+        }
+
+        private class LocalInputManager : ManiaInputManager
+        {
+            public LocalInputManager(int variant)
+                : base(new ManiaRuleset().RulesetInfo, variant)
+            {
+            }
+
+            protected override RulesetKeyBindingContainer CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
+                => new LocalKeyBindingContainer(ruleset, variant, unique);
+
+            private class LocalKeyBindingContainer : RulesetKeyBindingContainer
+            {
+                public LocalKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
+                    : base(ruleset, variant, unique)
+                {
+                }
+
+                protected override void ReloadMappings()
+                {
+                    KeyBindings = DefaultKeyBindings;
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+// Copyright (c) 2007-2018 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.Graphics.Containers;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.UI.Scrolling;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    /// <summary>
+    /// A container which provides a <see cref="IScrollingInfo"/> to children.
+    /// </summary>
+    public class ScrollingTestContainer : Container
+    {
+        [Cached(Type = typeof(IScrollingInfo))]
+        private readonly TestScrollingInfo scrollingInfo = new TestScrollingInfo();
+
+        public ScrollingTestContainer(ScrollingDirection direction)
+        {
+            scrollingInfo.Direction.Value = direction;
+        }
+
+        public void Flip() => scrollingInfo.Direction.Value = scrollingInfo.Direction.Value == ScrollingDirection.Up ? ScrollingDirection.Down : ScrollingDirection.Up;
+    }
+
+    public class TestScrollingInfo : IScrollingInfo
+    {
+        public readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
+        IBindable<ScrollingDirection> IScrollingInfo.Direction => Direction;
+    }
+}

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

@@ -0,0 +1,111 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Mania.UI.Components;
+using osu.Game.Rulesets.UI.Scrolling;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [TestFixture]
+    public class TestCaseColumn : ManiaInputTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(Column),
+            typeof(ColumnBackground),
+            typeof(ColumnKeyArea),
+            typeof(ColumnHitObjectArea)
+        };
+
+        private readonly List<Column> columns = new List<Column>();
+
+        public TestCaseColumn()
+            : base(2)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Child = new FillFlowContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Spacing = new Vector2(20, 0),
+                Children = new[]
+                {
+                    createColumn(ScrollingDirection.Up, ManiaAction.Key1),
+                    createColumn(ScrollingDirection.Down, ManiaAction.Key2)
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            AddStep("note", createNote);
+            AddStep("hold note", createHoldNote);
+        }
+
+        private void createNote()
+        {
+            for (int i = 0; i < columns.Count; i++)
+            {
+                var obj = new Note { Column = i, StartTime = Time.Current + 2000 };
+                obj.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+                columns[i].Add(new DrawableNote(obj));
+            }
+        }
+
+        private void createHoldNote()
+        {
+            for (int i = 0; i < columns.Count; i++)
+            {
+                var obj = new HoldNote { Column = i, StartTime = Time.Current + 2000, Duration = 500 };
+                obj.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+                columns[i].Add(new DrawableHoldNote(obj));
+            }
+        }
+
+        private Drawable createColumn(ScrollingDirection direction, ManiaAction action)
+        {
+            var column = new Column
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Height = 0.85f,
+                AccentColour = Color4.OrangeRed,
+                Action = { Value = action },
+                VisibleTimeRange = { Value = 2000 }
+            };
+
+            columns.Add(column);
+
+            return new ScrollingTestContainer(direction)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                AutoSizeAxes = Axes.X,
+                RelativeSizeAxes = Axes.Y,
+                Child = column
+            };
+        }
+    }
+}

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

@@ -0,0 +1,32 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Game.Rulesets.Mania.Configuration;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [TestFixture]
+    public class TestCaseEditor : EditorTestCase
+    {
+        private readonly Bindable<ManiaScrollingDirection> direction = new Bindable<ManiaScrollingDirection>();
+
+        public TestCaseEditor()
+            : base(new ManiaRuleset())
+        {
+            AddStep("upwards scroll", () => direction.Value = ManiaScrollingDirection.Up);
+            AddStep("downwards scroll", () => direction.Value = ManiaScrollingDirection.Down);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(RulesetConfigCache configCache)
+        {
+            var config = (ManiaConfigManager)configCache.GetConfigFor(Ruleset.Value.CreateInstance());
+            config.BindWith(ManiaSetting.ScrollDirection, direction);
+        }
+    }
+}

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

@@ -1,106 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using NUnit.Framework;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.Mania.Objects.Drawables;
-using osu.Game.Tests.Visual;
-using OpenTK;
-using OpenTK.Graphics;
-
-namespace osu.Game.Rulesets.Mania.Tests
-{
-    [TestFixture]
-    public class TestCaseManiaHitObjects : OsuTestCase
-    {
-        public TestCaseManiaHitObjects()
-        {
-            Note note1 = new Note();
-            Note note2 = new Note();
-            HoldNote holdNote = new HoldNote { StartTime = 1000 };
-
-            note1.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
-            note2.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
-            holdNote.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
-
-            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(note1, ManiaAction.Key1)
-                                    {
-                                        Y = 5000,
-                                        LifetimeStart = double.MinValue,
-                                        LifetimeEnd = double.MaxValue,
-                                        AccentColour = Color4.Red
-                                    },
-                                    new DrawableNote(note2, ManiaAction.Key1)
-                                    {
-                                        Y = 6000,
-                                        LifetimeStart = double.MinValue,
-                                        LifetimeEnd = double.MaxValue,
-                                        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(holdNote, ManiaAction.Key1)
-                                    {
-                                        Y = 5000,
-                                        Height = 1000,
-                                        LifetimeStart = double.MinValue,
-                                        LifetimeEnd = double.MaxValue,
-                                        AccentColour = Color4.Red,
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            });
-        }
-    }
-}

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

@@ -1,190 +0,0 @@
-// Copyright (c) 2007-2018 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 NUnit.Framework;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Timing;
-using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Configuration;
-using osu.Game.Rulesets.Mania.Beatmaps;
-using osu.Game.Rulesets.Mania.Configuration;
-using osu.Game.Rulesets.Mania.Judgements;
-using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.Mania.Objects.Drawables;
-using osu.Game.Rulesets.Mania.UI;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Tests.Visual;
-
-namespace osu.Game.Rulesets.Mania.Tests
-{
-    [TestFixture]
-    public class TestCaseManiaPlayfield : OsuTestCase
-    {
-        private const double start_time = 500;
-        private const double duration = 500;
-
-        protected override double TimePerAction => 200;
-
-        private RulesetInfo maniaRuleset;
-
-        public TestCaseManiaPlayfield()
-        {
-            var rng = new Random(1337);
-
-            AddStep("1 column", () => createPlayfield(1));
-            AddStep("4 columns", () => createPlayfield(4));
-            AddStep("5 columns", () => createPlayfield(5));
-            AddStep("8 columns", () => createPlayfield(8));
-            AddStep("4 + 4 columns", () =>
-            {
-                var stages = new List<StageDefinition>
-                {
-                    new StageDefinition { Columns = 4 },
-                    new StageDefinition { Columns = 4 },
-                };
-                createPlayfield(stages);
-            });
-
-            AddStep("2 + 4 + 2 columns", () =>
-            {
-                var stages = new List<StageDefinition>
-                {
-                    new StageDefinition { Columns = 2 },
-                    new StageDefinition { Columns = 4 },
-                    new StageDefinition { Columns = 2 },
-                };
-                createPlayfield(stages);
-            });
-
-            AddStep("1 + 8 + 1 columns", () =>
-            {
-                var stages = new List<StageDefinition>
-                {
-                    new StageDefinition { Columns = 1 },
-                    new StageDefinition { Columns = 8 },
-                    new StageDefinition { Columns = 1 },
-                };
-                createPlayfield(stages);
-            });
-
-            AddStep("Reversed", () => createPlayfield(4, true));
-
-            AddStep("Notes with input", () => createPlayfieldWithNotes());
-            AddStep("Notes with input (reversed)", () => createPlayfieldWithNotes(true));
-            AddStep("Notes with gravity", () => createPlayfieldWithNotes());
-            AddStep("Notes with gravity (reversed)", () => createPlayfieldWithNotes(true));
-
-            AddStep("Hit explosion", () =>
-            {
-                var playfield = createPlayfield(4);
-
-                int col = rng.Next(0, 4);
-
-                var note = new Note { Column = col };
-                note.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
-
-                var drawableNote = new DrawableNote(note, ManiaAction.Key1)
-                {
-                    AccentColour = playfield.Columns.ElementAt(col).AccentColour
-                };
-
-                playfield.OnJudgement(drawableNote, new ManiaJudgement { Result = HitResult.Perfect });
-                playfield.Columns[col].OnJudgement(drawableNote, new ManiaJudgement { Result = HitResult.Perfect });
-            });
-        }
-
-        private DependencyContainer dependencies;
-
-        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
-            => dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
-
-        [BackgroundDependencyLoader]
-        private void load(RulesetStore rulesets, SettingsStore settings)
-        {
-            maniaRuleset = rulesets.GetRuleset(3);
-
-            dependencies.Cache(new ManiaConfigManager(settings, maniaRuleset, 4));
-        }
-
-        private ManiaPlayfield createPlayfield(int cols, bool inverted = false)
-        {
-            var stages = new List<StageDefinition>
-            {
-                new StageDefinition { Columns = cols },
-            };
-
-            return createPlayfield(stages, inverted);
-        }
-
-        private ManiaPlayfield createPlayfield(List<StageDefinition> stages, bool inverted = false)
-        {
-            Clear();
-
-            var inputManager = new ManiaInputManager(maniaRuleset, stages.Sum(g => g.Columns)) { RelativeSizeAxes = Axes.Both };
-            Add(inputManager);
-
-            ManiaPlayfield playfield;
-
-            inputManager.Add(playfield = new ManiaPlayfield(stages)
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-            });
-
-            playfield.Inverted.Value = inverted;
-
-            return playfield;
-        }
-
-        private void createPlayfieldWithNotes(bool inverted = false)
-        {
-            Clear();
-
-            var rateAdjustClock = new StopwatchClock(true) { Rate = 1 };
-
-            var inputManager = new ManiaInputManager(maniaRuleset, 4) { RelativeSizeAxes = Axes.Both };
-            Add(inputManager);
-
-            ManiaPlayfield playfield;
-            var stages = new List<StageDefinition>
-            {
-                new StageDefinition { Columns = 4 },
-            };
-
-            inputManager.Add(playfield = new ManiaPlayfield(stages)
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                Clock = new FramedClock(rateAdjustClock)
-            });
-
-            playfield.Inverted.Value = inverted;
-
-            for (double t = start_time; t <= start_time + duration; t += 100)
-            {
-                var note1 = new Note { StartTime = t, Column = 0 };
-                var note2 = new Note { StartTime = t, Column = 3 };
-
-                note1.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
-                note2.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
-
-                playfield.Add(new DrawableNote(note1, ManiaAction.Key1));
-                playfield.Add(new DrawableNote(note2, ManiaAction.Key4));
-            }
-
-            var holdNote1 = new HoldNote { StartTime = start_time, Duration = duration, Column = 1 };
-            var holdNote2 = new HoldNote { StartTime = start_time, Duration = duration, Column = 2 };
-
-            holdNote1.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
-            holdNote2.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
-
-            playfield.Add(new DrawableHoldNote(holdNote1, ManiaAction.Key2));
-            playfield.Add(new DrawableHoldNote(holdNote2, ManiaAction.Key3));
-        }
-    }
-}

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

@@ -0,0 +1,184 @@
+// Copyright (c) 2007-2018 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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Tests.Visual;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [TestFixture]
+    public class TestCaseNotes : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(DrawableNote),
+            typeof(DrawableHoldNote)
+        };
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Child = new FillFlowContainer
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                AutoSizeAxes = Axes.Both,
+                Direction = FillDirection.Horizontal,
+                Spacing = new Vector2(20),
+                Children = new[]
+                {
+                    createNoteDisplay(ScrollingDirection.Down, 1, out var note1),
+                    createNoteDisplay(ScrollingDirection.Up, 2, out var note2),
+                    createHoldNoteDisplay(ScrollingDirection.Down, 1, out var holdNote1),
+                    createHoldNoteDisplay(ScrollingDirection.Up, 2, out var holdNote2),
+                }
+            };
+
+            AddAssert("note 1 facing downwards", () => verifyAnchors(note1, Anchor.y2));
+            AddAssert("note 2 facing upwards", () => verifyAnchors(note2, Anchor.y0));
+            AddAssert("hold note 1 facing downwards", () => verifyAnchors(holdNote1, Anchor.y2));
+            AddAssert("hold note 2 facing upwards", () => verifyAnchors(holdNote2, Anchor.y0));
+        }
+
+        private Drawable createNoteDisplay(ScrollingDirection direction, int identifier, out DrawableNote hitObject)
+        {
+            var note = new Note { StartTime = 999999999 };
+            note.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+            return new ScrollingTestContainer(direction)
+            {
+                AutoSizeAxes = Axes.Both,
+                Child = new NoteContainer(direction, $"note {identifier}, scrolling {direction.ToString().ToLowerInvariant()}")
+                {
+                    Child = hitObject = new DrawableNote(note) { AccentColour = Color4.OrangeRed }
+                }
+            };
+        }
+
+        private Drawable createHoldNoteDisplay(ScrollingDirection direction, int identifier, out DrawableHoldNote hitObject)
+        {
+            var note = new HoldNote { StartTime = 999999999, Duration = 5000 };
+            note.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+            return new ScrollingTestContainer(direction)
+            {
+                AutoSizeAxes = Axes.Both,
+                Child = new NoteContainer(direction, $"hold note {identifier}, scrolling {direction.ToString().ToLowerInvariant()}")
+                {
+                    Child = hitObject = new DrawableHoldNote(note)
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        AccentColour = Color4.OrangeRed,
+                    }
+                }
+            };
+        }
+
+        private bool verifyAnchors(DrawableHitObject hitObject, Anchor expectedAnchor)
+            => hitObject.Anchor.HasFlag(expectedAnchor) && hitObject.Origin.HasFlag(expectedAnchor);
+
+        private bool verifyAnchors(DrawableHoldNote holdNote, Anchor expectedAnchor)
+            => verifyAnchors((DrawableHitObject)holdNote, expectedAnchor) && holdNote.NestedHitObjects.All(n => verifyAnchors(n, expectedAnchor));
+
+        private class NoteContainer : Container
+        {
+            private readonly Container content;
+            protected override Container<Drawable> Content => content;
+
+            private readonly ScrollingDirection direction;
+
+            public NoteContainer(ScrollingDirection direction, string description)
+            {
+                this.direction = direction;
+                AutoSizeAxes = Axes.Both;
+
+                InternalChild = new FillFlowContainer
+                {
+                    AutoSizeAxes = Axes.Both,
+                    Spacing = new Vector2(0, 10),
+                    Direction = FillDirection.Vertical,
+                    Children = new Drawable[]
+                    {
+                        new Container
+                        {
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                            Width = 45,
+                            Height = 100,
+                            Children = new Drawable[]
+                            {
+                                new Box
+                                {
+                                    Anchor = Anchor.TopCentre,
+                                    Origin = Anchor.TopCentre,
+                                    RelativeSizeAxes = Axes.Both,
+                                    Width = 1.25f,
+                                    Colour = Color4.Black.Opacity(0.5f)
+                                },
+                                content = new Container { RelativeSizeAxes = Axes.Both }
+                            }
+                        },
+                        new SpriteText
+                        {
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                            TextSize = 14,
+                            Text = description
+                        }
+                    }
+                };
+            }
+
+            protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+            {
+                var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
+                dependencies.CacheAs<IBindable<ManiaAction>>(new Bindable<ManiaAction>());
+                return dependencies;
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                foreach (var obj in content.OfType<DrawableHitObject>())
+                {
+                    if (!(obj.HitObject is IHasEndTime endTime))
+                        continue;
+
+                    foreach (var nested in obj.NestedHitObjects)
+                    {
+                        double finalPosition = (nested.HitObject.StartTime - obj.HitObject.StartTime) / endTime.Duration;
+                        switch (direction)
+                        {
+                            case ScrollingDirection.Up:
+                                nested.Y = (float)(finalPosition * content.DrawHeight);
+                                break;
+                            case ScrollingDirection.Down:
+                                nested.Y = (float)(-finalPosition * content.DrawHeight);
+                                break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -1,16 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using NUnit.Framework;
-
-namespace osu.Game.Rulesets.Mania.Tests
-{
-    [TestFixture]
-    public class TestCasePerformancePoints : Game.Tests.Visual.TestCasePerformancePoints
-    {
-        public TestCasePerformancePoints()
-            : base(new ManiaRuleset())
-        {
-        }
-    }
-}

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

@@ -0,0 +1,138 @@
+// Copyright (c) 2007-2018 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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.UI.Scrolling;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [TestFixture]
+    public class TestCaseStage : ManiaInputTestCase
+    {
+        private const int columns = 4;
+
+        private readonly List<ManiaStage> stages = new List<ManiaStage>();
+
+        private FillFlowContainer<ScrollingTestContainer> fill;
+
+        public TestCaseStage()
+            : base(columns)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Child = fill = new FillFlowContainer<ScrollingTestContainer>
+            {
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Spacing = new Vector2(20, 0),
+                Children = new[]
+                {
+                    createStage(ScrollingDirection.Up, ManiaAction.Key1),
+                    createStage(ScrollingDirection.Down, ManiaAction.Key3)
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            AddStep("note", createNote);
+            AddStep("hold note", createHoldNote);
+            AddStep("minor bar line", () => createBarLine(false));
+            AddStep("major bar line", () => createBarLine(true));
+
+            AddAssert("check note anchors", () => notesInStageAreAnchored(stages[0], Anchor.TopCentre));
+            AddAssert("check note anchors", () => notesInStageAreAnchored(stages[1], Anchor.BottomCentre));
+
+            AddStep("flip direction", () =>
+            {
+                foreach (var c in fill.Children)
+                    c.Flip();
+            });
+
+            AddAssert("check note anchors", () => notesInStageAreAnchored(stages[0], Anchor.BottomCentre));
+            AddAssert("check note anchors", () => notesInStageAreAnchored(stages[1], Anchor.TopCentre));
+        }
+
+        private bool notesInStageAreAnchored(ManiaStage stage, Anchor anchor) => stage.Columns.SelectMany(c => c.AllHitObjects).All(o => o.Anchor == anchor);
+
+        private void createNote()
+        {
+            foreach (var stage in stages)
+            {
+                for (int i = 0; i < stage.Columns.Count; i++)
+                {
+                    var obj = new Note { Column = i, StartTime = Time.Current + 2000 };
+                    obj.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+                    stage.Add(new DrawableNote(obj));
+                }
+            }
+        }
+
+        private void createHoldNote()
+        {
+            foreach (var stage in stages)
+            {
+                for (int i = 0; i < stage.Columns.Count; i++)
+                {
+                    var obj = new HoldNote { Column = i, StartTime = Time.Current + 2000, Duration = 500 };
+                    obj.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+                    stage.Add(new DrawableHoldNote(obj));
+                }
+            }
+        }
+
+        private void createBarLine(bool major)
+        {
+            foreach (var stage in stages)
+            {
+                var obj = new BarLine
+                {
+                    StartTime = Time.Current + 2000,
+                    ControlPoint = new TimingControlPoint(),
+                    BeatIndex = major ? 0 : 1
+                };
+
+                obj.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+                stage.Add(obj);
+            }
+        }
+
+        private ScrollingTestContainer createStage(ScrollingDirection direction, ManiaAction action)
+        {
+            var specialAction = ManiaAction.Special1;
+
+            var stage = new ManiaStage(0, new StageDefinition { Columns = 2 }, ref action, ref specialAction) { VisibleTimeRange = { Value = 2000 } };
+            stages.Add(stage);
+
+            return new ScrollingTestContainer(direction)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Y,
+                AutoSizeAxes = Axes.X,
+                Child = stage
+            };
+        }
+    }
+}

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

@@ -1,8 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\osu.TestProject.props" />
+  <ItemGroup Label="Package References">
+    <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.8.0" />
+    <PackageReference Include="NUnit" Version="3.10.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.10.0" />
+  </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>
-    <TargetFrameworks>netcoreapp2.1;net471</TargetFrameworks>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
   </PropertyGroup>
   <ItemGroup Label="Project References">
     <ProjectReference Include="..\osu.Game.Rulesets.Mania\osu.Game.Rulesets.Mania.csproj" />

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

@@ -5,6 +5,7 @@ using osu.Game.Rulesets.Mania.Objects;
 using System;
 using System.Linq;
 using System.Collections.Generic;
+using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
@@ -28,8 +29,10 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         public int TargetColumns;
         public readonly bool IsForCurrentRuleset;
 
+        // Internal for testing purposes
+        internal FastRandom Random { get; private set; }
+
         private Pattern lastPattern = new Pattern();
-        private FastRandom random;
 
         private ManiaBeatmap beatmap;
 
@@ -62,7 +65,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             BeatmapDifficulty difficulty = original.BeatmapInfo.BaseDifficulty;
 
             int seed = (int)Math.Round(difficulty.DrainRate + difficulty.CircleSize) * 20 + (int)(difficulty.OverallDifficulty * 41.2) + (int)Math.Round(difficulty.ApproachRate);
-            random = new FastRandom(seed);
+            Random = new FastRandom(seed);
 
             return base.ConvertBeatmap(original);
         }
@@ -100,7 +103,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
 
         private double lastTime;
         private Vector2 lastPosition;
-        private PatternType lastStair;
+        private PatternType lastStair = PatternType.Stair;
         private void recordNote(double time, Vector2 position)
         {
             lastTime = time;
@@ -115,12 +118,15 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         /// <returns>The hit objects generated.</returns>
         private IEnumerable<ManiaHitObject> generateSpecific(HitObject original, IBeatmap originalBeatmap)
         {
-            var generator = new SpecificBeatmapPatternGenerator(random, original, beatmap, lastPattern, originalBeatmap);
+            var generator = new SpecificBeatmapPatternGenerator(Random, original, beatmap, lastPattern, originalBeatmap);
 
-            Pattern newPattern = generator.Generate();
-            lastPattern = newPattern;
+            foreach (var newPattern in generator.Generate())
+            {
+                lastPattern = newPattern;
 
-            return newPattern.HitObjects;
+                foreach (var obj in newPattern.HitObjects)
+                    yield return obj;
+            }
         }
 
         /// <summary>
@@ -138,27 +144,44 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             Patterns.PatternGenerator conversion = null;
 
             if (distanceData != null)
-                conversion = new DistanceObjectPatternGenerator(random, original, beatmap, lastPattern, originalBeatmap);
+            {
+                var generator = new DistanceObjectPatternGenerator(Random, original, beatmap, lastPattern, originalBeatmap);
+                conversion = generator;
+
+                for (double time = original.StartTime; !Precision.DefinitelyBigger(time, generator.EndTime); time += generator.SegmentDuration)
+                {
+                    recordNote(time, positionData?.Position ?? Vector2.Zero);
+                    computeDensity(time);
+                }
+            }
             else if (endTimeData != null)
-                conversion = new EndTimeObjectPatternGenerator(random, original, beatmap, originalBeatmap);
+            {
+                conversion = new EndTimeObjectPatternGenerator(Random, original, beatmap, originalBeatmap);
+
+                recordNote(endTimeData.EndTime, new Vector2(256, 192));
+                computeDensity(endTimeData.EndTime);
+            }
             else if (positionData != null)
             {
                 computeDensity(original.StartTime);
 
-                conversion = new HitObjectPatternGenerator(random, original, beatmap, lastPattern, lastTime, lastPosition, density, lastStair, originalBeatmap);
+                conversion = new HitObjectPatternGenerator(Random, original, beatmap, lastPattern, lastTime, lastPosition, density, lastStair, originalBeatmap);
 
                 recordNote(original.StartTime, positionData.Position);
             }
 
             if (conversion == null)
-                return null;
+                yield break;
 
-            Pattern newPattern = conversion.Generate();
+            foreach (var newPattern in conversion.Generate())
+            {
+                lastPattern = conversion is EndTimeObjectPatternGenerator ? lastPattern : newPattern;
+                lastStair = (conversion as HitObjectPatternGenerator)?.StairType ?? lastStair;
 
-            lastPattern = conversion is EndTimeObjectPatternGenerator ? lastPattern : newPattern;
-            lastStair = (conversion as HitObjectPatternGenerator)?.StairType ?? lastStair;
+                foreach (var obj in newPattern.HitObjects)
+                    yield return obj;
 
-            return newPattern.HitObjects;
+            }
         }
 
         /// <summary>
@@ -171,7 +194,12 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             {
             }
 
-            public override Pattern Generate()
+            public override IEnumerable<Pattern> Generate()
+            {
+                yield return generate();
+            }
+
+            private Pattern generate()
             {
                 var endTimeData = HitObject as IHasEndTime;
                 var positionData = HitObject as IHasXPosition;

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

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.MathUtils;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.MathUtils;
@@ -24,8 +25,9 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// </summary>
         private const float osu_base_scoring_distance = 100;
 
-        private readonly double endTime;
-        private readonly double segmentDuration;
+        public readonly double EndTime;
+        public readonly double SegmentDuration;
+
         private readonly int spanCount;
 
         private PatternType convertType;
@@ -52,70 +54,105 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             // The duration of the osu! hit object
             double osuDuration = distance / osuVelocity;
 
-            endTime = hitObject.StartTime + osuDuration;
-            segmentDuration = (endTime - HitObject.StartTime) / spanCount;
+            EndTime = hitObject.StartTime + osuDuration;
+            SegmentDuration = (EndTime - HitObject.StartTime) / spanCount;
         }
 
-        public override Pattern Generate()
+        public override IEnumerable<Pattern> Generate()
         {
+            var originalPattern = generate();
+
+            if (originalPattern.HitObjects.Count() == 1)
+            {
+                yield return originalPattern;
+                yield break;
+            }
+
+            // We need to split the intermediate pattern into two new patterns:
+            // 1. A pattern containing all objects that do not end at our EndTime.
+            // 2. A pattern containing all objects that end at our EndTime. This will be used for further pattern generation.
+            var intermediatePattern = new Pattern();
+            var endTimePattern = new Pattern();
+
+            foreach (var obj in originalPattern.HitObjects)
+            {
+                if (!Precision.AlmostEquals(EndTime, (obj as IHasEndTime)?.EndTime ?? obj.StartTime))
+                    intermediatePattern.Add(obj);
+                else
+                    endTimePattern.Add(obj);
+            }
+
+            yield return intermediatePattern;
+            yield return endTimePattern;
+        }
+
+        private Pattern generate()
+        {
+            if (TotalColumns == 1)
+            {
+                var pattern = new Pattern();
+                addToPattern(pattern, 0, HitObject.StartTime, EndTime);
+                return pattern;
+            }
+
             if (spanCount > 1)
             {
-                if (segmentDuration <= 90)
+                if (SegmentDuration <= 90)
                     return generateRandomHoldNotes(HitObject.StartTime, 1);
 
-                if (segmentDuration <= 120)
+                if (SegmentDuration <= 120)
                 {
                     convertType |= PatternType.ForceNotStack;
                     return generateRandomNotes(HitObject.StartTime, spanCount + 1);
                 }
 
-                if (segmentDuration <= 160)
+                if (SegmentDuration <= 160)
                     return generateStair(HitObject.StartTime);
 
-                if (segmentDuration <= 200 && ConversionDifficulty > 3)
+                if (SegmentDuration <= 200 && ConversionDifficulty > 3)
                     return generateRandomMultipleNotes(HitObject.StartTime);
 
-                double duration = endTime - HitObject.StartTime;
+                double duration = EndTime - HitObject.StartTime;
                 if (duration >= 4000)
                     return generateNRandomNotes(HitObject.StartTime, 0.23, 0, 0);
 
-                if (segmentDuration > 400 && spanCount < TotalColumns - 1 - RandomStart)
+                if (SegmentDuration > 400 && spanCount < TotalColumns - 1 - RandomStart)
                     return generateTiledHoldNotes(HitObject.StartTime);
 
                 return generateHoldAndNormalNotes(HitObject.StartTime);
             }
 
-            if (segmentDuration <= 110)
+            if (SegmentDuration <= 110)
             {
                 if (PreviousPattern.ColumnWithObjects < TotalColumns)
                     convertType |= PatternType.ForceNotStack;
                 else
                     convertType &= ~PatternType.ForceNotStack;
-                return generateRandomNotes(HitObject.StartTime, segmentDuration < 80 ? 1 : 2);
+                return generateRandomNotes(HitObject.StartTime, SegmentDuration < 80 ? 1 : 2);
             }
 
             if (ConversionDifficulty > 6.5)
             {
-                if ((convertType & PatternType.LowProbability) > 0)
+                if (convertType.HasFlag(PatternType.LowProbability))
                     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)
+                if (convertType.HasFlag(PatternType.LowProbability))
                     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)
+                if (convertType.HasFlag(PatternType.LowProbability))
                     return generateNRandomNotes(HitObject.StartTime, 0.3, 0, 0);
                 return generateNRandomNotes(HitObject.StartTime, 0.37, 0.08, 0);
             }
 
-            if ((convertType & PatternType.LowProbability) > 0)
+            if (convertType.HasFlag(PatternType.LowProbability))
                 return generateNRandomNotes(HitObject.StartTime, 0.17, 0, 0);
             return generateNRandomNotes(HitObject.StartTime, 0.27, 0, 0);
         }
@@ -136,20 +173,19 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             var pattern = new Pattern();
 
             int usableColumns = TotalColumns - RandomStart - PreviousPattern.ColumnWithObjects;
-            int nextColumn = Random.Next(RandomStart, TotalColumns);
+            int nextColumn = GetRandomColumn();
             for (int i = 0; i < Math.Min(usableColumns, noteCount); i++)
             {
-                while (pattern.ColumnHasObject(nextColumn) || PreviousPattern.ColumnHasObject(nextColumn))  //find available column
-                    nextColumn = Random.Next(RandomStart, TotalColumns);
-                addToPattern(pattern, nextColumn, startTime, endTime);
+                // Find available column
+                nextColumn = FindAvailableColumn(nextColumn, pattern, PreviousPattern);
+                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, TotalColumns);
-                addToPattern(pattern, nextColumn, startTime, endTime);
+                nextColumn = FindAvailableColumn(nextColumn, pattern);
+                addToPattern(pattern, nextColumn, startTime, EndTime);
             }
 
             return pattern;
@@ -172,21 +208,16 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             var pattern = new Pattern();
 
             int nextColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
-            if ((convertType & PatternType.ForceNotStack) > 0 && PreviousPattern.ColumnWithObjects < TotalColumns)
-            {
-                while (PreviousPattern.ColumnHasObject(nextColumn))
-                    nextColumn = Random.Next(RandomStart, TotalColumns);
-            }
+            if (convertType.HasFlag(PatternType.ForceNotStack) && PreviousPattern.ColumnWithObjects < TotalColumns)
+                nextColumn = FindAvailableColumn(nextColumn, PreviousPattern);
 
             int lastColumn = nextColumn;
             for (int i = 0; i < noteCount; i++)
             {
                 addToPattern(pattern, nextColumn, startTime, startTime);
-                while (nextColumn == lastColumn)
-                    nextColumn = Random.Next(RandomStart, TotalColumns);
-
+                nextColumn = FindAvailableColumn(nextColumn, validation: c => c != lastColumn);
                 lastColumn = nextColumn;
-                startTime += segmentDuration;
+                startTime += SegmentDuration;
             }
 
             return pattern;
@@ -216,7 +247,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             for (int i = 0; i <= spanCount; i++)
             {
                 addToPattern(pattern, column, startTime, startTime);
-                startTime += segmentDuration;
+                startTime += SegmentDuration;
 
                 // Check if we're at the borders of the stage, and invert the pattern if so
                 if (increasing)
@@ -276,8 +307,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 if (TotalColumns > 2)
                     addToPattern(pattern, nextColumn, startTime, startTime);
 
-                nextColumn = Random.Next(RandomStart, TotalColumns);
-                startTime += segmentDuration;
+                nextColumn = GetRandomColumn();
+                startTime += SegmentDuration;
             }
 
             return pattern;
@@ -322,9 +353,9 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                     break;
             }
 
-            bool isDoubleSample(SampleInfo sample) => sample.Name == SampleInfo.HIT_CLAP && sample.Name == SampleInfo.HIT_FINISH;
+            bool isDoubleSample(SampleInfo sample) => sample.Name == SampleInfo.HIT_CLAP || sample.Name == SampleInfo.HIT_FINISH;
 
-            bool canGenerateTwoNotes = (convertType & PatternType.LowProbability) == 0;
+            bool canGenerateTwoNotes = !convertType.HasFlag(PatternType.LowProbability);
             canGenerateTwoNotes &= HitObject.Samples.Any(isDoubleSample) || sampleInfoListAt(HitObject.StartTime).Any(isDoubleSample);
 
             if (canGenerateTwoNotes)
@@ -354,19 +385,14 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             int columnRepeat = Math.Min(spanCount, TotalColumns);
 
             int nextColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
-            if ((convertType & PatternType.ForceNotStack) > 0 && PreviousPattern.ColumnWithObjects < TotalColumns)
-            {
-                while (PreviousPattern.ColumnHasObject(nextColumn))
-                    nextColumn = Random.Next(RandomStart, TotalColumns);
-            }
+            if (convertType.HasFlag(PatternType.ForceNotStack) && PreviousPattern.ColumnWithObjects < TotalColumns)
+                nextColumn = FindAvailableColumn(nextColumn, PreviousPattern);
 
             for (int i = 0; i < columnRepeat; i++)
             {
-                while (pattern.ColumnHasObject(nextColumn))
-                    nextColumn = Random.Next(RandomStart, TotalColumns);
-
-                addToPattern(pattern, nextColumn, startTime, endTime);
-                startTime += segmentDuration;
+                nextColumn = FindAvailableColumn(nextColumn, pattern);
+                addToPattern(pattern, nextColumn, startTime, EndTime);
+                startTime += SegmentDuration;
             }
 
             return pattern;
@@ -388,16 +414,13 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             var pattern = new Pattern();
 
             int holdColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
-            if ((convertType & PatternType.ForceNotStack) > 0 && PreviousPattern.ColumnWithObjects < TotalColumns)
-            {
-                while (PreviousPattern.ColumnHasObject(holdColumn))
-                    holdColumn = Random.Next(RandomStart, TotalColumns);
-            }
+            if (convertType.HasFlag(PatternType.ForceNotStack) && PreviousPattern.ColumnWithObjects < TotalColumns)
+                holdColumn = FindAvailableColumn(holdColumn, PreviousPattern);
 
             // Create the hold note
-            addToPattern(pattern, holdColumn, startTime, endTime);
+            addToPattern(pattern, holdColumn, startTime, EndTime);
 
-            int nextColumn = Random.Next(RandomStart, TotalColumns);
+            int nextColumn = GetRandomColumn();
             int noteCount;
             if (ConversionDifficulty > 6.5)
                 noteCount = GetRandomNoteCount(0.63, 0);
@@ -418,8 +441,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 {
                     for (int j = 0; j < noteCount; j++)
                     {
-                        while (rowPattern.ColumnHasObject(nextColumn) || nextColumn == holdColumn)
-                            nextColumn = Random.Next(RandomStart, TotalColumns);
+                        nextColumn = FindAvailableColumn(nextColumn, validation: c => c != holdColumn, patterns: rowPattern);
                         addToPattern(rowPattern, nextColumn, startTime, startTime);
                     }
                 }
@@ -427,7 +449,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 pattern.Add(rowPattern);
                 rowPattern.Clear();
 
-                startTime += segmentDuration;
+                startTime += SegmentDuration;
             }
 
             return pattern;
@@ -445,7 +467,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             if (curveData == null)
                 return HitObject.Samples;
 
-            double segmentTime = (endTime - HitObject.StartTime) / spanCount;
+            double segmentTime = (EndTime - HitObject.StartTime) / spanCount;
 
             int index = (int)(segmentTime == 0 ? 0 : (time - HitObject.StartTime) / segmentTime);
             return curveData.RepeatSamples[index];

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

@@ -19,45 +19,37 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         public EndTimeObjectPatternGenerator(FastRandom random, HitObject hitObject, ManiaBeatmap beatmap, IBeatmap originalBeatmap)
             : base(random, hitObject, beatmap, new Pattern(), originalBeatmap)
         {
-            var endtimeData = HitObject as IHasEndTime;
-
-            endTime = endtimeData?.EndTime ?? 0;
+            endTime = (HitObject as IHasEndTime)?.EndTime ?? 0;
         }
 
-        public override Pattern Generate()
+        public override IEnumerable<Pattern> Generate()
+        {
+            yield return generate();
+        }
+
+        private Pattern generate()
         {
             var pattern = new Pattern();
 
             bool generateHold = endTime - HitObject.StartTime >= 100;
 
-            if (TotalColumns == 8)
+            switch (TotalColumns)
             {
-                if (HitObject.Samples.Any(s => s.Name == SampleInfo.HIT_FINISH) && endTime - HitObject.StartTime < 1000)
+                case 8 when HitObject.Samples.Any(s => s.Name == SampleInfo.HIT_FINISH) && endTime - HitObject.StartTime < 1000:
                     addToPattern(pattern, 0, generateHold);
-                else
-                    addToPattern(pattern, getNextRandomColumn(RandomStart), generateHold);
+                    break;
+                case 8:
+                    addToPattern(pattern, FindAvailableColumn(GetRandomColumn(), PreviousPattern), generateHold);
+                    break;
+                default:
+                    if (TotalColumns > 0)
+                        addToPattern(pattern, GetRandomColumn(), generateHold);
+                    break;
             }
-            else if (TotalColumns > 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, TotalColumns);
-
-            while (PreviousPattern.ColumnHasObject(nextColumn))
-                nextColumn = Random.Next(start, TotalColumns);
-
-            return nextColumn;
-        }
-
         /// <summary>
         /// Constructs and adds a note to a pattern.
         /// </summary>

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

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using OpenTK;
 using osu.Game.Audio;
@@ -20,12 +21,10 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
         private readonly PatternType convertType;
 
-        public HitObjectPatternGenerator(FastRandom random, HitObject hitObject, ManiaBeatmap beatmap, Pattern previousPattern, double previousTime, Vector2 previousPosition, double density, PatternType lastStair, IBeatmap originalBeatmap)
+        public HitObjectPatternGenerator(FastRandom random, HitObject hitObject, ManiaBeatmap beatmap, Pattern previousPattern, double previousTime, Vector2 previousPosition, double density,
+                                         PatternType lastStair, IBeatmap originalBeatmap)
             : base(random, hitObject, beatmap, previousPattern, originalBeatmap)
         {
-            if (previousTime > hitObject.StartTime) throw new ArgumentOutOfRangeException(nameof(previousTime));
-            if (density < 0) throw new ArgumentOutOfRangeException(nameof(density));
-
             StairType = lastStair;
 
             TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(hitObject.StartTime);
@@ -77,117 +76,138 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             }
             else
                 convertType |= PatternType.LowProbability;
+
+            if (!convertType.HasFlag(PatternType.KeepSingle))
+            {
+                if (HitObject.Samples.Any(s => s.Name == SampleInfo.HIT_FINISH) && TotalColumns != 8)
+                    convertType |= PatternType.Mirror;
+                else if (HitObject.Samples.Any(s => s.Name == SampleInfo.HIT_CLAP))
+                    convertType |= PatternType.Gathered;
+            }
         }
 
-        public override Pattern Generate()
+        public override IEnumerable<Pattern> Generate()
         {
-            int lastColumn = PreviousPattern.HitObjects.FirstOrDefault()?.Column ?? 0;
+            yield return generate();
+        }
 
-            if ((convertType & PatternType.Reverse) > 0 && PreviousPattern.HitObjects.Any())
+        private Pattern generate()
+        {
+            var pattern = new Pattern();
+
+            try
             {
-                // Generate a new pattern by copying the last hit objects in reverse-column order
-                var pattern = new Pattern();
-
-                for (int i = RandomStart; i < TotalColumns; i++)
-                    if (PreviousPattern.ColumnHasObject(i))
-                        addToPattern(pattern, RandomStart + TotalColumns - 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
-                && (TotalColumns != 8 || lastColumn != 0)
-                // Make sure the last column was not the centre column
-                && (TotalColumns % 2 == 0 || lastColumn != TotalColumns / 2))
-            {
-                // Generate a new pattern by cycling backwards (similar to Reverse but for only one hit object)
-                var pattern = new Pattern();
-
-                int column = RandomStart + TotalColumns - 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 < TotalColumns; 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 == TotalColumns)
+                if (TotalColumns == 1)
                 {
-                    targetColumn = RandomStart;
-                    StairType = PatternType.ReverseStair;
+                    addToPattern(pattern, 0);
+                    return pattern;
                 }
 
-                addToPattern(pattern, targetColumn);
-                return pattern;
-            }
+                int lastColumn = PreviousPattern.HitObjects.FirstOrDefault()?.Column ?? 0;
 
-            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)
+                if (convertType.HasFlag(PatternType.Reverse) && PreviousPattern.HitObjects.Any())
                 {
-                    targetColumn = TotalColumns - 1;
-                    StairType = PatternType.Stair;
+                    // Generate a new pattern by copying the last hit objects in reverse-column order
+                    for (int i = RandomStart; i < TotalColumns; i++)
+                        if (PreviousPattern.ColumnHasObject(i))
+                            addToPattern(pattern, RandomStart + TotalColumns - i - 1);
+
+                    return pattern;
                 }
 
-                addToPattern(pattern, targetColumn);
-                return pattern;
-            }
+                if (convertType.HasFlag(PatternType.Cycle) && PreviousPattern.HitObjects.Count() == 1
+                                                          // If we convert to 7K + 1, let's not overload the special key
+                                                          && (TotalColumns != 8 || lastColumn != 0)
+                                                          // Make sure the last column was not the centre column
+                                                          && (TotalColumns % 2 == 0 || lastColumn != TotalColumns / 2))
+                {
+                    // Generate a new pattern by cycling backwards (similar to Reverse but for only one hit object)
+                    int column = RandomStart + TotalColumns - lastColumn - 1;
+                    addToPattern(pattern, column);
 
-            if ((convertType & PatternType.KeepSingle) > 0)
-                return generateRandomNotes(1);
+                    return pattern;
+                }
+
+                if (convertType.HasFlag(PatternType.ForceStack) && PreviousPattern.HitObjects.Any())
+                {
+                    // Generate a new pattern by placing on the already filled columns
+                    for (int i = RandomStart; i < TotalColumns; i++)
+                        if (PreviousPattern.ColumnHasObject(i))
+                            addToPattern(pattern, i);
+
+                    return pattern;
+                }
+
+                if (PreviousPattern.HitObjects.Count() == 1)
+                {
+                    if (convertType.HasFlag(PatternType.Stair))
+                    {
+                        // Generate a new pattern by placing on the next column, cycling back to the start if there is no "next"
+                        int targetColumn = lastColumn + 1;
+                        if (targetColumn == TotalColumns)
+                            targetColumn = RandomStart;
+
+                        addToPattern(pattern, targetColumn);
+                        return pattern;
+                    }
+
+                    if (convertType.HasFlag(PatternType.ReverseStair))
+                    {
+                        // Generate a new pattern by placing on the previous column, cycling back to the end if there is no "previous"
+                        int targetColumn = lastColumn - 1;
+                        if (targetColumn == RandomStart - 1)
+                            targetColumn = TotalColumns - 1;
+
+                        addToPattern(pattern, targetColumn);
+                        return pattern;
+                    }
+                }
+
+                if (convertType.HasFlag(PatternType.KeepSingle))
+                    return pattern = generateRandomNotes(1);
+
+                if (convertType.HasFlag(PatternType.Mirror))
+                {
+                    if (ConversionDifficulty > 6.5)
+                        return pattern = generateRandomPatternWithMirrored(0.12, 0.38, 0.12);
+                    if (ConversionDifficulty > 4)
+                        return pattern = generateRandomPatternWithMirrored(0.12, 0.17, 0);
+                    return pattern = generateRandomPatternWithMirrored(0.12, 0, 0);
+                }
 
-            if ((convertType & PatternType.Mirror) > 0)
-            {
                 if (ConversionDifficulty > 6.5)
-                    return generateRandomPatternWithMirrored(0.12, 0.38, 0.12);
+                {
+                    if (convertType.HasFlag(PatternType.LowProbability))
+                        return pattern = generateRandomPattern(0.78, 0.42, 0, 0);
+                    return pattern = generateRandomPattern(1, 0.62, 0, 0);
+                }
+
                 if (ConversionDifficulty > 4)
-                    return generateRandomPatternWithMirrored(0.12, 0.17, 0);
-                return generateRandomPatternWithMirrored(0.12, 0, 0);
-            }
+                {
+                    if (convertType.HasFlag(PatternType.LowProbability))
+                        return pattern = generateRandomPattern(0.35, 0.08, 0, 0);
+                    return pattern = generateRandomPattern(0.52, 0.15, 0, 0);
+                }
 
-            if (ConversionDifficulty > 6.5)
+                if (ConversionDifficulty > 2)
+                {
+                    if (convertType.HasFlag(PatternType.LowProbability))
+                        return pattern = generateRandomPattern(0.18, 0, 0, 0);
+                    return pattern = generateRandomPattern(0.45, 0, 0, 0);
+                }
+
+                return pattern = generateRandomPattern(0, 0, 0, 0);
+            }
+            finally
             {
-                if ((convertType & PatternType.LowProbability) > 0)
-                    return generateRandomPattern(0.78, 0.42, 0, 0);
-                return generateRandomPattern(1, 0.62, 0, 0);
+                foreach (var obj in pattern.HitObjects)
+                {
+                    if (convertType.HasFlag(PatternType.Stair) && obj.Column == TotalColumns - 1)
+                        StairType = PatternType.ReverseStair;
+                    if (convertType.HasFlag(PatternType.ReverseStair) && obj.Column == RandomStart)
+                        StairType = PatternType.Stair;
+                }
             }
-
-            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>
@@ -203,7 +223,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         {
             var pattern = new Pattern();
 
-            bool allowStacking = (convertType & PatternType.ForceNotStack) == 0;
+            bool allowStacking = !convertType.HasFlag(PatternType.ForceNotStack);
 
             if (!allowStacking)
                 noteCount = Math.Min(noteCount, TotalColumns - RandomStart - PreviousPattern.ColumnWithObjects);
@@ -211,22 +231,27 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             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 == TotalColumns)
-                            nextColumn = RandomStart;
-                    }
-                    else
-                        nextColumn = Random.Next(RandomStart, TotalColumns);
-                }
+                nextColumn = allowStacking
+                    ? FindAvailableColumn(nextColumn, nextColumn: getNextColumn, patterns: pattern)
+                    : FindAvailableColumn(nextColumn, nextColumn: getNextColumn, patterns: new[] { pattern, PreviousPattern });
 
                 addToPattern(pattern, nextColumn);
             }
 
             return pattern;
+
+            int getNextColumn(int last)
+            {
+                if (convertType.HasFlag(PatternType.Gathered))
+                {
+                    last++;
+                    if (last == TotalColumns)
+                        last = RandomStart;
+                }
+                else
+                    last = GetRandomColumn();
+                return last;
+            }
         }
 
         /// <summary>
@@ -263,17 +288,19 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
         private Pattern generateRandomPatternWithMirrored(double centreProbability, double p2, double p3)
         {
+            if (convertType.HasFlag(PatternType.ForceNotStack))
+                return generateRandomPattern(1 / 2f + p2 / 2, p2, (p2 + p3) / 2, p3);
+
             var pattern = new Pattern();
 
             bool addToCentre;
             int noteCount = getRandomNoteCountMirrored(centreProbability, p2, p3, out addToCentre);
 
             int columnLimit = (TotalColumns % 2 == 0 ? TotalColumns : TotalColumns - 1) / 2;
-            int nextColumn = Random.Next(RandomStart, columnLimit);
+            int nextColumn = GetRandomColumn(upperBound: columnLimit);
             for (int i = 0; i < noteCount; i++)
             {
-                while (pattern.ColumnHasObject(nextColumn))
-                    nextColumn = Random.Next(RandomStart, columnLimit);
+                nextColumn = FindAvailableColumn(nextColumn, upperBound: columnLimit, patterns: pattern);
 
                 // Add normal note
                 addToPattern(pattern, nextColumn);
@@ -345,9 +372,6 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         {
             addToCentre = false;
 
-            if ((convertType & PatternType.ForceNotStack) > 0)
-                return getRandomNoteCount(p2 / 2, p2, (p2 + p3) / 2, p3);
-
             switch (TotalColumns)
             {
                 case 2:

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

@@ -3,6 +3,7 @@
 
 using System;
 using System.Linq;
+using JetBrains.Annotations;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.MathUtils;
 using osu.Game.Rulesets.Objects;
@@ -90,6 +91,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         }
 
         private double? conversionDifficulty;
+
         /// <summary>
         /// A difficulty factor used for various conversion methods from osu!stable.
         /// </summary>
@@ -103,21 +105,95 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 HitObject lastObject = OriginalBeatmap.HitObjects.LastOrDefault();
                 HitObject firstObject = OriginalBeatmap.HitObjects.FirstOrDefault();
 
-                double drainTime = (lastObject?.StartTime ?? 0) - (firstObject?.StartTime ?? 0);
-                drainTime -= OriginalBeatmap.TotalBreakTime;
+                // Drain time in seconds
+                int drainTime = (int)(((lastObject?.StartTime ?? 0) - (firstObject?.StartTime ?? 0) - OriginalBeatmap.TotalBreakTime) / 1000);
 
                 if (drainTime == 0)
-                    drainTime = 10000000;
-
-                // We need this in seconds
-                drainTime /= 1000;
+                    drainTime = 10000;
 
                 BeatmapDifficulty difficulty = OriginalBeatmap.BeatmapInfo.BaseDifficulty;
-                conversionDifficulty = ((difficulty.DrainRate + MathHelper.Clamp(difficulty.ApproachRate, 4, 7)) / 1.5 + OriginalBeatmap.HitObjects.Count() / drainTime * 9f) / 38f * 5f / 1.15;
+                conversionDifficulty = ((difficulty.DrainRate + MathHelper.Clamp(difficulty.ApproachRate, 4, 7)) / 1.5 + (double)OriginalBeatmap.HitObjects.Count() / drainTime * 9f) / 38f * 5f / 1.15;
                 conversionDifficulty = Math.Min(conversionDifficulty.Value, 12);
 
                 return conversionDifficulty.Value;
             }
         }
+
+        /// <summary>
+        /// Finds a new column in which a <see cref="HitObject"/> can be placed.
+        /// This uses <see cref="GetRandomColumn"/> to pick the next candidate column.
+        /// </summary>
+        /// <param name="initialColumn">The initial column to test. This may be returned if it is already a valid column.</param>
+        /// <param name="patterns">A list of patterns for which the validity of a column should be checked against.
+        /// A column is not a valid candidate if a <see cref="HitObject"/> occupies the same column in any of the patterns.</param>
+        /// <returns>A column for which there are no <see cref="HitObject"/>s in any of <paramref name="patterns"/> occupying the same column.</returns>
+        /// <exception cref="NotEnoughColumnsException">If there are no valid candidate columns.</exception>
+        protected int FindAvailableColumn(int initialColumn, params Pattern[] patterns)
+            => FindAvailableColumn(initialColumn, null, patterns: patterns);
+
+        /// <summary>
+        /// Finds a new column in which a <see cref="HitObject"/> can be placed.
+        /// </summary>
+        /// <param name="initialColumn">The initial column to test. This may be returned if it is already a valid column.</param>
+        /// <param name="nextColumn">A function to retrieve the next column. If null, a randomisation scheme will be used.</param>
+        /// <param name="validation">A function to perform additional validation checks to determine if a column is a valid candidate for a <see cref="HitObject"/>.</param>
+        /// <param name="lowerBound">The minimum column index. If null, <see cref="RandomStart"/> is used.</param>
+        /// <param name="upperBound">The maximum column index. If null, <see cref="PatternGenerator.TotalColumns"/> is used.</param>
+        /// <param name="patterns">A list of patterns for which the validity of a column should be checked against.
+        /// A column is not a valid candidate if a <see cref="HitObject"/> occupies the same column in any of the patterns.</param>
+        /// <returns>A column which has passed the <paramref name="validation"/> check and for which there are no
+        /// <see cref="HitObject"/>s in any of <paramref name="patterns"/> occupying the same column.</returns>
+        /// <exception cref="NotEnoughColumnsException">If there are no valid candidate columns.</exception>
+        protected int FindAvailableColumn(int initialColumn, int? lowerBound = null, int? upperBound = null, Func<int, int> nextColumn = null, [InstantHandle] Func<int, bool> validation = null,
+                                          params Pattern[] patterns)
+        {
+            lowerBound = lowerBound ?? RandomStart;
+            upperBound = upperBound ?? TotalColumns;
+            nextColumn = nextColumn ?? (_ => GetRandomColumn(lowerBound, upperBound));
+
+            // Check for the initial column
+            if (isValid(initialColumn))
+                return initialColumn;
+
+            // Ensure that we have at least one free column, so that an endless loop is avoided
+            bool hasValidColumns = false;
+            for (int i = lowerBound.Value; i < upperBound.Value; i++)
+            {
+                hasValidColumns = isValid(i);
+                if (hasValidColumns)
+                    break;
+            }
+
+            if (!hasValidColumns)
+                throw new NotEnoughColumnsException();
+
+            // Iterate until a valid column is found. This is a random iteration in the default case.
+            do
+            {
+                initialColumn = nextColumn(initialColumn);
+            } while (!isValid(initialColumn));
+
+            return initialColumn;
+
+            bool isValid(int column) => validation?.Invoke(column) != false && !patterns.Any(p => p.ColumnHasObject(column));
+        }
+
+        /// <summary>
+        /// Returns a random column index in the range [<paramref name="lowerBound"/>, <paramref name="upperBound"/>).
+        /// </summary>
+        /// <param name="lowerBound">The minimum column index. If null, <see cref="RandomStart"/> is used.</param>
+        /// <param name="upperBound">The maximum column index. If null, <see cref="PatternGenerator.TotalColumns"/> is used.</param>
+        protected int GetRandomColumn(int? lowerBound = null, int? upperBound = null) => Random.Next(lowerBound ?? RandomStart, upperBound ?? TotalColumns);
+
+        /// <summary>
+        /// Occurs when mania conversion is stuck in an infinite loop unable to find columns to place new hitobjects in.
+        /// </summary>
+        public class NotEnoughColumnsException : Exception
+        {
+            public NotEnoughColumnsException()
+                : base("There were not enough columns to complete conversion.")
+            {
+            }
+        }
     }
 }

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

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using System.Collections.Generic;
 using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns
@@ -42,9 +43,9 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns
         }
 
         /// <summary>
-        /// Generates the pattern for <see cref="HitObject"/>, filled with hit objects.
+        /// Generates the patterns for <see cref="HitObject"/>, each filled with hit objects.
         /// </summary>
-        /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
-        public abstract Pattern Generate();
+        /// <returns>The <see cref="Pattern"/>s containing the hit objects.</returns>
+        public abstract IEnumerable<Pattern> Generate();
     }
 }

osu.Game.Rulesets.Mania/Configuration/ManiaConfigManager.cs

@@ -4,12 +4,13 @@
 using osu.Framework.Configuration.Tracking;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Configuration;
+using osu.Game.Rulesets.Mania.UI;
 
 namespace osu.Game.Rulesets.Mania.Configuration
 {
     public class ManiaConfigManager : RulesetConfigManager<ManiaSetting>
     {
-        public ManiaConfigManager(SettingsStore settings, RulesetInfo ruleset, int variant)
+        public ManiaConfigManager(SettingsStore settings, RulesetInfo ruleset, int? variant = null)
             : base(settings, ruleset, variant)
         {
         }
@@ -19,6 +20,7 @@ namespace osu.Game.Rulesets.Mania.Configuration
             base.InitialiseDefaults();
 
             Set(ManiaSetting.ScrollTime, 1500.0, 50.0, 10000.0, 50.0);
+            Set(ManiaSetting.ScrollDirection, ManiaScrollingDirection.Down);
         }
 
         public override TrackedSettings CreateTrackedSettings() => new TrackedSettings
@@ -29,6 +31,7 @@ namespace osu.Game.Rulesets.Mania.Configuration
 
     public enum ManiaSetting
     {
-        ScrollTime
+        ScrollTime,
+        ScrollDirection
     }
 }

osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyAttributes.cs

@@ -0,0 +1,18 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mods;
+
+namespace osu.Game.Rulesets.Mania.Difficulty
+{
+    public class ManiaDifficultyAttributes : DifficultyAttributes
+    {
+        public double GreatHitWindow;
+
+        public ManiaDifficultyAttributes(Mod[] mods, double starRating)
+            : base(mods, starRating)
+        {
+        }
+    }
+}

osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs

@@ -7,6 +7,7 @@ using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;
 
@@ -28,47 +29,44 @@ namespace osu.Game.Rulesets.Mania.Difficulty
         /// </summary>
         private const double decay_weight = 0.9;
 
-        /// <summary>
-        /// HitObjects are stored as a member variable.
-        /// </summary>
-        private readonly List<ManiaHitObjectDifficulty> difficultyHitObjects = new List<ManiaHitObjectDifficulty>();
+        private readonly bool isForCurrentRuleset;
 
-        public ManiaDifficultyCalculator(IBeatmap beatmap)
-            : base(beatmap)
+        public ManiaDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+            : base(ruleset, beatmap)
         {
+            isForCurrentRuleset = beatmap.BeatmapInfo.Ruleset.Equals(ruleset.RulesetInfo);
         }
 
-        public ManiaDifficultyCalculator(IBeatmap beatmap, Mod[] mods)
-            : base(beatmap, mods)
+        protected override DifficultyAttributes Calculate(IBeatmap beatmap, Mod[] mods, double timeRate)
         {
-        }
+            if (!beatmap.HitObjects.Any())
+                return new ManiaDifficultyAttributes(mods, 0);
 
-        public override double Calculate(Dictionary<string, double> categoryDifficulty = null)
-        {
-            // Fill our custom DifficultyHitObject class, that carries additional information
-            difficultyHitObjects.Clear();
+            var difficultyHitObjects = new List<ManiaHitObjectDifficulty>();
 
-            int columnCount = (Beatmap as ManiaBeatmap)?.TotalColumns ?? 7;
+            int columnCount = ((ManiaBeatmap)beatmap).TotalColumns;
 
             // Sort DifficultyHitObjects by StartTime of the HitObjects - just to make sure.
             // Note: Stable sort is done so that the ordering of hitobjects with equal start times doesn't change
-            difficultyHitObjects.AddRange(Beatmap.HitObjects.Select(h => new ManiaHitObjectDifficulty((ManiaHitObject)h, columnCount)).OrderBy(h => h.BaseHitObject.StartTime));
+            difficultyHitObjects.AddRange(beatmap.HitObjects.Select(h => new ManiaHitObjectDifficulty((ManiaHitObject)h, columnCount)).OrderBy(h => h.BaseHitObject.StartTime));
 
-            if (!calculateStrainValues())
-                return 0;
+            if (!calculateStrainValues(difficultyHitObjects, timeRate))
+                return new DifficultyAttributes(mods, 0);
 
-            double starRating = calculateDifficulty() * star_scaling_factor;
 
-            if (categoryDifficulty != null)
-                categoryDifficulty["Strain"] = starRating;
+            double starRating = calculateDifficulty(difficultyHitObjects, timeRate) * star_scaling_factor;
 
-            return starRating;
+            return new ManiaDifficultyAttributes(mods, starRating)
+            {
+                // Todo: This int cast is temporary to achieve 1:1 results with osu!stable, and should be remoevd in the future
+                GreatHitWindow = (int)(beatmap.HitObjects.First().HitWindows.Great / 2) / timeRate
+            };
         }
 
-        private bool calculateStrainValues()
+        private bool calculateStrainValues(List<ManiaHitObjectDifficulty> objects, double timeRate)
         {
             // Traverse hitObjects in pairs to calculate the strain value of NextHitObject from the strain value of CurrentHitObject and environment.
-            using (List<ManiaHitObjectDifficulty>.Enumerator hitObjectsEnumerator = difficultyHitObjects.GetEnumerator())
+            using (var hitObjectsEnumerator = objects.GetEnumerator())
             {
                 if (!hitObjectsEnumerator.MoveNext())
                     return false;
@@ -79,7 +77,7 @@ namespace osu.Game.Rulesets.Mania.Difficulty
                 while (hitObjectsEnumerator.MoveNext())
                 {
                     var next = hitObjectsEnumerator.Current;
-                    next?.CalculateStrains(current, TimeRate);
+                    next?.CalculateStrains(current, timeRate);
                     current = next;
                 }
 
@@ -87,9 +85,9 @@ namespace osu.Game.Rulesets.Mania.Difficulty
             }
         }
 
-        private double calculateDifficulty()
+        private double calculateDifficulty(List<ManiaHitObjectDifficulty> objects, double timeRate)
         {
-            double actualStrainStep = strain_step * TimeRate;
+            double actualStrainStep = strain_step * timeRate;
 
             // Find the highest strain value within each strain step
             List<double> highestStrains = new List<double>();
@@ -97,7 +95,7 @@ namespace osu.Game.Rulesets.Mania.Difficulty
             double maximumStrain = 0; // We need to keep track of the maximum strain in the current interval
 
             ManiaHitObjectDifficulty previousHitObject = null;
-            foreach (var hitObject in difficultyHitObjects)
+            foreach (var hitObject in objects)
             {
                 // While we are beyond the current interval push the currently available maximum to our strain list
                 while (hitObject.BaseHitObject.StartTime > intervalEndTime)
@@ -141,5 +139,36 @@ namespace osu.Game.Rulesets.Mania.Difficulty
 
             return difficulty;
         }
+
+        protected override Mod[] DifficultyAdjustmentMods
+        {
+            get
+            {
+                var mods = new Mod[]
+                {
+                    new ManiaModDoubleTime(),
+                    new ManiaModHalfTime(),
+                    new ManiaModEasy(),
+                    new ManiaModHardRock(),
+                };
+
+                if (isForCurrentRuleset)
+                    return mods;
+
+                // if we are a convert, we can be played in any key mod.
+                return mods.Concat(new Mod[]
+                {
+                    new ManiaModKey1(),
+                    new ManiaModKey2(),
+                    new ManiaModKey3(),
+                    new ManiaModKey4(),
+                    new ManiaModKey5(),
+                    new ManiaModKey6(),
+                    new ManiaModKey7(),
+                    new ManiaModKey8(),
+                    new ManiaModKey9(),
+                }).ToArray();
+            }
+        }
     }
 }

osu.Game.Rulesets.Mania/Difficulty/ManiaPerformanceCalculator.cs

@@ -13,6 +13,8 @@ namespace osu.Game.Rulesets.Mania.Difficulty
 {
     public class ManiaPerformanceCalculator : PerformanceCalculator
     {
+        protected new ManiaDifficultyAttributes Attributes => (ManiaDifficultyAttributes)base.Attributes;
+
         private Mod[] mods;
 
         // Score after being scaled by non-difficulty-increasing mods
@@ -25,7 +27,7 @@ namespace osu.Game.Rulesets.Mania.Difficulty
         private int countMeh;
         private int countMiss;
 
-        public ManiaPerformanceCalculator(Ruleset ruleset, IBeatmap beatmap, Score score)
+        public ManiaPerformanceCalculator(Ruleset ruleset, WorkingBeatmap beatmap, Score score)
             : base(ruleset, beatmap, score)
         {
         }
@@ -82,7 +84,7 @@ namespace osu.Game.Rulesets.Mania.Difficulty
         private double computeStrainValue()
         {
             // Obtain strain difficulty
-            double strainValue = Math.Pow(5 * Math.Max(1, Attributes["Strain"] / 0.2) - 4.0, 2.2) / 135.0;
+            double strainValue = Math.Pow(5 * Math.Max(1, Attributes.StarRating / 0.2) - 4.0, 2.2) / 135.0;
 
             // Longer maps are worth more
             strainValue *= 1.0 + 0.1 * Math.Min(1.0, totalHits / 1500.0);
@@ -105,14 +107,12 @@ namespace osu.Game.Rulesets.Mania.Difficulty
 
         private double computeAccuracyValue(double strainValue)
         {
-            // Todo: This int cast is temporary to achieve 1:1 results with osu!stable, and should be remoevd in the future
-            double hitWindowGreat = (int)(Beatmap.HitObjects.First().HitWindows.Great / 2) / TimeRate;
-            if (hitWindowGreat <= 0)
+            if (Attributes.GreatHitWindow <= 0)
                 return 0;
 
             // Lots of arbitrary values from testing.
             // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution
-            double accuracyValue = Math.Max(0.0, 0.2 - (hitWindowGreat - 34) * 0.006667)
+            double accuracyValue = Math.Max(0.0, 0.2 - (Attributes.GreatHitWindow - 34) * 0.006667)
                                        * strainValue
                                        * Math.Pow(Math.Max(0.0, scaledScore - 960000) / 40000, 1.1);
 

osu.Game.Rulesets.Mania/Edit/Layers/Selection/Overlays/HoldNoteMask.cs

@@ -0,0 +1,84 @@
+// Copyright (c) 2007-2018 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.Graphics;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.UI.Scrolling;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.Edit.Layers.Selection.Overlays
+{
+    public class HoldNoteMask : HitObjectMask
+    {
+        public new DrawableHoldNote HitObject => (DrawableHoldNote)base.HitObject;
+
+        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
+
+        private readonly BodyPiece body;
+
+        public HoldNoteMask(DrawableHoldNote hold)
+            : base(hold)
+        {
+            InternalChildren = new Drawable[]
+            {
+                new HoldNoteNoteMask(hold.Head),
+                new HoldNoteNoteMask(hold.Tail),
+                body = new BodyPiece
+                {
+                    AccentColour = Color4.Transparent
+                },
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours, IScrollingInfo scrollingInfo)
+        {
+            body.BorderColour = colours.Yellow;
+
+            direction.BindTo(scrollingInfo.Direction);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            Size = HitObject.DrawSize + new Vector2(0, HitObject.Tail.DrawHeight);
+            Position = Parent.ToLocalSpace(HitObject.ScreenSpaceDrawQuad.TopLeft);
+
+            // This is a side-effect of not matching the hitobject's anchors/origins, which is kinda hard to do
+            // When scrolling upwards our origin is already at the top of the head note (which is the intended location),
+            // but when scrolling downwards our origin is at the _bottom_ of the tail note (where we need to be at the _top_ of the tail note)
+            if (direction.Value == ScrollingDirection.Down)
+                Y -= HitObject.Tail.DrawHeight;
+        }
+
+        private class HoldNoteNoteMask : NoteMask
+        {
+            public HoldNoteNoteMask(DrawableNote note)
+                : base(note)
+            {
+                Select();
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                Anchor = HitObject.Anchor;
+                Origin = HitObject.Origin;
+
+                Position = HitObject.DrawPosition;
+            }
+
+            // Todo: This is temporary, since the note masks don't do anything special yet. In the future they will handle input.
+            public override bool HandleMouseInput => false;
+        }
+    }
+}

osu.Game.Rulesets.Mania/Edit/Layers/Selection/Overlays/NoteMask.cs

@@ -0,0 +1,39 @@
+// Copyright (c) 2007-2018 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.Game.Graphics;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+
+namespace osu.Game.Rulesets.Mania.Edit.Layers.Selection.Overlays
+{
+    public class NoteMask : HitObjectMask
+    {
+        public NoteMask(DrawableNote note)
+            : base(note)
+        {
+            Scale = note.Scale;
+
+            CornerRadius = 5;
+            Masking = true;
+
+            AddInternal(new NotePiece());
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Colour = colours.Yellow;
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            Size = HitObject.DrawSize;
+            Position = Parent.ToLocalSpace(HitObject.ScreenSpaceDrawQuad.TopLeft);
+        }
+    }
+}

osu.Game.Rulesets.Mania/Edit/ManiaEditPlayfield.cs

@@ -0,0 +1,17 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.UI;
+using System.Collections.Generic;
+
+namespace osu.Game.Rulesets.Mania.Edit
+{
+    public class ManiaEditPlayfield : ManiaPlayfield
+    {
+        public ManiaEditPlayfield(List<StageDefinition> stages)
+            : base(stages)
+        {
+        }
+    }
+}

osu.Game.Rulesets.Mania/Edit/ManiaEditRulesetContainer.cs

@@ -0,0 +1,27 @@
+// Copyright (c) 2007-2018 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.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Mania.Edit
+{
+    public class ManiaEditRulesetContainer : ManiaRulesetContainer
+    {
+        public ManiaEditRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
+            : base(ruleset, beatmap)
+        {
+        }
+
+        protected override Playfield CreatePlayfield() => new ManiaEditPlayfield(Beatmap.Stages)
+        {
+            Anchor = Anchor.Centre,
+            Origin = Anchor.Centre,
+        };
+
+        protected override Vector2 PlayfieldArea => Vector2.One;
+    }
+}

osu.Game.Rulesets.Mania/Edit/ManiaHitObjectComposer.cs

@@ -0,0 +1,56 @@
+// Copyright (c) 2007-2018 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.Edit;
+using osu.Game.Rulesets.Edit.Tools;
+using osu.Game.Rulesets.Mania.Edit.Layers.Selection.Overlays;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI;
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Game.Rulesets.Mania.Configuration;
+using osu.Game.Rulesets.Mania.UI;
+
+namespace osu.Game.Rulesets.Mania.Edit
+{
+    public class ManiaHitObjectComposer : HitObjectComposer
+    {
+        protected new ManiaConfigManager Config => (ManiaConfigManager)base.Config;
+
+        public ManiaHitObjectComposer(Ruleset ruleset)
+            : base(ruleset)
+        {
+        }
+
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+        {
+            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
+            dependencies.CacheAs<IScrollingInfo>(new ManiaScrollingInfo(Config));
+            return dependencies;
+        }
+
+        protected override RulesetContainer CreateRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap) => new ManiaEditRulesetContainer(ruleset, beatmap);
+
+        protected override IReadOnlyList<ICompositionTool> CompositionTools => new ICompositionTool[]
+        {
+            new HitObjectCompositionTool<Note>("Note"),
+            new HitObjectCompositionTool<HoldNote>("Hold"),
+        };
+
+        public override HitObjectMask CreateMaskFor(DrawableHitObject hitObject)
+        {
+            switch (hitObject)
+            {
+                case DrawableNote note:
+                    return new NoteMask(note);
+                case DrawableHoldNote holdNote:
+                    return new HoldNoteMask(holdNote);
+            }
+
+            return base.CreateMaskFor(hitObject);
+        }
+    }
+}

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

@@ -8,6 +8,7 @@ namespace osu.Game.Rulesets.Mania.Judgements
     public class HoldNoteJudgement : ManiaJudgement
     {
         public override bool AffectsCombo => false;
+
         protected override int NumericResultFor(HitResult result) => 0;
     }
 }

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

@@ -1,27 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Game.Rulesets.Scoring;
-
-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;
-
-        protected override int NumericResultFor(HitResult result)
-        {
-            switch (result)
-            {
-                default:
-                    return base.NumericResultFor(result);
-                case HitResult.Great:
-                case HitResult.Perfect:
-                    return base.NumericResultFor(HasBroken ? HitResult.Good : result);
-            }
-        }
-    }
-}