Merge branch 'master' into issue-templates

.gitignore

@@ -10,6 +10,10 @@
 # User-specific files (MonoDevelop/Xamarin Studio)
 *.userprefs
 
+### Cake ###
+tools/*
+!tools/cakebuild.csproj
+
 # Build results
 bin/[Dd]ebug/
 [Dd]ebugPublic/
@@ -98,6 +102,7 @@ $tf/
 _ReSharper*/
 *.[Rr]e[Ss]harper
 *.DotSettings.user
+inspectcode
 
 # JustCode is a .NET coding add-in
 .JustCode
@@ -257,3 +262,5 @@ paket-files/
 __pycache__/
 *.pyc
 Staging/
+
+inspectcodereport.xml

README.md

@@ -25,6 +25,7 @@ Build and run
 
 - Using Visual Studio 2017, Rider or Visual Studio Code (configurations are included)
 - From command line using `dotnet run --project osu.Desktop`. When building for non-development purposes, add `-c Release` to gain higher performance.
+- To run with code analysis, instead use `powershell ./build.ps1` or `build.sh`. This is currently only supported under windows due to [resharper cli shortcomings](https://youtrack.jetbrains.com/issue/RSRP-410004). Alternative, you can install resharper or use rider to get inline support in your IDE of choice.
 
 Note: If you run from command line under linux, you will need to prefix the output folder to your `LD_LIBRARY_PATH`. See `.vscode/launch.json` for an example
 

appveyor.yml

@@ -1,22 +1,8 @@
 clone_depth: 1
 version: '{branch}-{build}'
 image: Visual Studio 2017
-configuration: Debug
+test: off
-cache:
-  - C:\ProgramData\chocolatey\bin -> appveyor.yml
-  - C:\ProgramData\chocolatey\lib -> appveyor.yml
 install:
   - cmd: git submodule update --init --recursive --depth=5
-  - cmd: choco install resharper-clt -y
+build_script:
-  - cmd: choco install nvika -y
+  - cmd: PowerShell -Version 2.0 .\build.ps1
-  - cmd: dotnet tool install CodeFileSanity --version 0.0.16 --global
-before_build:
-  - cmd: CodeFileSanity
-  - cmd: nuget restore -verbosity quiet
-build:
-  project: osu.sln
-  parallel: true
-  verbosity: minimal
-after_build:
-  - cmd: inspectcode --o="inspectcodereport.xml" --projects:osu.Game* --caches-home="inspectcode" osu.sln > NUL
-  - cmd: NVika parsereport "inspectcodereport.xml" --treatwarningsaserrors

build.cake

@@ -0,0 +1,72 @@
+#addin "nuget:?package=CodeFileSanity&version=0.0.21"
+#addin "nuget:?package=JetBrains.ReSharper.CommandLineTools&version=2018.2.2"
+#tool "nuget:?package=NVika.MSBuild&version=1.0.1"
+
+///////////////////////////////////////////////////////////////////////////////
+// ARGUMENTS
+///////////////////////////////////////////////////////////////////////////////
+
+var target = Argument("target", "Build");
+var configuration = Argument("configuration", "Release");
+
+var osuSolution = new FilePath("./osu.sln");
+
+///////////////////////////////////////////////////////////////////////////////
+// TASKS
+///////////////////////////////////////////////////////////////////////////////
+
+Task("Restore")
+    .Does(() => {
+        DotNetCoreRestore(osuSolution.FullPath);
+    });
+
+Task("Compile")
+    .IsDependentOn("Restore")
+    .Does(() => {
+        DotNetCoreBuild(osuSolution.FullPath, new DotNetCoreBuildSettings {
+            Configuration = configuration,
+            NoRestore = true,
+        });
+    });
+
+Task("Test")
+    .IsDependentOn("Compile")
+    .Does(() => {
+        var testAssemblies = GetFiles("**/*.Tests/bin/**/*.Tests.dll");
+
+        DotNetCoreVSTest(testAssemblies, new DotNetCoreVSTestSettings {
+            Logger = AppVeyor.IsRunningOnAppVeyor ? "Appveyor" : $"trx",
+            Parallel = true,
+            ToolTimeout = TimeSpan.FromMinutes(10),
+        });
+    });
+
+// windows only because both inspectcore and nvika depend on net45
+Task("InspectCode")
+    .WithCriteria(IsRunningOnWindows())
+    .IsDependentOn("Compile")
+    .Does(() => {
+        var nVikaToolPath = GetFiles("./tools/NVika.MSBuild.*/tools/NVika.exe").First();
+
+        InspectCode(osuSolution, new InspectCodeSettings {
+            CachesHome = "inspectcode",
+            OutputFile = "inspectcodereport.xml",
+        });
+
+        StartProcess(nVikaToolPath, @"parsereport ""inspectcodereport.xml"" --treatwarningsaserrors");
+    });
+
+Task("CodeFileSanity")
+    .Does(() => {
+        ValidateCodeSanity(new ValidateCodeSanitySettings {
+            RootDirectory = ".",
+            IsAppveyorBuild = AppVeyor.IsRunningOnAppVeyor
+        });
+    });
+
+Task("Build")
+    .IsDependentOn("CodeFileSanity")
+    .IsDependentOn("InspectCode")
+    .IsDependentOn("Test");
+
+RunTarget(target);

build.ps1

@@ -0,0 +1,79 @@
+##########################################################################
+# This is a customized Cake bootstrapper script for PowerShell.
+##########################################################################
+
+<#
+
+.SYNOPSIS
+This is a Powershell script to bootstrap a Cake build.
+
+.DESCRIPTION
+This Powershell script restores NuGet tools (including Cake)
+and execute your Cake build script with the parameters you provide.
+
+.PARAMETER Script
+The build script to execute.
+.PARAMETER Target
+The build script target to run.
+.PARAMETER Configuration
+The build configuration to use.
+.PARAMETER Verbosity
+Specifies the amount of information to be displayed.
+.PARAMETER ShowDescription
+Shows description about tasks.
+.PARAMETER DryRun
+Performs a dry run.
+.PARAMETER ScriptArgs
+Remaining arguments are added here.
+
+.LINK
+https://cakebuild.net
+
+#>
+
+[CmdletBinding()]
+Param(
+    [string]$Script = "build.cake",
+    [string]$Target,
+    [string]$Configuration,
+    [ValidateSet("Quiet", "Minimal", "Normal", "Verbose", "Diagnostic")]
+    [string]$Verbosity,
+    [switch]$ShowDescription,
+    [Alias("WhatIf", "Noop")]
+    [switch]$DryRun,
+    [Parameter(Position=0,Mandatory=$false,ValueFromRemainingArguments=$true)]
+    [string[]]$ScriptArgs
+)
+
+Write-Host "Preparing to run build script..."
+
+# Determine the script root for resolving other paths.
+if(!$PSScriptRoot){
+    $PSScriptRoot = Split-Path $MyInvocation.MyCommand.Path -Parent
+}
+
+# Resolve the paths for resources used for debugging.
+$TOOLS_DIR = Join-Path $PSScriptRoot "tools"
+$CAKE_CSPROJ = Join-Path $TOOLS_DIR "cakebuild.csproj"
+
+# Install the required tools locally.
+Write-Host "Restoring cake tools..."
+Invoke-Expression "dotnet restore `"$CAKE_CSPROJ`" --packages `"$TOOLS_DIR`"" | Out-Null
+
+# Find the Cake executable
+$CAKE_EXECUTABLE = (Get-ChildItem -Path ./tools/cake.coreclr/ -Filter Cake.dll -Recurse).FullName
+
+# Build Cake arguments
+$cakeArguments = @("$Script");
+if ($Target) { $cakeArguments += "-target=$Target" }
+if ($Configuration) { $cakeArguments += "-configuration=$Configuration" }
+if ($Verbosity) { $cakeArguments += "-verbosity=$Verbosity" }
+if ($ShowDescription) { $cakeArguments += "-showdescription" }
+if ($DryRun) { $cakeArguments += "-dryrun" }
+if ($Experimental) { $cakeArguments += "-experimental" }
+$cakeArguments += $ScriptArgs
+
+# Start Cake
+Write-Host "Running build script..."
+Invoke-Expression "dotnet `"$CAKE_EXECUTABLE`" $cakeArguments"
+exit $LASTEXITCODE

build.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+
+##########################################################################
+# This is a customized Cake bootstrapper script for Shell.
+##########################################################################
+
+echo "Preparing to run build script..."
+
+SCRIPT_DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
+TOOLS_DIR=$SCRIPT_DIR/tools
+CAKE_BINARY_PATH=$TOOLS_DIR/"cake.coreclr"
+
+SCRIPT="build.cake"
+CAKE_CSPROJ=$TOOLS_DIR/"cakebuild.csproj"
+
+# Parse arguments.
+CAKE_ARGUMENTS=()
+for i in "$@"; do
+    case $1 in
+        -s|--script) SCRIPT="$2"; shift ;;
+        --) shift; CAKE_ARGUMENTS+=("$@"); break ;;
+        *) CAKE_ARGUMENTS+=("$1") ;;
+    esac
+    shift
+done
+
+# Install the required tools locally.
+echo "Restoring cake tools..."
+dotnet restore $CAKE_CSPROJ --packages $TOOLS_DIR > /dev/null 2>&1
+
+# Search for the CakeBuild binary.
+CAKE_BINARY=$(find $CAKE_BINARY_PATH -name "Cake.dll")
+
+# Start Cake
+echo "Running build script..."
+
+dotnet "$CAKE_BINARY" $SCRIPT "${CAKE_ARGUMENTS[@]}"

cake.config

@@ -0,0 +1,5 @@
+
+[Nuget]
+Source=https://api.nuget.org/v3/index.json
+UseInProcessClient=true
+LoadDependencies=true

osu-resources

@@ -1 +1 @@
-Subproject commit c3848d8b1c84966abe851d915bcca878415614b4
+Subproject commit 9ee64e369fe6fdafc6aed40f5a35b5f01eb82c53

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

@@ -42,7 +42,7 @@ namespace osu.Game.Rulesets.Catch.Tests
                         Vector2.Zero,
                         new Vector2(width * CatchPlayfield.BASE_WIDTH, 0)
                     },
-                    CurveType = CurveType.Linear,
+                    PathType = PathType.Linear,
                     Distance = width * CatchPlayfield.BASE_WIDTH,
                     StartTime = i * 2000,
                     NewCombo = i % 8 == 0

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

@@ -35,7 +35,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                     StartTime = obj.StartTime,
                     Samples = obj.Samples,
                     ControlPoints = curveData.ControlPoints,
-                    CurveType = curveData.CurveType,
+                    PathType = curveData.PathType,
                     Distance = curveData.Distance,
                     RepeatSamples = curveData.RepeatSamples,
                     RepeatCount = curveData.RepeatCount,

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

@@ -50,7 +50,7 @@ namespace osu.Game.Rulesets.Catch.Objects
             if (TickDistance == 0)
                 return;
 
-            var length = Curve.Distance;
+            var length = Path.Distance;
             var tickDistance = Math.Min(TickDistance, length);
             var spanDuration = length / Velocity;
 
@@ -95,7 +95,7 @@ namespace osu.Game.Rulesets.Catch.Objects
                         AddNested(new TinyDroplet
                         {
                             StartTime = t,
-                            X = X + Curve.PositionAt(progress).X / CatchPlayfield.BASE_WIDTH,
+                            X = X + Path.PositionAt(progress).X / CatchPlayfield.BASE_WIDTH,
                             Samples = new List<SampleInfo>(Samples.Select(s => new SampleInfo
                             {
                                 Bank = s.Bank,
@@ -110,7 +110,7 @@ namespace osu.Game.Rulesets.Catch.Objects
                         AddNested(new Droplet
                         {
                             StartTime = time,
-                            X = X + Curve.PositionAt(distanceProgress).X / CatchPlayfield.BASE_WIDTH,
+                            X = X + Path.PositionAt(distanceProgress).X / CatchPlayfield.BASE_WIDTH,
                             Samples = new List<SampleInfo>(Samples.Select(s => new SampleInfo
                             {
                                 Bank = s.Bank,
@@ -127,12 +127,12 @@ namespace osu.Game.Rulesets.Catch.Objects
                 {
                     Samples = Samples,
                     StartTime = spanStartTime + spanDuration,
-                    X = X + Curve.PositionAt(reversed ? 0 : 1).X / CatchPlayfield.BASE_WIDTH
+                    X = X + Path.PositionAt(reversed ? 0 : 1).X / CatchPlayfield.BASE_WIDTH
                 });
             }
         }
 
-        public double EndTime => StartTime + this.SpanCount() * Curve.Distance / Velocity;
+        public double EndTime => StartTime + this.SpanCount() * Path.Distance / Velocity;
 
         public float EndX => X + this.CurvePositionAt(1).X / CatchPlayfield.BASE_WIDTH;
 
@@ -140,24 +140,24 @@ namespace osu.Game.Rulesets.Catch.Objects
 
         public double Distance
         {
-            get { return Curve.Distance; }
+            get { return Path.Distance; }
-            set { Curve.Distance = value; }
+            set { Path.Distance = value; }
         }
 
-        public SliderCurve Curve { get; } = new SliderCurve();
+        public SliderPath Path { get; } = new SliderPath();
 
         public Vector2[] ControlPoints
         {
-            get { return Curve.ControlPoints; }
+            get { return Path.ControlPoints; }
-            set { Curve.ControlPoints = value; }
+            set { Path.ControlPoints = value; }
         }
 
         public List<List<SampleInfo>> RepeatSamples { get; set; } = new List<List<SampleInfo>>();
 
-        public CurveType CurveType
+        public PathType PathType
         {
-            get { return Curve.CurveType; }
+            get { return Path.PathType; }
-            set { Curve.CurveType = value; }
+            set { Path.PathType = value; }
         }
 
         public double? LegacyLastTickOffset { get; set; }

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

@@ -31,7 +31,7 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public override PassThroughInputManager CreateInputManager() => new CatchInputManager(Ruleset.RulesetInfo);
 
-        protected override DrawableHitObject<CatchHitObject> GetVisualRepresentation(CatchHitObject h)
+        public override DrawableHitObject<CatchHitObject> GetVisualRepresentation(CatchHitObject h)
         {
             switch (h)
             {

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

@@ -1,22 +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 System;
 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.Edit.Masks;
 using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
-    public class ManiaHitObjectComposer : HitObjectComposer
+    public class ManiaHitObjectComposer : HitObjectComposer<ManiaHitObject>
     {
         protected new ManiaConfigManager Config => (ManiaConfigManager)base.Config;
 
@@ -32,22 +33,19 @@ namespace osu.Game.Rulesets.Mania.Edit
             return dependencies;
         }
 
-        protected override RulesetContainer CreateRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap) => new ManiaEditRulesetContainer(ruleset, beatmap);
+        protected override RulesetContainer<ManiaHitObject> CreateRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
+            => new ManiaEditRulesetContainer(ruleset, beatmap);
 
-        protected override IReadOnlyList<ICompositionTool> CompositionTools => new ICompositionTool[]
+        protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => Array.Empty<HitObjectCompositionTool>();
-        {
-            new HitObjectCompositionTool<Note>("Note"),
-            new HitObjectCompositionTool<HoldNote>("Hold"),
-        };
 
-        public override HitObjectMask CreateMaskFor(DrawableHitObject hitObject)
+        public override SelectionMask CreateMaskFor(DrawableHitObject hitObject)
         {
             switch (hitObject)
             {
                 case DrawableNote note:
-                    return new NoteMask(note);
+                    return new NoteSelectionMask(note);
                 case DrawableHoldNote holdNote:
-                    return new HoldNoteMask(holdNote);
+                    return new HoldNoteSelectionMask(holdNote);
             }
 
             return base.CreateMaskFor(hitObject);

osu.Game.Rulesets.Mania/Edit/Masks/HoldNoteSelectionMask.cs

@@ -13,9 +13,9 @@ using osu.Game.Rulesets.UI.Scrolling;
 using OpenTK;
 using OpenTK.Graphics;
 
-namespace osu.Game.Rulesets.Mania.Edit.Layers.Selection.Overlays
+namespace osu.Game.Rulesets.Mania.Edit.Masks
 {
-    public class HoldNoteMask : HitObjectMask
+    public class HoldNoteSelectionMask : SelectionMask
     {
         public new DrawableHoldNote HitObject => (DrawableHoldNote)base.HitObject;
 
@@ -23,13 +23,13 @@ namespace osu.Game.Rulesets.Mania.Edit.Layers.Selection.Overlays
 
         private readonly BodyPiece body;
 
-        public HoldNoteMask(DrawableHoldNote hold)
+        public HoldNoteSelectionMask(DrawableHoldNote hold)
             : base(hold)
         {
             InternalChildren = new Drawable[]
             {
-                new HoldNoteNoteMask(hold.Head),
+                new HoldNoteNoteSelectionMask(hold.Head),
-                new HoldNoteNoteMask(hold.Tail),
+                new HoldNoteNoteSelectionMask(hold.Tail),
                 body = new BodyPiece
                 {
                     AccentColour = Color4.Transparent
@@ -59,9 +59,9 @@ namespace osu.Game.Rulesets.Mania.Edit.Layers.Selection.Overlays
                 Y -= HitObject.Tail.DrawHeight;
         }
 
-        private class HoldNoteNoteMask : NoteMask
+        private class HoldNoteNoteSelectionMask : NoteSelectionMask
         {
-            public HoldNoteNoteMask(DrawableNote note)
+            public HoldNoteNoteSelectionMask(DrawableNote note)
                 : base(note)
             {
                 Select();

osu.Game.Rulesets.Mania/Edit/Masks/NoteSelectionMask.cs

@@ -7,11 +7,11 @@ 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
+namespace osu.Game.Rulesets.Mania.Edit.Masks
 {
-    public class NoteMask : HitObjectMask
+    public class NoteSelectionMask : SelectionMask
     {
-        public NoteMask(DrawableNote note)
+        public NoteSelectionMask(DrawableNote note)
             : base(note)
         {
             Scale = note.Scale;

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

@@ -5,13 +5,11 @@ using System.Collections.Generic;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModDualStages : Mod, IPlayfieldTypeMod, IApplicableToBeatmapConverter, IApplicableToRulesetContainer<ManiaHitObject>
+    public class ManiaModDualStages : Mod, IPlayfieldTypeMod, IApplicableToBeatmapConverter, IApplicableToBeatmap<ManiaHitObject>
     {
         public override string Name => "Dual Stages";
         public override string ShortenedName => "DS";
@@ -34,22 +32,21 @@ namespace osu.Game.Rulesets.Mania.Mods
             mbc.TargetColumns *= 2;
         }
 
-        public void ApplyToRulesetContainer(RulesetContainer<ManiaHitObject> rulesetContainer)
+        public void ApplyToBeatmap(Beatmap<ManiaHitObject> beatmap)
         {
-            var mrc = (ManiaRulesetContainer)rulesetContainer;
-
-            // Although this can work, for now let's not allow keymods for mania-specific beatmaps
             if (isForCurrentRuleset)
                 return;
 
+            var maniaBeatmap = (ManiaBeatmap)beatmap;
+
             var newDefinitions = new List<StageDefinition>();
-            foreach (var existing in mrc.Beatmap.Stages)
+            foreach (var existing in maniaBeatmap.Stages)
             {
                 newDefinitions.Add(new StageDefinition { Columns = existing.Columns / 2 });
                 newDefinitions.Add(new StageDefinition { Columns = existing.Columns / 2 });
             }
 
-            mrc.Beatmap.Stages = newDefinitions;
+            maniaBeatmap.Stages = newDefinitions;
         }
 
         public PlayfieldType PlayfieldType => PlayfieldType.Dual;

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

@@ -96,7 +96,7 @@ namespace osu.Game.Rulesets.Mania.UI
 
         public override PassThroughInputManager CreateInputManager() => new ManiaInputManager(Ruleset.RulesetInfo, Variant);
 
-        protected override DrawableHitObject<ManiaHitObject> GetVisualRepresentation(ManiaHitObject h)
+        public override DrawableHitObject<ManiaHitObject> GetVisualRepresentation(ManiaHitObject h)
         {
             switch (h)
             {

osu.Game.Rulesets.Osu.Tests/TestCaseHitCirclePlacementMask.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.Edit;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestCaseHitCirclePlacementMask : HitObjectPlacementMaskTestCase
+    {
+        protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableHitCircle((HitCircle)hitObject);
+        protected override PlacementMask CreateMask() => new HitCirclePlacementMask();
+    }
+}

osu.Game.Rulesets.Osu.Tests/TestCaseHitCircleSelectionMask.cs

@@ -0,0 +1,29 @@
+// 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.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Tests.Visual;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestCaseHitCircleSelectionMask : HitObjectSelectionMaskTestCase
+    {
+        private readonly DrawableHitCircle drawableObject;
+
+        public TestCaseHitCircleSelectionMask()
+        {
+            var hitCircle = new HitCircle { Position = new Vector2(256, 192) };
+            hitCircle.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty { CircleSize = 2 });
+
+            Add(drawableObject = new DrawableHitCircle(hitCircle));
+        }
+
+        protected override SelectionMask CreateMask() => new HitCircleSelectionMask(drawableObject);
+    }
+}

osu.Game.Rulesets.Osu.Tests/TestCaseSlider.cs

@@ -181,7 +181,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             var slider = new Slider
             {
-                CurveType = CurveType.Linear,
+                PathType = PathType.Linear,
                 StartTime = Time.Current + 1000,
                 Position = new Vector2(-200, 0),
                 ControlPoints = new[]
@@ -207,7 +207,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             var slider = new Slider
             {
-                CurveType = CurveType.Bezier,
+                PathType = PathType.Bezier,
                 StartTime = Time.Current + 1000,
                 Position = new Vector2(-200, 0),
                 ControlPoints = new[]
@@ -232,7 +232,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             var slider = new Slider
             {
-                CurveType = CurveType.Linear,
+                PathType = PathType.Linear,
                 StartTime = Time.Current + 1000,
                 Position = new Vector2(0, 0),
                 ControlPoints = new[]
@@ -264,7 +264,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
                 StartTime = Time.Current + 1000,
                 Position = new Vector2(-100, 0),
-                CurveType = CurveType.Catmull,
+                PathType = PathType.Catmull,
                 ControlPoints = new[]
                 {
                     Vector2.Zero,

osu.Game.Rulesets.Osu.Tests/TestCaseSliderPlacementMask.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.Edit;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestCaseSliderPlacementMask : HitObjectPlacementMaskTestCase
+    {
+        protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableSlider((Slider)hitObject);
+        protected override PlacementMask CreateMask() => new SliderPlacementMask();
+    }
+}

osu.Game.Rulesets.Osu.Tests/TestCaseSliderSelectionMask.cs

@@ -0,0 +1,55 @@
+// 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 osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks;
+using osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Tests.Visual;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestCaseSliderSelectionMask : HitObjectSelectionMaskTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(SliderSelectionMask),
+            typeof(SliderCircleSelectionMask),
+            typeof(SliderBodyPiece),
+            typeof(SliderCircle),
+            typeof(PathControlPointVisualiser),
+            typeof(PathControlPointPiece)
+        };
+
+        private readonly DrawableSlider drawableObject;
+
+        public TestCaseSliderSelectionMask()
+        {
+            var slider = new Slider
+            {
+                Position = new Vector2(256, 192),
+                ControlPoints = new[]
+                {
+                    Vector2.Zero,
+                    new Vector2(150, 150),
+                    new Vector2(300, 0)
+                },
+                PathType = PathType.Bezier,
+                Distance = 350
+            };
+
+            slider.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty { CircleSize = 2 });
+
+            Add(drawableObject = new DrawableSlider(slider));
+        }
+
+        protected override SelectionMask CreateMask() => new SliderSelectionMask(drawableObject);
+    }
+}

osu.Game.Rulesets.Osu.Tests/TestCaseSpinnerPlacementMask.cs

@@ -0,0 +1,20 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestCaseSpinnerPlacementMask : HitObjectPlacementMaskTestCase
+    {
+        protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableSpinner((Spinner)hitObject);
+
+        protected override PlacementMask CreateMask() => new SpinnerPlacementMask();
+    }
+}

osu.Game.Rulesets.Osu.Tests/TestCaseSpinnerSelectionMask.cs

@@ -0,0 +1,50 @@
+// 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 osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks;
+using osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks.Components;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Tests.Visual;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestCaseSpinnerSelectionMask : HitObjectSelectionMaskTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(SpinnerSelectionMask),
+            typeof(SpinnerPiece)
+        };
+
+        private readonly DrawableSpinner drawableSpinner;
+
+        public TestCaseSpinnerSelectionMask()
+        {
+            var spinner = new Spinner
+            {
+                Position = new Vector2(256, 256),
+                StartTime = -1000,
+                EndTime = 2000
+            };
+            spinner.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty { CircleSize = 2 });
+
+            Add(new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Size = new Vector2(0.5f),
+                Child = drawableSpinner = new DrawableSpinner(spinner)
+            });
+        }
+
+        protected override SelectionMask CreateMask() => new SpinnerSelectionMask(drawableSpinner) { Size = new Vector2(0.5f) };
+    }
+}

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

@@ -36,14 +36,17 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                     StartTime = original.StartTime,
                     Samples = original.Samples,
                     ControlPoints = curveData.ControlPoints,
-                    CurveType = curveData.CurveType,
+                    PathType = curveData.PathType,
                     Distance = curveData.Distance,
                     RepeatSamples = curveData.RepeatSamples,
                     RepeatCount = curveData.RepeatCount,
                     Position = positionData?.Position ?? Vector2.Zero,
                     NewCombo = comboData?.NewCombo ?? false,
                     ComboOffset = comboData?.ComboOffset ?? 0,
-                    LegacyLastTickOffset = legacyOffset?.LegacyLastTickOffset
+                    LegacyLastTickOffset = legacyOffset?.LegacyLastTickOffset,
+                    // prior to v8, speed multipliers don't adjust for how many ticks are generated over the same distance.
+                    // this results in more (or less) ticks being generated in <v8 maps for the same time duration.
+                    TickDistanceMultiplier = beatmap.BeatmapInfo.BeatmapVersion < 8 ? 1f / beatmap.ControlPointInfo.DifficultyPointAt(original.StartTime).SpeedMultiplier : 1
                 };
             }
             else if (endTimeData != null)

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

@@ -75,15 +75,13 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
             {
                 computeSliderCursorPosition(lastSlider);
                 lastCursorPosition = lastSlider.LazyEndPosition ?? lastCursorPosition;
+
+                TravelDistance = lastSlider.LazyTravelDistance * scalingFactor;
             }
 
             // Don't need to jump to reach spinners
             if (!(BaseObject is Spinner))
                 JumpDistance = (BaseObject.StackedPosition * scalingFactor - lastCursorPosition * scalingFactor).Length;
-
-            // Todo: BUG!!! Last slider's travel distance is considered ONLY IF we ourselves are also a slider!
-            if (BaseObject is Slider)
-                TravelDistance = (lastSlider?.LazyTravelDistance ?? 0) * scalingFactor;
         }
 
         private void setTimingValues()
@@ -110,7 +108,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
                     progress = progress % 1;
 
                 // ReSharper disable once PossibleInvalidOperationException (bugged in current r# version)
-                var diff = slider.StackedPosition + slider.Curve.PositionAt(progress) - slider.LazyEndPosition.Value;
+                var diff = slider.StackedPosition + slider.Path.PositionAt(progress) - slider.LazyEndPosition.Value;
                 float dist = diff.Length;
 
                 if (dist > approxFollowCircleRadius)

osu.Game.Rulesets.Osu/Edit/HitCircleCompositionTool.cs

@@ -0,0 +1,20 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Tools;
+using osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Edit
+{
+    public class HitCircleCompositionTool : HitObjectCompositionTool
+    {
+        public HitCircleCompositionTool()
+            : base(nameof(HitCircle))
+        {
+        }
+
+        public override PlacementMask CreatePlacementMask() => new HitCirclePlacementMask();
+    }
+}

osu.Game.Rulesets.Osu/Edit/Layers/Selection/Overlays/HitCircleMask.cs

@@ -1,37 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Framework.Graphics;
-using osu.Framework.Allocation;
-using osu.Game.Graphics;
-using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
-
-namespace osu.Game.Rulesets.Osu.Edit.Layers.Selection.Overlays
-{
-    public class HitCircleMask : HitObjectMask
-    {
-        public HitCircleMask(DrawableHitCircle hitCircle)
-            : base(hitCircle)
-        {
-            Origin = Anchor.Centre;
-
-            Position = hitCircle.Position;
-            Size = hitCircle.Size;
-            Scale = hitCircle.Scale;
-
-            CornerRadius = Size.X / 2;
-
-            AddInternal(new RingPiece());
-
-            hitCircle.HitObject.PositionChanged += _ => Position = hitCircle.Position;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            Colour = colours.Yellow;
-        }
-    }
-}

osu.Game.Rulesets.Osu/Edit/Layers/Selection/Overlays/SliderCircleMask.cs

@@ -1,61 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Game.Graphics;
-using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
-using OpenTK;
-
-namespace osu.Game.Rulesets.Osu.Edit.Layers.Selection.Overlays
-{
-    public class SliderCircleMask : HitObjectMask
-    {
-        public SliderCircleMask(DrawableHitCircle sliderHead, DrawableSlider slider)
-            : this(sliderHead, Vector2.Zero, slider)
-        {
-        }
-
-        public SliderCircleMask(DrawableSliderTail sliderTail, DrawableSlider slider)
-            : this(sliderTail, ((Slider)slider.HitObject).Curve.PositionAt(1), slider)
-        {
-        }
-
-        private readonly DrawableOsuHitObject hitObject;
-
-        private SliderCircleMask(DrawableOsuHitObject hitObject, Vector2 position, DrawableSlider slider)
-            : base(hitObject)
-        {
-            this.hitObject = hitObject;
-
-            Origin = Anchor.Centre;
-
-            Position = position;
-            Size = slider.HeadCircle.Size;
-            Scale = slider.HeadCircle.Scale;
-
-            AddInternal(new RingPiece());
-
-            Select();
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            Colour = colours.Yellow;
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-
-            RelativeAnchorPosition = hitObject.RelativeAnchorPosition;
-        }
-
-        // Todo: This is temporary, since the slider circle masks don't do anything special yet. In the future they will handle input.
-        public override bool HandlePositionalInput => false;
-    }
-}

osu.Game.Rulesets.Osu/Edit/Layers/Selection/Overlays/SliderMask.cs

@@ -1,67 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Primitives;
-using osu.Game.Graphics;
-using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
-using OpenTK;
-using OpenTK.Graphics;
-
-namespace osu.Game.Rulesets.Osu.Edit.Layers.Selection.Overlays
-{
-    public class SliderMask : HitObjectMask
-    {
-        private readonly SliderBody body;
-        private readonly DrawableSlider slider;
-
-        public SliderMask(DrawableSlider slider)
-            : base(slider)
-        {
-            this.slider = slider;
-
-            Position = slider.Position;
-
-            var sliderObject = (Slider)slider.HitObject;
-
-            InternalChildren = new Drawable[]
-            {
-                body = new SliderBody(sliderObject)
-                {
-                    AccentColour = Color4.Transparent,
-                    PathWidth = sliderObject.Scale * 64
-                },
-                new SliderCircleMask(slider.HeadCircle, slider),
-                new SliderCircleMask(slider.TailCircle, slider),
-            };
-
-            sliderObject.PositionChanged += _ => Position = slider.Position;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            body.BorderColour = colours.Yellow;
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-
-            Size = slider.Size;
-            OriginPosition = slider.OriginPosition;
-
-            // Need to cause one update
-            body.UpdateProgress(0);
-        }
-
-        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => body.ReceivePositionalInputAt(screenSpacePos);
-
-        public override Vector2 SelectionPoint => ToScreenSpace(OriginPosition);
-        public override Quad SelectionQuad => body.PathDrawQuad;
-    }
-}

osu.Game.Rulesets.Osu/Edit/Masks/HitCircleMasks/Components/HitCirclePiece.cs

@@ -0,0 +1,44 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks.Components
+{
+    public class HitCirclePiece : CompositeDrawable
+    {
+        private readonly HitCircle hitCircle;
+
+        public HitCirclePiece(HitCircle hitCircle)
+        {
+            this.hitCircle = hitCircle;
+            Origin = Anchor.Centre;
+
+            Size = new Vector2((float)OsuHitObject.OBJECT_RADIUS * 2);
+            Scale = new Vector2(hitCircle.Scale);
+            CornerRadius = Size.X / 2;
+
+            InternalChild = new RingPiece();
+
+            hitCircle.PositionChanged += _ => UpdatePosition();
+            hitCircle.StackHeightChanged += _ => UpdatePosition();
+            hitCircle.ScaleChanged += _ => Scale = new Vector2(hitCircle.Scale);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Colour = colours.Yellow;
+
+            UpdatePosition();
+        }
+
+        protected virtual void UpdatePosition() => Position = hitCircle.StackedPosition;
+    }
+}

osu.Game.Rulesets.Osu/Edit/Masks/HitCircleMasks/HitCirclePlacementMask.cs

@@ -0,0 +1,42 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Input.Events;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks.Components;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks
+{
+    public class HitCirclePlacementMask : PlacementMask
+    {
+        public new HitCircle HitObject => (HitCircle)base.HitObject;
+
+        public HitCirclePlacementMask()
+            : base(new HitCircle())
+        {
+            InternalChild = new HitCirclePiece(HitObject);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            // Fixes a 1-frame position discrpancy due to the first mouse move event happening in the next frame
+            HitObject.Position = GetContainingInputManager().CurrentState.Mouse.Position;
+        }
+
+        protected override bool OnClick(ClickEvent e)
+        {
+            HitObject.StartTime = EditorClock.CurrentTime;
+            EndPlacement();
+            return true;
+        }
+
+        protected override bool OnMouseMove(MouseMoveEvent e)
+        {
+            HitObject.Position = e.MousePosition;
+            return true;
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/Masks/HitCircleMasks/HitCircleSelectionMask.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.Edit;
+using osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks.Components;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks
+{
+    public class HitCircleSelectionMask : SelectionMask
+    {
+        public HitCircleSelectionMask(DrawableHitCircle hitCircle)
+            : base(hitCircle)
+        {
+            InternalChild = new HitCirclePiece((HitCircle)hitCircle.HitObject);
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/Masks/SliderMasks/Components/PathControlPointPiece.cs

@@ -0,0 +1,113 @@
+// 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;
+using osu.Framework.Graphics.Lines;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Osu.Objects;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components
+{
+    public class PathControlPointPiece : CompositeDrawable
+    {
+        private readonly Slider slider;
+        private readonly int index;
+
+        private readonly Path path;
+        private readonly CircularContainer marker;
+
+        [Resolved]
+        private OsuColour colours { get; set; }
+
+        public PathControlPointPiece(Slider slider, int index)
+        {
+            this.slider = slider;
+            this.index = index;
+
+            Origin = Anchor.Centre;
+            AutoSizeAxes = Axes.Both;
+
+            InternalChildren = new Drawable[]
+            {
+                path = new SmoothPath
+                {
+                    Anchor = Anchor.Centre,
+                    PathWidth = 1
+                },
+                marker = new CircularContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(10),
+                    Masking = true,
+                    Child = new Box { RelativeSizeAxes = Axes.Both }
+                }
+            };
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            Position = slider.StackedPosition + slider.ControlPoints[index];
+
+            marker.Colour = isSegmentSeparator ? colours.Red : colours.Yellow;
+
+            path.ClearVertices();
+
+            if (index != slider.ControlPoints.Length - 1)
+            {
+                path.AddVertex(Vector2.Zero);
+                path.AddVertex(slider.ControlPoints[index + 1] - slider.ControlPoints[index]);
+            }
+
+            path.OriginPosition = path.PositionInBoundingBox(Vector2.Zero);
+        }
+
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => marker.ReceivePositionalInputAt(screenSpacePos);
+
+        protected override bool OnDragStart(DragStartEvent e) => true;
+
+        protected override bool OnDrag(DragEvent e)
+        {
+            var newControlPoints = slider.ControlPoints.ToArray();
+
+            if (index == 0)
+            {
+                // Special handling for the head - only the position of the slider changes
+                slider.Position += e.Delta;
+
+                // Since control points are relative to the position of the slider, they all need to be offset backwards by the delta
+                for (int i = 1; i < newControlPoints.Length; i++)
+                    newControlPoints[i] -= e.Delta;
+            }
+            else
+                newControlPoints[index] += e.Delta;
+
+            if (isSegmentSeparatorWithNext)
+                newControlPoints[index + 1] = newControlPoints[index];
+
+            if (isSegmentSeparatorWithPrevious)
+                newControlPoints[index - 1] = newControlPoints[index];
+
+            slider.ControlPoints = newControlPoints;
+            slider.Path.Calculate(true);
+
+            return true;
+        }
+
+        protected override bool OnDragEnd(DragEndEvent e) => true;
+
+        private bool isSegmentSeparator => isSegmentSeparatorWithNext || isSegmentSeparatorWithPrevious;
+
+        private bool isSegmentSeparatorWithNext => index < slider.ControlPoints.Length - 1 && slider.ControlPoints[index + 1] == slider.ControlPoints[index];
+
+        private bool isSegmentSeparatorWithPrevious => index > 0 && slider.ControlPoints[index - 1] == slider.ControlPoints[index];
+    }
+}

osu.Game.Rulesets.Osu/Edit/Masks/SliderMasks/Components/PathControlPointVisualiser.cs

@@ -0,0 +1,34 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components
+{
+    public class PathControlPointVisualiser : CompositeDrawable
+    {
+        private readonly Slider slider;
+
+        private readonly Container<PathControlPointPiece> pieces;
+
+        public PathControlPointVisualiser(Slider slider)
+        {
+            this.slider = slider;
+
+            InternalChild = pieces = new Container<PathControlPointPiece> { RelativeSizeAxes = Axes.Both };
+
+            slider.ControlPointsChanged += _ => updatePathControlPoints();
+            updatePathControlPoints();
+        }
+
+        private void updatePathControlPoints()
+        {
+            while (slider.ControlPoints.Length > pieces.Count)
+                pieces.Add(new PathControlPointPiece(slider, pieces.Count));
+            while (slider.ControlPoints.Length < pieces.Count)
+                pieces.Remove(pieces[pieces.Count - 1]);
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/Masks/SliderMasks/Components/SliderBodyPiece.cs

@@ -0,0 +1,59 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components
+{
+    public class SliderBodyPiece : CompositeDrawable
+    {
+        private readonly Slider slider;
+        private readonly ManualSliderBody body;
+
+        public SliderBodyPiece(Slider slider)
+        {
+            this.slider = slider;
+
+            InternalChild = body = new ManualSliderBody
+            {
+                AccentColour = Color4.Transparent,
+                PathWidth = slider.Scale * 64
+            };
+
+            slider.PositionChanged += _ => updatePosition();
+            slider.ScaleChanged += _ => body.PathWidth = slider.Scale * 64;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            body.BorderColour = colours.Yellow;
+
+            updatePosition();
+        }
+
+        private void updatePosition() => Position = slider.StackedPosition;
+
+        protected override void Update()
+        {
+            base.Update();
+
+            slider.Path.Calculate();
+
+            var vertices = new List<Vector2>();
+            slider.Path.GetPathToProgress(vertices, 0, 1);
+
+            body.SetVertices(vertices);
+
+            Size = body.Size;
+            OriginPosition = body.PathOffset;
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/Masks/SliderMasks/Components/SliderCirclePiece.cs

@@ -0,0 +1,36 @@
+// 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.Osu.Edit.Masks.HitCircleMasks.Components;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components
+{
+    public class SliderCirclePiece : HitCirclePiece
+    {
+        private readonly Slider slider;
+        private readonly SliderPosition position;
+
+        public SliderCirclePiece(Slider slider, SliderPosition position)
+            : base(slider.HeadCircle)
+        {
+            this.slider = slider;
+            this.position = position;
+
+            slider.ControlPointsChanged += _ => UpdatePosition();
+        }
+
+        protected override void UpdatePosition()
+        {
+            switch (position)
+            {
+                case SliderPosition.Start:
+                    Position = slider.StackedPosition + slider.Path.PositionAt(0);
+                    break;
+                case SliderPosition.End:
+                    Position = slider.StackedPosition + slider.Path.PositionAt(1);
+                    break;
+            }
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/Masks/SliderMasks/SliderCircleSelectionMask.cs

@@ -0,0 +1,24 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks
+{
+    public class SliderCircleSelectionMask : SelectionMask
+    {
+        public SliderCircleSelectionMask(DrawableOsuHitObject hitObject, Slider slider, SliderPosition position)
+            : base(hitObject)
+        {
+            InternalChild = new SliderCirclePiece(slider, position);
+
+            Select();
+        }
+
+        // Todo: This is temporary, since the slider circle masks don't do anything special yet. In the future they will handle input.
+        public override bool HandlePositionalInput => false;
+    }
+}

osu.Game.Rulesets.Osu/Edit/Masks/SliderMasks/SliderPlacementMask.cs

@@ -0,0 +1,180 @@
+// 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.Allocation;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Input.Events;
+using osu.Framework.MathUtils;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components;
+using OpenTK;
+using OpenTK.Input;
+
+namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks
+{
+    public class SliderPlacementMask : PlacementMask
+    {
+        public new Objects.Slider HitObject => (Objects.Slider)base.HitObject;
+
+        private readonly List<Segment> segments = new List<Segment>();
+        private Vector2 cursor;
+
+        private PlacementState state;
+
+        public SliderPlacementMask()
+            : base(new Objects.Slider())
+        {
+            RelativeSizeAxes = Axes.Both;
+            segments.Add(new Segment(Vector2.Zero));
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            InternalChildren = new Drawable[]
+            {
+                new SliderBodyPiece(HitObject),
+                new SliderCirclePiece(HitObject, SliderPosition.Start),
+                new SliderCirclePiece(HitObject, SliderPosition.End),
+                new PathControlPointVisualiser(HitObject),
+            };
+
+            setState(PlacementState.Initial);
+        }
+
+        protected override bool OnMouseMove(MouseMoveEvent e)
+        {
+            switch (state)
+            {
+                case PlacementState.Initial:
+                    HitObject.Position = e.MousePosition;
+                    return true;
+                case PlacementState.Body:
+                    cursor = e.MousePosition - HitObject.Position;
+                    return true;
+            }
+
+            return false;
+        }
+
+        protected override bool OnClick(ClickEvent e)
+        {
+            switch (state)
+            {
+                case PlacementState.Initial:
+                    beginCurve();
+                    break;
+                case PlacementState.Body:
+                    switch (e.Button)
+                    {
+                        case MouseButton.Left:
+                            segments.Last().ControlPoints.Add(cursor);
+                            break;
+                    }
+
+                    break;
+            }
+
+            return true;
+        }
+
+        protected override bool OnMouseUp(MouseUpEvent e)
+        {
+            if (state == PlacementState.Body && e.Button == MouseButton.Right)
+                endCurve();
+            return base.OnMouseUp(e);
+        }
+
+        protected override bool OnDoubleClick(DoubleClickEvent e)
+        {
+            segments.Add(new Segment(segments[segments.Count - 1].ControlPoints.Last()));
+            return true;
+        }
+
+        private void beginCurve()
+        {
+            BeginPlacement();
+
+            HitObject.StartTime = EditorClock.CurrentTime;
+            setState(PlacementState.Body);
+        }
+
+        private void endCurve()
+        {
+            updateSlider();
+            EndPlacement();
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+            updateSlider();
+        }
+
+        private void updateSlider()
+        {
+            for (int i = 0; i < segments.Count; i++)
+                segments[i].Calculate(i == segments.Count - 1 ? (Vector2?)cursor : null);
+
+            HitObject.ControlPoints = segments.SelectMany(s => s.ControlPoints).Concat(cursor.Yield()).ToArray();
+            HitObject.PathType = HitObject.ControlPoints.Length > 2 ? PathType.Bezier : PathType.Linear;
+            HitObject.Distance = segments.Sum(s => s.Distance);
+        }
+
+        private void setState(PlacementState newState)
+        {
+            state = newState;
+        }
+
+        private enum PlacementState
+        {
+            Initial,
+            Body,
+        }
+
+        private class Segment
+        {
+            public float Distance { get; private set; }
+
+            public readonly List<Vector2> ControlPoints = new List<Vector2>();
+
+            public Segment(Vector2 offset)
+            {
+                ControlPoints.Add(offset);
+            }
+
+            public void Calculate(Vector2? cursor = null)
+            {
+                Span<Vector2> allControlPoints = stackalloc Vector2[ControlPoints.Count + (cursor.HasValue ? 1 : 0)];
+
+                for (int i = 0; i < ControlPoints.Count; i++)
+                    allControlPoints[i] = ControlPoints[i];
+                if (cursor.HasValue)
+                    allControlPoints[allControlPoints.Length - 1] = cursor.Value;
+
+                List<Vector2> result;
+
+                switch (allControlPoints.Length)
+                {
+                    case 1:
+                    case 2:
+                        result = PathApproximator.ApproximateLinear(allControlPoints);
+                        break;
+                    default:
+                        result = PathApproximator.ApproximateBezier(allControlPoints);
+                        break;
+                }
+
+                Distance = 0;
+                for (int i = 0; i < result.Count - 1; i++)
+                    Distance += Vector2.Distance(result[i], result[i + 1]);
+            }
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/Masks/SliderMasks/SliderPosition.cs

@@ -0,0 +1,11 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks
+{
+    public enum SliderPosition
+    {
+        Start,
+        End
+    }
+}

osu.Game.Rulesets.Osu/Edit/Masks/SliderMasks/SliderSelectionMask.cs

@@ -0,0 +1,33 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks
+{
+    public class SliderSelectionMask : SelectionMask
+    {
+        private readonly SliderCircleSelectionMask headMask;
+
+        public SliderSelectionMask(DrawableSlider slider)
+            : base(slider)
+        {
+            var sliderObject = (Slider)slider.HitObject;
+
+            InternalChildren = new Drawable[]
+            {
+                new SliderBodyPiece(sliderObject),
+                headMask = new SliderCircleSelectionMask(slider.HeadCircle, sliderObject, SliderPosition.Start),
+                new SliderCircleSelectionMask(slider.TailCircle, sliderObject, SliderPosition.End),
+                new PathControlPointVisualiser(sliderObject),
+            };
+        }
+
+        public override Vector2 SelectionPoint => headMask.SelectionPoint;
+    }
+}

osu.Game.Rulesets.Osu/Edit/Masks/SpinnerMasks/Components/SpinnerPiece.cs

@@ -0,0 +1,66 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks.Components
+{
+    public class SpinnerPiece : CompositeDrawable
+    {
+        private readonly Spinner spinner;
+        private readonly CircularContainer circle;
+
+        public SpinnerPiece(Spinner spinner)
+        {
+            this.spinner = spinner;
+
+            Origin = Anchor.Centre;
+
+            RelativeSizeAxes = Axes.Both;
+            FillMode = FillMode.Fit;
+            Size = new Vector2(1.3f);
+
+            RingPiece ring;
+            InternalChildren = new Drawable[]
+            {
+                circle = new CircularContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    Alpha = 0.5f,
+                    Child = new Box { RelativeSizeAxes = Axes.Both }
+                },
+                ring = new RingPiece
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre
+                }
+            };
+
+            ring.Scale = new Vector2(spinner.Scale);
+
+            spinner.PositionChanged += _ => updatePosition();
+            spinner.StackHeightChanged += _ => updatePosition();
+            spinner.ScaleChanged += _ => ring.Scale = new Vector2(spinner.Scale);
+
+            updatePosition();
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Colour = colours.Yellow;
+        }
+
+        private void updatePosition() => Position = spinner.Position;
+
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => circle.ReceivePositionalInputAt(screenSpacePos);
+    }
+}

osu.Game.Rulesets.Osu/Edit/Masks/SpinnerMasks/SpinnerPlacementMask.cs

@@ -0,0 +1,45 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Framework.Input.Events;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks.Components;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.UI;
+
+namespace osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks
+{
+    public class SpinnerPlacementMask : PlacementMask
+    {
+        public new Spinner HitObject => (Spinner)base.HitObject;
+
+        private readonly SpinnerPiece piece;
+
+        private bool isPlacingEnd;
+
+        public SpinnerPlacementMask()
+            : base(new Spinner { Position = OsuPlayfield.BASE_SIZE / 2 })
+        {
+            InternalChild = piece = new SpinnerPiece(HitObject) { Alpha = 0.5f };
+        }
+
+        protected override bool OnClick(ClickEvent e)
+        {
+            if (isPlacingEnd)
+            {
+                HitObject.EndTime = EditorClock.CurrentTime;
+                EndPlacement();
+            }
+            else
+            {
+                HitObject.StartTime = EditorClock.CurrentTime;
+
+                isPlacingEnd = true;
+                piece.FadeTo(1f, 150, Easing.OutQuint);
+            }
+
+            return true;
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/Masks/SpinnerMasks/SpinnerSelectionMask.cs

@@ -0,0 +1,24 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks.Components;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks
+{
+    public class SpinnerSelectionMask : SelectionMask
+    {
+        private readonly SpinnerPiece piece;
+
+        public SpinnerSelectionMask(DrawableSpinner spinner)
+            : base(spinner)
+        {
+            InternalChild = piece = new SpinnerPiece((Spinner)spinner.HitObject);
+        }
+
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => piece.ReceivePositionalInputAt(screenSpacePos);
+    }
+}

osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs

@@ -8,7 +8,9 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Edit.Layers.Selection.Overlays;
+using osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks;
+using osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks;
+using osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Osu.UI;
@@ -16,32 +18,35 @@ using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Osu.Edit
 {
-    public class OsuHitObjectComposer : HitObjectComposer
+    public class OsuHitObjectComposer : HitObjectComposer<OsuHitObject>
     {
         public OsuHitObjectComposer(Ruleset ruleset)
             : base(ruleset)
         {
         }
 
-        protected override RulesetContainer CreateRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap) => new OsuEditRulesetContainer(ruleset, beatmap);
+        protected override RulesetContainer<OsuHitObject> CreateRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
+            => new OsuEditRulesetContainer(ruleset, beatmap);
 
-        protected override IReadOnlyList<ICompositionTool> CompositionTools => new ICompositionTool[]
+        protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
         {
-            new HitObjectCompositionTool<HitCircle>(),
+            new HitCircleCompositionTool(),
-            new HitObjectCompositionTool<Slider>(),
+            new SliderCompositionTool(),
-            new HitObjectCompositionTool<Spinner>()
+            new SpinnerCompositionTool()
         };
 
         protected override Container CreateLayerContainer() => new PlayfieldAdjustmentContainer { RelativeSizeAxes = Axes.Both };
 
-        public override HitObjectMask CreateMaskFor(DrawableHitObject hitObject)
+        public override SelectionMask CreateMaskFor(DrawableHitObject hitObject)
         {
             switch (hitObject)
             {
                 case DrawableHitCircle circle:
-                    return new HitCircleMask(circle);
+                    return new HitCircleSelectionMask(circle);
                 case DrawableSlider slider:
-                    return new SliderMask(slider);
+                    return new SliderSelectionMask(slider);
+                case DrawableSpinner spinner:
+                    return new SpinnerSelectionMask(spinner);
             }
 
             return base.CreateMaskFor(hitObject);

osu.Game.Rulesets.Osu/Edit/SliderCompositionTool.cs

@@ -0,0 +1,20 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Tools;
+using osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Edit
+{
+    public class SliderCompositionTool : HitObjectCompositionTool
+    {
+        public SliderCompositionTool()
+            : base(nameof(Slider))
+        {
+        }
+
+        public override PlacementMask CreatePlacementMask() => new SliderPlacementMask();
+    }
+}

osu.Game.Rulesets.Osu/Edit/SpinnerCompositionTool.cs

@@ -0,0 +1,20 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Tools;
+using osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Edit
+{
+    public class SpinnerCompositionTool : HitObjectCompositionTool
+    {
+        public SpinnerCompositionTool()
+            : base(nameof(Spinner))
+        {
+        }
+
+        public override PlacementMask CreatePlacementMask() => new SpinnerPlacementMask();
+    }
+}

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

@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.Mods
                 newControlPoints[i] = new Vector2(slider.ControlPoints[i].X, -slider.ControlPoints[i].Y);
 
             slider.ControlPoints = newControlPoints;
-            slider.Curve?.Calculate(); // Recalculate the slider curve
+            slider.Path?.Calculate(); // Recalculate the slider curve
         }
     }
 }

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

@@ -61,6 +61,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             Size = circle.DrawSize;
 
             HitObject.PositionChanged += _ => Position = HitObject.StackedPosition;
+            HitObject.StackHeightChanged += _ => Position = HitObject.StackedPosition;
+            HitObject.ScaleChanged += s => Scale = new Vector2(s);
         }
 
         public override Color4 AccentColour

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

@@ -23,7 +23,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         public readonly DrawableHitCircle HeadCircle;
         public readonly DrawableSliderTail TailCircle;
 
-        public readonly SliderBody Body;
+        public readonly SnakingSliderBody Body;
         public readonly SliderBall Ball;
 
         public DrawableSlider(Slider s)
@@ -38,7 +38,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             InternalChildren = new Drawable[]
             {
-                Body = new SliderBody(s)
+                Body = new SnakingSliderBody(s)
                 {
                     PathWidth = s.Scale * 64,
                 },
@@ -85,6 +85,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             }
 
             HitObject.PositionChanged += _ => Position = HitObject.StackedPosition;
+            HitObject.ScaleChanged += _ =>
+            {
+                Body.PathWidth = HitObject.Scale * 64;
+                Ball.Scale = new Vector2(HitObject.Scale);
+            };
+
+            slider.ControlPointsChanged += _ => Body.Refresh();
         }
 
         public override Color4 AccentColour
@@ -119,7 +126,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             double completionProgress = MathHelper.Clamp((Time.Current - slider.StartTime) / slider.Duration, 0, 1);
 
             foreach (var c in components.OfType<ISliderProgress>()) c.UpdateProgress(completionProgress);
-            foreach (var c in components.OfType<ITrackSnaking>()) c.UpdateSnakingPosition(slider.Curve.PositionAt(Body.SnakedStart ?? 0), slider.Curve.PositionAt(Body.SnakedEnd ?? 0));
+            foreach (var c in components.OfType<ITrackSnaking>()) c.UpdateSnakingPosition(slider.Path.PositionAt(Body.SnakedStart ?? 0), slider.Path.PositionAt(Body.SnakedEnd ?? 0));
             foreach (var t in components.OfType<IRequireTracking>()) t.Tracking = Ball.Tracking;
 
             Size = Body.Size;

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

@@ -16,7 +16,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
             this.slider = slider;
 
-            Position = HitObject.Position - slider.Position;
+            h.PositionChanged += _ => updatePosition();
+            slider.ControlPointsChanged += _ => updatePosition();
+
+            updatePosition();
         }
 
         protected override void Update()
@@ -33,5 +36,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         public Action<double> OnShake;
 
         protected override void Shake(double maximumLength) => OnShake?.Invoke(maximumLength);
+
+        private void updatePosition() => Position = HitObject.Position - slider.Position;
     }
 }

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

@@ -8,6 +8,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
     public class DrawableSliderTail : DrawableOsuHitObject, IRequireTracking
     {
+        private readonly Slider slider;
+
         /// <summary>
         /// The judgement text is provided by the <see cref="DrawableSlider"/>.
         /// </summary>
@@ -18,6 +20,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         public DrawableSliderTail(Slider slider, SliderTailCircle hitCircle)
             : base(hitCircle)
         {
+            this.slider = slider;
+
             Origin = Anchor.Centre;
 
             RelativeSizeAxes = Axes.Both;
@@ -25,7 +29,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             AlwaysPresent = true;
 
-            Position = HitObject.Position - slider.Position;
+            hitCircle.PositionChanged += _ => updatePosition();
+            slider.ControlPointsChanged += _ => updatePosition();
+
+            updatePosition();
         }
 
         protected override void CheckForResult(bool userTriggered, double timeOffset)
@@ -33,5 +40,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             if (!userTriggered && timeOffset >= 0)
                 ApplyResult(r => r.Type = Tracking ? HitResult.Great : HitResult.Miss);
         }
+
+        private void updatePosition() => Position = HitObject.Position - slider.Position;
     }
 }

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

@@ -112,6 +112,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     Alpha = 0
                 }
             };
+
+            s.PositionChanged += _ => Position = s.Position;
         }
 
         public float Progress => MathHelper.Clamp(Disc.RotationAbsolute / 360 / Spinner.SpinsRequired, 0, 1);
@@ -167,7 +169,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         protected override void Update()
         {
-            Disc.Tracking = OsuActionInputManager.PressedActions.Any(x => x == OsuAction.LeftButton || x == OsuAction.RightButton);
+            Disc.Tracking = OsuActionInputManager?.PressedActions.Any(x => x == OsuAction.LeftButton || x == OsuAction.RightButton) ?? false;
             if (!spmCounter.IsPresent && Disc.Tracking)
                 spmCounter.FadeIn(HitObject.TimeFadeIn);
 

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

@@ -0,0 +1,20 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    /// <summary>
+    /// A <see cref="SliderBody"/> with the ability to set the drawn vertices manually.
+    /// </summary>
+    public class ManualSliderBody : SliderBody
+    {
+        public new void SetVertices(IReadOnlyList<Vector2> vertices)
+        {
+            base.SetVertices(vertices);
+            Size = Path.Size;
+        }
+    }
+}

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

@@ -4,7 +4,6 @@
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics.Sprites;
 using OpenTK.Graphics;
 using osu.Framework.Graphics.Shapes;
@@ -14,7 +13,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
     public class NumberPiece : Container
     {
-        private readonly SpriteText number;
+        private readonly SkinnableSpriteText number;
 
         public string Text
         {
@@ -41,15 +40,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                     },
                     Child = new Box()
                 }, s => s.GetTexture("Play/osu/hitcircle") == null),
-                number = new OsuSpriteText
+                number = new SkinnableSpriteText("Play/osu/number-text", _ => new OsuSpriteText
                 {
-                    Text = @"1",
                     Font = @"Venera",
                     UseFullGlyphHeight = false,
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
                     TextSize = 40,
-                    Alpha = 1
+                }, restrictSize: false)
+                {
+                    Text = @"1"
                 }
             };
         }

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

@@ -1,24 +1,22 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// 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 osu.Framework.Allocation;
-using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Lines;
-using OpenTK.Graphics.ES30;
-using OpenTK.Graphics;
 using osu.Framework.Graphics.Primitives;
-using osu.Game.Rulesets.Objects.Types;
 using OpenTK;
+using OpenTK.Graphics;
+using OpenTK.Graphics.ES30;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
-    public class SliderBody : Container, ISliderProgress
+    public abstract class SliderBody : CompositeDrawable
     {
         private readonly SliderPath path;
+        protected Path Path => path;
+
         private readonly BufferedContainer container;
 
         public float PathWidth
@@ -30,15 +28,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
         /// <summary>
         /// Offset in absolute coordinates from the start of the curve.
         /// </summary>
-        public Vector2 PathOffset { get; private set; }
+        public virtual Vector2 PathOffset => path.PositionInBoundingBox(path.Vertices[0]);
-
-        public readonly List<Vector2> CurrentCurve = new List<Vector2>();
-
-        public readonly Bindable<bool> SnakingIn = new Bindable<bool>();
-        public readonly Bindable<bool> SnakingOut = new Bindable<bool>();
-
-        public double? SnakedStart { get; private set; }
-        public double? SnakedEnd { get; private set; }
 
         /// <summary>
         /// Used to colour the path.
@@ -74,28 +64,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 
         public Quad PathDrawQuad => container.ScreenSpaceDrawQuad;
 
-        private Vector2 topLeftOffset;
+        protected SliderBody()
-
-        private readonly Slider slider;
-
-        public SliderBody(Slider s)
         {
-            slider = s;
+            InternalChild = container = new BufferedContainer
-
-            Children = new Drawable[]
-            {
-                container = new BufferedContainer
             {
                 RelativeSizeAxes = Axes.Both,
                 CacheDrawnFrameBuffer = true,
-                    Children = new Drawable[]
+                Child = path = new SliderPath { Blending = BlendingMode.None }
-                    {
-                        path = new SliderPath
-                        {
-                            Blending = BlendingMode.None,
-                        },
-                    }
-                },
             };
 
             container.Attach(RenderbufferInternalFormat.DepthComponent16);
@@ -103,81 +78,15 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => path.ReceivePositionalInputAt(screenSpacePos);
 
-        public void SetRange(double p0, double p1)
+        /// <summary>
+        /// Sets the vertices of the path which should be drawn by this <see cref="SliderBody"/>.
+        /// </summary>
+        /// <param name="vertices">The vertices</param>
+        protected void SetVertices(IReadOnlyList<Vector2> vertices)
         {
-            if (p0 > p1)
+            path.Vertices = vertices;
-                MathHelper.Swap(ref p0, ref p1);
-
-            if (updateSnaking(p0, p1))
-            {
-                // The path is generated such that its size encloses it. This change of size causes the path
-                // to move around while snaking, so we need to offset it to make sure it maintains the
-                // same position as when it is fully snaked.
-                var newTopLeftOffset = path.PositionInBoundingBox(Vector2.Zero);
-                path.Position = topLeftOffset - newTopLeftOffset;
-
             container.ForceRedraw();
         }
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            computeSize();
-        }
-
-        private void computeSize()
-        {
-            // Generate the entire curve
-            slider.Curve.GetPathToProgress(CurrentCurve, 0, 1);
-            foreach (Vector2 p in CurrentCurve)
-                path.AddVertex(p);
-
-            Size = path.Size;
-
-            topLeftOffset = path.PositionInBoundingBox(Vector2.Zero);
-            PathOffset = path.PositionInBoundingBox(CurrentCurve[0]);
-        }
-
-        private bool updateSnaking(double p0, double p1)
-        {
-            if (SnakedStart == p0 && SnakedEnd == p1) return false;
-
-            SnakedStart = p0;
-            SnakedEnd = p1;
-
-            slider.Curve.GetPathToProgress(CurrentCurve, p0, p1);
-
-            path.ClearVertices();
-            foreach (Vector2 p in CurrentCurve)
-                path.AddVertex(p);
-
-            return true;
-        }
-
-        public void UpdateProgress(double completionProgress)
-        {
-            var span = slider.SpanAt(completionProgress);
-            var spanProgress = slider.ProgressAt(completionProgress);
-
-            double start = 0;
-            double end = SnakingIn ? MathHelper.Clamp((Time.Current - (slider.StartTime - slider.TimePreempt)) / slider.TimeFadeIn, 0, 1) : 1;
-
-            if (span >= slider.SpanCount() - 1)
-            {
-                if (Math.Min(span, slider.SpanCount() - 1) % 2 == 1)
-                {
-                    start = 0;
-                    end = SnakingOut ? spanProgress : 1;
-                }
-                else
-                {
-                    start = SnakingOut ? spanProgress : 0;
-                }
-            }
-
-            SetRange(start, end);
-        }
 
         private class SliderPath : SmoothPath
         {

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

@@ -0,0 +1,118 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Game.Rulesets.Objects.Types;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    /// <summary>
+    /// A <see cref="SliderBody"/> which changes its curve depending on the snaking progress.
+    /// </summary>
+    public class SnakingSliderBody : SliderBody, ISliderProgress
+    {
+        public readonly List<Vector2> CurrentCurve = new List<Vector2>();
+
+        public readonly Bindable<bool> SnakingIn = new Bindable<bool>();
+        public readonly Bindable<bool> SnakingOut = new Bindable<bool>();
+
+        public double? SnakedStart { get; private set; }
+        public double? SnakedEnd { get; private set; }
+
+        public override Vector2 PathOffset => snakedPathOffset;
+
+        /// <summary>
+        /// The top-left position of the path when fully snaked.
+        /// </summary>
+        private Vector2 snakedPosition;
+
+        /// <summary>
+        /// The offset of the path from <see cref="snakedPosition"/> when fully snaked.
+        /// </summary>
+        private Vector2 snakedPathOffset;
+
+        private readonly Slider slider;
+
+        public SnakingSliderBody(Slider slider)
+        {
+            this.slider = slider;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Refresh();
+        }
+
+        public void UpdateProgress(double completionProgress)
+        {
+            var span = slider.SpanAt(completionProgress);
+            var spanProgress = slider.ProgressAt(completionProgress);
+
+            double start = 0;
+            double end = SnakingIn ? MathHelper.Clamp((Time.Current - (slider.StartTime - slider.TimePreempt)) / slider.TimeFadeIn, 0, 1) : 1;
+
+            if (span >= slider.SpanCount() - 1)
+            {
+                if (Math.Min(span, slider.SpanCount() - 1) % 2 == 1)
+                {
+                    start = 0;
+                    end = SnakingOut ? spanProgress : 1;
+                }
+                else
+                {
+                    start = SnakingOut ? spanProgress : 0;
+                }
+            }
+
+            setRange(start, end);
+        }
+
+        public void Refresh()
+        {
+            // Generate the entire curve
+            slider.Path.GetPathToProgress(CurrentCurve, 0, 1);
+            SetVertices(CurrentCurve);
+
+            // The body is sized to the full path size to avoid excessive autosize computations
+            Size = Path.Size;
+
+            snakedPosition = Path.PositionInBoundingBox(Vector2.Zero);
+            snakedPathOffset = Path.PositionInBoundingBox(Path.Vertices[0]);
+
+            var lastSnakedStart = SnakedStart ?? 0;
+            var lastSnakedEnd = SnakedEnd ?? 0;
+
+            SnakedStart = null;
+            SnakedEnd = null;
+
+            setRange(lastSnakedStart, lastSnakedEnd);
+        }
+
+        private void setRange(double p0, double p1)
+        {
+            if (p0 > p1)
+                MathHelper.Swap(ref p0, ref p1);
+
+            if (SnakedStart == p0 && SnakedEnd == p1) return;
+
+            SnakedStart = p0;
+            SnakedEnd = p1;
+
+            slider.Path.GetPathToProgress(CurrentCurve, p0, p1);
+
+            SetVertices(CurrentCurve);
+
+            // The bounding box of the path expands as it snakes, which in turn shifts the position of the path.
+            // Depending on the direction of expansion, it may appear as if the path is expanding towards the position of the slider
+            // rather than expanding out from the position of the slider.
+            // To remove this effect, the path's position is shifted towards its final snaked position
+
+            Path.Position = snakedPosition - Path.PositionInBoundingBox(Vector2.Zero);
+        }
+    }
+}

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

@@ -16,13 +16,15 @@ namespace osu.Game.Rulesets.Osu.Objects
         public const double OBJECT_RADIUS = 64;
 
         public event Action<Vector2> PositionChanged;
+        public event Action<int> StackHeightChanged;
+        public event Action<float> ScaleChanged;
 
         public double TimePreempt = 600;
         public double TimeFadeIn = 400;
 
         private Vector2 position;
 
-        public Vector2 Position
+        public virtual Vector2 Position
         {
             get => position;
             set
@@ -44,13 +46,39 @@ namespace osu.Game.Rulesets.Osu.Objects
 
         public Vector2 StackedEndPosition => EndPosition + StackOffset;
 
-        public virtual int StackHeight { get; set; }
+        private int stackHeight;
+
+        public int StackHeight
+        {
+            get => stackHeight;
+            set
+            {
+                if (stackHeight == value)
+                    return;
+                stackHeight = value;
+
+                StackHeightChanged?.Invoke(value);
+            }
+        }
 
         public Vector2 StackOffset => new Vector2(StackHeight * Scale * -6.4f);
 
         public double Radius => OBJECT_RADIUS * Scale;
 
-        public float Scale { get; set; } = 1;
+        private float scale = 1;
+
+        public float Scale
+        {
+            get => scale;
+            set
+            {
+                if (scale == value)
+                    return;
+                scale = value;
+
+                ScaleChanged?.Invoke(value);
+            }
+        }
 
         public virtual bool NewCombo { get; set; }
 

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

@@ -22,7 +22,9 @@ namespace osu.Game.Rulesets.Osu.Objects
         /// </summary>
         private const float base_scoring_distance = 100;
 
-        public double EndTime => StartTime + this.SpanCount() * Curve.Distance / Velocity;
+        public event Action<Vector2[]> ControlPointsChanged;
+
+        public double EndTime => StartTime + this.SpanCount() * Path.Distance / Velocity;
         public double Duration => EndTime - StartTime;
 
         public Vector2 StackedPositionAt(double t) => StackedPosition + this.CurvePositionAt(t);
@@ -50,24 +52,49 @@ namespace osu.Game.Rulesets.Osu.Objects
             }
         }
 
-        public SliderCurve Curve { get; } = new SliderCurve();
+        public SliderPath Path { get; } = new SliderPath();
 
         public Vector2[] ControlPoints
         {
-            get { return Curve.ControlPoints; }
+            get => Path.ControlPoints;
-            set { Curve.ControlPoints = value; }
+            set
+            {
+                if (Path.ControlPoints == value)
+                    return;
+                Path.ControlPoints = value;
+
+                ControlPointsChanged?.Invoke(value);
+
+                if (TailCircle != null)
+                    TailCircle.Position = EndPosition;
+            }
         }
 
-        public CurveType CurveType
+        public PathType PathType
         {
-            get { return Curve.CurveType; }
+            get { return Path.PathType; }
-            set { Curve.CurveType = value; }
+            set { Path.PathType = value; }
         }
 
         public double Distance
         {
-            get { return Curve.Distance; }
+            get { return Path.Distance; }
-            set { Curve.Distance = value; }
+            set { Path.Distance = value; }
+        }
+
+        public override Vector2 Position
+        {
+            get => base.Position;
+            set
+            {
+                base.Position = value;
+
+                if (HeadCircle != null)
+                    HeadCircle.Position = value;
+
+                if (TailCircle != null)
+                    TailCircle.Position = EndPosition;
+            }
         }
 
         public double? LegacyLastTickOffset { get; set; }
@@ -92,8 +119,21 @@ namespace osu.Game.Rulesets.Osu.Objects
         /// </summary>
         public double SpanDuration => Duration / this.SpanCount();
 
-        public double Velocity;
+        /// <summary>
-        public double TickDistance;
+        /// Velocity of this <see cref="Slider"/>.
+        /// </summary>
+        public double Velocity { get; private set; }
+
+        /// <summary>
+        /// Spacing between <see cref="SliderTick"/>s of this <see cref="Slider"/>.
+        /// </summary>
+        public double TickDistance { get; private set; }
+
+        /// <summary>
+        /// An extra multiplier that affects the number of <see cref="SliderTick"/>s generated by this <see cref="Slider"/>.
+        /// An increase in this value increases <see cref="TickDistance"/>, which reduces the number of ticks generated.
+        /// </summary>
+        public double TickDistanceMultiplier = 1;
 
         public HitCircle HeadCircle;
         public SliderTailCircle TailCircle;
@@ -108,7 +148,7 @@ namespace osu.Game.Rulesets.Osu.Objects
             double scoringDistance = base_scoring_distance * difficulty.SliderMultiplier * difficultyPoint.SpeedMultiplier;
 
             Velocity = scoringDistance / timingPoint.BeatLength;
-            TickDistance = scoringDistance / difficulty.SliderTickRate;
+            TickDistance = scoringDistance / difficulty.SliderTickRate * TickDistanceMultiplier;
         }
 
         protected override void CreateNestedHitObjects()
@@ -149,7 +189,7 @@ namespace osu.Game.Rulesets.Osu.Objects
 
         private void createTicks()
         {
-            var length = Curve.Distance;
+            var length = Path.Distance;
             var tickDistance = MathHelper.Clamp(TickDistance, 0, length);
 
             if (tickDistance == 0) return;
@@ -188,7 +228,7 @@ namespace osu.Game.Rulesets.Osu.Objects
                         SpanIndex = span,
                         SpanStartTime = spanStartTime,
                         StartTime = spanStartTime + timeProgress * SpanDuration,
-                        Position = Position + Curve.PositionAt(distanceProgress),
+                        Position = Position + Path.PositionAt(distanceProgress),
                         StackHeight = StackHeight,
                         Scale = Scale,
                         Samples = sampleList
@@ -206,7 +246,7 @@ namespace osu.Game.Rulesets.Osu.Objects
                     RepeatIndex = repeatIndex,
                     SpanDuration = SpanDuration,
                     StartTime = StartTime + repeat * SpanDuration,
-                    Position = Position + Curve.PositionAt(repeat % 2),
+                    Position = Position + Path.PositionAt(repeat % 2),
                     StackHeight = StackHeight,
                     Scale = Scale,
                     Samples = new List<SampleInfo>(RepeatSamples[repeatIndex])

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

@@ -7,6 +7,7 @@ using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Judgements;
+using OpenTK;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {
@@ -31,5 +32,10 @@ namespace osu.Game.Rulesets.Osu.Objects
         }
 
         public override Judgement CreateJudgement() => new OsuJudgement();
+
+        public override void OffsetPosition(Vector2 offset)
+        {
+            // for now we don't want to allow spinners to be moved around.
+        }
     }
 }

osu.Game.Rulesets.Osu/UI/OsuRulesetContainer.cs

@@ -31,7 +31,7 @@ namespace osu.Game.Rulesets.Osu.UI
 
         public override PassThroughInputManager CreateInputManager() => new OsuInputManager(Ruleset.RulesetInfo);
 
-        protected override DrawableHitObject<OsuHitObject> GetVisualRepresentation(OsuHitObject h)
+        public override DrawableHitObject<OsuHitObject> GetVisualRepresentation(OsuHitObject h)
         {
             switch (h)
             {

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

@@ -78,7 +78,7 @@ namespace osu.Game.Rulesets.Taiko.UI
 
         protected override Playfield CreatePlayfield() => new TaikoPlayfield(Beatmap.ControlPointInfo);
 
-        protected override DrawableHitObject<TaikoHitObject> GetVisualRepresentation(TaikoHitObject h)
+        public override DrawableHitObject<TaikoHitObject> GetVisualRepresentation(TaikoHitObject h)
         {
             switch (h)
             {

osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapDecoderTest.cs

@@ -8,11 +8,13 @@ using OpenTK.Graphics;
 using osu.Game.Tests.Resources;
 using System.Linq;
 using osu.Game.Audio;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Skinning;
 
@@ -21,6 +23,25 @@ namespace osu.Game.Tests.Beatmaps.Formats
     [TestFixture]
     public class LegacyBeatmapDecoderTest
     {
+        [Test]
+        public void TestDecodeBeatmapVersion()
+        {
+            using (var resStream = Resource.OpenResource("beatmap-version.osu"))
+            using (var stream = new StreamReader(resStream))
+            {
+                var decoder = Decoder.GetDecoder<Beatmap>(stream);
+
+                stream.BaseStream.Position = 0;
+                stream.DiscardBufferedData();
+
+                var working = new TestWorkingBeatmap(decoder.Decode(stream));
+
+                Assert.AreEqual(6, working.BeatmapInfo.BeatmapVersion);
+                Assert.AreEqual(6, working.Beatmap.BeatmapInfo.BeatmapVersion);
+                Assert.AreEqual(6, working.GetPlayableBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo.BeatmapVersion);
+            }
+        }
+
         [Test]
         public void TestDecodeBeatmapGeneral()
         {

osu.Game.Tests/Resources/beatmap-version.osu

@@ -0,0 +1 @@
+osu file format v6

osu.Game.Tests/Visual/TestCaseHitObjectComposer.cs

@@ -13,14 +13,18 @@ using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Edit;
+using osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks;
+using osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks.Components;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit.Screens.Compose;
 using osu.Game.Screens.Edit.Screens.Compose.Layers;
 using osu.Game.Tests.Beatmaps;
 
 namespace osu.Game.Tests.Visual
 {
     [TestFixture]
-    public class TestCaseHitObjectComposer : OsuTestCase
+    [Cached(Type = typeof(IPlacementHandler))]
+    public class TestCaseHitObjectComposer : OsuTestCase, IPlacementHandler
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
@@ -29,9 +33,14 @@ namespace osu.Game.Tests.Visual
             typeof(HitObjectComposer),
             typeof(OsuHitObjectComposer),
             typeof(HitObjectMaskLayer),
-            typeof(NotNullAttribute)
+            typeof(NotNullAttribute),
+            typeof(HitCirclePiece),
+            typeof(HitCircleSelectionMask),
+            typeof(HitCirclePlacementMask),
         };
 
+        private HitObjectComposer composer;
+
         [BackgroundDependencyLoader]
         private void load()
         {
@@ -49,9 +58,7 @@ namespace osu.Game.Tests.Visual
                             Vector2.Zero,
                             new Vector2(216, 0),
                         },
-                        Distance = 400,
+                        Distance = 216,
-                        Velocity = 1,
-                        TickDistance = 100,
                         Scale = 0.5f,
                     }
                 },
@@ -61,7 +68,15 @@ namespace osu.Game.Tests.Visual
             Dependencies.CacheAs<IAdjustableClock>(clock);
             Dependencies.CacheAs<IFrameBasedClock>(clock);
 
-            Child = new OsuHitObjectComposer(new OsuRuleset());
+            Child = composer = new OsuHitObjectComposer(new OsuRuleset());
         }
+
+        public void BeginPlacement(HitObject hitObject)
+        {
+        }
+
+        public void EndPlacement(HitObject hitObject) => composer.Add(hitObject);
+
+        public void Delete(HitObject hitObject) => composer.Remove(hitObject);
     }
 }

osu.Game/Beatmaps/BeatmapInfo.cs

@@ -19,7 +19,6 @@ namespace osu.Game.Beatmaps
         [JsonIgnore]
         public int ID { get; set; }
 
-        //TODO: should be in database
         public int BeatmapVersion;
 
         private int? onlineBeatmapID;

osu.Game/Beatmaps/BeatmapManager.cs

@@ -148,11 +148,12 @@ namespace osu.Game.Beatmaps
         /// </summary>
         /// <param name="beatmapSetInfo">The <see cref="BeatmapSetInfo"/> to be downloaded.</param>
         /// <param name="noVideo">Whether the beatmap should be downloaded without video. Defaults to false.</param>
-        public void Download(BeatmapSetInfo beatmapSetInfo, bool noVideo = false)
+        /// <returns>Downloading can happen</returns>
+        public bool Download(BeatmapSetInfo beatmapSetInfo, bool noVideo = false)
         {
             var existing = GetExistingDownload(beatmapSetInfo);
 
-            if (existing != null || api == null) return;
+            if (existing != null || api == null) return false;
 
             if (!api.LocalUser.Value.IsSupporter)
             {
@@ -161,7 +162,7 @@ namespace osu.Game.Beatmaps
                     Icon = FontAwesome.fa_superpowers,
                     Text = "You gotta be an osu!supporter to download for now 'yo"
                 });
-                return;
+                return false;
             }
 
             var downloadNotification = new DownloadNotification
@@ -227,6 +228,7 @@ namespace osu.Game.Beatmaps
             // don't run in the main api queue as this is a long-running task.
             Task.Factory.StartNew(() => request.Perform(api), TaskCreationOptions.LongRunning);
             BeatmapDownloadBegan?.Invoke(request);
+            return true;
         }
 
         protected override void PresentCompletedImport(IEnumerable<BeatmapSetInfo> imported)
@@ -348,7 +350,7 @@ namespace osu.Game.Beatmaps
                 OnlineBeatmapSetID = beatmap.BeatmapInfo.BeatmapSet?.OnlineBeatmapSetID,
                 Beatmaps = new List<BeatmapInfo>(),
                 Hash = computeBeatmapSetHash(reader),
-                Metadata = beatmap.Metadata
+                Metadata = beatmap.Metadata,
             };
         }
 

osu.Game/Beatmaps/Drawables/BeatmapSetDownloader.cs

@@ -71,10 +71,12 @@ namespace osu.Game.Beatmaps.Drawables
             if (DownloadState.Value > DownloadStatus.NotDownloaded)
                 return;
 
-            beatmaps.Download(set, noVideo);
+            if (beatmaps.Download(set, noVideo))
-
+            {
+                // Only change state if download can happen
                 DownloadState.Value = DownloadStatus.Downloading;
             }
+        }
 
         private void setAdded(BeatmapSetInfo s)
         {

osu.Game/Beatmaps/DummyWorkingBeatmap.cs

@@ -26,15 +26,7 @@ namespace osu.Game.Beatmaps
                     Title = "no beatmaps available!"
                 },
                 BeatmapSet = new BeatmapSetInfo(),
-                BaseDifficulty = new BeatmapDifficulty
+                BaseDifficulty = new BeatmapDifficulty(),
-                {
-                    DrainRate = 0,
-                    CircleSize = 0,
-                    OverallDifficulty = 0,
-                    ApproachRate = 0,
-                    SliderMultiplier = 0,
-                    SliderTickRate = 0,
-                },
                 Ruleset = new DummyRulesetInfo()
             })
         {

osu.Game/Beatmaps/WorkingBeatmap.cs

@@ -41,8 +41,13 @@ namespace osu.Game.Beatmaps
             beatmap = new RecyclableLazy<IBeatmap>(() =>
             {
                 var b = GetBeatmap() ?? new Beatmap();
-                // use the database-backed info.
+
+                // The original beatmap version needs to be preserved as the database doesn't contain it
+                BeatmapInfo.BeatmapVersion = b.BeatmapInfo.BeatmapVersion;
+
+                // Use the database-backed info for more up-to-date values (beatmap id, ranked status, etc)
                 b.BeatmapInfo = BeatmapInfo;
+
                 return b;
             });
 

osu.Game/Online/API/Requests/SearchBeatmapSetsRequest.cs

@@ -1,16 +1,14 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System.Collections.Generic;
 using System.ComponentModel;
-using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Direct;
 using osu.Game.Rulesets;
 
 namespace osu.Game.Online.API.Requests
 {
-    public class SearchBeatmapSetsRequest : APIRequest<IEnumerable<APIBeatmapSet>>
+    public class SearchBeatmapSetsRequest : APIRequest<SearchBeatmapSetsResponse>
     {
         private readonly string query;
         private readonly RulesetInfo ruleset;
@@ -35,6 +33,7 @@ namespace osu.Game.Online.API.Requests
     public enum BeatmapSearchCategory
     {
         Any = 7,
+
         [Description("Ranked & Approved")]
         RankedApproved = 0,
         Approved = 1,
@@ -43,6 +42,7 @@ namespace osu.Game.Online.API.Requests
         Qualified = 3,
         Pending = 4,
         Graveyard = 5,
+
         [Description("My Maps")]
         MyMaps = 6,
     }

osu.Game/Online/API/Requests/SearchBeatmapSetsResponse.cs

@@ -0,0 +1,20 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using osu.Game.Online.API.Requests.Responses;
+
+namespace osu.Game.Online.API.Requests
+{
+    public class SearchBeatmapSetsResponse
+    {
+        public IEnumerable<APIBeatmapSet> BeatmapSets;
+
+        /// <summary>
+        /// A collection of parameters which should be passed to the search endpoint to fetch the next page.
+        /// </summary>
+        [JsonProperty("cursor")]
+        public dynamic CursorJson;
+    }
+}

osu.Game/Overlays/DirectOverlay.cs

@@ -288,7 +288,7 @@ namespace osu.Game.Overlays
             {
                 Task.Run(() =>
                 {
-                    var sets = response.Select(r => r.ToBeatmapSet(rulesets)).ToList();
+                    var sets = response.BeatmapSets.Select(r => r.ToBeatmapSet(rulesets)).ToList();
 
                     // may not need scheduling; loads async internally.
                     Schedule(() =>

osu.Game/Rulesets/Edit/EditRulesetContainer.cs

@@ -0,0 +1,106 @@
+// 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.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Edit
+{
+    public abstract class EditRulesetContainer : CompositeDrawable
+    {
+        /// <summary>
+        /// The <see cref="Playfield"/> contained by this <see cref="EditRulesetContainer"/>.
+        /// </summary>
+        public abstract Playfield Playfield { get; }
+
+        internal EditRulesetContainer()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        /// <summary>
+        /// Adds a <see cref="HitObject"/> to the <see cref="Beatmap"/> and displays a visual representation of it.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> to add.</param>
+        /// <returns>The visual representation of <paramref name="hitObject"/>.</returns>
+        internal abstract DrawableHitObject Add(HitObject hitObject);
+
+        /// <summary>
+        /// Removes a <see cref="HitObject"/> from the <see cref="Beatmap"/> and the display.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> to remove.</param>
+        /// <returns>The visual representation of the removed <paramref name="hitObject"/>.</returns>
+        internal abstract DrawableHitObject Remove(HitObject hitObject);
+    }
+
+    public class EditRulesetContainer<TObject> : EditRulesetContainer
+        where TObject : HitObject
+    {
+        public override Playfield Playfield => rulesetContainer.Playfield;
+
+        private Ruleset ruleset => rulesetContainer.Ruleset;
+        private Beatmap<TObject> beatmap => rulesetContainer.Beatmap;
+
+        private readonly RulesetContainer<TObject> rulesetContainer;
+
+        public EditRulesetContainer(RulesetContainer<TObject> rulesetContainer)
+        {
+            this.rulesetContainer = rulesetContainer;
+
+            InternalChild = rulesetContainer;
+
+            Playfield.DisplayJudgements.Value = false;
+        }
+
+        internal override DrawableHitObject Add(HitObject hitObject)
+        {
+            var tObject = (TObject)hitObject;
+
+            // Add to beatmap, preserving sorting order
+            var insertionIndex = beatmap.HitObjects.FindLastIndex(h => h.StartTime <= hitObject.StartTime);
+            beatmap.HitObjects.Insert(insertionIndex + 1, tObject);
+
+            // Process object
+            var processor = ruleset.CreateBeatmapProcessor(beatmap);
+
+            processor.PreProcess();
+            tObject.ApplyDefaults(beatmap.ControlPointInfo, beatmap.BeatmapInfo.BaseDifficulty);
+            processor.PostProcess();
+
+            // Add visual representation
+            var drawableObject = rulesetContainer.GetVisualRepresentation(tObject);
+
+            rulesetContainer.Playfield.Add(drawableObject);
+            rulesetContainer.Playfield.PostProcess();
+
+            return drawableObject;
+        }
+
+        internal override DrawableHitObject Remove(HitObject hitObject)
+        {
+            var tObject = (TObject)hitObject;
+
+            // Remove from beatmap
+            beatmap.HitObjects.Remove(tObject);
+
+            // Process the beatmap
+            var processor = ruleset.CreateBeatmapProcessor(beatmap);
+
+            processor.PreProcess();
+            processor.PostProcess();
+
+            // Remove visual representation
+            var drawableObject = Playfield.AllHitObjects.Single(d => d.HitObject == hitObject);
+
+            rulesetContainer.Playfield.Remove(drawableObject);
+            rulesetContainer.Playfield.PostProcess();
+
+            return drawableObject;
+        }
+    }
+}

osu.Game/Rulesets/Edit/HitObjectComposer.cs

@@ -13,6 +13,7 @@ using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Edit.Tools;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
 using osu.Game.Screens.Edit.Screens.Compose.Layers;
@@ -22,21 +23,24 @@ namespace osu.Game.Rulesets.Edit
 {
     public abstract class HitObjectComposer : CompositeDrawable
     {
-        private readonly Ruleset ruleset;
-
         public IEnumerable<DrawableHitObject> HitObjects => rulesetContainer.Playfield.AllHitObjects;
 
-        protected ICompositionTool CurrentTool { get; private set; }
+        protected readonly Ruleset Ruleset;
+
+        protected readonly IBindable<WorkingBeatmap> Beatmap = new Bindable<WorkingBeatmap>();
+
         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 EditRulesetContainer rulesetContainer;
 
-        protected HitObjectComposer(Ruleset ruleset)
+        private HitObjectMaskLayer maskLayer;
+        private PlacementContainer placementContainer;
+
+        internal HitObjectComposer(Ruleset ruleset)
         {
-            this.ruleset = ruleset;
+            Ruleset = ruleset;
 
             RelativeSizeAxes = Axes.Both;
         }
@@ -44,11 +48,11 @@ namespace osu.Game.Rulesets.Edit
         [BackgroundDependencyLoader]
         private void load(IBindableBeatmap beatmap, IFrameBasedClock framedClock)
         {
-            this.beatmap.BindTo(beatmap);
+            Beatmap.BindTo(beatmap);
 
             try
             {
-                rulesetContainer = CreateRulesetContainer(ruleset, beatmap.Value);
+                rulesetContainer = CreateRulesetContainer();
                 rulesetContainer.Clock = framedClock;
             }
             catch (Exception e)
@@ -57,14 +61,15 @@ namespace osu.Game.Rulesets.Edit
                 return;
             }
 
-            var layerBelowRuleset = new BorderLayer
+            var layerBelowRuleset = CreateLayerContainer();
-            {
+            layerBelowRuleset.Child = new BorderLayer { RelativeSizeAxes = Axes.Both };
-                RelativeSizeAxes = Axes.Both,
-                Child = CreateLayerContainer()
-            };
 
             var layerAboveRuleset = CreateLayerContainer();
-            layerAboveRuleset.Child = new HitObjectMaskLayer();
+            layerAboveRuleset.Children = new Drawable[]
+            {
+                maskLayer = new HitObjectMaskLayer(),
+                placementContainer = new PlacementContainer(),
+            };
 
             layerContainers.Add(layerBelowRuleset);
             layerContainers.Add(layerAboveRuleset);
@@ -107,8 +112,8 @@ namespace osu.Game.Rulesets.Edit
             };
 
             toolboxCollection.Items =
-                CompositionTools.Select(t => new RadioButton(t.Name, () => setCompositionTool(t)))
+                CompositionTools.Select(t => new RadioButton(t.Name, () => placementContainer.CurrentTool = t))
-                .Prepend(new RadioButton("Select", () => setCompositionTool(null)))
+                .Prepend(new RadioButton("Select", () => placementContainer.CurrentTool = null))
                 .ToList();
 
             toolboxCollection.Items[0].Select();
@@ -119,18 +124,11 @@ namespace osu.Game.Rulesets.Edit
             var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
             dependencies.CacheAs(this);
-            Config = dependencies.Get<RulesetConfigCache>().GetConfigFor(ruleset);
+            Config = dependencies.Get<RulesetConfigCache>().GetConfigFor(Ruleset);
 
             return dependencies;
         }
 
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            rulesetContainer.Playfield.DisplayJudgements.Value = false;
-        }
-
         protected override void UpdateAfterChildren()
         {
             base.UpdateAfterChildren();
@@ -144,17 +142,27 @@ namespace osu.Game.Rulesets.Edit
             });
         }
 
-        private void setCompositionTool(ICompositionTool tool) => CurrentTool = tool;
+        /// <summary>
+        /// Adds a <see cref="HitObject"/> to the <see cref="Beatmaps.Beatmap"/> and visualises it.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> to add.</param>
+        public void Add(HitObject hitObject)
+        {
+            maskLayer.AddMaskFor(rulesetContainer.Add(hitObject));
+            placementContainer.Refresh();
+        }
 
-        protected virtual RulesetContainer CreateRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap) => ruleset.CreateRulesetContainerWith(beatmap);
+        public void Remove(HitObject hitObject) => maskLayer.RemoveMaskFor(rulesetContainer.Remove(hitObject));
 
-        protected abstract IReadOnlyList<ICompositionTool> CompositionTools { get; }
+        internal abstract EditRulesetContainer CreateRulesetContainer();
+
+        protected abstract IReadOnlyList<HitObjectCompositionTool> CompositionTools { get; }
 
         /// <summary>
-        /// Creates a <see cref="HitObjectMask"/> for a specific <see cref="DrawableHitObject"/>.
+        /// Creates a <see cref="SelectionMask"/> for a specific <see cref="DrawableHitObject"/>.
         /// </summary>
         /// <param name="hitObject">The <see cref="DrawableHitObject"/> to create the overlay for.</param>
-        public virtual HitObjectMask CreateMaskFor(DrawableHitObject hitObject) => null;
+        public virtual SelectionMask CreateMaskFor(DrawableHitObject hitObject) => null;
 
         /// <summary>
         /// Creates a <see cref="MaskSelection"/> which outlines <see cref="DrawableHitObject"/>s
@@ -167,4 +175,18 @@ namespace osu.Game.Rulesets.Edit
         /// </summary>
         protected virtual Container CreateLayerContainer() => new Container { RelativeSizeAxes = Axes.Both };
     }
+
+    public abstract class HitObjectComposer<TObject> : HitObjectComposer
+        where TObject : HitObject
+    {
+        protected HitObjectComposer(Ruleset ruleset)
+            : base(ruleset)
+        {
+        }
+
+        internal override EditRulesetContainer CreateRulesetContainer()
+            => new EditRulesetContainer<TObject>(CreateRulesetContainer(Ruleset, Beatmap.Value));
+
+        protected abstract RulesetContainer<TObject> CreateRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap);
+    }
 }

osu.Game/Rulesets/Edit/PlacementMask.cs

@@ -0,0 +1,96 @@
+// 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.Input;
+using osu.Framework.Input.Events;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Screens.Edit.Screens.Compose;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Edit
+{
+    /// <summary>
+    /// A mask which governs the creation of a new <see cref="HitObject"/> to actualisation.
+    /// </summary>
+    public abstract class PlacementMask : CompositeDrawable, IRequireHighFrequencyMousePosition
+    {
+        /// <summary>
+        /// The <see cref="HitObject"/> that is being placed.
+        /// </summary>
+        protected readonly HitObject HitObject;
+
+        protected IClock EditorClock { get; private set; }
+
+        private readonly IBindable<WorkingBeatmap> beatmap = new Bindable<WorkingBeatmap>();
+
+        [Resolved]
+        private IPlacementHandler placementHandler { get; set; }
+
+        protected PlacementMask(HitObject hitObject)
+        {
+            HitObject = hitObject;
+
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(IBindableBeatmap beatmap, IAdjustableClock clock)
+        {
+            this.beatmap.BindTo(beatmap);
+
+            EditorClock = clock;
+
+            ApplyDefaultsToHitObject();
+        }
+
+        private bool placementBegun;
+
+        /// <summary>
+        /// Signals that the placement of <see cref="HitObject"/> has started.
+        /// </summary>
+        protected void BeginPlacement()
+        {
+            placementHandler.BeginPlacement(HitObject);
+            placementBegun = true;
+        }
+
+        /// <summary>
+        /// Signals that the placement of <see cref="HitObject"/> has finished.
+        /// This will destroy this <see cref="PlacementMask"/>, and add the <see cref="HitObject"/> to the <see cref="Beatmap"/>.
+        /// </summary>
+        protected void EndPlacement()
+        {
+            if (!placementBegun)
+                BeginPlacement();
+            placementHandler.EndPlacement(HitObject);
+        }
+
+        /// <summary>
+        /// Invokes <see cref="HitObject.ApplyDefaults"/>, refreshing <see cref="HitObject.NestedHitObjects"/> and parameters for the <see cref="HitObject"/>.
+        /// </summary>
+        protected void ApplyDefaultsToHitObject() => HitObject.ApplyDefaults(beatmap.Value.Beatmap.ControlPointInfo, beatmap.Value.Beatmap.BeatmapInfo.BaseDifficulty);
+
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => Parent?.ReceivePositionalInputAt(screenSpacePos) ?? false;
+
+        protected override bool Handle(UIEvent e)
+        {
+            base.Handle(e);
+
+            switch (e)
+            {
+                case ScrollEvent _:
+                    return false;
+                case MouseEvent _:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+    }
+}

osu.Game/Rulesets/Edit/SelectionMask.cs

@@ -3,6 +3,7 @@
 
 using System;
 using osu.Framework;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Input.Events;
@@ -16,31 +17,31 @@ namespace osu.Game.Rulesets.Edit
     /// <summary>
     /// A mask placed above a <see cref="DrawableHitObject"/> adding editing functionality.
     /// </summary>
-    public class HitObjectMask : CompositeDrawable, IStateful<SelectionState>
+    public class SelectionMask : CompositeDrawable, IStateful<SelectionState>
     {
         /// <summary>
-        /// Invoked when this <see cref="HitObjectMask"/> has been selected.
+        /// Invoked when this <see cref="SelectionMask"/> has been selected.
         /// </summary>
-        public event Action<HitObjectMask> Selected;
+        public event Action<SelectionMask> Selected;
 
         /// <summary>
-        /// Invoked when this <see cref="HitObjectMask"/> has been deselected.
+        /// Invoked when this <see cref="SelectionMask"/> has been deselected.
         /// </summary>
-        public event Action<HitObjectMask> Deselected;
+        public event Action<SelectionMask> Deselected;
 
         /// <summary>
-        /// Invoked when this <see cref="HitObjectMask"/> has requested selection.
+        /// Invoked when this <see cref="SelectionMask"/> has requested selection.
         /// Will fire even if already selected. Does not actually perform selection.
         /// </summary>
-        public event Action<HitObjectMask, InputState> SelectionRequested;
+        public event Action<SelectionMask, InputState> SelectionRequested;
 
         /// <summary>
-        /// Invoked when this <see cref="HitObjectMask"/> has requested drag.
+        /// Invoked when this <see cref="SelectionMask"/> has requested drag.
         /// </summary>
-        public event Action<HitObjectMask, Vector2, InputState> DragRequested;
+        public event Action<SelectionMask, Vector2, InputState> DragRequested;
 
         /// <summary>
-        /// The <see cref="DrawableHitObject"/> which this <see cref="HitObjectMask"/> applies to.
+        /// The <see cref="DrawableHitObject"/> which this <see cref="SelectionMask"/> applies to.
         /// </summary>
         public readonly DrawableHitObject HitObject;
 
@@ -48,10 +49,12 @@ namespace osu.Game.Rulesets.Edit
         public override bool HandlePositionalInput => ShouldBeAlive;
         public override bool RemoveWhenNotAlive => false;
 
-        public HitObjectMask(DrawableHitObject hitObject)
+        public SelectionMask(DrawableHitObject hitObject)
         {
             HitObject = hitObject;
 
+            RelativeSizeAxes = Axes.Both;
+
             AlwaysPresent = true;
             Alpha = 0;
         }
@@ -83,17 +86,19 @@ namespace osu.Game.Rulesets.Edit
         }
 
         /// <summary>
-        /// Selects this <see cref="HitObjectMask"/>, causing it to become visible.
+        /// Selects this <see cref="SelectionMask"/>, causing it to become visible.
         /// </summary>
         public void Select() => State = SelectionState.Selected;
 
         /// <summary>
-        /// Deselects this <see cref="HitObjectMask"/>, causing it to become invisible.
+        /// Deselects this <see cref="SelectionMask"/>, causing it to become invisible.
         /// </summary>
         public void Deselect() => State = SelectionState.NotSelected;
 
         public bool IsSelected => State == SelectionState.Selected;
 
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => HitObject.ReceivePositionalInputAt(screenSpacePos);
+
         private bool selectionRequested;
 
         protected override bool OnMouseDown(MouseDownEvent e)
@@ -130,13 +135,13 @@ namespace osu.Game.Rulesets.Edit
         }
 
         /// <summary>
-        /// The screen-space point that causes this <see cref="HitObjectMask"/> to be selected.
+        /// The screen-space point that causes this <see cref="SelectionMask"/> to be selected.
         /// </summary>
-        public virtual Vector2 SelectionPoint => ScreenSpaceDrawQuad.Centre;
+        public virtual Vector2 SelectionPoint => HitObject.ScreenSpaceDrawQuad.Centre;
 
         /// <summary>
-        /// The screen-space quad that outlines this <see cref="HitObjectMask"/> for selections.
+        /// The screen-space quad that outlines this <see cref="SelectionMask"/> for selections.
         /// </summary>
-        public virtual Quad SelectionQuad => ScreenSpaceDrawQuad;
+        public virtual Quad SelectionQuad => HitObject.ScreenSpaceDrawQuad;
     }
 }

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

@@ -1,23 +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.Objects;
-
 namespace osu.Game.Rulesets.Edit.Tools
 {
-    public class HitObjectCompositionTool<T> : ICompositionTool
+    public abstract class HitObjectCompositionTool
-        where T : HitObject
     {
-        public string Name { get; }
+        public readonly string Name;
 
-        public HitObjectCompositionTool()
+        protected HitObjectCompositionTool(string name)
-            : this(typeof(T).Name)
-        {
-        }
-
-        public HitObjectCompositionTool(string name)
         {
             Name = name;
         }
+
+        public abstract PlacementMask CreatePlacementMask();
     }
 }

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

@@ -1,10 +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
-
-namespace osu.Game.Rulesets.Edit.Tools
-{
-    public interface ICompositionTool
-    {
-        string Name { get; }
-    }
-}

osu.Game/Rulesets/Mods/IApplicableToBeatmap.cs

@@ -0,0 +1,22 @@
+// 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.Objects;
+
+namespace osu.Game.Rulesets.Mods
+{
+    /// <summary>
+    /// Interface for a <see cref="Mod"/> that applies changes to a <see cref="Beatmap"/>
+    /// after conversion and post-processing has completed.
+    /// </summary>
+    public interface IApplicableToBeatmap<TObject> : IApplicableMod
+        where TObject : HitObject
+    {
+        /// <summary>
+        /// Applies this <see cref="IApplicableToBeatmap{TObject}"/> to a <see cref="Beatmap{TObject}"/>.
+        /// </summary>
+        /// <param name="beatmap">The <see cref="Beatmap{TObject}"/> to apply to.</param>
+        void ApplyToBeatmap(Beatmap<TObject> beatmap);
+    }
+}

osu.Game/Rulesets/Objects/BezierApproximator.cs

@@ -1,151 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System;
-using System.Collections.Generic;
-using OpenTK;
-
-namespace osu.Game.Rulesets.Objects
-{
-    public readonly ref struct BezierApproximator
-    {
-        private readonly int count;
-        private readonly ReadOnlySpan<Vector2> controlPoints;
-        private readonly Vector2[] subdivisionBuffer1;
-        private readonly Vector2[] subdivisionBuffer2;
-
-        private const float tolerance = 0.25f;
-        private const float tolerance_sq = tolerance * tolerance;
-
-        public BezierApproximator(ReadOnlySpan<Vector2> controlPoints)
-        {
-            this.controlPoints = controlPoints;
-            count = controlPoints.Length;
-
-            subdivisionBuffer1 = new Vector2[count];
-            subdivisionBuffer2 = new Vector2[count * 2 - 1];
-        }
-
-        /// <summary>
-        /// Make sure the 2nd order derivative (approximated using finite elements) is within tolerable bounds.
-        /// NOTE: The 2nd order derivative of a 2d curve represents its curvature, so intuitively this function
-        ///       checks (as the name suggests) whether our approximation is _locally_ "flat". More curvy parts
-        ///       need to have a denser approximation to be more "flat".
-        /// </summary>
-        /// <param name="controlPoints">The control points to check for flatness.</param>
-        /// <returns>Whether the control points are flat enough.</returns>
-        private static bool isFlatEnough(Vector2[] controlPoints)
-        {
-            for (int i = 1; i < controlPoints.Length - 1; i++)
-                if ((controlPoints[i - 1] - 2 * controlPoints[i] + controlPoints[i + 1]).LengthSquared > tolerance_sq * 4)
-                    return false;
-
-            return true;
-        }
-
-        /// <summary>
-        /// Subdivides n control points representing a bezier curve into 2 sets of n control points, each
-        /// describing a bezier curve equivalent to a half of the original curve. Effectively this splits
-        /// the original curve into 2 curves which result in the original curve when pieced back together.
-        /// </summary>
-        /// <param name="controlPoints">The control points to split.</param>
-        /// <param name="l">Output: The control points corresponding to the left half of the curve.</param>
-        /// <param name="r">Output: The control points corresponding to the right half of the curve.</param>
-        private void subdivide(Vector2[] controlPoints, Vector2[] l, Vector2[] r)
-        {
-            Vector2[] midpoints = subdivisionBuffer1;
-
-            for (int i = 0; i < count; ++i)
-                midpoints[i] = controlPoints[i];
-
-            for (int i = 0; i < count; i++)
-            {
-                l[i] = midpoints[0];
-                r[count - i - 1] = midpoints[count - i - 1];
-
-                for (int j = 0; j < count - i - 1; j++)
-                    midpoints[j] = (midpoints[j] + midpoints[j + 1]) / 2;
-            }
-        }
-
-        /// <summary>
-        /// This uses <a href="https://en.wikipedia.org/wiki/De_Casteljau%27s_algorithm">De Casteljau's algorithm</a> to obtain an optimal
-        /// piecewise-linear approximation of the bezier curve with the same amount of points as there are control points.
-        /// </summary>
-        /// <param name="controlPoints">The control points describing the bezier curve to be approximated.</param>
-        /// <param name="output">The points representing the resulting piecewise-linear approximation.</param>
-        private void approximate(Vector2[] controlPoints, List<Vector2> output)
-        {
-            Vector2[] l = subdivisionBuffer2;
-            Vector2[] r = subdivisionBuffer1;
-
-            subdivide(controlPoints, l, r);
-
-            for (int i = 0; i < count - 1; ++i)
-                l[count + i] = r[i + 1];
-
-            output.Add(controlPoints[0]);
-            for (int i = 1; i < count - 1; ++i)
-            {
-                int index = 2 * i;
-                Vector2 p = 0.25f * (l[index - 1] + 2 * l[index] + l[index + 1]);
-                output.Add(p);
-            }
-        }
-
-        /// <summary>
-        /// Creates a piecewise-linear approximation of a bezier curve, by adaptively repeatedly subdividing
-        /// the control points until their approximation error vanishes below a given threshold.
-        /// </summary>
-        /// <returns>A list of vectors representing the piecewise-linear approximation.</returns>
-        public List<Vector2> CreateBezier()
-        {
-            List<Vector2> output = new List<Vector2>();
-
-            if (count == 0)
-                return output;
-
-            Stack<Vector2[]> toFlatten = new Stack<Vector2[]>();
-            Stack<Vector2[]> freeBuffers = new Stack<Vector2[]>();
-
-            // "toFlatten" contains all the curves which are not yet approximated well enough.
-            // We use a stack to emulate recursion without the risk of running into a stack overflow.
-            // (More specifically, we iteratively and adaptively refine our curve with a
-            // <a href="https://en.wikipedia.org/wiki/Depth-first_search">Depth-first search</a>
-            // over the tree resulting from the subdivisions we make.)
-            toFlatten.Push(controlPoints.ToArray());
-
-            Vector2[] leftChild = subdivisionBuffer2;
-
-            while (toFlatten.Count > 0)
-            {
-                Vector2[] parent = toFlatten.Pop();
-                if (isFlatEnough(parent))
-                {
-                    // If the control points we currently operate on are sufficiently "flat", we use
-                    // an extension to De Casteljau's algorithm to obtain a piecewise-linear approximation
-                    // of the bezier curve represented by our control points, consisting of the same amount
-                    // of points as there are control points.
-                    approximate(parent, output);
-                    freeBuffers.Push(parent);
-                    continue;
-                }
-
-                // If we do not yet have a sufficiently "flat" (in other words, detailed) approximation we keep
-                // subdividing the curve we are currently operating on.
-                Vector2[] rightChild = freeBuffers.Count > 0 ? freeBuffers.Pop() : new Vector2[count];
-                subdivide(parent, leftChild, rightChild);
-
-                // We re-use the buffer of the parent for one of the children, so that we save one allocation per iteration.
-                for (int i = 0; i < count; ++i)
-                    parent[i] = leftChild[i];
-
-                toFlatten.Push(rightChild);
-                toFlatten.Push(parent);
-            }
-
-            output.Add(controlPoints[count - 1]);
-            return output;
-        }
-    }
-}

osu.Game/Rulesets/Objects/CatmullApproximator.cs

@@ -1,70 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System;
-using System.Collections.Generic;
-using OpenTK;
-
-namespace osu.Game.Rulesets.Objects
-{
-    public readonly ref struct CatmullApproximator
-    {
-        /// <summary>
-        /// The amount of pieces to calculate for each controlpoint quadruplet.
-        /// </summary>
-        private const int detail = 50;
-
-        private readonly ReadOnlySpan<Vector2> controlPoints;
-
-        public CatmullApproximator(ReadOnlySpan<Vector2> controlPoints)
-        {
-            this.controlPoints = controlPoints;
-        }
-
-        /// <summary>
-        /// Creates a piecewise-linear approximation of a Catmull-Rom spline.
-        /// </summary>
-        /// <returns>A list of vectors representing the piecewise-linear approximation.</returns>
-        public List<Vector2> CreateCatmull()
-        {
-            var result = new List<Vector2>((controlPoints.Length - 1) * detail * 2);
-
-            for (int i = 0; i < controlPoints.Length - 1; i++)
-            {
-                var v1 = i > 0 ? controlPoints[i - 1] : controlPoints[i];
-                var v2 = controlPoints[i];
-                var v3 = i < controlPoints.Length - 1 ? controlPoints[i + 1] : v2 + v2 - v1;
-                var v4 = i < controlPoints.Length - 2 ? controlPoints[i + 2] : v3 + v3 - v2;
-
-                for (int c = 0; c < detail; c++)
-                {
-                    result.Add(findPoint(ref v1, ref v2, ref v3, ref v4, (float)c / detail));
-                    result.Add(findPoint(ref v1, ref v2, ref v3, ref v4, (float)(c + 1) / detail));
-                }
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Finds a point on the spline at the position of a parameter.
-        /// </summary>
-        /// <param name="vec1">The first vector.</param>
-        /// <param name="vec2">The second vector.</param>
-        /// <param name="vec3">The third vector.</param>
-        /// <param name="vec4">The fourth vector.</param>
-        /// <param name="t">The parameter at which to find the point on the spline, in the range [0, 1].</param>
-        /// <returns>The point on the spline at <paramref name="t"/>.</returns>
-        private Vector2 findPoint(ref Vector2 vec1, ref Vector2 vec2, ref Vector2 vec3, ref Vector2 vec4, float t)
-        {
-            float t2 = t * t;
-            float t3 = t * t2;
-
-            Vector2 result;
-            result.X = 0.5f * (2f * vec2.X + (-vec1.X + vec3.X) * t + (2f * vec1.X - 5f * vec2.X + 4f * vec3.X - vec4.X) * t2 + (-vec1.X + 3f * vec2.X - 3f * vec3.X + vec4.X) * t3);
-            result.Y = 0.5f * (2f * vec2.Y + (-vec1.Y + vec3.Y) * t + (2f * vec1.Y - 5f * vec2.Y + 4f * vec3.Y - vec4.Y) * t2 + (-vec1.Y + 3f * vec2.Y - 3f * vec3.Y + vec4.Y) * t3);
-
-            return result;
-        }
-    }
-}

osu.Game/Rulesets/Objects/CircularArcApproximator.cs

@@ -1,97 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System;
-using System.Collections.Generic;
-using osu.Framework.MathUtils;
-using OpenTK;
-
-namespace osu.Game.Rulesets.Objects
-{
-    public readonly ref struct CircularArcApproximator
-    {
-        private const float tolerance = 0.1f;
-
-        private readonly ReadOnlySpan<Vector2> controlPoints;
-
-        public CircularArcApproximator(ReadOnlySpan<Vector2> controlPoints)
-        {
-            this.controlPoints = controlPoints;
-        }
-
-        /// <summary>
-        /// Creates a piecewise-linear approximation of a circular arc curve.
-        /// </summary>
-        /// <returns>A list of vectors representing the piecewise-linear approximation.</returns>
-        public List<Vector2> CreateArc()
-        {
-            Vector2 a = controlPoints[0];
-            Vector2 b = controlPoints[1];
-            Vector2 c = controlPoints[2];
-
-            float aSq = (b - c).LengthSquared;
-            float bSq = (a - c).LengthSquared;
-            float cSq = (a - b).LengthSquared;
-
-            // If we have a degenerate triangle where a side-length is almost zero, then give up and fall
-            // back to a more numerically stable method.
-            if (Precision.AlmostEquals(aSq, 0) || Precision.AlmostEquals(bSq, 0) || Precision.AlmostEquals(cSq, 0))
-                return new List<Vector2>();
-
-            float s = aSq * (bSq + cSq - aSq);
-            float t = bSq * (aSq + cSq - bSq);
-            float u = cSq * (aSq + bSq - cSq);
-
-            float sum = s + t + u;
-
-            // If we have a degenerate triangle with an almost-zero size, then give up and fall
-            // back to a more numerically stable method.
-            if (Precision.AlmostEquals(sum, 0))
-                return new List<Vector2>();
-
-            Vector2 centre = (s * a + t * b + u * c) / sum;
-            Vector2 dA = a - centre;
-            Vector2 dC = c - centre;
-
-            float r = dA.Length;
-
-            double thetaStart = Math.Atan2(dA.Y, dA.X);
-            double thetaEnd = Math.Atan2(dC.Y, dC.X);
-
-            while (thetaEnd < thetaStart)
-                thetaEnd += 2 * Math.PI;
-
-            double dir = 1;
-            double thetaRange = thetaEnd - thetaStart;
-
-            // Decide in which direction to draw the circle, depending on which side of
-            // AC B lies.
-            Vector2 orthoAtoC = c - a;
-            orthoAtoC = new Vector2(orthoAtoC.Y, -orthoAtoC.X);
-            if (Vector2.Dot(orthoAtoC, b - a) < 0)
-            {
-                dir = -dir;
-                thetaRange = 2 * Math.PI - thetaRange;
-            }
-
-            // We select the amount of points for the approximation by requiring the discrete curvature
-            // to be smaller than the provided tolerance. The exact angle required to meet the tolerance
-            // is: 2 * Math.Acos(1 - TOLERANCE / r)
-            // The special case is required for extremely short sliders where the radius is smaller than
-            // the tolerance. This is a pathological rather than a realistic case.
-            int amountPoints = 2 * r <= tolerance ? 2 : Math.Max(2, (int)Math.Ceiling(thetaRange / (2 * Math.Acos(1 - tolerance / r))));
-
-            List<Vector2> output = new List<Vector2>(amountPoints);
-
-            for (int i = 0; i < amountPoints; ++i)
-            {
-                double fract = (double)i / (amountPoints - 1);
-                double theta = thetaStart + dir * fract * thetaRange;
-                Vector2 o = new Vector2((float)Math.Cos(theta), (float)Math.Sin(theta)) * r;
-                output.Add(centre + o);
-            }
-
-            return output;
-        }
-    }
-}

osu.Game/Rulesets/Objects/Legacy/Catch/ConvertHitObjectParser.cs

@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Catch
             };
         }
 
-        protected override HitObject CreateSlider(Vector2 position, bool newCombo, int comboOffset, Vector2[] controlPoints, double length, CurveType curveType, int repeatCount, List<List<SampleInfo>> repeatSamples)
+        protected override HitObject CreateSlider(Vector2 position, bool newCombo, int comboOffset, Vector2[] controlPoints, double length, PathType pathType, int repeatCount, List<List<SampleInfo>> repeatSamples)
         {
             newCombo |= forceNewCombo;
             comboOffset += extraComboOffset;
@@ -52,7 +52,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Catch
                 ComboOffset = comboOffset,
                 ControlPoints = controlPoints,
                 Distance = length,
-                CurveType = curveType,
+                PathType = pathType,
                 RepeatSamples = repeatSamples,
                 RepeatCount = repeatCount
             };

osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectParser.cs

@@ -70,7 +70,7 @@ namespace osu.Game.Rulesets.Objects.Legacy
                 }
                 else if (type.HasFlag(ConvertHitObjectType.Slider))
                 {
-                    CurveType curveType = CurveType.Catmull;
+                    PathType pathType = PathType.Catmull;
                     double length = 0;
 
                     string[] pointSplit = split[5].Split('|');
@@ -90,16 +90,16 @@ namespace osu.Game.Rulesets.Objects.Legacy
                             switch (t)
                             {
                                 case @"C":
-                                    curveType = CurveType.Catmull;
+                                    pathType = PathType.Catmull;
                                     break;
                                 case @"B":
-                                    curveType = CurveType.Bezier;
+                                    pathType = PathType.Bezier;
                                     break;
                                 case @"L":
-                                    curveType = CurveType.Linear;
+                                    pathType = PathType.Linear;
                                     break;
                                 case @"P":
-                                    curveType = CurveType.PerfectCurve;
+                                    pathType = PathType.PerfectCurve;
                                     break;
                             }
 
@@ -113,8 +113,8 @@ namespace osu.Game.Rulesets.Objects.Legacy
                     // osu-stable special-cased colinear perfect curves to a CurveType.Linear
                     bool isLinear(Vector2[] p) => Precision.AlmostEquals(0, (p[1].Y - p[0].Y) * (p[2].X - p[0].X) - (p[1].X - p[0].X) * (p[2].Y - p[0].Y));
 
-                    if (points.Length == 3 && curveType == CurveType.PerfectCurve && isLinear(points))
+                    if (points.Length == 3 && pathType == PathType.PerfectCurve && isLinear(points))
-                        curveType = CurveType.Linear;
+                        pathType = PathType.Linear;
 
                     int repeatCount = Convert.ToInt32(split[6], CultureInfo.InvariantCulture);
 
@@ -178,7 +178,7 @@ namespace osu.Game.Rulesets.Objects.Legacy
                     for (int i = 0; i < nodes; i++)
                         nodeSamples.Add(convertSoundType(nodeSoundTypes[i], nodeBankInfos[i]));
 
-                    result = CreateSlider(pos, combo, comboOffset, points, length, curveType, repeatCount, nodeSamples);
+                    result = CreateSlider(pos, combo, comboOffset, points, length, pathType, repeatCount, nodeSamples);
                 }
                 else if (type.HasFlag(ConvertHitObjectType.Spinner))
                 {
@@ -268,11 +268,11 @@ namespace osu.Game.Rulesets.Objects.Legacy
         /// <param name="comboOffset">When starting a new combo, the offset of the new combo relative to the current one.</param>
         /// <param name="controlPoints">The slider control points.</param>
         /// <param name="length">The slider length.</param>
-        /// <param name="curveType">The slider curve type.</param>
+        /// <param name="pathType">The slider curve type.</param>
         /// <param name="repeatCount">The slider repeat count.</param>
         /// <param name="repeatSamples">The samples to be played when the repeat nodes are hit. This includes the head and tail of the slider.</param>
         /// <returns>The hit object.</returns>
-        protected abstract HitObject CreateSlider(Vector2 position, bool newCombo, int comboOffset, Vector2[] controlPoints, double length, CurveType curveType, int repeatCount, List<List<SampleInfo>> repeatSamples);
+        protected abstract HitObject CreateSlider(Vector2 position, bool newCombo, int comboOffset, Vector2[] controlPoints, double length, PathType pathType, int repeatCount, List<List<SampleInfo>> repeatSamples);
 
         /// <summary>
         /// Creates a legacy Spinner-type hit object.

osu.Game/Rulesets/Objects/Legacy/ConvertSlider.cs

@@ -20,9 +20,9 @@ namespace osu.Game.Rulesets.Objects.Legacy
         /// <summary>
         /// <see cref="ConvertSlider"/>s don't need a curve since they're converted to ruleset-specific hitobjects.
         /// </summary>
-        public SliderCurve Curve { get; } = null;
+        public SliderPath Path { get; } = null;
         public Vector2[] ControlPoints { get; set; }
-        public CurveType CurveType { get; set; }
+        public PathType PathType { get; set; }
 
         public double Distance { get; set; }
 

osu.Game/Rulesets/Objects/Legacy/Mania/ConvertHitObjectParser.cs

@@ -26,14 +26,14 @@ namespace osu.Game.Rulesets.Objects.Legacy.Mania
             };
         }
 
-        protected override HitObject CreateSlider(Vector2 position, bool newCombo, int comboOffset, Vector2[] controlPoints, double length, CurveType curveType, int repeatCount, List<List<SampleInfo>> repeatSamples)
+        protected override HitObject CreateSlider(Vector2 position, bool newCombo, int comboOffset, Vector2[] controlPoints, double length, PathType pathType, int repeatCount, List<List<SampleInfo>> repeatSamples)
         {
             return new ConvertSlider
             {
                 X = position.X,
                 ControlPoints = controlPoints,
                 Distance = length,
-                CurveType = curveType,
+                PathType = pathType,
                 RepeatSamples = repeatSamples,
                 RepeatCount = repeatCount
             };

osu.Game/Rulesets/Objects/Legacy/Osu/ConvertHitObjectParser.cs

@@ -38,7 +38,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Osu
             };
         }
 
-        protected override HitObject CreateSlider(Vector2 position, bool newCombo, int comboOffset, Vector2[] controlPoints, double length, CurveType curveType, int repeatCount, List<List<SampleInfo>> repeatSamples)
+        protected override HitObject CreateSlider(Vector2 position, bool newCombo, int comboOffset, Vector2[] controlPoints, double length, PathType pathType, int repeatCount, List<List<SampleInfo>> repeatSamples)
         {
             newCombo |= forceNewCombo;
             comboOffset += extraComboOffset;
@@ -53,7 +53,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Osu
                 ComboOffset = comboOffset,
                 ControlPoints = controlPoints,
                 Distance = Math.Max(0, length),
-                CurveType = curveType,
+                PathType = pathType,
                 RepeatSamples = repeatSamples,
                 RepeatCount = repeatCount
             };

osu.Game/Rulesets/Objects/Legacy/Taiko/ConvertHitObjectParser.cs

@@ -23,13 +23,13 @@ namespace osu.Game.Rulesets.Objects.Legacy.Taiko
             return new ConvertHit();
         }
 
-        protected override HitObject CreateSlider(Vector2 position, bool newCombo, int comboOffset, Vector2[] controlPoints, double length, CurveType curveType, int repeatCount, List<List<SampleInfo>> repeatSamples)
+        protected override HitObject CreateSlider(Vector2 position, bool newCombo, int comboOffset, Vector2[] controlPoints, double length, PathType pathType, int repeatCount, List<List<SampleInfo>> repeatSamples)
         {
             return new ConvertSlider
             {
                 ControlPoints = controlPoints,
                 Distance = length,
-                CurveType = curveType,
+                PathType = pathType,
                 RepeatSamples = repeatSamples,
                 RepeatCount = repeatCount
             };

osu.Game/Rulesets/Objects/SliderPath.cs

@@ -10,13 +10,13 @@ using OpenTK;
 
 namespace osu.Game.Rulesets.Objects
 {
-    public class SliderCurve
+    public class SliderPath
     {
         public double Distance;
 
-        public Vector2[] ControlPoints;
+        public Vector2[] ControlPoints = Array.Empty<Vector2>();
 
-        public CurveType CurveType = CurveType.PerfectCurve;
+        public PathType PathType = PathType.PerfectCurve;
 
         public Vector2 Offset;
 
@@ -25,32 +25,28 @@ namespace osu.Game.Rulesets.Objects
 
         private List<Vector2> calculateSubpath(ReadOnlySpan<Vector2> subControlPoints)
         {
-            switch (CurveType)
+            switch (PathType)
             {
-                case CurveType.Linear:
+                case PathType.Linear:
-                    var result = new List<Vector2>(subControlPoints.Length);
+                    return PathApproximator.ApproximateLinear(subControlPoints);
-                    foreach (var c in subControlPoints)
+                case PathType.PerfectCurve:
-                        result.Add(c);
-
-                    return result;
-                case CurveType.PerfectCurve:
                     //we can only use CircularArc iff we have exactly three control points and no dissection.
                     if (ControlPoints.Length != 3 || subControlPoints.Length != 3)
                         break;
 
                     // Here we have exactly 3 control points. Attempt to fit a circular arc.
-                    List<Vector2> subpath = new CircularArcApproximator(subControlPoints).CreateArc();
+                    List<Vector2> subpath = PathApproximator.ApproximateCircularArc(subControlPoints);
 
                     // If for some reason a circular arc could not be fit to the 3 given points, fall back to a numerically stable bezier approximation.
                     if (subpath.Count == 0)
                         break;
 
                     return subpath;
-                case CurveType.Catmull:
+                case PathType.Catmull:
-                    return new CatmullApproximator(subControlPoints).CreateCatmull();
+                    return PathApproximator.ApproximateCatmull(subControlPoints);
             }
 
-            return new BezierApproximator(subControlPoints).CreateBezier();
+            return PathApproximator.ApproximateBezier(subControlPoints);
         }
 
         private void calculatePath()
@@ -93,7 +89,7 @@ namespace osu.Game.Rulesets.Objects
                 Vector2 diff = calculatedPath[i + 1] - calculatedPath[i];
                 double d = diff.Length;
 
-                // Shorten slider curves that are too long compared to what's
+                // Shorten slider paths that are too long compared to what's
                 // in the .osu file.
                 if (Distance - l < d)
                 {
@@ -109,7 +105,7 @@ namespace osu.Game.Rulesets.Objects
                 cumulativeLength.Add(l);
             }
 
-            // Lengthen slider curves that are too short compared to what's
+            // Lengthen slider paths that are too short compared to what's
             // in the .osu file.
             if (l < Distance && calculatedPath.Count > 1)
             {
@@ -124,10 +120,33 @@ namespace osu.Game.Rulesets.Objects
             }
         }
 
-        public void Calculate()
+        private void calculateCumulativeLength()
+        {
+            double l = 0;
+
+            cumulativeLength.Clear();
+            cumulativeLength.Add(l);
+
+            for (int i = 0; i < calculatedPath.Count - 1; ++i)
+            {
+                Vector2 diff = calculatedPath[i + 1] - calculatedPath[i];
+                double d = diff.Length;
+
+                l += d;
+                cumulativeLength.Add(l);
+            }
+
+            Distance = l;
+        }
+
+        public void Calculate(bool updateDistance = false)
         {
             calculatePath();
+
+            if (!updateDistance)
                 calculateCumulativeLengthAndTrimPath();
+            else
+                calculateCumulativeLength();
         }
 
         private int indexOfDistance(double d)
@@ -168,10 +187,10 @@ namespace osu.Game.Rulesets.Objects
         }
 
         /// <summary>
-        /// Computes the slider curve until a given progress that ranges from 0 (beginning of the slider)
+        /// Computes the slider path until a given progress that ranges from 0 (beginning of the slider)
         /// to 1 (end of the slider) and stores the generated path in the given list.
         /// </summary>
-        /// <param name="path">The list to be filled with the computed curve.</param>
+        /// <param name="path">The list to be filled with the computed path.</param>
         /// <param name="p0">Start progress. Ranges from 0 (beginning of the slider) to 1 (end of the slider).</param>
         /// <param name="p1">End progress. Ranges from 0 (beginning of the slider) to 1 (end of the slider).</param>
         public void GetPathToProgress(List<Vector2> path, double p0, double p1)
@@ -196,10 +215,10 @@ namespace osu.Game.Rulesets.Objects
         }
 
         /// <summary>
-        /// Computes the position on the slider at a given progress that ranges from 0 (beginning of the curve)
+        /// Computes the position on the slider at a given progress that ranges from 0 (beginning of the path)
-        /// to 1 (end of the curve).
+        /// to 1 (end of the path).
         /// </summary>
-        /// <param name="progress">Ranges from 0 (beginning of the curve) to 1 (end of the curve).</param>
+        /// <param name="progress">Ranges from 0 (beginning of the path) to 1 (end of the path).</param>
         /// <returns></returns>
         public Vector2 PositionAt(double progress)
         {

osu.Game/Rulesets/Objects/Types/IHasCurve.cs

@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Objects.Types
         /// <summary>
         /// The curve.
         /// </summary>
-        SliderCurve Curve { get; }
+        SliderPath Path { get; }
 
         /// <summary>
         /// The control points that shape the curve.
@@ -23,7 +23,7 @@ namespace osu.Game.Rulesets.Objects.Types
         /// <summary>
         /// The type of curve.
         /// </summary>
-        CurveType CurveType { get; }
+        PathType PathType { get; }
     }
 
     public static class HasCurveExtensions
@@ -35,7 +35,7 @@ namespace osu.Game.Rulesets.Objects.Types
         /// <param name="progress">[0, 1] where 0 is the start time of the <see cref="HitObject"/> and 1 is the end time of the <see cref="HitObject"/>.</param>
         /// <returns>The position on the curve.</returns>
         public static Vector2 CurvePositionAt(this IHasCurve obj, double progress)
-            => obj.Curve.PositionAt(obj.ProgressAt(progress));
+            => obj.Path.PositionAt(obj.ProgressAt(progress));
 
         /// <summary>
         /// Computes the progress along the curve relative to how much of the <see cref="HitObject"/> has been completed.

osu.Game/Rulesets/Objects/Types/PathType.cs

@@ -3,7 +3,7 @@
 
 namespace osu.Game.Rulesets.Objects.Types
 {
-    public enum CurveType
+    public enum PathType
     {
         Catmull,
         Bezier,

osu.Game/Rulesets/UI/RulesetContainer.cs

@@ -73,7 +73,7 @@ namespace osu.Game.Rulesets.UI
         /// </summary>
         public readonly CursorContainer Cursor;
 
-        protected readonly Ruleset Ruleset;
+        public readonly Ruleset Ruleset;
 
         protected IRulesetConfigManager Config { get; private set; }
 
@@ -238,6 +238,8 @@ namespace osu.Game.Rulesets.UI
 
             KeyBindingInputManager = CreateInputManager();
             KeyBindingInputManager.RelativeSizeAxes = Axes.Both;
+
+            applyBeatmapMods(Mods);
         }
 
         [BackgroundDependencyLoader]
@@ -255,16 +257,29 @@ namespace osu.Game.Rulesets.UI
                 KeyBindingInputManager.Add(Cursor);
 
             // Apply mods
-            applyMods(Mods, config);
+            applyRulesetMods(Mods, config);
 
             loadObjects();
         }
 
+        /// <summary>
+        /// Applies the active mods to the Beatmap.
+        /// </summary>
+        /// <param name="mods"></param>
+        private void applyBeatmapMods(IEnumerable<Mod> mods)
+        {
+            if (mods == null)
+                return;
+
+            foreach (var mod in mods.OfType<IApplicableToBeatmap<TObject>>())
+                mod.ApplyToBeatmap(Beatmap);
+        }
+
         /// <summary>
         /// Applies the active mods to this RulesetContainer.
         /// </summary>
         /// <param name="mods"></param>
-        private void applyMods(IEnumerable<Mod> mods, OsuConfigManager config)
+        private void applyRulesetMods(IEnumerable<Mod> mods, OsuConfigManager config)
         {
             if (mods == null)
                 return;
@@ -290,17 +305,7 @@ namespace osu.Game.Rulesets.UI
         private void loadObjects()
         {
             foreach (TObject h in Beatmap.HitObjects)
-            {
+                AddRepresentation(h);
-                var drawableObject = GetVisualRepresentation(h);
-
-                if (drawableObject == null)
-                    continue;
-
-                drawableObject.OnNewResult += (_, r) => OnNewResult?.Invoke(r);
-                drawableObject.OnRevertResult += (_, r) => OnRevertResult?.Invoke(r);
-
-                Playfield.Add(drawableObject);
-            }
 
             Playfield.PostProcess();
 
@@ -308,12 +313,30 @@ namespace osu.Game.Rulesets.UI
                 mod.ApplyToDrawableHitObjects(Playfield.HitObjectContainer.Objects);
         }
 
+        /// <summary>
+        /// Creates and adds the visual representation of a <see cref="TObject"/> to this <see cref="RulesetContainer{TObject}"/>.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="TObject"/> to add the visual representation for.</param>
+        internal void AddRepresentation(TObject hitObject)
+        {
+            var drawableObject = GetVisualRepresentation(hitObject);
+
+            if (drawableObject == null)
+                return;
+
+            drawableObject.OnNewResult += (_, r) => OnNewResult?.Invoke(r);
+            drawableObject.OnRevertResult += (_, r) => OnRevertResult?.Invoke(r);
+
+            Playfield.Add(drawableObject);
+        }
+
+
         /// <summary>
         /// Creates a DrawableHitObject from a HitObject.
         /// </summary>
         /// <param name="h">The HitObject to make drawable.</param>
         /// <returns>The DrawableHitObject.</returns>
-        protected abstract DrawableHitObject<TObject> GetVisualRepresentation(TObject h);
+        public abstract DrawableHitObject<TObject> GetVisualRepresentation(TObject h);
     }
 
     /// <summary>

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

@@ -9,18 +9,21 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Logging;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Screens.Edit.Screens.Compose.Timeline;
 
 namespace osu.Game.Screens.Edit.Screens.Compose
 {
-    public class Compose : EditorScreen
+    [Cached(Type = typeof(IPlacementHandler))]
+    public class Compose : EditorScreen, IPlacementHandler
     {
         private const float vertical_margins = 10;
         private const float horizontal_margins = 20;
 
         private readonly BindableBeatDivisor beatDivisor = new BindableBeatDivisor();
 
-        private Container composerContainer;
+        private HitObjectComposer composer;
 
         [BackgroundDependencyLoader(true)]
         private void load([CanBeNull] BindableBeatDivisor beatDivisor)
@@ -28,6 +31,8 @@ namespace osu.Game.Screens.Edit.Screens.Compose
             if (beatDivisor != null)
                 this.beatDivisor.BindTo(beatDivisor);
 
+            Container composerContainer;
+
             Children = new Drawable[]
             {
                 new GridContainer
@@ -101,7 +106,7 @@ namespace osu.Game.Screens.Edit.Screens.Compose
                 return;
             }
 
-            var composer = ruleset.CreateHitObjectComposer();
+            composer = ruleset.CreateHitObjectComposer();
             if (composer == null)
             {
                 Logger.Log($"Ruleset {ruleset.Description} doesn't support hitobject composition.");
@@ -111,5 +116,13 @@ namespace osu.Game.Screens.Edit.Screens.Compose
 
             composerContainer.Child = composer;
         }
+
+        public void BeginPlacement(HitObject hitObject)
+        {
+        }
+
+        public void EndPlacement(HitObject hitObject) => composer.Add(hitObject);
+
+        public void Delete(HitObject hitObject) => composer.Remove(hitObject);
     }
 }

osu.Game/Screens/Edit/Screens/Compose/IPlacementHandler.cs

@@ -0,0 +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.Game.Rulesets.Objects;
+
+namespace osu.Game.Screens.Edit.Screens.Compose
+{
+    public interface IPlacementHandler
+    {
+        /// <summary>
+        /// Notifies that a placement has begun.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> being placed.</param>
+        void BeginPlacement(HitObject hitObject);
+
+        /// <summary>
+        /// Notifies that a placement has finished.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> that has been placed.</param>
+        void EndPlacement(HitObject hitObject);
+
+        /// <summary>
+        /// Deletes a <see cref="HitObject"/>.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> to delete.</param>
+        void Delete(HitObject hitObject);
+    }
+}

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

@@ -14,7 +14,7 @@ using OpenTK.Graphics;
 namespace osu.Game.Screens.Edit.Screens.Compose.Layers
 {
     /// <summary>
-    /// A layer that handles and displays drag selection for a collection of <see cref="HitObjectMask"/>s.
+    /// A layer that handles and displays drag selection for a collection of <see cref="SelectionMask"/>s.
     /// </summary>
     public class DragLayer : CompositeDrawable
     {
@@ -30,7 +30,7 @@ namespace osu.Game.Screens.Edit.Screens.Compose.Layers
         /// <summary>
         /// Creates a new <see cref="DragLayer"/>.
         /// </summary>
-        /// <param name="maskContainer">The selectable <see cref="HitObjectMask"/>s.</param>
+        /// <param name="maskContainer">The selectable <see cref="SelectionMask"/>s.</param>
         public DragLayer(Action<RectangleF> performSelection)
         {
             this.performSelection = performSelection;

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

@@ -1,6 +1,7 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -13,7 +14,9 @@ namespace osu.Game.Screens.Edit.Screens.Compose.Layers
     public class HitObjectMaskLayer : CompositeDrawable
     {
         private MaskContainer maskContainer;
-        private HitObjectComposer composer;
+
+        [Resolved]
+        private HitObjectComposer composer { get; set; }
 
         public HitObjectMaskLayer()
         {
@@ -21,10 +24,8 @@ namespace osu.Game.Screens.Edit.Screens.Compose.Layers
         }
 
         [BackgroundDependencyLoader]
-        private void load(HitObjectComposer composer)
+        private void load()
         {
-            this.composer = composer;
-
             maskContainer = new MaskContainer();
 
             var maskSelection = composer.CreateMaskSelection();
@@ -48,10 +49,10 @@ namespace osu.Game.Screens.Edit.Screens.Compose.Layers
             };
 
             foreach (var obj in composer.HitObjects)
-                addMask(obj);
+                AddMaskFor(obj);
         }
 
-        protected override bool OnMouseDown(MouseDownEvent e)
+        protected override bool OnClick(ClickEvent e)
         {
             maskContainer.DeselectAll();
             return true;
@@ -61,7 +62,7 @@ namespace osu.Game.Screens.Edit.Screens.Compose.Layers
         /// Adds a mask for a <see cref="DrawableHitObject"/> which adds movement support.
         /// </summary>
         /// <param name="hitObject">The <see cref="DrawableHitObject"/> to create a mask for.</param>
-        private void addMask(DrawableHitObject hitObject)
+        public void AddMaskFor(DrawableHitObject hitObject)
         {
             var mask = composer.CreateMaskFor(hitObject);
             if (mask == null)
@@ -69,5 +70,19 @@ namespace osu.Game.Screens.Edit.Screens.Compose.Layers
 
             maskContainer.Add(mask);
         }
+
+        /// <summary>
+        /// Removes a mask for a <see cref="DrawableHitObject"/>.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="DrawableHitObject"/> for which to remove the mask.</param>
+        public void RemoveMaskFor(DrawableHitObject hitObject)
+        {
+            var maskToRemove = maskContainer.Single(m => m.HitObject == hitObject);
+            if (maskToRemove == null)
+                return;
+
+            maskToRemove.Deselect();
+            maskContainer.Remove(maskToRemove);
+        }
     }
 }

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

@@ -13,36 +13,36 @@ using RectangleF = osu.Framework.Graphics.Primitives.RectangleF;
 
 namespace osu.Game.Screens.Edit.Screens.Compose.Layers
 {
-    public class MaskContainer : Container<HitObjectMask>
+    public class MaskContainer : Container<SelectionMask>
     {
         /// <summary>
-        /// Invoked when any <see cref="HitObjectMask"/> is selected.
+        /// Invoked when any <see cref="SelectionMask"/> is selected.
         /// </summary>
-        public event Action<HitObjectMask> MaskSelected;
+        public event Action<SelectionMask> MaskSelected;
 
         /// <summary>
-        /// Invoked when any <see cref="HitObjectMask"/> is deselected.
+        /// Invoked when any <see cref="SelectionMask"/> is deselected.
         /// </summary>
-        public event Action<HitObjectMask> MaskDeselected;
+        public event Action<SelectionMask> MaskDeselected;
 
         /// <summary>
-        /// Invoked when any <see cref="HitObjectMask"/> requests selection.
+        /// Invoked when any <see cref="SelectionMask"/> requests selection.
         /// </summary>
-        public event Action<HitObjectMask, InputState> MaskSelectionRequested;
+        public event Action<SelectionMask, InputState> MaskSelectionRequested;
 
         /// <summary>
-        /// Invoked when any <see cref="HitObjectMask"/> requests drag.
+        /// Invoked when any <see cref="SelectionMask"/> requests drag.
         /// </summary>
-        public event Action<HitObjectMask, Vector2, InputState> MaskDragRequested;
+        public event Action<SelectionMask, Vector2, InputState> MaskDragRequested;
 
-        private IEnumerable<HitObjectMask> aliveMasks => AliveInternalChildren.Cast<HitObjectMask>();
+        private IEnumerable<SelectionMask> aliveMasks => AliveInternalChildren.Cast<SelectionMask>();
 
         public MaskContainer()
         {
             RelativeSizeAxes = Axes.Both;
         }
 
-        public override void Add(HitObjectMask drawable)
+        public override void Add(SelectionMask drawable)
         {
             if (drawable == null) throw new ArgumentNullException(nameof(drawable));
 
@@ -54,7 +54,7 @@ namespace osu.Game.Screens.Edit.Screens.Compose.Layers
             drawable.DragRequested += onDragRequested;
         }
 
-        public override bool Remove(HitObjectMask drawable)
+        public override bool Remove(SelectionMask drawable)
         {
             if (drawable == null) throw new ArgumentNullException(nameof(drawable));
 
@@ -87,33 +87,33 @@ namespace osu.Game.Screens.Edit.Screens.Compose.Layers
         }
 
         /// <summary>
-        /// Deselects all selected <see cref="HitObjectMask"/>s.
+        /// Deselects all selected <see cref="SelectionMask"/>s.
         /// </summary>
         public void DeselectAll() => aliveMasks.ToList().ForEach(m => m.Deselect());
 
-        private void onMaskSelected(HitObjectMask mask)
+        private void onMaskSelected(SelectionMask mask)
         {
             MaskSelected?.Invoke(mask);
             ChangeChildDepth(mask, 1);
         }
 
-        private void onMaskDeselected(HitObjectMask mask)
+        private void onMaskDeselected(SelectionMask mask)
         {
             MaskDeselected?.Invoke(mask);
             ChangeChildDepth(mask, 0);
         }
 
-        private void onSelectionRequested(HitObjectMask mask, InputState state) => MaskSelectionRequested?.Invoke(mask, state);
+        private void onSelectionRequested(SelectionMask mask, InputState state) => MaskSelectionRequested?.Invoke(mask, state);
-        private void onDragRequested(HitObjectMask mask, Vector2 delta, InputState state) => MaskDragRequested?.Invoke(mask, delta, state);
+        private void onDragRequested(SelectionMask mask, Vector2 delta, InputState state) => MaskDragRequested?.Invoke(mask, delta, state);
 
         protected override int Compare(Drawable x, Drawable y)
         {
-            if (!(x is HitObjectMask xMask) || !(y is HitObjectMask yMask))
+            if (!(x is SelectionMask xMask) || !(y is SelectionMask yMask))
                 return base.Compare(x, y);
             return Compare(xMask, yMask);
         }
 
-        public int Compare(HitObjectMask x, HitObjectMask y)
+        public int Compare(SelectionMask x, SelectionMask y)
         {
             // dpeth is used to denote selected status (we always want selected masks to handle input first).
             int d = x.Depth.CompareTo(y.Depth);

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

@@ -3,32 +3,38 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Events;
 using osu.Framework.Input.States;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Types;
 using OpenTK;
+using OpenTK.Input;
 
 namespace osu.Game.Screens.Edit.Screens.Compose.Layers
 {
     /// <summary>
-    /// A box which surrounds <see cref="HitObjectMask"/>s and provides interactive handles, context menus etc.
+    /// A box which surrounds <see cref="SelectionMask"/>s and provides interactive handles, context menus etc.
     /// </summary>
     public class MaskSelection : CompositeDrawable
     {
         public const float BORDER_RADIUS = 2;
 
-        private readonly List<HitObjectMask> selectedMasks;
+        private readonly List<SelectionMask> selectedMasks;
 
         private Drawable outline;
 
+        [Resolved]
+        private IPlacementHandler placementHandler { get; set; }
+
         public MaskSelection()
         {
-            selectedMasks = new List<HitObjectMask>();
+            selectedMasks = new List<SelectionMask>();
 
             RelativeSizeAxes = Axes.Both;
             AlwaysPresent = true;
@@ -54,7 +60,7 @@ namespace osu.Game.Screens.Edit.Screens.Compose.Layers
 
         #region User Input Handling
 
-        public void HandleDrag(HitObjectMask m, Vector2 delta, InputState state)
+        public void HandleDrag(SelectionMask m, Vector2 delta, InputState state)
         {
             // Todo: Various forms of snapping
 
@@ -69,6 +75,22 @@ namespace osu.Game.Screens.Edit.Screens.Compose.Layers
             }
         }
 
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            if (e.Repeat)
+                return base.OnKeyDown(e);
+
+            switch (e.Key)
+            {
+                case Key.Delete:
+                    foreach (var h in selectedMasks.ToList())
+                        placementHandler.Delete(h.HitObject.HitObject);
+                    return true;
+            }
+
+            return base.OnKeyDown(e);
+        }
+
         #endregion
 
         #region Selection Handling
@@ -82,13 +104,13 @@ namespace osu.Game.Screens.Edit.Screens.Compose.Layers
         /// Handle a mask becoming selected.
         /// </summary>
         /// <param name="mask">The mask.</param>
-        public void HandleSelected(HitObjectMask mask) => selectedMasks.Add(mask);
+        public void HandleSelected(SelectionMask mask) => selectedMasks.Add(mask);
 
         /// <summary>
         /// Handle a mask becoming deselected.
         /// </summary>
         /// <param name="mask">The mask.</param>
-        public void HandleDeselected(HitObjectMask mask)
+        public void HandleDeselected(SelectionMask mask)
         {
             selectedMasks.Remove(mask);
 
@@ -101,7 +123,7 @@ namespace osu.Game.Screens.Edit.Screens.Compose.Layers
         /// Handle a mask requesting selection.
         /// </summary>
         /// <param name="mask">The mask.</param>
-        public void HandleSelectionRequested(HitObjectMask mask, InputState state)
+        public void HandleSelectionRequested(SelectionMask mask, InputState state)
         {
             if (state.Keyboard.ControlPressed)
             {

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

@@ -0,0 +1,50 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Edit.Tools;
+using Container = System.ComponentModel.Container;
+
+namespace osu.Game.Screens.Edit.Screens.Compose.Layers
+{
+    public class PlacementContainer : CompositeDrawable
+    {
+        private readonly Container maskContainer;
+
+        public PlacementContainer()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        private HitObjectCompositionTool currentTool;
+
+        /// <summary>
+        /// The current placement tool.
+        /// </summary>
+        public HitObjectCompositionTool CurrentTool
+        {
+            get => currentTool;
+            set
+            {
+                if (currentTool == value)
+                    return;
+                currentTool = value;
+
+                Refresh();
+            }
+        }
+
+        /// <summary>
+        /// Refreshes the current placement tool.
+        /// </summary>
+        public void Refresh()
+        {
+            ClearInternal();
+
+            var mask = CurrentTool?.CreatePlacementMask();
+            if (mask != null)
+                InternalChild = mask;
+        }
+    }
+}