Working card dragging into album slots, persistent slots

Assets/Scripts/UI/CardSystem/AlbumCard.cs

@@ -0,0 +1,172 @@
+using System;
+using AppleHills.Data.CardSystem;
+using Pixelplacement;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UI.CardSystem
+{
+    /// <summary>
+    /// Album card component that wraps CardDisplay.
+    /// Handles tap-to-enlarge and tap-to-shrink interactions for cards placed in album slots.
+    /// 
+    /// TODO: Consider refactoring to state machine pattern (PendingReveal, PlacedInSlot, Enlarged)
+    /// This would eliminate the need for separate AlbumPlacementCard wrapper and simplify the hierarchy.
+    /// See design discussion with state transitions for cleaner architecture.
+    /// </summary>
+    public class AlbumCard : MonoBehaviour, IPointerClickHandler
+    {
+        [Header("References")]
+        [SerializeField] private CardDisplay cardDisplay;
+        
+        [Header("Enlarge Settings")]
+        [SerializeField] private float enlargedScale = 2.5f;
+        [SerializeField] private float scaleDuration = 0.3f;
+        
+        // Events for AlbumViewPage to manage backdrop and reparenting
+        public event Action<AlbumCard> OnEnlargeRequested;
+        public event Action<AlbumCard> OnShrinkRequested;
+        
+        private AlbumCardSlot _parentSlot;
+        private CardData _cardData;
+        private bool _isEnlarged;
+        private Vector3 _originalScale;
+        private Transform _originalParent;
+        private Vector3 _originalLocalPosition;
+        private Quaternion _originalLocalRotation;
+        
+        private void Awake()
+        {
+            // Auto-find CardDisplay if not assigned
+            if (cardDisplay == null)
+            {
+                cardDisplay = GetComponentInChildren<CardDisplay>();
+            }
+            
+            // Store original scale
+            _originalScale = transform.localScale;
+        }
+        
+        /// <summary>
+        /// Setup card with data
+        /// </summary>
+        public void SetupCard(CardData data)
+        {
+            _cardData = data;
+            
+            if (cardDisplay != null)
+            {
+                cardDisplay.SetupCard(data);
+            }
+        }
+        
+        /// <summary>
+        /// Set the parent slot this card belongs to
+        /// </summary>
+        public void SetParentSlot(AlbumCardSlot slot)
+        {
+            _parentSlot = slot;
+        }
+        
+        /// <summary>
+        /// Get the card data
+        /// </summary>
+        public CardData GetCardData()
+        {
+            return _cardData;
+        }
+        
+        /// <summary>
+        /// Handle tap on card - request enlarge/shrink from parent page
+        /// Only process clicks when card is placed in a slot (not during reveal flow)
+        /// </summary>
+        public void OnPointerClick(PointerEventData eventData)
+        {
+            // During reveal flow (before placed in slot), ignore clicks
+            // Let the parent FlippableCard handle them
+            if (_parentSlot == null)
+                return;
+            
+            if (_isEnlarged)
+            {
+                OnShrinkRequested?.Invoke(this);
+            }
+            else
+            {
+                OnEnlargeRequested?.Invoke(this);
+            }
+        }
+        
+        /// <summary>
+        /// Enlarge card (called by AlbumViewPage after reparenting)
+        /// </summary>
+        public void EnlargeCard()
+        {
+            if (_isEnlarged) return;
+            
+            _isEnlarged = true;
+            
+            // Store original transform info for restoration
+            _originalParent = transform.parent;
+            _originalLocalPosition = transform.localPosition;
+            _originalLocalRotation = transform.localRotation;
+            
+            // Scale up with snappy tween
+            Tween.LocalScale(transform, _originalScale * enlargedScale, scaleDuration, 0f, Tween.EaseOutBack);
+        }
+        
+        /// <summary>
+        /// Shrink card back to original size (called by AlbumViewPage before reparenting back)
+        /// </summary>
+        /// <param name="onComplete">Optional callback to invoke when shrink animation completes</param>
+        public void ShrinkCard(System.Action onComplete = null)
+        {
+            if (!_isEnlarged) return;
+            
+            _isEnlarged = false;
+            
+            // Scale back down with snappy tween, invoke callback when done
+            Tween.LocalScale(transform, _originalScale, scaleDuration, 0f, Tween.EaseInBack, 
+                completeCallback: () => onComplete?.Invoke());
+        }
+        
+        /// <summary>
+        /// Get original parent for restoration
+        /// </summary>
+        public Transform GetOriginalParent()
+        {
+            return _originalParent;
+        }
+        
+        /// <summary>
+        /// Get original local position for restoration
+        /// </summary>
+        public Vector3 GetOriginalLocalPosition()
+        {
+            return _originalLocalPosition;
+        }
+        
+        /// <summary>
+        /// Get original local rotation for restoration
+        /// </summary>
+        public Quaternion GetOriginalLocalRotation()
+        {
+            return _originalLocalRotation;
+        }
+        
+        /// <summary>
+        /// Check if card is currently enlarged
+        /// </summary>
+        public bool IsEnlarged => _isEnlarged;
+        
+        /// <summary>
+        /// Force reset enlarged state (for cleanup scenarios like page closing)
+        /// </summary>
+        public void ForceResetEnlargedState()
+        {
+            _isEnlarged = false;
+            transform.localScale = _originalScale;
+        }
+    }
+}
+