Working state for minigameobstacles

Assets/Scripts/Minigames/DivingForPictures/PlayerPhaseCollisionBehavior.cs

@@ -0,0 +1,180 @@
+using UnityEngine;
+
+namespace Minigames.DivingForPictures
+{
+    /// <summary>
+    /// Collision behavior that grants temporary immunity and allows the player to phase through obstacles.
+    /// During immunity, the player can pass through all obstacles without further collision detection.
+    /// </summary>
+    public class PlayerPhaseCollisionBehavior : PlayerCollisionBehavior
+    {
+        [Header("Phase Settings")]
+        [Tooltip("Whether to disable the player's collider during immunity to allow phasing through obstacles")]
+        [SerializeField] private bool disableColliderDuringImmunity = true;
+        
+        [Tooltip("How fast the player sprite blinks during phase mode (seconds between blinks)")]
+        [SerializeField] private float visualFeedbackBlinkRate = 0.1f;
+        
+        private SpriteRenderer _spriteRenderer;
+        private bool _originalColliderState;
+        private bool _isBlinking;
+        private float _blinkTimer;
+        private Color _originalColor;
+        private float _originalAlpha;
+        
+        protected override void Awake()
+        {
+            base.Awake();
+            
+            // Get sprite renderer from player character
+            if (playerCharacter != null)
+            {
+                _spriteRenderer = playerCharacter.GetComponent<SpriteRenderer>();
+            }
+            
+            if (_spriteRenderer != null)
+            {
+                _originalColor = _spriteRenderer.color;
+                _originalAlpha = _originalColor.a;
+            }
+            
+            if (playerCollider != null)
+            {
+                _originalColliderState = playerCollider.enabled;
+            }
+        }
+        
+        protected override void Update()
+        {
+            base.Update();
+            
+            // Handle visual feedback blinking during immunity
+            if (_isBlinking && _spriteRenderer != null)
+            {
+                _blinkTimer -= Time.deltaTime;
+                
+                if (_blinkTimer <= 0f)
+                {
+                    // Toggle visibility
+                    Color currentColor = _spriteRenderer.color;
+                    currentColor.a = currentColor.a > 0.5f ? 0.3f : _originalAlpha;
+                    _spriteRenderer.color = currentColor;
+                    
+                    _blinkTimer = visualFeedbackBlinkRate;
+                }
+            }
+        }
+        
+        protected override void CheckForCollisions()
+        {
+            // Override to skip collision detection entirely during immunity if collider is disabled
+            if (isImmune && disableColliderDuringImmunity)
+            {
+                return; // Skip collision detection completely
+            }
+            
+            base.CheckForCollisions();
+        }
+        
+        protected override void HandleCollisionResponse(Collider2D obstacle)
+        {
+            Debug.Log("[PlayerPhaseCollisionBehavior] Collision detected - entering phase mode");
+            
+            // No immediate physical response - just start immunity period
+            // The immunity will be handled by the base class
+        }
+        
+        protected override void OnImmunityStart()
+        {
+            base.OnImmunityStart();
+            
+            // Disable collider to allow phasing through obstacles
+            if (disableColliderDuringImmunity && playerCollider != null)
+            {
+                playerCollider.enabled = false;
+                Debug.Log("[PlayerPhaseCollisionBehavior] Collider disabled - entering phase mode");
+            }
+            
+            // Start visual feedback
+            StartVisualFeedback();
+        }
+        
+        protected override void OnImmunityEnd()
+        {
+            base.OnImmunityEnd();
+            
+            // Re-enable collider
+            if (playerCollider != null)
+            {
+                playerCollider.enabled = _originalColliderState;
+                Debug.Log("[PlayerPhaseCollisionBehavior] Collider re-enabled - exiting phase mode");
+            }
+            
+            // Stop visual feedback
+            StopVisualFeedback();
+        }
+        
+        /// <summary>
+        /// Starts the visual feedback to indicate immunity/phase mode
+        /// </summary>
+        private void StartVisualFeedback()
+        {
+            if (_spriteRenderer != null)
+            {
+                _isBlinking = true;
+                _blinkTimer = 0f;
+                
+                // Start with reduced opacity
+                Color immunityColor = _originalColor;
+                immunityColor.a = 0.3f;
+                _spriteRenderer.color = immunityColor;
+            }
+        }
+        
+        /// <summary>
+        /// Stops the visual feedback and restores original appearance
+        /// </summary>
+        private void StopVisualFeedback()
+        {
+            _isBlinking = false;
+            
+            if (_spriteRenderer != null)
+            {
+                // Restore original color and alpha
+                _spriteRenderer.color = _originalColor;
+            }
+        }
+        
+        /// <summary>
+        /// Public method to toggle collider behavior during immunity
+        /// </summary>
+        public void SetColliderDisabling(bool disable)
+        {
+            disableColliderDuringImmunity = disable;
+        }
+        
+        /// <summary>
+        /// Check if player is currently in phase mode
+        /// </summary>
+        public bool IsPhasing => isImmune && disableColliderDuringImmunity;
+        
+        /// <summary>
+        /// Manually trigger phase mode (useful for testing or special abilities)
+        /// </summary>
+        public void TriggerPhaseMode(float duration = -1f)
+        {
+            if (duration > 0f)
+            {
+                isImmune = true;
+                immunityTimer = duration;
+                OnImmunityStart();
+            }
+            else
+            {
+                isImmune = true;
+                immunityTimer = damageImmunityDuration;
+                OnImmunityStart();
+            }
+        }
+    }
+}