427 lines
16 KiB
C#
427 lines
16 KiB
C#
using System;
|
|
using System.Collections;
|
|
using Core;
|
|
using Data.CardSystem;
|
|
using Pixelplacement;
|
|
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
|
|
namespace UI.CardSystem
|
|
{
|
|
/// <summary>
|
|
/// UI component for granting booster packs from minigames.
|
|
/// Supports awarding 1 to N booster packs with visual animations.
|
|
/// Shows up to 3 booster packs visually. For more than 3, duplicates the first pack and tweens them sequentially.
|
|
/// </summary>
|
|
public class MinigameBoosterGiver : MonoBehaviour
|
|
{
|
|
public static MinigameBoosterGiver Instance { get; private set; }
|
|
|
|
[Header("Visual References")]
|
|
[SerializeField] private GameObject visualContainer;
|
|
[SerializeField] private RectTransform[] boosterImages; // Up to 3 booster pack visuals
|
|
[SerializeField] private RectTransform glowImage; // Single glow effect for all boosters
|
|
[SerializeField] private Button continueButton;
|
|
|
|
[Header("Animation Settings")]
|
|
[SerializeField] private float hoverAmount = 20f;
|
|
[SerializeField] private float hoverDuration = 1.5f;
|
|
[SerializeField] private float glowPulseMax = 1.1f;
|
|
[SerializeField] private float glowPulseDuration = 1.2f;
|
|
|
|
[Header("Disappear Animation")]
|
|
[SerializeField] private Vector2 targetBottomLeftOffset = new Vector2(100f, 100f);
|
|
[SerializeField] private float tweenDuration = 0.8f;
|
|
[SerializeField] private float delayBetweenTweens = 0.2f;
|
|
[SerializeField] private float disappearScale = 0.2f;
|
|
|
|
private Vector3[] _boosterInitialPositions;
|
|
private Vector3[] _boosterInitialScales;
|
|
private Vector3 _glowInitialScale;
|
|
private Coroutine _currentSequence;
|
|
private Action _onCompleteCallback;
|
|
private int _totalPackCount = 1;
|
|
|
|
private void Awake()
|
|
{
|
|
// Singleton pattern
|
|
if (Instance != null && Instance != this)
|
|
{
|
|
Logging.Warning("[MinigameBoosterGiver] Duplicate instance found. Destroying.");
|
|
Destroy(gameObject);
|
|
return;
|
|
}
|
|
|
|
Instance = this;
|
|
|
|
// Cache initial values for all booster images
|
|
if (boosterImages != null && boosterImages.Length > 0)
|
|
{
|
|
_boosterInitialPositions = new Vector3[boosterImages.Length];
|
|
_boosterInitialScales = new Vector3[boosterImages.Length];
|
|
|
|
for (int i = 0; i < boosterImages.Length; i++)
|
|
{
|
|
if (boosterImages[i] != null)
|
|
{
|
|
_boosterInitialPositions[i] = boosterImages[i].localPosition;
|
|
_boosterInitialScales[i] = boosterImages[i].localScale;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (glowImage != null)
|
|
{
|
|
_glowInitialScale = glowImage.localScale;
|
|
}
|
|
|
|
// Setup button listener
|
|
if (continueButton != null)
|
|
{
|
|
continueButton.onClick.AddListener(OnContinueClicked);
|
|
}
|
|
|
|
// Start hidden
|
|
if (visualContainer != null)
|
|
{
|
|
visualContainer.SetActive(false);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initialize the booster giver with a specific pack count.
|
|
/// Shows up to 3 booster visuals based on count.
|
|
/// </summary>
|
|
/// <param name="packCount">Number of booster packs to grant</param>
|
|
public void Initialize(int packCount)
|
|
{
|
|
_totalPackCount = Mathf.Max(1, packCount);
|
|
|
|
// Show up to 3 booster visuals
|
|
int visualCount = Mathf.Min(_totalPackCount, boosterImages.Length);
|
|
|
|
for (int i = 0; i < boosterImages.Length; i++)
|
|
{
|
|
bool shouldShow = i < visualCount;
|
|
if (boosterImages[i] != null)
|
|
{
|
|
boosterImages[i].gameObject.SetActive(shouldShow);
|
|
}
|
|
}
|
|
|
|
Logging.Debug($"[MinigameBoosterGiver] Initialized with {_totalPackCount} packs, showing {visualCount} visuals");
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
if (Instance == this)
|
|
{
|
|
Instance = null;
|
|
}
|
|
|
|
if (continueButton != null)
|
|
{
|
|
continueButton.onClick.RemoveListener(OnContinueClicked);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Public API to give a booster pack. Displays UI, starts animations, and waits for user interaction.
|
|
/// </summary>
|
|
/// <param name="onComplete">Optional callback when the sequence completes and pack is granted</param>
|
|
public void GiveBooster(Action onComplete = null)
|
|
{
|
|
if (_currentSequence != null)
|
|
{
|
|
Logging.Warning("[MinigameBoosterGiver] Already running a sequence. Ignoring new request.");
|
|
return;
|
|
}
|
|
|
|
_onCompleteCallback = onComplete;
|
|
_currentSequence = StartCoroutine(GiveBoosterSequence());
|
|
}
|
|
|
|
private IEnumerator GiveBoosterSequence()
|
|
{
|
|
// Show the visual
|
|
if (visualContainer != null)
|
|
{
|
|
visualContainer.SetActive(true);
|
|
}
|
|
|
|
// Reset positions and scales for visible boosters
|
|
int visualCount = Mathf.Min(_totalPackCount, boosterImages.Length);
|
|
|
|
for (int i = 0; i < visualCount; i++)
|
|
{
|
|
if (boosterImages[i] != null)
|
|
{
|
|
boosterImages[i].localPosition = _boosterInitialPositions[i];
|
|
boosterImages[i].localScale = _boosterInitialScales[i];
|
|
}
|
|
}
|
|
|
|
// Reset glow scale
|
|
if (glowImage != null)
|
|
{
|
|
glowImage.localScale = _glowInitialScale;
|
|
}
|
|
|
|
// Enable the continue button
|
|
if (continueButton != null)
|
|
{
|
|
continueButton.interactable = true;
|
|
}
|
|
|
|
// Start idle hovering animation on all visible boosters (ping-pong)
|
|
for (int i = 0; i < visualCount; i++)
|
|
{
|
|
if (boosterImages[i] != null)
|
|
{
|
|
Vector3 hoverTarget = _boosterInitialPositions[i] + Vector3.up * hoverAmount;
|
|
Tween.LocalPosition(boosterImages[i], hoverTarget, hoverDuration, 0f, Tween.EaseLinear, Tween.LoopType.PingPong);
|
|
}
|
|
}
|
|
|
|
// Start pulsing animation on the single glow (ping-pong scale)
|
|
if (glowImage != null)
|
|
{
|
|
Vector3 glowPulseScale = _glowInitialScale * glowPulseMax;
|
|
Tween.LocalScale(glowImage, glowPulseScale, glowPulseDuration, 0f, Tween.EaseOut, Tween.LoopType.PingPong);
|
|
}
|
|
|
|
// Wait for button click (handled by OnContinueClicked)
|
|
yield return null;
|
|
}
|
|
|
|
private void OnContinueClicked()
|
|
{
|
|
if (_currentSequence == null)
|
|
{
|
|
return; // Not in a sequence
|
|
}
|
|
|
|
// Disable and hide button to prevent double-clicks
|
|
if (continueButton != null)
|
|
{
|
|
continueButton.interactable = false;
|
|
continueButton.gameObject.SetActive(false);
|
|
}
|
|
|
|
// Start moving all boosters to backpack
|
|
StartCoroutine(MoveAllBoostersToBackpack());
|
|
}
|
|
|
|
private IEnumerator MoveAllBoostersToBackpack()
|
|
{
|
|
// Show scrapbook button temporarily using HUD visibility context
|
|
PlayerHudManager.HudVisibilityContext hudContext = null;
|
|
GameObject scrapbookButton = PlayerHudManager.Instance?.GetScrabookButton();
|
|
|
|
if (scrapbookButton != null)
|
|
{
|
|
hudContext = PlayerHudManager.Instance.ShowElementTemporarily(scrapbookButton);
|
|
}
|
|
else
|
|
{
|
|
Logging.Warning("[MinigameBoosterGiver] Scrapbook button not found in PlayerHudManager.");
|
|
}
|
|
|
|
// Calculate target position once
|
|
Vector3 targetPosition = GetTargetPosition(scrapbookButton);
|
|
|
|
int remaining = _totalPackCount;
|
|
int visualCount = Mathf.Min(_totalPackCount, boosterImages.Length);
|
|
|
|
// Stop and fade out the single glow immediately
|
|
if (glowImage != null)
|
|
{
|
|
Tween.Stop(glowImage.GetInstanceID());
|
|
Tween.LocalScale(glowImage, Vector3.zero, tweenDuration * 0.5f, 0f, Tween.EaseInBack);
|
|
}
|
|
|
|
// Phase 1: Animate duplicates for packs above 3 (if any)
|
|
int duplicatesToAnimate = Mathf.Max(0, _totalPackCount - 3);
|
|
|
|
for (int i = 0; i < duplicatesToAnimate; i++)
|
|
{
|
|
// Spawn duplicate at the first booster's current position
|
|
if (boosterImages.Length > 0 && boosterImages[0] != null)
|
|
{
|
|
StartCoroutine(TweenPackToBackpack(boosterImages[0], targetPosition, isDuplicate: true));
|
|
}
|
|
|
|
remaining--;
|
|
|
|
// Wait for stagger delay before next
|
|
if (i < duplicatesToAnimate - 1 || remaining > 0)
|
|
{
|
|
yield return new WaitForSeconds(delayBetweenTweens);
|
|
}
|
|
}
|
|
|
|
// Phase 2: Animate the actual visible packs (up to 3)
|
|
for (int i = 0; i < visualCount && i < remaining; i++)
|
|
{
|
|
if (boosterImages[i] != null)
|
|
{
|
|
// Stop hover animations first
|
|
Tween.Stop(boosterImages[i].GetInstanceID());
|
|
|
|
// Tween the actual booster
|
|
StartCoroutine(TweenPackToBackpack(boosterImages[i], targetPosition, isDuplicate: false));
|
|
}
|
|
|
|
// Wait for stagger delay before next (except after last one)
|
|
if (i < visualCount - 1 && i < remaining - 1)
|
|
{
|
|
yield return new WaitForSeconds(delayBetweenTweens);
|
|
}
|
|
}
|
|
|
|
// Wait for the last tween to complete
|
|
yield return new WaitForSeconds(tweenDuration);
|
|
|
|
// Grant all booster packs at once
|
|
if (CardSystemManager.Instance != null)
|
|
{
|
|
CardSystemManager.Instance.AddBoosterPack(_totalPackCount);
|
|
Logging.Debug($"[MinigameBoosterGiver] Granted {_totalPackCount} booster pack(s)!");
|
|
}
|
|
else
|
|
{
|
|
Logging.Warning("[MinigameBoosterGiver] CardSystemManager not found, cannot grant booster packs.");
|
|
}
|
|
|
|
// Hide scrapbook button by disposing the context
|
|
hudContext?.Dispose();
|
|
|
|
// Hide the visual container
|
|
if (visualContainer != null)
|
|
{
|
|
visualContainer.SetActive(false);
|
|
}
|
|
|
|
// Show button again for next use
|
|
if (continueButton != null)
|
|
{
|
|
continueButton.gameObject.SetActive(true);
|
|
}
|
|
|
|
// Invoke completion callback
|
|
_onCompleteCallback?.Invoke();
|
|
_onCompleteCallback = null;
|
|
|
|
// Clear sequence reference
|
|
_currentSequence = null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generic method to tween a booster pack to the backpack button.
|
|
/// Handles both duplicates (instantiated clones) and actual booster visuals.
|
|
/// </summary>
|
|
private IEnumerator TweenPackToBackpack(RectTransform sourceRect, Vector3 targetPosition, bool isDuplicate)
|
|
{
|
|
RectTransform packToAnimate;
|
|
|
|
if (isDuplicate)
|
|
{
|
|
// Create a clone at the source position
|
|
GameObject clone = Instantiate(sourceRect.gameObject, sourceRect.parent);
|
|
packToAnimate = clone.GetComponent<RectTransform>();
|
|
|
|
if (packToAnimate != null)
|
|
{
|
|
packToAnimate.localPosition = sourceRect.localPosition;
|
|
packToAnimate.localScale = sourceRect.localScale;
|
|
packToAnimate.gameObject.SetActive(true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
packToAnimate = sourceRect;
|
|
}
|
|
|
|
if (packToAnimate == null)
|
|
{
|
|
yield break;
|
|
}
|
|
|
|
// Tween to target position
|
|
Tween.LocalPosition(packToAnimate, targetPosition, tweenDuration, 0f, Tween.EaseInBack);
|
|
|
|
// Scale down
|
|
Vector3 targetScale = packToAnimate.localScale * disappearScale;
|
|
Tween.LocalScale(packToAnimate, targetScale, tweenDuration, 0f, Tween.EaseInBack);
|
|
|
|
// Don't wait here - let animations overlap
|
|
// Hide/destroy the booster after tween completes (duplicate or not)
|
|
// Since we destroy the entire UI instance anyway, just clean up visual artifacts
|
|
yield return new WaitForSeconds(tweenDuration);
|
|
|
|
if (packToAnimate != null)
|
|
{
|
|
packToAnimate.gameObject.SetActive(false);
|
|
}
|
|
|
|
yield break;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the target position for the booster pack animation (scrapbook button or fallback).
|
|
/// </summary>
|
|
private Vector3 GetTargetPosition(GameObject scrapbookButton)
|
|
{
|
|
if (scrapbookButton != null && boosterImages.Length > 0 && boosterImages[0] != null)
|
|
{
|
|
RectTransform scrapbookRect = scrapbookButton.GetComponent<RectTransform>();
|
|
if (scrapbookRect != null)
|
|
{
|
|
// Convert scrapbook button's world position to local position relative to booster's parent
|
|
Canvas canvas = GetComponentInParent<Canvas>();
|
|
if (canvas != null && canvas.renderMode == RenderMode.ScreenSpaceOverlay)
|
|
{
|
|
// For overlay canvas, convert screen position to local position
|
|
Vector2 screenPos = RectTransformUtility.WorldToScreenPoint(null, scrapbookRect.position);
|
|
RectTransformUtility.ScreenPointToLocalPointInRectangle(
|
|
boosterImages[0].parent as RectTransform,
|
|
screenPos,
|
|
null,
|
|
out Vector2 localPoint);
|
|
return localPoint;
|
|
}
|
|
else
|
|
{
|
|
// For world space or camera canvas
|
|
return boosterImages[0].parent.InverseTransformPoint(scrapbookRect.position);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Fallback position
|
|
return GetFallbackPosition();
|
|
}
|
|
|
|
private Vector3 GetFallbackPosition()
|
|
{
|
|
RectTransform canvasRect = GetComponentInParent<Canvas>()?.GetComponent<RectTransform>();
|
|
if (canvasRect != null)
|
|
{
|
|
// Convert bottom-left corner with offset to local position
|
|
Vector2 bottomLeft = new Vector2(-canvasRect.rect.width / 2f, -canvasRect.rect.height / 2f);
|
|
return bottomLeft + targetBottomLeftOffset;
|
|
}
|
|
else
|
|
{
|
|
// Ultimate fallback if no canvas found
|
|
if (boosterImages.Length > 0 && _boosterInitialPositions != null && _boosterInitialPositions.Length > 0)
|
|
{
|
|
return _boosterInitialPositions[0] + new Vector3(-500f, -500f, 0f);
|
|
}
|
|
return new Vector3(-500f, -500f, 0f);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|