diff --git a/osu.Game.Rulesets.Mania/UI/Column.cs b/osu.Game.Rulesets.Mania/UI/Column.cs
index be31954099..511d6c8623 100644
--- a/osu.Game.Rulesets.Mania/UI/Column.cs
+++ b/osu.Game.Rulesets.Mania/UI/Column.cs
@@ -17,7 +17,6 @@ using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
 using osuTK;
 using osu.Game.Rulesets.Mania.Beatmaps;
-using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
@@ -143,54 +142,5 @@ 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(Stage.COLUMN_SPACING / 2, 0)).Contains(ToLocalSpace(screenSpacePos));
-
-        /// <summary>
-        /// Given a time, return the screen space position within this column.
-        /// </summary>
-        public Vector2 ScreenSpacePositionAtTime(double time)
-        {
-            var pos = ScrollingInfo.Algorithm.PositionAt(time, Time.Current, ScrollingInfo.TimeRange.Value, HitObjectContainer.DrawHeight);
-
-            switch (ScrollingInfo.Direction.Value)
-            {
-                case ScrollingDirection.Down:
-                    // We're dealing with screen coordinates in which the position decreases towards the centre of the screen resulting in an increase in start time.
-                    // The scrolling algorithm instead assumes a top anchor meaning an increase in time corresponds to an increase in position,
-                    // so when scrolling downwards the coordinates need to be flipped.
-                    pos = HitObjectContainer.DrawHeight - pos;
-
-                    // Blueprints are centred on the mouse position, such that the hitobject position is anchored at the top or bottom of the blueprint depending on the scroll direction.
-                    pos -= DefaultNotePiece.NOTE_HEIGHT / 2;
-                    break;
-
-                case ScrollingDirection.Up:
-                    pos += DefaultNotePiece.NOTE_HEIGHT / 2;
-                    break;
-            }
-
-            return HitObjectContainer.ToScreenSpace(new Vector2(HitObjectContainer.DrawWidth / 2, pos));
-        }
-
-        /// <summary>
-        /// Given a position in screen space, return the time within this column.
-        /// </summary>
-        public double TimeAtScreenSpacePosition(Vector2 screenSpacePosition)
-        {
-            // convert to local space of column so we can snap and fetch correct location.
-            Vector2 localPosition = HitObjectContainer.ToLocalSpace(screenSpacePosition);
-
-            switch (ScrollingInfo.Direction.Value)
-            {
-                case ScrollingDirection.Down:
-                    // as above
-                    localPosition.Y = HitObjectContainer.DrawHeight - localPosition.Y;
-                    break;
-            }
-
-            // offset for the fact that blueprints are centered, as above.
-            localPosition.Y -= DefaultNotePiece.NOTE_HEIGHT / 2;
-
-            return ScrollingInfo.Algorithm.TimeAt(localPosition.Y, Time.Current, ScrollingInfo.TimeRange.Value, HitObjectContainer.DrawHeight);
-        }
     }
 }
diff --git a/osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs b/osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs
index 15e625872d..4ef2c04f23 100644
--- a/osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs
+++ b/osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs
@@ -9,6 +9,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Layout;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
+using osuTK;
 
 namespace osu.Game.Rulesets.UI.Scrolling
 {
@@ -78,6 +79,92 @@ namespace osu.Game.Rulesets.UI.Scrolling
             hitObjectInitialStateCache.Clear();
         }
 
+        public double TimeAtScreenSpace(Vector2 screenSpacePosition)
+        {
+            // convert to local space of column so we can snap and fetch correct location.
+            Vector2 localPosition = ToLocalSpace(screenSpacePosition);
+
+            float position = 0;
+
+            switch (scrollingInfo.Direction.Value)
+            {
+                case ScrollingDirection.Up:
+                case ScrollingDirection.Down:
+                    position = localPosition.Y;
+                    break;
+
+                case ScrollingDirection.Right:
+                case ScrollingDirection.Left:
+                    position = localPosition.X;
+                    break;
+            }
+
+            flipPositionIfRequired(ref position);
+
+            return scrollingInfo.Algorithm.TimeAt(position, Time.Current, scrollingInfo.TimeRange.Value, getLength());
+        }
+
+        public Vector2 ScreenSpacePositionAtTime(double time)
+        {
+            var pos = scrollingInfo.Algorithm.PositionAt(time, Time.Current, scrollingInfo.TimeRange.Value, getLength());
+
+            flipPositionIfRequired(ref pos);
+
+            switch (scrollingInfo.Direction.Value)
+            {
+                case ScrollingDirection.Up:
+                case ScrollingDirection.Down:
+                    return ToScreenSpace(new Vector2(getBredth() / 2, pos));
+
+                default:
+                    return ToScreenSpace(new Vector2(pos, getBredth() / 2));
+            }
+        }
+
+        private float getLength()
+        {
+            switch (scrollingInfo.Direction.Value)
+            {
+                case ScrollingDirection.Left:
+                case ScrollingDirection.Right:
+                    return DrawWidth;
+
+                default:
+                    return DrawHeight;
+            }
+        }
+
+        private float getBredth()
+        {
+            switch (scrollingInfo.Direction.Value)
+            {
+                case ScrollingDirection.Up:
+                case ScrollingDirection.Down:
+                    return DrawWidth;
+
+                default:
+                    return DrawHeight;
+            }
+        }
+
+        private void flipPositionIfRequired(ref float position)
+        {
+            // We're dealing with screen coordinates in which the position decreases towards the centre of the screen resulting in an increase in start time.
+            // The scrolling algorithm instead assumes a top anchor meaning an increase in time corresponds to an increase in position,
+            // so when scrolling downwards the coordinates need to be flipped.
+
+            switch (scrollingInfo.Direction.Value)
+            {
+                case ScrollingDirection.Down:
+                    position = DrawHeight - position;
+                    break;
+
+                case ScrollingDirection.Right:
+                    position = DrawWidth - position;
+                    break;
+            }
+        }
+
         private void onDefaultsApplied(DrawableHitObject drawableObject)
         {
             // The cache may not exist if the hitobject state hasn't been computed yet (e.g. if the hitobject was added + defaults applied in the same frame).
diff --git a/osu.Game/Rulesets/UI/Scrolling/ScrollingPlayfield.cs b/osu.Game/Rulesets/UI/Scrolling/ScrollingPlayfield.cs
index fd143a3687..1ccde9b1e3 100644
--- a/osu.Game/Rulesets/UI/Scrolling/ScrollingPlayfield.cs
+++ b/osu.Game/Rulesets/UI/Scrolling/ScrollingPlayfield.cs
@@ -4,6 +4,7 @@
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Game.Rulesets.Objects.Drawables;
+using osuTK;
 
 namespace osu.Game.Rulesets.UI.Scrolling
 {
@@ -23,6 +24,18 @@ namespace osu.Game.Rulesets.UI.Scrolling
             Direction.BindTo(ScrollingInfo.Direction);
         }
 
+        /// <summary>
+        /// Given a position in screen space, return the time within this column.
+        /// </summary>
+        public virtual double TimeAtScreenSpacePosition(Vector2 screenSpacePosition) =>
+            ((ScrollingHitObjectContainer)HitObjectContainer).TimeAtScreenSpace(screenSpacePosition);
+
+        /// <summary>
+        /// Given a time, return the screen space position within this column.
+        /// </summary>
+        public virtual Vector2 ScreenSpacePositionAtTime(double time)
+            => ((ScrollingHitObjectContainer)HitObjectContainer).ScreenSpacePositionAtTime(time);
+
         protected sealed override HitObjectContainer CreateHitObjectContainer() => new ScrollingHitObjectContainer();
     }
 }