Merge pull request #3179 from peppy/direct-list-view

Reduce animations of osu!direct list mode

README.md

@@ -24,7 +24,7 @@ Clone the repository including submodules
 Build and run
 
 - Using Visual Studio 2017, Rider or Visual Studio Code (configurations are included)
-- From command line using `dotnet run --project osu.Desktop --framework netcoreapp2.1`
+- From command line using `dotnet run --project osu.Desktop`
 
 If you run into issues building you may need to restore nuget packages (commonly via `dotnet restore`). Visual Studio Code users must run `Restore` task from debug tab before attempt to build.
 

appveyor.yml

@@ -9,12 +9,10 @@ install:
   - cmd: git submodule update --init --recursive --depth=5
   - cmd: choco install resharper-clt -y
   - cmd: choco install nvika -y
-  - cmd: appveyor DownloadFile https://github.com/peppy/CodeFileSanity/releases/download/v0.2.5/CodeFileSanity.exe
+  - cmd: dotnet tool install CodeFileSanity --version 0.0.16 --global
 before_build:
-  - cmd: CodeFileSanity.exe
+  - cmd: CodeFileSanity
   - cmd: nuget restore -verbosity quiet
-environment:
-  TargetFramework: net471
 build:
   project: osu.sln
   parallel: true

appveyor_deploy.yml

@@ -16,17 +16,15 @@ build_script:
   - cd osu-deploy
   - nuget restore -verbosity quiet
   - msbuild osu.Desktop.Deploy.csproj
-  - cmd: ..\appveyor-tools\secure-file -decrypt ..\fdc6f19b04.enc -secret %decode_secret% -out bin\Debug\net471\osu.Desktop.Deploy.exe.config
-  - cd bin\Debug\net471\
-  - osu.Desktop.Deploy.exe %code_signing_password% %APPVEYOR_REPO_TAG_NAME%
+  - cmd: ..\appveyor-tools\secure-file -decrypt ..\fdc6f19b04.enc -secret %decode_secret% -out bin\Debug\netcoreapp2.1\osu.Desktop.Deploy.dll.config
+  - dotnet bin/Debug/netcoreapp2.1/osu.Desktop.Deploy.dll %code_signing_password% %APPVEYOR_REPO_TAG_NAME%
 environment:
-  TargetFramework: net471
   decode_secret:
     secure: i67IC2xj6DjjxmA6Oj2jing3+MwzLkq6CbGsjfZ7rdY=
   code_signing_password:
     secure: 34tLNqvjmmZEi97MLKfrnQ==
 artifacts:
-  - path: 'Releases\*'
+  - path: 'osu-deploy/releases/*'
 deploy:
   - provider: Environment
     name: github

osu.Desktop/OsuGameDesktop.cs

@@ -13,6 +13,7 @@ using osu.Game;
 using OpenTK.Input;
 using Microsoft.Win32;
 using osu.Desktop.Updater;
+using osu.Framework;
 using osu.Framework.Platform.Windows;
 
 namespace osu.Desktop
@@ -51,11 +52,10 @@ namespace osu.Desktop
                     v.State = Visibility.Visible;
                 });
 
-#if NET_FRAMEWORK
-                Add(new SquirrelUpdateManager());
-#else
-                Add(new SimpleUpdateManager());
-#endif
+                if (RuntimeInfo.OS == RuntimeInfo.Platform.Windows)
+                    Add(new SquirrelUpdateManager());
+                else
+                    Add(new SimpleUpdateManager());
             }
         }
 

osu.Desktop/Program.cs

@@ -8,10 +8,6 @@ using osu.Framework;
 using osu.Framework.Platform;
 using osu.Game.IPC;
 
-#if NET_FRAMEWORK
-using System.Runtime;
-#endif
-
 namespace osu.Desktop
 {
     public static class Program
@@ -19,8 +15,6 @@ namespace osu.Desktop
         [STAThread]
         public static int Main(string[] args)
         {
-            useMultiCoreJit();
-
             // Back up the cwd before DesktopGameHost changes it
             var cwd = Environment.CurrentDirectory;
 
@@ -51,14 +45,5 @@ namespace osu.Desktop
                 return 0;
             }
         }
-
-        private static void useMultiCoreJit()
-        {
-#if NET_FRAMEWORK
-            var directory = Directory.CreateDirectory(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Profiles"));
-            ProfileOptimization.SetProfileRoot(directory.FullName);
-            ProfileOptimization.StartProfile("Startup.Profile");
-#endif
-        }
     }
 }

osu.Desktop/Updater/SquirrelUpdateManager.cs

@@ -1,7 +1,6 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-#if NET_FRAMEWORK
 using System;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
@@ -162,4 +161,3 @@ namespace osu.Desktop.Updater
         }
     }
 }
-#endif

osu.Desktop/osu.Desktop.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\osu.Game.props" />
   <PropertyGroup Label="Project">
-    <TargetFrameworks>net471;netcoreapp2.1</TargetFrameworks>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
     <OutputType>WinExe</OutputType>
     <PlatformTarget>AnyCPU</PlatformTarget>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
@@ -13,9 +13,6 @@
     <Version>0.0.0</Version>
     <FileVersion>0.0.0</FileVersion>
   </PropertyGroup>
-  <PropertyGroup Label="Defines">
-    <DefineConstants Condition="'$(TargetFramework)' == 'net471'">$(DefineConstants);NET_FRAMEWORK</DefineConstants>
-  </PropertyGroup>
   <PropertyGroup>
     <StartupObject>osu.Desktop.Program</StartupObject>
   </PropertyGroup>
@@ -29,11 +26,12 @@
     <PackageReference Include="Microsoft.Win32.Registry" Version="4.5.0" />
   </ItemGroup>
   <ItemGroup Label="Package References">
+    <PackageReference Include="System.IO.Packaging" Version="4.5.0" />
+    <PackageReference Include="ppy.squirrel.windows" Version="1.8.0.5" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.1" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.1.1" />
-    <PackageReference Include="squirrel.windows" Version="1.8.0" Condition="'$(TargetFramework)' == 'net471'" />
   </ItemGroup>
   <ItemGroup Label="Resources">
     <EmbeddedResource Include="lazer.ico" />
   </ItemGroup>
-</Project>
+</Project>

osu.Desktop/osu.nuspec

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

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

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

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

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

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

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

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -93,13 +93,11 @@ namespace osu.Game.Rulesets.Catch
                         new CatchModHidden(),
                         new CatchModFlashlight(),
                     };
-                case ModType.Special:
+                case ModType.Automation:
                     return new Mod[]
                     {
-                        new CatchModRelax(),
-                        null,
-                        null,
                         new MultiMod(new CatchModAutoplay(), new ModCinema()),
+                        new CatchModRelax(),
                     };
                 default:
                     return new Mod[] { };

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

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

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

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

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

@@ -14,24 +14,20 @@ namespace osu.Game.Rulesets.Mania.Tests
     /// </summary>
     public class ScrollingTestContainer : Container
     {
-        private readonly ScrollingDirection direction;
+        [Cached(Type = typeof(IScrollingInfo))]
+        private readonly TestScrollingInfo scrollingInfo = new TestScrollingInfo();
 
         public ScrollingTestContainer(ScrollingDirection direction)
         {
-            this.direction = direction;
+            scrollingInfo.Direction.Value = direction;
         }
 
-        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
-        {
-            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
-            dependencies.CacheAs<IScrollingInfo>(new ScrollingInfo { Direction = { Value = direction }});
-            return dependencies;
-        }
+        public void Flip() => scrollingInfo.Direction.Value = scrollingInfo.Direction.Value == ScrollingDirection.Up ? ScrollingDirection.Down : ScrollingDirection.Up;
+    }
 
-        private class ScrollingInfo : IScrollingInfo
-        {
-            public readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
-            IBindable<ScrollingDirection> IScrollingInfo.Direction => Direction;
-        }
+    public class TestScrollingInfo : IScrollingInfo
+    {
+        public readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
+        IBindable<ScrollingDirection> IScrollingInfo.Direction => Direction;
     }
 }

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

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

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

@@ -46,15 +46,20 @@ namespace osu.Game.Rulesets.Mania.Tests
                 Spacing = new Vector2(20),
                 Children = new[]
                 {
-                    createNoteDisplay(ScrollingDirection.Down),
-                    createNoteDisplay(ScrollingDirection.Up),
-                    createHoldNoteDisplay(ScrollingDirection.Down),
-                    createHoldNoteDisplay(ScrollingDirection.Up),
+                    createNoteDisplay(ScrollingDirection.Down, 1, out var note1),
+                    createNoteDisplay(ScrollingDirection.Up, 2, out var note2),
+                    createHoldNoteDisplay(ScrollingDirection.Down, 1, out var holdNote1),
+                    createHoldNoteDisplay(ScrollingDirection.Up, 2, out var holdNote2),
                 }
             };
+
+            AddAssert("note 1 facing downwards", () => verifyAnchors(note1, Anchor.y2));
+            AddAssert("note 2 facing upwards", () => verifyAnchors(note2, Anchor.y0));
+            AddAssert("hold note 1 facing downwards", () => verifyAnchors(holdNote1, Anchor.y2));
+            AddAssert("hold note 2 facing upwards", () => verifyAnchors(holdNote2, Anchor.y0));
         }
 
-        private Drawable createNoteDisplay(ScrollingDirection direction)
+        private Drawable createNoteDisplay(ScrollingDirection direction, int identifier, out DrawableNote hitObject)
         {
             var note = new Note { StartTime = 999999999 };
             note.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
@@ -62,24 +67,24 @@ namespace osu.Game.Rulesets.Mania.Tests
             return new ScrollingTestContainer(direction)
             {
                 AutoSizeAxes = Axes.Both,
-                Child = new NoteContainer(direction, $"note, scrolling {direction.ToString().ToLowerInvariant()}")
+                Child = new NoteContainer(direction, $"note {identifier}, scrolling {direction.ToString().ToLowerInvariant()}")
                 {
-                    Child = new DrawableNote(note) { AccentColour = Color4.OrangeRed }
+                    Child = hitObject = new DrawableNote(note) { AccentColour = Color4.OrangeRed }
                 }
             };
         }
 
-        private Drawable createHoldNoteDisplay(ScrollingDirection direction)
+        private Drawable createHoldNoteDisplay(ScrollingDirection direction, int identifier, out DrawableHoldNote hitObject)
         {
-            var note = new HoldNote { StartTime = 999999999, Duration = 1000 };
+            var note = new HoldNote { StartTime = 999999999, Duration = 5000 };
             note.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
 
             return new ScrollingTestContainer(direction)
             {
                 AutoSizeAxes = Axes.Both,
-                Child = new NoteContainer(direction, $"hold note, scrolling {direction.ToString().ToLowerInvariant()}")
+                Child = new NoteContainer(direction, $"hold note {identifier}, scrolling {direction.ToString().ToLowerInvariant()}")
                 {
-                    Child = new DrawableHoldNote(note)
+                    Child = hitObject = new DrawableHoldNote(note)
                     {
                         RelativeSizeAxes = Axes.Both,
                         AccentColour = Color4.OrangeRed,
@@ -88,6 +93,12 @@ namespace osu.Game.Rulesets.Mania.Tests
             };
         }
 
+        private bool verifyAnchors(DrawableHitObject hitObject, Anchor expectedAnchor)
+            => hitObject.Anchor.HasFlag(expectedAnchor) && hitObject.Origin.HasFlag(expectedAnchor);
+
+        private bool verifyAnchors(DrawableHoldNote holdNote, Anchor expectedAnchor)
+            => verifyAnchors((DrawableHitObject)holdNote, expectedAnchor) && holdNote.NestedHitObjects.All(n => verifyAnchors(n, expectedAnchor));
+
         private class NoteContainer : Container
         {
             private readonly Container content;

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

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
@@ -24,6 +25,8 @@ namespace osu.Game.Rulesets.Mania.Tests
 
         private readonly List<ManiaStage> stages = new List<ManiaStage>();
 
+        private FillFlowContainer<ScrollingTestContainer> fill;
+
         public TestCaseStage()
             : base(columns)
         {
@@ -32,7 +35,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         [BackgroundDependencyLoader]
         private void load()
         {
-            Child = new FillFlowContainer
+            Child = fill = new FillFlowContainer<ScrollingTestContainer>
             {
                 RelativeSizeAxes = Axes.Both,
                 Anchor = Anchor.Centre,
@@ -54,8 +57,22 @@ namespace osu.Game.Rulesets.Mania.Tests
             AddStep("hold note", createHoldNote);
             AddStep("minor bar line", () => createBarLine(false));
             AddStep("major bar line", () => createBarLine(true));
+
+            AddAssert("check note anchors", () => notesInStageAreAnchored(stages[0], Anchor.TopCentre));
+            AddAssert("check note anchors", () => notesInStageAreAnchored(stages[1], Anchor.BottomCentre));
+
+            AddStep("flip direction", () =>
+            {
+                foreach (var c in fill.Children)
+                    c.Flip();
+            });
+
+            AddAssert("check note anchors", () => notesInStageAreAnchored(stages[0], Anchor.BottomCentre));
+            AddAssert("check note anchors", () => notesInStageAreAnchored(stages[1], Anchor.TopCentre));
         }
 
+        private bool notesInStageAreAnchored(ManiaStage stage, Anchor anchor) => stage.Columns.SelectMany(c => c.AllHitObjects).All(o => o.Anchor == anchor);
+
         private void createNote()
         {
             foreach (var stage in stages)
@@ -101,7 +118,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             }
         }
 
-        private Drawable createStage(ScrollingDirection direction, ManiaAction action)
+        private ScrollingTestContainer createStage(ScrollingDirection direction, ManiaAction action)
         {
             var specialAction = ManiaAction.Special1;
 

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

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

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

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

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

@@ -0,0 +1,39 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+
+namespace osu.Game.Rulesets.Mania.Edit.Layers.Selection.Overlays
+{
+    public class NoteMask : HitObjectMask
+    {
+        public NoteMask(DrawableNote note)
+            : base(note)
+        {
+            Scale = note.Scale;
+
+            CornerRadius = 5;
+            Masking = true;
+
+            AddInternal(new NotePiece());
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Colour = colours.Yellow;
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            Size = HitObject.DrawSize;
+            Position = Parent.ToLocalSpace(HitObject.ScreenSpaceDrawQuad.TopLeft);
+        }
+    }
+}

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

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

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

@@ -0,0 +1,27 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using OpenTK;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Mania.Edit
+{
+    public class ManiaEditRulesetContainer : ManiaRulesetContainer
+    {
+        public ManiaEditRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
+            : base(ruleset, beatmap)
+        {
+        }
+
+        protected override Playfield CreatePlayfield() => new ManiaEditPlayfield(Beatmap.Stages)
+        {
+            Anchor = Anchor.Centre,
+            Origin = Anchor.Centre,
+        };
+
+        protected override Vector2 PlayfieldArea => Vector2.One;
+    }
+}

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

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

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -19,9 +19,11 @@ using osu.Game.Configuration;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Edit;
 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;
 
 namespace osu.Game.Rulesets.Mania
@@ -32,6 +34,8 @@ namespace osu.Game.Rulesets.Mania
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new ManiaBeatmapConverter(beatmap);
         public override PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, Score score) => new ManiaPerformanceCalculator(this, beatmap, score);
 
+        public override HitObjectComposer CreateHitObjectComposer() => new ManiaHitObjectComposer(this);
+
         public override IEnumerable<Mod> ConvertLegacyMods(LegacyMods mods)
         {
             if (mods.HasFlag(LegacyMods.Nightcore))
@@ -120,7 +124,7 @@ namespace osu.Game.Rulesets.Mania
                         new MultiMod(new ManiaModFadeIn(), new ManiaModHidden()),
                         new ManiaModFlashlight(),
                     };
-                case ModType.Special:
+                case ModType.Conversion:
                     return new Mod[]
                     {
                         new MultiMod(new ManiaModKey4(),
@@ -135,6 +139,10 @@ namespace osu.Game.Rulesets.Mania
                         new ManiaModRandom(),
                         new ManiaModDualStages(),
                         new ManiaModMirror(),
+                    };
+                case ModType.Automation:
+                    return new Mod[]
+                    {
                         new MultiMod(new ManiaModAutoplay(), new ModCinema()),
                     };
                 default:

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

@@ -13,6 +13,7 @@ namespace osu.Game.Rulesets.Mania.Mods
     {
         public override string ShortenedName => 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
         public override bool Ranked => true;
 

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

@@ -16,6 +16,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override string Name => "Dual Stages";
         public override string ShortenedName => "DS";
         public override string Description => @"Double the stages, double the fun!";
+        public override ModType Type => ModType.Conversion;
         public override double ScoreMultiplier => 1;
 
         private bool isForCurrentRuleset;

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

@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Mania.Mods
     {
         public override string Name => "Mirror";
         public override string ShortenedName => "MR";
-        public override ModType Type => ModType.Special;
+        public override ModType Type => ModType.Conversion;
         public override double ScoreMultiplier => 1;
         public override bool Ranked => true;
 

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

@@ -16,6 +16,7 @@ namespace osu.Game.Rulesets.Mania.Mods
     {
         public override string Name => "Random";
         public override string ShortenedName => "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;

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

@@ -21,8 +21,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
     {
         public override bool DisplayJudgement => false;
 
-        private readonly DrawableNote head;
-        private readonly DrawableNote tail;
+        public readonly DrawableNote Head;
+        public readonly DrawableNote Tail;
 
         private readonly BodyPiece bodyPiece;
 
@@ -57,12 +57,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                         HoldStartTime = () => holdStartTime
                     })
                 },
-                head = new DrawableHeadNote(this)
+                Head = new DrawableHeadNote(this)
                 {
                     Anchor = Anchor.TopCentre,
                     Origin = Anchor.TopCentre
                 },
-                tail = new DrawableTailNote(this)
+                Tail = new DrawableTailNote(this)
                 {
                     Anchor = Anchor.TopCentre,
                     Origin = Anchor.TopCentre
@@ -72,8 +72,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             foreach (var tick in tickContainer)
                 AddNested(tick);
 
-            AddNested(head);
-            AddNested(tail);
+            AddNested(Head);
+            AddNested(Tail);
         }
 
         protected override void OnDirectionChanged(ScrollingDirection direction)
@@ -91,15 +91,15 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 base.AccentColour = value;
 
                 bodyPiece.AccentColour = value;
-                head.AccentColour = value;
-                tail.AccentColour = value;
+                Head.AccentColour = value;
+                Tail.AccentColour = value;
                 tickContainer.ForEach(t => t.AccentColour = value);
             }
         }
 
         protected override void CheckForJudgements(bool userTriggered, double timeOffset)
         {
-            if (tail.AllJudged)
+            if (Tail.AllJudged)
                 AddJudgement(new HoldNoteJudgement { Result = HitResult.Perfect });
         }
 
@@ -108,8 +108,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             base.Update();
 
             // Make the body piece not lie under the head note
-            bodyPiece.Y = (Direction.Value == ScrollingDirection.Up ? 1 : -1) * head.Height / 2;
-            bodyPiece.Height = DrawHeight - head.Height / 2 + tail.Height / 2;
+            bodyPiece.Y = (Direction.Value == ScrollingDirection.Up ? 1 : -1) * Head.Height / 2;
+            bodyPiece.Height = DrawHeight - Head.Height / 2 + Tail.Height / 2;
         }
 
         public bool OnPressed(ManiaAction action)
@@ -141,7 +141,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             holdStartTime = null;
 
             // If the key has been released too early, the user should not receive full score for the release
-            if (!tail.IsHit)
+            if (!Tail.IsHit)
                 hasBroken = true;
 
             return true;

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

@@ -8,7 +8,7 @@ using osu.Game.Rulesets.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
-    internal class DrawableManiaJudgement : DrawableJudgement
+    public class DrawableManiaJudgement : DrawableJudgement
     {
         public DrawableManiaJudgement(Judgement judgement, DrawableHitObject judgedObject)
             : base(judgement, judgedObject)

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

@@ -1,22 +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.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Mania.Objects;
 using osu.Framework.Graphics.Containers;
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using osu.Framework.Allocation;
 using osu.Game.Rulesets.Mania.Beatmaps;
-using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Mania.Configuration;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
     public class ManiaPlayfield : ManiaScrollingPlayfield
     {
-        public List<Column> Columns => stages.SelectMany(x => x.Columns).ToList();
         private readonly List<ManiaStage> stages = new List<ManiaStage>();
 
         public ManiaPlayfield(List<StageDefinition> stageDefinitions)

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

@@ -4,7 +4,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
-using osu.Framework.Configuration;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Input;
@@ -35,8 +34,7 @@ namespace osu.Game.Rulesets.Mania.UI
 
         public IEnumerable<BarLine> BarLines;
 
-        private readonly Bindable<ManiaScrollingDirection> configDirection = new Bindable<ManiaScrollingDirection>();
-        private ScrollingInfo scrollingInfo;
+        protected new ManiaConfigManager Config => (ManiaConfigManager)base.Config;
 
         public ManiaRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
@@ -73,9 +71,6 @@ namespace osu.Game.Rulesets.Mania.UI
         private void load()
         {
             BarLines.ForEach(Playfield.Add);
-
-            ((ManiaConfigManager)Config).BindWith(ManiaSetting.ScrollDirection, configDirection);
-            configDirection.BindValueChanged(d => scrollingInfo.Direction.Value = (ScrollingDirection)d, true);
         }
 
         private DependencyContainer dependencies;
@@ -83,11 +78,14 @@ namespace osu.Game.Rulesets.Mania.UI
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
             dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
-            dependencies.CacheAs<IScrollingInfo>(scrollingInfo = new ScrollingInfo());
+
+            if (dependencies.Get<ManiaScrollingInfo>() == null)
+                dependencies.CacheAs<IScrollingInfo>(new ManiaScrollingInfo(Config));
+
             return dependencies;
         }
 
-        protected sealed override Playfield CreatePlayfield() => new ManiaPlayfield(Beatmap.Stages)
+        protected override Playfield CreatePlayfield() => new ManiaPlayfield(Beatmap.Stages)
         {
             Anchor = Anchor.Centre,
             Origin = Anchor.Centre,
@@ -115,11 +113,5 @@ namespace osu.Game.Rulesets.Mania.UI
         protected override Vector2 PlayfieldArea => new Vector2(1, 0.8f);
 
         protected override ReplayInputHandler CreateReplayInputHandler(Replay replay) => new ManiaFramedReplayInputHandler(replay);
-
-        private class ScrollingInfo : IScrollingInfo
-        {
-            public readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
-            IBindable<ScrollingDirection> IScrollingInfo.Direction => Direction;
-        }
     }
 }

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

@@ -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.Framework.Configuration;
+using osu.Game.Rulesets.Mania.Configuration;
+using osu.Game.Rulesets.UI.Scrolling;
+
+namespace osu.Game.Rulesets.Mania.UI
+{
+    public class ManiaScrollingInfo : IScrollingInfo
+    {
+        private readonly Bindable<ManiaScrollingDirection> configDirection = new Bindable<ManiaScrollingDirection>();
+
+        public readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
+        IBindable<ScrollingDirection> IScrollingInfo.Direction => Direction;
+
+        public ManiaScrollingInfo(ManiaConfigManager config)
+        {
+            config.BindWith(ManiaSetting.ScrollDirection, configDirection);
+            configDirection.BindValueChanged(v => Direction.Value = (ScrollingDirection)v, true);
+        }
+    }
+}

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

@@ -23,7 +23,7 @@ namespace osu.Game.Rulesets.Mania.UI
     /// <summary>
     /// A collection of <see cref="Column"/>s.
     /// </summary>
-    internal class ManiaStage : ManiaScrollingPlayfield
+    public class ManiaStage : ManiaScrollingPlayfield
     {
         public const float HIT_TARGET_POSITION = 50;
 

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

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

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

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

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

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

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

@@ -12,6 +12,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Name => "Autopilot";
         public override string ShortenedName => "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.";
         public override double ScoreMultiplier => 1;
         public override Type[] IncompatibleMods => new[] { typeof(OsuModSpunOut), typeof(ModRelax), typeof(ModSuddenDeath), typeof(ModNoFail), typeof(ModAutoplay) };

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

@@ -12,6 +12,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Name => "Spun Out";
         public override string ShortenedName => "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.";
         public override double ScoreMultiplier => 0.9;
         public override bool Ranked => true;

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

@@ -10,6 +10,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => "Target";
         public override string ShortenedName => "TP";
+        public override ModType Type => ModType.Conversion;
         public override FontAwesome Icon => FontAwesome.fa_osu_mod_target;
         public override string Description => @"Practice keeping up with the beat of the song.";
         public override double ScoreMultiplier => 1;

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

@@ -7,6 +7,7 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
 {
@@ -20,27 +21,26 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
         {
             Origin = Anchor.Centre;
 
-            Masking = true;
-            AutoSizeAxes = Axes.Both;
-            CornerRadius = width / 2;
-            EdgeEffect = new EdgeEffectParameters
+            Child = new SkinnableDrawable("Play/osu/followpoint", _ => new Container
             {
-                Type = EdgeEffectType.Glow,
-                Colour = Color4.White.Opacity(0.2f),
-                Radius = 4,
-            };
-
-            Children = new Drawable[]
-            {
-                new Box
+                Masking = true,
+                AutoSizeAxes = Axes.Both,
+                CornerRadius = width / 2,
+                EdgeEffect = new EdgeEffectParameters
+                {
+                    Type = EdgeEffectType.Glow,
+                    Colour = Color4.White.Opacity(0.2f),
+                    Radius = 4,
+                },
+                Child = new Box
                 {
                     Size = new Vector2(width),
                     Blending = BlendingMode.Additive,
                     Origin = Anchor.Centre,
                     Anchor = Anchor.Centre,
                     Alpha = 0.5f,
-                },
-            };
+                }
+            }, restrictSize: false);
         }
     }
 }

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

@@ -73,7 +73,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
 
                     Vector2 distanceVector = endPosition - startPosition;
                     int distance = (int)distanceVector.Length;
-                    float rotation = (float)Math.Atan2(distanceVector.Y, distanceVector.X);
+                    float rotation = (float)(Math.Atan2(distanceVector.Y, distanceVector.X) * (180 / Math.PI));
                     double duration = endTime - startTime;
 
                     for (int d = (int)(PointDistance * 1.5); d < distance - PointDistance; d += PointDistance)

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

@@ -10,6 +10,7 @@ using OpenTK;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -33,11 +34,11 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             InternalChildren = new Drawable[]
             {
-                new SpriteIcon
+                new SkinnableDrawable("Play/osu/reversearrow", _ => new SpriteIcon
                 {
                     RelativeSizeAxes = Axes.Both,
                     Icon = FontAwesome.fa_chevron_right
-                }
+                }, restrictSize: false)
             };
         }
 
@@ -74,6 +75,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             }
         }
 
+        private bool hasRotation;
+
         public void UpdateSnakingPosition(Vector2 start, Vector2 end)
         {
             bool isRepeatAtEnd = repeatPoint.RepeatIndex % 2 == 0;
@@ -87,15 +90,33 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             int searchStart = isRepeatAtEnd ? curve.Count - 1 : 0;
             int direction = isRepeatAtEnd ? -1 : 1;
 
+            Vector2 aimRotationVector = Vector2.Zero;
+
             // find the next vector2 in the curve which is not equal to our current position to infer a rotation.
             for (int i = searchStart; i >= 0 && i < curve.Count; i += direction)
             {
                 if (Precision.AlmostEquals(curve[i], Position))
                     continue;
 
-                Rotation = MathHelper.RadiansToDegrees((float)Math.Atan2(curve[i].Y - Position.Y, curve[i].X - Position.X));
+                aimRotationVector = curve[i];
                 break;
             }
+
+
+            float aimRotation = MathHelper.RadiansToDegrees((float)Math.Atan2(aimRotationVector.Y - Position.Y, aimRotationVector.X - Position.X));
+            while (Math.Abs(aimRotation - Rotation) > 180)
+                aimRotation += aimRotation < Rotation ? 360 : -360;
+
+            if (!hasRotation)
+            {
+                Rotation = aimRotation;
+                hasRotation = true;
+            }
+            else
+            {
+                // If we're already snaking, interpolate to smooth out sharp curves (linear sliders, mainly).
+                Rotation = Interpolation.ValueAt(MathHelper.Clamp(Clock.ElapsedFrameTime, 0, 100), Rotation, aimRotation, 0, 50, Easing.OutQuint);
+            }
         }
     }
 }

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

@@ -8,6 +8,8 @@ using OpenTK.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Skinning;
+using osu.Framework.Graphics.Containers;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -22,23 +24,27 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         public DrawableSliderTick(SliderTick sliderTick) : base(sliderTick)
         {
             Size = new Vector2(16) * sliderTick.Scale;
-
-            Masking = true;
-            CornerRadius = Size.X / 2;
-
             Origin = Anchor.Centre;
 
-            BorderThickness = 2;
-            BorderColour = Color4.White;
-
             InternalChildren = new Drawable[]
             {
-                new Box
+                new SkinnableDrawable("Play/osu/sliderscorepoint", _ => new Container
                 {
+                    Masking = true,
                     RelativeSizeAxes = Axes.Both,
-                    Colour = AccentColour,
-                    Alpha = 0.3f,
-                }
+                    Origin = Anchor.Centre,
+                    CornerRadius = Size.X / 2,
+
+                    BorderThickness = 2,
+                    BorderColour = Color4.White,
+
+                    Child = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = AccentColour,
+                        Alpha = 0.3f,
+                    }
+                }, restrictSize: false)
             };
         }
 

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

@@ -10,6 +10,7 @@ using osu.Framework.Input.States;
 using osu.Game.Rulesets.Objects.Types;
 using OpenTK;
 using OpenTK.Graphics;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
@@ -18,6 +19,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
         private const float width = 128;
 
         private Color4 accentColour = Color4.Black;
+
         /// <summary>
         /// The colour that is used for the slider ball.
         /// </summary>
@@ -27,14 +29,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             set
             {
                 accentColour = value;
-                if (ball != null)
-                    ball.Colour = value;
+                if (drawableBall != null)
+                    drawableBall.Colour = value;
             }
         }
 
         private readonly Slider slider;
-        public readonly Box FollowCircle;
-        private readonly Box ball;
+        public readonly Drawable FollowCircle;
+        private Drawable drawableBall;
 
         public SliderBall(Slider slider)
         {
@@ -43,19 +45,30 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             AutoSizeAxes = Axes.Both;
             Blending = BlendingMode.Additive;
             Origin = Anchor.Centre;
-            BorderThickness = 10;
-            BorderColour = Color4.Orange;
 
-            Children = new Drawable[]
+            Children = new[]
             {
-                FollowCircle = new Box
+                FollowCircle = new Container
                 {
                     Origin = Anchor.Centre,
                     Anchor = Anchor.Centre,
-                    Colour = Color4.Orange,
                     Width = width,
                     Height = width,
                     Alpha = 0,
+                    Child = new SkinnableDrawable("Play/osu/sliderfollowcircle", _ => new CircularContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Masking = true,
+                        BorderThickness = 5,
+                        BorderColour = Color4.Orange,
+                        Blending = BlendingMode.Additive,
+                        Child = new Box
+                        {
+                            Colour = Color4.Orange,
+                            RelativeSizeAxes = Axes.Both,
+                            Alpha = 0.2f,
+                        }
+                    }),
                 },
                 new CircularContainer
                 {
@@ -63,18 +76,26 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                     AutoSizeAxes = Axes.Both,
                     Origin = Anchor.Centre,
                     Anchor = Anchor.Centre,
-                    BorderThickness = 10,
-                    BorderColour = Color4.White,
                     Alpha = 1,
-                    Children = new[]
+                    Child = new Container
                     {
-                        ball = new Box
+                        Width = width,
+                        Height = width,
+                        // TODO: support skin filename animation (sliderb0, sliderb1...)
+                        Child = new SkinnableDrawable("Play/osu/sliderb", _ => new CircularContainer
                         {
-                            Colour = AccentColour,
-                            Alpha = 0.4f,
-                            Width = width,
-                            Height = width,
-                        },
+                            Masking = true,
+                            RelativeSizeAxes = Axes.Both,
+                            BorderThickness = 10,
+                            BorderColour = Color4.White,
+                            Alpha = 1,
+                            Child = drawableBall = new Box
+                            {
+                                Colour = AccentColour,
+                                RelativeSizeAxes = Axes.Both,
+                                Alpha = 0.4f,
+                            }
+                        }),
                     }
                 }
             };
@@ -111,6 +132,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
         }
 
         private bool tracking;
+
         public bool Tracking
         {
             get { return tracking; }
@@ -120,8 +142,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                     return;
                 tracking = value;
 
-                FollowCircle.ScaleTo(tracking ? 2.8f : 1, 300, Easing.OutQuint);
-                FollowCircle.FadeTo(tracking ? 0.2f : 0, 300, Easing.OutQuint);
+                FollowCircle.ScaleTo(tracking ? 2f : 1, 300, Easing.OutQuint);
+                FollowCircle.FadeTo(tracking ? 1f : 0, 300, Easing.OutQuint);
             }
         }
 

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

@@ -16,6 +16,9 @@ namespace osu.Game.Rulesets.Osu.Objects
         {
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
 
+            // Out preempt should be one span early to give the user ample warning.
+            TimePreempt += SpanDuration;
+
             // We want to show the first RepeatPoint as the TimePreempt dictates but on short (and possibly fast) sliders
             // we may need to cut down this time on following RepeatPoints to only show up to two RepeatPoints at any given time.
             if (RepeatIndex > 0)

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -94,6 +94,7 @@ namespace osu.Game.Rulesets.Osu
                         new OsuModEasy(),
                         new OsuModNoFail(),
                         new MultiMod(new OsuModHalfTime(), new OsuModDaycore()),
+                        new OsuModSpunOut(),
                     };
                 case ModType.DifficultyIncrease:
                     return new Mod[]
@@ -104,14 +105,17 @@ namespace osu.Game.Rulesets.Osu
                         new OsuModHidden(),
                         new OsuModFlashlight(),
                     };
-                case ModType.Special:
+                case ModType.Conversion:
                     return new Mod[]
                     {
+                        new OsuModTarget(),
+                    };
+                case ModType.Automation:
+                    return new Mod[]
+                    {
+                        new MultiMod(new OsuModAutoplay(), new ModCinema()),
                         new OsuModRelax(),
                         new OsuModAutopilot(),
-                        new OsuModSpunOut(),
-                        new MultiMod(new OsuModAutoplay(), new ModCinema()),
-                        new OsuModTarget(),
                     };
                 default:
                     return new Mod[] { };

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

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

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

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

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

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

osu.Game.Rulesets.Taiko/TaikoRuleset.cs

@@ -93,13 +93,11 @@ namespace osu.Game.Rulesets.Taiko
                         new TaikoModHidden(),
                         new TaikoModFlashlight(),
                     };
-                case ModType.Special:
+                case ModType.Automation:
                     return new Mod[]
                     {
-                        new TaikoModRelax(),
-                        null,
-                        null,
                         new MultiMod(new TaikoModAutoplay(), new ModCinema()),
+                        new TaikoModRelax(),
                     };
                 default:
                     return new Mod[] { };

osu.Game.Tests/Visual/TestCaseMods.cs

@@ -2,7 +2,6 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
-using System.ComponentModel;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Overlays.Mods;
@@ -13,10 +12,11 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
 using System.Linq;
 using System.Collections.Generic;
-using osu.Game.Rulesets.Osu;
+using NUnit.Framework;
+using osu.Framework.Configuration;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Graphics.Sprites;
-using osu.Game.Rulesets.Mania;
+using osu.Game.Overlays.Mods.Sections;
 using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.UI;
 using OpenTK.Graphics;
@@ -36,7 +36,9 @@ namespace osu.Game.Tests.Visual
             typeof(ModButtonEmpty),
             typeof(DifficultyReductionSection),
             typeof(DifficultyIncreaseSection),
-            typeof(SpecialSection),
+            typeof(AutomationSection),
+            typeof(ConversionSection),
+            typeof(FunSection),
         };
 
         private RulesetStore rulesets;
@@ -47,11 +49,6 @@ namespace osu.Game.Tests.Visual
         private void load(RulesetStore rulesets)
         {
             this.rulesets = rulesets;
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
 
             Add(modSelect = new TestModSelectOverlay
             {
@@ -68,34 +65,25 @@ namespace osu.Game.Tests.Visual
                 Position = new Vector2(0, 25),
             });
 
+            modDisplay.Current.UnbindBindings();
             modDisplay.Current.BindTo(modSelect.SelectedMods);
 
-            AddStep("Toggle", modSelect.ToggleVisibility);
-            AddStep("Hide", modSelect.Hide);
             AddStep("Show", modSelect.Show);
-
-            foreach (var rulesetInfo in rulesets.AvailableRulesets)
-            {
-                Ruleset ruleset = rulesetInfo.CreateInstance();
-                AddStep($"switch to {ruleset.Description}", () => Ruleset.Value = rulesetInfo);
-
-                switch (ruleset)
-                {
-                    case OsuRuleset or:
-                        testOsuMods(or);
-                        break;
-                    case ManiaRuleset mr:
-                        testManiaMods(mr);
-                        break;
-                }
-            }
+            AddStep("Toggle", modSelect.ToggleVisibility);
+            AddStep("Toggle", modSelect.ToggleVisibility);
         }
 
-        private void testOsuMods(OsuRuleset ruleset)
+        [Test]
+        public void TestOsuMods()
         {
-            var easierMods = ruleset.GetModsFor(ModType.DifficultyReduction);
-            var harderMods = ruleset.GetModsFor(ModType.DifficultyIncrease);
-            var assistMods = ruleset.GetModsFor(ModType.Special);
+            var ruleset = rulesets.AvailableRulesets.First(r => r.ID == 0);
+            AddStep("change ruleset", () => { Ruleset.Value = ruleset; });
+
+            var instance = ruleset.CreateInstance();
+
+            var easierMods = instance.GetModsFor(ModType.DifficultyReduction);
+            var harderMods = instance.GetModsFor(ModType.DifficultyIncrease);
+            var assistMods = instance.GetModsFor(ModType.Automation);
 
             var noFailMod = easierMods.FirstOrDefault(m => m is OsuModNoFail);
             var hiddenMod = harderMods.FirstOrDefault(m => m is OsuModHidden);
@@ -117,9 +105,40 @@ namespace osu.Game.Tests.Visual
             testUnimplementedMod(autoPilotMod);
         }
 
-        private void testManiaMods(ManiaRuleset ruleset)
+        [Test]
+        public void TestManiaMods()
         {
-            testRankedText(ruleset.GetModsFor(ModType.Special).First(m => m is ManiaModRandom));
+            var ruleset = rulesets.AvailableRulesets.First(r => r.ID == 3);
+            AddStep("change ruleset", () => { Ruleset.Value = ruleset; });
+
+            testRankedText(ruleset.CreateInstance().GetModsFor(ModType.Conversion).First(m => m is ManiaModRandom));
+        }
+
+        [Test]
+        public void TestRulesetChanges()
+        {
+            var rulesetOsu = rulesets.AvailableRulesets.First(r => r.ID == 0);
+            var rulesetMania = rulesets.AvailableRulesets.First(r => r.ID == 3);
+
+            AddStep("change ruleset to null", () => { Ruleset.Value = null; });
+
+            var instance = rulesetOsu.CreateInstance();
+            var easierMods = instance.GetModsFor(ModType.DifficultyReduction);
+            var noFailMod = easierMods.FirstOrDefault(m => m is OsuModNoFail);
+
+            AddStep("set mods externally", () => { modDisplay.Current.Value = new[] { noFailMod }; });
+
+            AddStep("change ruleset to osu", () => { Ruleset.Value = rulesetOsu; });
+
+            AddAssert("ensure mods still selected", () => modDisplay.Current.Value.Single(m => m is OsuModNoFail) != null);
+
+            AddStep("change ruleset to mania", () => { Ruleset.Value = rulesetMania; });
+
+            AddAssert("ensure mods not selected", () => !modDisplay.Current.Value.Any(m => m is OsuModNoFail));
+
+            AddStep("change ruleset to osu", () => { Ruleset.Value = rulesetOsu; });
+
+            AddAssert("ensure mods not selected", () => !modDisplay.Current.Value.Any());
         }
 
         private void testSingleMod(Mod mod)
@@ -234,6 +253,8 @@ namespace osu.Game.Tests.Visual
 
         private class TestModSelectOverlay : ModSelectOverlay
         {
+            public new Bindable<IEnumerable<Mod>> SelectedMods => base.SelectedMods;
+
             public ModButton GetModButton(Mod mod)
             {
                 var section = ModSectionsContainer.Children.Single(s => s.ModType == mod.Type);

osu.Game.Tests/Visual/TestCasePlayerLoader.cs

@@ -1,25 +1,61 @@
 // 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.Threading;
 using osu.Framework.Allocation;
 using osu.Game.Beatmaps;
 using osu.Game.Screens.Play;
 
 namespace osu.Game.Tests.Visual
 {
-    public class TestCasePlayerLoader : OsuTestCase
+    public class TestCasePlayerLoader : ManualInputManagerTestCase
     {
+        private PlayerLoader loader;
+
         [BackgroundDependencyLoader]
         private void load(OsuGameBase game)
         {
             Beatmap.Value = new DummyWorkingBeatmap(game);
 
-            AddStep("load dummy beatmap", () => Add(new PlayerLoader(new Player
+            AddStep("load dummy beatmap", () => Add(loader = new PlayerLoader(new Player
             {
                 AllowPause = false,
                 AllowLeadIn = false,
                 AllowResults = false,
             })));
+
+            AddStep("mouse in centre", () => InputManager.MoveMouseTo(loader.ScreenSpaceDrawQuad.Centre));
+
+            AddUntilStep(() => !loader.IsCurrentScreen, "wait for no longer current");
+
+            AddStep("load slow dummy beatmap", () =>
+            {
+                SlowLoadPlayer slow;
+
+                Add(loader = new PlayerLoader(slow = new SlowLoadPlayer
+                {
+                    AllowPause = false,
+                    AllowLeadIn = false,
+                    AllowResults = false,
+                }));
+
+                Scheduler.AddDelayed(() => slow.Ready = true, 5000);
+            });
+
+            AddUntilStep(() => !loader.IsCurrentScreen, "wait for no longer current");
+        }
+
+        protected class SlowLoadPlayer : Player
+        {
+            public bool Ready;
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                while (!Ready)
+                    Thread.Sleep(1);
+            }
         }
     }
+
 }

osu.Game.Tests/Visual/TestCaseScreenBreadcrumbControl.cs

@@ -54,11 +54,11 @@ namespace osu.Game.Tests.Visual
 
             breadcrumbs.Current.TriggerChange();
 
-            assertCurrent();
+            waitForCurrent();
             pushNext();
-            assertCurrent();
+            waitForCurrent();
             pushNext();
-            assertCurrent();
+            waitForCurrent();
 
             AddStep(@"make start current", () =>
             {
@@ -66,8 +66,9 @@ namespace osu.Game.Tests.Visual
                 currentScreen = startScreen;
             });
 
-            assertCurrent();
+            waitForCurrent();
             pushNext();
+            waitForCurrent();
             AddAssert(@"only 2 items", () => breadcrumbs.Items.Count() == 2);
             AddStep(@"exit current", () => changedScreen.Exit());
             AddAssert(@"current screen is first", () => startScreen == changedScreen);
@@ -80,7 +81,7 @@ namespace osu.Game.Tests.Visual
         }
 
         private void pushNext() => AddStep(@"push next screen", () => currentScreen = ((TestScreen)currentScreen).PushNext());
-        private void assertCurrent() => AddAssert(@"changedScreen correct", () => currentScreen == changedScreen);
+        private void waitForCurrent() => AddUntilStep(() => currentScreen.IsCurrentScreen, "current screen");
 
         private abstract class TestScreen : OsuScreen
         {

osu.Game.Tests/osu.Game.Tests.csproj

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

osu.Game/Graphics/UserInterface/OsuTabControl.cs

@@ -37,7 +37,7 @@ namespace osu.Game.Graphics.UserInterface
         {
             TabContainer.Spacing = new Vector2(10f, 0f);
 
-            Add(strip = new Box
+            AddInternal(strip = new Box
             {
                 Anchor = Anchor.BottomLeft,
                 Origin = Anchor.BottomLeft,

osu.Game/Online/Chat/InfoMessage.cs

@@ -6,7 +6,7 @@ using osu.Game.Users;
 
 namespace osu.Game.Online.Chat
 {
-    public class InfoMessage : Message
+    public class InfoMessage : LocalMessage
     {
         private static int infoID = -1;
 

osu.Game/Online/Chat/LocalEchoMessage.cs

@@ -3,7 +3,7 @@
 
 namespace osu.Game.Online.Chat
 {
-    public class LocalEchoMessage : Message
+    public class LocalEchoMessage : LocalMessage
     {
         public LocalEchoMessage() : base(null)
         {

osu.Game/Online/Chat/LocalMessage.cs

@@ -0,0 +1,16 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Online.Chat
+{
+    /// <summary>
+    /// A message which is generated and displayed locally.
+    /// </summary>
+    public class LocalMessage : Message
+    {
+        protected LocalMessage(long? id)
+            : base(id)
+        {
+        }
+    }
+}

osu.Game/OsuGame.cs

@@ -99,7 +99,9 @@ namespace osu.Game
         private readonly List<OverlayContainer> overlays = new List<OverlayContainer>();
 
         // todo: move this to SongSelect once Screen has the ability to unsuspend.
-        public readonly Bindable<IEnumerable<Mod>> SelectedMods = new Bindable<IEnumerable<Mod>>(new List<Mod>());
+        [Cached]
+        [Cached(Type = typeof(IBindable<IEnumerable<Mod>>))]
+        private readonly Bindable<IEnumerable<Mod>> selectedMods = new Bindable<IEnumerable<Mod>>(new Mod[] { });
 
         public OsuGame(string[] args = null)
         {

osu.Game/Overlays/BeatmapSet/Buttons/DownloadButton.cs

@@ -1,18 +1,28 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Drawables;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Online.API;
+using osu.Game.Users;
 using OpenTK;
+using OpenTK.Graphics;
 
 namespace osu.Game.Overlays.BeatmapSet.Buttons
 {
-    public class DownloadButton : HeaderButton
+    public class DownloadButton : HeaderButton, IHasTooltip
     {
+        public string TooltipText => Enabled ? null : "You gotta be an osu!supporter to download for now 'yo";
+
+        private readonly IBindable<User> localUser = new Bindable<User>();
+
         public DownloadButton(BeatmapSetInfo set, bool noVideo = false)
         {
             Width = 120;
@@ -86,5 +96,17 @@ namespace osu.Game.Overlays.BeatmapSet.Buttons
                 }
             };
         }
+
+        [BackgroundDependencyLoader]
+        private void load(APIAccess api)
+        {
+            localUser.BindTo(api.LocalUser);
+            localUser.BindValueChanged(userChanged, true);
+            Enabled.BindValueChanged(enabledChanged, true);
+        }
+
+        private void userChanged(User user) => Enabled.Value = user.IsSupporter;
+
+        private void enabledChanged(bool enabled) => this.FadeColour(enabled ? Color4.White : Color4.Gray, 200, Easing.OutQuint);
     }
 }

osu.Game/Overlays/Chat/DrawableChannel.cs

@@ -85,7 +85,7 @@ namespace osu.Game.Overlays.Chat
 
             if (!IsLoaded) return;
 
-            if (scroll.IsScrolledToEnd(10) || !flow.Children.Any())
+            if (scroll.IsScrolledToEnd(10) || !flow.Children.Any() || newMessages.Any(m => m is LocalMessage))
                 scrollToEnd();
 
             var staleMessages = flow.Children.Where(c => c.LifetimeEnd == double.MaxValue).ToArray();

osu.Game/Overlays/Direct/DirectListPanel.cs

@@ -12,7 +12,6 @@ using osu.Game.Graphics.Sprites;
 using osu.Framework.Allocation;
 using osu.Framework.Localisation;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.States;
 using osu.Game.Beatmaps;
 
 namespace osu.Game.Overlays.Direct
@@ -26,12 +25,14 @@ namespace osu.Game.Overlays.Direct
 
         private PlayButton playButton;
         private Box progressBar;
-        private Container downloadContainer;
+
+        protected override bool FadePlayButton => false;
 
         protected override PlayButton PlayButton => playButton;
         protected override Box PreviewBar => progressBar;
 
-        public DirectListPanel(BeatmapSetInfo beatmap) : base(beatmap)
+        public DirectListPanel(BeatmapSetInfo beatmap)
+            : base(beatmap)
         {
             RelativeSizeAxes = Axes.X;
             Height = height;
@@ -66,30 +67,45 @@ namespace osu.Game.Overlays.Direct
                             Spacing = new Vector2(10, 0),
                             Children = new Drawable[]
                             {
-                                playButton = new PlayButton(SetInfo)
-                                {
-                                    Origin = Anchor.CentreLeft,
-                                    Anchor = Anchor.CentreLeft,
-                                    Size = new Vector2(height / 2),
-                                    FillMode = FillMode.Fit,
-                                    Alpha = 0,
-                                },
                                 new FillFlowContainer
                                 {
                                     AutoSizeAxes = Axes.Both,
                                     Direction = FillDirection.Vertical,
                                     Children = new Drawable[]
                                     {
-                                        new OsuSpriteText
+                                        new FillFlowContainer
                                         {
-                                            Current = localisation.GetUnicodePreference(SetInfo.Metadata.TitleUnicode, SetInfo.Metadata.Title),
-                                            TextSize = 18,
-                                            Font = @"Exo2.0-BoldItalic",
-                                        },
-                                        new OsuSpriteText
-                                        {
-                                            Current = localisation.GetUnicodePreference(SetInfo.Metadata.ArtistUnicode, SetInfo.Metadata.Artist),
-                                            Font = @"Exo2.0-BoldItalic",
+                                            AutoSizeAxes = Axes.Both,
+                                            Direction = FillDirection.Horizontal,
+                                            Children = new Drawable[]
+                                            {
+                                                playButton = new PlayButton(SetInfo)
+                                                {
+                                                    Origin = Anchor.CentreLeft,
+                                                    Anchor = Anchor.CentreLeft,
+                                                    Size = new Vector2(height / 2),
+                                                    FillMode = FillMode.Fit,
+                                                },
+                                                new FillFlowContainer
+                                                {
+                                                    AutoSizeAxes = Axes.Both,
+                                                    Direction = FillDirection.Vertical,
+                                                    Children = new Drawable[]
+                                                    {
+                                                        new OsuSpriteText
+                                                        {
+                                                            Current = localisation.GetUnicodePreference(SetInfo.Metadata.TitleUnicode, SetInfo.Metadata.Title),
+                                                            TextSize = 18,
+                                                            Font = @"Exo2.0-BoldItalic",
+                                                        },
+                                                        new OsuSpriteText
+                                                        {
+                                                            Current = localisation.GetUnicodePreference(SetInfo.Metadata.ArtistUnicode, SetInfo.Metadata.Artist),
+                                                            Font = @"Exo2.0-BoldItalic",
+                                                        },
+                                                    }
+                                                },
+                                            }
                                         },
                                         new FillFlowContainer
                                         {
@@ -108,16 +124,13 @@ namespace osu.Game.Overlays.Direct
                             Origin = Anchor.TopRight,
                             AutoSizeAxes = Axes.Both,
                             Direction = FillDirection.Horizontal,
-                            LayoutEasing = Easing.OutQuint,
-                            LayoutDuration = transition_duration,
                             Children = new Drawable[]
                             {
-                                downloadContainer = new Container
+                                new Container
                                 {
-                                    Anchor = Anchor.TopRight,
-                                    Origin = Anchor.TopRight,
+                                    Anchor = Anchor.CentreRight,
+                                    Origin = Anchor.CentreRight,
                                     AutoSizeAxes = Axes.Both,
-                                    Alpha = 0,
                                     Child = new DownloadButton(SetInfo)
                                     {
                                         Size = new Vector2(height - vertical_padding * 3),
@@ -184,17 +197,5 @@ namespace osu.Game.Overlays.Direct
                 },
             });
         }
-
-        protected override bool OnHover(InputState state)
-        {
-            downloadContainer.FadeIn(transition_duration, Easing.InOutQuint);
-            return base.OnHover(state);
-        }
-
-        protected override void OnHoverLost(InputState state)
-        {
-            downloadContainer.FadeOut(transition_duration, Easing.InOutQuint);
-            base.OnHoverLost(state);
-        }
     }
 }

osu.Game/Overlays/Direct/DirectPanel.cs

@@ -40,6 +40,8 @@ namespace osu.Game.Overlays.Direct
         protected abstract PlayButton PlayButton { get; }
         protected abstract Box PreviewBar { get; }
 
+        protected virtual bool FadePlayButton => true;
+
         protected override Container<Drawable> Content => content;
 
         protected DirectPanel(BeatmapSetInfo setInfo)
@@ -125,7 +127,8 @@ namespace osu.Game.Overlays.Direct
         {
             content.TweenEdgeEffectTo(edgeEffectHovered, hover_transition_time, Easing.OutQuint);
             content.MoveToY(-4, hover_transition_time, Easing.OutQuint);
-            PlayButton.FadeIn(120, Easing.InOutQuint);
+            if (FadePlayButton)
+                PlayButton.FadeIn(120, Easing.InOutQuint);
 
             return base.OnHover(state);
         }
@@ -134,7 +137,7 @@ namespace osu.Game.Overlays.Direct
         {
             content.TweenEdgeEffectTo(edgeEffectNormal, hover_transition_time, Easing.OutQuint);
             content.MoveToY(0, hover_transition_time, Easing.OutQuint);
-            if (!PreviewPlaying)
+            if (FadePlayButton && !PreviewPlaying)
                 PlayButton.FadeOut(120, Easing.InOutQuint);
 
             base.OnHoverLost(state);

osu.Game/Overlays/Mods/ModSection.cs

@@ -2,7 +2,6 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using OpenTK;
-using OpenTK.Graphics;
 using OpenTK.Input;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -45,7 +44,6 @@ namespace osu.Game.Overlays.Mods
 
                     return new ModButton(m)
                     {
-                        SelectedColour = selectedColour,
                         SelectionChanged = Action,
                     };
                 }).ToArray();
@@ -57,25 +55,14 @@ namespace osu.Game.Overlays.Mods
 
         private ModButton[] buttons = { };
 
-        private Color4 selectedColour = Color4.White;
-        public Color4 SelectedColour
-        {
-            get => selectedColour;
-            set
-            {
-                if (value == selectedColour) return;
-                selectedColour = value;
-
-                foreach (ModButton button in buttons)
-                    button.SelectedColour = value;
-            }
-        }
-
         protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
         {
-            var index = Array.IndexOf(ToggleKeys, args.Key);
-            if (index > -1 && index < buttons.Length)
-                buttons[index].SelectNext(state.Keyboard.ShiftPressed ? -1 : 1);
+            if (ToggleKeys != null)
+            {
+                var index = Array.IndexOf(ToggleKeys, args.Key);
+                if (index > -1 && index < buttons.Length)
+                    buttons[index].SelectNext(state.Keyboard.ShiftPressed ? -1 : 1);
+            }
 
             return base.OnKeyDown(state, args);
         }
@@ -125,6 +112,10 @@ namespace osu.Game.Overlays.Mods
         protected ModSection()
         {
             AutoSizeAxes = Axes.Y;
+            RelativeSizeAxes = Axes.X;
+
+            Origin = Anchor.TopCentre;
+            Anchor = Anchor.TopCentre;
 
             Children = new Drawable[]
             {

osu.Game/Overlays/Mods/ModSelectOverlay.cs

@@ -21,6 +21,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics.Containers;
 using osu.Game.Rulesets;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Overlays.Mods.Sections;
 
 namespace osu.Game.Overlays.Mods
 {
@@ -38,9 +39,39 @@ namespace osu.Game.Overlays.Mods
 
         protected readonly FillFlowContainer<ModSection> ModSectionsContainer;
 
-        public readonly Bindable<IEnumerable<Mod>> SelectedMods = new Bindable<IEnumerable<Mod>>();
+        protected readonly Bindable<IEnumerable<Mod>> SelectedMods = new Bindable<IEnumerable<Mod>>(new Mod[] { });
 
-        public readonly IBindable<RulesetInfo> Ruleset = new Bindable<RulesetInfo>();
+        protected readonly IBindable<RulesetInfo> Ruleset = new Bindable<RulesetInfo>();
+
+        [BackgroundDependencyLoader(true)]
+        private void load(OsuColour colours, IBindable<RulesetInfo> ruleset, AudioManager audio, Bindable<IEnumerable<Mod>> selectedMods)
+        {
+            LowMultiplierColour = colours.Red;
+            HighMultiplierColour = colours.Green;
+            UnrankedLabel.Colour = colours.Blue;
+
+            Ruleset.BindTo(ruleset);
+            if (selectedMods != null) SelectedMods.BindTo(selectedMods);
+
+            sampleOn = audio.Sample.Get(@"UI/check-on");
+            sampleOff = audio.Sample.Get(@"UI/check-off");
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Ruleset.BindValueChanged(rulesetChanged, true);
+            SelectedMods.BindValueChanged(selectedModsChanged, true);
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            Ruleset.UnbindAll();
+            SelectedMods.UnbindAll();
+        }
 
         private void rulesetChanged(RulesetInfo newRuleset)
         {
@@ -50,33 +81,16 @@ namespace osu.Game.Overlays.Mods
 
             foreach (ModSection section in ModSectionsContainer.Children)
                 section.Mods = instance.GetModsFor(section.ModType);
+
+            // attempt to re-select any already selected mods.
+            // this may be the first time we are receiving the ruleset, in which case they will still match.
+            selectedModsChanged(SelectedMods.Value);
+
+            // write the mods back to the SelectedMods bindable in the case a change was not applicable.
+            // this generally isn't required as the previous line will perform deselection; just here for safety.
             refreshSelectedMods();
         }
 
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours, IBindable<RulesetInfo> ruleset, AudioManager audio)
-        {
-            SelectedMods.ValueChanged += selectedModsChanged;
-
-            LowMultiplierColour = colours.Red;
-            HighMultiplierColour = colours.Green;
-            UnrankedLabel.Colour = colours.Blue;
-
-            Ruleset.BindTo(ruleset);
-            Ruleset.BindValueChanged(rulesetChanged, true);
-
-            sampleOn = audio.Sample.Get(@"UI/check-on");
-            sampleOff = audio.Sample.Get(@"UI/check-off");
-        }
-
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-
-            Ruleset.UnbindAll();
-            SelectedMods.UnbindAll();
-        }
-
         private void selectedModsChanged(IEnumerable<Mod> obj)
         {
             foreach (ModSection section in ModSectionsContainer.Children)
@@ -175,10 +189,7 @@ namespace osu.Game.Overlays.Mods
             refreshSelectedMods();
         }
 
-        private void refreshSelectedMods()
-        {
-            SelectedMods.Value = ModSectionsContainer.Children.SelectMany(s => s.SelectedMods).ToArray();
-        }
+        private void refreshSelectedMods() => SelectedMods.Value = ModSectionsContainer.Children.SelectMany(s => s.SelectedMods).ToArray();
 
         public ModSelectOverlay()
         {
@@ -188,6 +199,7 @@ namespace osu.Game.Overlays.Mods
             Waves.FourthWaveColour = OsuColour.FromHex(@"003a4e");
 
             Height = 510;
+
             Children = new Drawable[]
             {
                 new Container
@@ -211,178 +223,172 @@ namespace osu.Game.Overlays.Mods
                         },
                     },
                 },
-                new FillFlowContainer
+                new GridContainer
                 {
-                    RelativeSizeAxes = Axes.X,
-                    AutoSizeAxes = Axes.Y,
+                    RelativeSizeAxes = Axes.Both,
                     Anchor = Anchor.BottomCentre,
                     Origin = Anchor.BottomCentre,
-                    Direction = FillDirection.Vertical,
-                    Spacing = new Vector2(0f, 10f),
-                    Children = new Drawable[]
+                    RowDimensions = new[]
                     {
-                        // Header
-                        new Container
+                        new Dimension(GridSizeMode.Absolute, 90),
+                        new Dimension(GridSizeMode.Distributed),
+                        new Dimension(GridSizeMode.Absolute, 70),
+                    },
+                    Content = new[]
+                    {
+                        new Drawable[]
                         {
-                            RelativeSizeAxes = Axes.X,
-                            Height = 82,
-                            Origin = Anchor.TopCentre,
-                            Anchor = Anchor.TopCentre,
-                            Children = new Drawable[]
+                            new Container
                             {
-                                new Box
+                                RelativeSizeAxes = Axes.Both,
+                                Origin = Anchor.TopCentre,
+                                Anchor = Anchor.TopCentre,
+                                Children = new Drawable[]
                                 {
-                                    RelativeSizeAxes = Axes.Both,
-                                    Colour = OsuColour.Gray(10).Opacity(100),
-                                },
-                                new FillFlowContainer
-                                {
-                                    Origin = Anchor.TopCentre,
-                                    Anchor = Anchor.TopCentre,
-                                    RelativeSizeAxes = Axes.X,
-                                    AutoSizeAxes = Axes.Y,
-                                    Direction = FillDirection.Vertical,
-                                    Width = content_width,
-                                    Padding = new MarginPadding
+                                    new Box
                                     {
-                                        Top = 10,
-                                        Bottom = 10,
+                                        RelativeSizeAxes = Axes.Both,
+                                        Colour = OsuColour.Gray(10).Opacity(100),
                                     },
-                                    Children = new Drawable[]
+                                    new FillFlowContainer
                                     {
-                                        new OsuSpriteText
+                                        Origin = Anchor.Centre,
+                                        Anchor = Anchor.Centre,
+                                        RelativeSizeAxes = Axes.X,
+                                        AutoSizeAxes = Axes.Y,
+                                        Direction = FillDirection.Vertical,
+                                        Width = content_width,
+                                        Children = new Drawable[]
                                         {
-                                            Font = @"Exo2.0-Bold",
-                                            Text = @"Gameplay Mods",
-                                            TextSize = 22,
-                                            Shadow = true,
-                                            Margin = new MarginPadding
+                                            new OsuSpriteText
                                             {
-                                                Bottom = 4,
+                                                Font = @"Exo2.0-Bold",
+                                                Text = @"Gameplay Mods",
+                                                TextSize = 22,
+                                                Shadow = true,
+                                                Margin = new MarginPadding
+                                                {
+                                                    Bottom = 4,
+                                                },
+                                            },
+                                            new OsuTextFlowContainer(text =>
+                                            {
+                                                text.TextSize = 18;
+                                                text.Shadow = true;
+                                            })
+                                            {
+                                                RelativeSizeAxes = Axes.X,
+                                                AutoSizeAxes = Axes.Y,
+                                                Text = "Mods provide different ways to enjoy gameplay. Some have an effect on the score you can achieve during ranked play.\nOthers are just for fun.",
                                             },
-                                        },
-                                        new OsuSpriteText
-                                        {
-                                            Text = @"Mods provide different ways to enjoy gameplay. Some have an effect on the score you can achieve during ranked play.",
-                                            TextSize = 18,
-                                            Shadow = true,
-                                        },
-                                        new OsuSpriteText
-                                        {
-                                            Text = @"Others are just for fun.",
-                                            TextSize = 18,
-                                            Shadow = true,
                                         },
                                     },
                                 },
                             },
                         },
-                        // Body
-                        ModSectionsContainer = new FillFlowContainer<ModSection>
+                        new Drawable[]
                         {
-                            Origin = Anchor.TopCentre,
-                            Anchor = Anchor.TopCentre,
-                            RelativeSizeAxes = Axes.X,
-                            AutoSizeAxes = Axes.Y,
-                            Spacing = new Vector2(0f, 10f),
-                            Width = content_width,
-                            Children = new ModSection[]
+                            // Body
+                            new OsuScrollContainer
                             {
-                                new DifficultyReductionSection
+                                ScrollbarVisible = false,
+                                Origin = Anchor.TopCentre,
+                                Anchor = Anchor.TopCentre,
+                                RelativeSizeAxes = Axes.Both,
+                                Padding = new MarginPadding { Vertical = 10 },
+                                Child = ModSectionsContainer = new FillFlowContainer<ModSection>
                                 {
-                                    RelativeSizeAxes = Axes.X,
                                     Origin = Anchor.TopCentre,
                                     Anchor = Anchor.TopCentre,
-                                    Action = modButtonPressed,
-                                },
-                                new DifficultyIncreaseSection
-                                {
                                     RelativeSizeAxes = Axes.X,
-                                    Origin = Anchor.TopCentre,
-                                    Anchor = Anchor.TopCentre,
-                                    Action = modButtonPressed,
-                                },
-                                new SpecialSection
-                                {
-                                    RelativeSizeAxes = Axes.X,
-                                    Origin = Anchor.TopCentre,
-                                    Anchor = Anchor.TopCentre,
-                                    Action = modButtonPressed,
-                                },
-                            }
-                        },
-                        // Footer
-                        new Container
-                        {
-                            RelativeSizeAxes = Axes.X,
-                            Height = 70,
-                            Origin = Anchor.TopCentre,
-                            Anchor = Anchor.TopCentre,
-                            Children = new Drawable[]
-                            {
-                                new Box
-                                {
-                                    RelativeSizeAxes = Axes.Both,
-                                    Colour = new Color4(172, 20, 116, 255),
-                                    Alpha = 0.5f,
-                                },
-                                footerContainer = new FillFlowContainer
-                                {
-                                    Origin = Anchor.BottomCentre,
-                                    Anchor = Anchor.BottomCentre,
                                     AutoSizeAxes = Axes.Y,
-                                    RelativeSizeAxes = Axes.X,
+                                    Spacing = new Vector2(0f, 10f),
                                     Width = content_width,
-                                    Direction = FillDirection.Horizontal,
-                                    Padding = new MarginPadding
+                                    Children = new ModSection[]
                                     {
-                                        Vertical = 15
+                                        new DifficultyReductionSection { Action = modButtonPressed },
+                                        new DifficultyIncreaseSection { Action = modButtonPressed },
+                                        new AutomationSection { Action = modButtonPressed },
+                                        new ConversionSection { Action = modButtonPressed },
+                                        new FunSection { Action = modButtonPressed },
+                                    }
+                                },
+                            },
+                        },
+                        new Drawable[]
+                        {
+                            // Footer
+                            new Container
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Origin = Anchor.TopCentre,
+                                Anchor = Anchor.TopCentre,
+                                Children = new Drawable[]
+                                {
+                                    new Box
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                        Colour = new Color4(172, 20, 116, 255),
+                                        Alpha = 0.5f,
                                     },
-                                    Children = new Drawable[]
+                                    footerContainer = new FillFlowContainer
                                     {
-                                        DeselectAllButton = new TriangleButton
+                                        Origin = Anchor.BottomCentre,
+                                        Anchor = Anchor.BottomCentre,
+                                        AutoSizeAxes = Axes.Y,
+                                        RelativeSizeAxes = Axes.X,
+                                        Width = content_width,
+                                        Direction = FillDirection.Horizontal,
+                                        Padding = new MarginPadding
                                         {
-                                            Width = 180,
-                                            Text = "Deselect All",
-                                            Action = DeselectAll,
-                                            Margin = new MarginPadding
-                                            {
-                                                Right = 20
-                                            }
+                                            Vertical = 15
                                         },
-                                        new OsuSpriteText
+                                        Children = new Drawable[]
                                         {
-                                            Text = @"Score Multiplier:",
-                                            TextSize = 30,
-                                            Margin = new MarginPadding
+                                            DeselectAllButton = new TriangleButton
                                             {
-                                                Top = 5,
-                                                Right = 10
-                                            }
-                                        },
-                                        MultiplierLabel = new OsuSpriteText
-                                        {
-                                            Font = @"Exo2.0-Bold",
-                                            TextSize = 30,
-                                            Margin = new MarginPadding
+                                                Width = 180,
+                                                Text = "Deselect All",
+                                                Action = DeselectAll,
+                                                Margin = new MarginPadding
+                                                {
+                                                    Right = 20
+                                                }
+                                            },
+                                            new OsuSpriteText
                                             {
-                                                Top = 5
-                                            }
-                                        },
-                                        UnrankedLabel = new OsuSpriteText
-                                        {
-                                            Font = @"Exo2.0-Bold",
-                                            Text = @"(Unranked)",
-                                            TextSize = 30,
-                                            Margin = new MarginPadding
+                                                Text = @"Score Multiplier:",
+                                                TextSize = 30,
+                                                Margin = new MarginPadding
+                                                {
+                                                    Top = 5,
+                                                    Right = 10
+                                                }
+                                            },
+                                            MultiplierLabel = new OsuSpriteText
                                             {
-                                                Top = 5,
-                                                Left = 10
+                                                Font = @"Exo2.0-Bold",
+                                                TextSize = 30,
+                                                Margin = new MarginPadding
+                                                {
+                                                    Top = 5
+                                                }
+                                            },
+                                            UnrankedLabel = new OsuSpriteText
+                                            {
+                                                Font = @"Exo2.0-Bold",
+                                                Text = @"(Unranked)",
+                                                TextSize = 30,
+                                                Margin = new MarginPadding
+                                                {
+                                                    Top = 5,
+                                                    Left = 10
+                                                }
                                             }
                                         }
                                     }
-                                }
-                            },
+                                },
+                            }
                         },
                     },
                 },

osu.Game/Overlays/Mods/Sections/AutomationSection.cs

@@ -0,0 +1,19 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Mods;
+using OpenTK.Input;
+
+namespace osu.Game.Overlays.Mods.Sections
+{
+    public class AutomationSection : ModSection
+    {
+        protected override Key[] ToggleKeys => new[] { Key.Z, Key.X, Key.C, Key.V, Key.B, Key.N, Key.M };
+        public override ModType ModType => ModType.Automation;
+
+        public AutomationSection()
+        {
+            Header = @"Automation";
+        }
+    }
+}

osu.Game/Overlays/Mods/Sections/ConversionSection.cs

@@ -0,0 +1,19 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Mods;
+using OpenTK.Input;
+
+namespace osu.Game.Overlays.Mods.Sections
+{
+    public class ConversionSection : ModSection
+    {
+        protected override Key[] ToggleKeys => null;
+        public override ModType ModType => ModType.Conversion;
+
+        public ConversionSection()
+        {
+            Header = @"Conversion";
+        }
+    }
+}

osu.Game/Overlays/Mods/Sections/DifficultyIncreaseSection.cs

@@ -1,24 +1,16 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK.Input;
-using osu.Framework.Allocation;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
+using OpenTK.Input;
 
-namespace osu.Game.Overlays.Mods
+namespace osu.Game.Overlays.Mods.Sections
 {
     public class DifficultyIncreaseSection : ModSection
     {
         protected override Key[] ToggleKeys => new[] { Key.A, Key.S, Key.D, Key.F, Key.G, Key.H, Key.J, Key.K, Key.L };
         public override ModType ModType => ModType.DifficultyIncrease;
 
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            SelectedColour = colours.YellowLight;
-        }
-
         public DifficultyIncreaseSection()
         {
             Header = @"Difficulty Increase";

osu.Game/Overlays/Mods/Sections/DifficultyReductionSection.cs

@@ -1,24 +1,16 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK.Input;
-using osu.Framework.Allocation;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
+using OpenTK.Input;
 
-namespace osu.Game.Overlays.Mods
+namespace osu.Game.Overlays.Mods.Sections
 {
     public class DifficultyReductionSection : ModSection
     {
         protected override Key[] ToggleKeys => new[] { Key.Q, Key.W, Key.E, Key.R, Key.T, Key.Y, Key.U, Key.I, Key.O, Key.P };
         public override ModType ModType => ModType.DifficultyReduction;
 
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            SelectedColour = colours.GreenLight;
-        }
-
         public DifficultyReductionSection()
         {
             Header = @"Difficulty Reduction";

osu.Game/Overlays/Mods/Sections/FunSection.cs

@@ -0,0 +1,19 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Mods;
+using OpenTK.Input;
+
+namespace osu.Game.Overlays.Mods.Sections
+{
+    public class FunSection : ModSection
+    {
+        protected override Key[] ToggleKeys => null;
+        public override ModType ModType => ModType.Fun;
+
+        public FunSection()
+        {
+            Header = @"Fun";
+        }
+    }
+}

osu.Game/Overlays/Mods/SpecialSection.cs

@@ -1,27 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using OpenTK.Input;
-using osu.Framework.Allocation;
-using osu.Game.Graphics;
-using osu.Game.Rulesets.Mods;
-
-namespace osu.Game.Overlays.Mods
-{
-    public class SpecialSection : ModSection
-    {
-        protected override Key[] ToggleKeys => new[] { Key.Z, Key.X, Key.C, Key.V, Key.B, Key.N, Key.M };
-        public override ModType ModType => ModType.Special;
-
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            SelectedColour = colours.BlueLight;
-        }
-
-        public SpecialSection()
-        {
-            Header = @"Special";
-        }
-    }
-}

osu.Game/Overlays/UserProfileOverlay.cs

@@ -195,7 +195,7 @@ namespace osu.Game.Overlays
                 TabContainer.AutoSizeAxes |= Axes.X;
                 TabContainer.Anchor |= Anchor.x1;
                 TabContainer.Origin |= Anchor.x1;
-                Add(bottom = new Box
+                AddInternal(bottom = new Box
                 {
                     RelativeSizeAxes = Axes.X,
                     Height = 1,

osu.Game/Rulesets/Edit/HitObjectComposer.cs

@@ -11,6 +11,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Logging;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
@@ -23,12 +24,15 @@ namespace osu.Game.Rulesets.Edit
     {
         private readonly Ruleset ruleset;
 
+        public IEnumerable<DrawableHitObject> HitObjects => rulesetContainer.Playfield.AllHitObjects;
+
         protected ICompositionTool CurrentTool { get; private set; }
+        protected IRulesetConfigManager Config { get; private set; }
+
+        private readonly List<Container> layerContainers = new List<Container>();
+        private readonly IBindable<WorkingBeatmap> beatmap = new Bindable<WorkingBeatmap>();
 
         private RulesetContainer rulesetContainer;
-        private readonly List<Container> layerContainers = new List<Container>();
-
-        private readonly IBindable<WorkingBeatmap> beatmap = new Bindable<WorkingBeatmap>();
 
         protected HitObjectComposer(Ruleset ruleset)
         {
@@ -60,7 +64,7 @@ namespace osu.Game.Rulesets.Edit
             };
 
             var layerAboveRuleset = CreateLayerContainer();
-            layerAboveRuleset.Child = new HitObjectMaskLayer(rulesetContainer.Playfield, this);
+            layerAboveRuleset.Child = new HitObjectMaskLayer();
 
             layerContainers.Add(layerBelowRuleset);
             layerContainers.Add(layerAboveRuleset);
@@ -110,6 +114,16 @@ namespace osu.Game.Rulesets.Edit
             toolboxCollection.Items[0].Select();
         }
 
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+        {
+            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
+
+            dependencies.CacheAs(this);
+            Config = dependencies.Get<RulesetConfigCache>().GetConfigFor(ruleset);
+
+            return dependencies;
+        }
+
         protected override void LoadComplete()
         {
             base.LoadComplete();

osu.Game/Rulesets/Edit/Tools/HitObjectCompositionTool.cs

@@ -8,6 +8,16 @@ namespace osu.Game.Rulesets.Edit.Tools
     public class HitObjectCompositionTool<T> : ICompositionTool
         where T : HitObject
     {
-        public string Name => typeof(T).Name;
+        public string Name { get; }
+
+        public HitObjectCompositionTool()
+            : this(typeof(T).Name)
+        {
+        }
+
+        public HitObjectCompositionTool(string name)
+        {
+            Name = name;
+        }
     }
 }

osu.Game/Rulesets/Mods/Mod.cs

@@ -29,7 +29,7 @@ namespace osu.Game.Rulesets.Mods
         /// <summary>
         /// The type of this mod.
         /// </summary>
-        public virtual ModType Type => ModType.Special;
+        public virtual ModType Type => ModType.Fun;
 
         /// <summary>
         /// The user readable description of this mod.

osu.Game/Rulesets/Mods/ModAutoplay.cs

@@ -26,6 +26,7 @@ namespace osu.Game.Rulesets.Mods
         public override string Name => "Autoplay";
         public override string ShortenedName => "AT";
         public override FontAwesome Icon => FontAwesome.fa_osu_mod_auto;
+        public override ModType Type => ModType.Automation;
         public override string Description => "Watch a perfect automated play through the song.";
         public override double ScoreMultiplier => 1;
         public bool AllowFail => false;

osu.Game/Rulesets/Mods/ModRelax.cs

@@ -11,6 +11,7 @@ namespace osu.Game.Rulesets.Mods
         public override string Name => "Relax";
         public override string ShortenedName => "RX";
         public override FontAwesome Icon => FontAwesome.fa_osu_mod_relax;
+        public override ModType Type => ModType.Automation;
         public override double ScoreMultiplier => 1;
         public override Type[] IncompatibleMods => new[] { typeof(ModAutoplay), typeof(ModNoFail), typeof(ModSuddenDeath) };
     }

osu.Game/Rulesets/Mods/ModType.cs

@@ -7,6 +7,8 @@ namespace osu.Game.Rulesets.Mods
     {
         DifficultyReduction,
         DifficultyIncrease,
-        Special
+        Conversion,
+        Automation,
+        Fun
     }
 }

osu.Game/Rulesets/UI/ModIcon.cs

@@ -79,10 +79,18 @@ namespace osu.Game.Rulesets.UI
                     backgroundColour = colours.Green;
                     highlightedColour = colours.GreenLight;
                     break;
-                case ModType.Special:
+                case ModType.Automation:
                     backgroundColour = colours.Blue;
                     highlightedColour = colours.BlueLight;
                     break;
+                case ModType.Conversion:
+                    backgroundColour = colours.Purple;
+                    highlightedColour = colours.PurpleLight;
+                    break;
+                case ModType.Fun:
+                    backgroundColour = colours.Pink;
+                    highlightedColour = colours.PinkLight;
+                    break;
             }
 
             applyStyle();
@@ -92,10 +100,7 @@ namespace osu.Game.Rulesets.UI
 
         public bool Highlighted
         {
-            get
-            {
-                return highlighted;
-            }
+            get { return highlighted; }
 
             set
             {

osu.Game/Rulesets/UI/Playfield.cs

@@ -1,10 +1,13 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Configuration;
 
 namespace osu.Game.Rulesets.UI
@@ -12,15 +15,21 @@ namespace osu.Game.Rulesets.UI
     public abstract class Playfield : ScalableContainer
     {
         /// <summary>
-        /// The HitObjects contained in this Playfield.
+        /// The <see cref="DrawableHitObject"/> contained in this Playfield.
         /// </summary>
         public HitObjectContainer HitObjects { get; private set; }
 
         /// <summary>
-        /// All the <see cref="Playfield"/>s nested inside this playfield.
+        /// All the <see cref="DrawableHitObject"/>s contained in this <see cref="Playfield"/> and all <see cref="NestedPlayfields"/>.
         /// </summary>
-        public IReadOnlyList<Playfield> NestedPlayfields => nestedPlayfields;
-        private List<Playfield> nestedPlayfields;
+        public IEnumerable<DrawableHitObject> AllHitObjects => HitObjects?.Objects.Concat(NestedPlayfields.SelectMany(p => p.AllHitObjects)) ?? Enumerable.Empty<DrawableHitObject>();
+
+        /// <summary>
+        /// All <see cref="Playfield"/>s nested inside this <see cref="Playfield"/>.
+        /// </summary>
+        public IEnumerable<Playfield> NestedPlayfields => nestedPlayfields.IsValueCreated ? nestedPlayfields.Value : Enumerable.Empty<Playfield>();
+
+        private readonly Lazy<List<Playfield>> nestedPlayfields = new Lazy<List<Playfield>>();
 
         /// <summary>
         /// Whether judgements should be displayed by this and and all nested <see cref="Playfield"/>s.
@@ -54,7 +63,7 @@ namespace osu.Game.Rulesets.UI
         /// <summary>
         /// Performs post-processing tasks (if any) after all DrawableHitObjects are loaded into this Playfield.
         /// </summary>
-        public virtual void PostProcess() => nestedPlayfields?.ForEach(p => p.PostProcess());
+        public virtual void PostProcess() => NestedPlayfields.ForEach(p => p.PostProcess());
 
         /// <summary>
         /// Adds a DrawableHitObject to this Playfield.
@@ -75,12 +84,8 @@ namespace osu.Game.Rulesets.UI
         /// <param name="otherPlayfield">The <see cref="Playfield"/> to add.</param>
         protected void AddNested(Playfield otherPlayfield)
         {
-            if (nestedPlayfields == null)
-                nestedPlayfields = new List<Playfield>();
-
-            nestedPlayfields.Add(otherPlayfield);
-
             otherPlayfield.DisplayJudgements.BindTo(DisplayJudgements);
+            nestedPlayfields.Value.Add(otherPlayfield);
         }
 
         /// <summary>

osu.Game/Screens/Edit/Menus/ScreenSelectionTabControl.cs

@@ -25,7 +25,7 @@ namespace osu.Game.Screens.Edit.Menus
             TabContainer.AutoSizeAxes = Axes.X;
             TabContainer.Padding = new MarginPadding();
 
-            Add(new Box
+            AddInternal(new Box
             {
                 Anchor = Anchor.BottomLeft,
                 Origin = Anchor.BottomLeft,

osu.Game/Screens/Edit/Screens/Compose/Layers/HitObjectMaskLayer.cs

@@ -1,7 +1,6 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -9,30 +8,24 @@ using osu.Framework.Input.EventArgs;
 using osu.Framework.Input.States;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Screens.Edit.Screens.Compose.Layers
 {
     public class HitObjectMaskLayer : CompositeDrawable
     {
-        private readonly Playfield playfield;
-        private readonly HitObjectComposer composer;
-
         private MaskContainer maskContainer;
+        private HitObjectComposer composer;
 
-        public HitObjectMaskLayer(Playfield playfield, HitObjectComposer composer)
+        public HitObjectMaskLayer()
         {
-            // we need the playfield as HitObjects may not be initialised until its BDL.
-            this.playfield = playfield;
-
-            this.composer = composer;
-
             RelativeSizeAxes = Axes.Both;
         }
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(HitObjectComposer composer)
         {
+            this.composer = composer;
+
             maskContainer = new MaskContainer();
 
             var maskSelection = composer.CreateMaskSelection();
@@ -55,7 +48,7 @@ namespace osu.Game.Screens.Edit.Screens.Compose.Layers
                 dragLayer.CreateProxy()
             };
 
-            foreach (var obj in playfield.HitObjects.Objects)
+            foreach (var obj in composer.HitObjects)
                 addMask(obj);
         }
 
@@ -77,18 +70,5 @@ namespace osu.Game.Screens.Edit.Screens.Compose.Layers
 
             maskContainer.Add(mask);
         }
-
-        /// <summary>
-        /// Removes the mask for a <see cref="DrawableHitObject"/>.
-        /// </summary>
-        /// <param name="hitObject">The <see cref="DrawableHitObject"/> to remove the mask for.</param>
-        private void removeMask(DrawableHitObject hitObject)
-        {
-            var mask = maskContainer.FirstOrDefault(h => h.HitObject == hitObject);
-            if (mask == null)
-                return;
-
-            maskContainer.Remove(mask);
-        }
     }
 }

osu.Game/Screens/Play/Player.cs

@@ -213,7 +213,7 @@ namespace osu.Game.Screens.Play
                     {
                         if (!IsCurrentScreen) return;
 
-                        pauseContainer.Hide();
+                        fadeOut(true);
                         Restart();
                     },
                 }
@@ -278,6 +278,8 @@ namespace osu.Game.Screens.Play
                     ScoreProcessor.PopulateScore(score);
                     score.User = RulesetContainer.Replay?.User ?? api.LocalUser.Value;
                     Push(new Results(score));
+
+                    onCompletionEvent = null;
                 });
             }
         }
@@ -340,6 +342,13 @@ namespace osu.Game.Screens.Play
 
         protected override bool OnExiting(Screen next)
         {
+            if (onCompletionEvent != null)
+            {
+                // Proceed to result screen if beatmap already finished playing
+                onCompletionEvent.RunTask();
+                return true;
+            }
+
             if ((!AllowPause || HasFailed || !ValidForResume || pauseContainer?.IsPaused != false || RulesetContainer?.HasReplayLoaded != false) && (!pauseContainer?.IsResuming ?? true))
             {
                 // In the case of replays, we may have changed the playback rate.
@@ -355,16 +364,10 @@ namespace osu.Game.Screens.Play
             return true;
         }
 
-        private void fadeOut()
+        private void fadeOut(bool instant = false)
         {
-            const float fade_out_duration = 250;
-
-            RulesetContainer?.FadeOut(fade_out_duration);
-            Content.FadeOut(fade_out_duration);
-
-            hudOverlay?.ScaleTo(0.7f, fade_out_duration * 3, Easing.In);
-
-            Background?.FadeTo(1f, fade_out_duration);
+            float fadeOutDuration = instant ? 0 : 250;
+            Content.FadeOut(fadeOutDuration);
         }
 
         protected override bool OnScroll(InputState state) => mouseWheelDisabled.Value && !pauseContainer.IsPaused;

osu.Game/Screens/Play/PlayerLoader.cs

@@ -1,12 +1,12 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System.Linq;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Input.EventArgs;
 using osu.Framework.Input.States;
 using osu.Framework.Localisation;
 using osu.Framework.Screens;
@@ -14,14 +14,18 @@ using osu.Framework.Threading;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Screens.Menu;
 using osu.Game.Screens.Play.PlayerSettings;
 using OpenTK;
+using OpenTK.Graphics;
 
 namespace osu.Game.Screens.Play
 {
     public class PlayerLoader : ScreenWithBeatmapBackground
     {
+        private static readonly Vector2 background_blur = new Vector2(15);
+
         private Player player;
 
         private BeatmapMetadataDisplay info;
@@ -62,26 +66,30 @@ namespace osu.Game.Screens.Play
                 Margin = new MarginPadding(25),
                 Children = new PlayerSettingsGroup[]
                 {
-                    new VisualSettings(),
+                    visualSettings = new VisualSettings(),
                     new InputSettings()
                 }
             });
 
-            loadTask = LoadComponentAsync(player);
+            loadTask = LoadComponentAsync(player, playerLoaded);
         }
 
+        private void playerLoaded(Player player) => info.Loading = false;
+
         protected override void OnResuming(Screen last)
         {
             base.OnResuming(last);
 
             contentIn();
 
+            info.Loading = true;
+
             //we will only be resumed if the player has requested a re-run (see ValidForResume setting above)
             loadTask = LoadComponentAsync(player = new Player
             {
                 RestartCount = player.RestartCount + 1,
                 RestartRequested = player.RestartRequested,
-            });
+            }, playerLoaded);
 
             this.Delay(400).Schedule(pushWhenLoaded);
         }
@@ -123,23 +131,33 @@ namespace osu.Game.Screens.Play
             logo.Delay(resuming ? 0 : 500).MoveToOffset(new Vector2(0, -0.24f), 500, Easing.InOutExpo);
         }
 
-        private bool weHandledMouseDown;
-
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
-        {
-            weHandledMouseDown = true;
-            return base.OnMouseDown(state, args);
-        }
-
-        protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
-        {
-            weHandledMouseDown = false;
-            return base.OnMouseUp(state, args);
-        }
-
         private ScheduledDelegate pushDebounce;
+        private VisualSettings visualSettings;
 
-        private bool readyForPush => player.LoadState == LoadState.Ready && IsHovered && (!GetContainingInputManager().CurrentState.Mouse.HasAnyButtonPressed || weHandledMouseDown);
+        private bool readyForPush => player.LoadState == LoadState.Ready && IsHovered && GetContainingInputManager()?.DraggedDrawable == null;
+
+        protected override bool OnHover(InputState state)
+        {
+            // restore our screen defaults
+            InitializeBackgroundElements();
+            return base.OnHover(state);
+        }
+
+        protected override void OnHoverLost(InputState state)
+        {
+            if (GetContainingInputManager().HoveredDrawables.Contains(visualSettings))
+            {
+                // show user setting preview
+                UpdateBackgroundElements();
+            }
+            base.OnHoverLost(state);
+        }
+
+        protected override void InitializeBackgroundElements()
+        {
+            Background?.FadeTo(1, BACKGROUND_FADE_DURATION, Easing.OutQuint);
+            Background?.BlurTo(background_blur, BACKGROUND_FADE_DURATION, Easing.OutQuint);
+        }
 
         private void pushWhenLoaded()
         {
@@ -231,7 +249,7 @@ namespace osu.Game.Screens.Play
                             Anchor = Anchor.TopCentre,
                             Origin = Anchor.TopRight,
                             Margin = new MarginPadding { Right = 5 },
-                            Colour = OsuColour.Gray(0.5f),
+                            Colour = OsuColour.Gray(0.8f),
                             Text = left,
                         },
                         new OsuSpriteText
@@ -246,6 +264,25 @@ namespace osu.Game.Screens.Play
             }
 
             private readonly WorkingBeatmap beatmap;
+            private LoadingAnimation loading;
+            private Sprite backgroundSprite;
+
+            public bool Loading
+            {
+                set
+                {
+                    if (value)
+                    {
+                        loading.Show();
+                        backgroundSprite.FadeColour(OsuColour.Gray(0.5f), 400, Easing.OutQuint);
+                    }
+                    else
+                    {
+                        loading.Hide();
+                        backgroundSprite.FadeColour(Color4.White, 400, Easing.OutQuint);
+                    }
+                }
+            }
 
             public BeatmapMetadataDisplay(WorkingBeatmap beatmap)
             {
@@ -292,9 +329,9 @@ namespace osu.Game.Screens.Play
                                 Anchor = Anchor.TopCentre,
                                 CornerRadius = 10,
                                 Masking = true,
-                                Children = new[]
+                                Children = new Drawable[]
                                 {
-                                    new Sprite
+                                    backgroundSprite = new Sprite
                                     {
                                         RelativeSizeAxes = Axes.Both,
                                         Texture = beatmap?.Background,
@@ -302,6 +339,7 @@ namespace osu.Game.Screens.Play
                                         Anchor = Anchor.Centre,
                                         FillMode = FillMode.Fill,
                                     },
+                                    loading = new LoadingAnimation { Scale = new Vector2(1.3f) }
                                 }
                             },
                             new OsuSpriteText
@@ -329,6 +367,8 @@ namespace osu.Game.Screens.Play
                         },
                     }
                 };
+
+                Loading = true;
             }
         }
     }

osu.Game/Screens/Play/PlayerSettings/PlayerSettingsGroup.cs

@@ -128,6 +128,27 @@ namespace osu.Game.Screens.Play.PlayerSettings
             };
         }
 
+        private const float fade_duration = 800;
+        private const float inactive_alpha = 0.5f;
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            this.Delay(600).FadeTo(inactive_alpha, fade_duration, Easing.OutQuint);
+        }
+
+        protected override bool OnHover(InputState state)
+        {
+            this.FadeIn(fade_duration, Easing.OutQuint);
+            return true;
+        }
+
+        protected override void OnHoverLost(InputState state)
+        {
+            this.FadeTo(inactive_alpha, fade_duration, Easing.OutQuint);
+            base.OnHoverLost(state);
+        }
+
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
@@ -140,7 +161,6 @@ namespace osu.Game.Screens.Play.PlayerSettings
 
         protected override Container<Drawable> Content => content;
 
-        protected override bool OnHover(InputState state) => true;
         protected override bool OnMouseDown(InputState state, MouseDownEventArgs args) => true;
     }
 }

osu.Game/Screens/Play/ScreenWithBeatmapBackground.cs

@@ -15,6 +15,8 @@ namespace osu.Game.Screens.Play
     {
         protected override BackgroundScreen CreateBackground() => new BackgroundScreenBeatmap(Beatmap.Value);
 
+        protected new BackgroundScreenBeatmap Background => (BackgroundScreenBeatmap)base.Background;
+
         public override bool AllowBeatmapRulesetChange => false;
 
         protected const float BACKGROUND_FADE_DURATION = 800;
@@ -43,21 +45,30 @@ namespace osu.Game.Screens.Play
             DimLevel.ValueChanged += _ => UpdateBackgroundElements();
             BlurLevel.ValueChanged += _ => UpdateBackgroundElements();
             ShowStoryboard.ValueChanged += _ => UpdateBackgroundElements();
-            UpdateBackgroundElements();
+            InitializeBackgroundElements();
         }
 
         protected override void OnResuming(Screen last)
         {
             base.OnResuming(last);
-            UpdateBackgroundElements();
+            InitializeBackgroundElements();
         }
 
+        /// <summary>
+        /// Called once on entering screen. By Default, performs a full <see cref="UpdateBackgroundElements"/> call.
+        /// </summary>
+        protected virtual void InitializeBackgroundElements() => UpdateBackgroundElements();
+
+        /// <summary>
+        /// Called wen background elements require updates, usually due to a user changing a setting.
+        /// </summary>
+        /// <param name="userChange"></param>
         protected virtual void UpdateBackgroundElements()
         {
             if (!IsCurrentScreen) return;
 
             Background?.FadeTo(BackgroundOpacity, BACKGROUND_FADE_DURATION, Easing.OutQuint);
-            (Background as BackgroundScreenBeatmap)?.BlurTo(new Vector2((float)BlurLevel.Value * 25), BACKGROUND_FADE_DURATION, Easing.OutQuint);
+            Background?.BlurTo(new Vector2((float)BlurLevel.Value * 25), BACKGROUND_FADE_DURATION, Easing.OutQuint);
         }
     }
 }

osu.Game/Screens/Play/SkipOverlay.cs

@@ -4,6 +4,8 @@
 using System;
 using osu.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Threading;
@@ -214,17 +216,21 @@ namespace osu.Game.Screens.Play
             private Box background;
             private AspectContainer aspect;
 
+            private SampleChannel sampleConfirm;
+
             public Button()
             {
                 RelativeSizeAxes = Axes.Both;
             }
 
             [BackgroundDependencyLoader]
-            private void load(OsuColour colours)
+            private void load(OsuColour colours, AudioManager audio)
             {
                 colourNormal = colours.Yellow;
                 colourHover = colours.YellowDark;
 
+                sampleConfirm = audio.Sample.Get(@"SongSelect/confirm-selection");
+
                 Children = new Drawable[]
                 {
                     background = new Box
@@ -311,6 +317,8 @@ namespace osu.Game.Screens.Play
                 if (!Enabled)
                     return false;
 
+                sampleConfirm.Play();
+
                 box.FlashColour(Color4.White, 500, Easing.OutQuint);
                 aspect.ScaleTo(1.2f, 2000, Easing.OutQuint);
 

osu.Game/Screens/Select/PlaySongSelect.cs

@@ -50,13 +50,14 @@ namespace osu.Game.Screens.Select
 
         private SampleChannel sampleConfirm;
 
-        public readonly Bindable<IEnumerable<Mod>> SelectedMods = new Bindable<IEnumerable<Mod>>(new List<Mod>());
+        [Cached]
+        [Cached(Type = typeof(IBindable<IEnumerable<Mod>>))]
+        private readonly Bindable<IEnumerable<Mod>> selectedMods = new Bindable<IEnumerable<Mod>>(new Mod[] { });
 
         [BackgroundDependencyLoader(true)]
-        private void load(OsuColour colours, AudioManager audio, BeatmapManager beatmaps, DialogOverlay dialogOverlay, OsuGame osu)
+        private void load(OsuColour colours, AudioManager audio, BeatmapManager beatmaps, DialogOverlay dialogOverlay, Bindable<IEnumerable<Mod>> selectedMods)
         {
-            if (osu != null) SelectedMods.BindTo(osu.SelectedMods);
-            modSelect.SelectedMods.BindTo(SelectedMods);
+            if (selectedMods != null) this.selectedMods.BindTo(selectedMods);
 
             sampleConfirm = audio.Sample.Get(@"SongSelect/confirm-selection");
 
@@ -84,7 +85,7 @@ namespace osu.Game.Screens.Select
 
         protected override void UpdateBeatmap(WorkingBeatmap beatmap)
         {
-            beatmap.Mods.BindTo(SelectedMods);
+            beatmap.Mods.BindTo(selectedMods);
 
             base.UpdateBeatmap(beatmap);
 
@@ -131,7 +132,7 @@ namespace osu.Game.Screens.Select
             if (Beatmap.Value.Track != null)
                 Beatmap.Value.Track.Looping = false;
 
-            SelectedMods.UnbindAll();
+            selectedMods.UnbindAll();
             Beatmap.Value.Mods.Value = new Mod[] { };
 
             return false;
@@ -147,10 +148,10 @@ namespace osu.Game.Screens.Select
                 var auto = Ruleset.Value.CreateInstance().GetAutoplayMod();
                 var autoType = auto.GetType();
 
-                var mods = modSelect.SelectedMods.Value;
+                var mods = selectedMods.Value;
                 if (mods.All(m => m.GetType() != autoType))
                 {
-                    modSelect.SelectedMods.Value = mods.Append(auto);
+                    selectedMods.Value = mods.Append(auto);
                     removeAutoModOnResume = true;
                 }
             }

osu.Game/Screens/Select/SongSelect.cs

@@ -69,7 +69,7 @@ namespace osu.Game.Screens.Select
         private SampleChannel sampleChangeDifficulty;
         private SampleChannel sampleChangeBeatmap;
 
-        public new readonly Bindable<RulesetInfo> Ruleset = new Bindable<RulesetInfo>();
+        protected new readonly Bindable<RulesetInfo> Ruleset = new Bindable<RulesetInfo>();
 
         private DependencyContainer dependencies;
 

osu.Game/osu.Game.csproj

@@ -18,8 +18,8 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.1" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.1.1" />
     <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
-    <PackageReference Include="ppy.osu.Framework" Version="2018.721.0" />
-    <PackageReference Include="SharpCompress" Version="0.17.1" />
+    <PackageReference Include="ppy.osu.Framework" Version="2018.806.0" />
+    <PackageReference Include="SharpCompress" Version="0.22.0" />
     <PackageReference Include="NUnit" Version="3.10.1" />
     <PackageReference Include="System.ComponentModel.Annotations" Version="4.5.0" />
   </ItemGroup>

osu.Game/osu.nuspec

@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2011/08/nuspec.xsd">
-    <metadata>
-        <id>osulazer</id>
-        <version>0.0.0</version>
-        <title>osulazer</title>
-        <authors>ppy Pty Ltd</authors>
-        <owners>Dean Herbert</owners>
-        <projectUrl>https://osu.ppy.sh/</projectUrl>
-        <iconUrl>https://puu.sh/tYyXZ/9a01a5d1b0.ico</iconUrl>
-        <requireLicenseAcceptance>false</requireLicenseAcceptance>
-        <description>click the circles. to the beat.</description>
-        <summary>click the circles.</summary>
-        <releaseNotes>testing</releaseNotes>
-        <copyright>Copyright ppy Pty Ltd 2007-2018</copyright>
-        <language>en-AU</language>
-    </metadata>
-    <files>
-      <file src="*.exe" target="lib\net45\" exclude="**vshost**"/>
-      <file src="*.dll" target="lib\net45\"/>
-      <file src="*.config" target="lib\net45\"/>
-      <file src="x86\*.dll" target="lib\net45\x86\"/>
-      <file src="x64\*.dll" target="lib\net45\x64\"/>
-    </files>
-</package>
-

osu.TestProject.props

@@ -13,9 +13,6 @@
   <ItemGroup Label="Package References">
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.1" />
     <PackageReference Include="DeepEqual" Version="1.6.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.7.2" />
-    <PackageReference Include="NUnit" Version="3.10.1" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.10.0" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="..\osu.Game\Tests\VisualTestRunner.cs">