Initial conversion of taiko to use ScrollingPlayfield.

osu.Desktop.Tests/Visual/TestCaseTaikoPlayfield.cs

@@ -151,13 +151,9 @@ namespace osu.Desktop.Tests.Visual
 
         private void addBarLine(bool major, double delay = scroll_time)
         {
-            BarLine bl = new BarLine
+            BarLine bl = new BarLine { StartTime = playfield.Time.Current + delay };
-            {
-                StartTime = playfield.Time.Current + delay,
-                ScrollTime = scroll_time
-            };
 
-            playfield.AddBarLine(major ? new DrawableBarLineMajor(bl) : new DrawableBarLine(bl));
+            playfield.Add(major ? new DrawableBarLineMajor(bl) : new DrawableBarLine(bl));
         }
 
         private void addSwell(double duration = default_duration)
@@ -166,7 +162,6 @@ namespace osu.Desktop.Tests.Visual
             {
                 StartTime = playfield.Time.Current + scroll_time,
                 Duration = duration,
-                ScrollTime = scroll_time
             }));
         }
 
@@ -180,7 +175,6 @@ namespace osu.Desktop.Tests.Visual
                 StartTime = playfield.Time.Current + scroll_time,
                 IsStrong = strong,
                 Duration = duration,
-                ScrollTime = scroll_time,
             };
 
             playfield.Add(new DrawableDrumRoll(d));
@@ -191,7 +185,6 @@ namespace osu.Desktop.Tests.Visual
             Hit h = new Hit
             {
                 StartTime = playfield.Time.Current + scroll_time,
-                ScrollTime = scroll_time,
                 IsStrong = strong
             };
 
@@ -206,7 +199,6 @@ namespace osu.Desktop.Tests.Visual
             Hit h = new Hit
             {
                 StartTime = playfield.Time.Current + scroll_time,
-                ScrollTime = scroll_time,
                 IsStrong = strong
             };
 

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

@@ -5,13 +5,16 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using OpenTK;
+using osu.Game.Rulesets.Objects.Drawables;
+using System;
+using osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
     /// <summary>
     /// A line that scrolls alongside hit objects in the playfield and visualises control points.
     /// </summary>
-    public class DrawableBarLine : Container
+    public class DrawableBarLine : DrawableTaikoHitObject<BarLine>
     {
         /// <summary>
         /// The width of the line tracker.
@@ -34,15 +37,11 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         protected readonly BarLine BarLine;
 
         public DrawableBarLine(BarLine barLine)
+            : base(barLine)
         {
             BarLine = barLine;
 
-            Anchor = Anchor.CentreLeft;
-            Origin = Anchor.Centre;
-
-            RelativePositionAxes = Axes.X;
             RelativeSizeAxes = Axes.Y;
-
             Width = tracker_width;
 
             Children = new[]
@@ -56,24 +55,12 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                     Alpha = 0.75f
                 }
             };
-
-            LifetimeStart = BarLine.StartTime - BarLine.ScrollTime * 2;
-            LifetimeEnd = BarLine.StartTime + BarLine.ScrollTime;
         }
 
-        protected override void LoadComplete()
+        protected override TaikoPiece CreateMainPiece() => new TaikoPiece();
+
+        protected override void UpdateState(ArmedState state)
         {
-            base.LoadComplete();
-            this.Delay(BarLine.StartTime - Time.Current).FadeOut(base_fadeout_time * BarLine.ScrollTime / 1000);
-        }
-
-        private void updateScrollPosition(double time) => this.MoveToX((float)((BarLine.StartTime - time) / BarLine.ScrollTime));
-
-        protected override void Update()
-        {
-            base.Update();
-
-            updateScrollPosition(Time.Current);
         }
     }
 }

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableDrumRoll.cs

@@ -11,6 +11,7 @@ using OpenTK;
 using OpenTK.Graphics;
 using osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
@@ -34,27 +35,29 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             RelativeSizeAxes = Axes.Y;
             AutoSizeAxes = Axes.X;
 
+            Width = (float)HitObject.Duration;
+
+            Container<DrawableDrumRollTick> tickContainer;
+            MainPiece.Add(tickContainer = new Container<DrawableDrumRollTick>
+            {
+                RelativeSizeAxes = Axes.Both,
+                RelativeChildOffset = new Vector2((float)HitObject.StartTime, 0),
+                RelativeChildSize = new Vector2((float)HitObject.Duration, 1)
+            });
+
             foreach (var tick in drumRoll.Ticks)
             {
-                var newTick = new DrawableDrumRollTick(tick)
+                var newTick = new DrawableDrumRollTick(tick) { X = (float)tick.StartTime };
-                {
-                    X = (float)((tick.StartTime - HitObject.StartTime) / HitObject.Duration)
-                };
-
                 newTick.OnJudgement += onTickJudgement;
 
                 AddNested(newTick);
-                MainPiece.Add(newTick);
+                tickContainer.Add(newTick);
             }
         }
 
         protected override TaikoJudgement CreateJudgement() => new TaikoJudgement { SecondHit = HitObject.IsStrong };
 
-        protected override TaikoPiece CreateMainPiece() => new ElongatedCirclePiece
+        protected override TaikoPiece CreateMainPiece() => new ElongatedCirclePiece();
-        {
-            Length = (float)(HitObject.Duration / HitObject.ScrollTime),
-            PlayfieldLengthReference = () => Parent.DrawSize.X
-        };
 
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
@@ -63,17 +66,6 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             accentDarkColour = colours.YellowDarker;
         }
 
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            // This is naive, however it's based on the reasoning that the hit target
-            // is further than mid point of the play field, so the time taken to scroll in should always
-            // be greater than the time taken to scroll out to the left of the screen.
-            // Thus, using PreEmpt here is enough for the drum roll to completely scroll out.
-            LifetimeEnd = HitObject.EndTime + HitObject.ScrollTime;
-        }
-
         private void onTickJudgement(DrawableHitObject<TaikoHitObject, TaikoJudgement> obj)
         {
             if (obj.Judgement.Result == HitResult.Hit)

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableDrumRollTick.cs

@@ -47,11 +47,6 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             }
         }
 
-        protected override void UpdateScrollPosition(double time)
-        {
-            // Ticks don't move
-        }
-
         protected override bool HandleKeyPress(Key key)
         {
             return Judgement.Result == HitResult.None && UpdateJudgement(true);

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwell.cs

@@ -118,7 +118,6 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             });
 
             MainPiece.Add(symbol = new SwellSymbolPiece());
-
         }
 
         [BackgroundDependencyLoader]
@@ -189,20 +188,22 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             Expire();
         }
 
-        protected override void UpdateScrollPosition(double time)
+        protected override void Update()
         {
-            // Make the swell stop at the hit target
+            base.Update();
-            double t = Math.Min(HitObject.StartTime, time);
 
+            // Make the swell stop at the hit target
+            X = (float)Math.Max(Time.Current, HitObject.StartTime);
+
+            double t = Math.Min(HitObject.StartTime, Time.Current);
             if (t == HitObject.StartTime && !hasStarted)
             {
                 OnStart?.Invoke();
                 hasStarted = true;
             }
-
-            base.UpdateScrollPosition(t);
         }
 
+
         protected override bool HandleKeyPress(Key key)
         {
             if (Judgement.Result != HitResult.None)

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs

@@ -12,7 +12,7 @@ using OpenTK.Input;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
-    public abstract class DrawableTaikoHitObject<TaikoHitType> : DrawableHitObject<TaikoHitObject, TaikoJudgement>
+    public abstract class DrawableTaikoHitObject<TaikoHitType> : DrawableScrollingHitObject<TaikoHitObject, TaikoJudgement>
         where TaikoHitType : TaikoHitObject
     {
         /// <summary>
@@ -38,30 +38,14 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             RelativeSizeAxes = Axes.Both;
             Size = new Vector2(HitObject.IsStrong ? TaikoHitObject.DEFAULT_STRONG_SIZE : TaikoHitObject.DEFAULT_SIZE);
 
-            RelativePositionAxes = Axes.X;
-
             Add(MainPiece = CreateMainPiece());
             MainPiece.KiaiMode = HitObject.Kiai;
-
-            LifetimeStart = HitObject.StartTime - HitObject.ScrollTime * 2;
         }
 
         protected override TaikoJudgement CreateJudgement() => new TaikoJudgement();
 
         protected virtual TaikoPiece CreateMainPiece() => new CirclePiece();
 
-        /// <summary>
-        /// Sets the scroll position of the DrawableHitObject relative to the offset between
-        /// a time value and the HitObject's StartTime.
-        /// </summary>
-        /// <param name="time"></param>
-        protected virtual void UpdateScrollPosition(double time) => X = (float)((HitObject.StartTime - time) / HitObject.ScrollTime);
-
-        protected override void Update()
-        {
-            UpdateScrollPosition(Time.Current);
-        }
-
         protected virtual bool HandleKeyPress(Key key) => false;
 
         protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)

osu.Game.Rulesets.Taiko/Objects/Drawables/Pieces/ElongatedCirclePiece.cs

@@ -8,16 +8,6 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces
 {
     public class ElongatedCirclePiece : CirclePiece
     {
-        /// <summary>
-        /// As we are being used to define the absolute size of hits, we need to be given a relative reference of our containing playfield container.
-        /// </summary>
-        public Func<float> PlayfieldLengthReference;
-
-        /// <summary>
-        /// The length of this piece as a multiple of the value returned by <see cref="PlayfieldLengthReference"/>
-        /// </summary>
-        public float Length;
-
         public ElongatedCirclePiece()
         {
             RelativeSizeAxes = Axes.Y;
@@ -35,7 +25,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces
                 Right = padding,
             };
 
-            Width = (PlayfieldLengthReference?.Invoke() ?? 0) * Length + DrawHeight;
+            Width = Parent.DrawSize.X + DrawHeight;
         }
     }
 }

osu.Game.Rulesets.Taiko/Objects/DrumRoll.cs

@@ -80,7 +80,6 @@ namespace osu.Game.Rulesets.Taiko.Objects
                 ret.Add(new DrumRollTick
                 {
                     FirstTick = first,
-                    ScrollTime = ScrollTime,
                     TickSpacing = tickSpacing,
                     StartTime = t,
                     IsStrong = IsStrong,

osu.Game.Rulesets.Taiko/Objects/TaikoHitObject.cs

@@ -24,16 +24,6 @@ namespace osu.Game.Rulesets.Taiko.Objects
         /// </summary>
         public const float DEFAULT_STRONG_SIZE = DEFAULT_SIZE * STRONG_SCALE;
 
-        /// <summary>
-        /// The time taken from the initial (off-screen) spawn position to the centre of the hit target for a <see cref="TimingControlPoint.BeatLength"/> of 1000ms.
-        /// </summary>
-        private const double scroll_time = 6000;
-
-        /// <summary>
-        /// Our adjusted <see cref="scroll_time"/> taking into consideration local <see cref="TimingControlPoint.BeatLength"/> and other speed multipliers.
-        /// </summary>
-        public double ScrollTime;
-
         /// <summary>
         /// Whether this HitObject is a "strong" type.
         /// Strong hit objects give more points for hitting the hit object with both keys.
@@ -49,12 +39,8 @@ namespace osu.Game.Rulesets.Taiko.Objects
         {
             base.ApplyDefaults(controlPointInfo, difficulty);
 
-            TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
-            DifficultyControlPoint difficultyPoint = controlPointInfo.DifficultyPointAt(StartTime);
             EffectControlPoint effectPoint = controlPointInfo.EffectPointAt(StartTime);
 
-            ScrollTime = scroll_time * (timingPoint.BeatLength * difficultyPoint.SpeedMultiplier / 1000) / difficulty.SliderMultiplier;
-
             Kiai |= effectPoint.KiaiMode;
         }
     }

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

@@ -21,7 +21,7 @@ using System.Linq;
 
 namespace osu.Game.Rulesets.Taiko.UI
 {
-    public class TaikoHitRenderer : HitRenderer<TaikoHitObject, TaikoJudgement>
+    public class TaikoHitRenderer : ScrollingHitRenderer<TaikoPlayfield, TaikoHitObject, TaikoJudgement>
     {
         public TaikoHitRenderer(WorkingBeatmap beatmap, bool isForCurrentRuleset)
             : base(beatmap, isForCurrentRuleset)
@@ -72,7 +72,7 @@ namespace osu.Game.Rulesets.Taiko.UI
                 barLine.ApplyDefaults(Beatmap.ControlPointInfo, Beatmap.BeatmapInfo.Difficulty);
 
                 bool isMajor = currentBeat % (int)currentPoint.TimeSignature == 0;
-                taikoPlayfield.AddBarLine(isMajor ? new DrawableBarLineMajor(barLine) : new DrawableBarLine(barLine));
+                taikoPlayfield.Add(isMajor ? new DrawableBarLineMajor(barLine) : new DrawableBarLine(barLine));
 
                 double bl = currentPoint.BeatLength;
                 if (bl < 800)

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

@@ -18,7 +18,7 @@ using osu.Game.Rulesets.Taiko.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Taiko.UI
 {
-    public class TaikoPlayfield : Playfield<TaikoHitObject, TaikoJudgement>
+    public class TaikoPlayfield : ScrollingPlayfield<TaikoHitObject, TaikoJudgement>
     {
         /// <summary>
         /// Default height of a <see cref="TaikoPlayfield"/> when inside a <see cref="TaikoHitRenderer"/>.
@@ -35,14 +35,14 @@ namespace osu.Game.Rulesets.Taiko.UI
         /// </summary>
         private const float left_area_size = 240;
 
-        protected override Container<Drawable> Content => hitObjectContainer;
 
         private readonly Container<HitExplosion> hitExplosionContainer;
         private readonly Container<KiaiHitExplosion> kiaiExplosionContainer;
-        private readonly Container<DrawableBarLine> barLineContainer;
         private readonly Container<DrawableTaikoJudgement> judgementContainer;
 
-        private readonly Container hitObjectContainer;
+        protected override Container<Drawable> Content => content;
+        private readonly Container content;
+
         private readonly Container topLevelHitContainer;
 
         private readonly Container overlayBackgroundContainer;
@@ -52,6 +52,7 @@ namespace osu.Game.Rulesets.Taiko.UI
         private readonly Box background;
 
         public TaikoPlayfield()
+            : base(Axes.X)
         {
             AddRangeInternal(new Drawable[]
             {
@@ -96,10 +97,6 @@ namespace osu.Game.Rulesets.Taiko.UI
                                     FillMode = FillMode.Fit,
                                     BlendingMode = BlendingMode.Additive,
                                 },
-                                barLineContainer = new Container<DrawableBarLine>
-                                {
-                                    RelativeSizeAxes = Axes.Both,
-                                },
                                 new HitTarget
                                 {
                                     Anchor = Anchor.CentreLeft,
@@ -107,7 +104,7 @@ namespace osu.Game.Rulesets.Taiko.UI
                                     RelativeSizeAxes = Axes.Both,
                                     FillMode = FillMode.Fit
                                 },
-                                hitObjectContainer = new Container
+                                content = new Container
                                 {
                                     RelativeSizeAxes = Axes.Both,
                                 },
@@ -205,11 +202,6 @@ namespace osu.Game.Rulesets.Taiko.UI
                 swell.OnStart += () => topLevelHitContainer.Add(swell.CreateProxy());
         }
 
-        public void AddBarLine(DrawableBarLine barLine)
-        {
-            barLineContainer.Add(barLine);
-        }
-
         public override void OnJudgement(DrawableHitObject<TaikoHitObject, TaikoJudgement> judgedObject)
         {
             bool wasHit = judgedObject.Judgement.Result == HitResult.Hit;