Working state for minigameobstacles

Assets/Scripts/Minigames/DivingForPictures/PlayerBlinkBehavior.cs

@@ -0,0 +1,242 @@
+using UnityEngine;
+using System.Collections;
+
+namespace Minigames.DivingForPictures
+{
+    /// <summary>
+    /// Handles visual feedback for player damage by making the sprite renderer blink red.
+    /// Automatically subscribes to damage events from PlayerCollisionBehavior components.
+    /// </summary>
+    public class PlayerBlinkBehavior : MonoBehaviour
+    {
+        [Header("Blink Settings")]
+        [Tooltip("Color to blink to when taking damage (typically red for damage indication)")]
+        [SerializeField] private Color damageBlinkColor = Color.red;
+        
+        [Tooltip("How fast to blink between normal and damage colors (seconds between color changes)")]
+        [SerializeField] private float blinkRate = 0.15f;
+        
+        [Tooltip("Alpha value for the damage color (0 = transparent, 1 = opaque)")]
+        [Range(0f, 1f)]
+        [SerializeField] private float damageColorAlpha = 0.7f;
+        
+        [Header("References")]
+        [Tooltip("The SpriteRenderer to apply blink effects to (auto-assigned if empty)")]
+        [SerializeField] private SpriteRenderer targetSpriteRenderer;
+        
+        private bool _isBlinking;
+        private bool _isShowingDamageColor;
+        private Coroutine _blinkCoroutine;
+        private Color _originalColor; // Missing field declaration
+        
+        private void Awake()
+        {
+            // Auto-assign sprite renderer if not set
+            if (targetSpriteRenderer == null)
+            {
+                targetSpriteRenderer = GetComponent<SpriteRenderer>();
+                if (targetSpriteRenderer == null)
+                {
+                    targetSpriteRenderer = GetComponentInChildren<SpriteRenderer>();
+                    if (targetSpriteRenderer != null)
+                    {
+                        Debug.Log($"[PlayerBlinkBehavior] Found SpriteRenderer on child object: {targetSpriteRenderer.gameObject.name}");
+                    }
+                }
+            }
+            
+            if (targetSpriteRenderer == null)
+            {
+                Debug.LogError("[PlayerBlinkBehavior] No SpriteRenderer found on this GameObject or its children!");
+                return;
+            }
+            
+            // Store original color
+            _originalColor = targetSpriteRenderer.color;
+            
+            // Ensure damage color has the correct alpha
+            damageBlinkColor.a = damageColorAlpha;
+        }
+        
+        private void OnEnable()
+        {
+            // Subscribe to damage events
+            PlayerCollisionBehavior.OnDamageStart += StartBlinking;
+            PlayerCollisionBehavior.OnDamageEnd += StopBlinking;
+        }
+        
+        private void OnDisable()
+        {
+            // Unsubscribe from damage events
+            PlayerCollisionBehavior.OnDamageStart -= StartBlinking;
+            PlayerCollisionBehavior.OnDamageEnd -= StopBlinking;
+            
+            // Stop any ongoing blink effect
+            if (_blinkCoroutine != null)
+            {
+                StopCoroutine(_blinkCoroutine);
+                _blinkCoroutine = null;
+            }
+            
+            // Restore original color
+            RestoreOriginalColor();
+        }
+        
+        /// <summary>
+        /// Starts the red blinking effect when damage begins
+        /// </summary>
+        private void StartBlinking()
+        {
+            if (targetSpriteRenderer == null) return;
+            
+            Debug.Log("[PlayerBlinkBehavior] Starting damage blink effect");
+            
+            // Stop any existing blink coroutine
+            if (_blinkCoroutine != null)
+            {
+                StopCoroutine(_blinkCoroutine);
+            }
+            
+            _isBlinking = true;
+            _isShowingDamageColor = false;
+            
+            // Start the blink coroutine
+            _blinkCoroutine = StartCoroutine(BlinkCoroutine());
+        }
+        
+        /// <summary>
+        /// Stops the blinking effect when damage ends
+        /// </summary>
+        private void StopBlinking()
+        {
+            Debug.Log("[PlayerBlinkBehavior] Stopping damage blink effect");
+            
+            _isBlinking = false;
+            
+            // Stop the blink coroutine
+            if (_blinkCoroutine != null)
+            {
+                StopCoroutine(_blinkCoroutine);
+                _blinkCoroutine = null;
+            }
+            
+            // Restore original color
+            RestoreOriginalColor();
+        }
+        
+        /// <summary>
+        /// Coroutine that handles the blinking animation
+        /// </summary>
+        private IEnumerator BlinkCoroutine()
+        {
+            while (_isBlinking && targetSpriteRenderer != null)
+            {
+                // Toggle between original and damage colors
+                if (_isShowingDamageColor)
+                {
+                    targetSpriteRenderer.color = _originalColor;
+                    _isShowingDamageColor = false;
+                }
+                else
+                {
+                    targetSpriteRenderer.color = damageBlinkColor;
+                    _isShowingDamageColor = true;
+                }
+                
+                // Wait for blink interval
+                yield return new WaitForSeconds(blinkRate);
+            }
+        }
+        
+        /// <summary>
+        /// Restores the sprite renderer to its original color
+        /// </summary>
+        private void RestoreOriginalColor()
+        {
+            if (targetSpriteRenderer != null)
+            {
+                targetSpriteRenderer.color = _originalColor;
+                _isShowingDamageColor = false;
+            }
+        }
+        
+        /// <summary>
+        /// Updates the original color reference (useful if sprite color changes during gameplay)
+        /// </summary>
+        public void UpdateOriginalColor()
+        {
+            if (targetSpriteRenderer != null && !_isBlinking)
+            {
+                _originalColor = targetSpriteRenderer.color;
+            }
+        }
+        
+        /// <summary>
+        /// Public method to change blink color at runtime
+        /// </summary>
+        public void SetDamageBlinkColor(Color newColor)
+        {
+            damageBlinkColor = newColor;
+            damageBlinkColor.a = damageColorAlpha;
+        }
+        
+        /// <summary>
+        /// Public method to change blink rate at runtime
+        /// </summary>
+        public void SetBlinkRate(float rate)
+        {
+            blinkRate = rate;
+        }
+        
+        /// <summary>
+        /// Check if currently blinking
+        /// </summary>
+        public bool IsBlinking => _isBlinking;
+        
+        /// <summary>
+        /// Manually trigger blink effect (useful for testing or other damage sources)
+        /// </summary>
+        public void TriggerBlink(float duration)
+        {
+            if (_blinkCoroutine != null)
+            {
+                StopCoroutine(_blinkCoroutine);
+            }
+            
+            StartCoroutine(ManualBlinkCoroutine(duration));
+        }
+        
+        /// <summary>
+        /// Coroutine for manually triggered blink effects
+        /// </summary>
+        private IEnumerator ManualBlinkCoroutine(float duration)
+        {
+            _isBlinking = true;
+            _isShowingDamageColor = false;
+            
+            float elapsed = 0f;
+            
+            while (elapsed < duration && targetSpriteRenderer != null)
+            {
+                // Toggle between original and damage colors
+                if (_isShowingDamageColor)
+                {
+                    targetSpriteRenderer.color = _originalColor;
+                    _isShowingDamageColor = false;
+                }
+                else
+                {
+                    targetSpriteRenderer.color = damageBlinkColor;
+                    _isShowingDamageColor = true;
+                }
+                
+                yield return new WaitForSeconds(blinkRate);
+                elapsed += blinkRate;
+            }
+            
+            // Ensure we end with original color
+            RestoreOriginalColor();
+            _isBlinking = false;
+        }
+    }
+}