Populate minigame with obstacles and monster spawns (#5)

- Simulated "fake" physics and collisions
- Object pooling for tiles, obstacles and monster spawns
- Base monster scoring with proximity triggers and depth multiplier

Co-authored-by: AlexanderT <alexander@foolhardyhorizons.com>
Co-authored-by: Michal Pikulski <michal.a.pikulski@gmail.com>
Reviewed-on: #5

Assets/Scripts/Minigames/DivingForPictures/Bubble.cs

@@ -1,30 +1,38 @@
 using UnityEngine;
+using System.Collections;
 using Pooling;
 
 namespace Minigames.DivingForPictures
 {
     /// <summary>
     /// Represents a single bubble, handling its movement, wobble effect, scaling, and sprite assignment.
+    /// Uses coroutines for better performance instead of Update() calls.
     /// </summary>
     public class Bubble : MonoBehaviour, IPoolableWithReference<BubblePool>
     {
         public float speed = 1f;
         public float wobbleSpeed = 1f;
         private SpriteRenderer spriteRenderer;
-        private SpriteRenderer bubbleSpriteRenderer; // Renamed from bottleSpriteRenderer
+        private SpriteRenderer bubbleSpriteRenderer;
         private float timeOffset;
         private float minScale = 0.2f;
         private float maxScale = 1.2f;
-        private float baseScale = 1f; // Added to store the initial scale
+        private float baseScale = 1f;
 
-        private Camera mainCamera; // Cache camera reference
-        private BubblePool parentPool; // Reference to the pool this bubble came from
+        private Camera mainCamera;
+        private BubblePool parentPool;
+        
+        // Coroutine references
+        private Coroutine _movementCoroutine;
+        private Coroutine _wobbleCoroutine;
+        private Coroutine _offScreenCheckCoroutine;
 
         void Awake()
         {
             // Cache references and randomize time offset for wobble
             spriteRenderer = GetComponent<SpriteRenderer>();
             timeOffset = Random.value * 100f;
+            
             // Find the child named "BubbleSprite" and get its SpriteRenderer
             Transform bubbleSpriteTransform = transform.Find("BubbleSprite");
             if (bubbleSpriteTransform != null)
@@ -36,20 +44,101 @@ namespace Minigames.DivingForPictures
             mainCamera = Camera.main;
         }
 
-        void Update()
+        private void OnEnable()
         {
-            // Move bubble upward
-            transform.position += Vector3.up * (speed * Time.deltaTime);
-            
-            // Wobble effect (smooth oscillation between min and max scale)
-            float t = (Mathf.Sin((Time.time + timeOffset) * wobbleSpeed) + 1f) * 0.5f; // t in [0,1]
-            float wobbleFactor = Mathf.Lerp(minScale, maxScale, t);
-            transform.localScale = Vector3.one * (baseScale * wobbleFactor);
-            
-            // Destroy when off screen - using cached camera reference
-            if (mainCamera != null && transform.position.y > mainCamera.orthographicSize + 2f)
+            StartBubbleBehavior();
+        }
+
+        private void OnDisable()
+        {
+            StopBubbleBehavior();
+        }
+
+        /// <summary>
+        /// Starts all bubble behavior coroutines
+        /// </summary>
+        private void StartBubbleBehavior()
+        {
+            _movementCoroutine = StartCoroutine(MovementCoroutine());
+            _wobbleCoroutine = StartCoroutine(WobbleCoroutine());
+            _offScreenCheckCoroutine = StartCoroutine(OffScreenCheckCoroutine());
+        }
+
+        /// <summary>
+        /// Stops all bubble behavior coroutines
+        /// </summary>
+        private void StopBubbleBehavior()
+        {
+            if (_movementCoroutine != null)
             {
-                OnBubbleDestroy();
+                StopCoroutine(_movementCoroutine);
+                _movementCoroutine = null;
+            }
+
+            if (_wobbleCoroutine != null)
+            {
+                StopCoroutine(_wobbleCoroutine);
+                _wobbleCoroutine = null;
+            }
+
+            if (_offScreenCheckCoroutine != null)
+            {
+                StopCoroutine(_offScreenCheckCoroutine);
+                _offScreenCheckCoroutine = null;
+            }
+        }
+
+        /// <summary>
+        /// Coroutine that handles bubble upward movement
+        /// </summary>
+        private IEnumerator MovementCoroutine()
+        {
+            while (enabled && gameObject.activeInHierarchy)
+            {
+                // Move bubble upward
+                transform.position += Vector3.up * (speed * Time.deltaTime);
+                
+                // Wait for next frame
+                yield return null;
+            }
+        }
+
+        /// <summary>
+        /// Coroutine that handles the wobble scaling effect
+        /// </summary>
+        private IEnumerator WobbleCoroutine()
+        {
+            while (enabled && gameObject.activeInHierarchy)
+            {
+                // Wobble effect (smooth oscillation between min and max scale)
+                float t = (Mathf.Sin((Time.time + timeOffset) * wobbleSpeed) + 1f) * 0.5f; // t in [0,1]
+                float wobbleFactor = Mathf.Lerp(minScale, maxScale, t);
+                transform.localScale = Vector3.one * (baseScale * wobbleFactor);
+                
+                // Wait for next frame
+                yield return null;
+            }
+        }
+
+        /// <summary>
+        /// Coroutine that checks if bubble has moved off-screen
+        /// Runs at a lower frequency for better performance
+        /// </summary>
+        private IEnumerator OffScreenCheckCoroutine()
+        {
+            const float checkInterval = 0.1f; // Check every 100ms instead of every frame
+            
+            while (enabled && gameObject.activeInHierarchy)
+            {
+                // Check if bubble is off screen
+                if (mainCamera != null && transform.position.y > mainCamera.orthographicSize + 2f)
+                {
+                    OnBubbleDestroy();
+                    yield break; // Exit coroutine since bubble is being destroyed
+                }
+                
+                // Wait for the check interval
+                yield return new WaitForSeconds(checkInterval);
             }
         }
 
@@ -143,6 +232,24 @@ namespace Minigames.DivingForPictures
             minScale = min;
             maxScale = max;
         }
+
+        /// <summary>
+        /// Sets the movement speed at runtime
+        /// </summary>
+        /// <param name="newSpeed">New movement speed</param>
+        public void SetSpeed(float newSpeed)
+        {
+            speed = newSpeed;
+        }
+
+        /// <summary>
+        /// Sets the wobble speed at runtime
+        /// </summary>
+        /// <param name="newWobbleSpeed">New wobble speed</param>
+        public void SetWobbleSpeed(float newWobbleSpeed)
+        {
+            wobbleSpeed = newWobbleSpeed;
+        }
         
         /// <summary>
         /// Resets the bubble state for reuse from object pool