818 lines
32 KiB
C#
818 lines
32 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using AppleHills.Data.CardSystem;
|
|
using Core;
|
|
using Data.CardSystem;
|
|
using Pixelplacement;
|
|
using UI.Core;
|
|
using UI.CardSystem.DragDrop;
|
|
using UI.DragAndDrop.Core;
|
|
using Unity.Cinemachine;
|
|
using UnityEngine;
|
|
using UnityEngine.Serialization;
|
|
using UnityEngine.UI;
|
|
|
|
namespace UI.CardSystem
|
|
{
|
|
/// <summary>
|
|
/// UI page for opening booster packs and displaying the cards received.
|
|
/// Manages the entire booster opening flow with drag-and-drop interaction.
|
|
/// </summary>
|
|
public class BoosterOpeningPage : UIPage
|
|
{
|
|
[Header("UI References")]
|
|
[SerializeField] private CanvasGroup canvasGroup;
|
|
|
|
[Header("Booster Management")]
|
|
[SerializeField] private GameObject boosterPackPrefab; // Prefab to instantiate new boosters
|
|
[SerializeField] private SlotContainer bottomRightSlots; // Holds waiting boosters (max 3)
|
|
[SerializeField] private DraggableSlot centerOpeningSlot; // Where booster goes to open
|
|
|
|
[Header("Card Display")]
|
|
[SerializeField] private Transform cardDisplayContainer;
|
|
[FormerlySerializedAs("flippableCardPrefab")]
|
|
[SerializeField] private GameObject cardPrefab; // New Card prefab using state machine
|
|
[SerializeField] private float cardSpacing = 150f;
|
|
[SerializeField] private float cardWidth = 400f;
|
|
[SerializeField] private float cardHeight = 540f;
|
|
|
|
[Header("Settings")]
|
|
[SerializeField] private float boosterDisappearDuration = 0.5f;
|
|
[SerializeField] private CinemachineImpulseSource impulseSource;
|
|
[SerializeField] private ParticleSystem openingParticleSystem;
|
|
[SerializeField] private GameObject albumIcon; // Target for card fly-away animation and dismiss button
|
|
|
|
private Button _dismissButton; // Button to close/dismiss the booster opening page
|
|
private int _availableBoosterCount;
|
|
private BoosterPackDraggable _currentBoosterInCenter;
|
|
private List<BoosterPackDraggable> _activeBoostersInSlots = new List<BoosterPackDraggable>();
|
|
private List<GameObject> _currentRevealedCards = new List<GameObject>();
|
|
private List<StateMachine.Card> _currentCards = new List<StateMachine.Card>();
|
|
private CardData[] _currentCardData;
|
|
private StateMachine.Card _activeCard; // Currently selected/revealing card
|
|
private int _cardsCompletedInteraction; // Track how many cards finished their reveal flow
|
|
private bool _isProcessingOpening;
|
|
private const int MAX_VISIBLE_BOOSTERS = 3;
|
|
private void Awake()
|
|
{
|
|
// Make sure we have a CanvasGroup for transitions
|
|
if (canvasGroup == null)
|
|
canvasGroup = GetComponent<CanvasGroup>();
|
|
if (canvasGroup == null)
|
|
canvasGroup = gameObject.AddComponent<CanvasGroup>();
|
|
|
|
// Get dismiss button from albumIcon GameObject
|
|
if (albumIcon != null)
|
|
{
|
|
_dismissButton = albumIcon.GetComponent<Button>();
|
|
if (_dismissButton != null)
|
|
{
|
|
_dismissButton.onClick.AddListener(OnDismissButtonClicked);
|
|
}
|
|
else
|
|
{
|
|
Logging.Warning("[BoosterOpeningPage] albumIcon does not have a Button component!");
|
|
}
|
|
}
|
|
|
|
// UI pages should start disabled
|
|
gameObject.SetActive(false);
|
|
}
|
|
|
|
internal override void OnManagedDestroy()
|
|
{
|
|
// Unsubscribe from dismiss button
|
|
if (_dismissButton != null)
|
|
{
|
|
_dismissButton.onClick.RemoveListener(OnDismissButtonClicked);
|
|
}
|
|
|
|
// Unsubscribe from slot events
|
|
if (centerOpeningSlot != null)
|
|
{
|
|
centerOpeningSlot.OnOccupied -= OnBoosterPlacedInCenter;
|
|
centerOpeningSlot.OnVacated -= OnBoosterRemovedFromCenter;
|
|
}
|
|
|
|
// Unsubscribe from booster events
|
|
UnsubscribeFromAllBoosters();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the number of available booster packs before showing the page
|
|
/// </summary>
|
|
public void SetAvailableBoosterCount(int count)
|
|
{
|
|
_availableBoosterCount = count;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when the dismiss button (albumIcon) is clicked
|
|
/// </summary>
|
|
private void OnDismissButtonClicked()
|
|
{
|
|
if (UIPageController.Instance != null)
|
|
{
|
|
UIPageController.Instance.PopPage();
|
|
Logging.Debug("[BoosterOpeningPage] Dismiss button clicked, popping page from stack");
|
|
}
|
|
}
|
|
|
|
public override void TransitionIn()
|
|
{
|
|
base.TransitionIn();
|
|
|
|
// Ensure album icon is visible when page opens
|
|
if (albumIcon != null)
|
|
{
|
|
albumIcon.SetActive(true);
|
|
}
|
|
|
|
InitializeBoosterDisplay();
|
|
}
|
|
|
|
public override void TransitionOut()
|
|
{
|
|
CleanupPage();
|
|
base.TransitionOut();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initialize the booster pack display based on available count
|
|
/// </summary>
|
|
private void InitializeBoosterDisplay()
|
|
{
|
|
Logging.Debug($"[BoosterOpeningPage] InitializeBoosterDisplay called with {_availableBoosterCount} boosters available");
|
|
|
|
if (boosterPackPrefab == null)
|
|
{
|
|
Logging.Warning("BoosterOpeningPage: No booster pack prefab assigned!");
|
|
return;
|
|
}
|
|
|
|
if (bottomRightSlots == null || bottomRightSlots.SlotCount == 0)
|
|
{
|
|
Logging.Warning("BoosterOpeningPage: No slots available!");
|
|
return;
|
|
}
|
|
|
|
// Clear any existing boosters
|
|
_activeBoostersInSlots.Clear();
|
|
|
|
// Calculate how many boosters to show (max 3, or available count, whichever is lower)
|
|
int visibleCount = Mathf.Min(_availableBoosterCount, MAX_VISIBLE_BOOSTERS);
|
|
|
|
Logging.Debug($"[BoosterOpeningPage] Will spawn {visibleCount} boosters");
|
|
|
|
// Spawn boosters and assign to slots
|
|
for (int i = 0; i < visibleCount; i++)
|
|
{
|
|
SpawnBoosterInSlot(i);
|
|
}
|
|
|
|
// Subscribe to center slot events
|
|
if (centerOpeningSlot != null)
|
|
{
|
|
centerOpeningSlot.OnOccupied += OnBoosterPlacedInCenter;
|
|
centerOpeningSlot.OnVacated += OnBoosterRemovedFromCenter;
|
|
Logging.Debug($"[BoosterOpeningPage] Subscribed to center slot events");
|
|
}
|
|
else
|
|
{
|
|
Logging.Warning("[BoosterOpeningPage] centerOpeningSlot is null!");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Spawn a new booster and place it in the specified slot index
|
|
/// </summary>
|
|
private void SpawnBoosterInSlot(int slotIndex)
|
|
{
|
|
DraggableSlot slot = FindSlotByIndex(slotIndex);
|
|
if (slot == null)
|
|
{
|
|
Logging.Warning($"[BoosterOpeningPage] Could not find slot with SlotIndex {slotIndex}!");
|
|
return;
|
|
}
|
|
|
|
// Instantiate booster
|
|
GameObject boosterObj = Instantiate(boosterPackPrefab, slot.transform);
|
|
BoosterPackDraggable booster = boosterObj.GetComponent<BoosterPackDraggable>();
|
|
|
|
if (booster != null)
|
|
{
|
|
// Reset state
|
|
booster.ResetTapCount();
|
|
booster.SetTapToOpenEnabled(false);
|
|
|
|
// Subscribe to events
|
|
booster.OnReadyToOpen += OnBoosterReadyToOpen;
|
|
|
|
// Assign to slot with animation
|
|
booster.AssignToSlot(slot, true);
|
|
|
|
// Track it
|
|
_activeBoostersInSlots.Add(booster);
|
|
|
|
Logging.Debug($"[BoosterOpeningPage] Spawned booster in slot with SlotIndex {slotIndex}");
|
|
}
|
|
else
|
|
{
|
|
Logging.Warning($"[BoosterOpeningPage] Spawned booster has no BoosterPackDraggable component!");
|
|
Destroy(boosterObj);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Remove and destroy the booster from the specified slot
|
|
/// </summary>
|
|
private void RemoveBoosterFromSlot(int slotIndex)
|
|
{
|
|
if (slotIndex >= _activeBoostersInSlots.Count)
|
|
return;
|
|
|
|
BoosterPackDraggable booster = _activeBoostersInSlots[slotIndex];
|
|
if (booster != null)
|
|
{
|
|
// Unsubscribe from events
|
|
booster.OnReadyToOpen -= OnBoosterReadyToOpen;
|
|
|
|
// Animate out and destroy
|
|
Transform boosterTransform = booster.transform;
|
|
Tween.LocalScale(boosterTransform, Vector3.zero, 0.3f, 0f, Tween.EaseInBack,
|
|
completeCallback: () =>
|
|
{
|
|
if (booster != null && booster.gameObject != null)
|
|
{
|
|
Destroy(booster.gameObject);
|
|
}
|
|
});
|
|
|
|
// Remove from slot
|
|
if (booster.CurrentSlot != null)
|
|
{
|
|
booster.CurrentSlot.Vacate();
|
|
}
|
|
|
|
Logging.Debug($"[BoosterOpeningPage] Removed booster from slot {slotIndex}");
|
|
}
|
|
|
|
_activeBoostersInSlots.RemoveAt(slotIndex);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update visible boosters based on available count
|
|
/// </summary>
|
|
private void UpdateVisibleBoosters()
|
|
{
|
|
int targetCount = Mathf.Min(_availableBoosterCount, MAX_VISIBLE_BOOSTERS);
|
|
|
|
// Remove excess boosters (from the end)
|
|
while (_activeBoostersInSlots.Count > targetCount)
|
|
{
|
|
int lastIndex = _activeBoostersInSlots.Count - 1;
|
|
RemoveBoosterFromSlot(lastIndex);
|
|
}
|
|
|
|
Logging.Debug($"[BoosterOpeningPage] Updated visible boosters: {_activeBoostersInSlots.Count}/{targetCount}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Shuffle boosters so they always occupy the first available slots
|
|
/// </summary>
|
|
private void ShuffleBoostersToFront()
|
|
{
|
|
if (_activeBoostersInSlots.Count == 0) return;
|
|
|
|
Logging.Debug($"[BoosterOpeningPage] Shuffling {_activeBoostersInSlots.Count} boosters to front slots");
|
|
|
|
// Unassign all boosters from their current slots
|
|
foreach (var booster in _activeBoostersInSlots)
|
|
{
|
|
if (booster.CurrentSlot != null)
|
|
{
|
|
booster.CurrentSlot.Vacate();
|
|
}
|
|
}
|
|
|
|
// Reassign boosters to first N slots starting from slot with SlotIndex 0
|
|
for (int i = 0; i < _activeBoostersInSlots.Count; i++)
|
|
{
|
|
// Find slot by its actual SlotIndex property
|
|
DraggableSlot targetSlot = FindSlotByIndex(i);
|
|
BoosterPackDraggable booster = _activeBoostersInSlots[i];
|
|
|
|
if (targetSlot != null)
|
|
{
|
|
Logging.Debug($"[BoosterOpeningPage] Assigning booster to slot with SlotIndex {i} {targetSlot.name}");
|
|
booster.AssignToSlot(targetSlot, true); // Animate the move
|
|
}
|
|
else
|
|
{
|
|
Logging.Warning($"[BoosterOpeningPage] Could not find slot with SlotIndex {i} {targetSlot.name}");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find a slot by its SlotIndex property (not list position)
|
|
/// </summary>
|
|
private DraggableSlot FindSlotByIndex(int slotIndex)
|
|
{
|
|
foreach (var slot in bottomRightSlots.Slots)
|
|
{
|
|
if (slot.SlotIndex == slotIndex)
|
|
{
|
|
return slot;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Try to spawn a new booster to maintain up to 3 visible
|
|
/// Pass decrementCount=true when called after placing a booster in center slot
|
|
/// (accounts for the booster that will be consumed)
|
|
/// </summary>
|
|
private void TrySpawnNewBooster(bool decrementCount = false)
|
|
{
|
|
// Can we spawn more boosters?
|
|
if (_activeBoostersInSlots.Count >= MAX_VISIBLE_BOOSTERS)
|
|
return; // Already at max
|
|
|
|
// Use decremented count if this is called after placing in center
|
|
// (the booster in center will be consumed, so we check against count - 1)
|
|
int effectiveCount = decrementCount ? _availableBoosterCount - 1 : _availableBoosterCount;
|
|
|
|
if (_activeBoostersInSlots.Count >= effectiveCount)
|
|
return; // No more boosters available
|
|
|
|
// Find first available slot by SlotIndex (0, 1, 2)
|
|
for (int i = 0; i < MAX_VISIBLE_BOOSTERS; i++)
|
|
{
|
|
DraggableSlot slot = FindSlotByIndex(i);
|
|
if (slot != null && !slot.IsOccupied)
|
|
{
|
|
SpawnBoosterInSlot(i);
|
|
Logging.Debug($"[BoosterOpeningPage] Spawned new booster in slot with SlotIndex {i}");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle when a booster is placed in the center opening slot
|
|
/// </summary>
|
|
private void OnBoosterPlacedInCenter(DraggableObject draggable)
|
|
{
|
|
BoosterPackDraggable booster = draggable as BoosterPackDraggable;
|
|
if (booster == null) return;
|
|
|
|
_currentBoosterInCenter = booster;
|
|
|
|
// Remove from active slots list
|
|
_activeBoostersInSlots.Remove(booster);
|
|
|
|
// Hide album icon when booster is placed in center
|
|
if (albumIcon != null)
|
|
{
|
|
albumIcon.SetActive(false);
|
|
Logging.Debug($"[BoosterOpeningPage] Album icon hidden");
|
|
}
|
|
|
|
// Lock the slot so it can't be dragged out
|
|
Logging.Debug($"[BoosterOpeningPage] Locking center slot. IsLocked before: {centerOpeningSlot.IsLocked}");
|
|
centerOpeningSlot.SetLocked(true);
|
|
Logging.Debug($"[BoosterOpeningPage] IsLocked after: {centerOpeningSlot.IsLocked}");
|
|
|
|
// Configure booster for opening (disables drag, enables tapping, resets tap count)
|
|
Logging.Debug($"[BoosterOpeningPage] Calling SetInOpeningSlot(true) on booster");
|
|
booster.SetInOpeningSlot(true);
|
|
|
|
// Subscribe to tap events for visual feedback
|
|
booster.OnTapped += OnBoosterTapped;
|
|
booster.OnReadyToOpen += OnBoosterReadyToOpen;
|
|
booster.OnBoosterOpened += OnBoosterOpened;
|
|
|
|
// Try to spawn a new booster to maintain 3 visible
|
|
// Use decrementCount=true because this booster will be consumed
|
|
TrySpawnNewBooster(decrementCount: true);
|
|
|
|
// Shuffle remaining boosters to occupy the first slots
|
|
ShuffleBoostersToFront();
|
|
|
|
Logging.Debug($"[BoosterOpeningPage] Booster placed in center, ready for taps. Active boosters in slots: {_activeBoostersInSlots.Count}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle when a booster is removed from the center opening slot
|
|
/// </summary>
|
|
private void OnBoosterRemovedFromCenter(DraggableObject draggable)
|
|
{
|
|
BoosterPackDraggable booster = draggable as BoosterPackDraggable;
|
|
if (booster == null) return;
|
|
|
|
// If it's being removed back to a corner slot, add it back to tracking
|
|
if (booster.CurrentSlot != null && bottomRightSlots.HasSlot(booster.CurrentSlot))
|
|
{
|
|
_activeBoostersInSlots.Add(booster);
|
|
booster.SetInOpeningSlot(false);
|
|
}
|
|
|
|
_currentBoosterInCenter = null;
|
|
Logging.Debug($"[BoosterOpeningPage] Booster removed from center");
|
|
}
|
|
|
|
private void OnBoosterTapped(BoosterPackDraggable booster, int currentTaps, int maxTaps)
|
|
{
|
|
Logging.Debug($"[BoosterOpeningPage] Booster tapped: {currentTaps}/{maxTaps}");
|
|
|
|
// Fire Cinemachine impulse with random velocity (excluding Z)
|
|
if (impulseSource != null)
|
|
{
|
|
// Generate random velocity vector (X and Y only, Z = 0)
|
|
Vector3 randomVelocity = new Vector3(
|
|
Random.Range(-1f, 1f),
|
|
Random.Range(-1f, 1f),
|
|
0f
|
|
);
|
|
|
|
// Normalize to ensure consistent strength
|
|
randomVelocity.Normalize();
|
|
|
|
// Generate the impulse with strength 1 and random velocity
|
|
impulseSource.GenerateImpulse(randomVelocity);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle when booster is opened - play particle effects
|
|
/// </summary>
|
|
private void OnBoosterOpened(BoosterPackDraggable booster)
|
|
{
|
|
Logging.Debug($"[BoosterOpeningPage] Booster opened, playing particle effect");
|
|
|
|
// Reset and play particle system
|
|
if (openingParticleSystem != null)
|
|
{
|
|
// Stop any existing playback
|
|
if (openingParticleSystem.isPlaying)
|
|
{
|
|
openingParticleSystem.Stop();
|
|
}
|
|
|
|
// Clear existing particles
|
|
openingParticleSystem.Clear();
|
|
|
|
// Play the particle system
|
|
openingParticleSystem.Play();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle tap-to-place: When player taps a booster in bottom slots, move it to center
|
|
/// </summary>
|
|
public void OnBoosterTappedInBottomSlot(BoosterPackDraggable booster)
|
|
{
|
|
if (_currentBoosterInCenter != null || centerOpeningSlot == null)
|
|
return; // Center slot already occupied
|
|
|
|
// Move booster to center slot
|
|
booster.AssignToSlot(centerOpeningSlot, true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle when booster is ready to open (after max taps)
|
|
/// </summary>
|
|
private void OnBoosterReadyToOpen(BoosterPackDraggable booster)
|
|
{
|
|
if (_isProcessingOpening) return;
|
|
|
|
Logging.Debug($"[BoosterOpeningPage] Booster ready to open!");
|
|
|
|
// Trigger the actual opening sequence
|
|
booster.TriggerOpen();
|
|
StartCoroutine(ProcessBoosterOpening(booster));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Process the booster opening sequence
|
|
/// </summary>
|
|
private IEnumerator ProcessBoosterOpening(BoosterPackDraggable booster)
|
|
{
|
|
_isProcessingOpening = true;
|
|
|
|
// Call CardSystemManager to open the pack
|
|
if (CardSystemManager.Instance != null)
|
|
{
|
|
List<CardData> revealedCardsList = CardSystemManager.Instance.OpenBoosterPack();
|
|
_currentCardData = revealedCardsList.ToArray();
|
|
|
|
// Animate booster disappearing
|
|
yield return StartCoroutine(AnimateBoosterDisappear(booster));
|
|
|
|
// Decrement available count
|
|
_availableBoosterCount--;
|
|
|
|
// Update visible boosters (remove from end if we drop below thresholds)
|
|
UpdateVisibleBoosters();
|
|
|
|
// Show cards using new Card prefab
|
|
SpawnBoosterCards(_currentCardData);
|
|
|
|
// Wait for player to reveal all cards
|
|
bool isLastBooster = _availableBoosterCount <= 0;
|
|
yield return StartCoroutine(WaitForCardReveals());
|
|
|
|
// Check if this was the last booster pack
|
|
if (isLastBooster)
|
|
{
|
|
// See earlier comment for timing
|
|
Logging.Debug("[BoosterOpeningPage] Last booster opened, auto-transitioning to album main page");
|
|
if (UIPageController.Instance != null)
|
|
{
|
|
UIPageController.Instance.PopPage();
|
|
}
|
|
}
|
|
}
|
|
|
|
_isProcessingOpening = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Spawn cards for booster opening flow using the new Card prefab and state machine.
|
|
/// </summary>
|
|
private void SpawnBoosterCards(CardData[] cards)
|
|
{
|
|
if (cardPrefab == null || cardDisplayContainer == null)
|
|
{
|
|
Logging.Warning("BoosterOpeningPage: Missing card prefab or container!");
|
|
return;
|
|
}
|
|
|
|
_currentRevealedCards.Clear();
|
|
_currentCards.Clear();
|
|
_cardsCompletedInteraction = 0;
|
|
_activeCard = null;
|
|
|
|
int count = cards.Length;
|
|
float totalWidth = (count - 1) * cardSpacing;
|
|
float startX = -totalWidth / 2f;
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
GameObject cardObj = Instantiate(cardPrefab, cardDisplayContainer);
|
|
RectTransform cardRect = cardObj.GetComponent<RectTransform>();
|
|
if (cardRect != null)
|
|
{
|
|
cardRect.anchoredPosition = new Vector2(startX + (i * cardSpacing), 0);
|
|
cardRect.sizeDelta = new Vector2(cardWidth, cardHeight); // Set card size
|
|
cardRect.localScale = Vector3.zero; // for pop-in
|
|
}
|
|
|
|
var card = cardObj.GetComponent<StateMachine.Card>();
|
|
var context = cardObj.GetComponent<StateMachine.CardContext>();
|
|
if (card != null && context != null)
|
|
{
|
|
// Setup card for booster reveal
|
|
// States will query CardSystemManager for current collection state as needed
|
|
context.SetupCard(cards[i]);
|
|
card.SetupForBoosterReveal(cards[i], false); // isNew parameter not used anymore
|
|
card.SetDraggingEnabled(false);
|
|
|
|
// Subscribe to CardDisplay click for selection
|
|
context.CardDisplay.OnCardClicked += (_) => OnCardClicked(card);
|
|
|
|
// Subscribe to reveal flow complete event from booster context
|
|
context.BoosterContext.OnRevealFlowComplete += () => OnCardRevealComplete(card);
|
|
|
|
// Track the card
|
|
_currentCards.Add(card);
|
|
|
|
// Tween in
|
|
Tween.LocalScale(cardObj.transform, Vector3.one, 0.3f, i * 0.1f, Tween.EaseOutBack);
|
|
}
|
|
else
|
|
{
|
|
Logging.Warning($"[BoosterOpeningPage] Card component or context missing on spawned card {i}!");
|
|
}
|
|
|
|
_currentRevealedCards.Add(cardObj);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle when a card is clicked - start reveal flow if conditions are met
|
|
/// </summary>
|
|
private void OnCardClicked(StateMachine.Card card)
|
|
{
|
|
// Only allow clicking idle cards when no other card is active
|
|
if (_activeCard == null && card.IsIdle && card.Context.IsClickable)
|
|
{
|
|
Logging.Debug($"[BoosterOpeningPage] Card {card.CardData?.Name} selected for reveal");
|
|
|
|
// Set as active and disable all other idle cards
|
|
_activeCard = card;
|
|
foreach (var otherCard in _currentCards)
|
|
{
|
|
if (otherCard != card && otherCard.IsIdle)
|
|
{
|
|
otherCard.Context.IsClickable = false;
|
|
}
|
|
}
|
|
|
|
// Click will route to IdleState automatically and trigger flip
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle when a card completes its reveal flow
|
|
/// </summary>
|
|
private void OnCardRevealComplete(StateMachine.Card card)
|
|
{
|
|
_cardsCompletedInteraction++;
|
|
|
|
Logging.Debug($"[BoosterOpeningPage] Card {card.CardData?.Name} reveal complete ({_cardsCompletedInteraction}/{_currentCardData.Length})");
|
|
|
|
// Add card to inventory NOW (after player saw it)
|
|
if (card.CardData != null)
|
|
{
|
|
Data.CardSystem.CardSystemManager.Instance.AddCardToInventoryDelayed(card.CardData);
|
|
}
|
|
|
|
// Clear active card and re-enable remaining idle cards
|
|
if (_activeCard == card)
|
|
{
|
|
_activeCard = null;
|
|
|
|
foreach (var otherCard in _currentCards)
|
|
{
|
|
if (otherCard.IsIdle)
|
|
{
|
|
otherCard.Context.IsClickable = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Animate the booster pack disappearing
|
|
/// </summary>
|
|
private IEnumerator AnimateBoosterDisappear(BoosterPackDraggable booster)
|
|
{
|
|
if (booster == null) yield break;
|
|
|
|
// Scale down and fade out
|
|
Transform boosterTransform = booster.transform;
|
|
|
|
Tween.LocalScale(boosterTransform, Vector3.zero, boosterDisappearDuration, 0f, Tween.EaseInBack);
|
|
|
|
// Also fade the visual if it has a CanvasGroup
|
|
CanvasGroup boosterCg = booster.GetComponentInChildren<CanvasGroup>();
|
|
if (boosterCg != null)
|
|
{
|
|
Tween.Value(1f, 0f, (val) => boosterCg.alpha = val, boosterDisappearDuration, 0f);
|
|
}
|
|
|
|
yield return new WaitForSeconds(boosterDisappearDuration);
|
|
|
|
// Destroy the booster
|
|
Destroy(booster.gameObject);
|
|
_currentBoosterInCenter = null;
|
|
|
|
// Unlock center slot
|
|
centerOpeningSlot.SetLocked(false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Wait until all cards complete their reveal flow
|
|
/// </summary>
|
|
private IEnumerator WaitForCardReveals()
|
|
{
|
|
// Wait until all cards have completed their reveal flow
|
|
while (_cardsCompletedInteraction < _currentCardData.Length)
|
|
{
|
|
yield return null;
|
|
}
|
|
|
|
Logging.Debug($"[BoosterOpeningPage] All cards revealed! Animating cards to album...");
|
|
|
|
// Small pause
|
|
yield return new WaitForSeconds(0.5f);
|
|
|
|
// Show album icon before cards start tweening to it
|
|
if (albumIcon != null)
|
|
{
|
|
albumIcon.SetActive(true);
|
|
Logging.Debug($"[BoosterOpeningPage] Album icon shown for card tween target");
|
|
}
|
|
|
|
// Animate cards to album icon (or center if no icon assigned) with staggered delays
|
|
Vector3 targetPosition = albumIcon != null ? albumIcon.transform.position : Vector3.zero;
|
|
|
|
int cardIndex = 0;
|
|
foreach (GameObject cardObj in _currentRevealedCards)
|
|
{
|
|
if (cardObj != null)
|
|
{
|
|
float delay = cardIndex * 0.5f;
|
|
// Use world space position tween for root transform
|
|
Tween.Position(cardObj.transform, targetPosition, 0.5f, delay, Tween.EaseInBack);
|
|
Tween.LocalScale(cardObj.transform, Vector3.zero, 0.5f, delay, Tween.EaseInBack,
|
|
completeCallback: () => { if (cardObj != null) Destroy(cardObj); });
|
|
cardIndex++;
|
|
}
|
|
}
|
|
|
|
float totalAnimationTime = _currentCardData.Length * 0.5f;
|
|
_currentRevealedCards.Clear();
|
|
_currentCards.Clear();
|
|
|
|
yield return new WaitForSeconds(totalAnimationTime);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clean up the page when hidden
|
|
/// </summary>
|
|
private void CleanupPage()
|
|
{
|
|
UnsubscribeFromAllBoosters();
|
|
|
|
// Destroy all active boosters
|
|
foreach (var booster in _activeBoostersInSlots.ToList())
|
|
{
|
|
if (booster != null && booster.gameObject != null)
|
|
Destroy(booster.gameObject);
|
|
}
|
|
_activeBoostersInSlots.Clear();
|
|
|
|
// Clear any remaining cards
|
|
foreach (GameObject card in _currentRevealedCards)
|
|
{
|
|
if (card != null)
|
|
Destroy(card);
|
|
}
|
|
_currentRevealedCards.Clear();
|
|
|
|
_currentBoosterInCenter = null;
|
|
_isProcessingOpening = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Unsubscribe from all booster events
|
|
/// </summary>
|
|
private void UnsubscribeFromAllBoosters()
|
|
{
|
|
// Unsubscribe from active boosters in slots
|
|
foreach (var booster in _activeBoostersInSlots)
|
|
{
|
|
if (booster != null)
|
|
{
|
|
booster.OnReadyToOpen -= OnBoosterReadyToOpen;
|
|
booster.OnTapped -= OnBoosterTapped;
|
|
booster.OnBoosterOpened -= OnBoosterOpened;
|
|
}
|
|
}
|
|
|
|
// Unsubscribe from center booster
|
|
if (_currentBoosterInCenter != null)
|
|
{
|
|
_currentBoosterInCenter.OnReadyToOpen -= OnBoosterReadyToOpen;
|
|
_currentBoosterInCenter.OnTapped -= OnBoosterTapped;
|
|
_currentBoosterInCenter.OnBoosterOpened -= OnBoosterOpened;
|
|
}
|
|
}
|
|
|
|
protected override void DoTransitionIn(System.Action onComplete)
|
|
{
|
|
// Simple fade in animation
|
|
if (canvasGroup != null)
|
|
{
|
|
canvasGroup.alpha = 0f;
|
|
Tween.Value(0f, 1f, (value) => canvasGroup.alpha = value, transitionDuration, 0f, Tween.EaseInOut, Tween.LoopType.None, null, onComplete, obeyTimescale: false);
|
|
}
|
|
else
|
|
{
|
|
// Fallback if no CanvasGroup
|
|
onComplete?.Invoke();
|
|
}
|
|
}
|
|
|
|
protected override void DoTransitionOut(System.Action onComplete)
|
|
{
|
|
// Simple fade out animation
|
|
if (canvasGroup != null)
|
|
{
|
|
Tween.Value(canvasGroup.alpha, 0f, (value) => canvasGroup.alpha = value, transitionDuration, 0f, Tween.EaseInOut, Tween.LoopType.None, null, onComplete, obeyTimescale: false);
|
|
}
|
|
else
|
|
{
|
|
// Fallback if no CanvasGroup
|
|
onComplete?.Invoke();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|