AppleHillsProduction/Assets/Scripts/UI/CardSystem/DragDrop/BoosterPackVisual.cs

using Pixelplacement;
using UI.DragAndDrop.Core;
using UnityEngine;
using UnityEngine.UI;

namespace UI.CardSystem.DragDrop
{
    /// <summary>
    /// Visual representation for BoosterPackDraggable.
    /// Displays the booster pack sprite and handles opening animations.
    /// </summary>
    public class BoosterPackVisual : DraggableVisual
    {
        [Header("Booster Pack Visual")]
        [SerializeField] private Image packImage;
        [SerializeField] private Sprite packSprite;
        [SerializeField] private ParticleSystem glowEffect;
        [SerializeField] private Transform glowTransform;
        
        [Header("Opening Animation")]
        [SerializeField] private float openingScalePunch = 0.5f;
        [SerializeField] private float openingRotationPunch = 360f;
        [SerializeField] private float openingDuration = 0.5f;
        
        private BoosterPackDraggable _boosterDraggable;
        
        public override void Initialize(DraggableObject parent)
        {
            base.Initialize(parent);
            
            _boosterDraggable = parent as BoosterPackDraggable;
            
            // Get pack image if not assigned
            if (packImage == null)
            {
                packImage = GetComponentInChildren<Image>();
            }
            
            // Set initial sprite
            if (packImage != null && packSprite != null)
            {
                packImage.sprite = packSprite;
            }
            
            // Subscribe to booster events
            if (_boosterDraggable != null)
            {
                _boosterDraggable.OnBoosterOpened += HandleBoosterOpened;
                _boosterDraggable.OnTapped += HandleTapped;
            }
            
            // Start glow effect if available
            if (glowEffect != null && !glowEffect.isPlaying)
            {
                glowEffect.Play();
            }
        }
        
        protected override void UpdateVisualContent()
        {
            // Update glow rotation for visual interest
            if (glowTransform != null)
            {
                glowTransform.Rotate(Vector3.forward * 30f * Time.deltaTime);
            }
        }
        
        private void HandleBoosterOpened(BoosterPackDraggable booster)
        {
            PlayOpeningAnimation();
        }
        
        private void HandleTapped(BoosterPackDraggable booster, int currentTap, int maxTaps)
        {
            PlayShakeAnimation(currentTap, maxTaps);
        }
        
        /// <summary>
        /// Play progressive shake animation based on tap intensity
        /// </summary>
        public void PlayShakeAnimation(int intensity, int maxIntensity)
        {
            float normalizedIntensity = (float)intensity / maxIntensity;
            float shakeAmount = Mathf.Lerp(5f, 30f, normalizedIntensity);
            float shakeDuration = 0.15f;
            
            // Shake rotation
            Vector3 shakeRotation = new Vector3(
                Random.Range(-shakeAmount, shakeAmount),
                Random.Range(-shakeAmount, shakeAmount),
                Random.Range(-shakeAmount, shakeAmount)
            );
            
            Tween.Rotation(transform, transform.eulerAngles + shakeRotation, 
                           shakeDuration, 0f, Tween.EaseOutBack,
                           completeCallback: () => {
                               Tween.Rotation(transform, Vector3.zero, 
                                            shakeDuration, 0f, Tween.EaseInBack);
                           });
            
            // Scale punch (gets bigger with each tap)
            float punchScale = 1f + (normalizedIntensity * 0.2f);
            Tween.LocalScale(transform, Vector3.one * punchScale, 
                             shakeDuration / 2f, 0f, Tween.EaseOutBack,
                             completeCallback: () => {
                                 Tween.LocalScale(transform, Vector3.one, 
                                                shakeDuration / 2f, 0f, Tween.EaseInBack);
                             });
            
            // Extra glow burst on final tap
            if (intensity == maxIntensity && glowEffect != null)
            {
                var emission = glowEffect.emission;
                emission.rateOverTimeMultiplier = 50f;
            }
        }
        
        /// <summary>
        /// Play the booster pack opening animation
        /// </summary>
        public void PlayOpeningAnimation()
        {
            // Scale punch
            Vector3 targetScale = transform.localScale * (1f + openingScalePunch);
            Tween.LocalScale(transform, targetScale, openingDuration / 2f, 0f, Tween.EaseOutBack, 
                completeCallback: () => {
                    Tween.LocalScale(transform, Vector3.one, openingDuration / 2f, 0f, Tween.EaseInBack);
                });
            
            // Rotation
            Tween.Rotation(transform, transform.eulerAngles + Vector3.forward * openingRotationPunch, 
                openingDuration, 0f, Tween.EaseOutBack);
            
            // Glow burst
            if (glowEffect != null)
            {
                glowEffect.Stop();
                glowEffect.Play();
            }
        }
        
        /// <summary>
        /// Set the booster pack sprite
        /// </summary>
        public void SetPackSprite(Sprite sprite)
        {
            packSprite = sprite;
            if (packImage != null)
            {
                packImage.sprite = packSprite;
            }
        }
        
        protected override void OnPointerEnterVisual()
        {
            base.OnPointerEnterVisual();
            
            // Extra glow when hovering
            if (glowEffect != null)
            {
                var emission = glowEffect.emission;
                emission.rateOverTimeMultiplier = 20f;
            }
        }
        
        protected override void OnPointerExitVisual()
        {
            base.OnPointerExitVisual();
            
            // Restore normal glow
            if (glowEffect != null)
            {
                var emission = glowEffect.emission;
                emission.rateOverTimeMultiplier = 10f;
            }
        }
        
        protected override void OnDestroy()
        {
            base.OnDestroy();
            
            if (_boosterDraggable != null)
            {
                _boosterDraggable.OnBoosterOpened -= HandleBoosterOpened;
            }
        }
    }
}