Add in-gameplay version of kiai star fountains/burst

osu.Game.Tests/Visual/Menus/TestSceneStarFountain.cs

@@ -4,17 +4,17 @@
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
-using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Screens.Menu;
+using osu.Game.Screens.Play;
 
 namespace osu.Game.Tests.Visual.Menus
 {
     [TestFixture]
     public partial class TestSceneStarFountain : OsuTestScene
     {
-        [SetUpSteps]
+        [Test]
-        public void SetUpSteps()
+        public void TestMenu()
         {
             AddStep("make fountains", () =>
             {
@@ -34,11 +34,7 @@ namespace osu.Game.Tests.Visual.Menus
                     },
                 };
             });
-        }
 
-        [Test]
-        public void TestPew()
-        {
             AddRepeatStep("activate fountains sometimes", () =>
             {
                 foreach (var fountain in Children.OfType<StarFountain>())
@@ -48,5 +44,34 @@ namespace osu.Game.Tests.Visual.Menus
                 }
             }, 150);
         }
+
+        [Test]
+        public void TestGameplay()
+        {
+            AddStep("make fountains", () =>
+            {
+                Children = new[]
+                {
+                    new KiaiGameplayFountains.GameplayStarFountain
+                    {
+                        Anchor = Anchor.BottomLeft,
+                        Origin = Anchor.BottomLeft,
+                        X = 75,
+                    },
+                    new KiaiGameplayFountains.GameplayStarFountain
+                    {
+                        Anchor = Anchor.BottomRight,
+                        Origin = Anchor.BottomRight,
+                        X = -75,
+                    },
+                };
+            });
+
+            AddRepeatStep("activate fountains", () =>
+            {
+                ((StarFountain)Children[0]).Shoot(1);
+                ((StarFountain)Children[1]).Shoot(-1);
+            }, 150);
+        }
     }
 }

osu.Game/Screens/Menu/StarFountain.cs

@@ -21,9 +21,11 @@ namespace osu.Game.Screens.Menu
         [BackgroundDependencyLoader]
         private void load()
         {
-            InternalChild = spewer = new StarFountainSpewer();
+            InternalChild = spewer = CreateSpewer();
         }
 
+        protected virtual StarFountainSpewer CreateSpewer() => new StarFountainSpewer();
+
         public void Shoot(int direction) => spewer.Shoot(direction);
 
         protected override void SkinChanged(ISkinSource skin)
@@ -38,17 +40,23 @@ namespace osu.Game.Screens.Menu
             private const int particle_duration_max = 1000;
 
             private double? lastShootTime;
-            private int lastShootDirection;
+
+            protected int LastShootDirection { get; private set; }
 
             protected override float ParticleGravity => 800;
 
-            private const double shoot_duration = 800;
+            protected virtual double ShootDuration => 800;
 
             [Resolved]
             private ISkinSource skin { get; set; } = null!;
 
             public StarFountainSpewer()
-                : base(null, 240, particle_duration_max)
+                : this(240)
+            {
+            }
+
+            protected StarFountainSpewer(int perSecond)
+                : base(null, perSecond, particle_duration_max)
             {
             }
 
@@ -67,16 +75,16 @@ namespace osu.Game.Screens.Menu
                     StartAngle = getRandomVariance(4),
                     EndAngle = getRandomVariance(2),
                     EndScale = 2.2f + getRandomVariance(0.4f),
-                    Velocity = new Vector2(getCurrentAngle(), -1400 + getRandomVariance(100)),
+                    Velocity = new Vector2(GetCurrentAngle(), -1400 + getRandomVariance(100)),
                 };
             }
 
-            private float getCurrentAngle()
+            protected virtual float GetCurrentAngle()
             {
-                const float x_velocity_from_direction = 500;
                 const float x_velocity_random_variance = 60;
+                const float x_velocity_from_direction = 500;
 
-                return lastShootDirection * x_velocity_from_direction * (float)(1 - 2 * (Clock.CurrentTime - lastShootTime!.Value) / shoot_duration) + getRandomVariance(x_velocity_random_variance);
+                return LastShootDirection * x_velocity_from_direction * (float)(1 - 2 * (Clock.CurrentTime - lastShootTime!.Value) / ShootDuration) + getRandomVariance(x_velocity_random_variance);
             }
 
             private ScheduledDelegate? deactivateDelegate;
@@ -86,10 +94,10 @@ namespace osu.Game.Screens.Menu
                 Active.Value = true;
 
                 deactivateDelegate?.Cancel();
-                deactivateDelegate = Scheduler.AddDelayed(() => Active.Value = false, shoot_duration);
+                deactivateDelegate = Scheduler.AddDelayed(() => Active.Value = false, ShootDuration);
 
                 lastShootTime = Clock.CurrentTime;
-                lastShootDirection = direction;
+                LastShootDirection = direction;
             }
 
             private static float getRandomVariance(float variance) => RNG.NextSingle(-variance, variance);

osu.Game/Screens/Play/KiaiGameplayFountains.cs

@@ -0,0 +1,94 @@
+// 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.
+
+#nullable disable
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Audio.Track;
+using osu.Framework.Graphics;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Graphics.Containers;
+using osu.Game.Screens.Menu;
+
+namespace osu.Game.Screens.Play
+{
+    public partial class KiaiGameplayFountains : BeatSyncedContainer
+    {
+        private StarFountain leftFountain = null!;
+        private StarFountain rightFountain = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            RelativeSizeAxes = Axes.Both;
+
+            Children = new[]
+            {
+                leftFountain = new GameplayStarFountain
+                {
+                    Anchor = Anchor.BottomLeft,
+                    Origin = Anchor.BottomLeft,
+                    X = 75,
+                },
+                rightFountain = new GameplayStarFountain
+                {
+                    Anchor = Anchor.BottomRight,
+                    Origin = Anchor.BottomRight,
+                    X = -75,
+                },
+            };
+        }
+
+        private bool isTriggered;
+
+        private double? lastTrigger;
+
+        protected override void OnNewBeat(int beatIndex, TimingControlPoint timingPoint, EffectControlPoint effectPoint, ChannelAmplitudes amplitudes)
+        {
+            base.OnNewBeat(beatIndex, timingPoint, effectPoint, amplitudes);
+
+            if (effectPoint.KiaiMode && !isTriggered)
+            {
+                bool isNearEffectPoint = Math.Abs(BeatSyncSource.Clock.CurrentTime - effectPoint.Time) < 500;
+                if (isNearEffectPoint)
+                    Shoot();
+            }
+
+            isTriggered = effectPoint.KiaiMode;
+        }
+
+        public void Shoot()
+        {
+            if (lastTrigger != null && Clock.CurrentTime - lastTrigger < 500)
+                return;
+
+            leftFountain.Shoot(1);
+            rightFountain.Shoot(-1);
+            lastTrigger = Clock.CurrentTime;
+        }
+
+        public partial class GameplayStarFountain : StarFountain
+        {
+            protected override StarFountainSpewer CreateSpewer() => new GameplayStarFountainSpewer();
+
+            private partial class GameplayStarFountainSpewer : StarFountainSpewer
+            {
+                protected override double ShootDuration => 400;
+
+                public GameplayStarFountainSpewer()
+                    : base(perSecond: 180)
+                {
+                }
+
+                protected override float GetCurrentAngle()
+                {
+                    const float x_velocity_from_direction = 450;
+                    const float x_velocity_to_direction = 600;
+
+                    return LastShootDirection * RNG.NextSingle(x_velocity_from_direction, x_velocity_to_direction);
+                }
+            }
+        }
+    }
+}

osu.Game/Screens/Play/Player.cs

@@ -405,8 +405,20 @@ namespace osu.Game.Screens.Play
 
         protected virtual GameplayClockContainer CreateGameplayClockContainer(WorkingBeatmap beatmap, double gameplayStart) => new MasterGameplayClockContainer(beatmap, gameplayStart);
 
-        private Drawable createUnderlayComponents() =>
+        private Drawable createUnderlayComponents()
-            DimmableStoryboard = new DimmableStoryboard(GameplayState.Storyboard, GameplayState.Mods) { RelativeSizeAxes = Axes.Both };
+        {
+            var container = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
+                {
+                    DimmableStoryboard = new DimmableStoryboard(GameplayState.Storyboard, GameplayState.Mods) { RelativeSizeAxes = Axes.Both },
+                    new KiaiGameplayFountains(),
+                },
+            };
+
+            return container;
+        }
 
         private Drawable createGameplayComponents(IWorkingBeatmap working) => new ScalingContainer(ScalingMode.Gameplay)
         {