Merge branch 'add-mania-selection-testcase' into mania-selection-movement

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

@@ -5,7 +5,6 @@ using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
-using osu.Game.Configuration;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Judgements;
@@ -21,14 +20,8 @@ namespace osu.Game.Rulesets.Catch.UI
 
         private readonly CatcherArea catcherArea;
 
-        protected override bool UserScrollSpeedAdjustment => false;
-
-        protected override ScrollVisualisationMethod VisualisationMethod => ScrollVisualisationMethod.Constant;
-
         public CatchPlayfield(BeatmapDifficulty difficulty, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> getVisualRepresentation)
         {
-            Direction.Value = ScrollingDirection.Down;
-
             Container explodingFruitContainer;
 
             Anchor = Anchor.TopCentre;
@@ -55,8 +48,6 @@ namespace osu.Game.Rulesets.Catch.UI
                     HitObjectContainer
                 }
             };
-
-            VisibleTimeRange.Value = BeatmapDifficulty.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450);
         }
 
         public bool CheckIfWeCanCatch(CatchHitObject obj) => catcherArea.AttemptCatch(obj);

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

@@ -3,6 +3,7 @@
 
 using osu.Framework.Input;
 using osu.Game.Beatmaps;
+using osu.Game.Configuration;
 using osu.Game.Input.Handlers;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawable;
@@ -18,9 +19,15 @@ namespace osu.Game.Rulesets.Catch.UI
 {
     public class CatchRulesetContainer : ScrollingRulesetContainer<CatchPlayfield, CatchHitObject>
     {
+        protected override ScrollVisualisationMethod VisualisationMethod => ScrollVisualisationMethod.Constant;
+
+        protected override bool UserScrollSpeedAdjustment => false;
+
         public CatchRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
+            Direction.Value = ScrollingDirection.Down;
+            TimeRange.Value = BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450);
         }
 
         public override ScoreProcessor CreateScoreProcessor() => new CatchScoreProcessor(this);

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

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

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

@@ -14,6 +14,7 @@ using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mania.UI.Components;
 using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Tests.Visual;
 using OpenTK;
 using OpenTK.Graphics;
 
@@ -93,7 +94,6 @@ namespace osu.Game.Rulesets.Mania.Tests
                 Height = 0.85f,
                 AccentColour = Color4.OrangeRed,
                 Action = { Value = action },
-                VisibleTimeRange = { Value = 2000 }
             };
 
             columns.Add(column);
@@ -104,6 +104,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 Origin = Anchor.Centre,
                 AutoSizeAxes = Axes.X,
                 RelativeSizeAxes = Axes.Y,
+                TimeRange = 2000,
                 Child = column
             };
         }

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

@@ -0,0 +1,57 @@
+// 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.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mania.Edit.Blueprints;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public class TestCaseHoldNoteSelectionBlueprint : SelectionBlueprintTestCase
+    {
+        private readonly DrawableHoldNote drawableObject;
+
+        protected override Container<Drawable> Content => content ?? base.Content;
+        private readonly Container content;
+
+        public TestCaseHoldNoteSelectionBlueprint()
+        {
+            var holdNote = new HoldNote { Column = 0, Duration = 1000 };
+            holdNote.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+            base.Content.Child = content = new ScrollingTestContainer(ScrollingDirection.Down)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                AutoSizeAxes = Axes.Y,
+                Width = 50,
+                Child = drawableObject = new DrawableHoldNote(holdNote)
+                {
+                    Height = 300,
+                    AccentColour = OsuColour.Gray(0.3f)
+                }
+            };
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            foreach (var nested in drawableObject.NestedHitObjects)
+            {
+                double finalPosition = (nested.HitObject.StartTime - drawableObject.HitObject.StartTime) / drawableObject.HitObject.Duration;
+                nested.Y = (float)(-finalPosition * content.DrawHeight);
+            }
+        }
+
+        protected override SelectionBlueprint CreateBlueprint() => new HoldNoteSelectionBlueprint(drawableObject);
+    }
+}

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

@@ -0,0 +1,41 @@
+// 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.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mania.Edit.Blueprints;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Tests.Visual;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public class TestCaseNoteSelectionBlueprint : SelectionBlueprintTestCase
+    {
+        private readonly DrawableNote drawableObject;
+
+        protected override Container<Drawable> Content => content ?? base.Content;
+        private readonly Container content;
+
+        public TestCaseNoteSelectionBlueprint()
+        {
+            var note = new Note { Column = 0 };
+            note.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+            base.Content.Child = content = new ScrollingTestContainer(ScrollingDirection.Down)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Size = new Vector2(50, 20),
+                Child = drawableObject = new DrawableNote(note)
+            };
+        }
+
+        protected override SelectionBlueprint CreateBlueprint() => new NoteSelectionBlueprint(drawableObject);
+    }
+}

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

@@ -14,6 +14,7 @@ using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Tests.Visual;
 using OpenTK;
 
 namespace osu.Game.Rulesets.Mania.Tests
@@ -122,7 +123,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         {
             var specialAction = ManiaAction.Special1;
 
-            var stage = new ManiaStage(0, new StageDefinition { Columns = 2 }, ref action, ref specialAction) { VisibleTimeRange = { Value = 2000 } };
+            var stage = new ManiaStage(0, new StageDefinition { Columns = 2 }, ref action, ref specialAction);
             stages.Add(stage);
 
             return new ScrollingTestContainer(direction)
@@ -131,6 +132,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 Origin = Anchor.Centre,
                 RelativeSizeAxes = Axes.Y,
                 AutoSizeAxes = Axes.X,
+                TimeRange = 2000,
                 Child = stage
             };
         }

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

@@ -4,18 +4,17 @@
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Primitives;
 using osu.Game.Graphics;
-using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
-using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using OpenTK;
 using OpenTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
-    public class HoldNoteSelectionBlueprint : SelectionBlueprint
+    public class HoldNoteSelectionBlueprint : ManiaSelectionBlueprint
     {
         public new DrawableHoldNote HitObject => (DrawableHoldNote)base.HitObject;
 
@@ -59,6 +58,8 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
                 Y -= HitObject.Tail.DrawHeight;
         }
 
+        public override Quad SelectionQuad => ScreenSpaceDrawQuad;
+
         private class HoldNoteNoteSelectionBlueprint : NoteSelectionBlueprint
         {
             public HoldNoteNoteSelectionBlueprint(DrawableNote note)

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

@@ -0,0 +1,23 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Framework.Input.Events;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Mania.Edit.Blueprints
+{
+    public class ManiaSelectionBlueprint : SelectionBlueprint
+    {
+        public ManiaSelectionBlueprint(DrawableHitObject hitObject)
+            : base(hitObject)
+        {
+            RelativeSizeAxes = Axes.None;
+        }
+
+        public override void AdjustPosition(DragEvent dragEvent)
+        {
+        }
+    }
+}

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

@@ -3,13 +3,12 @@
 
 using osu.Framework.Allocation;
 using osu.Game.Graphics;
-using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
-    public class NoteSelectionBlueprint : SelectionBlueprint
+    public class NoteSelectionBlueprint : ManiaSelectionBlueprint
     {
         public NoteSelectionBlueprint(DrawableNote note)
             : base(note)

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

@@ -6,11 +6,14 @@ using OpenTK;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.UI;
+using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
     public class ManiaEditRulesetContainer : ManiaRulesetContainer
     {
+        public new IScrollingInfo ScrollingInfo => base.ScrollingInfo;
+
         public ManiaEditRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {

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

@@ -10,31 +10,32 @@ using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Drawables;
 using System.Collections.Generic;
 using osu.Framework.Allocation;
-using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.Edit.Blueprints;
-using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
     public class ManiaHitObjectComposer : HitObjectComposer<ManiaHitObject>
     {
-        protected new ManiaConfigManager Config => (ManiaConfigManager)base.Config;
-
         public ManiaHitObjectComposer(Ruleset ruleset)
             : base(ruleset)
         {
         }
 
+        private DependencyContainer dependencies;
+
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
-        {
+            => dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
-            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
-            dependencies.CacheAs<IScrollingInfo>(new ManiaScrollingInfo(Config));
-            return dependencies;
-        }
 
         protected override RulesetContainer<ManiaHitObject> CreateRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
-            => new ManiaEditRulesetContainer(ruleset, beatmap);
+        {
+            var 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);
+
+            return rulesetContainer;
+        }
 
         protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => Array.Empty<HitObjectCompositionTool>();
 

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

@@ -0,0 +1,18 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Mania.Edit.Masks
+{
+    public abstract class ManiaSelectionBlueprint : SelectionBlueprint
+    {
+        protected ManiaSelectionBlueprint(DrawableHitObject hitObject)
+            : base(hitObject)
+        {
+            RelativeSizeAxes = Axes.None;
+        }
+    }
+}

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

@@ -5,7 +5,6 @@ using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 

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

@@ -9,7 +9,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
-using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces

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

@@ -1,12 +1,12 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System.Linq;
 using OpenTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
-using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Input.Bindings;
@@ -16,7 +16,7 @@ using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
-    public class Column : ManiaScrollingPlayfield, IKeyBindingHandler<ManiaAction>, IHasAccentColour
+    public class Column : ScrollingPlayfield, IKeyBindingHandler<ManiaAction>, IHasAccentColour
     {
         private const float column_width = 45;
         private const float special_column_width = 70;
@@ -134,7 +134,7 @@ namespace osu.Game.Rulesets.Mania.UI
             hitObject.AccentColour = AccentColour;
             hitObject.OnNewResult += OnNewResult;
 
-            HitObjects.Add(hitObject);
+            HitObjectContainer.Add(hitObject);
         }
 
         internal void OnNewResult(DrawableHitObject judgedObject, JudgementResult result)
@@ -144,7 +144,7 @@ namespace osu.Game.Rulesets.Mania.UI
 
             explosionContainer.Add(new HitExplosion(judgedObject)
             {
-                Anchor = Direction == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre
+                Anchor = Direction.Value == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre
             });
         }
 
@@ -154,10 +154,10 @@ namespace osu.Game.Rulesets.Mania.UI
                 return false;
 
             var nextObject =
-                HitObjects.AliveObjects.FirstOrDefault(h => h.HitObject.StartTime > Time.Current) ??
+                HitObjectContainer.AliveObjects.FirstOrDefault(h => h.HitObject.StartTime > Time.Current) ??
                 // fallback to non-alive objects to find next off-screen object
-                HitObjects.Objects.FirstOrDefault(h => h.HitObject.StartTime > Time.Current) ??
+                HitObjectContainer.Objects.FirstOrDefault(h => h.HitObject.StartTime > Time.Current) ??
-                HitObjects.Objects.LastOrDefault();
+                HitObjectContainer.Objects.LastOrDefault();
 
             nextObject?.PlaySamples();
 

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

@@ -1,20 +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.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using System;
 using System.Collections.Generic;
 using osu.Game.Rulesets.Mania.Beatmaps;
-using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI.Scrolling;
 using OpenTK;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
-    public class ManiaPlayfield : ManiaScrollingPlayfield
+    public class ManiaPlayfield : ScrollingPlayfield
     {
         private readonly List<ManiaStage> stages = new List<ManiaStage>();
 
@@ -41,7 +40,6 @@ namespace osu.Game.Rulesets.Mania.UI
             for (int i = 0; i < stageDefinitions.Count; i++)
             {
                 var newStage = new ManiaStage(firstColumnIndex, stageDefinitions[i], ref normalColumnAction, ref specialColumnAction);
-                newStage.VisibleTimeRange.BindTo(VisibleTimeRange);
 
                 playfieldGrid.Content[0][i] = newStage;
 
@@ -68,11 +66,5 @@ namespace osu.Game.Rulesets.Mania.UI
 
             return null;
         }
-
-        [BackgroundDependencyLoader]
-        private void load(ManiaConfigManager maniaConfig)
-        {
-            maniaConfig.BindWith(ManiaSetting.ScrollTime, VisibleTimeRange);
-        }
     }
 }

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

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Configuration;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Input;
@@ -35,6 +36,8 @@ namespace osu.Game.Rulesets.Mania.UI
 
         protected new ManiaConfigManager Config => (ManiaConfigManager)base.Config;
 
+        private readonly Bindable<ManiaScrollingDirection> configDirection = new Bindable<ManiaScrollingDirection>();
+
         public ManiaRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
@@ -70,18 +73,11 @@ namespace osu.Game.Rulesets.Mania.UI
         private void load()
         {
             BarLines.ForEach(Playfield.Add);
-        }
 
-        private DependencyContainer dependencies;
+            Config.BindWith(ManiaSetting.ScrollDirection, configDirection);
+            configDirection.BindValueChanged(v => Direction.Value = (ScrollingDirection)v, true);
 
-        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+            Config.BindWith(ManiaSetting.ScrollTime, TimeRange);
-        {
-            dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
-
-            if (dependencies.Get<ManiaScrollingInfo>() == null)
-                dependencies.CacheAs<IScrollingInfo>(new ManiaScrollingInfo(Config));
-
-            return dependencies;
         }
 
         protected override Playfield CreatePlayfield() => new ManiaPlayfield(Beatmap.Stages)

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

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

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

@@ -1,21 +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.Configuration;
-using osu.Game.Rulesets.UI.Scrolling;
-
-namespace osu.Game.Rulesets.Mania.UI
-{
-    public abstract class ManiaScrollingPlayfield : ScrollingPlayfield
-    {
-        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
-
-        [BackgroundDependencyLoader]
-        private void load(IScrollingInfo scrollingInfo)
-        {
-            direction.BindTo(scrollingInfo.Direction);
-            direction.BindValueChanged(direction => Direction.Value = direction, true);
-        }
-    }
-}

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

@@ -23,7 +23,7 @@ namespace osu.Game.Rulesets.Mania.UI
     /// <summary>
     /// A collection of <see cref="Column"/>s.
     /// </summary>
-    public class ManiaStage : ManiaScrollingPlayfield
+    public class ManiaStage : ScrollingPlayfield
     {
         public const float HIT_TARGET_POSITION = 50;
 
@@ -144,8 +144,6 @@ namespace osu.Game.Rulesets.Mania.UI
 
         public void AddColumn(Column c)
         {
-            c.VisibleTimeRange.BindTo(VisibleTimeRange);
-
             topLevelContainer.Add(c.TopLevelContainer.CreateProxy());
             columnFlow.Add(c);
             AddNested(c);

osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/HitCircleSelectionBlueprint.cs

@@ -1,14 +1,13 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles
 {
-    public class HitCircleSelectionBlueprint : SelectionBlueprint
+    public class HitCircleSelectionBlueprint : OsuSelectionBlueprint
     {
         public HitCircleSelectionBlueprint(DrawableHitCircle hitCircle)
             : base(hitCircle)

osu.Game.Rulesets.Osu/Edit/Blueprints/OsuSelectionBlueprint.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.Framework.Input.Events;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints
+{
+    public class OsuSelectionBlueprint : SelectionBlueprint
+    {
+        protected OsuHitObject OsuObject => (OsuHitObject)HitObject.HitObject;
+
+        public OsuSelectionBlueprint(DrawableHitObject hitObject)
+            : base(hitObject)
+        {
+        }
+
+        public override void AdjustPosition(DragEvent dragEvent) => OsuObject.Position += dragEvent.Delta;
+    }
+}

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

@@ -1,18 +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.Rulesets.Edit;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 {
-    public class SliderCircleSelectionBlueprint : SelectionBlueprint
+    public class SliderCircleSelectionBlueprint : OsuSelectionBlueprint
     {
+        private readonly Slider slider;
+
         public SliderCircleSelectionBlueprint(DrawableOsuHitObject hitObject, Slider slider, SliderPosition position)
             : base(hitObject)
         {
+            this.slider = slider;
+
             InternalChild = new SliderCirclePiece(slider, position);
 
             Select();
@@ -20,5 +24,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 
         // Todo: This is temporary, since the slider circle masks don't do anything special yet. In the future they will handle input.
         public override bool HandlePositionalInput => false;
+
+        public override void AdjustPosition(DragEvent dragEvent) => slider.Position += dragEvent.Delta;
     }
 }

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

@@ -2,7 +2,6 @@
 // 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.Blueprints.Sliders.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
@@ -10,7 +9,7 @@ using OpenTK;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 {
-    public class SliderSelectionBlueprint : SelectionBlueprint
+    public class SliderSelectionBlueprint : OsuSelectionBlueprint
     {
         private readonly SliderCircleSelectionBlueprint headBlueprint;
 

osu.Game.Rulesets.Osu/Edit/Blueprints/Spinners/SpinnerSelectionBlueprint.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 osu.Game.Rulesets.Edit;
+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;
@@ -9,7 +9,7 @@ using OpenTK;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners
 {
-    public class SpinnerSelectionBlueprint : SelectionBlueprint
+    public class SpinnerSelectionBlueprint : OsuSelectionBlueprint
     {
         private readonly SpinnerPiece piece;
 
@@ -20,5 +20,10 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners
         }
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => piece.ReceivePositionalInputAt(screenSpacePos);
+
+        public override void AdjustPosition(DragEvent dragEvent)
+        {
+            // Spinners don't support position adjustments
+        }
     }
 }

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

@@ -7,11 +7,10 @@ using osu.Game.Rulesets.Objects;
 using OpenTK;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Rulesets.Edit.Types;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {
-    public abstract class OsuHitObject : HitObject, IHasComboInformation, IHasEditablePosition
+    public abstract class OsuHitObject : HitObject, IHasComboInformation, IHasPosition
     {
         public const double OBJECT_RADIUS = 64;
 
@@ -100,8 +99,6 @@ namespace osu.Game.Rulesets.Osu.Objects
             Scale = (1.0f - 0.7f * (difficulty.CircleSize - 5) / 5) / 2;
         }
 
-        public virtual void OffsetPosition(Vector2 offset) => Position += offset;
-
         protected override HitWindows CreateHitWindows() => new OsuHitWindows();
     }
 }

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

@@ -166,7 +166,7 @@ namespace osu.Game.Rulesets.Osu.Objects
 
         private void createSliderEnds()
         {
-            HeadCircle = new SliderCircle(this)
+            HeadCircle = new SliderCircle
             {
                 StartTime = StartTime,
                 Position = Position,
@@ -176,7 +176,7 @@ namespace osu.Game.Rulesets.Osu.Objects
                 ComboIndex = ComboIndex,
             };
 
-            TailCircle = new SliderTailCircle(this)
+            TailCircle = new SliderTailCircle
             {
                 StartTime = EndTime,
                 Position = EndPosition,

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

@@ -1,19 +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 OpenTK;
-
 namespace osu.Game.Rulesets.Osu.Objects
 {
     public class SliderCircle : HitCircle
     {
-        private readonly Slider slider;
-
-        public SliderCircle(Slider slider)
-        {
-            this.slider = slider;
-        }
-
-        public override void OffsetPosition(Vector2 offset) => slider.OffsetPosition(offset);
     }
 }

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

@@ -8,11 +8,6 @@ namespace osu.Game.Rulesets.Osu.Objects
 {
     public class SliderTailCircle : SliderCircle
     {
-        public SliderTailCircle(Slider slider)
-            : base(slider)
-        {
-        }
-
         public override Judgement CreateJudgement() => new OsuSliderTailJudgement();
     }
 }

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

@@ -7,7 +7,6 @@ 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
 {
@@ -32,10 +31,5 @@ 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.Taiko/UI/TaikoPlayfield.cs

@@ -8,7 +8,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Judgements;
@@ -39,10 +38,6 @@ namespace osu.Game.Rulesets.Taiko.UI
         /// </summary>
         private const float left_area_size = 240;
 
-        protected override bool UserScrollSpeedAdjustment => false;
-
-        protected override ScrollVisualisationMethod VisualisationMethod => ScrollVisualisationMethod.Overlapping;
-
         private readonly Container<HitExplosion> hitExplosionContainer;
         private readonly Container<KiaiHitExplosion> kiaiExplosionContainer;
         private readonly JudgementContainer<DrawableTaikoJudgement> judgementContainer;
@@ -59,8 +54,6 @@ namespace osu.Game.Rulesets.Taiko.UI
 
         public TaikoPlayfield(ControlPointInfo controlPoints)
         {
-            Direction.Value = ScrollingDirection.Left;
-
             InternalChild = new PlayfieldAdjustmentContainer
             {
                 Anchor = Anchor.CentreLeft,
@@ -200,8 +193,6 @@ namespace osu.Game.Rulesets.Taiko.UI
                     }
                 }
             };
-
-            VisibleTimeRange.Value = 7000;
         }
 
         [BackgroundDependencyLoader]

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

@@ -14,6 +14,7 @@ using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.Taiko.Replays;
 using System.Linq;
 using osu.Framework.Input;
+using osu.Game.Configuration;
 using osu.Game.Input.Handlers;
 using osu.Game.Rulesets.UI.Scrolling;
 
@@ -21,9 +22,15 @@ namespace osu.Game.Rulesets.Taiko.UI
 {
     public class TaikoRulesetContainer : ScrollingRulesetContainer<TaikoPlayfield, TaikoHitObject>
     {
+        protected override ScrollVisualisationMethod VisualisationMethod => ScrollVisualisationMethod.Overlapping;
+
+        protected override bool UserScrollSpeedAdjustment => false;
+
         public TaikoRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
+            Direction.Value = ScrollingDirection.Left;
+            TimeRange.Value = 7000;
         }
 
         [BackgroundDependencyLoader]

osu.Game.Tests/Visual/TestCaseScrollingHitObjects.cs

@@ -9,6 +9,7 @@ using OpenTK;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Timing;
@@ -22,6 +23,7 @@ namespace osu.Game.Tests.Visual
     {
         public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(Playfield) };
 
+        private readonly ScrollingTestContainer[] scrollContainers = new ScrollingTestContainer[4];
         private readonly TestPlayfield[] playfields = new TestPlayfield[4];
 
         public TestCaseScrollingHitObjects()
@@ -33,18 +35,38 @@ namespace osu.Game.Tests.Visual
                 {
                     new Drawable[]
                     {
-                        playfields[0] = new TestPlayfield(ScrollingDirection.Up),
+                        scrollContainers[0] = new ScrollingTestContainer(ScrollingDirection.Up)
-                        playfields[1] = new TestPlayfield(ScrollingDirection.Down)
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Child = playfields[0] = new TestPlayfield()
+                        },
+                        scrollContainers[1] = new ScrollingTestContainer(ScrollingDirection.Up)
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Child = playfields[1] = new TestPlayfield()
+                        },
                     },
                     new Drawable[]
                     {
-                        playfields[2] = new TestPlayfield(ScrollingDirection.Left),
+                        scrollContainers[2] = new ScrollingTestContainer(ScrollingDirection.Up)
-                        playfields[3] = new TestPlayfield(ScrollingDirection.Right)
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Child = playfields[2] = new TestPlayfield()
+                        },
+                        scrollContainers[3] = new ScrollingTestContainer(ScrollingDirection.Up)
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Child = playfields[3] = new TestPlayfield()
+                        }
                     }
                 }
             });
 
-            AddSliderStep("Time range", 100, 10000, 5000, v => playfields.ForEach(p => p.VisibleTimeRange.Value = v));
+            AddStep("Constant scroll", () => setScrollAlgorithm(ScrollVisualisationMethod.Constant));
+            AddStep("Overlapping scroll", () => setScrollAlgorithm(ScrollVisualisationMethod.Overlapping));
+            AddStep("Sequential scroll", () => setScrollAlgorithm(ScrollVisualisationMethod.Sequential));
+
+            AddSliderStep("Time range", 100, 10000, 5000, v => scrollContainers.ForEach(c => c.TimeRange = v));
             AddStep("Add control point", () => addControlPoint(Time.Current + 5000));
         }
 
@@ -52,7 +74,7 @@ namespace osu.Game.Tests.Visual
         {
             base.LoadComplete();
 
-            playfields.ForEach(p => p.HitObjects.AddControlPoint(new MultiplierControlPoint(0)));
+            scrollContainers.ForEach(c => c.ControlPoints.Add(new MultiplierControlPoint(0)));
 
             for (int i = 0; i <= 5000; i += 1000)
                 addHitObject(Time.Current + i);
@@ -73,12 +95,15 @@ namespace osu.Game.Tests.Visual
 
         private void addControlPoint(double time)
         {
+            scrollContainers.ForEach(c =>
+            {
+                c.ControlPoints.Add(new MultiplierControlPoint(time) { DifficultyPoint = { SpeedMultiplier = 3 } });
+                c.ControlPoints.Add(new MultiplierControlPoint(time + 2000) { DifficultyPoint = { SpeedMultiplier = 2 } });
+                c.ControlPoints.Add(new MultiplierControlPoint(time + 3000) { DifficultyPoint = { SpeedMultiplier = 1 } });
+            });
+
             playfields.ForEach(p =>
             {
-                p.HitObjects.AddControlPoint(new MultiplierControlPoint(time) { DifficultyPoint = { SpeedMultiplier = 3 } });
-                p.HitObjects.AddControlPoint(new MultiplierControlPoint(time + 2000) { DifficultyPoint = { SpeedMultiplier = 2 } });
-                p.HitObjects.AddControlPoint(new MultiplierControlPoint(time + 3000) { DifficultyPoint = { SpeedMultiplier = 1 } });
-
                 TestDrawableControlPoint createDrawablePoint(double t)
                 {
                     var obj = new TestDrawableControlPoint(p.Direction, t);
@@ -111,15 +136,14 @@ namespace osu.Game.Tests.Visual
             }
         }
 
+        private void setScrollAlgorithm(ScrollVisualisationMethod algorithm) => scrollContainers.ForEach(c => c.ScrollAlgorithm = algorithm);
 
         private class TestPlayfield : ScrollingPlayfield
         {
-            public new ScrollingDirection Direction => base.Direction;
+            public new ScrollingDirection Direction => base.Direction.Value;
 
-            public TestPlayfield(ScrollingDirection direction)
+            public TestPlayfield()
             {
-                base.Direction.Value = direction;
-
                 Padding = new MarginPadding(2);
 
                 InternalChildren = new Drawable[]

osu.Game/Rulesets/Edit/SelectionBlueprint.cs

@@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Edit
     /// <summary>
     /// A blueprint placed above a <see cref="DrawableHitObject"/> adding editing functionality.
     /// </summary>
-    public class SelectionBlueprint : CompositeDrawable, IStateful<SelectionState>
+    public abstract class SelectionBlueprint : CompositeDrawable, IStateful<SelectionState>
     {
         /// <summary>
         /// Invoked when this <see cref="SelectionBlueprint"/> has been selected.
@@ -38,7 +38,7 @@ namespace osu.Game.Rulesets.Edit
         /// <summary>
         /// Invoked when this <see cref="SelectionBlueprint"/> has requested drag.
         /// </summary>
-        public event Action<SelectionBlueprint, Vector2, InputState> DragRequested;
+        public event Action<DragEvent> DragRequested;
 
         /// <summary>
         /// The <see cref="DrawableHitObject"/> which this <see cref="SelectionBlueprint"/> applies to.
@@ -49,7 +49,7 @@ namespace osu.Game.Rulesets.Edit
         public override bool HandlePositionalInput => ShouldBeAlive;
         public override bool RemoveWhenNotAlive => false;
 
-        public SelectionBlueprint(DrawableHitObject hitObject)
+        protected SelectionBlueprint(DrawableHitObject hitObject)
         {
             HitObject = hitObject;
 
@@ -130,10 +130,12 @@ namespace osu.Game.Rulesets.Edit
 
         protected override bool OnDrag(DragEvent e)
         {
-            DragRequested?.Invoke(this, e.Delta, e.CurrentState);
+            DragRequested?.Invoke(e);
             return true;
         }
 
+        public abstract void AdjustPosition(DragEvent dragEvent);
+
         /// <summary>
         /// The screen-space point that causes this <see cref="SelectionBlueprint"/> to be selected.
         /// </summary>

osu.Game/Rulesets/Edit/Types/IHasEditablePosition.cs

@@ -1,13 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Game.Rulesets.Objects.Types;
-using OpenTK;
-
-namespace osu.Game.Rulesets.Edit.Types
-{
-    public interface IHasEditablePosition : IHasPosition
-    {
-        void OffsetPosition(Vector2 offset);
-    }
-}

osu.Game/Rulesets/UI/Scrolling/IScrollingInfo.cs

@@ -3,9 +3,9 @@
 
 using osu.Framework.Configuration;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Rulesets.UI.Scrolling.Algorithms;
 
-namespace osu.Game.Rulesets.Mania.UI
+namespace osu.Game.Rulesets.UI.Scrolling
 {
     public interface IScrollingInfo
     {
@@ -13,5 +13,15 @@ namespace osu.Game.Rulesets.Mania.UI
         /// The direction <see cref="HitObject"/>s should scroll in.
         /// </summary>
         IBindable<ScrollingDirection> Direction { get; }
+
+        /// <summary>
+        ///
+        /// </summary>
+        IBindable<double> TimeRange { get; }
+
+        /// <summary>
+        /// The algorithm which controls <see cref="HitObject"/> positions and sizes.
+        /// </summary>
+        IScrollAlgorithm Algorithm { get; }
     }
 }

osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs

@@ -1,59 +1,39 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Framework.Allocation;
 using osu.Framework.Caching;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
-using osu.Framework.Lists;
-using osu.Game.Configuration;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
-using osu.Game.Rulesets.Timing;
-using osu.Game.Rulesets.UI.Scrolling.Algorithms;
 
 namespace osu.Game.Rulesets.UI.Scrolling
 {
     public class ScrollingHitObjectContainer : HitObjectContainer
     {
-        /// <summary>
+        private readonly IBindable<double> timeRange = new BindableDouble();
-        /// The duration required to scroll through one length of the <see cref="ScrollingHitObjectContainer"/> before any control point adjustments.
-        /// </summary>
-        public readonly BindableDouble TimeRange = new BindableDouble
-        {
-            MinValue = 0,
-            MaxValue = double.MaxValue
-        };
 
-        /// <summary>
+        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
-        /// The control points that adjust the scrolling speed.
-        /// </summary>
-        protected readonly SortedList<MultiplierControlPoint> ControlPoints = new SortedList<MultiplierControlPoint>();
 
-        public readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
+        [Resolved]
-
+        private IScrollingInfo scrollingInfo { get; set; }
-        private readonly IScrollAlgorithm algorithm;
 
         private Cached initialStateCache = new Cached();
 
-        public ScrollingHitObjectContainer(ScrollVisualisationMethod visualisationMethod)
+        public ScrollingHitObjectContainer()
         {
             RelativeSizeAxes = Axes.Both;
-
-            TimeRange.ValueChanged += _ => initialStateCache.Invalidate();
-            Direction.ValueChanged += _ => initialStateCache.Invalidate();
-
-            switch (visualisationMethod)
-            {
-                case ScrollVisualisationMethod.Sequential:
-                    algorithm = new SequentialScrollAlgorithm(ControlPoints);
-                    break;
-                case ScrollVisualisationMethod.Overlapping:
-                    algorithm = new OverlappingScrollAlgorithm(ControlPoints);
-                    break;
-                case ScrollVisualisationMethod.Constant:
-                    algorithm = new ConstantScrollAlgorithm();
-                    break;
         }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            direction.BindTo(scrollingInfo.Direction);
+            timeRange.BindTo(scrollingInfo.TimeRange);
+
+            direction.ValueChanged += _ => initialStateCache.Invalidate();
+            timeRange.ValueChanged += _ => initialStateCache.Invalidate();
         }
 
         public override void Add(DrawableHitObject hitObject)
@@ -70,20 +50,6 @@ namespace osu.Game.Rulesets.UI.Scrolling
             return result;
         }
 
-        public void AddControlPoint(MultiplierControlPoint controlPoint)
-        {
-            ControlPoints.Add(controlPoint);
-            initialStateCache.Invalidate();
-        }
-
-        public bool RemoveControlPoint(MultiplierControlPoint controlPoint)
-        {
-            var result = ControlPoints.Remove(controlPoint);
-            if (result)
-                initialStateCache.Invalidate();
-            return result;
-        }
-
         public override bool Invalidate(Invalidation invalidation = Invalidation.All, Drawable source = null, bool shallPropagate = true)
         {
             if ((invalidation & (Invalidation.RequiredParentSizeToFit | Invalidation.DrawInfo)) > 0)
@@ -100,7 +66,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
 
             if (!initialStateCache.IsValid)
             {
-                switch (Direction.Value)
+                switch (direction.Value)
                 {
                     case ScrollingDirection.Up:
                     case ScrollingDirection.Down:
@@ -111,7 +77,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
                         break;
                 }
 
-                algorithm.Reset();
+                scrollingInfo.Algorithm.Reset();
 
                 foreach (var obj in Objects)
                     computeInitialStateRecursive(obj);
@@ -121,19 +87,19 @@ namespace osu.Game.Rulesets.UI.Scrolling
 
         private void computeInitialStateRecursive(DrawableHitObject hitObject)
         {
-            hitObject.LifetimeStart = algorithm.GetDisplayStartTime(hitObject.HitObject.StartTime, TimeRange);
+            hitObject.LifetimeStart = scrollingInfo.Algorithm.GetDisplayStartTime(hitObject.HitObject.StartTime, timeRange.Value);
 
             if (hitObject.HitObject is IHasEndTime endTime)
             {
-                switch (Direction.Value)
+                switch (direction.Value)
                 {
                     case ScrollingDirection.Up:
                     case ScrollingDirection.Down:
-                        hitObject.Height = algorithm.GetLength(hitObject.HitObject.StartTime, endTime.EndTime, TimeRange, scrollLength);
+                        hitObject.Height = scrollingInfo.Algorithm.GetLength(hitObject.HitObject.StartTime, endTime.EndTime, timeRange.Value, scrollLength);
                         break;
                     case ScrollingDirection.Left:
                     case ScrollingDirection.Right:
-                        hitObject.Width = algorithm.GetLength(hitObject.HitObject.StartTime, endTime.EndTime, TimeRange, scrollLength);
+                        hitObject.Width = scrollingInfo.Algorithm.GetLength(hitObject.HitObject.StartTime, endTime.EndTime, timeRange.Value, scrollLength);
                         break;
                 }
             }
@@ -158,19 +124,19 @@ namespace osu.Game.Rulesets.UI.Scrolling
 
         private void updatePosition(DrawableHitObject hitObject, double currentTime)
         {
-            switch (Direction.Value)
+            switch (direction.Value)
             {
                 case ScrollingDirection.Up:
-                    hitObject.Y = algorithm.PositionAt(hitObject.HitObject.StartTime, currentTime, TimeRange, scrollLength);
+                    hitObject.Y = scrollingInfo.Algorithm.PositionAt(hitObject.HitObject.StartTime, currentTime, timeRange.Value, scrollLength);
                     break;
                 case ScrollingDirection.Down:
-                    hitObject.Y = -algorithm.PositionAt(hitObject.HitObject.StartTime, currentTime, TimeRange, scrollLength);
+                    hitObject.Y = -scrollingInfo.Algorithm.PositionAt(hitObject.HitObject.StartTime, currentTime, timeRange.Value, scrollLength);
                     break;
                 case ScrollingDirection.Left:
-                    hitObject.X = algorithm.PositionAt(hitObject.HitObject.StartTime, currentTime, TimeRange, scrollLength);
+                    hitObject.X = scrollingInfo.Algorithm.PositionAt(hitObject.HitObject.StartTime, currentTime, timeRange.Value, scrollLength);
                     break;
                 case ScrollingDirection.Right:
-                    hitObject.X = -algorithm.PositionAt(hitObject.HitObject.StartTime, currentTime, TimeRange, scrollLength);
+                    hitObject.X = -scrollingInfo.Algorithm.PositionAt(hitObject.HitObject.StartTime, currentTime, timeRange.Value, scrollLength);
                     break;
             }
         }

osu.Game/Rulesets/UI/Scrolling/ScrollingPlayfield.cs

@@ -3,10 +3,6 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
-using osu.Framework.Graphics;
-using osu.Framework.Input.Bindings;
-using osu.Game.Configuration;
-using osu.Game.Input.Bindings;
 using osu.Game.Rulesets.Objects.Drawables;
 
 namespace osu.Game.Rulesets.UI.Scrolling
@@ -14,88 +10,19 @@ namespace osu.Game.Rulesets.UI.Scrolling
     /// <summary>
     /// A type of <see cref="Playfield"/> specialized towards scrolling <see cref="DrawableHitObject"/>s.
     /// </summary>
-    public abstract class ScrollingPlayfield : Playfield, IKeyBindingHandler<GlobalAction>
+    public abstract class ScrollingPlayfield : Playfield
     {
-        /// <summary>
+        protected readonly IBindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
-        /// The default span of time visible by the length of the scrolling axes.
-        /// This is clamped between <see cref="time_span_min"/> and <see cref="time_span_max"/>.
-        /// </summary>
-        private const double time_span_default = 1500;
 
-        /// <summary>
+        [Resolved]
-        /// The minimum span of time that may be visible by the length of the scrolling axes.
+        private IScrollingInfo scrollingInfo { get; set; }
-        /// </summary>
-        private const double time_span_min = 50;
-
-        /// <summary>
-        /// The maximum span of time that may be visible by the length of the scrolling axes.
-        /// </summary>
-        private const double time_span_max = 10000;
-
-        /// <summary>
-        /// The step increase/decrease of the span of time visible by the length of the scrolling axes.
-        /// </summary>
-        private const double time_span_step = 200;
-
-        /// <summary>
-        /// The span of time that is visible by the length of the scrolling axes.
-        /// For example, only hit objects with start time less than or equal to 1000 will be visible with <see cref="VisibleTimeRange"/> = 1000.
-        /// </summary>
-        public readonly BindableDouble VisibleTimeRange = new BindableDouble(time_span_default)
-        {
-            Default = time_span_default,
-            MinValue = time_span_min,
-            MaxValue = time_span_max
-        };
-
-        /// <summary>
-        /// Whether the player can change <see cref="VisibleTimeRange"/>.
-        /// </summary>
-        protected virtual bool UserScrollSpeedAdjustment => true;
-
-        /// <summary>
-        /// The container that contains the <see cref="DrawableHitObject"/>s.
-        /// </summary>
-        public new ScrollingHitObjectContainer HitObjects => (ScrollingHitObjectContainer)HitObjectContainer;
-
-        /// <summary>
-        /// The direction in which <see cref="DrawableHitObject"/>s in this <see cref="ScrollingPlayfield"/> should scroll.
-        /// </summary>
-        protected readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
-
-        protected virtual ScrollVisualisationMethod VisualisationMethod => ScrollVisualisationMethod.Sequential;
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            HitObjects.TimeRange.BindTo(VisibleTimeRange);
+            Direction.BindTo(scrollingInfo.Direction);
         }
 
-        public bool OnPressed(GlobalAction action)
+        protected sealed override HitObjectContainer CreateHitObjectContainer() => new ScrollingHitObjectContainer();
-        {
-            if (!UserScrollSpeedAdjustment)
-                return false;
-
-            switch (action)
-            {
-                case GlobalAction.IncreaseScrollSpeed:
-                    this.TransformBindableTo(VisibleTimeRange, VisibleTimeRange - time_span_step, 200, Easing.OutQuint);
-                    return true;
-                case GlobalAction.DecreaseScrollSpeed:
-                    this.TransformBindableTo(VisibleTimeRange, VisibleTimeRange + time_span_step, 200, Easing.OutQuint);
-                    return true;
-            }
-
-            return false;
-        }
-
-        public bool OnReleased(GlobalAction action) => false;
-
-        protected sealed override HitObjectContainer CreateHitObjectContainer()
-        {
-            var container = new ScrollingHitObjectContainer(VisualisationMethod);
-            container.Direction.BindTo(Direction);
-            return container;
-        }
     }
 }

osu.Game/Rulesets/UI/Scrolling/ScrollingRulesetContainer.cs

@@ -4,13 +4,18 @@
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
-using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics;
+using osu.Framework.Input.Bindings;
 using osu.Framework.Lists;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Configuration;
+using osu.Game.Input.Bindings;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Timing;
+using osu.Game.Rulesets.UI.Scrolling.Algorithms;
 
 namespace osu.Game.Rulesets.UI.Scrolling
 {
@@ -18,20 +23,82 @@ namespace osu.Game.Rulesets.UI.Scrolling
     /// A type of <see cref="RulesetContainer{TPlayfield,TObject}"/> that supports a <see cref="ScrollingPlayfield"/>.
     /// <see cref="HitObject"/>s inside this <see cref="RulesetContainer{TPlayfield,TObject}"/> will scroll within the playfield.
     /// </summary>
-    public abstract class ScrollingRulesetContainer<TPlayfield, TObject> : RulesetContainer<TPlayfield, TObject>
+    public abstract class ScrollingRulesetContainer<TPlayfield, TObject> : RulesetContainer<TPlayfield, TObject>, IKeyBindingHandler<GlobalAction>
         where TObject : HitObject
         where TPlayfield : ScrollingPlayfield
     {
+        /// <summary>
+        /// The default span of time visible by the length of the scrolling axes.
+        /// This is clamped between <see cref="time_span_min"/> and <see cref="time_span_max"/>.
+        /// </summary>
+        private const double time_span_default = 1500;
+
+        /// <summary>
+        /// The minimum span of time that may be visible by the length of the scrolling axes.
+        /// </summary>
+        private const double time_span_min = 50;
+
+        /// <summary>
+        /// The maximum span of time that may be visible by the length of the scrolling axes.
+        /// </summary>
+        private const double time_span_max = 10000;
+
+        /// <summary>
+        /// The step increase/decrease of the span of time visible by the length of the scrolling axes.
+        /// </summary>
+        private const double time_span_step = 200;
+
+        protected readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
+
+        /// <summary>
+        /// The span of time that is visible by the length of the scrolling axes.
+        /// For example, only hit objects with start time less than or equal to 1000 will be visible with <see cref="TimeRange"/> = 1000.
+        /// </summary>
+        protected readonly BindableDouble TimeRange = new BindableDouble(time_span_default)
+        {
+            Default = time_span_default,
+            MinValue = time_span_min,
+            MaxValue = time_span_max
+        };
+
+        protected virtual ScrollVisualisationMethod VisualisationMethod => ScrollVisualisationMethod.Sequential;
+
+        /// <summary>
+        /// Whether the player can change <see cref="VisibleTimeRange"/>.
+        /// </summary>
+        protected virtual bool UserScrollSpeedAdjustment => true;
+
         /// <summary>
         /// Provides the default <see cref="MultiplierControlPoint"/>s that adjust the scrolling rate of <see cref="HitObject"/>s
         /// inside this <see cref="RulesetContainer{TPlayfield,TObject}"/>.
         /// </summary>
         /// <returns></returns>
-        protected readonly SortedList<MultiplierControlPoint> DefaultControlPoints = new SortedList<MultiplierControlPoint>(Comparer<MultiplierControlPoint>.Default);
+        private readonly SortedList<MultiplierControlPoint> controlPoints = new SortedList<MultiplierControlPoint>(Comparer<MultiplierControlPoint>.Default);
+
+        protected IScrollingInfo ScrollingInfo => scrollingInfo;
+
+        [Cached(Type = typeof(IScrollingInfo))]
+        private readonly LocalScrollingInfo scrollingInfo;
 
         protected ScrollingRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
+            scrollingInfo = new LocalScrollingInfo();
+            scrollingInfo.Direction.BindTo(Direction);
+            scrollingInfo.TimeRange.BindTo(TimeRange);
+
+            switch (VisualisationMethod)
+            {
+                case ScrollVisualisationMethod.Sequential:
+                    scrollingInfo.Algorithm = new SequentialScrollAlgorithm(controlPoints);
+                    break;
+                case ScrollVisualisationMethod.Overlapping:
+                    scrollingInfo.Algorithm = new OverlappingScrollAlgorithm(controlPoints);
+                    break;
+                case ScrollVisualisationMethod.Constant:
+                    scrollingInfo.Algorithm = new ConstantScrollAlgorithm();
+                    break;
+            }
         }
 
         [BackgroundDependencyLoader]
@@ -75,19 +142,40 @@ namespace osu.Game.Rulesets.UI.Scrolling
                             // Collapse sections with the same start time
                             .GroupBy(s => s.StartTime).Select(g => g.Last()).OrderBy(s => s.StartTime);
 
-            DefaultControlPoints.AddRange(timingChanges);
+            controlPoints.AddRange(timingChanges);
 
             // If we have no control points, add a default one
-            if (DefaultControlPoints.Count == 0)
+            if (controlPoints.Count == 0)
-                DefaultControlPoints.Add(new MultiplierControlPoint { Velocity = Beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier });
+                controlPoints.Add(new MultiplierControlPoint { Velocity = Beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier });
-
-            DefaultControlPoints.ForEach(c => applySpeedAdjustment(c, Playfield));
         }
 
-        private void applySpeedAdjustment(MultiplierControlPoint controlPoint, ScrollingPlayfield playfield)
+        public bool OnPressed(GlobalAction action)
         {
-            playfield.HitObjects.AddControlPoint(controlPoint);
+            if (!UserScrollSpeedAdjustment)
-            playfield.NestedPlayfields?.OfType<ScrollingPlayfield>().ForEach(p => applySpeedAdjustment(controlPoint, p));
+                return false;
+
+            switch (action)
+            {
+                case GlobalAction.IncreaseScrollSpeed:
+                    this.TransformBindableTo(TimeRange, TimeRange - time_span_step, 200, Easing.OutQuint);
+                    return true;
+                case GlobalAction.DecreaseScrollSpeed:
+                    this.TransformBindableTo(TimeRange, TimeRange + time_span_step, 200, Easing.OutQuint);
+                    return true;
+            }
+
+            return false;
+        }
+
+        public bool OnReleased(GlobalAction action) => false;
+
+        private class LocalScrollingInfo : IScrollingInfo
+        {
+            public IBindable<ScrollingDirection> Direction { get; } = new Bindable<ScrollingDirection>();
+
+            public IBindable<double> TimeRange { get; } = new BindableDouble();
+
+            public IScrollAlgorithm Algorithm { get; set; }
         }
     }
 }

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

@@ -12,7 +12,6 @@ using osu.Framework.Input.States;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Objects.Drawables;
-using OpenTK;
 
 namespace osu.Game.Screens.Edit.Compose.Components
 {
@@ -165,7 +164,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         private void onSelectionRequested(SelectionBlueprint blueprint, InputState state) => selectionBox.HandleSelectionRequested(blueprint, state);
 
-        private void onDragRequested(SelectionBlueprint blueprint, Vector2 delta, InputState state) => selectionBox.HandleDrag(blueprint, delta, state);
+        private void onDragRequested(DragEvent dragEvent) => selectionBox.HandleDrag(dragEvent);
 
         private class SelectionBlueprintContainer : Container<SelectionBlueprint>
         {

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

@@ -12,7 +12,6 @@ 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;
 
@@ -60,19 +59,12 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         #region User Input Handling
 
-        public void HandleDrag(SelectionBlueprint m, Vector2 delta, InputState state)
+        public void HandleDrag(DragEvent dragEvent)
         {
             // Todo: Various forms of snapping
 
             foreach (var blueprint in selectedBlueprints)
-            {
+                blueprint.AdjustPosition(dragEvent);
-                switch (blueprint.HitObject.HitObject)
-                {
-                    case IHasEditablePosition editablePosition:
-                        editablePosition.OffsetPosition(delta);
-                        break;
-                }
-            }
         }
 
         protected override bool OnKeyDown(KeyDownEvent e)

osu.Game/Tests/Visual/ScrollingTestContainer.cs

@@ -0,0 +1,92 @@
+// 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.Framework.Lists;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Timing;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Rulesets.UI.Scrolling.Algorithms;
+
+namespace osu.Game.Tests.Visual
+{
+    /// <summary>
+    /// A container which provides a <see cref="IScrollingInfo"/> to children.
+    /// This should only be used when testing
+    /// </summary>
+    public class ScrollingTestContainer : Container
+    {
+        public SortedList<MultiplierControlPoint> ControlPoints => scrollingInfo.Algorithm.ControlPoints;
+
+        public ScrollVisualisationMethod ScrollAlgorithm { set => scrollingInfo.Algorithm.Algorithm = value; }
+
+        public double TimeRange { set => scrollingInfo.TimeRange.Value = value; }
+
+        [Cached(Type = typeof(IScrollingInfo))]
+        private readonly TestScrollingInfo scrollingInfo = new TestScrollingInfo();
+
+        public ScrollingTestContainer(ScrollingDirection direction)
+        {
+            scrollingInfo.Direction.Value = direction;
+        }
+
+        public void Flip() => scrollingInfo.Direction.Value = scrollingInfo.Direction.Value == ScrollingDirection.Up ? ScrollingDirection.Down : ScrollingDirection.Up;
+
+        private class TestScrollingInfo : IScrollingInfo
+        {
+            public readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
+            IBindable<ScrollingDirection> IScrollingInfo.Direction => Direction;
+
+            public readonly Bindable<double> TimeRange = new Bindable<double>(1000) { Value = 1000 };
+            IBindable<double> IScrollingInfo.TimeRange => TimeRange;
+
+            public readonly TestScrollAlgorithm Algorithm = new TestScrollAlgorithm();
+            IScrollAlgorithm IScrollingInfo.Algorithm => Algorithm;
+        }
+
+        private class TestScrollAlgorithm : IScrollAlgorithm
+        {
+            public readonly SortedList<MultiplierControlPoint> ControlPoints = new SortedList<MultiplierControlPoint>();
+
+            private IScrollAlgorithm implementation;
+
+            public TestScrollAlgorithm()
+            {
+                Algorithm = ScrollVisualisationMethod.Constant;
+            }
+
+            public ScrollVisualisationMethod Algorithm
+            {
+                set
+                {
+                    switch (value)
+                    {
+                        case ScrollVisualisationMethod.Constant:
+                            implementation = new ConstantScrollAlgorithm();
+                            break;
+                        case ScrollVisualisationMethod.Overlapping:
+                            implementation = new OverlappingScrollAlgorithm(ControlPoints);
+                            break;
+                        case ScrollVisualisationMethod.Sequential:
+                            implementation = new SequentialScrollAlgorithm(ControlPoints);
+                            break;
+                    }
+                }
+            }
+
+            public double GetDisplayStartTime(double time, double timeRange)
+                => implementation.GetDisplayStartTime(time, timeRange);
+
+            public float GetLength(double startTime, double endTime, double timeRange, float scrollLength)
+                => implementation.GetLength(startTime, endTime, timeRange, scrollLength);
+
+            public float PositionAt(double time, double currentTime, double timeRange, float scrollLength)
+                => implementation.PositionAt(time, currentTime, timeRange, scrollLength);
+
+            public void Reset()
+                => implementation.Reset();
+        }
+    }
+}

osu.Game/Tests/Visual/SelectionBlueprintTestCase.cs

@@ -29,9 +29,12 @@ namespace osu.Game.Tests.Visual
         [BackgroundDependencyLoader]
         private void load()
         {
-            base.Content.Add(blueprint = CreateBlueprint());
+            blueprint = CreateBlueprint();
+            blueprint.Depth = float.MinValue;
             blueprint.SelectionRequested += (_, __) => blueprint.Select();
 
+            Add(blueprint);
+
             AddStep("Select", () => blueprint.Select());
             AddStep("Deselect", () => blueprint.Deselect());
         }