Remove empty files

Update framework
Revert values on lease end
2026-05-21 06:29:52 +08:00 · 2019-01-21 16:37:20 +09:00 · 2019-01-21 16:37:20 +09:00 · 2019-01-21 16:37:20 +09:00 · 2019-01-21 16:37:20 +09:00 · 2019-01-20 19:57:04 +09:00
502 changed files with 13240 additions and 5179 deletions
@@ -1,6 +1,6 @@
 <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/netcoreapp2.1/osu.Game.Rulesets.Catch.Tests.dll" />
+    <option name="EXE_PATH" value="$PROJECT_DIR$/osu.Game.Rulesets.Catch.Tests/bin/Debug/netcoreapp2.2/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" />
@@ -1,6 +1,6 @@
 <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/netcoreapp2.1/osu.Game.Rulesets.Mania.Tests.dll" />
+    <option name="EXE_PATH" value="$PROJECT_DIR$/osu.Game.Rulesets.Mania.Tests/bin/Debug/netcoreapp2.2/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" />
@@ -1,6 +1,6 @@
 <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/netcoreapp2.1/osu.Game.Rulesets.Osu.Tests.dll" />
+    <option name="EXE_PATH" value="$PROJECT_DIR$/osu.Game.Rulesets.Osu.Tests/bin/Debug/netcoreapp2.2/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" />
@@ -1,6 +1,6 @@
 <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/netcoreapp2.1/osu.Game.Rulesets.Taiko.Tests.dll" />
+    <option name="EXE_PATH" value="$PROJECT_DIR$/osu.Game.Rulesets.Taiko.Tests/bin/Debug/netcoreapp2.2/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" />
@@ -1,6 +1,6 @@
 <component name="ProjectRunConfigurationManager">
  <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="EXE_PATH" value="$PROJECT_DIR$/osu.Game.Tests/bin/Debug/netcoreapp2.2/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" />
@@ -1,17 +1,20 @@
 <component name="ProjectRunConfigurationManager">
  <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="EXE_PATH" value="$PROJECT_DIR$/osu.Desktop/bin/Debug/netcoreapp2.2/osu!.dll" />
    <option name="PROGRAM_PARAMETERS" value="" />
    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/osu.Desktop" />
    <option name="PASS_PARENT_ENVS" value="1" />
    <option name="USE_EXTERNAL_CONSOLE" value="0" />
    <option name="USE_MONO" value="0" />
+    <option name="RUNTIME_ARGUMENTS" value="" />
    <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=".NETCoreApp,Version=v2.1" />
-    <method />
+    <option name="PROJECT_TFM" value=".NETCoreApp,Version=v2.2" />
+    <method v="2">
+      <option name="Build" enabled="true" />
+    </method>
  </configuration>
 </component>
@@ -7,13 +7,13 @@
            "request": "launch",
            "program": "dotnet",
            "args": [
-                "${workspaceRoot}/osu.Game.Tests/bin/Debug/netcoreapp2.1/osu.Game.Tests.dll"
+                "${workspaceRoot}/osu.Game.Tests/bin/Debug/netcoreapp2.2/osu.Game.Tests.dll"
            ],
            "cwd": "${workspaceRoot}",
            "preLaunchTask": "Build tests (Debug)",
            "linux": {
                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Game.Tests/bin/Debug/netcoreapp2.1:${env:LD_LIBRARY_PATH}"
+                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Game.Tests/bin/Debug/netcoreapp2.2:${env:LD_LIBRARY_PATH}"
                }
            },
            "console": "internalConsole"
@@ -24,13 +24,13 @@
            "request": "launch",
            "program": "dotnet",
            "args": [
-                "${workspaceRoot}/osu.Game.Tests/bin/Release/netcoreapp2.1/osu.Game.Tests.dll"
+                "${workspaceRoot}/osu.Game.Tests/bin/Release/netcoreapp2.2/osu.Game.Tests.dll"
            ],
            "cwd": "${workspaceRoot}",
            "preLaunchTask": "Build tests (Release)",
            "linux": {
                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Game.Tests/bin/Release/netcoreapp2.1:${env:LD_LIBRARY_PATH}"
+                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Game.Tests/bin/Release/netcoreapp2.2:${env:LD_LIBRARY_PATH}"
                }
            },
            "console": "internalConsole"
@@ -41,13 +41,13 @@
            "request": "launch",
            "program": "dotnet",
            "args": [
-                "${workspaceRoot}/osu.Desktop/bin/Debug/netcoreapp2.1/osu!.dll"
+                "${workspaceRoot}/osu.Desktop/bin/Debug/netcoreapp2.2/osu!.dll"
            ],
            "cwd": "${workspaceRoot}",
            "preLaunchTask": "Build osu! (Debug)",
            "linux": {
                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Desktop/bin/Debug/netcoreapp2.1:${env:LD_LIBRARY_PATH}"
+                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Desktop/bin/Debug/netcoreapp2.2:${env:LD_LIBRARY_PATH}"
                }
            },
            "console": "internalConsole"
@@ -58,13 +58,13 @@
            "request": "launch",
            "program": "dotnet",
            "args": [
-                "${workspaceRoot}/osu.Desktop/bin/Release/netcoreapp2.1/osu!.dll"
+                "${workspaceRoot}/osu.Desktop/bin/Release/netcoreapp2.2/osu!.dll"
            ],
            "cwd": "${workspaceRoot}",
            "preLaunchTask": "Build osu! (Release)",
            "linux": {
                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Desktop/bin/Release/netcoreapp2.1:${env:LD_LIBRARY_PATH}"
+                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Desktop/bin/Release/netcoreapp2.2:${env:LD_LIBRARY_PATH}"
                }
            },
            "console": "internalConsole"
@@ -11,7 +11,6 @@
                "build",
                "--no-restore",
                "osu.Desktop",
-                "/p:TargetFramework=netcoreapp2.1",
                "/p:GenerateFullPaths=true",
                "/m",
                "/verbosity:m"
@@ -27,7 +26,6 @@
                "build",
                "--no-restore",
                "osu.Desktop",
-                "/p:TargetFramework=netcoreapp2.1",
                "/p:Configuration=Release",
                "/p:GenerateFullPaths=true",
                "/m",
@@ -44,7 +42,6 @@
                "build",
                "--no-restore",
                "osu.Game.Tests",
-                "/p:TargetFramework=netcoreapp2.1",
                "/p:GenerateFullPaths=true",
                "/m",
                "/verbosity:m"
@@ -60,7 +57,6 @@
                "build",
                "--no-restore",
                "osu.Game.Tests",
-                "/p:TargetFramework=netcoreapp2.1",
                "/p:Configuration=Release",
                "/p:GenerateFullPaths=true",
                "/m",
@@ -70,7 +66,7 @@
            "problemMatcher": "$msCompile"
        },
        {
-            "label": "Restore (netcoreapp2.1)",
+            "label": "Restore (netcoreapp2.2)",
            "type": "shell",
            "command": "dotnet",
            "args": [
@@ -10,26 +10,71 @@ We are accepting bug reports (please report with as much detail as possible). Fe

 # Requirements

- 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).
+- A desktop platform with the [.NET Core SDK 2.2](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 2017+](https://visualstudio.microsoft.com/vs/), [Jetbrains Rider](https://www.jetbrains.com/rider/) or [Visual Studio Code](https://code.visualstudio.com/).

-# Building and running
+# Running osu!

-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).
+## Releases

-Clone the repository including submodules
+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.

-`git clone --recurse-submodules https://github.com/ppy/osu`
+- Windows (x64) users should download and run `install.exe`.
+- macOS users (10.12 "Sierra" and higher) should download and run `osu.app.zip`.
+- iOS users can join the [TestFlight beta program](https://t.co/xQJmHkfC18).

-Build and run
+If your platform is not listed above, there is still a chance you can manually build it by following the instructions below.

- Using Visual Studio 2017, Rider or Visual Studio Code (configurations are included)
- From command line using `dotnet run --project osu.Desktop`. When building for non-development purposes, add `-c Release` to gain higher performance.
- To run with code analysis, instead use `powershell ./build.ps1` or `build.sh`. This is currently only supported under windows due to [resharper cli shortcomings](https://youtrack.jetbrains.com/issue/RSRP-410004). Alternative, you can install resharper or use rider to get inline support in your IDE of choice.
+## Downloading the source code

-Note: If you run from command line under linux, you will need to prefix the output folder to your `LD_LIBRARY_PATH`. See `.vscode/launch.json` for an example
+Clone the repository **including submodules**:

-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.
+```shell
+git clone --recurse-submodules https://github.com/ppy/osu
+cd osu
+```
+
+> If you forgot the `--recurse-submodules` option, run this command inside the `osu` directory:
+>
+> `git submodule update --init --recursive`
+
+To update the source code to the latest commit, run the following command inside the `osu` directory:
+
+```shell
+git pull --recurse-submodules
+```
+
+## Building
+
+Build configurations for the recommended IDEs (listed above) are included. You should use the provided Build/Run functionality of your IDE to get things going. When testing or building new components, it's highly encouraged you use the `VisualTests` project/configuration. More information on this provided below.
+
+> Visual Studio Code users must run the `Restore` task before any build attempt.
+
+You can also build and run osu! from the command-line with a single command:
+
+```shell
+dotnet run --project osu.Desktop
+```
+
+If you are not interested in debugging osu!, you can add `-c Release` to gain performance. In this case, you must replace `Debug` with `Release` in any commands mentioned in this document.
+
+If the build fails, try to restore nuget packages with `dotnet restore`.
+
+### A note for Linux users
+
+On Linux, the environment variable `LD_LIBRARY_PATH` must point to the build directory, located at `osu.Desktop/bin/Debug/$NETCORE_VERSION`.
+
+`$NETCORE_VERSION` is the version of .NET Core SDK. You can have it with `grep TargetFramework osu.Desktop/osu.Desktop.csproj | sed -r 's/.*>(.*)<\/.*/\1/'`.
+
+For example, you can run osu! with the following command:
+
+```shell
+LD_LIBRARY_PATH="$(pwd)/osu.Desktop/bin/Debug/netcoreapp2.2" dotnet run --project osu.Desktop
+```
+
+## Code analysis
+
+Code analysis can be run with `powershell ./build.ps1` or `build.sh`. This is currently only supported under windows due to [resharper cli shortcomings](https://youtrack.jetbrains.com/issue/RSRP-410004). Alternative, you can install resharper or use rider to get inline support in your IDE of choice.

 # Contributing

@@ -15,12 +15,16 @@ using Microsoft.Win32;
 using osu.Desktop.Updater;
 using osu.Framework;
 using osu.Framework.Platform.Windows;
+using osu.Framework.Screens;
+using osu.Game.Screens;
+using osu.Game.Screens.Menu;

 namespace osu.Desktop
 {
    internal class OsuGameDesktop : OsuGame
    {
        private readonly bool noVersionOverlay;
+        private VersionManager versionManager;

        public OsuGameDesktop(string[] args = null)
            : base(args)
@@ -46,7 +50,7 @@ namespace osu.Desktop

            if (!noVersionOverlay)
            {
-                LoadComponentAsync(new VersionManager { Depth = int.MinValue }, v =>
+                LoadComponentAsync(versionManager = new VersionManager { Depth = int.MinValue }, v =>
                {
                    Add(v);
                    v.State = Visibility.Visible;
@@ -59,6 +63,23 @@ namespace osu.Desktop
            }
        }

+        protected override void ScreenChanged(OsuScreen current, Screen newScreen)
+        {
+            base.ScreenChanged(current, newScreen);
+            switch (newScreen)
+            {
+                case Intro _:
+                case MainMenu _:
+                    if (versionManager != null)
+                        versionManager.State = Visibility.Visible;
+                    break;
+                default:
+                    if (versionManager != null)
+                        versionManager.State = Visibility.Hidden;
+                    break;
+            }
+        }
+
        public override void SetHost(GameHost host)
        {
            base.SetHost(host);
@@ -76,7 +97,7 @@ namespace osu.Desktop

        private void fileDrop(object sender, FileDropEventArgs e)
        {
-            var filePaths = new[] { e.FileName };
+            var filePaths = e.FileNames;

            var firstExtension = Path.GetExtension(filePaths.First());

@@ -128,11 +128,12 @@ namespace osu.Desktop.Overlays

        protected override void PopIn()
        {
-            this.FadeIn(1000);
+            this.FadeIn(1400, Easing.OutQuint);
        }

        protected override void PopOut()
        {
+            this.FadeOut(500, Easing.OutQuint);
        }
    }
 }
@@ -2,7 +2,6 @@
 // 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;
@@ -41,24 +40,32 @@ namespace osu.Desktop.Updater

        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)
+            try
            {
-                notificationOverlay.Post(new SimpleNotification
+                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)
                {
-                    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 = () =>
+                    notificationOverlay.Post(new SimpleNotification
                    {
-                        host.OpenUrlExternally(getBestUrl(latest));
-                        return true;
-                    }
-                });
+                        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;
+                        }
+                    });
+                }
+            }
+            catch
+            {
+                // we shouldn't crash on a web failure. or any failure for the matter.
            }
        }

@@ -69,10 +76,10 @@ namespace osu.Desktop.Updater
            switch (RuntimeInfo.OS)
            {
                case RuntimeInfo.Platform.Windows:
-                    bestAsset = release.Assets?.FirstOrDefault(f => f.Name.EndsWith(".exe"));
+                    bestAsset = release.Assets?.Find(f => f.Name.EndsWith(".exe"));
                    break;
                case RuntimeInfo.Platform.MacOsx:
-                    bestAsset = release.Assets?.FirstOrDefault(f => f.Name.EndsWith(".app.zip"));
+                    bestAsset = release.Assets?.Find(f => f.Name.EndsWith(".app.zip"));
                    break;
            }

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
  <Import Project="..\osu.Game.props" />
  <PropertyGroup Label="Project">
-    <TargetFramework>netcoreapp2.1</TargetFramework>
+    <TargetFramework>netcoreapp2.2</TargetFramework>
    <OutputType>WinExe</OutputType>
    <PlatformTarget>AnyCPU</PlatformTarget>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
@@ -28,8 +28,8 @@
  <ItemGroup Label="Package References">
    <PackageReference Include="System.IO.Packaging" Version="4.5.0" />
    <PackageReference Include="ppy.squirrel.windows" Version="1.9.0.3" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.1.4" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.1" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.2.1" />
  </ItemGroup>
  <ItemGroup Label="Resources">
    <EmbeddedResource Include="lazer.ico" />
@@ -7,7 +7,7 @@
            "request": "launch",
            "program": "dotnet",
            "args": [
-                "${workspaceRoot}/bin/Debug/netcoreapp2.1/osu.Game.Rulesets.Catch.Tests.dll"
+                "${workspaceRoot}/bin/Debug/netcoreapp2.2/osu.Game.Rulesets.Catch.Tests.dll"
            ],
            "cwd": "${workspaceRoot}",
            "preLaunchTask": "Build (Debug)",
@@ -20,7 +20,7 @@
            "request": "launch",
            "program": "dotnet",
            "args": [
-                "${workspaceRoot}/bin/Release/netcoreapp2.1/osu.Game.Rulesets.Catch.Tests.dll"
+                "${workspaceRoot}/bin/Release/netcoreapp2.2/osu.Game.Rulesets.Catch.Tests.dll"
            ],
            "cwd": "${workspaceRoot}",
            "preLaunchTask": "Build (Release)",
@@ -26,7 +26,6 @@ namespace osu.Game.Rulesets.Catch.Tests
                }
            };

-
            for (int i = 0; i < 512; i++)
                beatmap.HitObjects.Add(new Fruit { X = 0.5f + i / 2048f * (i % 10 - 5), StartTime = i * 100, NewCombo = i % 8 == 0 });

@@ -19,7 +19,6 @@ namespace osu.Game.Rulesets.Catch.Tests
        {
            var beatmap = new Beatmap { BeatmapInfo = { Ruleset = ruleset.RulesetInfo } };

-
            for (int i = 0; i < 512; i++)
                if (i % 5 < 3)
                    beatmap.HitObjects.Add(new Fruit { X = i % 10 < 5 ? 0.02f : 0.98f, StartTime = i * 100, NewCombo = i % 8 == 0 });
@@ -4,12 +4,12 @@
    <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
    <PackageReference Include="NUnit" Version="3.11.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.11.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.12.0" />
    <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
  </ItemGroup>
  <PropertyGroup Label="Project">
    <OutputType>WinExe</OutputType>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
+    <TargetFramework>netcoreapp2.2</TargetFramework>
  </PropertyGroup>
  <ItemGroup Label="Project References">
    <ProjectReference Include="..\osu.Game.Rulesets.Catch\osu.Game.Rulesets.Catch.csproj" />
@@ -14,7 +14,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 {
    public class CatchDifficultyCalculator : DifficultyCalculator
    {
-
        /// <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.
@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Catch.Judgements
            }
        }

-        protected override float HealthIncreaseFor(HitResult result)
+        protected override double HealthIncreaseFor(HitResult result)
        {
            switch (result)
            {
@@ -18,7 +18,7 @@ namespace osu.Game.Rulesets.Catch.Judgements
            }
        }

-        protected override float HealthIncreaseFor(HitResult result)
+        protected override double HealthIncreaseFor(HitResult result)
        {
            switch (result)
            {
@@ -22,29 +22,17 @@ namespace osu.Game.Rulesets.Catch.Judgements
            }
        }

-        /// <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)
+        protected override double HealthIncreaseFor(HitResult result)
        {
            switch (result)
            {
                default:
                    return 0;
                case HitResult.Perfect:
-                    return 10.2f;
+                    return 10.2;
            }
        }

-        /// <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" />
@@ -20,7 +20,7 @@ namespace osu.Game.Rulesets.Catch.Judgements
            }
        }

-        protected override float HealthIncreaseFor(HitResult result)
+        protected override double HealthIncreaseFor(HitResult result)
        {
            switch (result)
            {
@@ -5,20 +5,17 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
 using osu.Game.Users;

 namespace osu.Game.Rulesets.Catch.Mods
 {
    public class CatchModAutoplay : ModAutoplay<CatchHitObject>
    {
-        protected override Score CreateReplayScore(Beatmap<CatchHitObject> beatmap)
+        protected override Score CreateReplayScore(Beatmap<CatchHitObject> beatmap) => new Score
        {
-            return new Score
-            {
-                User = new User { Username = "osu!salad!" },
-                Replay = new CatchAutoGenerator(beatmap).Generate(),
-            };
-        }
+            ScoreInfo = new ScoreInfo { User = new User { Username = "osu!salad!" } },
+            Replay = new CatchAutoGenerator(beatmap).Generate(),
+        };
    }
 }
@@ -0,0 +1,23 @@
+// 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.Objects;
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Catch.Objects
+{
+    public class CatchHitWindows : HitWindows
+    {
+        public override bool IsHitResultAllowed(HitResult result)
+        {
+            switch (result)
+            {
+                case HitResult.Perfect:
+                case HitResult.Miss:
+                    return true;
+            }
+
+            return false;
+        }
+    }
+}
@@ -65,7 +65,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
            base.SkinChanged(skin, allowFallback);

            if (HitObject is IHasComboInformation combo)
-                AccentColour = skin.GetValue<SkinConfiguration, Color4>(s => s.ComboColours.Count > 0 ? s.ComboColours[combo.ComboIndex % s.ComboColours.Count] : (Color4?)null) ?? Color4.White;
+                AccentColour = skin.GetValue<SkinConfiguration, Color4>(s => s.ComboColours.Count > 0 ? s.ComboColours[combo.ComboIndex % s.ComboColours.Count] : Color4.White);
        }

        private const float preempt = 1000;
@@ -40,7 +40,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
        private void load()
        {
            // todo: this should come from the skin.
-            AccentColour = colourForRrepesentation(HitObject.VisualRepresentation);
+            AccentColour = colourForRepresentation(HitObject.VisualRepresentation);

            InternalChildren = new[]
            {
@@ -275,7 +275,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
            border.Alpha = (float)MathHelper.Clamp((HitObject.StartTime - Time.Current) / 500, 0, 1);
        }

-        private Color4 colourForRrepesentation(FruitVisualRepresentation representation)
+        private Color4 colourForRepresentation(FruitVisualRepresentation representation)
        {
            switch (representation)
            {
@@ -5,10 +5,10 @@ using System;
 using System.Linq;
 using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
+using osu.Game.Replays;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Replays;
-using osu.Game.Users;

 namespace osu.Game.Rulesets.Catch.Replays
 {
@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Catch.Replays
        public CatchAutoGenerator(Beatmap<CatchHitObject> beatmap)
            : base(beatmap)
        {
-            Replay = new Replay { User = new User { Username = @"Autoplay" } };
+            Replay = new Replay();
        }

        protected Replay Replay;
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using osu.Framework.Input.StateChanges;
 using osu.Framework.MathUtils;
+using osu.Game.Replays;
 using osu.Game.Rulesets.Replays;

 namespace osu.Game.Rulesets.Catch.Replays
@@ -2,9 +2,9 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

 using osu.Game.Beatmaps;
+using osu.Game.Replays.Legacy;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Replays;
-using osu.Game.Rulesets.Replays.Legacy;
 using osu.Game.Rulesets.Replays.Types;

 namespace osu.Game.Rulesets.Catch.Replays
@@ -3,9 +3,9 @@

 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.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;

@@ -40,8 +40,9 @@ namespace osu.Game.Rulesets.Catch.Scoring
                return;
            }

-            if (result.Judgement is CatchJudgement catchJudgement)
-                Health.Value += Math.Max(catchJudgement.HealthIncreaseFor(result) - hpDrainRate, 0) * harshness;
+            Health.Value += Math.Max(result.Judgement.HealthIncreaseFor(result) - hpDrainRate, 0) * harshness;
        }
+
+        protected override HitWindows CreateHitWindows() => new CatchHitWindows();
    }
 }
@@ -5,12 +5,12 @@ using osu.Framework.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Input.Handlers;
+using osu.Game.Replays;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Catch.Scoring;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
@@ -7,7 +7,7 @@
            "request": "launch",
            "program": "dotnet",
            "args": [
-                "${workspaceRoot}/bin/Debug/netcoreapp2.1/osu.Game.Rulesets.Mania.Tests.dll"
+                "${workspaceRoot}/bin/Debug/netcoreapp2.2/osu.Game.Rulesets.Mania.Tests.dll"
            ],
            "cwd": "${workspaceRoot}",
            "preLaunchTask": "Build (Debug)",
@@ -20,7 +20,7 @@
            "request": "launch",
            "program": "dotnet",
            "args": [
-                "${workspaceRoot}/bin/Release/netcoreapp2.1/osu.Game.Rulesets.Mania.Tests.dll"
+                "${workspaceRoot}/bin/Release/netcoreapp2.2/osu.Game.Rulesets.Mania.Tests.dll"
            ],
            "cwd": "${workspaceRoot}",
            "preLaunchTask": "Build (Release)",
@@ -0,0 +1,52 @@
+// 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.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Timing;
+using osu.Game.Rulesets.Mania.Edit;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Tests.Visual;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [Cached(Type = typeof(IManiaHitObjectComposer))]
+    public abstract class ManiaPlacementBlueprintTestCase : PlacementBlueprintTestCase, IManiaHitObjectComposer
+    {
+        private readonly Column column;
+
+        protected ManiaPlacementBlueprintTestCase()
+        {
+            Add(column = new Column(0)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                AccentColour = Color4.OrangeRed,
+                Clock = new FramedClock(new StopwatchClock()), // No scroll
+            });
+        }
+
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+        {
+            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
+
+            dependencies.CacheAs(((ScrollingTestContainer)HitObjectContainer).ScrollingInfo);
+
+            return dependencies;
+        }
+
+        protected override Container CreateHitObjectContainer() => new ScrollingTestContainer(ScrollingDirection.Down) { RelativeSizeAxes = Axes.Both };
+
+        protected override void AddHitObject(DrawableHitObject hitObject) => column.Add((DrawableManiaHitObject)hitObject);
+
+        public Column ColumnAt(Vector2 screenSpacePosition) => column;
+
+        public int TotalColumns => 1;
+    }
+}
@@ -0,0 +1,38 @@
+// 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.Graphics;
+using osu.Framework.Timing;
+using osu.Game.Rulesets.Mania.Edit;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Tests.Visual;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [Cached(Type = typeof(IManiaHitObjectComposer))]
+    public abstract class ManiaSelectionBlueprintTestCase : SelectionBlueprintTestCase, IManiaHitObjectComposer
+    {
+        [Cached(Type = typeof(IAdjustableClock))]
+        private readonly IAdjustableClock clock = new StopwatchClock();
+
+        private readonly Column column;
+
+        protected ManiaSelectionBlueprintTestCase()
+        {
+            Add(column = new Column(0)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                AccentColour = Color4.OrangeRed,
+                Clock = new FramedClock(new StopwatchClock()), // No scroll
+            });
+        }
+
+        public Column ColumnAt(Vector2 screenSpacePosition) => column;
+
+        public int TotalColumns => 1;
+    }
+}
@@ -49,8 +49,8 @@ namespace osu.Game.Rulesets.Mania.Tests
                Spacing = new Vector2(20, 0),
                Children = new[]
                {
-                    createColumn(ScrollingDirection.Up, ManiaAction.Key1),
-                    createColumn(ScrollingDirection.Down, ManiaAction.Key2)
+                    createColumn(ScrollingDirection.Up, ManiaAction.Key1, 0),
+                    createColumn(ScrollingDirection.Down, ManiaAction.Key2, 1)
                }
            };
        }
@@ -85,9 +85,9 @@ namespace osu.Game.Rulesets.Mania.Tests
            }
        }

-        private Drawable createColumn(ScrollingDirection direction, ManiaAction action)
+        private Drawable createColumn(ScrollingDirection direction, ManiaAction action, int index)
        {
-            var column = new Column
+            var column = new Column(index)
            {
                Anchor = Anchor.Centre,
                Origin = Anchor.Centre,
@@ -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.Edit;
+using osu.Game.Rulesets.Mania.Edit.Blueprints;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public class TestCaseHoldNotePlacementBlueprint : ManiaPlacementBlueprintTestCase
+    {
+        protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableHoldNote((HoldNote)hitObject);
+        protected override PlacementBlueprint CreateBlueprint() => new HoldNotePlacementBlueprint();
+    }
+}
@@ -15,7 +15,7 @@ using osu.Game.Tests.Visual;

 namespace osu.Game.Rulesets.Mania.Tests
 {
-    public class TestCaseHoldNoteSelectionBlueprint : SelectionBlueprintTestCase
+    public class TestCaseHoldNoteSelectionBlueprint : ManiaSelectionBlueprintTestCase
    {
        private readonly DrawableHoldNote drawableObject;

@@ -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.Edit;
+using osu.Game.Rulesets.Mania.Edit.Blueprints;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public class TestCaseNotePlacementBlueprint : ManiaPlacementBlueprintTestCase
+    {
+        protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableNote((Note)hitObject);
+        protected override PlacementBlueprint CreateBlueprint() => new NotePlacementBlueprint();
+    }
+}
@@ -15,7 +15,7 @@ using osuTK;

 namespace osu.Game.Rulesets.Mania.Tests
 {
-    public class TestCaseNoteSelectionBlueprint : SelectionBlueprintTestCase
+    public class TestCaseNoteSelectionBlueprint : ManiaSelectionBlueprintTestCase
    {
        private readonly DrawableNote drawableObject;

@@ -4,12 +4,12 @@
    <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
    <PackageReference Include="NUnit" Version="3.11.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.11.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.12.0" />
    <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
  </ItemGroup>
  <PropertyGroup Label="Project">
    <OutputType>WinExe</OutputType>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
+    <TargetFramework>netcoreapp2.2</TargetFramework>
  </PropertyGroup>
  <ItemGroup Label="Project References">
    <ProjectReference Include="..\osu.Game.Rulesets.Mania\osu.Game.Rulesets.Mania.csproj" />
@@ -180,7 +180,6 @@ namespace osu.Game.Rulesets.Mania.Beatmaps

                foreach (var obj in newPattern.HitObjects)
                    yield return obj;
-
            }
        }

@@ -53,7 +53,6 @@ namespace osu.Game.Rulesets.Mania.Difficulty
            if (!calculateStrainValues(difficultyHitObjects, timeRate))
                return new DifficultyAttributes(mods, 0);

-
            double starRating = calculateDifficulty(difficultyHitObjects, timeRate) * star_scaling_factor;

            return new ManiaDifficultyAttributes(mods, starRating)
@@ -8,6 +8,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;

 namespace osu.Game.Rulesets.Mania.Difficulty
 {
@@ -27,7 +28,7 @@ namespace osu.Game.Rulesets.Mania.Difficulty
        private int countMeh;
        private int countMiss;

-        public ManiaPerformanceCalculator(Ruleset ruleset, WorkingBeatmap beatmap, Score score)
+        public ManiaPerformanceCalculator(Ruleset ruleset, WorkingBeatmap beatmap, ScoreInfo score)
            : base(ruleset, beatmap, score)
        {
        }
@@ -0,0 +1,21 @@
+// 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.Mania.Objects.Drawables.Pieces;
+
+namespace osu.Game.Rulesets.Mania.Edit.Blueprints.Components
+{
+    public class EditBodyPiece : BodyPiece
+    {
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            AccentColour = colours.Yellow;
+
+            Background.Alpha = 0.5f;
+            Foreground.Alpha = 0;
+        }
+    }
+}
@@ -0,0 +1,74 @@
+// 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.Framework.Graphics;
+using osu.Framework.Input.Events;
+using osu.Game.Rulesets.Mania.Edit.Blueprints.Components;
+using osu.Game.Rulesets.Mania.Objects;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Edit.Blueprints
+{
+    public class HoldNotePlacementBlueprint : ManiaPlacementBlueprint<HoldNote>
+    {
+        private readonly EditBodyPiece bodyPiece;
+        private readonly EditNotePiece headPiece;
+        private readonly EditNotePiece tailPiece;
+
+        public HoldNotePlacementBlueprint()
+            : base(new HoldNote())
+        {
+            RelativeSizeAxes = Axes.Both;
+
+            InternalChildren = new Drawable[]
+            {
+                bodyPiece = new EditBodyPiece { Origin = Anchor.TopCentre },
+                headPiece = new EditNotePiece { Origin = Anchor.Centre },
+                tailPiece = new EditNotePiece { Origin = Anchor.Centre }
+            };
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (Column != null)
+            {
+                headPiece.Y = PositionAt(HitObject.StartTime);
+                tailPiece.Y = PositionAt(HitObject.EndTime);
+            }
+
+            var topPosition = new Vector2(headPiece.DrawPosition.X, Math.Min(headPiece.DrawPosition.Y, tailPiece.DrawPosition.Y));
+            var bottomPosition = new Vector2(headPiece.DrawPosition.X, Math.Max(headPiece.DrawPosition.Y, tailPiece.DrawPosition.Y));
+
+            bodyPiece.Position = topPosition;
+            bodyPiece.Width = headPiece.Width;
+            bodyPiece.Height = (bottomPosition - topPosition).Y;
+        }
+
+        private double originalStartTime;
+
+        protected override bool OnMouseMove(MouseMoveEvent e)
+        {
+            base.OnMouseMove(e);
+
+            if (PlacementBegun)
+            {
+                var endTime = TimeAt(e.ScreenSpaceMousePosition);
+
+                HitObject.StartTime = endTime < originalStartTime ? endTime : originalStartTime;
+                HitObject.Duration = Math.Abs(endTime - originalStartTime);
+            }
+            else
+            {
+                headPiece.Width = tailPiece.Width = SnappedWidth;
+                headPiece.X = tailPiece.X = SnappedMousePosition.X;
+
+                originalStartTime = HitObject.StartTime = TimeAt(e.ScreenSpaceMousePosition);
+            }
+
+            return true;
+        }
+    }
+}
@@ -49,7 +49,6 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
            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),
@@ -0,0 +1,118 @@
+// 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.Graphics;
+using osu.Framework.Input;
+using osu.Framework.Input.Events;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.UI.Scrolling;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Edit.Blueprints
+{
+    public abstract class ManiaPlacementBlueprint<T> : PlacementBlueprint,
+                                                       IRequireHighFrequencyMousePosition // the playfield could be moving behind us
+        where T : ManiaHitObject
+    {
+        protected new T HitObject => (T)base.HitObject;
+
+        protected Column Column;
+
+        /// <summary>
+        /// The current mouse position, snapped to the closest column.
+        /// </summary>
+        protected Vector2 SnappedMousePosition { get; private set; }
+
+        /// <summary>
+        /// The width of the closest column to the current mouse position.
+        /// </summary>
+        protected float SnappedWidth { get; private set; }
+
+        [Resolved]
+        private IManiaHitObjectComposer composer { get; set; }
+
+        [Resolved]
+        private IScrollingInfo scrollingInfo { get; set; }
+
+        protected ManiaPlacementBlueprint(T hitObject)
+            : base(hitObject)
+        {
+            RelativeSizeAxes = Axes.None;
+        }
+
+        protected override bool OnMouseDown(MouseDownEvent e)
+        {
+            if (Column == null)
+                return base.OnMouseDown(e);
+
+            HitObject.StartTime = TimeAt(e.ScreenSpaceMousePosition);
+            HitObject.Column = Column.Index;
+
+            BeginPlacement();
+            return true;
+        }
+
+        protected override bool OnMouseUp(MouseUpEvent e)
+        {
+            EndPlacement();
+            return base.OnMouseUp(e);
+        }
+
+        protected override bool OnMouseMove(MouseMoveEvent e)
+        {
+            if (!PlacementBegun)
+                Column = ColumnAt(e.ScreenSpaceMousePosition);
+
+            if (Column == null) return false;
+
+            SnappedWidth = Column.DrawWidth;
+
+            // Snap to the column
+            var parentPos = Parent.ToLocalSpace(Column.ToScreenSpace(new Vector2(Column.DrawWidth / 2, 0)));
+            SnappedMousePosition = new Vector2(parentPos.X, e.MousePosition.Y);
+            return true;
+        }
+
+        protected double TimeAt(Vector2 screenSpacePosition)
+        {
+            if (Column == null)
+                return 0;
+
+            var hitObjectContainer = Column.HitObjectContainer;
+
+            // If we're scrolling downwards, a position of 0 is actually further away from the hit target
+            // so we need to flip the vertical coordinate in the hitobject container's space
+            var hitObjectPos = Column.HitObjectContainer.ToLocalSpace(applyPositionOffset(screenSpacePosition, false)).Y;
+            if (scrollingInfo.Direction.Value == ScrollingDirection.Down)
+                hitObjectPos = hitObjectContainer.DrawHeight - hitObjectPos;
+
+            return scrollingInfo.Algorithm.TimeAt(hitObjectPos,
+                EditorClock.CurrentTime,
+                scrollingInfo.TimeRange.Value,
+                hitObjectContainer.DrawHeight);
+        }
+
+        protected float PositionAt(double time)
+        {
+            var pos = scrollingInfo.Algorithm.PositionAt(time,
+                EditorClock.CurrentTime,
+                scrollingInfo.TimeRange.Value,
+                Column.HitObjectContainer.DrawHeight);
+
+            return applyPositionOffset(Column.HitObjectContainer.ToSpaceOfOtherDrawable(new Vector2(0, pos), Parent), true).Y;
+        }
+
+        protected Column ColumnAt(Vector2 screenSpacePosition)
+            => composer.ColumnAt(applyPositionOffset(screenSpacePosition, false));
+
+        private Vector2 applyPositionOffset(Vector2 position, bool reverse)
+        {
+            position.Y += (scrollingInfo.Direction.Value == ScrollingDirection.Up && !reverse ? -1 : 1) * NotePiece.NOTE_HEIGHT / 2;
+            return position;
+        }
+    }
+}
@@ -1,23 +1,80 @@
 // 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.Graphics;
 using osu.Framework.Input.Events;
+using osu.Framework.Timing;
 using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI.Scrolling;
+using osuTK;

 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
    public class ManiaSelectionBlueprint : SelectionBlueprint
    {
+        public Vector2 ScreenSpaceDragPosition { get; private set; }
+        public Vector2 DragPosition { get; private set; }
+
+        protected new DrawableManiaHitObject HitObject => (DrawableManiaHitObject)base.HitObject;
+
+        protected IClock EditorClock { get; private set; }
+
+        [Resolved]
+        private IScrollingInfo scrollingInfo { get; set; }
+
+        [Resolved]
+        private IManiaHitObjectComposer composer { get; set; }
+
        public ManiaSelectionBlueprint(DrawableHitObject hitObject)
            : base(hitObject)
        {
            RelativeSizeAxes = Axes.None;
        }

-        public override void AdjustPosition(DragEvent dragEvent)
+        [BackgroundDependencyLoader]
+        private void load(IAdjustableClock clock)
        {
+            EditorClock = clock;
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            Position = Parent.ToLocalSpace(HitObject.ToScreenSpace(Vector2.Zero));
+        }
+
+        protected override bool OnMouseDown(MouseDownEvent e)
+        {
+            ScreenSpaceDragPosition = e.ScreenSpaceMousePosition;
+            DragPosition = HitObject.ToLocalSpace(e.ScreenSpaceMousePosition);
+
+            return base.OnMouseDown(e);
+        }
+
+        protected override bool OnDrag(DragEvent e)
+        {
+            var result = base.OnDrag(e);
+
+            ScreenSpaceDragPosition = e.ScreenSpaceMousePosition;
+            DragPosition = HitObject.ToLocalSpace(e.ScreenSpaceMousePosition);
+
+            return result;
+        }
+
+        public override void Show()
+        {
+            HitObject.AlwaysAlive = true;
+            base.Show();
+        }
+
+        public override void Hide()
+        {
+            HitObject.AlwaysAlive = false;
+            base.Hide();
        }
    }
 }
@@ -0,0 +1,30 @@
+// 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.Game.Rulesets.Mania.Edit.Blueprints.Components;
+using osu.Game.Rulesets.Mania.Objects;
+
+namespace osu.Game.Rulesets.Mania.Edit.Blueprints
+{
+    public class NotePlacementBlueprint : ManiaPlacementBlueprint<Note>
+    {
+        public NotePlacementBlueprint()
+            : base(new Note())
+        {
+            Origin = Anchor.Centre;
+
+            AutoSizeAxes = Axes.Y;
+
+            InternalChild = new EditNotePiece { RelativeSizeAxes = Axes.X };
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            Width = SnappedWidth;
+            Position = SnappedMousePosition;
+        }
+    }
+}
@@ -20,7 +20,6 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
            base.Update();

            Size = HitObject.DrawSize;
-            Position = Parent.ToLocalSpace(HitObject.ScreenSpaceDrawQuad.TopLeft);
        }
    }
 }
@@ -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.Edit;
+using osu.Game.Rulesets.Edit.Tools;
+using osu.Game.Rulesets.Mania.Edit.Blueprints;
+
+namespace osu.Game.Rulesets.Mania.Edit
+{
+    public class HoldNoteCompositionTool : HitObjectCompositionTool
+    {
+        public HoldNoteCompositionTool()
+            : base("Hold")
+        {
+        }
+
+        public override PlacementBlueprint CreatePlacementBlueprint() => new HoldNotePlacementBlueprint();
+    }
+}
@@ -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.Mania.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Edit
+{
+    public interface IManiaHitObjectComposer
+    {
+        Column ColumnAt(Vector2 screenSpacePosition);
+
+        int TotalColumns { get; }
+    }
+}
@@ -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 System;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
@@ -11,33 +10,54 @@ using osu.Game.Rulesets.Objects.Drawables;
 using System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Game.Rulesets.Mania.Edit.Blueprints;
+using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Edit.Compose.Components;
+using osuTK;

 namespace osu.Game.Rulesets.Mania.Edit
 {
-    public class ManiaHitObjectComposer : HitObjectComposer<ManiaHitObject>
+    [Cached(Type = typeof(IManiaHitObjectComposer))]
+    public class ManiaHitObjectComposer : HitObjectComposer<ManiaHitObject>, IManiaHitObjectComposer
    {
+        protected new ManiaEditRulesetContainer RulesetContainer { get; private set; }
+
        public ManiaHitObjectComposer(Ruleset ruleset)
            : base(ruleset)
        {
        }

+        /// <summary>
+        /// Retrieves the column that intersects a screen-space position.
+        /// </summary>
+        /// <param name="screenSpacePosition">The screen-space position.</param>
+        /// <returns>The column which intersects with <paramref name="screenSpacePosition"/>.</returns>
+        public Column ColumnAt(Vector2 screenSpacePosition) => RulesetContainer.GetColumnByPosition(screenSpacePosition);
+
        private DependencyContainer dependencies;

        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
            => dependencies = new DependencyContainer(base.CreateChildDependencies(parent));

+        public int TotalColumns => ((ManiaPlayfield)RulesetContainer.Playfield).TotalColumns;
+
        protected override RulesetContainer<ManiaHitObject> CreateRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
        {
-            var rulesetContainer = new ManiaEditRulesetContainer(ruleset, beatmap);
+            RulesetContainer = new ManiaEditRulesetContainer(ruleset, beatmap);

            // This is the earliest we can cache the scrolling info to ourselves, before masks are added to the hierarchy and inject it
-            dependencies.CacheAs(rulesetContainer.ScrollingInfo);
+            dependencies.CacheAs(RulesetContainer.ScrollingInfo);

-            return rulesetContainer;
+            return RulesetContainer;
        }

-        protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => Array.Empty<HitObjectCompositionTool>();
+        protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
+        {
+            new NoteCompositionTool(),
+            new HoldNoteCompositionTool()
+        };
+
+        public override SelectionHandler CreateSelectionHandler() => new ManiaSelectionHandler();

        public override SelectionBlueprint CreateBlueprintFor(DrawableHitObject hitObject)
        {
@@ -0,0 +1,125 @@
+// 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 osu.Framework.Allocation;
+using osu.Framework.Input.Events;
+using osu.Framework.Timing;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mania.Edit.Blueprints;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.UI;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Screens.Edit.Compose.Components;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Edit
+{
+    public class ManiaSelectionHandler : SelectionHandler
+    {
+        [Resolved]
+        private IScrollingInfo scrollingInfo { get; set; }
+
+        [Resolved]
+        private IManiaHitObjectComposer composer { get; set; }
+
+        private IClock editorClock;
+
+        [BackgroundDependencyLoader]
+        private void load(IAdjustableClock clock)
+        {
+            editorClock = clock;
+        }
+
+        public override void HandleDrag(SelectionBlueprint blueprint, DragEvent dragEvent)
+        {
+            adjustOrigins((ManiaSelectionBlueprint)blueprint);
+            performDragMovement(dragEvent);
+            performColumnMovement(dragEvent);
+
+            base.HandleDrag(blueprint, dragEvent);
+        }
+
+        /// <summary>
+        /// Ensures that the position of hitobjects remains centred to the mouse position.
+        /// E.g. The hitobject position will change if the editor scrolls while a hitobject is dragged.
+        /// </summary>
+        /// <param name="reference">The <see cref="ManiaSelectionBlueprint"/> that received the drag event.</param>
+        private void adjustOrigins(ManiaSelectionBlueprint reference)
+        {
+            var referenceParent = (HitObjectContainer)reference.HitObject.Parent;
+
+            float offsetFromReferenceOrigin = reference.DragPosition.Y - reference.HitObject.OriginPosition.Y;
+            float targetPosition = referenceParent.ToLocalSpace(reference.ScreenSpaceDragPosition).Y - offsetFromReferenceOrigin;
+
+            // Flip the vertical coordinate space when scrolling downwards
+            if (scrollingInfo.Direction.Value == ScrollingDirection.Down)
+                targetPosition = targetPosition - referenceParent.DrawHeight;
+
+            float movementDelta = targetPosition - reference.HitObject.Position.Y;
+
+            foreach (var b in SelectedBlueprints.OfType<ManiaSelectionBlueprint>())
+                b.HitObject.Y += movementDelta;
+        }
+
+        private void performDragMovement(DragEvent dragEvent)
+        {
+            foreach (var b in SelectedBlueprints)
+            {
+                var hitObject = b.HitObject;
+
+                var objectParent = (HitObjectContainer)hitObject.Parent;
+
+                // Using the hitobject position is required since AdjustPosition can be invoked multiple times per frame
+                // without the position having been updated by the parenting ScrollingHitObjectContainer
+                hitObject.Y += dragEvent.Delta.Y;
+
+                float targetPosition;
+
+                // If we're scrolling downwards, a position of 0 is actually further away from the hit target
+                // so we need to flip the vertical coordinate in the hitobject container's space
+                if (scrollingInfo.Direction.Value == ScrollingDirection.Down)
+                    targetPosition = -hitObject.Position.Y;
+                else
+                    targetPosition = hitObject.Position.Y;
+
+                objectParent.Remove(hitObject);
+
+                hitObject.HitObject.StartTime = scrollingInfo.Algorithm.TimeAt(targetPosition,
+                    editorClock.CurrentTime,
+                    scrollingInfo.TimeRange.Value,
+                    objectParent.DrawHeight);
+
+                objectParent.Add(hitObject);
+            }
+        }
+
+        private void performColumnMovement(DragEvent dragEvent)
+        {
+            var lastColumn = composer.ColumnAt(dragEvent.ScreenSpaceLastMousePosition);
+            var currentColumn = composer.ColumnAt(dragEvent.ScreenSpaceMousePosition);
+            if (lastColumn == null || currentColumn == null)
+                return;
+
+            int columnDelta = currentColumn.Index - lastColumn.Index;
+            if (columnDelta == 0)
+                return;
+
+            int minColumn = int.MaxValue;
+            int maxColumn = int.MinValue;
+
+            foreach (var obj in SelectedHitObjects.OfType<ManiaHitObject>())
+            {
+                if (obj.Column < minColumn)
+                    minColumn = obj.Column;
+                if (obj.Column > maxColumn)
+                    maxColumn = obj.Column;
+            }
+
+            columnDelta = MathHelper.Clamp(columnDelta, -minColumn, composer.TotalColumns - 1 - maxColumn);
+
+            foreach (var obj in SelectedHitObjects.OfType<ManiaHitObject>())
+                obj.Column += columnDelta;
+        }
+    }
+}
@@ -0,0 +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 osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Tools;
+using osu.Game.Rulesets.Mania.Edit.Blueprints;
+using osu.Game.Rulesets.Mania.Objects;
+
+namespace osu.Game.Rulesets.Mania.Edit
+{
+    public class NoteCompositionTool : HitObjectCompositionTool
+    {
+        public NoteCompositionTool()
+            : base(nameof(Note))
+        {
+        }
+
+        public override PlacementBlueprint CreatePlacementBlueprint() => new NotePlacementBlueprint();
+    }
+}
@@ -24,7 +24,7 @@ using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.Difficulty;
 using osu.Game.Rulesets.Mania.Edit;
-using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;

 namespace osu.Game.Rulesets.Mania
 {
@@ -32,7 +32,7 @@ namespace osu.Game.Rulesets.Mania
    {
        public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap) => new ManiaRulesetContainer(this, beatmap);
        public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new ManiaBeatmapConverter(beatmap);
-        public override PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, Score score) => new ManiaPerformanceCalculator(this, beatmap, score);
+        public override PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, ScoreInfo score) => new ManiaPerformanceCalculator(this, beatmap, score);

        public override HitObjectComposer CreateHitObjectComposer() => new ManiaHitObjectComposer(this);

@@ -11,7 +11,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 {
    public abstract class ManiaKeyMod : Mod, IApplicableToBeatmapConverter
    {
-        public override string ShortenedName => Name;
+        public override string Acronym => Name;
        public abstract int KeyCount { get; }
        public override ModType Type => ModType.Conversion;
        public override double ScoreMultiplier => 1; // TODO: Implement the mania key mod score multiplier
@@ -6,20 +6,17 @@ using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Replays;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
 using osu.Game.Users;

 namespace osu.Game.Rulesets.Mania.Mods
 {
    public class ManiaModAutoplay : ModAutoplay<ManiaHitObject>
    {
-        protected override Score CreateReplayScore(Beatmap<ManiaHitObject> beatmap)
+        protected override Score CreateReplayScore(Beatmap<ManiaHitObject> beatmap) => new Score
        {
-            return new Score
-            {
-                User = new User { Username = "osu!topus!" },
-                Replay = new ManiaAutoGenerator((ManiaBeatmap)beatmap).Generate(),
-            };
-        }
+            ScoreInfo = new ScoreInfo { User = new User { Username = "osu!topus!" } },
+            Replay = new ManiaAutoGenerator((ManiaBeatmap)beatmap).Generate(),
+        };
    }
 }
@@ -12,7 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
    public class ManiaModDualStages : Mod, IPlayfieldTypeMod, IApplicableToBeatmapConverter, IApplicableToBeatmap<ManiaHitObject>
    {
        public override string Name => "Dual Stages";
-        public override string ShortenedName => "DS";
+        public override string Acronym => "DS";
        public override string Description => @"Double the stages, double the fun!";
        public override ModType Type => ModType.Conversion;
        public override double ScoreMultiplier => 1;
@@ -11,7 +11,7 @@ namespace osu.Game.Rulesets.Mania.Mods
    public class ManiaModFadeIn : Mod
    {
        public override string Name => "Fade In";
-        public override string ShortenedName => "FI";
+        public override string Acronym => "FI";
        public override FontAwesome Icon => FontAwesome.fa_osu_mod_hidden;
        public override ModType Type => ModType.DifficultyIncrease;
        public override string Description => @"Keys appear out of nowhere!";
@@ -7,7 +7,7 @@ namespace osu.Game.Rulesets.Mania.Mods
    {
        public override int KeyCount => 1;
        public override string Name => "One Key";
-        public override string ShortenedName => "1K";
+        public override string Acronym => "1K";
        public override string Description => @"Play with one key.";
    }
 }
@@ -7,7 +7,7 @@ namespace osu.Game.Rulesets.Mania.Mods
    {
        public override int KeyCount => 2;
        public override string Name => "Two Keys";
-        public override string ShortenedName => "2K";
+        public override string Acronym => "2K";
        public override string Description => @"Play with two keys.";
    }
 }
@@ -7,7 +7,7 @@ namespace osu.Game.Rulesets.Mania.Mods
    {
        public override int KeyCount => 3;
        public override string Name => "Three Keys";
-        public override string ShortenedName => "3K";
+        public override string Acronym => "3K";
        public override string Description => @"Play with three keys.";
    }
 }
@@ -7,7 +7,7 @@ namespace osu.Game.Rulesets.Mania.Mods
    {
        public override int KeyCount => 4;
        public override string Name => "Four Keys";
-        public override string ShortenedName => "4K";
+        public override string Acronym => "4K";
        public override string Description => @"Play with four keys.";
    }
 }
@@ -7,7 +7,7 @@ namespace osu.Game.Rulesets.Mania.Mods
    {
        public override int KeyCount => 5;
        public override string Name => "Five Keys";
-        public override string ShortenedName => "5K";
+        public override string Acronym => "5K";
        public override string Description => @"Play with five keys.";
    }
 }
@@ -7,7 +7,7 @@ namespace osu.Game.Rulesets.Mania.Mods
    {
        public override int KeyCount => 6;
        public override string Name => "Six Keys";
-        public override string ShortenedName => "6K";
+        public override string Acronym => "6K";
        public override string Description => @"Play with six keys.";
    }
 }
@@ -7,7 +7,7 @@ namespace osu.Game.Rulesets.Mania.Mods
    {
        public override int KeyCount => 7;
        public override string Name => "Seven Keys";
-        public override string ShortenedName => "7K";
+        public override string Acronym => "7K";
        public override string Description => @"Play with seven keys.";
    }
 }
@@ -7,7 +7,7 @@ namespace osu.Game.Rulesets.Mania.Mods
    {
        public override int KeyCount => 8;
        public override string Name => "Eight Keys";
-        public override string ShortenedName => "8K";
+        public override string Acronym => "8K";
        public override string Description => @"Play with eight keys.";
    }
 }
@@ -7,7 +7,7 @@ namespace osu.Game.Rulesets.Mania.Mods
    {
        public override int KeyCount => 9;
        public override string Name => "Nine Keys";
-        public override string ShortenedName => "9K";
+        public override string Acronym => "9K";
        public override string Description => @"Play with nine keys.";
    }
 }
@@ -3,26 +3,26 @@

 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.UI;
 using System.Linq;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Beatmaps;

 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModMirror : Mod, IApplicableToRulesetContainer<ManiaHitObject>
+    public class ManiaModMirror : Mod, IApplicableToBeatmap<ManiaHitObject>
    {
        public override string Name => "Mirror";
-        public override string ShortenedName => "MR";
+        public override string Acronym => "MR";
        public override ModType Type => ModType.Conversion;
        public override double ScoreMultiplier => 1;
        public override bool Ranked => true;

-        public void ApplyToRulesetContainer(RulesetContainer<ManiaHitObject> rulesetContainer)
+        public void ApplyToBeatmap(Beatmap<ManiaHitObject> beatmap)
        {
-            var availableColumns = ((ManiaRulesetContainer)rulesetContainer).Beatmap.TotalColumns;
+            var availableColumns = ((ManiaBeatmap)beatmap).TotalColumns;

-            rulesetContainer.Objects.OfType<ManiaHitObject>().ForEach(h => h.Column = availableColumns - 1 - h.Column);
+            beatmap.HitObjects.OfType<ManiaHitObject>().ForEach(h => h.Column = availableColumns - 1 - h.Column);
        }
    }
 }
@@ -4,29 +4,29 @@
 using System.Linq;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.MathUtils;
+using osu.Game.Beatmaps;
 using osu.Game.Graphics;
+using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.UI;

 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModRandom : Mod, IApplicableToRulesetContainer<ManiaHitObject>
+    public class ManiaModRandom : Mod, IApplicableToBeatmap<ManiaHitObject>
    {
        public override string Name => "Random";
-        public override string ShortenedName => "RD";
+        public override string Acronym => "RD";
        public override ModType Type => ModType.Conversion;
        public override FontAwesome Icon => FontAwesome.fa_osu_dice;
        public override string Description => @"Shuffle around the keys!";
        public override double ScoreMultiplier => 1;

-        public void ApplyToRulesetContainer(RulesetContainer<ManiaHitObject> rulesetContainer)
+        public void ApplyToBeatmap(Beatmap<ManiaHitObject> beatmap)
        {
-            var availableColumns = ((ManiaRulesetContainer)rulesetContainer).Beatmap.TotalColumns;
+            var availableColumns = ((ManiaBeatmap)beatmap).TotalColumns;
            var shuffledColumns = Enumerable.Range(0, availableColumns).OrderBy(item => RNG.Next()).ToList();

-            rulesetContainer.Objects.OfType<ManiaHitObject>().ForEach(h => h.Column = shuffledColumns[h.Column]);
+            beatmap.HitObjects.OfType<ManiaHitObject>().ForEach(h => h.Column = shuffledColumns[h.Column]);
        }
    }
 }
@@ -12,6 +12,11 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 {
    public abstract class DrawableManiaHitObject : DrawableHitObject<ManiaHitObject>
    {
+        /// <summary>
+        /// Whether this <see cref="DrawableManiaHitObject"/> should always remain alive.
+        /// </summary>
+        internal bool AlwaysAlive;
+
        /// <summary>
        /// The <see cref="ManiaAction"/> which causes this <see cref="DrawableManiaHitObject{TObject}"/> to be hit.
        /// </summary>
@@ -34,6 +39,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
            Direction.BindValueChanged(OnDirectionChanged, true);
        }

+        protected override bool ShouldBeAlive => AlwaysAlive || base.ShouldBeAlive;
+
        protected virtual void OnDirectionChanged(ScrollingDirection direction)
        {
            Anchor = Origin = direction == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre;
@@ -15,12 +15,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
    /// <summary>
    /// Represents length-wise portion of a hold note.
    /// </summary>
-    internal class BodyPiece : Container, IHasAccentColour
+    public class BodyPiece : Container, IHasAccentColour
    {
        private readonly Container subtractionLayer;

-        private readonly Drawable background;
-        private readonly BufferedContainer foreground;
+        protected readonly Drawable Background;
+        protected readonly BufferedContainer Foreground;
        private readonly BufferedContainer subtractionContainer;

        public BodyPiece()
@@ -29,8 +29,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces

            Children = new[]
            {
-                background = new Box { RelativeSizeAxes = Axes.Both },
-                foreground = new BufferedContainer
+                Background = new Box { RelativeSizeAxes = Axes.Both },
+                Foreground = new BufferedContainer
                {
                    Blending = BlendingMode.Additive,
                    RelativeSizeAxes = Axes.Both,
@@ -123,7 +123,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
                    Radius = DrawWidth
                };

-                foreground.ForceRedraw();
+                Foreground.ForceRedraw();
                subtractionContainer.ForceRedraw();

                subtractionCache.Validate();
@@ -137,18 +137,18 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
            if (!IsLoaded)
                return;

-            foreground.Colour = AccentColour.Opacity(0.5f);
-            background.Colour = AccentColour.Opacity(0.7f);
+            Foreground.Colour = AccentColour.Opacity(0.5f);
+            Background.Colour = AccentColour.Opacity(0.7f);

            const float animation_length = 50;

-            foreground.ClearTransforms(false, nameof(foreground.Colour));
+            Foreground.ClearTransforms(false, nameof(Foreground.Colour));
            if (hitting)
            {
                // wait for the next sync point
                double synchronisedOffset = animation_length * 2 - Time.Current % (animation_length * 2);
-                using (foreground.BeginDelayedSequence(synchronisedOffset))
-                    foreground.FadeColour(AccentColour.Lighten(0.2f), animation_length).Then().FadeColour(foreground.Colour, animation_length).Loop();
+                using (Foreground.BeginDelayedSequence(synchronisedOffset))
+                    Foreground.FadeColour(AccentColour.Lighten(0.2f), animation_length).Then().FadeColour(Foreground.Colour, animation_length).Loop();
            }

            subtractionCache.Invalidate();
@@ -1,6 +1,7 @@
 // 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.Configuration;
 using osu.Game.Rulesets.Mania.Objects.Types;
 using osu.Game.Rulesets.Objects;

@@ -8,7 +9,13 @@ namespace osu.Game.Rulesets.Mania.Objects
 {
    public abstract class ManiaHitObject : HitObject, IHasColumn
    {
-        public virtual int Column { get; set; }
+        public readonly Bindable<int> ColumnBindable = new Bindable<int>();
+
+        public virtual int Column
+        {
+            get => ColumnBindable;
+            set => ColumnBindable.Value = value;
+        }

        protected override HitWindows CreateHitWindows() => new ManiaHitWindows();
    }
@@ -21,7 +21,6 @@ namespace osu.Game.Rulesets.Mania.Objects

        private readonly int beatmapColumnCount;

-
        private readonly double endTime;
        private readonly double[] heldUntil;

@@ -20,11 +20,10 @@ namespace osu.Game.Rulesets.Mania.Objects
            { HitResult.Miss, (376, 346, 316) },
        };

+        public override bool IsHitResultAllowed(HitResult result) => true;
+
        public override void SetDifficulty(double difficulty)
        {
-            AllowsPerfect = true;
-            AllowsOk = true;
-
            Perfect = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Perfect]);
            Great = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Great]);
            Good = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Good]);
@@ -3,11 +3,11 @@

 using System.Collections.Generic;
 using System.Linq;
+using osu.Game.Replays;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Replays;
-using osu.Game.Users;

 namespace osu.Game.Rulesets.Mania.Replays
 {
@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Mania.Replays
        public ManiaAutoGenerator(ManiaBeatmap beatmap)
            : base(beatmap)
        {
-            Replay = new Replay { User = new User { Username = @"Autoplay" } };
+            Replay = new Replay();

            columnActions = new ManiaAction[Beatmap.TotalColumns];

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Input.StateChanges;
+using osu.Game.Replays;
 using osu.Game.Rulesets.Replays;

 namespace osu.Game.Rulesets.Mania.Replays
@@ -3,9 +3,9 @@

 using System.Collections.Generic;
 using osu.Game.Beatmaps;
+using osu.Game.Replays.Legacy;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Replays;
-using osu.Game.Rulesets.Replays.Legacy;
 using osu.Game.Rulesets.Replays.Types;

 namespace osu.Game.Rulesets.Mania.Replays
@@ -5,6 +5,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;

@@ -157,5 +158,7 @@ namespace osu.Game.Rulesets.Mania.Scoring
                }
            }
        }
+
+        protected override HitWindows CreateHitWindows() => new ManiaHitWindows();
    }
 }
@@ -13,6 +13,7 @@ using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.UI.Components;
 using osu.Game.Rulesets.UI.Scrolling;
+using osuTK;

 namespace osu.Game.Rulesets.Mania.UI
 {
@@ -21,6 +22,11 @@ namespace osu.Game.Rulesets.Mania.UI
        private const float column_width = 45;
        private const float special_column_width = 70;

+        /// <summary>
+        /// The index of this column as part of the whole playfield.
+        /// </summary>
+        public readonly int Index;
+
        public readonly Bindable<ManiaAction> Action = new Bindable<ManiaAction>();

        private readonly ColumnBackground background;
@@ -30,8 +36,10 @@ namespace osu.Game.Rulesets.Mania.UI
        internal readonly Container TopLevelContainer;
        private readonly Container explosionContainer;

-        public Column()
+        public Column(int index)
        {
+            Index = index;
+
            RelativeSizeAxes = Axes.Y;
            Width = column_width;

@@ -137,6 +145,15 @@ namespace osu.Game.Rulesets.Mania.UI
            HitObjectContainer.Add(hitObject);
        }

+        public override bool Remove(DrawableHitObject h)
+        {
+            if (!base.Remove(h))
+                return false;
+
+            h.OnNewResult -= OnNewResult;
+            return true;
+        }
+
        internal void OnNewResult(DrawableHitObject judgedObject, JudgementResult result)
        {
            if (!result.IsHit || !judgedObject.DisplayResult || !DisplayJudgements)
@@ -165,5 +182,9 @@ namespace osu.Game.Rulesets.Mania.UI
        }

        public bool OnReleased(ManiaAction action) => false;
+
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos)
+            // This probably shouldn't exist as is, but the columns in the stage are separated by a 1px border
+            => DrawRectangle.Inflate(new Vector2(ManiaStage.COLUMN_SPACING / 2, 0)).Contains(ToLocalSpace(screenSpacePos));
    }
 }
@@ -5,6 +5,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -17,6 +18,8 @@ namespace osu.Game.Rulesets.Mania.UI
    {
        private readonly List<ManiaStage> stages = new List<ManiaStage>();

+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => stages.Any(s => s.ReceivePositionalInputAt(screenSpacePos));
+
        public ManiaPlayfield(List<StageDefinition> stageDefinitions)
        {
            if (stageDefinitions == null)
@@ -52,8 +55,42 @@ namespace osu.Game.Rulesets.Mania.UI

        public override void Add(DrawableHitObject h) => getStageByColumn(((ManiaHitObject)h.HitObject).Column).Add(h);

+        public override bool Remove(DrawableHitObject h) => getStageByColumn(((ManiaHitObject)h.HitObject).Column).Remove(h);
+
        public void Add(BarLine barline) => stages.ForEach(s => s.Add(barline));

+        /// <summary>
+        /// Retrieves a column from a screen-space position.
+        /// </summary>
+        /// <param name="screenSpacePosition">The screen-space position.</param>
+        /// <returns>The column which the <paramref name="screenSpacePosition"/> lies in.</returns>
+        public Column GetColumnByPosition(Vector2 screenSpacePosition)
+        {
+            Column found = null;
+
+            foreach (var stage in stages)
+            {
+                foreach (var column in stage.Columns)
+                {
+                    if (column.ReceivePositionalInputAt(screenSpacePosition))
+                    {
+                        found = column;
+                        break;
+                    }
+                }
+
+                if (found != null)
+                    break;
+            }
+
+            return found;
+        }
+
+        /// <summary>
+        /// Retrieves the total amount of columns across all stages in this playfield.
+        /// </summary>
+        public int TotalColumns => stages.Sum(s => s.Columns.Count);
+
        private ManiaStage getStageByColumn(int column)
        {
            int sum = 0;
@@ -12,6 +12,7 @@ using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Input.Handlers;
+using osu.Game.Replays;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.Mods;
@@ -21,10 +22,10 @@ using osu.Game.Rulesets.Mania.Replays;
 using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
-using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
+using osuTK;

 namespace osu.Game.Rulesets.Mania.UI
 {
@@ -80,6 +81,13 @@ namespace osu.Game.Rulesets.Mania.UI
            Config.BindWith(ManiaSetting.ScrollTime, TimeRange);
        }

+        /// <summary>
+        /// Retrieves the column that intersects a screen-space position.
+        /// </summary>
+        /// <param name="screenSpacePosition">The screen-space position.</param>
+        /// <returns>The column which intersects with <paramref name="screenSpacePosition"/>.</returns>
+        public Column GetColumnByPosition(Vector2 screenSpacePosition) => Playfield.GetColumnByPosition(screenSpacePosition);
+
        protected override Playfield CreatePlayfield() => new ManiaPlayfield(Beatmap.Stages)
        {
            Anchor = Anchor.Centre,
@@ -25,6 +25,8 @@ namespace osu.Game.Rulesets.Mania.UI
    /// </summary>
    public class ManiaStage : ScrollingPlayfield
    {
+        public const float COLUMN_SPACING = 1;
+
        public const float HIT_TARGET_POSITION = 50;

        public IReadOnlyList<Column> Columns => columnFlow.Children;
@@ -40,6 +42,8 @@ namespace osu.Game.Rulesets.Mania.UI
        private List<Color4> normalColumnColours = new List<Color4>();
        private Color4 specialColumnColour;

+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => Columns.Any(c => c.ReceivePositionalInputAt(screenSpacePos));
+
        private readonly int firstColumnIndex;

        public ManiaStage(int firstColumnIndex, StageDefinition definition, ref ManiaAction normalColumnStartAction, ref ManiaAction specialColumnStartAction)
@@ -84,8 +88,8 @@ namespace osu.Game.Rulesets.Mania.UI
                                    RelativeSizeAxes = Axes.Y,
                                    AutoSizeAxes = Axes.X,
                                    Direction = FillDirection.Horizontal,
-                                    Padding = new MarginPadding { Left = 1, Right = 1 },
-                                    Spacing = new Vector2(1, 0)
+                                    Padding = new MarginPadding { Left = COLUMN_SPACING, Right = COLUMN_SPACING },
+                                    Spacing = new Vector2(COLUMN_SPACING, 0)
                                },
                            }
                        },
@@ -123,7 +127,7 @@ namespace osu.Game.Rulesets.Mania.UI
            for (int i = 0; i < definition.Columns; i++)
            {
                var isSpecial = definition.IsSpecialColumn(i);
-                var column = new Column
+                var column = new Column(firstColumnIndex + i)
                {
                    IsSpecial = isSpecial,
                    Action = { Value = isSpecial ? specialColumnStartAction++ : normalColumnStartAction++ }
@@ -152,11 +156,31 @@ namespace osu.Game.Rulesets.Mania.UI
        public override void Add(DrawableHitObject h)
        {
            var maniaObject = (ManiaHitObject)h.HitObject;
-            int columnIndex = maniaObject.Column - firstColumnIndex;
-            Columns.ElementAt(columnIndex).Add(h);
+
+            int columnIndex = -1;
+
+            maniaObject.ColumnBindable.BindValueChanged(_ =>
+            {
+                if (columnIndex != -1)
+                    Columns.ElementAt(columnIndex).Remove(h);
+
+                columnIndex = maniaObject.Column - firstColumnIndex;
+                Columns.ElementAt(columnIndex).Add(h);
+            }, true);
+
            h.OnNewResult += OnNewResult;
        }

+        public override bool Remove(DrawableHitObject h)
+        {
+            var maniaObject = (ManiaHitObject)h.HitObject;
+            int columnIndex = maniaObject.Column - firstColumnIndex;
+            Columns.ElementAt(columnIndex).Remove(h);
+
+            h.OnNewResult -= OnNewResult;
+            return true;
+        }
+
        public void Add(BarLine barline) => base.Add(new DrawableBarLine(barline));

        internal void OnNewResult(DrawableHitObject judgedObject, JudgementResult result)
@@ -7,7 +7,7 @@
            "request": "launch",
            "program": "dotnet",
            "args": [
-                "${workspaceRoot}/bin/Debug/netcoreapp2.1/osu.Game.Rulesets.Osu.Tests.dll"
+                "${workspaceRoot}/bin/Debug/netcoreapp2.2/osu.Game.Rulesets.Osu.Tests.dll"
            ],
            "cwd": "${workspaceRoot}",
            "preLaunchTask": "Build (Debug)",
@@ -20,7 +20,7 @@
            "request": "launch",
            "program": "dotnet",
            "args": [
-                "${workspaceRoot}/bin/Release/netcoreapp2.1/osu.Game.Rulesets.Osu.Tests.dll"
+                "${workspaceRoot}/bin/Release/netcoreapp2.2/osu.Game.Rulesets.Osu.Tests.dll"
            ],
            "cwd": "${workspaceRoot}",
            "preLaunchTask": "Build (Release)",
@@ -4,12 +4,12 @@
    <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
    <PackageReference Include="NUnit" Version="3.11.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.11.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.12.0" />
    <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
  </ItemGroup>
  <PropertyGroup Label="Project">
    <OutputType>WinExe</OutputType>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
+    <TargetFramework>netcoreapp2.2</TargetFramework>
  </PropertyGroup>
  <ItemGroup Label="Project References">
    <ProjectReference Include="..\osu.Game.Rulesets.Osu\osu.Game.Rulesets.Osu.csproj" />
@@ -1,6 +1,7 @@
 // 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.Framework.Graphics;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects.Types;
@@ -23,60 +24,70 @@ namespace osu.Game.Rulesets.Osu.Beatmaps

            var osuBeatmap = (Beatmap<OsuHitObject>)Beatmap;

-            // Reset stacking
-            foreach (var h in osuBeatmap.HitObjects)
-                h.StackHeight = 0;
+            if (osuBeatmap.HitObjects.Count > 0)
+            {
+                // Reset stacking
+                foreach (var h in osuBeatmap.HitObjects)
+                    h.StackHeight = 0;

-            if (Beatmap.BeatmapInfo.BeatmapVersion >= 6)
-                applyStacking(osuBeatmap);
-            else
-                applyStackingOld(osuBeatmap);
+                if (Beatmap.BeatmapInfo.BeatmapVersion >= 6)
+                    applyStacking(osuBeatmap, 0, osuBeatmap.HitObjects.Count - 1);
+                else
+                    applyStackingOld(osuBeatmap);
+            }
        }

-        private void applyStacking(Beatmap<OsuHitObject> beatmap)
+        private void applyStacking(Beatmap<OsuHitObject> beatmap, int startIndex, int endIndex)
        {
-            // Extend the end index to include objects they are stacked on
-            int extendedEndIndex = beatmap.HitObjects.Count - 1;
-            for (int i = beatmap.HitObjects.Count - 1; i >= 0; i--)
+            if (startIndex > endIndex) throw new ArgumentOutOfRangeException(nameof(startIndex), $"{nameof(startIndex)} cannot be greater than {nameof(endIndex)}.");
+            if (startIndex < 0) throw new ArgumentOutOfRangeException(nameof(startIndex), $"{nameof(startIndex)} cannot be less than 0.");
+            if (endIndex < 0) throw new ArgumentOutOfRangeException(nameof(endIndex), $"{nameof(endIndex)} cannot be less than 0.");
+
+            int extendedEndIndex = endIndex;
+            if (endIndex < beatmap.HitObjects.Count - 1)
            {
-                int stackBaseIndex = i;
-                for (int n = stackBaseIndex + 1; n < beatmap.HitObjects.Count; n++)
+                // Extend the end index to include objects they are stacked on
+                for (int i = endIndex; i >= startIndex; i--)
                {
-                    OsuHitObject stackBaseObject = beatmap.HitObjects[stackBaseIndex];
-                    if (stackBaseObject is Spinner) break;
-
-                    OsuHitObject objectN = beatmap.HitObjects[n];
-                    if (objectN is Spinner)
-                        continue;
-
-                    double endTime = (stackBaseObject as IHasEndTime)?.EndTime ?? stackBaseObject.StartTime;
-                    double stackThreshold = objectN.TimePreempt * beatmap.BeatmapInfo.StackLeniency;
-
-                    if (objectN.StartTime - endTime > stackThreshold)
-                        //We are no longer within stacking range of the next object.
-                        break;
-
-                    if (Vector2Extensions.Distance(stackBaseObject.Position, objectN.Position) < stack_distance ||
-                        stackBaseObject is Slider && Vector2Extensions.Distance(stackBaseObject.EndPosition, objectN.Position) < stack_distance)
+                    int stackBaseIndex = i;
+                    for (int n = stackBaseIndex + 1; n < beatmap.HitObjects.Count; n++)
                    {
-                        stackBaseIndex = n;
+                        OsuHitObject stackBaseObject = beatmap.HitObjects[stackBaseIndex];
+                        if (stackBaseObject is Spinner) break;

-                        // HitObjects after the specified update range haven't been reset yet
-                        objectN.StackHeight = 0;
+                        OsuHitObject objectN = beatmap.HitObjects[n];
+                        if (objectN is Spinner)
+                            continue;
+
+                        double endTime = (stackBaseObject as IHasEndTime)?.EndTime ?? stackBaseObject.StartTime;
+                        double stackThreshold = objectN.TimePreempt * beatmap.BeatmapInfo.StackLeniency;
+
+                        if (objectN.StartTime - endTime > stackThreshold)
+                            //We are no longer within stacking range of the next object.
+                            break;
+
+                        if (Vector2Extensions.Distance(stackBaseObject.Position, objectN.Position) < stack_distance
+                            || stackBaseObject is Slider && Vector2Extensions.Distance(stackBaseObject.EndPosition, objectN.Position) < stack_distance)
+                        {
+                            stackBaseIndex = n;
+
+                            // HitObjects after the specified update range haven't been reset yet
+                            objectN.StackHeight = 0;
+                        }
                    }
-                }

-                if (stackBaseIndex > extendedEndIndex)
-                {
-                    extendedEndIndex = stackBaseIndex;
-                    if (extendedEndIndex == beatmap.HitObjects.Count - 1)
-                        break;
+                    if (stackBaseIndex > extendedEndIndex)
+                    {
+                        extendedEndIndex = stackBaseIndex;
+                        if (extendedEndIndex == beatmap.HitObjects.Count - 1)
+                            break;
+                    }
                }
            }

            //Reverse pass for stack calculation.
-            int extendedStartIndex = 0;
-            for (int i = extendedEndIndex; i > 0; i--)
+            int extendedStartIndex = startIndex;
+            for (int i = extendedEndIndex; i > startIndex; i--)
            {
                int n = i;
                /* We should check every note which has not yet got a stack.
@@ -155,7 +166,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                    /* We have hit the first slider in a possible stack.
                        * From this point on, we ALWAYS stack positive regardless.
                        */
-                    while (--n >= 0)
+                    while (--n >= startIndex)
                    {
                        OsuHitObject objectN = beatmap.HitObjects[n];
                        if (objectN is Spinner) continue;
@@ -57,6 +57,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                    s.Process(h);
            }

+            // The peak strain will not be saved for the last section in the above loop
+            foreach (Skill s in skills)
+                s.SaveCurrentPeak();
+
            double aimRating = Math.Sqrt(skills[0].DifficultyValue()) * difficulty_multiplier;
            double speedRating = Math.Sqrt(skills[1].DifficultyValue()) * difficulty_multiplier;
            double starRating = aimRating + speedRating + Math.Abs(aimRating - speedRating) / 2;
@@ -10,6 +10,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;

 namespace osu.Game.Rulesets.Osu.Difficulty
 {
@@ -29,7 +30,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
        private int countMeh;
        private int countMiss;

-        public OsuPerformanceCalculator(Ruleset ruleset, WorkingBeatmap beatmap, Score score)
+        public OsuPerformanceCalculator(Ruleset ruleset, WorkingBeatmap beatmap, ScoreInfo score)
            : base(ruleset, beatmap, score)
        {
            countHitCircles = Beatmap.HitObjects.Count(h => h is HitCircle);
@@ -104,13 +105,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty

            double approachRateFactor = 1.0f;
            if (Attributes.ApproachRate > 10.33f)
-                approachRateFactor += 0.45f * (Attributes.ApproachRate - 10.33f);
+                approachRateFactor += 0.3f * (Attributes.ApproachRate - 10.33f);
            else if (Attributes.ApproachRate < 8.0f)
            {
-                // HD is worth more with lower ar!
-                if (mods.Any(h => h is OsuModHidden))
-                    approachRateFactor += 0.02f * (8.0f - Attributes.ApproachRate);
-                else
                    approachRateFactor += 0.01f * (8.0f - Attributes.ApproachRate);
            }

@@ -118,12 +115,14 @@ namespace osu.Game.Rulesets.Osu.Difficulty

            // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
            if (mods.Any(h => h is OsuModHidden))
-                aimValue *= 1.02 + (11.0f - Attributes.ApproachRate) / 50.0; // Gives a 1.04 bonus for AR10, a 1.06 bonus for AR9, a 1.02 bonus for AR11.
+                aimValue *= 1.0f + 0.04f * (12.0f - Attributes.ApproachRate);

            if (mods.Any(h => h is OsuModFlashlight))
            {
-                // Apply length bonus again if flashlight is on simply because it becomes a lot harder on longer maps.
-                aimValue *= 1.45f * lengthBonus;
+                // Apply object-based bonus for flashlight.
+                aimValue *= 1.0f + 0.35f * Math.Min(1.0f, totalHits / 200.0f) +
+                        (totalHits > 200 ? 0.3f * Math.Min(1.0f, (totalHits - 200) / 300.0f) +
+                        (totalHits > 500 ? (totalHits - 500) / 1200.0f : 0.0f) : 0.0f);
            }

            // Scale the aim value with accuracy _slightly_
@@ -149,13 +148,19 @@ namespace osu.Game.Rulesets.Osu.Difficulty
            if (beatmapMaxCombo > 0)
                speedValue *= Math.Min(Math.Pow(scoreMaxCombo, 0.8f) / Math.Pow(beatmapMaxCombo, 0.8f), 1.0f);

+            double approachRateFactor = 1.0f;
+            if (Attributes.ApproachRate > 10.33f)
+                approachRateFactor += 0.3f * (Attributes.ApproachRate - 10.33f);
+
+            speedValue *= approachRateFactor;
+
            if (mods.Any(m => m is OsuModHidden))
-                speedValue *= 1.18f;
+                speedValue *= 1.0f + 0.04f * (12.0f - Attributes.ApproachRate);

            // Scale the speed value with accuracy _slightly_
-            speedValue *= 0.5f + accuracy / 2.0f;
+            speedValue *= 0.02f + accuracy;
            // It is important to also consider accuracy difficulty when doing that
-            speedValue *= 0.98f + Math.Pow(Attributes.OverallDifficulty, 2) / 2500;
+            speedValue *= 0.96f + Math.Pow(Attributes.OverallDifficulty, 2) / 1600;

            return speedValue;
        }
@@ -183,7 +188,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
            accuracyValue *= Math.Min(1.15f, Math.Pow(amountHitObjectsWithAccuracy / 1000.0f, 0.3f));

            if (mods.Any(m => m is OsuModHidden))
-                accuracyValue *= 1.02f;
+                accuracyValue *= 1.08f;
            if (mods.Any(m => m is OsuModFlashlight))
                accuracyValue *= 1.02f;

@@ -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.Input.Events;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
@@ -16,7 +15,5 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints
            : base(hitObject)
        {
        }
-
-        public override void AdjustPosition(DragEvent dragEvent) => OsuObject.Position += dragEvent.Delta;
    }
 }
@@ -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.Input.Events;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
@@ -10,13 +9,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 {
    public class SliderCircleSelectionBlueprint : OsuSelectionBlueprint
    {
-        private readonly Slider slider;
-
        public SliderCircleSelectionBlueprint(DrawableOsuHitObject hitObject, Slider slider, SliderPosition position)
            : base(hitObject)
        {
-            this.slider = slider;
-
            InternalChild = new SliderCirclePiece(slider, position);

            Select();
@@ -24,7 +19,5 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders

        // Todo: This is temporary, since the slider circle masks don't do anything special yet. In the future they will handle input.
        public override bool HandlePositionalInput => false;
-
-        public override void AdjustPosition(DragEvent dragEvent) => slider.Position += dragEvent.Delta;
    }
 }
@@ -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.Input.Events;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
@@ -20,10 +19,5 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners
        }

        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => piece.ReceivePositionalInputAt(screenSpacePos);
-
-        public override void AdjustPosition(DragEvent dragEvent)
-        {
-            // Spinners don't support position adjustments
-        }
    }
 }
@@ -15,6 +15,7 @@ using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Edit.Compose.Components;

 namespace osu.Game.Rulesets.Osu.Edit
 {
@@ -35,6 +36,8 @@ namespace osu.Game.Rulesets.Osu.Edit
            new SpinnerCompositionTool()
        };

+        public override SelectionHandler CreateSelectionHandler() => new OsuSelectionHandler();
+
        protected override Container CreateLayerContainer() => new PlayfieldAdjustmentContainer { RelativeSizeAxes = Axes.Both };

        public override SelectionBlueprint CreateBlueprintFor(DrawableHitObject hitObject)
@@ -0,0 +1,30 @@
+// 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 osu.Framework.Input.Events;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit.Compose.Components;
+
+namespace osu.Game.Rulesets.Osu.Edit
+{
+    public class OsuSelectionHandler : SelectionHandler
+    {
+        public override void HandleDrag(SelectionBlueprint blueprint, DragEvent dragEvent)
+        {
+            foreach (var h in SelectedHitObjects.OfType<OsuHitObject>())
+            {
+                if (h is Spinner)
+                {
+                    // Spinners don't support position adjustments
+                    continue;
+                }
+
+                h.Position += dragEvent.Delta;
+            }
+
+            base.HandleDrag(blueprint, dragEvent);
+        }
+    }
+}
@@ -10,7 +10,7 @@ namespace osu.Game.Rulesets.Osu.Mods
    public class OsuModAutopilot : Mod
    {
        public override string Name => "Autopilot";
-        public override string ShortenedName => "AP";
+        public override string Acronym => "AP";
        public override FontAwesome Icon => FontAwesome.fa_osu_mod_autopilot;
        public override ModType Type => ModType.Automation;
        public override string Description => @"Automatic cursor movement - just follow the rhythm.";
@@ -7,7 +7,8 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Replays;
-using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Users;

 namespace osu.Game.Rulesets.Osu.Mods
 {
@@ -15,12 +16,10 @@ namespace osu.Game.Rulesets.Osu.Mods
    {
        public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(OsuModAutopilot)).Append(typeof(OsuModSpunOut)).ToArray();

-        protected override Score CreateReplayScore(Beatmap<OsuHitObject> beatmap)
+        protected override Score CreateReplayScore(Beatmap<OsuHitObject> beatmap) => new Score
        {
-            return new Score
-            {
-                Replay = new OsuAutoGenerator(beatmap).Generate()
-            };
-        }
+            ScoreInfo = new ScoreInfo { User = new User { Username = "Autoplay" } },
+            Replay = new OsuAutoGenerator(beatmap).Generate()
+        };
    }
 }
@@ -0,0 +1,194 @@
+// 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.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    public class OsuModBlinds : Mod, IApplicableToRulesetContainer<OsuHitObject>, IApplicableToScoreProcessor
+    {
+        public override string Name => "Blinds";
+        public override string Description => "Play with blinds on your screen.";
+        public override string Acronym => "BL";
+
+        public override FontAwesome Icon => FontAwesome.fa_adjust;
+        public override ModType Type => ModType.DifficultyIncrease;
+
+        public override bool Ranked => false;
+
+        public override double ScoreMultiplier => 1.12;
+        private DrawableOsuBlinds blinds;
+
+        public void ApplyToRulesetContainer(RulesetContainer<OsuHitObject> rulesetContainer)
+        {
+            rulesetContainer.Overlays.Add(blinds = new DrawableOsuBlinds(rulesetContainer.Playfield.HitObjectContainer, rulesetContainer.Beatmap));
+        }
+
+        public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor)
+        {
+            scoreProcessor.Health.ValueChanged += val => { blinds.AnimateClosedness((float)val); };
+        }
+
+        /// <summary>
+        /// Element for the Blinds mod drawing 2 black boxes covering the whole screen which resize inside a restricted area with some leniency.
+        /// </summary>
+        public class DrawableOsuBlinds : Container
+        {
+            /// <summary>
+            /// Black background boxes behind blind panel textures.
+            /// </summary>
+            private Box blackBoxLeft, blackBoxRight;
+
+            private Drawable panelLeft, panelRight, bgPanelLeft, bgPanelRight;
+
+            private readonly Beatmap<OsuHitObject> beatmap;
+
+            /// <summary>
+            /// Value between 0 and 1 setting a maximum "closedness" for the blinds.
+            /// Useful for animating how far the blinds can be opened while keeping them at the original position if they are wider open than this.
+            /// </summary>
+            private const float target_clamp = 1;
+
+            private readonly float targetBreakMultiplier = 0;
+            private readonly float easing = 1;
+
+            private readonly CompositeDrawable restrictTo;
+
+            /// <summary>
+            /// <para>
+            /// Percentage of playfield to extend blinds over. Basically moves the origin points where the blinds start.
+            /// </para>
+            /// <para>
+            /// -1 would mean the blinds always cover the whole screen no matter health.
+            /// 0 would mean the blinds will only ever be on the edge of the playfield on 0% health.
+            /// 1 would mean the blinds are fully outside the playfield on 50% health.
+            /// Infinity would mean the blinds are always outside the playfield except on 100% health.
+            /// </para>
+            /// </summary>
+            private const float leniency = 0.1f;
+
+            public DrawableOsuBlinds(CompositeDrawable restrictTo, Beatmap<OsuHitObject> beatmap)
+            {
+                this.restrictTo = restrictTo;
+                this.beatmap = beatmap;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                RelativeSizeAxes = Axes.Both;
+
+                Children = new[]
+                {
+                    blackBoxLeft = new Box
+                    {
+                        Anchor = Anchor.TopLeft,
+                        Origin = Anchor.TopLeft,
+                        Colour = Color4.Black,
+                        RelativeSizeAxes = Axes.Y,
+                    },
+                    blackBoxRight = new Box
+                    {
+                        Anchor = Anchor.TopRight,
+                        Origin = Anchor.TopRight,
+                        Colour = Color4.Black,
+                        RelativeSizeAxes = Axes.Y,
+                    },
+                    bgPanelLeft = new ModBlindsPanel
+                    {
+                        Origin = Anchor.TopRight,
+                        Colour = Color4.Gray,
+                    },
+                    panelLeft = new ModBlindsPanel { Origin = Anchor.TopRight, },
+                    bgPanelRight = new ModBlindsPanel { Colour = Color4.Gray },
+                    panelRight = new ModBlindsPanel()
+                };
+            }
+
+            private float calculateGap(float value) => MathHelper.Clamp(value, 0, target_clamp) * targetBreakMultiplier;
+
+            // lagrange polinominal for (0,0) (0.6,0.4) (1,1) should make a good curve
+            private static float applyAdjustmentCurve(float value) => 0.6f * value * value + 0.4f * value;
+
+            protected override void Update()
+            {
+                float start = Parent.ToLocalSpace(restrictTo.ScreenSpaceDrawQuad.TopLeft).X;
+                float end = Parent.ToLocalSpace(restrictTo.ScreenSpaceDrawQuad.TopRight).X;
+
+                float rawWidth = end - start;
+
+                start -= rawWidth * leniency * 0.5f;
+                end += rawWidth * leniency * 0.5f;
+
+                float width = (end - start) * 0.5f * applyAdjustmentCurve(calculateGap(easing));
+
+                // different values in case the playfield ever moves from center to somewhere else.
+                blackBoxLeft.Width = start + width;
+                blackBoxRight.Width = DrawWidth - end + width;
+
+                panelLeft.X = start + width;
+                panelRight.X = end - width;
+                bgPanelLeft.X = start;
+                bgPanelRight.X = end;
+            }
+
+            protected override void LoadComplete()
+            {
+                const float break_open_early = 500;
+                const float break_close_late = 250;
+
+                base.LoadComplete();
+
+                var firstObj = beatmap.HitObjects[0];
+                var startDelay = firstObj.StartTime - firstObj.TimePreempt;
+
+                using (BeginAbsoluteSequence(startDelay + break_close_late, true))
+                    leaveBreak();
+
+                foreach (var breakInfo in beatmap.Breaks)
+                {
+                    if (breakInfo.HasEffect)
+                    {
+                        using (BeginAbsoluteSequence(breakInfo.StartTime - break_open_early, true))
+                        {
+                            enterBreak();
+                            using (BeginDelayedSequence(breakInfo.Duration + break_open_early + break_close_late, true))
+                                leaveBreak();
+                        }
+                    }
+                }
+            }
+
+            private void enterBreak() => this.TransformTo(nameof(targetBreakMultiplier), 0f, 1000, Easing.OutSine);
+
+            private void leaveBreak() => this.TransformTo(nameof(targetBreakMultiplier), 1f, 2500, Easing.OutBounce);
+
+            /// <summary>
+            /// 0 is open, 1 is closed.
+            /// </summary>
+            public void AnimateClosedness(float value) => this.TransformTo(nameof(easing), value, 200, Easing.OutQuint);
+
+            public class ModBlindsPanel : Sprite
+            {
+                [BackgroundDependencyLoader]
+                private void load(TextureStore textures)
+                {
+                    Texture = textures.Get("Play/osu/blinds-panel");
+                }
+            }
+        }
+    }
+}
@@ -26,9 +26,6 @@ namespace osu.Game.Rulesets.Osu.Mods
            if (slider == null)
                return;

-            slider.HeadCircle.Position = new Vector2(slider.HeadCircle.Position.X, OsuPlayfield.BASE_SIZE.Y - slider.HeadCircle.Position.Y);
-            slider.TailCircle.Position = new Vector2(slider.TailCircle.Position.X, OsuPlayfield.BASE_SIZE.Y - slider.TailCircle.Position.Y);
-
            slider.NestedHitObjects.OfType<SliderTick>().ForEach(h => h.Position = new Vector2(h.Position.X, OsuPlayfield.BASE_SIZE.Y - h.Position.Y));
            slider.NestedHitObjects.OfType<RepeatPoint>().ForEach(h => h.Position = new Vector2(h.Position.X, OsuPlayfield.BASE_SIZE.Y - h.Position.Y));

@@ -10,7 +10,7 @@ namespace osu.Game.Rulesets.Osu.Mods
    public class OsuModSpunOut : Mod
    {
        public override string Name => "Spun Out";
-        public override string ShortenedName => "SO";
+        public override string Acronym => "SO";
        public override FontAwesome Icon => FontAwesome.fa_osu_mod_spunout;
        public override ModType Type => ModType.DifficultyReduction;
        public override string Description => @"Spinners will be automatically completed.";
--- a/Show More
+++ b/Show More