add: Chain reactions

Author: SinlessDevil

Assets/Code/Logic/Zuma/Balls/Ball.cs

@@ -59,8 +59,9 @@ public void Activate(Vector3 position, Quaternion rotation)
         public void Deactivate()
         {
             _text.text = "";
-            
+
             Dispose();
+            SetInteractive(false);
 
             gameObject.SetActive(false);
         }

Assets/Code/Services/BallController/AttachingBallChainHandler.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Linq;
 using Code.Logic.Zuma.Balls;
 using Code.Services.Levels;
 using Code.Services.LocalProgress;
@@ -21,10 +22,10 @@ public class AttachingBallChainHandler
         public AttachingBallChainHandler(
             PathCreator pathCreator,
             BallChainDTO ballChainDto,
-            ChainTracker chainTracker, 
-            WidgetBallChainProvider widgetBallChainProvider, 
-            WinBallChainHandler winBallChainHandler, 
-            ILevelService levelService, 
+            ChainTracker chainTracker,
+            WidgetBallChainProvider widgetBallChainProvider,
+            WinBallChainHandler winBallChainHandler,
+            ILevelService levelService,
             ILevelLocalProgressService levelLocalProgressService)
         {
             _pathCreator = pathCreator;
@@ -44,10 +45,9 @@ public void TryAttachBall(Ball newBall)
 
             InsertBallToChainByDistance(newBall, collision);
         }
-        
+
         private CollisionData GetClosestCollision(Ball newBall)
         {
-            var path = _pathCreator.path;
             float minDistance = float.MaxValue;
             CollisionData closest = null;
 
@@ -58,12 +58,7 @@ private CollisionData GetClosestCollision(Ball newBall)
 
                 if (distance <= _ballChainDto.CollisionThreshold && distance < minDistance)
                 {
-                    closest = new CollisionData
-                    {
-                        Ball = existingBall,
-                        Distance = distance,
-                        Index = i
-                    };
+                    closest = new CollisionData { Ball = existingBall, Distance = distance, Index = i };
                     minDistance = distance;
                 }
             }
@@ -79,106 +74,136 @@ private void InsertBallToChainByDistance(Ball newBall, CollisionData collision)
             float closestBallDist = path.GetClosestDistanceAlongPath(collision.Ball.transform.position);
 
             if (collision.Index == _chainTracker.Balls.Count - 1 && newBallDist < closestBallDist)
-            {
                 AttachBallToChain(newBall, _chainTracker.Balls.Count);
-            }
             else if (collision.Index == 0 && newBallDist > closestBallDist)
-            {
                 AttachBallToChain(newBall, 0);
-            }
             else
             {
                 int insertIndex = (newBallDist > closestBallDist) ? collision.Index : collision.Index + 1;
                 AttachBallToChain(newBall, insertIndex);
             }
         }
-        
+
         private void AttachBallToChain(Ball newBall, int index)
         {
             newBall.Dispose();
-            
+
             _chainTracker.InsertBall(index, newBall);
             _chainTracker.AddDistanceTravelled(_ballChainDto.SpacingBalls);
-           
+
             ReIndexBalls();
-            
+
             WaitToCheckAndDestroyMatches(newBall).Forget();
         }
 
         private async UniTask WaitToCheckAndDestroyMatches(Ball insertedBall)
         {
             await UniTask.Delay((int)(_ballChainDto.DurationMovingOffset * 1000));
-            CheckAndDestroyMatches(insertedBall, _chainTracker.Balls);
+            await CheckAndDestroyMatches(insertedBall, _chainTracker.Balls);
         }
-        
-        private void CheckAndDestroyMatches(Ball insertedBall, List<Ball> balls)
+
+        private async UniTask CheckAndDestroyMatches(Ball pivotBall, List<Ball> balls)
         {
-            List<Ball> matchingBalls = new List<Ball> { insertedBall };
-            Color matchColor = insertedBall.Color;
+            var matchingBalls = FindMatchesAroundBall(pivotBall, balls);
 
-            for (int i = insertedBall.Index - 1; i >= 0; i--)
+            if (matchingBalls.Count >= _ballChainDto.MatchingCount)
             {
-                if (balls[i].Color == matchColor)
-                    matchingBalls.Add(balls[i]);
-                else
-                    break;
-            }
+                int score = matchingBalls.Count * _levelService.GetCurrentLevelStaticData().LevelConfig.ScoreConfig.ScorePerItem;
+                _levelLocalProgressService.AddScore(score);
+                _widgetBallChainProvider.SetUpWidget(matchingBalls, pivotBall, score);
+                _winBallChainHandler.TryWin(balls.Count - matchingBalls.Count);
+
+                int junctionIndex = matchingBalls.Min(b => b.Index) - 1;
 
-            for (int i = insertedBall.Index + 1; i < balls.Count; i++)
+                await DestroyBalls(matchingBalls, balls);
+                await CheckChainReaction(junctionIndex, balls);
+            }
+            else
             {
-                if (balls[i].Color == matchColor)
-                    matchingBalls.Add(balls[i]);
-                else
-                    break;
+                pivotBall.SetInteractive(false);
             }
+        }
+
+        // Recursively checks for new matches after a group is destroyed.
+        // junctionIndex points to the ball just before the destroyed group.
+        private async UniTask CheckChainReaction(int junctionIndex, List<Ball> balls)
+        {
+            if (balls.Count == 0 || _winBallChainHandler.IsWin)
+                return;
+
+            await UniTask.Delay((int)(_ballChainDto.DurationMovingOffset * 1000));
+
+            junctionIndex = Mathf.Clamp(junctionIndex, 0, balls.Count - 1);
+            Ball anchor = balls[junctionIndex];
+            var matchingBalls = FindMatchesAroundBall(anchor, balls);
 
             if (matchingBalls.Count >= _ballChainDto.MatchingCount)
             {
-                int count = matchingBalls.Count * _levelService.GetCurrentLevelStaticData().LevelConfig.ScoreConfig.ScorePerItem;
-                _levelLocalProgressService.AddScore(count);
-                
-                _widgetBallChainProvider.SetUpWidget(matchingBalls, insertedBall, count);
+                int score = matchingBalls.Count * _levelService.GetCurrentLevelStaticData().LevelConfig.ScoreConfig.ScorePerItem;
+                _levelLocalProgressService.AddScore(score);
+                _widgetBallChainProvider.SetUpWidget(matchingBalls, anchor, score);
                 _winBallChainHandler.TryWin(balls.Count - matchingBalls.Count);
-                
-                PlayDestroyMatchingBalls(insertedBall, balls, matchingBalls);
-                
-                ReIndexBalls();
+
+                int nextJunctionIndex = matchingBalls.Min(b => b.Index) - 1;
+
+                await DestroyBalls(matchingBalls, balls);
+                await CheckChainReaction(nextJunctionIndex, balls);
             }
-            else
+        }
+
+        // Waits for ALL destroy animations to finish, then removes balls and contracts the chain at once.
+        private async UniTask DestroyBalls(List<Ball> matchingBalls, List<Ball> allBalls)
+        {
+            await UniTask.WhenAll(matchingBalls.Select(WaitForDestroyAnimation));
+
+            foreach (var ball in matchingBalls)
             {
-                insertedBall.SetInteractive(false);
+                allBalls.Remove(ball);
+                ball.Deactivate();
             }
+
+            _chainTracker.SubtractDistanceTravelled(matchingBalls.Count * _ballChainDto.SpacingBalls);
+            ReIndexBalls();
         }
 
-        private void PlayDestroyMatchingBalls(Ball insertedBall, List<Ball> balls, List<Ball> matchingBalls)
+        private UniTask WaitForDestroyAnimation(Ball ball)
         {
-            foreach (var ball in matchingBalls)
+            var tcs = new UniTaskCompletionSource();
+            ball.PlayDestroyAnimation(() => tcs.TrySetResult());
+            return tcs.Task;
+        }
+
+        private List<Ball> FindMatchesAroundBall(Ball pivotBall, List<Ball> balls)
+        {
+            var matching = new List<Ball> { pivotBall };
+            Color color = pivotBall.Color;
+
+            for (int i = pivotBall.Index - 1; i >= 0; i--)
             {
-                ball.PlayDestroyAnimation(() =>
-                {
-                    balls.Remove(ball);
-                    ball.Deactivate();
-                 
-                    insertedBall.SetInteractive(false);
-                    
-                    _chainTracker.SubtractDistanceTravelled(_ballChainDto.SpacingBalls);
-                });
+                if (balls[i].Color == color) matching.Add(balls[i]);
+                else break;
             }
+
+            for (int i = pivotBall.Index + 1; i < balls.Count; i++)
+            {
+                if (balls[i].Color == color) matching.Add(balls[i]);
+                else break;
+            }
+
+            return matching;
         }
 
         private void ReIndexBalls()
         {
             for (int i = 0; i < _chainTracker.Balls.Count; i++)
-            {
                 _chainTracker.Balls[i].SetIndex(i);
-            }
         }
-        
+
         private class CollisionData
         {
             public Ball Ball;
             public float Distance;
             public int Index;
         }
     }
-}
+}