Merge branch 'master' into hold-note-placement

osu-resources

@@ -1 +1 @@
-Subproject commit 651e598b016b43e31ab1c1b29d5b30c92361b8d9
+Subproject commit 694cb03f19c93106ed0f2593f3e506e835fb652a

osu.Desktop/OsuGameDesktop.cs

@@ -10,7 +10,7 @@ using osu.Desktop.Overlays;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Platform;
 using osu.Game;
-using OpenTK.Input;
+using osuTK.Input;
 using Microsoft.Win32;
 using osu.Desktop.Updater;
 using osu.Framework;

osu.Desktop/Overlays/VersionManager.cs

@@ -15,8 +15,8 @@ using osu.Game.Graphics.Sprites;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Utils;
-using OpenTK;
+using osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Desktop.Overlays
 {

osu.Desktop/Updater/SquirrelUpdateManager.cs

@@ -2,6 +2,8 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using System.IO;
+using System.Reflection;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
@@ -12,9 +14,10 @@ using osu.Game;
 using osu.Game.Graphics;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
-using OpenTK;
+using osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using Squirrel;
+using LogLevel = Splat.LogLevel;
 
 namespace osu.Desktop.Updater
 {
@@ -35,7 +38,10 @@ namespace osu.Desktop.Updater
             notificationOverlay = notification;
 
             if (game.IsDeployedBuild)
+            {
+                Splat.Locator.CurrentMutable.Register(() => new SquirrelLogger(), typeof(Splat.ILogger));
                 Schedule(() => Task.Run(() => checkForUpdateAsync()));
+            }
         }
 
         private async void checkForUpdateAsync(bool useDeltaPatching = true, UpdateProgressNotification notification = null)
@@ -159,5 +165,31 @@ namespace osu.Desktop.Updater
                 });
             }
         }
+
+        private class SquirrelLogger : Splat.ILogger, IDisposable
+        {
+            private readonly string path;
+            private readonly object locker = new object();
+            public LogLevel Level { get; set; } = LogLevel.Info;
+
+            public SquirrelLogger()
+            {
+                var file = Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), "SquirrelSetupUpdater.log");
+                if (File.Exists(file)) File.Delete(file);
+                path = file;
+            }
+
+            public void Write(string message, LogLevel logLevel)
+            {
+                if (logLevel < Level)
+                    return;
+
+                lock (locker) File.AppendAllText(path, message + "\r\n");
+            }
+
+            public void Dispose()
+            {
+            }
+        }
     }
 }

osu.Desktop/osu.Desktop.csproj

@@ -27,7 +27,7 @@
   </ItemGroup>
   <ItemGroup Label="Package References">
     <PackageReference Include="System.IO.Packaging" Version="4.5.0" />
-    <PackageReference Include="ppy.squirrel.windows" Version="1.9.0.2" />
+    <PackageReference Include="ppy.squirrel.windows" Version="1.9.0.3" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.1.4" />
   </ItemGroup>

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

@@ -9,7 +9,7 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Screens.Play;
 using osu.Game.Tests.Visual;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {

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

@@ -10,7 +10,7 @@ using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Catch.Objects.Drawable.Pieces;
 using osu.Game.Tests.Visual;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {

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

@@ -8,7 +8,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Objects.Types;
-using OpenTK;
+using osuTK;
 using osu.Game.Rulesets.Catch.MathUtils;
 
 namespace osu.Game.Rulesets.Catch.Beatmaps

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

@@ -4,7 +4,7 @@
 using System;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Difficulty
 {

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

@@ -1,12 +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.Graphics;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.UI;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Mods
 {
-    public class CatchModFlashlight : ModFlashlight
+    public class CatchModFlashlight : ModFlashlight<CatchHitObject>
     {
         public override double ScoreMultiplier => 1.12;
+
+        private const float default_flashlight_size = 350;
+
+        public override Flashlight CreateFlashlight() => new CatchFlashlight(playfield);
+
+        private CatchPlayfield playfield;
+
+        public override void ApplyToRulesetContainer(RulesetContainer<CatchHitObject> rulesetContainer)
+        {
+            playfield = (CatchPlayfield)rulesetContainer.Playfield;
+            base.ApplyToRulesetContainer(rulesetContainer);
+        }
+
+        private class CatchFlashlight : Flashlight
+        {
+            private readonly CatchPlayfield playfield;
+
+            public CatchFlashlight(CatchPlayfield playfield)
+            {
+                this.playfield = playfield;
+                FlashlightSize = new Vector2(0, getSizeFor(0));
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                var catcherArea = playfield.CatcherArea;
+
+                FlashlightPosition = catcherArea.ToSpaceOfOtherDrawable(catcherArea.MovableCatcher.DrawPosition, this);
+            }
+
+            private float getSizeFor(int combo)
+            {
+                if (combo > 200)
+                    return default_flashlight_size * 0.8f;
+                else if (combo > 100)
+                    return default_flashlight_size * 0.9f;
+                else
+                    return default_flashlight_size;
+            }
+
+            protected override void OnComboChange(int newCombo)
+            {
+                this.TransformTo(nameof(FlashlightSize), new Vector2(0, getSizeFor(newCombo)), FLASHLIGHT_FADE_DURATION);
+            }
+
+            protected override string FragmentShader => "CircularFlashlight";
+        }
     }
 }

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

@@ -2,8 +2,8 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
-using OpenTK;
+using osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;

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

@@ -4,8 +4,8 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Catch.Objects.Drawable.Pieces;
-using OpenTK;
+using osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {

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

@@ -9,8 +9,8 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Catch.Objects.Drawable.Pieces;
-using OpenTK;
+using osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {
@@ -40,7 +40,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
         private void load()
         {
             // todo: this should come from the skin.
-            AccentColour = colourForRrepesentation(HitObject.VisualRepresentation);
+            AccentColour = colourForRepresentation(HitObject.VisualRepresentation);
 
             InternalChildren = new[]
             {
@@ -275,7 +275,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
             border.Alpha = (float)MathHelper.Clamp((HitObject.StartTime - Time.Current) / 500, 0, 1);
         }
 
-        private Color4 colourForRrepesentation(FruitVisualRepresentation representation)
+        private Color4 colourForRepresentation(FruitVisualRepresentation representation)
         {
             switch (representation)
             {

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

@@ -1,7 +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 OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {

osu.Game.Rulesets.Catch/Objects/Drawable/Pieces/Pulp.cs

@@ -6,7 +6,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable.Pieces
 {

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

@@ -10,7 +10,7 @@ using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
@@ -18,7 +18,7 @@ namespace osu.Game.Rulesets.Catch.UI
     {
         public const float BASE_WIDTH = 512;
 
-        private readonly CatcherArea catcherArea;
+        internal readonly CatcherArea CatcherArea;
 
         public CatchPlayfield(BeatmapDifficulty difficulty, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> getVisualRepresentation)
         {
@@ -38,7 +38,7 @@ namespace osu.Game.Rulesets.Catch.UI
                     {
                         RelativeSizeAxes = Axes.Both,
                     },
-                    catcherArea = new CatcherArea(difficulty)
+                    CatcherArea = new CatcherArea(difficulty)
                     {
                         GetVisualRepresentation = getVisualRepresentation,
                         ExplodingFruitTarget = explodingFruitContainer,
@@ -50,7 +50,7 @@ namespace osu.Game.Rulesets.Catch.UI
             };
         }
 
-        public bool CheckIfWeCanCatch(CatchHitObject obj) => catcherArea.AttemptCatch(obj);
+        public bool CheckIfWeCanCatch(CatchHitObject obj) => CatcherArea.AttemptCatch(obj);
 
         public override void Add(DrawableHitObject h)
         {
@@ -63,6 +63,6 @@ namespace osu.Game.Rulesets.Catch.UI
         }
 
         private void onNewResult(DrawableHitObject judgedObject, JudgementResult result)
-            => catcherArea.OnResult((DrawableCatchHitObject)judgedObject, result);
+            => CatcherArea.OnResult((DrawableCatchHitObject)judgedObject, result);
     }
 }

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

@@ -18,8 +18,8 @@ using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
-using OpenTK;
+using osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
@@ -27,7 +27,7 @@ namespace osu.Game.Rulesets.Catch.UI
     {
         public const float CATCHER_SIZE = 100;
 
-        protected readonly Catcher MovableCatcher;
+        protected internal readonly Catcher MovableCatcher;
 
         public Func<CatchHitObject, DrawableHitObject<CatchHitObject>> GetVisualRepresentation;
 

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

@@ -3,7 +3,7 @@
 
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.UI
 {

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

@@ -11,8 +11,8 @@ using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
-using OpenTK;
+using osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {

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

@@ -0,0 +1,15 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Timing;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public abstract class ManiaSelectionBlueprintTestCase : SelectionBlueprintTestCase
+    {
+        [Cached(Type = typeof(IAdjustableClock))]
+        private readonly IAdjustableClock clock = new StopwatchClock();
+    }
+}

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

@@ -15,8 +15,8 @@ using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mania.UI.Components;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
-using OpenTK;
+using osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {

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

@@ -15,7 +15,7 @@ using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {
-    public class TestCaseHoldNoteSelectionBlueprint : SelectionBlueprintTestCase
+    public class TestCaseHoldNoteSelectionBlueprint : ManiaSelectionBlueprintTestCase
     {
         private readonly DrawableHoldNote drawableObject;
 

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

@@ -11,11 +11,11 @@ using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {
-    public class TestCaseNoteSelectionBlueprint : SelectionBlueprintTestCase
+    public class TestCaseNoteSelectionBlueprint : ManiaSelectionBlueprintTestCase
     {
         private readonly DrawableNote drawableObject;
 

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

@@ -20,8 +20,8 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
-using OpenTK;
+using osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {

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

@@ -15,7 +15,7 @@ using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {

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

@@ -12,7 +12,7 @@ using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Mania.Beatmaps.Patterns;
 using osu.Game.Rulesets.Mania.MathUtils;
 using osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy;
-using OpenTK;
+using osuTK;
 using osu.Game.Audio;
 
 namespace osu.Game.Rulesets.Mania.Beatmaps

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

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using OpenTK;
+using osuTK;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;

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

@@ -7,7 +7,7 @@ using JetBrains.Annotations;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.MathUtils;
 using osu.Game.Rulesets.Objects;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 {

osu.Game.Rulesets.Mania/Edit/Blueprints/HoldNotePlacementBlueprint.cs

@@ -7,7 +7,7 @@ using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Mania.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.UI;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {

osu.Game.Rulesets.Mania/Edit/Blueprints/HoldNoteSelectionBlueprint.cs

@@ -9,8 +9,8 @@ using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.UI.Scrolling;
-using OpenTK;
+using osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
@@ -49,7 +49,6 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             base.Update();
 
             Size = HitObject.DrawSize + new Vector2(0, HitObject.Tail.DrawHeight);
-            Position = Parent.ToLocalSpace(HitObject.ScreenSpaceDrawQuad.TopLeft);
 
             // This is a side-effect of not matching the hitobject's anchors/origins, which is kinda hard to do
             // When scrolling upwards our origin is already at the top of the head note (which is the intended location),

osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaPlacementBlueprint.cs

@@ -9,7 +9,7 @@ using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.UI.Scrolling;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
@@ -44,17 +44,13 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
         {
             Column column = ColumnAt(e.ScreenSpaceMousePosition);
 
-            if (column == null)
+            if (column == null) return false;
-                SnappedMousePosition = e.MousePosition;
-            else
-            {
-                SnappedWidth = column.DrawWidth;
 
-                // Snap to the column
+            SnappedWidth = column.DrawWidth;
-                var parentPos = Parent.ToLocalSpace(column.ToScreenSpace(new Vector2(column.DrawWidth / 2, 0)));
-                SnappedMousePosition = new Vector2(parentPos.X, e.MousePosition.Y);
-            }
 
+            // Snap to the column
+            var parentPos = Parent.ToLocalSpace(column.ToScreenSpace(new Vector2(column.DrawWidth / 2, 0)));
+            SnappedMousePosition = new Vector2(parentPos.X, e.MousePosition.Y);
             return true;
         }
 

osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaSelectionBlueprint.cs

@@ -1,23 +1,79 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Events;
+using osu.Framework.Timing;
 using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI.Scrolling;
+using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
     public class ManiaSelectionBlueprint : SelectionBlueprint
     {
+        protected new DrawableManiaHitObject HitObject => (DrawableManiaHitObject)base.HitObject;
+
+        protected IClock EditorClock { get; private set; }
+
+        [Resolved]
+        private IScrollingInfo scrollingInfo { get; set; }
+
         public ManiaSelectionBlueprint(DrawableHitObject hitObject)
             : base(hitObject)
         {
             RelativeSizeAxes = Axes.None;
         }
 
+        [BackgroundDependencyLoader]
+        private void load(IAdjustableClock clock)
+        {
+            EditorClock = clock;
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            Position = Parent.ToLocalSpace(HitObject.ToScreenSpace(Vector2.Zero));
+        }
+
         public override void AdjustPosition(DragEvent dragEvent)
         {
+            var objectParent = HitObject.Parent;
+
+            // Using the hitobject position is required since AdjustPosition can be invoked multiple times per frame
+            // without the position having been updated by the parenting ScrollingHitObjectContainer
+            HitObject.Y += dragEvent.Delta.Y;
+
+            float targetPosition;
+
+            // If we're scrolling downwards, a position of 0 is actually further away from the hit target
+            // so we need to flip the vertical coordinate in the hitobject container's space
+            if (scrollingInfo.Direction.Value == ScrollingDirection.Down)
+                targetPosition = -HitObject.Position.Y;
+            else
+                targetPosition = HitObject.Position.Y;
+
+            HitObject.HitObject.StartTime = scrollingInfo.Algorithm.TimeAt(targetPosition,
+                EditorClock.CurrentTime,
+                scrollingInfo.TimeRange.Value,
+                objectParent.DrawHeight);
+        }
+
+        public override void Show()
+        {
+            HitObject.AlwaysAlive = true;
+            base.Show();
+        }
+
+        public override void Hide()
+        {
+            HitObject.AlwaysAlive = false;
+            base.Hide();
         }
     }
 }

osu.Game.Rulesets.Mania/Edit/Blueprints/NoteSelectionBlueprint.cs

@@ -20,7 +20,6 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             base.Update();
 
             Size = HitObject.DrawSize;
-            Position = Parent.ToLocalSpace(HitObject.ScreenSpaceDrawQuad.TopLeft);
         }
     }
 }

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

@@ -2,7 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Game.Rulesets.Mania.UI;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Edit
 {

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

@@ -2,7 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Graphics;
-using OpenTK;
+using osuTK;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.UI;

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

@@ -12,33 +12,40 @@ using osu.Framework.Allocation;
 using osu.Game.Rulesets.Mania.Edit.Blueprints;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.UI;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
     [Cached(Type = typeof(IManiaHitObjectComposer))]
     public class ManiaHitObjectComposer : HitObjectComposer<ManiaHitObject>, IManiaHitObjectComposer
     {
+        protected new ManiaEditRulesetContainer RulesetContainer { get; private set; }
+
         public ManiaHitObjectComposer(Ruleset ruleset)
             : base(ruleset)
         {
         }
 
+        /// <summary>
+        /// Retrieves the column that intersects a screen-space position.
+        /// </summary>
+        /// <param name="screenSpacePosition">The screen-space position.</param>
+        /// <returns>The column which intersects with <paramref name="screenSpacePosition"/>.</returns>
+        public Column ColumnAt(Vector2 screenSpacePosition) => RulesetContainer.GetColumnByPosition(screenSpacePosition);
+
         private DependencyContainer dependencies;
 
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
             => dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
-        public Column ColumnAt(Vector2 screenSpacePosition) => ((ManiaPlayfield)RulesetContainer.Playfield).GetColumnByPosition(screenSpacePosition);
-
         protected override RulesetContainer<ManiaHitObject> CreateRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
         {
-            var rulesetContainer = new ManiaEditRulesetContainer(ruleset, beatmap);
+            RulesetContainer = new ManiaEditRulesetContainer(ruleset, beatmap);
 
             // This is the earliest we can cache the scrolling info to ourselves, before masks are added to the hierarchy and inject it
-            dependencies.CacheAs(rulesetContainer.ScrollingInfo);
+            dependencies.CacheAs(RulesetContainer.ScrollingInfo);
 
-            return rulesetContainer;
+            return RulesetContainer;
         }
 
         protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]

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

@@ -3,6 +3,7 @@
 
 using System;
 using osu.Game.Graphics;
+using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Mania.Mods
@@ -16,6 +17,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override string Description => @"Keys appear out of nowhere!";
         public override double ScoreMultiplier => 1;
         public override bool Ranked => true;
-        public override Type[] IncompatibleMods => new[] { typeof(ModFlashlight) };
+        public override Type[] IncompatibleMods => new[] { typeof(ModFlashlight<ManiaHitObject>) };
     }
 }

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

@@ -2,13 +2,60 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using osu.Framework.Caching;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;
+using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModFlashlight : ModFlashlight
+    public class ManiaModFlashlight : ModFlashlight<ManiaHitObject>
     {
         public override double ScoreMultiplier => 1;
         public override Type[] IncompatibleMods => new[] { typeof(ModHidden) };
+
+        private const float default_flashlight_size = 180;
+
+        public override Flashlight CreateFlashlight() => new ManiaFlashlight();
+
+        private class ManiaFlashlight : Flashlight
+        {
+            private readonly Cached flashlightProperties = new Cached();
+
+            public ManiaFlashlight()
+            {
+                FlashlightSize = new Vector2(0, default_flashlight_size);
+            }
+
+            public override bool Invalidate(Invalidation invalidation = Invalidation.All, Drawable source = null, bool shallPropagate = true)
+            {
+                if ((invalidation & Invalidation.DrawSize) > 0)
+                {
+                    flashlightProperties.Invalidate();
+                }
+
+                return base.Invalidate(invalidation, source, shallPropagate);
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                if (!flashlightProperties.IsValid)
+                {
+                    FlashlightSize = new Vector2(DrawWidth, FlashlightSize.Y);
+
+                    FlashlightPosition = DrawPosition + DrawSize / 2;
+                    flashlightProperties.Validate();
+                }
+            }
+
+            protected override void OnComboChange(int newCombo)
+            {
+            }
+
+            protected override string FragmentShader => "RectangularFlashlight";
+        }
     }
 }

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

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Mania.Mods
@@ -10,6 +11,6 @@ namespace osu.Game.Rulesets.Mania.Mods
     {
         public override string Description => @"Keys fade out before you hit them!";
         public override double ScoreMultiplier => 1;
-        public override Type[] IncompatibleMods => new[] { typeof(ModFlashlight) };
+        public override Type[] IncompatibleMods => new[] { typeof(ModFlashlight<ManiaHitObject>) };
     }
 }

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

@@ -1,11 +1,11 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK;
+using osuTK;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Rulesets.Objects.Drawables;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables
 {

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

@@ -5,7 +5,7 @@ using System.Linq;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Scoring;

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

@@ -2,8 +2,8 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
-using OpenTK;
+using osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;

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

@@ -12,6 +12,11 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 {
     public abstract class DrawableManiaHitObject : DrawableHitObject<ManiaHitObject>
     {
+        /// <summary>
+        /// Whether this <see cref="DrawableManiaHitObject"/> should always remain alive.
+        /// </summary>
+        internal bool AlwaysAlive;
+
         /// <summary>
         /// The <see cref="ManiaAction"/> which causes this <see cref="DrawableManiaHitObject{TObject}"/> to be hit.
         /// </summary>
@@ -34,6 +39,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             Direction.BindValueChanged(OnDirectionChanged, true);
         }
 
+        protected override bool ShouldBeAlive => AlwaysAlive || base.ShouldBeAlive;
+
         protected virtual void OnDirectionChanged(ScrollingDirection direction)
         {
             Anchor = Origin = direction == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre;

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

@@ -2,7 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Extensions.Color4Extensions;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/BodyPiece.cs

@@ -3,7 +3,7 @@
 
 using System;
 using osu.Framework.Caching;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/GlowPiece.cs

@@ -6,7 +6,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
 {

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/LaneGlowPiece.cs

@@ -1,7 +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 OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/NotePiece.cs

@@ -3,7 +3,7 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;

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

@@ -2,7 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Linq;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics;
@@ -13,7 +13,7 @@ using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.UI.Components;
 using osu.Game.Rulesets.UI.Scrolling;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
@@ -145,6 +145,13 @@ namespace osu.Game.Rulesets.Mania.UI
             HitObjectContainer.Add(hitObject);
         }
 
+        public override void Remove(DrawableHitObject h)
+        {
+            h.OnNewResult -= OnNewResult;
+
+            HitObjectContainer.Remove(h);
+        }
+
         internal void OnNewResult(DrawableHitObject judgedObject, JudgementResult result)
         {
             if (!result.IsHit || !judgedObject.DisplayResult || !DisplayJudgements)
@@ -176,6 +183,6 @@ namespace osu.Game.Rulesets.Mania.UI
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos)
             // This probably shouldn't exist as is, but the columns in the stage are separated by a 1px border
-            => DrawRectangle.Inflate(new Vector2(1, 0)).Contains(ToLocalSpace(screenSpacePos));
+            => DrawRectangle.Inflate(new Vector2(ManiaStage.COLUMN_SPACING / 2, 0)).Contains(ToLocalSpace(screenSpacePos));
     }
 }

osu.Game.Rulesets.Mania/UI/Components/ColumnBackground.cs

@@ -11,7 +11,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Bindings;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.UI.Scrolling;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.UI.Components
 {

osu.Game.Rulesets.Mania/UI/Components/ColumnHitObjectArea.cs

@@ -10,7 +10,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.UI.Components
 {

osu.Game.Rulesets.Mania/UI/Components/ColumnKeyArea.cs

@@ -11,8 +11,8 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Bindings;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.UI.Scrolling;
-using OpenTK;
+using osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.UI.Components
 {

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

@@ -1,7 +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 OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -9,7 +9,7 @@ using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.Objects.Drawables;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Mania.UI
 {

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

@@ -5,11 +5,12 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
@@ -17,6 +18,8 @@ namespace osu.Game.Rulesets.Mania.UI
     {
         private readonly List<ManiaStage> stages = new List<ManiaStage>();
 
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => stages.Any(s => s.ReceivePositionalInputAt(screenSpacePos));
+
         public ManiaPlayfield(List<StageDefinition> stageDefinitions)
         {
             if (stageDefinitions == null)
@@ -52,6 +55,8 @@ namespace osu.Game.Rulesets.Mania.UI
 
         public override void Add(DrawableHitObject h) => getStageByColumn(((ManiaHitObject)h.HitObject).Column).Add(h);
 
+        public override void Remove(DrawableHitObject h) => getStageByColumn(((ManiaHitObject)h.HitObject).Column).Remove(h);
+
         public void Add(BarLine barline) => stages.ForEach(s => s.Add(barline));
 
         /// <summary>

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

@@ -25,6 +25,7 @@ using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
+using osuTK;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
@@ -80,6 +81,13 @@ namespace osu.Game.Rulesets.Mania.UI
             Config.BindWith(ManiaSetting.ScrollTime, TimeRange);
         }
 
+        /// <summary>
+        /// Retrieves the column that intersects a screen-space position.
+        /// </summary>
+        /// <param name="screenSpacePosition">The screen-space position.</param>
+        /// <returns>The column which intersects with <paramref name="screenSpacePosition"/>.</returns>
+        public Column GetColumnByPosition(Vector2 screenSpacePosition) => Playfield.GetColumnByPosition(screenSpacePosition);
+
         protected override Playfield CreatePlayfield() => new ManiaPlayfield(Beatmap.Stages)
         {
             Anchor = Anchor.Centre,

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

@@ -15,8 +15,8 @@ using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
-using OpenTK;
+using osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
@@ -25,6 +25,8 @@ namespace osu.Game.Rulesets.Mania.UI
     /// </summary>
     public class ManiaStage : ScrollingPlayfield
     {
+        public const float COLUMN_SPACING = 1;
+
         public const float HIT_TARGET_POSITION = 50;
 
         public IReadOnlyList<Column> Columns => columnFlow.Children;
@@ -40,6 +42,8 @@ namespace osu.Game.Rulesets.Mania.UI
         private List<Color4> normalColumnColours = new List<Color4>();
         private Color4 specialColumnColour;
 
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => Columns.Any(c => c.ReceivePositionalInputAt(screenSpacePos));
+
         private readonly int firstColumnIndex;
 
         public ManiaStage(int firstColumnIndex, StageDefinition definition, ref ManiaAction normalColumnStartAction, ref ManiaAction specialColumnStartAction)
@@ -84,8 +88,8 @@ namespace osu.Game.Rulesets.Mania.UI
                                     RelativeSizeAxes = Axes.Y,
                                     AutoSizeAxes = Axes.X,
                                     Direction = FillDirection.Horizontal,
-                                    Padding = new MarginPadding { Left = 1, Right = 1 },
+                                    Padding = new MarginPadding { Left = COLUMN_SPACING, Right = COLUMN_SPACING },
-                                    Spacing = new Vector2(1, 0)
+                                    Spacing = new Vector2(COLUMN_SPACING, 0)
                                 },
                             }
                         },
@@ -157,6 +161,15 @@ namespace osu.Game.Rulesets.Mania.UI
             h.OnNewResult += OnNewResult;
         }
 
+        public override void Remove(DrawableHitObject h)
+        {
+            var maniaObject = (ManiaHitObject)h.HitObject;
+            int columnIndex = maniaObject.Column - firstColumnIndex;
+            Columns.ElementAt(columnIndex).Remove(h);
+
+            h.OnNewResult -= OnNewResult;
+        }
+
         public void Add(BarLine barline) => base.Add(new DrawableBarLine(barline));
 
         internal void OnNewResult(DrawableHitObject judgedObject, JudgementResult result)

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

@@ -8,7 +8,7 @@ using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
-using OpenTK;
+using osuTK;
 using System.Collections.Generic;
 using System;
 using osu.Game.Rulesets.Mods;

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

@@ -8,7 +8,7 @@ using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {

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

@@ -11,8 +11,8 @@ using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
-using OpenTK;
+using osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Game.Rulesets.Mods;
 using System.Linq;
 using NUnit.Framework;

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

@@ -13,7 +13,7 @@ using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {

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

@@ -13,7 +13,7 @@ using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {

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

@@ -1,7 +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 OpenTK;
+using osuTK;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;

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

@@ -4,7 +4,7 @@
 using System;
 using System.Linq;
 using osu.Game.Rulesets.Osu.Objects;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
 {

osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/Components/HitCirclePiece.cs

@@ -3,19 +3,19 @@
 
 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;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components
 {
-    public class HitCirclePiece : CompositeDrawable
+    public class HitCirclePiece : HitObjectPiece
     {
         private readonly HitCircle hitCircle;
 
         public HitCirclePiece(HitCircle hitCircle)
+            : base(hitCircle)
         {
             this.hitCircle = hitCircle;
             Origin = Anchor.Centre;
@@ -25,10 +25,6 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components
             CornerRadius = Size.X / 2;
 
             InternalChild = new RingPiece();
-
-            hitCircle.PositionChanged += _ => UpdatePosition();
-            hitCircle.StackHeightChanged += _ => UpdatePosition();
-            hitCircle.ScaleChanged += _ => Scale = new Vector2(hitCircle.Scale);
         }
 
         [BackgroundDependencyLoader]
@@ -36,7 +32,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components
         {
             Colour = colours.Yellow;
 
-            UpdatePosition();
+            PositionBindable.BindValueChanged(_ => UpdatePosition(), true);
+            StackHeightBindable.BindValueChanged(_ => UpdatePosition());
+            ScaleBindable.BindValueChanged(v => Scale = new Vector2(v), true);
         }
 
         protected virtual void UpdatePosition() => Position = hitCircle.StackedPosition;

osu.Game.Rulesets.Osu/Edit/Blueprints/HitObjectPiece.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.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Osu.Objects;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints
+{
+    /// <summary>
+    /// A piece of a blueprint which responds to changes in the state of a <see cref="OsuHitObject"/>.
+    /// </summary>
+    public abstract class HitObjectPiece : CompositeDrawable
+    {
+        protected readonly IBindable<Vector2> PositionBindable = new Bindable<Vector2>();
+        protected readonly IBindable<int> StackHeightBindable = new Bindable<int>();
+        protected readonly IBindable<float> ScaleBindable = new Bindable<float>();
+
+        private readonly OsuHitObject hitObject;
+
+        protected HitObjectPiece(OsuHitObject hitObject)
+        {
+            this.hitObject = hitObject;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            PositionBindable.BindTo(hitObject.PositionBindable);
+            StackHeightBindable.BindTo(hitObject.StackHeightBindable);
+            ScaleBindable.BindTo(hitObject.ScaleBindable);
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/Blueprints/SliderPiece.cs

@@ -0,0 +1,32 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints
+{
+    /// <summary>
+    /// A piece of a blueprint which responds to changes in the state of a <see cref="Slider"/>.
+    /// </summary>
+    public abstract class SliderPiece : HitObjectPiece
+    {
+        protected readonly IBindable<SliderPath> PathBindable = new Bindable<SliderPath>();
+
+        private readonly Slider slider;
+
+        protected SliderPiece(Slider slider)
+            : base(slider)
+        {
+            this.slider = slider;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            PathBindable.BindTo(slider.PathBindable);
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointPiece.cs

@@ -10,7 +10,7 @@ using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 {

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs

@@ -1,26 +1,31 @@
 // 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.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 {
-    public class PathControlPointVisualiser : CompositeDrawable
+    public class PathControlPointVisualiser : SliderPiece
     {
         private readonly Slider slider;
 
         private readonly Container<PathControlPointPiece> pieces;
 
         public PathControlPointVisualiser(Slider slider)
+            : base(slider)
         {
             this.slider = slider;
 
             InternalChild = pieces = new Container<PathControlPointPiece> { RelativeSizeAxes = Axes.Both };
+        }
 
-            slider.PathChanged += _ => updatePathControlPoints();
+        [BackgroundDependencyLoader]
-            updatePathControlPoints();
+        private void load()
+        {
+            PathBindable.BindValueChanged(_ => updatePathControlPoints(), true);
         }
 
         private void updatePathControlPoints()

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/SliderBodyPiece.cs

@@ -3,21 +3,21 @@
 
 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 osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 {
-    public class SliderBodyPiece : CompositeDrawable
+    public class SliderBodyPiece : SliderPiece
     {
         private readonly Slider slider;
         private readonly ManualSliderBody body;
 
         public SliderBodyPiece(Slider slider)
+            : base(slider)
         {
             this.slider = slider;
 
@@ -26,9 +26,6 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
                 AccentColour = Color4.Transparent,
                 PathWidth = slider.Scale * 64
             };
-
-            slider.PositionChanged += _ => updatePosition();
-            slider.ScaleChanged += _ => body.PathWidth = slider.Scale * 64;
         }
 
         [BackgroundDependencyLoader]
@@ -36,7 +33,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
         {
             body.BorderColour = colours.Yellow;
 
-            updatePosition();
+            PositionBindable.BindValueChanged(_ => updatePosition(), true);
+            ScaleBindable.BindValueChanged(v => body.PathWidth = v * 64, true);
         }
 
         private void updatePosition() => Position = slider.StackedPosition;

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/SliderCirclePiece.cs

@@ -1,6 +1,9 @@
 // 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.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
 using osu.Game.Rulesets.Osu.Objects;
 
@@ -8,6 +11,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 {
     public class SliderCirclePiece : HitCirclePiece
     {
+        private readonly IBindable<SliderPath> pathBindable = new Bindable<SliderPath>();
+
         private readonly Slider slider;
         private readonly SliderPosition position;
 
@@ -16,8 +21,13 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
         {
             this.slider = slider;
             this.position = position;
+        }
 
-            slider.PathChanged += _ => UpdatePosition();
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            pathBindable.BindTo(slider.PathBindable);
+            pathBindable.BindValueChanged(_ => UpdatePosition(), true);
         }
 
         protected override void UpdatePosition()

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs

@@ -12,8 +12,8 @@ using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
-using OpenTK;
+using osuTK;
-using OpenTK.Input;
+using osuTK.Input;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 {

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs

@@ -5,7 +5,7 @@ using osu.Framework.Graphics;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 {

osu.Game.Rulesets.Osu/Edit/Blueprints/Spinners/Components/SpinnerPiece.cs

@@ -8,16 +8,18 @@ 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;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners.Components
 {
-    public class SpinnerPiece : CompositeDrawable
+    public class SpinnerPiece : HitObjectPiece
     {
         private readonly Spinner spinner;
         private readonly CircularContainer circle;
+        private readonly RingPiece ring;
 
         public SpinnerPiece(Spinner spinner)
+            : base(spinner)
         {
             this.spinner = spinner;
 
@@ -27,7 +29,6 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners.Components
             FillMode = FillMode.Fit;
             Size = new Vector2(1.3f);
 
-            RingPiece ring;
             InternalChildren = new Drawable[]
             {
                 circle = new CircularContainer
@@ -45,18 +46,16 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners.Components
             };
 
             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;
+
+            PositionBindable.BindValueChanged(_ => updatePosition(), true);
+            StackHeightBindable.BindValueChanged(_ => updatePosition());
+            ScaleBindable.BindValueChanged(v => ring.Scale = new Vector2(v), true);
         }
 
         private void updatePosition() => Position = spinner.Position;

osu.Game.Rulesets.Osu/Edit/Blueprints/Spinners/SpinnerPlacementBlueprint.cs

@@ -37,6 +37,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners
 
                 isPlacingEnd = true;
                 piece.FadeTo(1f, 150, Easing.OutQuint);
+
+                BeginPlacement();
             }
 
             return true;

osu.Game.Rulesets.Osu/Edit/Blueprints/Spinners/SpinnerSelectionBlueprint.cs

@@ -5,7 +5,7 @@ using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners
 {

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

@@ -5,7 +5,7 @@ using osu.Framework.Graphics.Cursor;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.UI;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Edit
 {

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

@@ -1,12 +1,52 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Framework.Graphics;
+using osu.Framework.Input;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModFlashlight : ModFlashlight
+    public class OsuModFlashlight : ModFlashlight<OsuHitObject>
     {
         public override double ScoreMultiplier => 1.12;
+
+        private const float default_flashlight_size = 180;
+
+        public override Flashlight CreateFlashlight() => new OsuFlashlight();
+
+        private class OsuFlashlight : Flashlight, IRequireHighFrequencyMousePosition
+        {
+            public OsuFlashlight()
+            {
+                FlashlightSize = new Vector2(0, getSizeFor(0));
+            }
+
+            protected override bool OnMouseMove(MouseMoveEvent e)
+            {
+                FlashlightPosition = e.MousePosition;
+                return base.OnMouseMove(e);
+            }
+
+            private float getSizeFor(int combo)
+            {
+                if (combo > 200)
+                    return default_flashlight_size * 0.8f;
+                else if (combo > 100)
+                    return default_flashlight_size * 0.9f;
+                else
+                    return default_flashlight_size;
+            }
+
+            protected override void OnComboChange(int newCombo)
+            {
+                this.TransformTo(nameof(FlashlightSize), new Vector2(0, getSizeFor(newCombo)), FLASHLIGHT_FADE_DURATION);
+            }
+
+            protected override string FragmentShader => "CircularFlashlight";
+        }
     }
 }

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

@@ -7,7 +7,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.UI;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {

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

@@ -8,7 +8,7 @@ using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {

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

@@ -9,7 +9,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {

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

@@ -1,8 +1,8 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK;
+using osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;

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

@@ -3,7 +3,7 @@
 
 using System;
 using System.Collections.Generic;
-using OpenTK;
+using osuTK;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Types;
 

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

@@ -2,12 +2,14 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
-using OpenTK;
+using osuTK;
 using osu.Game.Rulesets.Scoring;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -21,6 +23,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         private readonly NumberPiece number;
         private readonly GlowPiece glow;
 
+        private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
+        private readonly IBindable<int> stackHeightBindable = new Bindable<int>();
+        private readonly IBindable<float> scaleBindable = new Bindable<float>();
+
         public DrawableHitCircle(HitCircle h)
             : base(h)
         {
@@ -59,10 +65,18 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             //may not be so correct
             Size = circle.DrawSize;
+        }
 
-            HitObject.PositionChanged += _ => Position = HitObject.StackedPosition;
+        [BackgroundDependencyLoader]
-            HitObject.StackHeightChanged += _ => Position = HitObject.StackedPosition;
+        private void load()
-            HitObject.ScaleChanged += s => Scale = new Vector2(s);
+        {
+            positionBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
+            stackHeightBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
+            scaleBindable.BindValueChanged(v => Scale = new Vector2(v));
+
+            positionBindable.BindTo(HitObject.PositionBindable);
+            stackHeightBindable.BindTo(HitObject.StackHeightBindable);
+            scaleBindable.BindTo(HitObject.ScaleBindable);
         }
 
         public override Color4 AccentColour

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

@@ -9,15 +9,13 @@ using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Game.Graphics.Containers;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
     public class DrawableOsuHitObject : DrawableHitObject<OsuHitObject>
     {
-        public override bool IsPresent => base.IsPresent || State.Value == ArmedState.Idle && Clock?.CurrentTime >= HitObject.StartTime - HitObject.TimePreempt;
-
         private readonly ShakeContainer shakeContainer;
 
         protected DrawableOsuHitObject(OsuHitObject hitObject)

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

@@ -2,7 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Graphics;
-using OpenTK;
+using osuTK;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;

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

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 using osu.Framework.Graphics;
 using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Objects.Drawables;
-using OpenTK;
+using osuTK;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;

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

@@ -1,17 +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 OpenTK;
+using osuTK;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Configuration;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Configuration;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -26,6 +28,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         public readonly SnakingSliderBody Body;
         public readonly SliderBall Ball;
 
+        private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
+        private readonly IBindable<float> scaleBindable = new Bindable<float>();
+        private readonly IBindable<SliderPath> pathBindable = new Bindable<SliderPath>();
+
         public DrawableSlider(Slider s)
             : base(s)
         {
@@ -83,15 +89,26 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 components.Add(drawableRepeatPoint);
                 AddNested(drawableRepeatPoint);
             }
+        }
 
-            HitObject.PositionChanged += _ => Position = HitObject.StackedPosition;
+        [BackgroundDependencyLoader]
-            HitObject.ScaleChanged += _ =>
+        private void load(OsuConfigManager config)
+        {
+            config.BindWith(OsuSetting.SnakingInSliders, Body.SnakingIn);
+            config.BindWith(OsuSetting.SnakingOutSliders, Body.SnakingOut);
+
+            positionBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
+            scaleBindable.BindValueChanged(v =>
             {
                 Body.PathWidth = HitObject.Scale * 64;
                 Ball.Scale = new Vector2(HitObject.Scale);
-            };
+            });
 
-            slider.PathChanged += _ => Body.Refresh();
+            positionBindable.BindTo(HitObject.PositionBindable);
+            scaleBindable.BindTo(HitObject.ScaleBindable);
+            pathBindable.BindTo(slider.PathBindable);
+
+            pathBindable.BindValueChanged(_ => Body.Refresh());
         }
 
         public override Color4 AccentColour
@@ -108,13 +125,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             }
         }
 
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
-        {
-            config.BindWith(OsuSetting.SnakingInSliders, Body.SnakingIn);
-            config.BindWith(OsuSetting.SnakingOutSliders, Body.SnakingOut);
-        }
-
         public bool Tracking;
 
         protected override void Update()

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

@@ -2,24 +2,35 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
     public class DrawableSliderHead : DrawableHitCircle
     {
+        private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
+        private readonly IBindable<SliderPath> pathBindable = new Bindable<SliderPath>();
+
         private readonly Slider slider;
 
         public DrawableSliderHead(Slider slider, HitCircle h)
             : base(h)
         {
             this.slider = slider;
+        }
 
-            h.PositionChanged += _ => updatePosition();
+        [BackgroundDependencyLoader]
-            slider.PathChanged += _ => updatePosition();
+        private void load()
+        {
+            positionBindable.BindTo(HitObject.PositionBindable);
+            pathBindable.BindTo(slider.PathBindable);
 
-            updatePosition();
+            positionBindable.BindValueChanged(_ => updatePosition());
+            pathBindable.BindValueChanged(_ => updatePosition(), true);
         }
 
         protected override void Update()

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

@@ -1,8 +1,11 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Framework.Configuration;
 using osu.Framework.Graphics;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -17,6 +20,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         public bool Tracking { get; set; }
 
+        private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
+        private readonly IBindable<SliderPath> pathBindable = new Bindable<SliderPath>();
+
         public DrawableSliderTail(Slider slider, SliderTailCircle hitCircle)
             : base(hitCircle)
         {
@@ -29,10 +35,11 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             AlwaysPresent = true;
 
-            hitCircle.PositionChanged += _ => updatePosition();
+            positionBindable.BindTo(hitCircle.PositionBindable);
-            slider.PathChanged += _ => updatePosition();
+            pathBindable.BindTo(slider.PathBindable);
 
-            updatePosition();
+            positionBindable.BindValueChanged(_ => updatePosition());
+            pathBindable.BindValueChanged(_ => updatePosition(), true);
         }
 
         protected override void CheckForResult(bool userTriggered, double timeOffset)

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

@@ -3,8 +3,8 @@
 
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
-using OpenTK;
+using osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;

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

@@ -6,11 +6,12 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
-using OpenTK;
+using osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Game.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Allocation;
+using osu.Framework.Configuration;
 using osu.Game.Screens.Ranking;
 using osu.Game.Rulesets.Scoring;
 
@@ -36,6 +37,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         private readonly Color4 baseColour = OsuColour.FromHex(@"002c3c");
         private readonly Color4 fillColour = OsuColour.FromHex(@"005b7c");
 
+        private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
+
         private Color4 normalColour;
         private Color4 completeColour;
 
@@ -112,8 +115,23 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     Alpha = 0
                 }
             };
+        }
 
-            s.PositionChanged += _ => Position = s.Position;
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            normalColour = baseColour;
+
+            Background.AccentColour = normalColour;
+
+            completeColour = colours.YellowLight.Opacity(0.75f);
+
+            Disc.AccentColour = fillColour;
+            circle.Colour = colours.BlueDark;
+            glow.Colour = colours.BlueDark;
+
+            positionBindable.BindValueChanged(v => Position = v);
+            positionBindable.BindTo(HitObject.PositionBindable);
         }
 
         public float Progress => MathHelper.Clamp(Disc.RotationAbsolute / 360 / Spinner.SpinsRequired, 0, 1);
@@ -153,20 +171,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             });
         }
 
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            normalColour = baseColour;
-
-            Background.AccentColour = normalColour;
-
-            completeColour = colours.YellowLight.Opacity(0.75f);
-
-            Disc.AccentColour = fillColour;
-            circle.Colour = colours.BlueDark;
-            glow.Colour = colours.BlueDark;
-        }
-
         protected override void Update()
         {
             Disc.Tracking = OsuActionInputManager?.PressedActions.Any(x => x == OsuAction.LeftButton || x == OsuAction.RightButton) ?? false;
@@ -213,6 +217,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             switch (state)
             {
+                case ArmedState.Idle:
+                    Expire(true);
+                    break;
                 case ArmedState.Hit:
                     sequence.ScaleTo(Scale * 1.2f, 320, Easing.Out);
                     break;

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

@@ -1,7 +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 OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {

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

@@ -6,7 +6,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
 using osu.Game.Skinning;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {

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

@@ -4,7 +4,7 @@
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Skinning;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {

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

@@ -3,7 +3,7 @@
 
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using OpenTK;
+using osuTK;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Skinning;
 

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

@@ -2,7 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Collections.Generic;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {

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

@@ -5,7 +5,7 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Skinning;
 

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

@@ -3,8 +3,8 @@
 
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using OpenTK;
+using osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Skinning;
 

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

@@ -7,9 +7,9 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Objects.Types;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Game.Skinning;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {

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

@@ -6,9 +6,9 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Lines;
 using osu.Framework.Graphics.Primitives;
-using OpenTK;
+using osuTK;
-using OpenTK.Graphics;
+using osuTK.Graphics;
-using OpenTK.Graphics.ES30;
+using osuTK.Graphics.ES30;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {