Merge pull request #8920 from peppy/taiko-scroller

Add taiko scroller

osu.Game.Rulesets.Taiko.Tests/Skinning/TestSceneTaikoPlayfield.cs

@@ -24,6 +24,7 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
             typeof(TaikoHitTarget),
             typeof(TaikoLegacyHitTarget),
             typeof(PlayfieldBackgroundRight),
+            typeof(LegacyTaikoScroller),
         }).ToList();
 
         [Cached(typeof(IScrollingInfo))]
@@ -51,6 +52,7 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
             {
                 Anchor = Anchor.CentreLeft,
                 Origin = Anchor.CentreLeft,
+                Height = 0.6f,
             }));
 
             AddRepeatStep("change height", () => this.ChildrenOfType<TaikoPlayfield>().ForEach(p => p.Height = Math.Max(0.2f, (p.Height + 0.2f) % 1f)), 50);

osu.Game.Rulesets.Taiko.Tests/Skinning/TestSceneTaikoScroller.cs

@@ -0,0 +1,22 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Testing;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Skinning;
+using osu.Game.Skinning;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Skinning
+{
+    public class TestSceneTaikoScroller : TaikoSkinnableTestScene
+    {
+        public TestSceneTaikoScroller()
+        {
+            AddStep("Load scroller", () => SetContents(() => new SkinnableDrawable(new TaikoSkinComponent(TaikoSkinComponents.TaikoScroller), _ => Empty())));
+            AddToggleStep("Toggle passing", passing => this.ChildrenOfType<LegacyTaikoScroller>().ForEach(s => s.LastResult.Value =
+                new JudgementResult(null, new Judgement()) { Type = passing ? HitResult.Perfect : HitResult.Miss }));
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Skinning/LegacyTaikoScroller.cs

@@ -0,0 +1,149 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Taiko.Skinning
+{
+    public class LegacyTaikoScroller : CompositeDrawable
+    {
+        public LegacyTaikoScroller()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader(true)]
+        private void load(GameplayBeatmap gameplayBeatmap)
+        {
+            if (gameplayBeatmap != null)
+                ((IBindable<JudgementResult>)LastResult).BindTo(gameplayBeatmap.LastJudgementResult);
+        }
+
+        private bool passing;
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            LastResult.BindValueChanged(result =>
+            {
+                var r = result.NewValue;
+
+                // always ignore hitobjects that don't affect combo (drumroll ticks etc.)
+                if (r?.Judgement.AffectsCombo == false)
+                    return;
+
+                passing = r == null || r.Type > HitResult.Miss;
+
+                foreach (var sprite in InternalChildren.OfType<ScrollerSprite>())
+                    sprite.Passing = passing;
+            }, true);
+        }
+
+        public Bindable<JudgementResult> LastResult = new Bindable<JudgementResult>();
+
+        protected override void Update()
+        {
+            base.Update();
+
+            while (true)
+            {
+                float? additiveX = null;
+
+                foreach (var sprite in InternalChildren)
+                {
+                    // add the x coordinates and perform re-layout on all sprites as spacing may change with gameplay scale.
+                    sprite.X = additiveX ??= sprite.X - (float)Time.Elapsed * 0.1f;
+
+                    additiveX += sprite.DrawWidth - 1;
+
+                    if (sprite.X + sprite.DrawWidth < 0)
+                        sprite.Expire();
+                }
+
+                var last = InternalChildren.LastOrDefault();
+
+                // only break from this loop once we have saturated horizontal space completely.
+                if (last != null && last.ScreenSpaceDrawQuad.TopRight.X >= ScreenSpaceDrawQuad.TopRight.X)
+                    break;
+
+                AddInternal(new ScrollerSprite
+                {
+                    Passing = passing
+                });
+            }
+        }
+
+        private class ScrollerSprite : CompositeDrawable
+        {
+            private Sprite passingSprite;
+            private Sprite failingSprite;
+
+            private bool passing = true;
+
+            public bool Passing
+            {
+                get => passing;
+                set
+                {
+                    if (value == passing)
+                        return;
+
+                    passing = value;
+
+                    if (IsLoaded)
+                        updatePassing();
+                }
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(ISkinSource skin)
+            {
+                AutoSizeAxes = Axes.X;
+                RelativeSizeAxes = Axes.Y;
+
+                FillMode = FillMode.Fit;
+
+                InternalChildren = new Drawable[]
+                {
+                    passingSprite = new Sprite { Texture = skin.GetTexture("taiko-slider") },
+                    failingSprite = new Sprite { Texture = skin.GetTexture("taiko-slider-fail"), Alpha = 0 },
+                };
+
+                updatePassing();
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                foreach (var c in InternalChildren)
+                    c.Scale = new Vector2(DrawHeight / c.Height);
+            }
+
+            private void updatePassing()
+            {
+                if (passing)
+                {
+                    passingSprite.Show();
+                    failingSprite.FadeOut(200);
+                }
+                else
+                {
+                    failingSprite.FadeIn(200);
+                    passingSprite.Delay(200).FadeOut();
+                }
+            }
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Skinning/TaikoLegacySkinTransformer.cs

@@ -85,6 +85,12 @@ namespace osu.Game.Rulesets.Taiko.Skinning
                         return new LegacyHitExplosion(sprite);
 
                     return null;
+
+                case TaikoSkinComponents.TaikoScroller:
+                    if (GetTexture("taiko-slider") != null)
+                        return new LegacyTaikoScroller();
+
+                    return null;
             }
 
             return source.GetDrawableComponent(component);

osu.Game.Rulesets.Taiko/TaikoSkinComponents.cs

@@ -18,5 +18,6 @@ namespace osu.Game.Rulesets.Taiko
         TaikoExplosionMiss,
         TaikoExplosionGood,
         TaikoExplosionGreat,
+        TaikoScroller
     }
 }

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

@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using osu.Framework.Allocation;
+using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Taiko.Objects;
@@ -16,11 +17,15 @@ using osu.Game.Replays;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Skinning;
+using osuTK;
 
 namespace osu.Game.Rulesets.Taiko.UI
 {
     public class DrawableTaikoRuleset : DrawableScrollingRuleset<TaikoHitObject>
     {
+        private SkinnableDrawable scroller;
+
         protected override ScrollVisualisationMethod VisualisationMethod => ScrollVisualisationMethod.Overlapping;
 
         protected override bool UserScrollSpeedAdjustment => false;
@@ -36,6 +41,20 @@ namespace osu.Game.Rulesets.Taiko.UI
         private void load()
         {
             new BarLineGenerator<BarLine>(Beatmap).BarLines.ForEach(bar => Playfield.Add(bar.Major ? new DrawableBarLineMajor(bar) : new DrawableBarLine(bar)));
+
+            AddInternal(scroller = new SkinnableDrawable(new TaikoSkinComponent(TaikoSkinComponents.TaikoScroller), _ => Empty())
+            {
+                RelativeSizeAxes = Axes.X,
+                Depth = float.MaxValue
+            });
+        }
+
+        protected override void UpdateAfterChildren()
+        {
+            base.UpdateAfterChildren();
+
+            var playfieldScreen = Playfield.ScreenSpaceDrawQuad;
+            scroller.Height = ToLocalSpace(playfieldScreen.TopLeft + new Vector2(0, playfieldScreen.Height / 20)).Y;
         }
 
         public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new TaikoPlayfieldAdjustmentContainer();

osu.Game/Screens/Play/GameplayBeatmap.cs

@@ -2,10 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Beatmaps.Timing;
+using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Screens.Play
@@ -38,5 +40,11 @@ namespace osu.Game.Screens.Play
         public IEnumerable<BeatmapStatistic> GetStatistics() => PlayableBeatmap.GetStatistics();
 
         public IBeatmap Clone() => PlayableBeatmap.Clone();
+
+        private readonly Bindable<JudgementResult> lastJudgementResult = new Bindable<JudgementResult>();
+
+        public IBindable<JudgementResult> LastJudgementResult => lastJudgementResult;
+
+        public void ApplyResult(JudgementResult result) => lastJudgementResult.Value = result;
     }
 }

osu.Game/Screens/Play/Player.cs

@@ -200,6 +200,7 @@ namespace osu.Game.Screens.Play
             {
                 HealthProcessor.ApplyResult(r);
                 ScoreProcessor.ApplyResult(r);
+                gameplayBeatmap.ApplyResult(r);
             };
 
             DrawableRuleset.OnRevertResult += r =>