352 lines
13 KiB
C#
352 lines
13 KiB
C#
using AppleHills.Data.CardSystem;
|
|
using Data.CardSystem;
|
|
using UI.DragAndDrop.Core;
|
|
using UnityEngine;
|
|
using UnityEngine.EventSystems;
|
|
|
|
namespace UI.CardSystem
|
|
{
|
|
/// <summary>
|
|
/// Specialized slot for album pages that only accepts a specific card.
|
|
/// Validates cards based on their CardDefinition.
|
|
/// Self-populates with owned cards when enabled.
|
|
/// Shows preview of target card when empty slot is tapped.
|
|
/// </summary>
|
|
public class AlbumCardSlot : DraggableSlot, IPointerClickHandler
|
|
{
|
|
[Header("Album Slot Configuration")]
|
|
[SerializeField] private CardDefinition targetCardDefinition; // Which card this slot accepts
|
|
[SerializeField] private GameObject albumCardPrefab; // Prefab to spawn when card is owned
|
|
|
|
[Header("Preview Card (for empty slots)")]
|
|
[SerializeField] private CardDisplay previewCardDisplay; // Nested CardDisplay showing greyed-out preview
|
|
[SerializeField] private float previewEnlargedScale = 2.5f;
|
|
[SerializeField] private float previewScaleDuration = 0.3f;
|
|
|
|
private bool _isOccupiedPermanently = false;
|
|
private AlbumCard _placedCard;
|
|
private bool _isPreviewShowing = false;
|
|
private Vector3 _previewOriginalScale;
|
|
|
|
private void Awake()
|
|
{
|
|
// Store original scale of preview card
|
|
if (previewCardDisplay != null)
|
|
{
|
|
_previewOriginalScale = previewCardDisplay.transform.localScale;
|
|
// Hide preview card by default
|
|
previewCardDisplay.gameObject.SetActive(false);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the target card this slot should accept
|
|
/// </summary>
|
|
public void SetTargetCard(CardDefinition definition)
|
|
{
|
|
targetCardDefinition = definition;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if this slot can accept a specific card
|
|
/// </summary>
|
|
public bool CanAcceptCard(CardData cardData)
|
|
{
|
|
if (cardData == null || targetCardDefinition == null) return false;
|
|
if (_isOccupiedPermanently) return false;
|
|
|
|
// Card must match this slot's target definition
|
|
return cardData.DefinitionId == targetCardDefinition.Id;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when a card is successfully placed in this slot
|
|
/// </summary>
|
|
public void OnCardPlaced(AlbumCard albumCard = null)
|
|
{
|
|
_isOccupiedPermanently = true;
|
|
|
|
if (albumCard != null)
|
|
{
|
|
_placedCard = albumCard;
|
|
albumCard.SetParentSlot(this);
|
|
|
|
// Register with AlbumViewPage for enlarge/shrink handling
|
|
AlbumViewPage albumPage = FindObjectOfType<AlbumViewPage>();
|
|
if (albumPage != null)
|
|
{
|
|
albumPage.RegisterAlbumCard(albumCard);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if this slot has a placed card
|
|
/// </summary>
|
|
public bool HasPlacedCard()
|
|
{
|
|
return _placedCard != null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the placed card (if any)
|
|
/// </summary>
|
|
public AlbumCard GetPlacedCard()
|
|
{
|
|
return _placedCard;
|
|
}
|
|
|
|
private void OnEnable()
|
|
{
|
|
// Check if we should spawn a card for this slot
|
|
CheckAndSpawnOwnedCard();
|
|
|
|
// Setup preview card display if slot is empty
|
|
SetupPreviewCard();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Setup the preview card display to show target card with preview visuals
|
|
/// Preview stays hidden until user taps to show it
|
|
/// </summary>
|
|
private void SetupPreviewCard()
|
|
{
|
|
if (previewCardDisplay == null || targetCardDefinition == null)
|
|
return;
|
|
|
|
// Only setup preview if slot is empty
|
|
if (_isOccupiedPermanently || _placedCard != null)
|
|
{
|
|
// Hide preview if slot is occupied
|
|
previewCardDisplay.gameObject.SetActive(false);
|
|
return;
|
|
}
|
|
|
|
// Setup preview card data
|
|
CardData previewData = targetCardDefinition.CreateCardData();
|
|
previewData.Rarity = CardRarity.Normal; // Show as normal rarity
|
|
previewCardDisplay.SetupCard(previewData);
|
|
|
|
// Apply preview visuals (black tint and ?????? name)
|
|
previewCardDisplay.SetPreviewVisuals();
|
|
|
|
// Keep preview hidden - it'll show when user taps to enlarge
|
|
previewCardDisplay.gameObject.SetActive(false);
|
|
|
|
Debug.Log($"[AlbumCardSlot] Setup preview card for {targetCardDefinition.Name} (hidden until tap)");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if player owns the card for this slot and spawn it if so
|
|
/// </summary>
|
|
private void CheckAndSpawnOwnedCard()
|
|
{
|
|
// Guard: need CardSystemManager and target definition
|
|
if (CardSystemManager.Instance == null || targetCardDefinition == null)
|
|
return;
|
|
|
|
// Guard: don't spawn if already occupied
|
|
if (_isOccupiedPermanently || _placedCard != null)
|
|
return;
|
|
|
|
// Guard: need prefab to spawn
|
|
if (albumCardPrefab == null)
|
|
{
|
|
Debug.LogWarning($"[AlbumCardSlot] No albumCardPrefab assigned for slot targeting {targetCardDefinition.name}");
|
|
return;
|
|
}
|
|
|
|
// Check if player owns this card at ANY rarity (prioritize highest rarity)
|
|
CardData ownedCard = null;
|
|
|
|
// Check in order: Legendary > Rare > Normal
|
|
foreach (CardRarity rarity in new[] { CardRarity.Legendary, CardRarity.Rare, CardRarity.Normal })
|
|
{
|
|
CardData card = CardSystemManager.Instance.GetCardInventory().GetCard(targetCardDefinition.Id, rarity);
|
|
if (card != null)
|
|
{
|
|
ownedCard = card;
|
|
break; // Found highest rarity owned
|
|
}
|
|
}
|
|
|
|
// Spawn card if owned
|
|
if (ownedCard != null)
|
|
{
|
|
SpawnAlbumCard(ownedCard);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Spawn an AlbumCard in this slot
|
|
/// </summary>
|
|
private void SpawnAlbumCard(CardData cardData)
|
|
{
|
|
GameObject cardObj = Instantiate(albumCardPrefab, transform);
|
|
AlbumCard albumCard = cardObj.GetComponent<AlbumCard>();
|
|
|
|
if (albumCard != null)
|
|
{
|
|
albumCard.SetupCard(cardData);
|
|
albumCard.SetParentSlot(this);
|
|
_placedCard = albumCard;
|
|
_isOccupiedPermanently = true;
|
|
|
|
// Register with AlbumViewPage for enlarge/shrink handling
|
|
AlbumViewPage albumPage = FindObjectOfType<AlbumViewPage>();
|
|
if (albumPage != null)
|
|
{
|
|
albumPage.RegisterAlbumCard(albumCard);
|
|
}
|
|
|
|
Debug.Log($"[AlbumCardSlot] Spawned owned card '{cardData.Name}' ({cardData.Rarity}) in slot");
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning($"[AlbumCardSlot] Spawned prefab has no AlbumCard component!");
|
|
Destroy(cardObj);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the target card definition for this slot
|
|
/// </summary>
|
|
public CardDefinition GetTargetCardDefinition()
|
|
{
|
|
return targetCardDefinition;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle click on slot - show/hide preview if empty
|
|
/// </summary>
|
|
public void OnPointerClick(PointerEventData eventData)
|
|
{
|
|
Debug.Log($"[CLICK-TRACE-SLOT] OnPointerClick on {name}, _isOccupiedPermanently={_isOccupiedPermanently}, _placedCard={((_placedCard != null) ? _placedCard.name : "NULL")}, _isPreviewShowing={_isPreviewShowing}, position={eventData.position}");
|
|
|
|
// Only handle clicks if slot is empty
|
|
if (_isOccupiedPermanently || _placedCard != null)
|
|
{
|
|
Debug.Log($"[CLICK-TRACE-SLOT] {name} - Slot is occupied, ignoring");
|
|
return;
|
|
}
|
|
|
|
// Only handle if we have a preview card setup
|
|
if (previewCardDisplay == null || targetCardDefinition == null)
|
|
{
|
|
Debug.Log($"[CLICK-TRACE-SLOT] {name} - No preview setup, ignoring");
|
|
return;
|
|
}
|
|
|
|
if (_isPreviewShowing)
|
|
{
|
|
Debug.Log($"[CLICK-TRACE-SLOT] {name} - Preview is showing, hiding it");
|
|
HidePreview();
|
|
}
|
|
else
|
|
{
|
|
Debug.Log($"[CLICK-TRACE-SLOT] {name} - Preview is hidden, showing it");
|
|
ShowPreview();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Show enlarged preview of target card
|
|
/// </summary>
|
|
private void ShowPreview()
|
|
{
|
|
if (_isPreviewShowing || previewCardDisplay == null)
|
|
return;
|
|
|
|
_isPreviewShowing = true;
|
|
|
|
// Show the preview card (already has preview visuals applied)
|
|
previewCardDisplay.gameObject.SetActive(true);
|
|
|
|
// Enable preview mode so clicks on CardDisplay forward to this slot
|
|
previewCardDisplay.SetPreviewMode(true, this);
|
|
|
|
// Reset to normal scale before enlarging
|
|
previewCardDisplay.transform.localScale = _previewOriginalScale;
|
|
|
|
// Get AlbumViewPage to show backdrop and reparent
|
|
AlbumViewPage albumPage = FindObjectOfType<AlbumViewPage>();
|
|
if (albumPage != null)
|
|
{
|
|
albumPage.ShowSlotPreview(this, previewCardDisplay.transform);
|
|
}
|
|
|
|
// Scale up preview card
|
|
Pixelplacement.Tween.LocalScale(previewCardDisplay.transform, _previewOriginalScale * previewEnlargedScale,
|
|
previewScaleDuration, 0f, Pixelplacement.Tween.EaseOutBack);
|
|
|
|
Debug.Log($"[AlbumCardSlot] Showing preview for {targetCardDefinition.Name}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hide preview and return to normal
|
|
/// </summary>
|
|
private void HidePreview()
|
|
{
|
|
if (!_isPreviewShowing || previewCardDisplay == null)
|
|
return;
|
|
|
|
_isPreviewShowing = false;
|
|
|
|
// Disable preview mode on CardDisplay
|
|
previewCardDisplay.SetPreviewMode(false, null);
|
|
|
|
// Get AlbumViewPage to hide backdrop
|
|
AlbumViewPage albumPage = FindObjectOfType<AlbumViewPage>();
|
|
if (albumPage != null)
|
|
{
|
|
albumPage.HideSlotPreview(this, previewCardDisplay.transform, () =>
|
|
{
|
|
// After shrink completes, reparent back to slot
|
|
previewCardDisplay.transform.SetParent(transform, false);
|
|
|
|
// Reset RectTransform properties
|
|
RectTransform previewRect = previewCardDisplay.transform as RectTransform;
|
|
if (previewRect != null)
|
|
{
|
|
// Set anchors to stretch in all directions (matching original setup)
|
|
previewRect.anchorMin = Vector2.zero; // (0, 0)
|
|
previewRect.anchorMax = Vector2.one; // (1, 1)
|
|
|
|
// Reset offsets to zero (left, right, top, bottom all = 0)
|
|
previewRect.offsetMin = Vector2.zero; // Sets left and bottom to 0
|
|
previewRect.offsetMax = Vector2.zero; // Sets right and top to 0 (note: these are negative values internally)
|
|
|
|
previewRect.pivot = new Vector2(0.5f, 0.5f);
|
|
}
|
|
|
|
previewCardDisplay.transform.localPosition = Vector3.zero;
|
|
previewCardDisplay.transform.localRotation = Quaternion.identity;
|
|
previewCardDisplay.transform.localScale = _previewOriginalScale;
|
|
|
|
// Hide the preview card after returning to slot
|
|
previewCardDisplay.gameObject.SetActive(false);
|
|
|
|
Debug.Log($"[AlbumCardSlot] Preview hidden and reset for {targetCardDefinition.Name}");
|
|
});
|
|
}
|
|
|
|
Debug.Log($"[AlbumCardSlot] Hiding preview for {targetCardDefinition.Name}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Public method to dismiss preview - can be called by CardDisplay when clicked
|
|
/// </summary>
|
|
public void DismissPreview()
|
|
{
|
|
Debug.Log($"[CLICK-TRACE-SLOT] DismissPreview called on {name}");
|
|
HidePreview();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the target card definition for this slot
|
|
/// </summary>
|
|
public CardDefinition TargetCardDefinition => targetCardDefinition;
|
|
}
|
|
}
|
|
|