AppleHillsProduction/Assets/Scripts/Minigames/DivingForPictures/PlayerPhaseCollisionBehavior.cs

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();
            }
        }
    }
}