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/FloatingObstacle.cs

@@ -0,0 +1,283 @@
+using UnityEngine;
+using System.Collections;
+using Pooling;
+
+namespace Minigames.DivingForPictures
+{
+    /// <summary>
+    /// Complete floating obstacle component that handles movement and pooling.
+    /// Obstacles move upward toward the surface. Collision detection is handled by the player.
+    /// Once an obstacle hits the player, its collider is disabled to prevent further collisions.
+    /// Uses coroutines for better performance instead of Update() calls.
+    /// </summary>
+    public class FloatingObstacle : MonoBehaviour, IPoolable
+    {
+        [Header("Obstacle Properties")]
+        [Tooltip("Index of the prefab this obstacle was created from")]
+        [SerializeField] private int prefabIndex;
+        
+        [Tooltip("Movement speed of this obstacle")]
+        [SerializeField] private float moveSpeed = 2f;
+        
+        [Header("Movement")]
+        [Tooltip("Whether this obstacle moves (can be disabled for static obstacles)")]
+        [SerializeField] private bool enableMovement = true;
+        
+        [Header("References")]
+        [Tooltip("Reference to the spawner that created this obstacle")]
+        [SerializeField] private ObstacleSpawner spawner;
+        
+        // Public properties
+        public int PrefabIndex
+        {
+            get => prefabIndex;
+            set => prefabIndex = value;
+        }
+        
+        public float MoveSpeed
+        {
+            get => moveSpeed;
+            set => moveSpeed = value;
+        }
+        
+        // Private fields
+        private Collider2D _collider;
+        private Camera _mainCamera;
+        private float _screenTop;
+        private Coroutine _movementCoroutine;
+        private Coroutine _offScreenCheckCoroutine;
+        
+        private void Awake()
+        {
+            _collider = GetComponent<Collider2D>();
+            
+            if (_collider == null)
+            {
+                _collider = GetComponentInChildren<Collider2D>();
+            }
+            
+            if (_collider == null)
+            {
+                Debug.LogError($"[FloatingObstacle] No Collider2D found on {gameObject.name}!");
+            }
+            
+            _mainCamera = Camera.main;
+        }
+        
+        private void OnEnable()
+        {
+            StartObstacleBehavior();
+        }
+        
+        private void OnDisable()
+        {
+            StopObstacleBehavior();
+        }
+        
+        /// <summary>
+        /// Starts the obstacle behavior coroutines
+        /// </summary>
+        private void StartObstacleBehavior()
+        {
+            if (enableMovement)
+            {
+                _movementCoroutine = StartCoroutine(MovementCoroutine());
+            }
+            
+            _offScreenCheckCoroutine = StartCoroutine(OffScreenCheckCoroutine());
+        }
+        
+        /// <summary>
+        /// Stops all obstacle behavior coroutines
+        /// </summary>
+        private void StopObstacleBehavior()
+        {
+            if (_movementCoroutine != null)
+            {
+                StopCoroutine(_movementCoroutine);
+                _movementCoroutine = null;
+            }
+            
+            if (_offScreenCheckCoroutine != null)
+            {
+                StopCoroutine(_offScreenCheckCoroutine);
+                _offScreenCheckCoroutine = null;
+            }
+        }
+        
+        /// <summary>
+        /// Coroutine that handles obstacle movement
+        /// </summary>
+        private IEnumerator MovementCoroutine()
+        {
+            while (enabled && gameObject.activeInHierarchy)
+            {
+                // Move the obstacle upward
+                transform.position += Vector3.up * (moveSpeed * Time.deltaTime);
+                
+                // Wait for next frame
+                yield return null;
+            }
+        }
+        
+        /// <summary>
+        /// Coroutine that checks if obstacle has moved off-screen
+        /// Runs at a lower frequency than movement for better performance
+        /// </summary>
+        private IEnumerator OffScreenCheckCoroutine()
+        {
+            const float checkInterval = 0.2f; // Check every 200ms instead of every frame
+            
+            while (enabled && gameObject.activeInHierarchy)
+            {
+                CheckIfOffScreen();
+                
+                // Wait for the check interval
+                yield return new WaitForSeconds(checkInterval);
+            }
+        }
+        
+        /// <summary>
+        /// Disables the collider after hitting the player to prevent further collisions
+        /// This is more performant than tracking hit state
+        /// </summary>
+        public void MarkDamageDealt()
+        {
+            if (_collider != null && _collider.enabled)
+            {
+                _collider.enabled = false;
+                Debug.Log($"[FloatingObstacle] Obstacle {gameObject.name} hit player - collider disabled");
+            }
+        }
+        
+        /// <summary>
+        /// Checks if the obstacle has moved off-screen and should be despawned
+        /// </summary>
+        private void CheckIfOffScreen()
+        {
+            if (_mainCamera == null) 
+            {
+                _mainCamera = Camera.main;
+                if (_mainCamera == null) return;
+            }
+            
+            // Always recalculate screen bounds to ensure accuracy
+            Vector3 topWorldPoint = _mainCamera.ViewportToWorldPoint(new Vector3(0.5f, 1f, _mainCamera.transform.position.z));
+            _screenTop = topWorldPoint.y;
+            
+            // Check if obstacle is significantly above screen top (obstacles move upward)
+            // Use a larger buffer to ensure obstacles are truly off-screen before returning to pool
+            if (transform.position.y > _screenTop + 5f)
+            {
+                Debug.Log($"[FloatingObstacle] {gameObject.name} off-screen at Y:{transform.position.y:F2}, screen top:{_screenTop:F2}");
+                ReturnToPool();
+            }
+        }
+        
+        /// <summary>
+        /// Returns this obstacle to the spawner's pool
+        /// </summary>
+        private void ReturnToPool()
+        {
+            // CRITICAL: Stop all behavior first to prevent race conditions
+            // This ensures no more off-screen checks or movement happen during pool return
+            StopObstacleBehavior();
+            
+            if (spawner != null)
+            {
+                spawner.ReturnObstacleToPool(gameObject, prefabIndex);
+            }
+            else
+            {
+                // Try to find the spawner instead of destroying the object
+                ObstacleSpawner foundSpawner = FindFirstObjectByType<ObstacleSpawner>();
+                if (foundSpawner != null)
+                {
+                    Debug.LogWarning($"[FloatingObstacle] Obstacle {gameObject.name} lost spawner reference, found replacement spawner");
+                    spawner = foundSpawner;
+                    spawner.ReturnObstacleToPool(gameObject, prefabIndex);
+                }
+                else
+                {
+                    // No spawner found - just deactivate the object instead of destroying it
+                    Debug.LogWarning($"[FloatingObstacle] No spawner found for {gameObject.name}, deactivating safely");
+                    gameObject.SetActive(false);
+                    
+                    // Move to a safe location to avoid interference
+                    transform.position = new Vector3(1000f, 1000f, 0f);
+                }
+            }
+        }
+        
+        /// <summary>
+        /// Sets the spawner reference for this obstacle
+        /// </summary>
+        /// <param name="obstacleSpawner">The spawner that created this obstacle</param>
+        public void SetSpawner(ObstacleSpawner obstacleSpawner)
+        {
+            spawner = obstacleSpawner;
+        }
+        
+        /// <summary>
+        /// Called when the obstacle is retrieved from the pool
+        /// </summary>
+        public void OnSpawn()
+        {
+            // Reset all state first
+            _screenTop = 0f; // Reset cached screen bounds
+            _mainCamera = Camera.main; // Refresh camera reference
+            
+            // Re-enable the collider for reuse
+            if (_collider != null)
+            {
+                _collider.enabled = true;
+            }
+            
+            Debug.Log($"[FloatingObstacle] Obstacle {gameObject.name} spawned from pool");
+            
+            // Note: Don't start coroutines here - OnEnable() will handle that when SetActive(true) is called
+        }
+        
+        /// <summary>
+        /// Called when the obstacle is returned to the pool
+        /// </summary>
+        public void OnDespawn()
+        {
+            // Stop all coroutines before returning to pool
+            StopObstacleBehavior();
+            
+            // Re-enable collider for next use (in case it was disabled)
+            if (_collider != null)
+            {
+                _collider.enabled = true;
+            }
+            
+            Debug.Log($"[FloatingObstacle] Obstacle {gameObject.name} despawned to pool");
+        }
+        
+        /// <summary>
+        /// Public method to manually trigger return to pool (for external systems)
+        /// </summary>
+        public void ForceReturnToPool()
+        {
+            ReturnToPool();
+        }
+        
+        /// <summary>
+        /// Public method to enable/disable movement at runtime
+        /// </summary>
+        public void SetMovementEnabled(bool enabled)
+        {
+            if (enableMovement == enabled) return;
+            
+            enableMovement = enabled;
+            
+            // Restart coroutines to apply movement change
+            if (gameObject.activeInHierarchy)
+            {
+                StopObstacleBehavior();
+                StartObstacleBehavior();
+            }
+        }
+    }
+}